[libc++] Do not require movability in __non_propagating_cache::__emplace_deref

[ldionne]

Summary

As explained in http://eel.is/c++draft/range.nonprop.cache#note-1, we
should allow copy and move elision to happen when calling emplace_deref
in non-propagating-cache. Before this change, the only way to emplace
into the non-propagating-cache was to call __set(*it), which materialized
*it when binding it to the reference argument of __set and disabled
move elision.

As a fly-by change, this also renames __set to __emplace for consistency
and adds tests for it.

[• Quuxplusone]

libcxx/include/__ranges/non_propagating_cache.h

46–49

This overload set has the distinct smell of "greedy perfect-forwarding overload eats things you wouldn't expect." You use it below like this:

constexpr _Tp& __emplace_deref(_Iter const& __iter) {
  return __value_.emplace(__deref_tag{}, __iter).__t_;
}

which I think is fine; but if you (or future-you) changes it to

constexpr _Tp& __emplace_deref(_Iter __iter) {
  return __value_.emplace(__deref_tag{}, __iter).__t_;
}

then suddenly it'll pick the wrong overload. Right?
I'm not 100% sure this is worth fixing, but if it is, then I think I'd fix it by adding a second tag type, say struct __no_deref_tag { }, and making the constructor on line 47 take __wrapper(__no_deref_tag, _Args&&...).

86–89

Any appetite for making these named members (e.g. npc.__value())?
Besides my usual advice that operators can be harder to read and/or go-to-definition of, it also just occurred to me that operators are subject to ADL but member functions are not:
https://godbolt.org/z/EsasGzoad
(I don't think the Standard cares about ADL in this instance; but any time I see a chance to ADL-proof something... ;))

libcxx/test/libcxx/ranges/range.nonprop.cache/emplace.pass.cpp

26

friend constexpr https://quuxplusone.github.io/blog/2021/04/03/static-constexpr-whittling-knife/
and consider line-breaking somewhere.

High-level comment: I'm not sure what benefit you get from the templated operator== or the use of tuple. If you just want something with a couple of weird constructors, why not string?

using Cache = std::ranges::__non_propagating_cache<std::string>;
Cache cache;
std::string& result = cache.__emplace();
assert(&result == &cache.__value() && result == "");

Cache cache;
std::string& result = cache.__emplace("foobar");
assert(&result == &cache.__value() && result == "foobar");

Cache cache;
std::string& result = cache.__emplace("foobar", 3);
assert(&result == &cache.__value() && result == "foo");

In this PR, though, it seems more important to test that it's legal to __emplace a NonMovable, similar to what you did below in the __emplace_deref test.

libcxx/test/libcxx/ranges/range.nonprop.cache/emplace_deref.pass.cpp

74–82 ↗

(On Diff #365851)

(This test LGTM.)

libcxx/test/libcxx/ranges/range.nonprop.cache/has_value.pass.cpp

31

I believe you could delete the characters T{} here, if you wanted.

[miscco]

libcxx/include/__ranges/drop_view.h

80

My

libcxx/include/__ranges/non_propagating_cache.h

45

I would not go that route.

There are more places where you would want to reuse __non_propagating_cache, e.g. with views::split you want to cache the call to search(__view.begin(), __pattern). That would not be possible to achieve when hard coding the wrapper in __non_propagating_cache

It is much easier to pull that wrapper as an implementation detail into views::join and let __non_propagating_cache be a generic utility

See (https://github.com/microsoft/STL/blob/a9321cfe53ea31a7e197d5d8336167d6ca3de8b6/stl/inc/ranges#L2962-L2975)

libcxx/test/libcxx/ranges/range.nonprop.cache/emplace_deref.pass.cpp

75 ↗

(On Diff #365851)

Essentially that type will never be copied either so maybe also try an immovable type?

[• Quuxplusone]

libcxx/include/__ranges/non_propagating_cache.h

45

I see a non-propagating-cache in lazy_split_view
http://eel.is/c++draft/range.adaptors#range.lazy.split.outer-1
but it's initialized only with the result of ranges::find, which is an iterator, right? I don't see anywhere where we'd need to cache the result of ranges::search.
I don't see a non-propagating-cache actually specified for split_view, although the English wording does talk about "caches the result [of begin()]" in http://eel.is/c++draft/range.adaptors#range.split.view-4

However, if we anticipate needing to emplace more things than just *it, then it would be reasonable IMO to augment or replace this __emplace_deref(It) with a more general __emplace_from(F) that takes an arbitrary prvalue-producing lambda. (What I've called the "super constructing super elider.")

94–98

FYI: With a super-eliding __emplace_from, this would turn into

template<class _Fn>
_LIBCPP_HIDE_FROM_ABI
constexpr _Tp& __emplace_from(_Fn __iter) {
  return __value_.emplace(__from_tag{}, _Fn).__t_;
}

template<class _Iter>
_LIBCPP_HIDE_FROM_ABI
constexpr _Tp& __emplace_deref(_Iter const& __iter) {
  return __emplace_from([&]() -> decltype(auto) { return *__iter; });
}

[miscco]

libcxx/include/__ranges/non_propagating_cache.h

45

You are missing the new and shiny split_view In begin we call find-next `http://eel.is/c++draft/range.split.view#3 with the explicit remark that we need to cache it http://eel.is/c++draft/range.split.view#4

find-next returns a subrange<It>

[ldionne]

Address review comments

libcxx/include/__ranges/drop_view.h

80

Did you leave this comment by mistake?

libcxx/include/__ranges/non_propagating_cache.h

45

Hmm, I quite like Arthur's idea with a general __emplace_from. It will allow us to easily elide from arbitrary expressions.

86–89

Any appetite for making these named members (e.g. npc.__value())?

Not really, I think operator* is pretty idiomatic and I see no strong enough reason to change.

libcxx/test/libcxx/ranges/range.nonprop.cache/emplace.pass.cpp

26

friend constexpr https://quuxplusone.github.io/blog/2021/04/03/static-constexpr-whittling-knife/ and consider line-breaking somewhere.

Done.

High-level comment: I'm not sure what benefit you get from the templated operator== or the use of tuple.

I just want to use any type where I can pass heterogeneous arguments through to the constructor.

In this PR, though, it seems more important to test that it's legal to __emplace a NonMovable, similar to what you did below in the __emplace_deref test.

It's not valid to do that, though, cause there is no way to perform move elision in that case AFAICT.

libcxx/test/libcxx/ranges/range.nonprop.cache/emplace_deref.pass.cpp

75 ↗

(On Diff #365851)

This should really say "Move elision should be performed instead", since that's what is happening. I fixed the comment. The type I'm using (NonMovable) *is* immovable. Are you requesting something else that I'm missing?

[• Quuxplusone]

libcxx/test/libcxx/ranges/range.nonprop.cache/emplace.pass.cpp

26

In this PR, though, it seems more important to test that it's legal to __emplace a NonMovable

std::ranges::__non_propagating_cache<NonMovable> cache;
NonMovable& result = cache.__emplace();
assert(&result == &*cache);

[ldionne]

Add test requested by Arthur.

libcxx/test/libcxx/ranges/range.nonprop.cache/emplace.pass.cpp

26

Ah, I see what you meant now. Done.

[• Quuxplusone]

Unlikely to be any more substantial comments from me.

libcxx/include/__ranges/non_propagating_cache.h

103

FWIW, this could be

return __value_.emplace(__from_tag{}, [&]() { return _Tp(_VSTD::forward<_Args>(__args)...); }).__t_;

and then eliminate __forward_tag. No strong preference.

[ldionne]

libcxx/include/__ranges/non_propagating_cache.h

103

Will keep as-is, I like to avoid creating a potentially large number of captures in the lambda here (even if those are by ref).

libcxx/include/__ranges/drop_view.h

constexpr auto begin()
                   random_access_range<const _View> && sized_range<const _View>))
     {
       if constexpr (_UseCache)
         if (__cached_begin_.__has_value())
           return *__cached_begin_;
 
       auto __tmp = ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
       if constexpr (_UseCache)
-        __cached_begin_.__set(__tmp);
+        __cached_begin_.__emplace(__tmp);
       return __tmp;
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto begin() const
       requires random_access_range<const _View> && sized_range<const _View>
     {
       return ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));

libcxx/include/__ranges/join_view.h

private:
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr void __satisfy() {
       for (; __outer_ != ranges::end(__parent_->__base_); ++__outer_) {
         auto&& __inner = [&]() -> auto&& {
           if constexpr (__ref_is_glvalue)
             return *__outer_;
           else
-            return __parent_->__cache_.__emplace_deref(__outer_);
+            return __parent_->__cache_.__emplace_from([&]() -> decltype(auto) { return *__outer_; });
         }();
         __inner_ = ranges::begin(__inner);
         if (*__inner_ != ranges::end(__inner))
           return;
       }
 
       if constexpr (__ref_is_glvalue)
         __inner_.reset();

libcxx/include/__ranges/non_propagating_cache.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_NON_PROPAGATING_CACHE_H
 #define _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H
 
 #include <__config>
 #include <__iterator/concepts.h>        // indirectly_readable
 #include <__iterator/iterator_traits.h> // iter_reference_t
 #include <__memory/addressof.h>
+#include <__utility/forward.h>
 #include <concepts>                     // constructible_from
 #include <optional>
 #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
 
-// clang-format off
-
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
   // __non_propagating_cache is a helper type that allows storing an optional value in it,
   // but which does not copy the source's value when it is copy constructed/assigned to,
   // and which resets the source's value when it is moved-from.
   //
   // This type is used as an implementation detail of some views that need to cache the
   // result of `begin()` in order to provide an amortized O(1) begin() method. Typically,
   // we don't want to propagate the value of the cache upon copy because the cached iterator
   // may refer to internal details of the source view.
   template<class _Tp>
     requires is_object_v<_Tp>
   class _LIBCPP_TEMPLATE_VIS __non_propagating_cache {
-    optional<_Tp> __value_ = nullopt;
+    struct __from_tag { };
+    struct __forward_tag { };
+
+    // This helper class is needed to perform copy and move elision when
+    // constructing the contained type from an iterator.
+    struct __wrapper {
+      template<class ..._Args>
+      constexpr explicit __wrapper(__forward_tag, _Args&& ...__args) : __t_(_VSTD::forward<_Args>(__args)...) { }
+      template<class _Fn>
+      constexpr explicit __wrapper(__from_tag, _Fn const& __f) : __t_(__f()) { }
+      _Tp __t_;
+    };
+
+    optional<__wrapper> __value_ = nullopt;
 
   public:
     _LIBCPP_HIDE_FROM_ABI __non_propagating_cache() = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __non_propagating_cache(__non_propagating_cache const&) noexcept
       : __value_(nullopt)
     { }
public:
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __non_propagating_cache& operator=(__non_propagating_cache&& __other) noexcept {
       __value_.reset();
       __other.__value_.reset();
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp& operator*() { return *__value_; }
+    constexpr _Tp& operator*() { return __value_->__t_; }
     _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp const& operator*() const { return *__value_; }
+    constexpr _Tp const& operator*() const { return __value_->__t_; }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr bool __has_value() const { return __value_.has_value(); }
+
+    template<class _Fn>
     _LIBCPP_HIDE_FROM_ABI
-    constexpr void __set(_Tp const& __value) { __value_.emplace(__value); }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void __set(_Tp&& __value) { __value_.emplace(_VSTD::move(__value)); }
+    constexpr _Tp& __emplace_from(_Fn const& __f) {
+      return __value_.emplace(__from_tag{}, __f).__t_;
+    }
 
-    template<class _Other>
+    template<class ..._Args>
     _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp& __emplace_deref(const _Other& __value) {
-      __value_.reset();
-      __value_.emplace(*__value);
-      return *__value_;
+    constexpr _Tp& __emplace(_Args&& ...__args) {
+      return __value_.emplace(__forward_tag{}, _VSTD::forward<_Args>(__args)...).__t_;
     }
   };
 
   struct __empty_cache { };
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
-_LIBCPP_POP_MACROS
-
 #endif // _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H

libcxx/include/__ranges/reverse_view.h

public:
     _LIBCPP_HIDE_FROM_ABI
     constexpr reverse_iterator<iterator_t<_View>> begin() {
       if constexpr (_UseCache)
         if (__cached_begin_.__has_value())
           return *__cached_begin_;
 
       auto __tmp = _VSTD::make_reverse_iterator(ranges::next(ranges::begin(__base_), ranges::end(__base_)));
       if constexpr (_UseCache)
-        __cached_begin_.__set(__tmp);
+        __cached_begin_.__emplace(__tmp);
       return __tmp;
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr reverse_iterator<iterator_t<_View>> begin() requires common_range<_View> {
       return _VSTD::make_reverse_iterator(ranges::end(__base_));
     }
 

libcxx/test/libcxx/ranges/range.nonprop.cache/assign.copy.pass.cpp

 
 template <class T>
 constexpr void test() {
   using Cache = std::ranges::__non_propagating_cache<T>;
   static_assert(std::is_nothrow_copy_assignable_v<Cache>);
 
   // Assign to an empty cache
   {
-    Cache a; a.__set(T{3});
+    Cache a; a.__emplace(3);
     Cache b;
 
     Cache& result = (b = a);
     assert(&result == &b);
     assert(!b.__has_value()); // make sure we don't propagate
 
     assert(a.__has_value()); // make sure we don't "steal" from the source
     assert(*a == T{3});      //
   }
 
   // Assign to a non-empty cache
   {
-    Cache a; a.__set(T{3});
-    Cache b; b.__set(T{5});
+    Cache a; a.__emplace(3);
+    Cache b; b.__emplace(5);
 
     Cache& result = (b = a);
     assert(&result == &b);
     assert(!b.__has_value()); // make sure we don't propagate
 
     assert(a.__has_value()); // make sure we don't "steal" from the source
     assert(*a == T{3});      //
   }
 
   // Self-assignment should not do anything (case with empty cache)
   {
     Cache b;
     Cache& result = (b = b);
     assert(&result == &b);
     assert(!b.__has_value());
   }
 
   // Self-assignment should not do anything (case with non-empty cache)
   {
-    Cache b; b.__set(T{5});
+    Cache b; b.__emplace(5);
     Cache& result = (b = b);
     assert(&result == &b);
     assert(b.__has_value());
     assert(*b == T{5});
   }
 }
 
 constexpr bool tests() {

libcxx/test/libcxx/ranges/range.nonprop.cache/assign.move.pass.cpp

 
 template <class T>
 constexpr void test() {
   using Cache = std::ranges::__non_propagating_cache<T>;
   static_assert(std::is_nothrow_move_assignable_v<Cache>);
 
   // Assign to an empty cache
   {
-    Cache a; a.__set(T{3});
+    Cache a; a.__emplace(3);
     Cache b;
 
     Cache& result = (b = std::move(a));
     assert(&result == &b);
     assert(!b.__has_value()); // make sure we don't propagate
     assert(!a.__has_value()); // make sure we disengage the source
   }
 
   // Assign to a non-empty cache
   {
-    Cache a; a.__set(T{3});
-    Cache b; b.__set(T{5});
+    Cache a; a.__emplace(3);
+    Cache b; b.__emplace(5);
 
     Cache& result = (b = std::move(a));
     assert(&result == &b);
     assert(!b.__has_value()); // make sure we don't propagate
     assert(!a.__has_value()); // make sure we disengage the source
   }
 
   // Self-assignment should clear the cache (case with empty cache)
   {
     Cache b;
 
     Cache& result = (b = std::move(b));
     assert(&result == &b);
     assert(!b.__has_value());
   }
 
   // Self-assignment should clear the cache (case with non-empty cache)
   {
-    Cache b; b.__set(T{5});
+    Cache b; b.__emplace(5);
 
     Cache& result = (b = std::move(b));
     assert(&result == &b);
     assert(!b.__has_value());
   }
 }
 
 constexpr bool tests() {

libcxx/test/libcxx/ranges/range.nonprop.cache/ctor.copy.pass.cpp

struct NotCopyConstructible {
   constexpr bool operator==(NotCopyConstructible const& other) const { return x == other.x; }
 };
 
 template <class T>
 constexpr void test() {
   using Cache = std::ranges::__non_propagating_cache<T>;
   static_assert(std::is_nothrow_copy_constructible_v<Cache>);
   Cache a;
-  a.__set(T{3});
+  a.__emplace(3);
 
   // Test with direct initialization
   {
     Cache b(a);
     assert(!b.__has_value()); // make sure we don't propagate
 
     assert(a.__has_value()); // make sure we don't "steal" from the source
     assert(*a == T{3});      //

libcxx/test/libcxx/ranges/range.nonprop.cache/ctor.move.pass.cpp

 template <class T>
 constexpr void test() {
   using Cache = std::ranges::__non_propagating_cache<T>;
   static_assert(std::is_nothrow_move_constructible_v<Cache>);
 
   // Test with direct initialization
   {
     Cache a;
-    a.__set(T{3});
+    a.__emplace(3);
 
     Cache b(std::move(a));
     assert(!b.__has_value()); // make sure we don't propagate
     assert(!a.__has_value()); // make sure we disengage the source
   }
 
   // Test with copy initialization
   {
     Cache a;
-    a.__set(T{3});
+    a.__emplace(3);
 
     Cache b = std::move(a);
     assert(!b.__has_value()); // make sure we don't propagate
     assert(!a.__has_value()); // make sure we disengage the source
   }
 }
 
 constexpr bool tests() {

libcxx/test/libcxx/ranges/range.nonprop.cache/deref.pass.cpp

 #include <cassert>
 
 template <class T>
 constexpr void test() {
   using Cache = std::ranges::__non_propagating_cache<T>;
 
   // non-const version
   {
-    Cache cache; cache.__set(T{3});
+    Cache cache; cache.__emplace(3);
     T& result = *cache;
     assert(result == T{3});
   }
 
   // const version
   {
-    Cache cache; cache.__set(T{3});
+    Cache cache; cache.__emplace(3);
     T const& result = *static_cast<Cache const&>(cache);
     assert(result == T{3});
   }
 }
 
 struct T {
   int x;
   constexpr explicit T(int i) : x(i) { }

libcxx/test/libcxx/ranges/range.nonprop.cache/emplace.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: libcpp-has-no-incomplete-ranges
+
+// template<class ...Args>
+// constexpr T& __emplace(Args&& ...);
+
+#include <ranges>
+
+#include <cassert>
+#include <tuple>
+
+template<int I>
+struct X {
+  int value = -1;
+  template<int J>
+  friend constexpr bool operator==(X const& a, X<J> const& b) { return I == J && a.value == b.value; }
+};
+
+constexpr bool test() {
+  {
+    using T = std::tuple<>;
+    using Cache = std::ranges::__non_propagating_cache<T>;
+    Cache cache;
+    T& result = cache.__emplace();
+    assert(&result == &*cache);
+    assert(result == T());
+  }
+
+  {
+    using T = std::tuple<X<0>>;
+    using Cache = std::ranges::__non_propagating_cache<T>;
+    Cache cache;
+    T& result = cache.__emplace();
+    assert(&result == &*cache);
+    assert(result == T());
+  }
+  {
+    using T = std::tuple<X<0>>;
+    using Cache = std::ranges::__non_propagating_cache<T>;
+    Cache cache;
+    T& result = cache.__emplace(X<0>{0});
+    assert(&result == &*cache);
+    assert(result == T(X<0>{0}));
+  }
+
+  {
+    using T = std::tuple<X<0>, X<1>>;
+    using Cache = std::ranges::__non_propagating_cache<T>;
+    Cache cache;
+    T& result = cache.__emplace();
+    assert(&result == &*cache);
+    assert(result == T());
+  }
+  {
+    using T = std::tuple<X<0>, X<1>>;
+    using Cache = std::ranges::__non_propagating_cache<T>;
+    Cache cache;
+    T& result = cache.__emplace(X<0>{0}, X<1>{1});
+    assert(&result == &*cache);
+    assert(result == T(X<0>{0}, X<1>{1}));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(test());
+  test();
+  return 0;
+}

libcxx/test/libcxx/ranges/range.nonprop.cache/emplace_from.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: libcpp-has-no-incomplete-ranges
+
+// template<class Fn>
+// constexpr T& __emplace_from(Fn const&);
+
+#include <ranges>
+
+#include <cassert>
+#include <tuple>
+
+template<int I>
+struct X {
+  int value = -1;
+  template<int J>
+  friend constexpr bool operator==(X const& a, X<J> const& b) { return I == J && a.value == b.value; }
+};
+
+struct NonMovable {
+  int value;
+  constexpr explicit NonMovable(int v) : value(v) { }
+  NonMovable(NonMovable&&) = delete;
+};
+
+constexpr bool test() {
+  {
+    using T = std::tuple<>;
+    using Cache = std::ranges::__non_propagating_cache<T>;
+    Cache cache;
+    T& result = cache.__emplace_from([] { return T(); });
+    assert(&result == &*cache);
+    assert(result == T());
+  }
+  {
+    using T = std::tuple<X<0>>;
+    using Cache = std::ranges::__non_propagating_cache<T>;
+    Cache cache;
+    T& result = cache.__emplace_from([] { return T(X<0>{0}); });
+    assert(&result == &*cache);
+    assert(result == T(X<0>{0}));
+  }
+  {
+    using T = std::tuple<X<0>, X<1>>;
+    using Cache = std::ranges::__non_propagating_cache<T>;
+    Cache cache;
+    T& result = cache.__emplace_from([] { return T(X<0>{0}, X<1>{1}); });
+    assert(&result == &*cache);
+    assert(result == T(X<0>{0}, X<1>{1}));
+  }
+
+  // Make sure that we do not require the type to be movable when we emplace it.
+  // Move elision should be performed instead, see http://eel.is/c++draft/range.nonprop.cache#note-1.
+  {
+    using Cache = std::ranges::__non_propagating_cache<NonMovable>;
+    Cache cache;
+    NonMovable& result = cache.__emplace_from([] { return NonMovable(3); });
+    assert(&result == &*cache);
+    assert(result.value == 3);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(test());
+  test();
+  return 0;
+}

libcxx/test/libcxx/ranges/range.nonprop.cache/has_value.pass.cpp

constexpr void test() {
   // __has_value on an empty cache
   {
     Cache const cache;
     assert(!cache.__has_value());
   }
 
   // __has_value on a non-empty cache
   {
-    Cache cache; cache.__set(T{});
+    Cache cache; cache.__emplace();
     assert(cache.__has_value());
   }
 }
 
 struct T { };
 
 constexpr bool tests() {
   test<T>();