Add is_nothrow_convertible (P0758R1)

[zoecarver]

Summary

Add both is_nothrow_convertible and is_nothrow_convertible_v according to P0758R1.

[ldionne]

include/type_traits

1594

Should be __is_nothrow_convertible_helper instead.

test/libcxx/type_traits/is_nothrow_convertible.pass.cpp

2 ↗

(On Diff #186171)

This should be test/std/type_traits/is_nothrow_convertible.pass.cpp because it's not a libc++ specific behavior.

31 ↗

(On Diff #186171)

Those should be static_asserts.

41 ↗

(On Diff #186171)

You have tests where To and From are complete types. Please add tests for:

• cv void types
• arrays of unknown bounds
• arrays of known bounds
• function types

[ldionne]

Actually, I'm looking at this and std::is_convertible again, and I think this should be using std::is_convertible in the implementation. I know the paper suggests the implementation in this patch, however it's unclear to me whether that implementation properly handles all the cases that std::is_convertible handles (notably with references). Also, using std::is_convertible under the hood means that we will use the __is_convertible_to intrinsic when it's available instead.

I would do something like this instead (untested):

template <typename _Fm, typename _To>
struct __is_nothrow_convertible_impl {
private:
    template <typename _Tp>
    static void __test_noexcept(_Tp) noexcept;
    
    template<typename __Fm, typename __To>
    static bool_constant<noexcept(__test_noexcept<__To>(declval<__Fm>()))>
    __test(int);
    
    template<typename, typename>
    static false_type
    __test(...);
    
public:
    using type = decltype(__test<_Fm, _To>(0));
};

template <typename _Fm, typename _To>
struct is_nothrow_convertible : __and_<is_convertible<_Fm, _To>, __is_nothrow_convertible_impl<_Fm, _To>>
{ };

This is very similar to what you have, but I also guard the whole thing with std::is_convertible. What do you think? Did I miss a subtlety that would make my draft implementation wrong (that's quite possible)?

[zoecarver]

@ldionne That looks good. I played around with using std::conditional for a while but I think your implementation is the cleanest.

[ldionne]

include/type_traits

1591

I don't think this is useful anymore, as this should be handled by std::is_convertible. IOW, I think only the test for noexcept-ness of the conversion needs to exist, not for convertibility.

[zoecarver]

include/type_traits

1591

Good catch, you're completely right. In fact, we could probably simplify this a lot and just have it use is_nothrow_constructible<_Fm, _To>. I am a bit hesitant to do that because it isn't what is_nothrow_constructible's intended use is, what do you think?

[zoecarver]

include/type_traits

1591

Actually correction: void will not work in the below __test_noexcept method so it has to have its own overload. But I can get rid of the is_array/is_function checks (because those will be caught by std::is_convertible).

[zoecarver]

@ldionne just for reference, this is what it would look like to use is_nothrow_constructible:

template <typename _Fm, typename _To>
struct is_nothrow_convertible : __and_<
    is_convertible<_Fm, _To>,
    __libcpp_is_nothrow_constructible<true, true, _Fm, _To>
>::type { };

[ldionne]

In D58019#1395157, @zoecarver wrote:

@ldionne just for reference, this is what it would look like to use is_nothrow_constructible:

template <typename _Fm, typename _To>
struct is_nothrow_convertible : __and_<
    is_convertible<_Fm, _To>,
    __libcpp_is_nothrow_constructible<true, true, _Fm, _To>
>::type { };

Right -- I'd rather we reimplement the checking ourselves instead of relying on __libcpp_is_nothrow_constructible<true, true, _Fm, _To> (where we'd be lying about the reference-ness of _To.

include/type_traits

1591

Makes sense, see my suggestion below. I don't think we can use is_nothrow_constructible, since the check for non-reference types is:

integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>

That's not checking whether the conversion operator is noexcept, only a constructor.

1619

How about this:

__or<
  __and_<is_void<_Fm>, is_void<_To>>,
  __and<is_convertible<_Fm, _To>, __is_nothrow_convertible_helper<_Fm, _To>>
>

And then __is_nothrow_convertible_helper doesn't have to care about void.

[zoecarver]

Sounds good, that is probably the better call.

include/type_traits

1591

Fair point, didn't think about that.

1619

Thanks @ldionne, that is great. After all the tests pass I will upload the new patch.

[ldionne]

This is looking better and better.

include/type_traits

1596

The rule is usually 1 underscore followed by a capital letter, or 2 underscores followed by a small letter. For template parameters, we use the former. Here you have 2 underscores followed by a capital.

This is pedantic, but since you're a new contributor, we might as well start on the right foot.

1597

You can hoist this helper function and its friend above outside of the class. This way you don't get an instantiation of __test_noexcept<_Tp> for each pair of _To and _From, only one for each type. You'll still get an instantiation of __test for each pair of _To and _From, but at least you don't need to play games with the names of the template parameters if you hoist the function outside the class.

1600

I don't think you need this overload anymore. Indeed, you already know that _Fm is convertible to _To because you checked with std::is_convertible.

test/std/type_traits/is_nothrow_convertible.pass.cpp

16

I think you don't need this header.

[zoecarver]

Thanks for all the help :)

include/type_traits

1597

Good idea. I also simply inherit from decltype instead of having the type member. Much cleaner.

1600

Your right.

test/std/type_traits/is_nothrow_convertible.pass.cpp

16

Correct.

[zoecarver]

@ldionne Friendly ping I think this is done?

[ldionne]

Sorry, I was at a Committee meeting. It looks like you need to update the synopsis comment at the top of file, and also update cxx2a_status.html. But I think this looks good apart from that.

[zoecarver]

Update synopsis comment and www.

[zoecarver]

@ldionne No worries, hope the committee meeting went well. Fixed both of those. This patch was definitely the most fun to write :)

[ldionne]

include/type_traits

149

Use From and To here too. Also, please add a // C++17 comment for both of them.

[zoecarver]

include/type_traits

149

// C++20, right?

[zoecarver]

Fix comment (// C++20 and To/From)

[ldionne]

include/type_traits

149

Uh, yes. Oops.

[ldionne]

Committed as r355010.

Thanks for the patch!

test/std/type_traits/is_nothrow_convertible.pass.cpp

51

Watch for trailing whitespace like this (I removed it when applying the patch). You can probably configure your editor to remove it automatically.

[zoecarver]

@ldionne Awesome! Thank you for the help.

test/std/type_traits/is_nothrow_convertible.pass.cpp

51

Thank you, I will keep an eye out for these.

include/type_traits

namespace std
     template <class T> struct has_virtual_destructor;
 
     template<class T> struct has_unique_object_representations;         // C++17
 
     // Relationships between types:
     template <class T, class U> struct is_same;
     template <class Base, class Derived> struct is_base_of;
     template <class From, class To> struct is_convertible;
  
+    template <typename From, typename To> struct is_nothrow_convertible; // C++20
+    template <typename From, typename To> inline constexpr bool is_nothrow_convertible_v; // C++20
+ 
+
     template <class Fn, class... ArgTypes> struct is_invocable;
     template <class R, class Fn, class... ArgTypes> struct is_invocable_r;
 
     template <class Fn, class... ArgTypes> struct is_nothrow_invocable;
     template <class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
 
     // Alignment properties and transformations:
     template <class T> struct alignment_of;

 #endif  // __has_feature(is_convertible_to)
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _From, class _To>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_convertible_v
     = is_convertible<_From, _To>::value;
 #endif
 
+// is_nothrow_convertible
+
+#if _LIBCPP_STD_VER > 17
+
+template <typename _Tp>
+static void __test_noexcept(_Tp) noexcept;
+
+template<typename _Fm, typename _To>
+static bool_constant<noexcept(__test_noexcept<_To>(declval<_Fm>()))>
+__is_nothrow_convertible_test();
+
+template <typename _Fm, typename _To>
+struct __is_nothrow_convertible_helper: decltype(__is_nothrow_convertible_test<_Fm, _To>())
+{ };
+
+template <typename _Fm, typename _To>
+struct is_nothrow_convertible : __or_<
+    __and_<is_void<_To>, is_void<_Fm>>,
+    __and_<is_convertible<_Fm, _To>, __is_nothrow_convertible_helper<_Fm, _To>>
+>::type { };
+
+template <typename _Fm, typename _To>
+inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<_Fm, _To>::value;
+
+#endif // _LIBCPP_STD_VER > 17
+
 // is_empty
 
 #if __has_feature(is_empty) || (_GNUC_VER >= 407)
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_empty
     : public integral_constant<bool, __is_empty(_Tp)> {};
 
 #else  // __has_feature(is_empty)
 
 template <class _Tp>
 struct __is_empty1
     : public _Tp
 {
     double __lx;
 };
 

test/std/type_traits/is_nothrow_convertible.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+
+// <type_traits>
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+#include <type_traits>
+
+struct A {};
+struct B {
+public:
+    operator A() { return a; } A a;
+};
+
+class C { };
+class D {
+public:
+    operator C() noexcept { return c; } C c;
+};
+
+int main(int, char**) {
+    static_assert((std::is_nothrow_convertible<int, double>::value), "");
+    static_assert(!(std::is_nothrow_convertible<int, char*>::value), "");
+    
+    static_assert(!(std::is_nothrow_convertible<A, B>::value), "");
+    static_assert((std::is_nothrow_convertible<D, C>::value), "");
+    
+    static_assert((std::is_nothrow_convertible_v<int, double>), "");
+    static_assert(!(std::is_nothrow_convertible_v<int, char*>), "");
+    
+    static_assert(!(std::is_nothrow_convertible_v<A, B>), "");
+    static_assert((std::is_nothrow_convertible_v<D, C>), "");
+    
+    static_assert((std::is_nothrow_convertible_v<const void, void>), "");
+    static_assert((std::is_nothrow_convertible_v<volatile void, void>), "");
+    static_assert((std::is_nothrow_convertible_v<void, const void>), "");
+    static_assert((std::is_nothrow_convertible_v<void, volatile void>), "");
+    
+    static_assert(!(std::is_nothrow_convertible_v<int[], double[]>), "");
+    static_assert(!(std::is_nothrow_convertible_v<int[], int[]>), "");
+    static_assert(!(std::is_nothrow_convertible_v<int[10], int[10]>), "");
+    static_assert(!(std::is_nothrow_convertible_v<int[10], double[10]>), "");
+    static_assert(!(std::is_nothrow_convertible_v<int[5], double[10]>), "");
+    static_assert(!(std::is_nothrow_convertible_v<int[10], A[10]>), "");
+    
+    typedef void V();
+    typedef int I();
+    static_assert(!(std::is_nothrow_convertible_v<V, V>), "");
+    static_assert(!(std::is_nothrow_convertible_v<V, I>), "");
+    
+    return 0;
+}

www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P0475R1">P0475R1</a></td><td>LWG</td><td>LWG 2511: guaranteed copy elision for piecewise construction</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0476R2">P0476R2</a></td><td>LWG</td><td>Bit-casting object representations</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0528R3">P0528R3</a></td><td>CWG</td><td>The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0542R5">P0542R5</a></td><td>CWG</td><td>Support for contract based programming in C++</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0556R3">P0556R3</a></td><td>LWG</td><td>Integral power-of-2 operations</td><td>Rapperswil</td><td><i>In Progress</i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0619R4">P0619R4</a></td><td>LWG</td><td>Reviewing Deprecated Facilities of C++17 for C++20</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0646R1">P0646R1</a></td><td>LWG</td><td>Improving the Return Value of Erase-Like Algorithms</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0722R3">P0722R3</a></td><td>CWG</td><td>Efficient sized delete for variable sized classes</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0758R1">P0758R1</a></td><td>LWG</td><td>Implicit conversion traits and utility functions</td><td>Rapperswil</td><td></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0758R1">P0758R1</a></td><td>LWG</td><td>Implicit conversion traits and utility functions</td><td>Rapperswil</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0759R1">P0759R1</a></td><td>LWG</td><td>fpos Requirements</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0769R2">P0769R2</a></td><td>LWG</td><td>Add shift to &lt;algorithm&gt;</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0788R3">P0788R3</a></td><td>LWG</td><td>Standard Library Specification in a Concepts and Contracts World</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0879R0">P0879R0</a></td><td>LWG</td><td>Constexpr for swap and swap related functions Also resolves LWG issue 2800.</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0887R1">P0887R1</a></td><td>LWG</td><td>The identity metafunction</td><td>Rapperswil</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P0892R2">P0892R2</a></td><td>CWG</td><td>explicit(bool)</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0898R3">P0898R3</a></td><td>LWG</td><td>Standard Library Concepts</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0935R0">P0935R0</a></td><td>LWG</td><td>Eradicating unnecessarily explicit default constructors from the standard library</td><td>Rapperswil</td><td></td><td></td></tr>