[libc++][ranges] Add subsumption tests to `[special.mem.concepts]`.

[var-const]

Summary

Test that nothrow-forward-iterator subsumes nothrow-input-iterator,
nothrow-forward-range subsumes nothrow-input-range, and
nothrow-sentinel-for and sentinel_for subsume each other.

This is a follow-up to D114761.

[var-const]

Please let me know if you'd like to add any more subsumption tests, e.g.:

• test that nothrow-input-iterator subsumes input_iterator (and likewise for the range);
• test that nothrow-sentinel-for and sentinel_for subsume each other (as suggested by @Quuxplusone in the original patch).

[var-const]

Update commit description.

[var-const]

Squash two commits into one.

[• Quuxplusone]

libcxx/test/libcxx/algorithms/specialized.algorithms/special.mem.concepts/nothrow_forward_range.compile.pass.cpp

37–41

Here, requires true is unnecessary: the former should properly subsume the latter, in the sense of "proper subset".

Also, I think it is actually more important (so I'd like to see) that you test "nothrow-sentinel-for and sentinel_for subsume each other." In that case, since the subsumption is not proper, the requires true will be needed in order to make the one function more-constrained than the other.

[• Quuxplusone]

libcxx/test/libcxx/algorithms/specialized.algorithms/special.mem.concepts/nothrow_forward_range.compile.pass.cpp

37–41

Oh, and also, please always pass [iterator types by value, but] range types by forwarding reference:

constexpr bool forward_subsumes_input(std::ranges::__nothrow_input_range auto&&);

Then you can use "foo" as your forwarding range here, too, instead of dragging in a std::array dependency.

[var-const]

Address feedback, add subsumption tests to nothrow-sentinel-for.

[var-const]

libcxx/test/libcxx/algorithms/specialized.algorithms/special.mem.concepts/nothrow_forward_range.compile.pass.cpp

37–41

Done, thanks for explaining!

37–41

Thanks! Added the tests for sentinels, PTAL.

[var-const]

Rebase on main.

[• Quuxplusone]

LGTM!

[var-const]

Rebase on main.

libcxx/test/libcxx/algorithms/specialized.algorithms/special.mem.concepts/nothrow_forward_iterator.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
 //
 //===----------------------------------------------------------------------===//
 
struct ForwardProxyIterator {
   bool operator==(const ForwardProxyIterator&) const;
 
   int operator*() const;
 };
 
 static_assert(std::ranges::__nothrow_forward_iterator<forward_iterator<int*>>);
 static_assert(std::forward_iterator<ForwardProxyIterator>);
 static_assert(!std::ranges::__nothrow_forward_iterator<ForwardProxyIterator>);
+
+constexpr bool forward_subsumes_input(std::ranges::__nothrow_forward_iterator auto) {
+  return true;
+}
+constexpr bool forward_subsumes_input(std::ranges::__nothrow_input_iterator auto);
+
+static_assert(forward_subsumes_input("foo"));

libcxx/test/libcxx/algorithms/specialized.algorithms/special.mem.concepts/nothrow_forward_range.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
 //
 //===----------------------------------------------------------------------===//
 
struct ForwardProxyIterator {
 
   int operator*() const;
 };
 
 static_assert(std::ranges::__nothrow_forward_range<test_range<forward_iterator>>);
 static_assert(!std::ranges::__nothrow_forward_range<test_range<cpp20_input_iterator>>);
 static_assert(std::ranges::forward_range<test_range<ForwardProxyIterator>>);
 static_assert(!std::ranges::__nothrow_forward_range<test_range<ForwardProxyIterator>>);
+
+constexpr bool forward_subsumes_input(std::ranges::__nothrow_forward_range auto&&) {
+  return true;
+}
+constexpr bool forward_subsumes_input(std::ranges::__nothrow_input_range auto&&);
+
+static_assert(forward_subsumes_input("foo"));

libcxx/test/libcxx/algorithms/specialized.algorithms/special.mem.concepts/nothrow_sentinel_for.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
 
 // template<class S, class I>
 // concept __nothrow_sentinel_for;
 
 #include <memory>
 
 static_assert(std::ranges::__nothrow_sentinel_for<int*, int*>);
 static_assert(!std::ranges::__nothrow_sentinel_for<int*, long*>);
+
+// Because `__nothrow_sentinel_for` is essentially an alias for `sentinel_for`,
+// the two concepts should subsume each other.
+
+constexpr bool ntsf_subsumes_sf(std::ranges::__nothrow_sentinel_for<char*> auto) requires true {
+  return true;
+}
+constexpr bool ntsf_subsumes_sf(std::sentinel_for<char*> auto);
+
+static_assert(ntsf_subsumes_sf("foo"));
+
+constexpr bool sf_subsumes_ntsf(std::sentinel_for<char*> auto) requires true {
+  return true;
+}
+constexpr bool sf_subsumes_ntsf(std::ranges::__nothrow_sentinel_for<char*> auto);
+
+static_assert(sf_subsumes_ntsf("foo"));