[libc++] Canonicalize the ranges results and their tests

[philnik]

• Try to fix GCC

[philnik]

• Fix CI

[Mordante]

This patch has several conflicts with D121528, please rebase it.
(I haven't looked to closely at the changes yet.)

[var-const]

libcxx/include/__algorithm/in_fun_result.h

23

I think this should be #if _LIBCPP_STD_VER > 17 instead.

libcxx/test/std/algorithms/algorithms.results/in_in_result.pass.cpp

9–11

I think no-concepts is no longer necessary.

10

Similar to the other patch, I'm concerned there appears to be a discrepancy between the guard used in the headers and the one used in the tests.

libcxx/test/std/algorithms/algorithms.results/no_unique_address.compile.pass.cpp

59

Question: why is it not possible to use _LIBCPP_NO_UNIQUE_ADDRESS?

65

Can you add a comment to explain why min_max_result has a significantly different test (I presume because it's the only class where both member variables have the same type)?

[philnik]

• Rebased
• Address comments

Thanks for the review @var-const! I'll update D121436 once this PR is landed. Then it should be a simple matter of applying the changes from this patch.

libcxx/test/std/algorithms/algorithms.results/no_unique_address.compile.pass.cpp

59

It's possible, but I think @Mordante wouldn't be very happy about it. In general we want to avoid using the libc++ macros in the test suite, and using the two attributes is completely portable (other than having warnings).

[var-const]

libcxx/test/std/algorithms/algorithms.results/in_out_result.pass.cpp

40

Question: is it okay to remove the tests for rvalue references?

88

I presume you find this test overkill, but just want to make sure.

libcxx/test/std/algorithms/algorithms.results/no_unique_address.compile.pass.cpp

59

Can you add a brief comment explaining that using _LIBCPP_NO_UNIQUE_ADDRESS is undesirable here because of <...> so that no one gets the urge to refactor this in the future?

[Mordante]

libcxx/test/std/algorithms/algorithms.results/no_unique_address.compile.pass.cpp

59

I indeed dislike _LIBCPP_NO_UNIQUE_ADDRESS in the tests. Our tests in std should (in theory) work with all Standard library implementations. Using _LIBCPP specific macros make these tests less portable. I know MSVC STL uses our tests, so it's not a purely hypothetical. However I think it makes sense to make a specific test macro for this case, for example TEST_UNIQUE_ADDRESS That macro can then hide we need different attributes for MSVC and Clang. Something along the lines

#if TEST_STD_VER >= 17
# if defined(_WIN32) // This might require tuning, not sure what Clang on Windows does.
#   define TEST_UNIQUE_ADDRESS [[msvc::no_unique_address]]
# else
#   define TEST_UNIQUE_ADDRESS [[no_unique_address]]
# endif
#else
# define TEST_UNIQUE_ADDRESS
#endif

[philnik]

• Address comments

libcxx/test/std/algorithms/algorithms.results/in_out_result.pass.cpp

40

What do you mean? They are in lines 43 and 44. Or am I missing something?

88

Yes, I don't really see what it would catch. If you want to keep it I can add it to the other tests too.

[Mordante]

Nice cleanup! LGTM after improving the commit message. Since @var-const had some remarks I leave the final approval to him.

libcxx/include/__algorithm/in_in_out_result.h

23

I'm not entirely up-to-date to what we do and don't enable from ranges. So I assume this is intentionally, but please add it to the commit message.

[ldionne]

There's a couple of things I don't understand with this patch. Why do we remove #ifndef _LIBCPP_HAS_NO_INCOMPLETE_RANGES? I think a description of what this commit does would be useful, since it looks like there might have been some discussion leading to this patch that I missed.

[ldionne]

LGTM with CI passing and with all the result types being disabled when HAS_NO_INCOMPLTE_RANGES. You'll also need to add UNSUPPORTED: libcpp-has-no-incomplete-ranges to some tests.

libcxx/include/__algorithm/in_found_result.h

21 ↗

(On Diff #418438)

Would it be possible to instead mark *all* the result types with HAS_NO_INCOMPLETE_RANGES?

[philnik]

• Address comments

[philnik]

• Guard ranges::mismatch and ranges::swap_ranges

[var-const]

libcxx/include/__algorithm/in_out_result.h

27

IIRC, we ended up settling on something like _InIter/_OutIter, right?

[philnik]

libcxx/include/__algorithm/in_out_result.h

27

Yes, I'll make a follow-up to rename all the results-type template arguments and the already-shipped aliases. I think it's easier to make it consistent first and then rename them all together in an NFC.

[var-const]

libcxx/include/__algorithm/in_out_result.h

27

SGTM.

libcxx/include/__algorithm/in_fun_result.h

 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER > 17
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 namespace ranges {
 template <class _Ip, class _Fp>
 struct in_fun_result {
   _LIBCPP_NO_UNIQUE_ADDRESS _Ip in;
   _LIBCPP_NO_UNIQUE_ADDRESS _Fp fun;
 
   template <class _I2, class _F2>
     requires convertible_to<const _Ip&, _I2> && convertible_to<const _Fp&, _F2>
   _LIBCPP_HIDE_FROM_ABI constexpr operator in_fun_result<_I2, _F2>() const & {
     return {in, fun};
   }
 
   template <class _I2, class _F2>
     requires convertible_to<_Ip, _I2> && convertible_to<_Fp, _F2>
   _LIBCPP_HIDE_FROM_ABI constexpr operator in_fun_result<_I2, _F2>() && {
     return {std::move(in), std::move(fun)};
   }
 };
 } // namespace ranges
 
-#endif // _LIBCPP_STD_VER > 17
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_IN_FUN_RESULT_H

libcxx/include/__algorithm/in_in_out_result.h

 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 namespace ranges {
 
 template <class _I1, class _I2, class _O1>
 struct in_in_out_result {
   _LIBCPP_NO_UNIQUE_ADDRESS _I1 in1;
   _LIBCPP_NO_UNIQUE_ADDRESS _I2 in2;
   _LIBCPP_NO_UNIQUE_ADDRESS _O1 out;
 
   template <class _II1, class _II2, class _OO1>
     requires convertible_to<const _I1&, _II1> && convertible_to<const _I2&, _II2> && convertible_to<const _O1&, _OO1>
   _LIBCPP_HIDE_FROM_ABI constexpr
   operator in_in_out_result<_II1, _II2, _OO1>() const& {
     return {in1, in2, out};
   }
 
   template <class _II1, class _II2, class _OO1>
     requires convertible_to<_I1, _II1> && convertible_to<_I2, _II2> && convertible_to<_O1, _OO1>
   _LIBCPP_HIDE_FROM_ABI constexpr
   operator in_in_out_result<_II1, _II2, _OO1>() && {
-    return {_VSTD::move(in1), _VSTD::move(in2), _VSTD::move(out)};
+    return {std::move(in1), std::move(in2), std::move(out)};
   }
 };
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_IN_IN_OUT_RESULT_H

libcxx/include/__algorithm/in_in_result.h

 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER > 17
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 namespace ranges {
 
 template <class _I1, class _I2>
 struct in_in_result {
   _LIBCPP_NO_UNIQUE_ADDRESS _I1 in1;
   _LIBCPP_NO_UNIQUE_ADDRESS _I2 in2;
 
   template <class _II1, class _II2>
     requires convertible_to<const _I1&, _II1> && convertible_to<const _I2&, _II2>
    _LIBCPP_HIDE_FROM_ABI constexpr
    operator in_in_result<_II1, _II2>() const & {
     return {in1, in2};
   }
 
   template <class _II1, class _II2>
     requires convertible_to<_I1, _II1> && convertible_to<_I2, _II2>
   _LIBCPP_HIDE_FROM_ABI constexpr
-  operator in_in_result<_II1, _II2>() && { return {_VSTD::move(in1), _VSTD::move(in2)}; }
+  operator in_in_result<_II1, _II2>() && {
+    return {std::move(in1), std::move(in2)};
+  }
 };
 
 } // namespace ranges
 
-#endif // _LIBCPP_STD_VER > 17
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_IN_IN_RESULT_H

libcxx/include/__algorithm/in_out_out_result.h

 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER > 17
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 namespace ranges {
 template <class _I1, class _O1, class _O2>
 struct in_out_out_result {
   _LIBCPP_NO_UNIQUE_ADDRESS _I1 in;
   _LIBCPP_NO_UNIQUE_ADDRESS _O1 out1;
   _LIBCPP_NO_UNIQUE_ADDRESS _O2 out2;
 
   template <class _II1, class _OO1, class _OO2>
     requires convertible_to<const _I1&, _II1> && convertible_to<const _O1&, _OO1> && convertible_to<const _O2&, _OO2>
   _LIBCPP_HIDE_FROM_ABI constexpr
   operator in_out_out_result<_II1, _OO1, _OO2>() const& {
     return {in, out1, out2};
   }
 
   template <class _II1, class _OO1, class _OO2>
     requires convertible_to<_I1, _II1> && convertible_to<_O1, _OO1> && convertible_to<_O2, _OO2>
   _LIBCPP_HIDE_FROM_ABI constexpr
   operator in_out_out_result<_II1, _OO1, _OO2>() && {
-    return {_VSTD::move(in), _VSTD::move(out1), _VSTD::move(out2)};
+    return {std::move(in), std::move(out1), std::move(out2)};
   }
 };
 } // namespace ranges
 
-#endif // _LIBCPP_STD_VER > 17
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_IN_OUT_OUT_RESULT_H

libcxx/include/__algorithm/in_out_result.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 namespace ranges {
 
-template<class _InputIterator, class _OutputIterator>
+template<class _I1, class _O1>
 struct in_out_result {
-  _LIBCPP_NO_UNIQUE_ADDRESS _InputIterator in;
-  _LIBCPP_NO_UNIQUE_ADDRESS _OutputIterator out;
+  _LIBCPP_NO_UNIQUE_ADDRESS _I1 in;
+  _LIBCPP_NO_UNIQUE_ADDRESS _O1 out;
 
-  template <class _InputIterator2, class _OutputIterator2>
-    requires convertible_to<const _InputIterator&, _InputIterator2> && convertible_to<const _OutputIterator&,
-                           _OutputIterator2>
+  template <class _I2, class _O2>
+    requires convertible_to<const _I1&, _I2> && convertible_to<const _O1&, _O2>
   _LIBCPP_HIDE_FROM_ABI
-  constexpr operator in_out_result<_InputIterator2, _OutputIterator2>() const & {
+  constexpr operator in_out_result<_I2, _O2>() const & {
     return {in, out};
   }
 
-  template <class _InputIterator2, class _OutputIterator2>
-    requires convertible_to<_InputIterator, _InputIterator2> && convertible_to<_OutputIterator, _OutputIterator2>
+  template <class _I2, class _O2>
+    requires convertible_to<_I1, _I2> && convertible_to<_O1, _O2>
   _LIBCPP_HIDE_FROM_ABI
-  constexpr operator in_out_result<_InputIterator2, _OutputIterator2>() && {
-    return {_VSTD::move(in), _VSTD::move(out)};
+  constexpr operator in_out_result<_I2, _O2>() && {
+    return {std::move(in), std::move(out)};
   }
 };
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_IN_OUT_RESULT_H

libcxx/include/__algorithm/min_max_result.h

 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#endif
+#endif // _LIBCPP___ALGORITHM_MIN_MAX_RESULT_H

libcxx/include/__algorithm/ranges_mismatch.h

 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER > 17
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 namespace ranges {
 
 template <class _I1, class _I2>
 using mismatch_result = in_in_result<_I1, _I2>;
 
 namespace __mismatch {
 struct __fn {

 };
 } // namespace __mismatch
 
 inline namespace __cpo {
   constexpr inline auto mismatch = __mismatch::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
-#endif // _LIBCPP_STD_VER > 17
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_RANGES_MISMATCH_H

libcxx/include/__algorithm/ranges_swap_ranges.h

 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#if _LIBCPP_STD_VER > 17
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
 template <class _I1, class _I2>
 using swap_ranges_result = in_in_result<_I1, _I2>;
 

 
 inline namespace __cpo {
   inline constexpr auto swap_ranges = __swap_ranges::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_STD_VER > 17
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 #endif // _LIBCPP___ALGORITHM_RANGES_SWAP_RANGES_H

libcxx/test/std/algorithms/algorithms.results/in_found_result.pass.cpp

 // struct in_found_result;
 
 #include <algorithm>
 #include <cassert>
 #include <type_traits>
 
 #include "MoveOnly.h"
 
-template <class T>
-struct ConvertibleFrom {
-  constexpr ConvertibleFrom(T c) : content{c} {}
-  T content;
-};
-
 struct A {
   explicit A(int);
 };
+// no implicit conversion
 static_assert(!std::is_constructible_v<std::ranges::in_found_result<A>, std::ranges::in_found_result<int>>);
 
 struct B {
   B(const int&);
   B(int&&);
 };
+// implicit conversion
 static_assert(std::is_constructible_v<std::ranges::in_found_result<B>, std::ranges::in_found_result<int>>);
 static_assert(std::is_constructible_v<std::ranges::in_found_result<B>, std::ranges::in_found_result<int>&>);
 static_assert(std::is_constructible_v<std::ranges::in_found_result<B>, const std::ranges::in_found_result<int>>);
 static_assert(std::is_constructible_v<std::ranges::in_found_result<B>, const std::ranges::in_found_result<int>&>);
 
 struct C {
   C(int&);
 };
 static_assert(!std::is_constructible_v<std::ranges::in_found_result<C>, std::ranges::in_found_result<int>&>);
 
+// has to be convertible via const&
 static_assert(std::is_convertible_v<std::ranges::in_found_result<int>&, std::ranges::in_found_result<long>>);
 static_assert(std::is_convertible_v<const std::ranges::in_found_result<int>&, std::ranges::in_found_result<long>>);
 static_assert(std::is_convertible_v<std::ranges::in_found_result<int>&&, std::ranges::in_found_result<long>>);
 static_assert(std::is_convertible_v<const std::ranges::in_found_result<int>&&, std::ranges::in_found_result<long>>);
 
+// should be move constructible
+static_assert(std::is_move_constructible_v<std::ranges::in_found_result<MoveOnly>>);
+
+// should not be copy constructible
+static_assert(!std::is_copy_constructible_v<std::ranges::in_found_result<MoveOnly>>);
+
 struct NotConvertible {};
+// conversions should not work if there is no conversion
 static_assert(!std::is_convertible_v<std::ranges::in_found_result<NotConvertible>, std::ranges::in_found_result<int>>);
 
 static_assert(std::is_same_v<decltype(std::ranges::in_found_result<int>::in), int>);
 static_assert(std::is_same_v<decltype(std::ranges::in_found_result<int>::found), bool>);
 
+template <class T>
+struct ConvertibleFrom {
+  constexpr ConvertibleFrom(T c) : content{c} {}
+  T content;
+};
+
 constexpr bool test() {
   {
     std::ranges::in_found_result<double> res{10, true};
     assert(res.in == 10);
     assert(res.found == true);
     std::ranges::in_found_result<ConvertibleFrom<int>> res2 = res;
     assert(res2.in.content == 10);
-    assert(res2.found);
+    assert(res2.found == true);
   }
   {
     std::ranges::in_found_result<MoveOnly> res{MoveOnly{}, false};
     assert(res.in.get() == 1);
     assert(!res.found);
     auto res2 = std::move(res);
     assert(res2.in.get() == 1);
     assert(!res2.found);

libcxx/test/std/algorithms/algorithms.results/in_fun_result.pass.cpp

 static_assert(std::is_constructible_v<std::ranges::in_fun_result<B, B>, std::ranges::in_fun_result<int, int>>);
 static_assert(std::is_constructible_v<std::ranges::in_fun_result<B, B>, std::ranges::in_fun_result<int, int>&>);
 static_assert(std::is_constructible_v<std::ranges::in_fun_result<B, B>, const std::ranges::in_fun_result<int, int>>);
 static_assert(std::is_constructible_v<std::ranges::in_fun_result<B, B>, const std::ranges::in_fun_result<int, int>&>);
 
 struct C {
   C(int&);
 };
-// has to be convertible via const&
 static_assert(!std::is_constructible_v<std::ranges::in_fun_result<C, C>, std::ranges::in_fun_result<int, int>&>);
 
+// has to be convertible via const&
 static_assert(std::is_convertible_v<std::ranges::in_fun_result<int, int>&, std::ranges::in_fun_result<long, long>>);
 static_assert(std::is_convertible_v<const std::ranges::in_fun_result<int, int>&, std::ranges::in_fun_result<long, long>>);
 static_assert(std::is_convertible_v<std::ranges::in_fun_result<int, int>&&, std::ranges::in_fun_result<long, long>>);
 static_assert(std::is_convertible_v<const std::ranges::in_fun_result<int, int>&&, std::ranges::in_fun_result<long, long>>);
 
 // should be move constructible
 static_assert(std::is_move_constructible_v<std::ranges::in_fun_result<MoveOnly, int>>);
 static_assert(std::is_move_constructible_v<std::ranges::in_fun_result<int, MoveOnly>>);
 
 // should not copy constructible with move-only type
 static_assert(!std::is_copy_constructible_v<std::ranges::in_fun_result<MoveOnly, int>>);
 static_assert(!std::is_copy_constructible_v<std::ranges::in_fun_result<int, MoveOnly>>);
 
 struct NotConvertible {};
 // conversions should not work if there is no conversion
-static_assert(!std::is_convertible_v<std::ranges::in_fun_result<NotConvertible, int>,
-                                     std::ranges::in_fun_result<int, int>>);
-static_assert(!std::is_convertible_v<std::ranges::in_fun_result<int, NotConvertible>,
-                                     std::ranges::in_fun_result<int, int>>);
+static_assert(!std::is_convertible_v<std::ranges::in_fun_result<NotConvertible, int>, std::ranges::in_fun_result<int, int>>);
+static_assert(!std::is_convertible_v<std::ranges::in_fun_result<int, NotConvertible>, std::ranges::in_fun_result<int, int>>);
 
 template <class T>
 struct ConvertibleFrom {
   constexpr ConvertibleFrom(T c) : content{c} {}
   T content;
 };
 
 constexpr bool test() {

libcxx/test/std/algorithms/algorithms.results/in_in_out_result.pass.cpp

 // struct in_in_out_result;
 
 #include <algorithm>
 #include <cassert>
 #include <type_traits>
 
 #include "MoveOnly.h"
 
-template <class T>
-struct ConvertibleFrom {
-  constexpr ConvertibleFrom(T c) : content{c} {}
-  T content;
-};
-
 struct A {
   explicit A(int);
 };
-// conversion is not implicit
+// no implicit conversion
 static_assert(!std::is_constructible_v<std::ranges::in_in_out_result<A, A, A>,
                                        std::ranges::in_in_out_result<int, int, int>>);
 
 struct B {
   B(int);
 };
+// implicit conversion
 static_assert(std::is_constructible_v<std::ranges::in_in_out_result<B, B, B>, std::ranges::in_in_out_result<int, int, int>>);
 static_assert(std::is_constructible_v<std::ranges::in_in_out_result<B, B, B>, std::ranges::in_in_out_result<int, int, int>&>);
 static_assert(std::is_constructible_v<std::ranges::in_in_out_result<B, B, B>, const std::ranges::in_in_out_result<int, int, int>>);
 static_assert(std::is_constructible_v<std::ranges::in_in_out_result<B, B, B>, const std::ranges::in_in_out_result<int, int, int>&>);
 
 struct C {
   C(int&);
 };
 static_assert(!std::is_constructible_v<std::ranges::in_in_out_result<C, C, C>, std::ranges::in_in_out_result<int, int, int>&>);
 
-static_assert(std::is_convertible_v<std::ranges::in_in_out_result<int, int, int>&,
-                                    std::ranges::in_in_out_result<long, long, long>>);
-static_assert(std::is_convertible_v<const std::ranges::in_in_out_result<int, int, int>&,
-                                    std::ranges::in_in_out_result<long, long, long>>);
-static_assert(std::is_convertible_v<std::ranges::in_in_out_result<int, int, int>&&,
-                                    std::ranges::in_in_out_result<long, long, long>>);
-static_assert(std::is_convertible_v<const std::ranges::in_in_out_result<int, int, int>&&,
-                                    std::ranges::in_in_out_result<long, long, long>>);
-
-struct NotConvertible {};
-static_assert(!std::is_convertible_v<std::ranges::in_in_out_result<NotConvertible, int, int>,
-                                     std::ranges::in_in_out_result<int, int, int>>);
-static_assert(!std::is_convertible_v<std::ranges::in_in_out_result<int, NotConvertible, int>,
-                                     std::ranges::in_in_out_result<int, int, int>>);
-static_assert(!std::is_convertible_v<std::ranges::in_in_out_result<int, int, NotConvertible>,
-                                     std::ranges::in_in_out_result<int, int, int>>);
-
-static_assert(std::is_constructible_v<std::ranges::in_in_out_result<MoveOnly, MoveOnly, MoveOnly>,
-                                      std::ranges::in_in_out_result<int, int, int>&>);
+// has to be convertible via const&
+static_assert(std::is_convertible_v<std::ranges::in_in_out_result<int, int, int>&, std::ranges::in_in_out_result<long, long, long>>);
+static_assert(std::is_convertible_v<const std::ranges::in_in_out_result<int, int, int>&, std::ranges::in_in_out_result<long, long, long>>);
+static_assert(std::is_convertible_v<std::ranges::in_in_out_result<int, int, int>&&, std::ranges::in_in_out_result<long, long, long>>);
+static_assert(std::is_convertible_v<const std::ranges::in_in_out_result<int, int, int>&&, std::ranges::in_in_out_result<long, long, long>>);
 
+// should be move constructible
 static_assert(std::is_move_constructible_v<std::ranges::in_in_out_result<MoveOnly, int, int>>);
 static_assert(std::is_move_constructible_v<std::ranges::in_in_out_result<int, MoveOnly, int>>);
 static_assert(std::is_move_constructible_v<std::ranges::in_in_out_result<int, int, MoveOnly>>);
 
+// should not be copy constructible
 static_assert(!std::is_copy_constructible_v<std::ranges::in_in_out_result<MoveOnly, int, int>>);
 static_assert(!std::is_copy_constructible_v<std::ranges::in_in_out_result<int, MoveOnly, int>>);
 static_assert(!std::is_copy_constructible_v<std::ranges::in_in_out_result<int, int, MoveOnly>>);
 
+struct NotConvertible {};
+// conversions should not work if there is no conversion
+static_assert(!std::is_convertible_v<std::ranges::in_in_out_result<NotConvertible, int, int>, std::ranges::in_in_out_result<int, int, int>>);
+static_assert(!std::is_convertible_v<std::ranges::in_in_out_result<int, NotConvertible, int>, std::ranges::in_in_out_result<int, int, int>>);
+static_assert(!std::is_convertible_v<std::ranges::in_in_out_result<int, int, NotConvertible>, std::ranges::in_in_out_result<int, int, int>>);
+
+template <class T>
+struct ConvertibleFrom {
+  constexpr ConvertibleFrom(T c) : content{c} {}
+  T content;
+};
+
 constexpr bool test() {
   {
     std::ranges::in_in_out_result<int, double, float> res{10, 0., 1.f};
     assert(res.in1 == 10);
     assert(res.in2 == 0.);
     assert(res.out == 1.f);
     std::ranges::in_in_out_result<ConvertibleFrom<int>, ConvertibleFrom<double>, ConvertibleFrom<float>> res2 = res;
     assert(res2.in1.content == 10);

libcxx/test/std/algorithms/algorithms.results/in_in_result.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-has-no-incomplete-ranges
 
 // template <class I1, class I2>
 // struct in_in_result;
 
 #include <algorithm>
 #include <cassert>
 #include <type_traits>
 
 #include "MoveOnly.h"
 
-template <class T>
-struct ConstructibleFrom {
-  constexpr ConstructibleFrom(T c) : content{c} {}
-  T content;
-};
-
 struct A {
   explicit A(int);
 };
-static_assert(!std::is_constructible_v<std::ranges::in_in_result<A, A>,
-                                       std::ranges::in_in_result<int, int>>);
+// no implicit conversion
+static_assert(!std::is_constructible_v<std::ranges::in_in_result<A, A>, std::ranges::in_in_result<int, int>>);
 
 struct B {
-  B(const int&);
-  B(int&&);
+  B(int);
 };
+// implicit conversion
 static_assert(std::is_constructible_v<std::ranges::in_in_result<B, B>, std::ranges::in_in_result<int, int>>);
 static_assert(std::is_constructible_v<std::ranges::in_in_result<B, B>, std::ranges::in_in_result<int, int>&>);
 static_assert(std::is_constructible_v<std::ranges::in_in_result<B, B>, const std::ranges::in_in_result<int, int>>);
 static_assert(std::is_constructible_v<std::ranges::in_in_result<B, B>, const std::ranges::in_in_result<int, int>&>);
 
 struct C {
   C(int&);
 };
 static_assert(!std::is_constructible_v<std::ranges::in_in_result<C, C>, std::ranges::in_in_result<int, int>&>);
 
-static_assert(std::is_convertible_v<         std::ranges::in_in_result<int, int>&, std::ranges::in_in_result<long, long>>);
-static_assert(!std::is_nothrow_convertible_v<std::ranges::in_in_result<int, int>&, std::ranges::in_in_result<long, long>>);
-static_assert(std::is_convertible_v<         const std::ranges::in_in_result<int, int>&, std::ranges::in_in_result<long, long>>);
-static_assert(!std::is_nothrow_convertible_v<const std::ranges::in_in_result<int, int>&, std::ranges::in_in_result<long, long>>);
-static_assert(std::is_convertible_v<         std::ranges::in_in_result<int, int>&&, std::ranges::in_in_result<long, long>>);
-static_assert(!std::is_nothrow_convertible_v<std::ranges::in_in_result<int, int>&&, std::ranges::in_in_result<long, long>>);
-static_assert(std::is_convertible_v<         const std::ranges::in_in_result<int, int>&&, std::ranges::in_in_result<long, long>>);
-static_assert(!std::is_nothrow_convertible_v<const std::ranges::in_in_result<int, int>&&, std::ranges::in_in_result<long, long>>);
+// has to be convertible via const&
+static_assert(std::is_convertible_v<std::ranges::in_in_result<int, int>&, std::ranges::in_in_result<long, long>>);
+static_assert(std::is_convertible_v<const std::ranges::in_in_result<int, int>&, std::ranges::in_in_result<long, long>>);
+static_assert(std::is_convertible_v<std::ranges::in_in_result<int, int>&&, std::ranges::in_in_result<long, long>>);
+static_assert(std::is_convertible_v<const std::ranges::in_in_result<int, int>&&, std::ranges::in_in_result<long, long>>);
+
+// should be move constructible
+static_assert(std::is_move_constructible_v<std::ranges::in_in_result<MoveOnly, int>>);
+static_assert(std::is_move_constructible_v<std::ranges::in_in_result<int, MoveOnly>>);
 
 struct NotConvertible {};
-static_assert(!std::is_convertible_v<std::ranges::in_in_result<NotConvertible, int>,
-                                     std::ranges::in_in_result<int, int>>);
-static_assert(!std::is_convertible_v<std::ranges::in_in_result<int, NotConvertible>,
-                                     std::ranges::in_in_result<int, int>>);
+// conversions should not work if there is no conversion
+static_assert(!std::is_convertible_v<std::ranges::in_in_result<NotConvertible, int>, std::ranges::in_in_result<int, int>>);
+static_assert(!std::is_convertible_v<std::ranges::in_in_result<int, NotConvertible>, std::ranges::in_in_result<int, int>>);
+
+template <class T>
+struct ConstructibleFrom {
+  constexpr ConstructibleFrom(T c) : content{c} {}
+  T content;
+};
 
 constexpr bool test() {
   {
     std::ranges::in_in_result<int, double> res{10L, 0.};
     assert(res.in1 == 10);
     assert(res.in2 == 0.);
     std::ranges::in_in_result<ConstructibleFrom<int>, ConstructibleFrom<double>> res2 = res;
     assert(res2.in1.content == 10);
     assert(res2.in2.content == 0.);
   }
   {
     std::ranges::in_in_result<MoveOnly, int> res{MoveOnly{}, 0};
     assert(res.in1.get() == 1);
     [[maybe_unused]] auto res2 = static_cast<std::ranges::in_in_result<MoveOnly, int>>(std::move(res));
     assert(res.in1.get() == 0);
   }
+  {
     auto [in1, in2] = std::ranges::in_in_result<int, int>{1, 2};
     assert(in1 == 1);
     assert(in2 == 2);
+  }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/algorithms.results/in_out_out_result.pass.cpp

 // struct in_out_out_result;
 
 #include <algorithm>
 #include <cassert>
 #include <type_traits>
 
 #include "MoveOnly.h"
 
-template <class T>
-struct ConvertibleFrom {
-  constexpr ConvertibleFrom(T c) : content{c} {}
-  T content;
-};
-
 struct A {
   explicit A(int);
 };
-// conversion is not implicit
-static_assert(!std::is_constructible_v<std::ranges::in_out_out_result<A, A, A>,
-                                       std::ranges::in_out_out_result<int, int, int>>);
+// no implicit conversion
+static_assert(!std::is_constructible_v<std::ranges::in_out_out_result<A, A, A>, std::ranges::in_out_out_result<int, int, int>>);
 
 struct B {
   B(int);
 };
+// implicit conversion
 static_assert(std::is_constructible_v<std::ranges::in_out_out_result<B, B, B>, std::ranges::in_out_out_result<int, int, int>>);
 static_assert(std::is_constructible_v<std::ranges::in_out_out_result<B, B, B>, std::ranges::in_out_out_result<int, int, int>&>);
 static_assert(std::is_constructible_v<std::ranges::in_out_out_result<B, B, B>, const std::ranges::in_out_out_result<int, int, int>>);
 static_assert(std::is_constructible_v<std::ranges::in_out_out_result<B, B, B>, const std::ranges::in_out_out_result<int, int, int>&>);
 
 struct C {
   C(int&);
 };
 static_assert(!std::is_constructible_v<std::ranges::in_out_out_result<C, C, C>, std::ranges::in_out_out_result<int, int, int>&>);
 
-static_assert(std::is_convertible_v<std::ranges::in_out_out_result<int, int, int>&,
-                                    std::ranges::in_out_out_result<long, long, long>>);
-static_assert(std::is_convertible_v<const std::ranges::in_out_out_result<int, int, int>&,
-                                    std::ranges::in_out_out_result<long, long, long>>);
-static_assert(std::is_convertible_v<std::ranges::in_out_out_result<int, int, int>&&,
-                                    std::ranges::in_out_out_result<long, long, long>>);
-static_assert(std::is_convertible_v<const std::ranges::in_out_out_result<int, int, int>&&,
-                                    std::ranges::in_out_out_result<long, long, long>>);
-
-struct NotConvertible {};
-static_assert(!std::is_convertible_v<std::ranges::in_out_out_result<NotConvertible, int, int>,
-                                     std::ranges::in_out_out_result<int, int, int>>);
-static_assert(!std::is_convertible_v<std::ranges::in_out_out_result<int, NotConvertible, int>,
-                                     std::ranges::in_out_out_result<int, int, int>>);
-static_assert(!std::is_convertible_v<std::ranges::in_out_out_result<int, int, NotConvertible>,
-                                     std::ranges::in_out_out_result<int, int, int>>);
-
-static_assert(std::is_constructible_v<std::ranges::in_out_out_result<MoveOnly, MoveOnly, MoveOnly>,
-                                      std::ranges::in_out_out_result<int, int, int>&>);
+// has to be convertible via const&
+static_assert(std::is_convertible_v<std::ranges::in_out_out_result<int, int, int>&, std::ranges::in_out_out_result<long, long, long>>);
+static_assert(std::is_convertible_v<const std::ranges::in_out_out_result<int, int, int>&, std::ranges::in_out_out_result<long, long, long>>);
+static_assert(std::is_convertible_v<std::ranges::in_out_out_result<int, int, int>&&, std::ranges::in_out_out_result<long, long, long>>);
+static_assert(std::is_convertible_v<const std::ranges::in_out_out_result<int, int, int>&&, std::ranges::in_out_out_result<long, long, long>>);
 
+// should be move constructible
 static_assert(std::is_move_constructible_v<std::ranges::in_out_out_result<MoveOnly, int, int>>);
 static_assert(std::is_move_constructible_v<std::ranges::in_out_out_result<int, MoveOnly, int>>);
 static_assert(std::is_move_constructible_v<std::ranges::in_out_out_result<int, int, MoveOnly>>);
 
 static_assert(!std::is_copy_constructible_v<std::ranges::in_out_out_result<MoveOnly, int, int>>);
 static_assert(!std::is_copy_constructible_v<std::ranges::in_out_out_result<int, MoveOnly, int>>);
 static_assert(!std::is_copy_constructible_v<std::ranges::in_out_out_result<int, int, MoveOnly>>);
 
+struct NotConvertible {};
+// conversions should not work if there is no conversion
+static_assert(!std::is_convertible_v<std::ranges::in_out_out_result<NotConvertible, int, int>, std::ranges::in_out_out_result<int, int, int>>);
+static_assert(!std::is_convertible_v<std::ranges::in_out_out_result<int, NotConvertible, int>, std::ranges::in_out_out_result<int, int, int>>);
+static_assert(!std::is_convertible_v<std::ranges::in_out_out_result<int, int, NotConvertible>, std::ranges::in_out_out_result<int, int, int>>);
+
+template <class T>
+struct ConvertibleFrom {
+  constexpr ConvertibleFrom(T c) : content{c} {}
+  T content;
+};
+
 constexpr bool test() {
   {
     std::ranges::in_out_out_result<int, double, float> res{10, 0., 1.f};
     assert(res.in == 10);
     assert(res.out1 == 0.);
     assert(res.out2 == 1.f);
     std::ranges::in_out_out_result<ConvertibleFrom<int>, ConvertibleFrom<double>, ConvertibleFrom<float>> res2 = res;
     assert(res2.in.content == 10);

libcxx/test/std/algorithms/algorithms.results/in_out_result.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-has-no-incomplete-ranges
-//
-// clang-cl and cl currently don't support [[no_unique_address]]
-// XFAIL: msvc
-
-// namespace ranges {
-//   template<class InputIterator, class OutputIterator>
-//     struct in_out_result;
-// }
-
-#include <algorithm>
-
-// Size optimization.
-struct Empty {};
-struct Empty2 {};
-
-static_assert(sizeof(std::ranges::in_out_result<Empty, int>) == sizeof(int));
-static_assert(sizeof(std::ranges::in_out_result<int, Empty>) == sizeof(int));
-static_assert(sizeof(std::ranges::in_out_result<Empty, Empty2>) == sizeof(char));

libcxx/test/std/algorithms/algorithms.results/in_out_result.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-has-no-incomplete-ranges
 
-// <algorithm>
-//
-// namespace ranges {
-//   template<class InputIterator, class OutputIterator>
-//     struct in_out_result;
-// }
+// template <class I1, class O1>
+// struct in_out_result;
 
 #include <algorithm>
 #include <cassert>
 #include <type_traits>
 
+#include "MoveOnly.h"
+
 struct A {
-  A(int&);
+  explicit A(int);
 };
-static_assert(!std::is_constructible_v<std::ranges::in_out_result<A, A>, std::ranges::in_out_result<int, int>&>);
-
-static_assert(std::is_convertible_v<std::ranges::in_out_result<int, int>&,
-    std::ranges::in_out_result<long, long>>);
-static_assert(!std::is_nothrow_convertible_v<std::ranges::in_out_result<int, int>&,
-    std::ranges::in_out_result<long, long>>);
-static_assert(std::is_convertible_v<const std::ranges::in_out_result<int, int>&,
-    std::ranges::in_out_result<long, long>>);
-static_assert(!std::is_nothrow_convertible_v<const std::ranges::in_out_result<int, int>&,
-    std::ranges::in_out_result<long, long>>);
-static_assert(std::is_convertible_v<std::ranges::in_out_result<int, int>&&,
-    std::ranges::in_out_result<long, long>>);
-static_assert(!std::is_nothrow_convertible_v<std::ranges::in_out_result<int, int>&&,
-    std::ranges::in_out_result<long, long>>);
-static_assert(std::is_convertible_v<const std::ranges::in_out_result<int, int>&&,
-    std::ranges::in_out_result<long, long>>);
-static_assert(!std::is_nothrow_convertible_v<const std::ranges::in_out_result<int, int>&&,
-    std::ranges::in_out_result<long, long>>);
+// no implicit conversion
+static_assert(!std::is_constructible_v<std::ranges::in_out_result<A, A>, std::ranges::in_out_result<int, int>>);
 
-int main(int, char**) {
-  // Conversion, fundamental types.
-  {
-    std::ranges::in_out_result<int, bool> x = {2, false};
-    // FIXME(varconst): try a narrowing conversion.
-    std::ranges::in_out_result<long, char> y = x;
-    assert(y.in == 2);
-    assert(y.out == '\0');
-  }
+struct B {
+  B(int);
+};
+// implicit conversion
+static_assert(std::is_constructible_v<std::ranges::in_out_result<B, B>, std::ranges::in_out_result<int, int>>);
+static_assert(std::is_constructible_v<std::ranges::in_out_result<B, B>, std::ranges::in_out_result<int, int>&>);
+static_assert(std::is_constructible_v<std::ranges::in_out_result<B, B>, const std::ranges::in_out_result<int, int>>);
+static_assert(std::is_constructible_v<std::ranges::in_out_result<B, B>, const std::ranges::in_out_result<int, int>&>);
 
-  // Conversion, user-defined types.
-  {
-    struct From1 {
-      int value = 0;
-      From1(int v) : value(v) {}
-    };
+struct C {
+  C(int&);
+static_assert(!std::is_constructible_v<std::ranges::in_out_result<C, C>, std::ranges::in_out_result<int, int>&>);
 
-    struct To1 {
-      int value = 0;
-      To1(int v) : value(v) {}
+// has to be convertible via const&
+static_assert(std::is_convertible_v<std::ranges::in_out_result<int, int>&, std::ranges::in_out_result<long, long>>);
+static_assert(std::is_convertible_v<const std::ranges::in_out_result<int, int>&, std::ranges::in_out_result<long, long>>);
+static_assert(std::is_convertible_v<std::ranges::in_out_result<int, int>&&, std::ranges::in_out_result<long, long>>);
+static_assert(std::is_convertible_v<const std::ranges::in_out_result<int, int>&&, std::ranges::in_out_result<long, long>>);
 
-      To1(const From1& f) : value(f.value) {};
-    };
+// should be move constructible
+static_assert(std::is_move_constructible_v<std::ranges::in_out_result<MoveOnly, int>>);
+static_assert(std::is_move_constructible_v<std::ranges::in_out_result<int, MoveOnly>>);
 
-    struct To2 {
-      int value = 0;
-      To2(int v) : value(v) {}
-    };
-    struct From2 {
-      int value = 0;
-      From2(int v) : value(v) {}
+struct NotConvertible {};
+// conversions should not work if there is no conversion
+static_assert(!std::is_convertible_v<std::ranges::in_out_result<NotConvertible, int>, std::ranges::in_out_result<int, NotConvertible>>);
+static_assert(!std::is_convertible_v<std::ranges::in_out_result<int, NotConvertible>, std::ranges::in_out_result<NotConvertible, int>>);
 
-      operator To2() const { return To2(value); }
-    };
+template <class T>
+struct ConvertibleFrom {
+  constexpr ConvertibleFrom(T c) : content{c} {}
+  T content;
 
-    std::ranges::in_out_result<From1, From2> x{42, 99};
-    std::ranges::in_out_result<To1, To2> y = x;
-    assert(y.in.value == 42);
-    assert(y.out.value == 99);
+constexpr bool test() {
+  {
+    std::ranges::in_out_result<double, int> res{10, 1};
+    assert(res.in == 10);
+    assert(res.out == 1);
+    std::ranges::in_out_result<ConvertibleFrom<double>, ConvertibleFrom<int>> res2 = res;
+    assert(res2.in.content == 10);
+    assert(res2.out.content == 1);
   }
-
-  // Copy-only type.
   {
-    struct CopyOnly {
-      int value = 0;
-      CopyOnly() = default;
-      CopyOnly(int v) : value(v) {}
-
-      CopyOnly(const CopyOnly&) = default;
-      CopyOnly(CopyOnly&&) = delete;
-    };
-
-    std::ranges::in_out_result<CopyOnly, CopyOnly> x;
-    x.in.value = 42;
-    x.out.value = 99;
-
-    auto y = x;
-    assert(y.in.value == 42);
-    assert(y.out.value == 99);
+    std::ranges::in_out_result<MoveOnly, int> res{MoveOnly{}, 10};
+    assert(res.in.get() == 1);
+    assert(res.out == 10);
+    auto res2 = std::move(res);
+    assert(res.in.get() == 0);
+    assert(res.out == 10);
+    assert(res2.in.get() == 1);
+    assert(res2.out == 10);
   }
-
-  // Move-only type.
   {
-    struct MoveOnly {
-      int value = 0;
-      MoveOnly(int v) : value(v) {}
-
-      MoveOnly(MoveOnly&&) = default;
-      MoveOnly(const MoveOnly&) = delete;
-    };
-
-    std::ranges::in_out_result<MoveOnly, MoveOnly> x{42, 99};
-    auto y = std::move(x);
-    assert(y.in.value == 42);
-    assert(y.out.value == 99);
+    auto [min, max] = std::ranges::in_out_result<int, int>{1, 2};
+    assert(min == 1);
+    assert(max == 2);
   }
 
-  // Unsuccessful conversion.
-  {
-    struct Foo1 {};
-    struct Foo2 {};
-    struct Bar1 {};
-    struct Bar2 {};
-    static_assert(
-        !std::is_convertible_v<std::ranges::in_out_result<Foo1, Foo2>, std::ranges::in_out_result<Bar1, Bar2>>);
-  }
+  return true;
 
-  return 0;
+int main(int, char**) {
+  test();
+  static_assert(test());
 }

libcxx/test/std/algorithms/algorithms.results/min_max_result.pass.cpp

 // struct min_max_result;
 
 #include <algorithm>
 #include <cassert>
 #include <type_traits>
 
 #include "MoveOnly.h"
 
-template <class T>
-struct ConvertibleFrom {
-  constexpr ConvertibleFrom(T c) : content{c} {}
-  T content;
-};
-
 struct A {
   explicit A(int);
 };
+// no implicit conversion
 static_assert(!std::is_constructible_v<std::ranges::min_max_result<A>, std::ranges::min_max_result<int>>);
 
 struct B {
-  B(const int&);
-  B(int&&);
+  B(int);
 };
+// implicit conversion
 static_assert(std::is_constructible_v<std::ranges::min_max_result<B>, std::ranges::min_max_result<int>>);
 static_assert(std::is_constructible_v<std::ranges::min_max_result<B>, std::ranges::min_max_result<int>&>);
 static_assert(std::is_constructible_v<std::ranges::min_max_result<B>, const std::ranges::min_max_result<int>>);
 static_assert(std::is_constructible_v<std::ranges::min_max_result<B>, const std::ranges::min_max_result<int>&>);
 
 struct C {
   C(int&);
 };
 static_assert(!std::is_constructible_v<std::ranges::min_max_result<C>, std::ranges::min_max_result<int>&>);
 
+// has to be convertible via const&
 static_assert(std::is_convertible_v<std::ranges::min_max_result<int>&, std::ranges::min_max_result<long>>);
 static_assert(std::is_convertible_v<const std::ranges::min_max_result<int>&, std::ranges::min_max_result<long>>);
 static_assert(std::is_convertible_v<std::ranges::min_max_result<int>&&, std::ranges::min_max_result<long>>);
 static_assert(std::is_convertible_v<const std::ranges::min_max_result<int>&&, std::ranges::min_max_result<long>>);
 
+// should be move constructible
+static_assert(std::is_move_constructible_v<std::ranges::min_max_result<MoveOnly>>);
+
+// should not be copy constructible
+static_assert(!std::is_copy_constructible_v<std::ranges::min_max_result<MoveOnly>>);
+
 struct NotConvertible {};
+// conversions should not work if there is no conversion
 static_assert(!std::is_convertible_v<std::ranges::min_max_result<NotConvertible>, std::ranges::min_max_result<int>>);
 
+template <class T>
+struct ConvertibleFrom {
+  constexpr ConvertibleFrom(T c) : content{c} {}
+  T content;
+};
+
 constexpr bool test() {
   {
     std::ranges::min_max_result<double> res{10, 1};
     assert(res.min == 10);
     assert(res.max == 1);
     std::ranges::min_max_result<ConvertibleFrom<int>> res2 = res;
     assert(res2.min.content == 10);
     assert(res2.max.content == 1);
   }
   {
     std::ranges::min_max_result<MoveOnly> res{MoveOnly{}, MoveOnly{}};
     assert(res.min.get() == 1);
     assert(res.max.get() == 1);
-    [[maybe_unused]] auto res2 = static_cast<std::ranges::min_max_result<MoveOnly>>(std::move(res));
+    auto res2 = std::move(res);
     assert(res.min.get() == 0);
     assert(res.max.get() == 0);
+    assert(res2.min.get() == 1);
+    assert(res2.max.get() == 1);
   }
+  {
     auto [min, max] = std::ranges::min_max_result<int>{1, 2};
     assert(min == 1);
     assert(max == 2);
+  }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/algorithms.results/no_unique_address.compile.pass.cpp

 
 // [algorithms.results]/1
 //   Each of the class templates specified in this subclause has the template parameters,
 //   data members, and special members specified below, and has no base classes or members
 //   other than those specified.
 
 #include <algorithm>
 
+#include "test_macros.h"
+
 struct Empty {};
 struct Empty2 {};
 
+static_assert(sizeof(std::ranges::in_fun_result<Empty, int>) == sizeof(int));
+static_assert(sizeof(std::ranges::in_fun_result<int, Empty>) == sizeof(int));
+static_assert(sizeof(std::ranges::in_fun_result<Empty, Empty>) == 2);
+
 static_assert(sizeof(std::ranges::in_in_result<Empty, int>) == sizeof(int));
 static_assert(sizeof(std::ranges::in_in_result<int, Empty>) == sizeof(int));
 static_assert(sizeof(std::ranges::in_in_result<Empty, Empty>) == 2);
 
+static_assert(sizeof(std::ranges::in_out_result<Empty, int>) == sizeof(int));
+static_assert(sizeof(std::ranges::in_out_result<int, Empty>) == sizeof(int));
+static_assert(sizeof(std::ranges::in_out_result<Empty, Empty2>) == sizeof(char));
+
 static_assert(sizeof(std::ranges::in_in_out_result<Empty, int, int>) == 2 * sizeof(int));
 static_assert(sizeof(std::ranges::in_in_out_result<int, Empty, int>) == 2 * sizeof(int));
 static_assert(sizeof(std::ranges::in_in_out_result<int, int, Empty>) == 2 * sizeof(int));
 static_assert(sizeof(std::ranges::in_in_out_result<char, Empty, Empty>) == 2);
 static_assert(sizeof(std::ranges::in_in_out_result<Empty, char, Empty>) == 2);
 static_assert(sizeof(std::ranges::in_in_out_result<Empty, Empty, char>) == 2);
 static_assert(sizeof(std::ranges::in_in_out_result<int, Empty, Empty2>) == sizeof(int));
 static_assert(sizeof(std::ranges::in_in_out_result<Empty, Empty, Empty>) == 3);
 
 static_assert(sizeof(std::ranges::in_out_out_result<Empty, int, int>) == 2 * sizeof(int));
 static_assert(sizeof(std::ranges::in_out_out_result<int, Empty, int>) == 2 * sizeof(int));
 static_assert(sizeof(std::ranges::in_out_out_result<int, int, Empty>) == 2 * sizeof(int));
 static_assert(sizeof(std::ranges::in_out_out_result<char, Empty, Empty>) == 2);
 static_assert(sizeof(std::ranges::in_out_out_result<Empty, char, Empty>) == 2);
 static_assert(sizeof(std::ranges::in_out_out_result<Empty, Empty, char>) == 2);
 static_assert(sizeof(std::ranges::in_out_out_result<int, Empty, Empty2>) == sizeof(int));
 static_assert(sizeof(std::ranges::in_out_out_result<Empty, Empty, Empty>) == 3);
 
-static_assert(sizeof(std::ranges::in_fun_result<Empty, int>) == sizeof(int));
-static_assert(sizeof(std::ranges::in_fun_result<int, Empty>) == sizeof(int));
-static_assert(sizeof(std::ranges::in_fun_result<Empty, Empty>) == 2);
+// In min_max_result both elements have the same type, so they can't have the same address.
+// So the only way to test that [[no_unique_address]] is used is to have it in another struct
+struct MinMaxNoUniqueAddress {
+  int a;
+  TEST_NO_UNIQUE_ADDRESS std::ranges::min_max_result<Empty> b;
+  int c;
+};
+
+static_assert(sizeof(std::ranges::min_max_result<Empty>) == 2);
+static_assert(sizeof(MinMaxNoUniqueAddress) == 8);
+
+static_assert(sizeof(std::ranges::in_found_result<Empty>) == sizeof(bool));

libcxx/test/support/test_macros.h

 #else
 #  define TEST_DIAGNOSTIC_PUSH
 #  define TEST_DIAGNOSTIC_POP
 #  define TEST_CLANG_DIAGNOSTIC_IGNORED(str)
 #  define TEST_GCC_DIAGNOSTIC_IGNORED(str)
 #  define TEST_MSVC_DIAGNOSTIC_IGNORED(num)
 #endif
 
+#if __has_cpp_attribute(msvc::no_unique_address)
+#define TEST_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
+#elif __has_cpp_attribute(no_unique_address)
+#define TEST_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+#define TEST_NO_UNIQUE_ADDRESS
+#endif
+
 #endif // SUPPORT_TEST_MACROS_HPP