[libc++] Fix the noexceptness of __decay_copy.

[• Quuxplusone]

Summary

When a was an array type, __decay_copy(a) was incorrectly marking itself noexcept(false), because it is false that int[10] is nothrow convertible to int[10] (in fact it is not convertible at all).

We have no tests explicitly for __decay_copy, but the new ranges::begin and ranges::end tests fail before this patch.

[• Quuxplusone]

libcxx/include/__utility/decay_copy.h

27

Actually, it occurs to me that several things are probably wrong here and we should just fix them all at once.

• We don't care about convertible but rather constructible.
• We should be returning decay_t<_Tp>(static_cast<_Tp&&>(__t)), not simply static_cast<_Tp&&>(__t).
• We should be noexcept'ing on the same expression.
• We should just go ahead and make this a full "write it three times" function, so that __decay_copy(mymutex) SFINAEs away instead of pretending it exists and then hard-erroring during instantiation.
• In C++23, DECAY_COPY is changing over to auto(x), which doesn't call move constructors when you pass it a prvalue, so we'll need something else anyway. How about we just make a macro like this?

#if PRESENT_DAY
 #define _LIBCPP_DECAY_COPY(x) static_cast<typename decay<decltype((x))>::type>(x)
#else
 #define _LIBCPP_DECAY_COPY(x) auto(x)
#endif

and replace all our usages throughout the codebase right now?

I have a vested interest because D115607 adds a ton of __decay_copy calls. :)

[ldionne]

libcxx/include/__utility/decay_copy.h

27

http://eel.is/c++draft/expos.only.func#lib:decay-copy is pretty clear on what it's doing. The change from convertible-to to constructible-from seems like a functional change to me.

Is this function somehow not implementing the exposition-only function I linked? If not, you know what I'm going to say. It might be boring, but we're not here to change the design of the standard, we're here to implement it.

libcxx/include/__utility/decay_copy.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 typename decay<_Tp>::type __decay_copy(_Tp&& __t)
 #if _LIBCPP_STD_VER > 17
-    noexcept(is_nothrow_convertible_v<_Tp, remove_reference_t<_Tp>>)
+    noexcept(is_nothrow_convertible_v<_Tp, decay_t<_Tp>>)
 #endif
 {
   return _VSTD::forward<_Tp>(__t);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___UTILITY_DECAY_COPY_H

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

struct NoThrowADLBegin {
   friend T begin(NoThrowADLBegin&) noexcept { return T{}; }
   friend T begin(NoThrowADLBegin const&) noexcept { return T{}; }
 };
 ASSERT_NOEXCEPT(std::ranges::begin(std::declval<NoThrowADLBegin<int*>&>()));
 ASSERT_NOEXCEPT(std::ranges::cbegin(std::declval<NoThrowADLBegin<int*>&>()));
 ASSERT_NOT_NOEXCEPT(std::ranges::begin(std::declval<NoThrowADLBegin<ThrowingIterator<int>>&>()));
 ASSERT_NOT_NOEXCEPT(std::ranges::cbegin(std::declval<NoThrowADLBegin<ThrowingIterator<int>>&>()));
 
+struct BeginReturnsArrayRef {
+    auto begin() const noexcept -> int(&)[10];
+    auto end() const noexcept -> int(&)[10];
+} brar;
+static_assert(noexcept(std::ranges::begin(brar)));
+static_assert(noexcept(std::ranges::cbegin(brar)));
+
 
 int main(int, char**) {
   testArray();
   static_assert(testArray());
 
   testBeginMember();
   static_assert(testBeginMember());
 
   testBeginFunction();
   static_assert(testBeginFunction());
 
   return 0;
 }

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

struct NoThrowADLEnd {
   friend T end(NoThrowADLEnd&) noexcept { return T{}; }
   friend T end(NoThrowADLEnd const&) noexcept { return T{}; }
 };
 ASSERT_NOEXCEPT(std::ranges::end(std::declval<NoThrowADLEnd<int*>&>()));
 ASSERT_NOEXCEPT(std::ranges::cend(std::declval<NoThrowADLEnd<int*>&>()));
 ASSERT_NOT_NOEXCEPT(std::ranges::end(std::declval<NoThrowADLEnd<ThrowingIterator<int>>&>()));
 ASSERT_NOT_NOEXCEPT(std::ranges::cend(std::declval<NoThrowADLEnd<ThrowingIterator<int>>&>()));
 
+struct BeginReturnsArrayRef {
+    auto begin() const noexcept -> int(&)[10];
+    auto end() const noexcept -> int(&)[10];
+} brar;
+static_assert(noexcept(std::ranges::end(brar)));
+static_assert(noexcept(std::ranges::cend(brar)));
+
 
 int main(int, char**) {
   testArray();
   static_assert(testArray());
 
   testEndMember();
   static_assert(testEndMember());
 
   testEndFunction();
   static_assert(testEndFunction());
 
   return 0;
 }