[libc++] Remove conditional noexcepts from view_interface

[• Quuxplusone]

Summary

As suggested in D117966 (attn @ldionne).
These conditional noexcepts are *permitted* by the Standard (as long
as there were no mistakes in them, I guess); but not *mandated*.
The Standard doesn't put any noexcept-specifications on these member functions.
The same logic would apply to transform_view::iterator::operator*
and transform_view::iterator::operator[], but the Standard mandates
conditional noexcept on iter_move(transform_view::iterator), and
I think it doesn't make much sense to say "moving from this iterator
is conditionally noexcept but not-moving from it is noexcept(false),"
so I'm leaving transform_view alone for now.

[ldionne]

LGTM. This fly-by refactoring was riiiight on the limit where I would have asked for as separate NFC :-).

[jloser]

LGTM.

libcxx/include/__ranges/view_interface.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_VIEW_INTERFACE_H
 #define _LIBCPP___RANGES_VIEW_INTERFACE_H
 
+#include <__concepts/derived_from.h>
+#include <__concepts/same_as.h>
 #include <__config>
 #include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/prev.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/empty.h>
-#include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_CONCEPTS) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 namespace ranges {
 
-template<class _Tp>
-concept __can_empty = requires(_Tp __t) { ranges::empty(__t); };
-
-template<class _Tp>
-void __implicitly_convert_to(type_identity_t<_Tp>) noexcept;
-
 template<class _Derived>
   requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
 class view_interface {
   _LIBCPP_HIDE_FROM_ABI
   constexpr _Derived& __derived() noexcept {
     static_assert(sizeof(_Derived) && derived_from<_Derived, view_interface> && view<_Derived>);
     return static_cast<_Derived&>(*this);
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr _Derived const& __derived() const noexcept {
     static_assert(sizeof(_Derived) && derived_from<_Derived, view_interface> && view<_Derived>);
     return static_cast<_Derived const&>(*this);
   }
 
 public:
   template<class _D2 = _Derived>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty()
-    noexcept(noexcept(__implicitly_convert_to<bool>(ranges::begin(__derived()) == ranges::end(__derived()))))
     requires forward_range<_D2>
   {
     return ranges::begin(__derived()) == ranges::end(__derived());
   }
 
   template<class _D2 = _Derived>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const
-    noexcept(noexcept(__implicitly_convert_to<bool>(ranges::begin(__derived()) == ranges::end(__derived()))))
     requires forward_range<const _D2>
   {
     return ranges::begin(__derived()) == ranges::end(__derived());
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr explicit operator bool()
-    noexcept(noexcept(ranges::empty(declval<_D2>())))
-    requires __can_empty<_D2>
+    requires requires (_D2& __t) { ranges::empty(__t); }
   {
     return !ranges::empty(__derived());
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr explicit operator bool() const
-    noexcept(noexcept(ranges::empty(declval<const _D2>())))
-    requires __can_empty<const _D2>
+    requires requires (const _D2& __t) { ranges::empty(__t); }
   {
     return !ranges::empty(__derived());
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto data()
-    noexcept(noexcept(std::to_address(ranges::begin(__derived()))))
     requires contiguous_iterator<iterator_t<_D2>>
   {
     return std::to_address(ranges::begin(__derived()));
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto data() const
-    noexcept(noexcept(std::to_address(ranges::begin(__derived()))))
     requires range<const _D2> && contiguous_iterator<iterator_t<const _D2>>
   {
     return std::to_address(ranges::begin(__derived()));
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto size()
-    noexcept(noexcept(ranges::end(__derived()) - ranges::begin(__derived())))
-    requires forward_range<_D2>
-      && sized_sentinel_for<sentinel_t<_D2>, iterator_t<_D2>>
+    requires forward_range<_D2> && sized_sentinel_for<sentinel_t<_D2>, iterator_t<_D2>>
   {
     return ranges::end(__derived()) - ranges::begin(__derived());
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto size() const
-    noexcept(noexcept(ranges::end(__derived()) - ranges::begin(__derived())))
-    requires forward_range<const _D2>
-      && sized_sentinel_for<sentinel_t<const _D2>, iterator_t<const _D2>>
+    requires forward_range<const _D2> && sized_sentinel_for<sentinel_t<const _D2>, iterator_t<const _D2>>
   {
     return ranges::end(__derived()) - ranges::begin(__derived());
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) front()
-    noexcept(noexcept(*ranges::begin(__derived())))
     requires forward_range<_D2>
   {
     _LIBCPP_ASSERT(!empty(),
         "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
     return *ranges::begin(__derived());
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) front() const
-    noexcept(noexcept(*ranges::begin(__derived())))
     requires forward_range<const _D2>
   {
     _LIBCPP_ASSERT(!empty(),
         "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
     return *ranges::begin(__derived());
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) back()
-    noexcept(noexcept(*ranges::prev(ranges::end(__derived()))))
     requires bidirectional_range<_D2> && common_range<_D2>
   {
     _LIBCPP_ASSERT(!empty(),
         "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
     return *ranges::prev(ranges::end(__derived()));
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) back() const
-    noexcept(noexcept(*ranges::prev(ranges::end(__derived()))))
     requires bidirectional_range<const _D2> && common_range<const _D2>
   {
     _LIBCPP_ASSERT(!empty(),
         "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
     return *ranges::prev(ranges::end(__derived()));
   }
 
   template<random_access_range _RARange = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) operator[](range_difference_t<_RARange> __index)
-    noexcept(noexcept(ranges::begin(__derived())[__index]))
   {
     return ranges::begin(__derived())[__index];
   }
 
   template<random_access_range _RARange = const _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const
-    noexcept(noexcept(ranges::begin(__derived())[__index]))
   {
     return ranges::begin(__derived())[__index];
   }
 };
 
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_VIEW_INTERFACE_H

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

 struct DataIsNull : std::ranges::view_interface<DataIsNull> {
   int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
   constexpr ContIter begin() const { return ContIter(buff); }
   constexpr ContIter end() const { return ContIter(buff + 8); }
   constexpr const int *data() const { return nullptr; }
 };
 static_assert(std::ranges::view<DataIsNull>);
 
-template<bool IsNoexcept>
-struct BoolConvertibleComparison : std::ranges::view_interface<BoolConvertibleComparison<IsNoexcept>> {
+struct BoolConvertibleComparison : std::ranges::view_interface<BoolConvertibleComparison> {
   struct ResultType {
     bool value;
-    constexpr operator bool() const noexcept(IsNoexcept) { return value; }
+    constexpr operator bool() const { return value; }
   };
 
   struct SentinelType {
     int *base_;
-    SentinelType() = default;
-    explicit constexpr SentinelType(int *base) : base_(base) {}
+    explicit SentinelType() = default;
+    constexpr explicit SentinelType(int *base) : base_(base) {}
     friend constexpr ResultType operator==(ForwardIter const& iter, SentinelType const& sent) noexcept { return {iter.base() == sent.base_}; }
     friend constexpr ResultType operator==(SentinelType const& sent, ForwardIter const& iter) noexcept { return {iter.base() == sent.base_}; }
     friend constexpr ResultType operator!=(ForwardIter const& iter, SentinelType const& sent) noexcept { return {iter.base() != sent.base_}; }
     friend constexpr ResultType operator!=(SentinelType const& sent, ForwardIter const& iter) noexcept { return {iter.base() != sent.base_}; }
   };
 
   int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
-  constexpr ForwardIter begin() const noexcept { return ForwardIter(const_cast<int*>(buff)); }
-  constexpr SentinelType end() const noexcept { return SentinelType(const_cast<int*>(buff) + 8); }
+  constexpr ForwardIter begin() const { return ForwardIter(const_cast<int*>(buff)); }
+  constexpr SentinelType end() const { return SentinelType(const_cast<int*>(buff) + 8); }
 };
-static_assert(std::ranges::view<BoolConvertibleComparison<true>>);
-static_assert(std::ranges::view<BoolConvertibleComparison<false>>);
+static_assert(std::ranges::view<BoolConvertibleComparison>);
 
 template<class T>
 concept EmptyInvocable = requires (T const& obj) { obj.empty(); };
 
 template<class T>
 concept BoolOpInvocable = requires (T const& obj) { bool(obj); };
 
 constexpr bool testEmpty() {
constexpr bool testEmpty() {
 
   assert(std::ranges::empty(emptyTrue));
   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;
-  LIBCPP_ASSERT_NOEXCEPT(boolConv.empty());
-  ASSERT_NOT_NOEXCEPT(boolConv2.empty());
+  BoolConvertibleComparison boolConv;
+  ASSERT_NOT_NOEXCEPT(boolConv.empty());
 
   assert(!boolConv.empty());
-  assert(!static_cast<BoolConvertibleComparison<true> const&>(boolConv).empty());
+  assert(!static_cast<const BoolConvertibleComparison&>(boolConv).empty());
 
   assert(boolConv);
-  assert(static_cast<BoolConvertibleComparison<true> const&>(boolConv));
+  assert(static_cast<const BoolConvertibleComparison&>(boolConv));
 
   assert(!std::ranges::empty(boolConv));
-  assert(!std::ranges::empty(static_cast<BoolConvertibleComparison<true> const&>(boolConv)));
+  assert(!std::ranges::empty(static_cast<const BoolConvertibleComparison&>(boolConv)));
 
   return true;
 }
 
 template<class T>
 concept DataInvocable = requires (T const& obj) { obj.data(); };
 
 constexpr bool testData() {