[libc++] Improve ranges::starts_with

[ZijunZhao]

Summary

Fix some nits in https://reviews.llvm.org/D150146

[philnik]

LGTM with green CI.

[ZijunZhao]

Submit: https://github.com/llvm/llvm-project/commit/f9f1f9c2a533d5caa3ddf813ebbd16fe3a13fce7

libcxx/test/std/algorithms/alg.nonmodifying/alg.starts_with/ranges.starts_with.pass.cpp

 static_assert(!HasStartsWithR<ForwardRangeNotSentinelSemiregular>);
 static_assert(!HasStartsWithR<ForwardRangeNotSentinelEqualityComparableWith>);
 static_assert(!HasStartsWithR<UncheckedRange<int*>, UncheckedRange<int**>>); // not indirectly comparable
 static_assert(HasStartsWithR<UncheckedRange<int*>, ForwardRangeNotDerivedFrom>);
 static_assert(HasStartsWithR<UncheckedRange<int*>, ForwardRangeNotIncrementable>);
 static_assert(!HasStartsWithR<UncheckedRange<int*>, ForwardRangeNotSentinelSemiregular>);
 static_assert(!HasStartsWithR<UncheckedRange<int*>, ForwardRangeNotSentinelEqualityComparableWith>);
 
+// clang-format off
 template <class Iter1, class Sent1 = Iter1, class Iter2, class Sent2 = Iter2>
 constexpr void test_iterators() {
-  // simple tests
-  {
+  {  // simple tests
     {
       int a[] = {1, 2, 3, 4, 5, 6};
       int p[] = {1, 2};
       std::same_as<bool> decltype(auto) ret =
         std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 2)));
       assert(ret);
     }
     {
       int a[]                               = {1, 2, 3, 4, 5, 6};
       int p[]                               = {1, 2};
       auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
       auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 2)));
       std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
       assert(ret);
     }
   }
 
-  // prefix doesn't match
-  {
+  { // prefix doesn't match
     {
       int a[] = {1, 2, 3, 4, 5, 6};
       int p[] = {4, 5, 6};
       std::same_as<bool> decltype(auto) ret =
           std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 3)));
       assert(!ret);
     }
     {
       int a[]                               = {1, 2, 3, 4, 5, 6};
       int p[]                               = {4, 5, 6};
       auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
       auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 3)));
       std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
       assert(!ret);
     }
   }
 
-  // range and prefix are identical
-  {
+  { // range and prefix are identical
     {
       int a[] = {1, 2, 3, 4, 5, 6};
       int p[] = {1, 2, 3, 4, 5, 6};
       std::same_as<bool> decltype(auto) ret =
           std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 6)));
       assert(ret);
     }
     {
       int a[]                               = {1, 2, 3, 4, 5, 6};
       int p[]                               = {1, 2, 3, 4, 5, 6};
       auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
       auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 6)));
       std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
       assert(ret);
     }
   }
 
-  // prefix is longer than range
-  {
+  { // prefix is longer than range
     {
       int a[] = {1, 2, 3, 4, 5, 6};
       int p[] = {1, 2, 3, 4, 5, 6, 7, 8};
       std::same_as<bool> decltype(auto) ret =
           std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 8)));
       assert(!ret);
     }
     {
       int a[]                               = {1, 2, 3, 4, 5, 6};
       int p[]                               = {1, 2, 3, 4, 5, 6, 7, 8};
       auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
       auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 8)));
       std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
       assert(!ret);
     }
   }
 
-  // prefix has zero length
-  {
+  { // prefix has zero length
     {
       int a[] = {1, 2, 3, 4, 5, 6};
       int p[] = {};
       std::same_as<bool> decltype(auto) ret =
           std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p)));
       assert(ret);
     }
     {
       int a[]                               = {1, 2, 3, 4, 5, 6};
       int p[]                               = {};
       auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
       auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p)));
       std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
       assert(ret);
     }
   }
 
-  // range has zero length
-  {
+  { // range has zero length
     {
       int a[] = {};
       int p[] = {1, 2, 3, 4, 5, 6, 7, 8};
       std::same_as<bool> decltype(auto) ret =
           std::ranges::starts_with(Iter1(a), Sent1(Iter1(a)), Iter2(p), Sent2(Iter2(p + 8)));
       assert(!ret);
     }
     {
       int a[]                               = {};
       int p[]                               = {1, 2, 3, 4, 5, 6, 7, 8};
       auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a)));
       auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 8)));
       std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
       assert(!ret);
     }
   }
 
-  // check that the predicate is used
-  {
+  { // check that the predicate is used
     {
       int a[] = {11, 8, 3, 4, 0, 6};
       int p[]                               = {1, 12};
       std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(
           Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 2)), [](int l, int r) { return l > r; });
       assert(!ret);
     }
     {
       int a[]                               = {11, 8, 3, 4, 0, 6};
       int p[]                               = {1, 12};
       auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
       auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 2)));
       std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix, [](int l, int r) { return l > r; });
       assert(!ret);
     }
   }
 
-  // check that the projections are used
-  {
+  { // check that the projections are used
     {
       int a[]                               = {1, 3, 5, 1, 5, 6};
       int p[]                               = {2, 3, 4};
       std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(
           Iter1(a),
           Sent1(Iter1(a + 6)),
           Iter2(p),
           Sent2(Iter2(p + 3)),
constexpr void test_iterators() {
       std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(
           whole, prefix, {}, [](int i) { return i + 3; }, [](int i) { return i * 2; });
       assert(ret);
     }
   }
 }
 
 constexpr bool test() {
-  types::for_each(types::forward_iterator_list<int*>{}, []<class I2>() {
-    types::for_each(types::forward_iterator_list<int*>{}, []<class I1>() {
-      test_iterators<I1, I1, I2, I2>();
-      test_iterators<I1, sized_sentinel<I1>, I2, I2>();
-      test_iterators<I1, I1, I2, sized_sentinel<I2>>();
-      test_iterators<I1, sized_sentinel<I1>, I2, sized_sentinel<I2>>();
+  types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class Iter2>() {
+    types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class Iter1>() {
+      if constexpr (std::forward_iterator<Iter1> && std::forward_iterator<Iter2>)
+        test_iterators<Iter1, Iter1, Iter2, Iter2>();
+      if constexpr (std::forward_iterator<Iter2>)
+        test_iterators<Iter1, sized_sentinel<Iter1>, Iter2, Iter2>();
+      if constexpr (std::forward_iterator<Iter1>)
+        test_iterators<Iter1, Iter1, Iter2, sized_sentinel<Iter2>>();
+      test_iterators<Iter1, sized_sentinel<Iter1>, Iter2, sized_sentinel<Iter2>>();
     });
   });
 
-  // check that std::invoke is used
-  {
+  { // check that std::invoke is used
     struct S {
       int i;
 
       constexpr S identity() { return *this; }
 
       constexpr bool compare(const S& s) { return i == s.i; }
     };
     {
constexpr bool test() {
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
+
   return 0;
 }