[libcxx] Implement std::to_address for C++20

[glenjofe]

Summary

Now implements P0653R2 - Utility to convert to raw pointer.

[glenjofe]

Include full context in the diff.

[mclow.lists]

This feature has not been added to the draft standard yet, so I'm reluctant to add it to libc++.

I appreciate the patch, and we may adopt it in the future, but not now.

[glenjofe]

Now implements P0653R2 which was accepted in Albuquerque.

[EricWF]

Initially this LGTM. I'll take another pass in the morning.

include/memory

1096

Just make this unconditionally constexpr.

test/std/utilities/memory/pointer.conversion/to_address.pass.cpp

100 ↗

(On Diff #123520)

Could you add some tests that run at compile time using static_assert.

Also, could you verify the functions are correctly marked noexcept using ASSERT_NOEXCEPT from test_macros.h?

[glenjofe]

Address Eric's review comments.

[EricWF]

test/std/utilities/memory/pointer.conversion/to_address.pass.cpp

119 ↗

(On Diff #123531)

Shouldn't one of these tests hit a non-noexcept function?

[glenjofe]

test/std/utilities/memory/pointer.conversion/to_address.pass.cpp

119 ↗

(On Diff #123531)

Both overloads of to_address are unconditionally noexcept.

[glenjofe]

Thanks Eric. Can you commit on my behalf?

include/memory

 {
     typedef Ptr pointer;
     typedef <details> element_type;
     typedef <details> difference_type;
 
     template <class U> using rebind = <details>;
 
     static pointer pointer_to(<details>);
+    static element_type* to_address(pointer p) noexcept;
 };
 
 template <class T>
 struct pointer_traits<T*>
 {
     typedef T* pointer;
     typedef T element_type;
     typedef ptrdiff_t difference_type;
 
     template <class U> using rebind = U*;
 
     static pointer pointer_to(<details>) noexcept;
+    static element_type* to_address(pointer p) noexcept;
 };
 
 template <class Alloc>
 struct allocator_traits
 {
     typedef Alloc                        allocator_type;
     typedef typename allocator_type::value_type
                                          value_type;
#ifndef _LIBCPP_CXX03_LANG
     template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type;
 #else
     template <class _Up> struct rebind
         {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;};
 #endif  // _LIBCPP_CXX03_LANG
 
 private:
     struct __nat {};
+
+    template <class _Tp>
+        _LIBCPP_INLINE_VISIBILITY
+        static element_type* __to_address(_Tp __p) _NOEXCEPT
+            {return pointer_traits<_Tp>::to_address(__p);}
 public:
     _LIBCPP_INLINE_VISIBILITY
     static pointer pointer_to(typename conditional<is_void<element_type>::value,
                                            __nat, element_type>::type& __r)
         {return pointer::pointer_to(__r);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    static element_type* to_address(pointer __p) _NOEXCEPT
+        {return __to_address(__p.operator->());}
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*>
 {
     typedef _Tp*      pointer;
     typedef _Tp       element_type;
     typedef ptrdiff_t difference_type;
 
 #ifndef _LIBCPP_CXX03_LANG
     template <class _Up> using rebind = _Up*;
 #else
     template <class _Up> struct rebind {typedef _Up* other;};
 #endif
 
 private:
     struct __nat {};
 public:
     _LIBCPP_INLINE_VISIBILITY
     static pointer pointer_to(typename conditional<is_void<element_type>::value,
                                       __nat, element_type>::type& __r) _NOEXCEPT
         {return _VSTD::addressof(__r);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    static element_type* to_address(pointer __p) _NOEXCEPT {return __p;}
 };
 
 template <class _From, class _To>
 struct __rebind_pointer {
 #ifndef _LIBCPP_CXX03_LANG
     typedef typename pointer_traits<_From>::template rebind<_To>        type;
 #else
     typedef typename pointer_traits<_From>::template rebind<_To>::other type;
struct __has_const_void_pointer<_Tp,
             typename __void_t<typename _Tp::const_void_pointer>::type> : true_type {};
 
 template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value>
 struct __const_void_pointer
 {
     typedef typename _Alloc::const_void_pointer type;
 };
 
 template <class _Ptr, class _Alloc>
 struct __const_void_pointer<_Ptr, _Alloc, false>
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef typename pointer_traits<_Ptr>::template rebind<const void> type;
 #else
     typedef typename pointer_traits<_Ptr>::template rebind<const void>::other type;
 #endif
 };
 
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp*
-__to_raw_pointer(_Tp* __p) _NOEXCEPT
-{
-    return __p;
-}
-
 template <class _Pointer>
 inline _LIBCPP_INLINE_VISIBILITY
 typename pointer_traits<_Pointer>::element_type*
 __to_raw_pointer(_Pointer __p) _NOEXCEPT
 {
-    return _VSTD::__to_raw_pointer(__p.operator->());
+    return pointer_traits<_Pointer>::to_address(__p);
 }
 
 template <class _Tp, class = void>
 struct __has_size_type : false_type {};
 
 template <class _Tp>
 struct __has_size_type<_Tp,
                typename __void_t<typename _Tp::size_type>::type> : true_type {};

test/std/utilities/memory/pointer.traits/pointer.traits.functions/to_address.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// element_type* pointer_traits::to_address(pointer p) noexcept;
+
+#include <memory>
+#include <cassert>
+
+struct P1
+{
+  typedef int element_type;
+  int* value;
+  explicit P1(int* ptr) noexcept : value(ptr) { }
+  int* operator->() const noexcept { return value; }
+};
+
+struct P2
+{
+  typedef P1::element_type element_type;
+  P1 value;
+  explicit P2(P1 ptr) noexcept : value(ptr) { }
+  P1 operator->() const noexcept { return value; }
+};
+
+int main()
+{
+    int i = 0;
+    P1 p1(&i);
+    assert(std::pointer_traits<P1>::to_address(p1) == &i);
+    P2 p2(p1);
+    assert(std::pointer_traits<P2>::to_address(p2) == &i);
+}

test/std/utilities/memory/pointer.traits/to_address.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// element_type* pointer_traits<T*>::to_address(pointer p) noexcept;
+
+#include <memory>
+#include <cassert>
+
+int main()
+{
+    int i = 0;
+    assert(std::pointer_traits<int*>::to_address(&i) == &i);
+    assert(std::pointer_traits<const int*>::to_address(&i) == &i);
+    assert(std::pointer_traits<void*>::to_address(&i) == &i);
+}