[libcxx][test] Remove redundant semiregular checks for CPOs

[jloser]

Summary

Some individual test files verify the CPO under test satisfies
semiregular concept. This is redundant since it is already part of the test
in verifying whether the entity is indeed a CPO in
libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp.

[• Quuxplusone]

LGTM!

[Mordante]

LGTM!

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.swap.pass.cpp

 #include <array>
 #include <cassert>
 
 #include "./unqualified_lookup_wrapper.h"
 #include "test_iterators.h"
 
 using IterSwapT = decltype(std::ranges::iter_swap);
 
-static_assert(std::semiregular<std::remove_cv_t<IterSwapT>>);
-
 struct HasIterSwap {
   int &value_;
   explicit HasIterSwap(int &value) : value_(value) { assert(value == 0); }
 
   friend constexpr void iter_swap(HasIterSwap& a, HasIterSwap& b) {
     a.value_ = 1;
     b.value_ = 1;
   }

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

 static_assert(!std::is_invocable_v<RangeSizeT, Incomplete(&&)[]>);
 
 extern Incomplete array_of_incomplete[42];
 static_assert(std::ranges::size(array_of_incomplete) == 42);
 static_assert(std::ranges::size(std::move(array_of_incomplete)) == 42);
 static_assert(std::ranges::size(std::as_const(array_of_incomplete)) == 42);
 static_assert(std::ranges::size(static_cast<const Incomplete(&&)[42]>(array_of_incomplete)) == 42);
 
-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; }
 };
 

libcxx/test/std/ranges/range.access/ssize.pass.cpp

 
 using RangeSSizeT = decltype(std::ranges::ssize);
 
 static_assert(!std::is_invocable_v<RangeSSizeT, int[]>);
 static_assert( std::is_invocable_v<RangeSSizeT, int[1]>);
 static_assert( std::is_invocable_v<RangeSSizeT, int (&&)[1]>);
 static_assert( std::is_invocable_v<RangeSSizeT, int (&)[1]>);
 
-static_assert(std::semiregular<std::remove_cv_t<RangeSSizeT>>);
-
 struct SizeMember {
   constexpr size_t size() { return 42; }
 };
 static_assert(!std::is_invocable_v<decltype(std::ranges::ssize), const SizeMember&>);
 
 struct SizeFunction {
   friend constexpr size_t size(SizeFunction) { return 42; }
 };

libcxx/test/std/ranges/range.adaptors/range.counted/counted.pass.cpp

 };
 
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     static_assert(std::addressof(std::views::counted) == std::addressof(std::ranges::views::counted));
 
-    auto copy = std::views::counted;
-    static_assert(std::semiregular<decltype(copy)>);
-
     static_assert( CountedInvocable<int*, size_t>);
     static_assert(!CountedInvocable<int*, LvalueConvertible>);
     static_assert( CountedInvocable<int*, LvalueConvertible&>);
     static_assert( CountedInvocable<int*, RvalueConvertible>);
     static_assert(!CountedInvocable<int*, RvalueConvertible&>);
     static_assert(!CountedInvocable<int*, OnlyExplicitlyConvertible>);
     static_assert(!CountedInvocable<int*, int*>);
     static_assert(!CountedInvocable<int*>);

libcxx/test/std/ranges/range.factories/range.iota.view/views_iota.pass.cpp

// Test with two arguments.
     const auto io = std::views::iota(T(10), u);
     assert(*io.begin() == T(10));
   }
   // Test that we return the correct type.
   {
     ASSERT_SAME_TYPE(decltype(std::views::iota(T(10))), std::ranges::iota_view<T>);
     ASSERT_SAME_TYPE(decltype(std::views::iota(T(10), u)), std::ranges::iota_view<T, U>);
   }
-  // Test that this is semiregular.
-  // Note: we cannot test perfect forwarding because both T and U must be copyable.
-  {
-    static_assert(std::semiregular<std::remove_const_t<decltype(std::views::iota)>>);
-  }
 }
 
 struct X {};
 
 constexpr bool test() {
   testType<SomeInt>(SomeInt(10));
   testType<SomeInt>(IntComparableWith(SomeInt(10)));
   testType<signed long>(IntComparableWith<signed long>(10));