[libcxx][test] tests for strengthened `noexcept` are non-portable

[• Quuxplusone]

I actually don't see any textual support for our metaprogrammy conditional-noexcepts in view_interface at all. @zoecarver if you're still around, what was the rationale for all the conditional-noexcept in D101737? Would anything important break if we just got rid of it all?

Not only would removing the noexcept-specifications be simpler, safer, and faster-to-compile, but it would also jibe with @ldionne's general philosophy of keeping as close to the Standard as possible. The Standard doesn't say that these functions should ever be noexcept, so by making ours sometimes-noexcept, we might be opening up portability pitfalls for libc++'s users.

[ldionne]

IIRC the idea was to make functions noexcept as much as we could because that's conforming and we thought that we'd never actually want to do anything else but terminate if an exception was thrown from those. But revisiting this, I agree it's a weird choice to have made and I would support removing the non-required noexcepts (in particular the conditional ones that add complexity). @Quuxplusone if you want to make a pass at those, be my guest, I'll be happy to review.

In the meantime, this looks OK to me since that behavior is indeed libc++ specific. I think the CI failure is OK to ignore.

libcxx/test/std/ranges/range.adaptors/range.drop/ctor.default.pass.cpp

 
 constexpr bool test() {
   std::ranges::drop_view<MoveOnlyView> dropView1;
   assert(std::ranges::begin(dropView1) == globalBuff);
 
   static_assert( std::is_default_constructible_v<std::ranges::drop_view<ForwardView>>);
   static_assert(!std::is_default_constructible_v<std::ranges::drop_view<NoDefaultCtorForwardView>>);
 
-  static_assert( std::is_nothrow_default_constructible_v<std::ranges::drop_view<ForwardView>>);
+  LIBCPP_STATIC_ASSERT( std::is_nothrow_default_constructible_v<std::ranges::drop_view<ForwardView>>);
   static_assert(!std::is_nothrow_default_constructible_v<ThrowingDefaultCtorForwardView>);
   static_assert(!std::is_nothrow_default_constructible_v<std::ranges::drop_view<ThrowingDefaultCtorForwardView>>);
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/deref.pass.cpp

 #include "../types.h"
 
 int main(int, char**) {
   {
     int buff[] = {0, 1, 2, 3, 4, 5, 6, 7};
     using View = std::ranges::transform_view<MoveOnlyView, PlusOne>;
     View transformView(MoveOnlyView{buff}, PlusOne{});
     assert(*transformView.begin() == 1);
-    static_assert(!noexcept(*std::declval<std::ranges::iterator_t<View>>()));
+    ASSERT_NOT_NOEXCEPT(*std::declval<std::ranges::iterator_t<View>>());
     ASSERT_SAME_TYPE(int, decltype(*std::declval<View>().begin()));
   }
   {
     int buff[] = {0, 1, 2, 3, 4, 5, 6, 7};
     using View = std::ranges::transform_view<MoveOnlyView, PlusOneMutable>;
     View transformView(MoveOnlyView{buff}, PlusOneMutable{});
     assert(*transformView.begin() == 1);
-    static_assert(!noexcept(*std::declval<std::ranges::iterator_t<View>>()));
+    ASSERT_NOT_NOEXCEPT(*std::declval<std::ranges::iterator_t<View>>());
     ASSERT_SAME_TYPE(int, decltype(*std::declval<View>().begin()));
   }
   {
     int buff[] = {0, 1, 2, 3, 4, 5, 6, 7};
     using View = std::ranges::transform_view<MoveOnlyView, PlusOneNoexcept>;
     View transformView(MoveOnlyView{buff}, PlusOneNoexcept{});
     assert(*transformView.begin() == 1);
-    static_assert(noexcept(*std::declval<std::ranges::iterator_t<View>>()));
+    LIBCPP_ASSERT_NOEXCEPT(*std::declval<std::ranges::iterator_t<View>>());
     ASSERT_SAME_TYPE(int, decltype(*std::declval<View>().begin()));
   }
   {
     int buff[] = {0, 1, 2, 3, 4, 5, 6, 7};
     using View = std::ranges::transform_view<MoveOnlyView, Increment>;
     View transformView(MoveOnlyView{buff}, Increment{});
     assert(*transformView.begin() == 1);
-    static_assert(!noexcept(*std::declval<std::ranges::iterator_t<View>>()));
+    ASSERT_NOT_NOEXCEPT(*std::declval<std::ranges::iterator_t<View>>());
     ASSERT_SAME_TYPE(int&, decltype(*std::declval<View>().begin()));
   }
   {
     int buff[] = {0, 1, 2, 3, 4, 5, 6, 7};
     using View = std::ranges::transform_view<MoveOnlyView, IncrementRvalueRef>;
     View transformView(MoveOnlyView{buff}, IncrementRvalueRef{});
     assert(*transformView.begin() == 1);
-    static_assert(!noexcept(*std::declval<std::ranges::iterator_t<View>>()));
+    ASSERT_NOT_NOEXCEPT(*std::declval<std::ranges::iterator_t<View>>());
     ASSERT_SAME_TYPE(int&&, decltype(*std::declval<View>().begin()));
   }
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/iter_move.pass.cpp

 #include "../types.h"
 
 constexpr bool test() {
   int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
 
   {
     std::ranges::transform_view transformView(MoveOnlyView{buff}, PlusOneMutable{});
     auto iter = transformView.begin();
-    static_assert(!noexcept(std::ranges::iter_move(iter)));
+    ASSERT_NOT_NOEXCEPT(std::ranges::iter_move(iter));
 
     assert(std::ranges::iter_move(iter) == 1);
     assert(std::ranges::iter_move(iter + 2) == 3);
 
     ASSERT_SAME_TYPE(int, decltype(std::ranges::iter_move(iter)));
     ASSERT_SAME_TYPE(int, decltype(std::ranges::iter_move(std::move(iter))));
   }
 
   {
-    static_assert( noexcept(std::ranges::iter_move(
-      std::declval<std::ranges::iterator_t<std::ranges::transform_view<MoveOnlyView, PlusOneNoexcept>>&>())));
-    static_assert(!noexcept(std::ranges::iter_move(
-      std::declval<std::ranges::iterator_t<std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>&>())));
+    LIBCPP_ASSERT_NOEXCEPT(std::ranges::iter_move(
+      std::declval<std::ranges::iterator_t<std::ranges::transform_view<MoveOnlyView, PlusOneNoexcept>>&>()));
+    ASSERT_NOT_NOEXCEPT(std::ranges::iter_move(
+      std::declval<std::ranges::iterator_t<std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>&>()));
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/subscript.pass.cpp

 
 constexpr bool test() {
   int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
   std::ranges::transform_view transformView1(MoveOnlyView{buff}, PlusOneMutable{});
   auto iter1 = std::move(transformView1).begin() + 1;
   assert(iter1[0] == 2);
   assert(iter1[4] == 6);
 
-  static_assert(!noexcept(
-    std::declval<std::ranges::iterator_t<std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>>()[0]));
-  static_assert( noexcept(
-    std::declval<std::ranges::iterator_t<std::ranges::transform_view<MoveOnlyView, PlusOneNoexcept>>>()[0]));
+  ASSERT_NOT_NOEXCEPT(
+    std::declval<std::ranges::iterator_t<std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>>()[0]);
+  LIBCPP_ASSERT_NOEXCEPT(
+    std::declval<std::ranges::iterator_t<std::ranges::transform_view<MoveOnlyView, PlusOneNoexcept>>>()[0]);
 
   ASSERT_SAME_TYPE(
     int,
     decltype(std::declval<std::ranges::transform_view<RandomAccessView, PlusOneMutable>>().begin()[0]));
   ASSERT_SAME_TYPE(
     int&,
     decltype(std::declval<std::ranges::transform_view<RandomAccessView, Increment>>().begin()[0]));
   ASSERT_SAME_TYPE(

libcxx/test/std/ranges/range.utility/view.interface/view.interface.pass.cpp

constexpr bool testEmpty() {
   assert(std::ranges::empty(static_cast<EmptyIsTrue const&>(emptyTrue)));
 
   // Try calling empty on an rvalue.
   MoveOnlyForwardRange moveOnly;
   assert(!std::move(moveOnly).empty());
 
   BoolConvertibleComparison<true> boolConv;
   BoolConvertibleComparison<false> boolConv2;
-  static_assert(noexcept(boolConv.empty()));
-  static_assert(!noexcept(boolConv2.empty()));
+  LIBCPP_ASSERT_NOEXCEPT(boolConv.empty());
+  ASSERT_NOT_NOEXCEPT(boolConv2.empty());
 
   assert(!boolConv.empty());
   assert(!static_cast<BoolConvertibleComparison<true> const&>(boolConv).empty());
 
   assert(boolConv);
   assert(static_cast<BoolConvertibleComparison<true> const&>(boolConv));
 
   assert(!std::ranges::empty(boolConv));