[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

     template <class U> using rebind = <details>;
 
     static pointer pointer_to(<details>);
+    static element_type* to_address(pointer p) noexcept;
 };
 
 template <class T>

     template <class U> using rebind = U*;
 
     static pointer pointer_to(<details>) noexcept;
+    static element_type* to_address(pointer p) noexcept;
 };
 
 template <class Alloc>

 
 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>

     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>

 #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>

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);
+}