[libc++] [LWG3374] Mark `to_address(const Ptr& p)` overload `constexpr`.

[ldionne]

libcxx/docs/Cxx2aStatusIssuesStatus.csv

281

Is there a reason why we don't have a version of completion for LWG issues? It would be nice if we could say Complete|12.0 like we do for papers. WDYT?

[curdeius]

libcxx/docs/Cxx2aStatusIssuesStatus.csv

281

I was thinking about just when modifying this line... I'll add this new column before landing this patch.

[curdeius]

• Rebase with added version

[ldionne]

LGTM once CI passes. I think you fixed those issues already, right? If so, don't bother rebasing just to trigger CI, and just commit this. Thanks!

libcxx/docs/Cxx2aStatusIssuesStatus.csv

 "`3362 <https://wg21.link/LWG3362>`__","Strike ``stop_source``\ 's ``operator!=``\ ","Prague",""
 "`3363 <https://wg21.link/LWG3363>`__","``drop_while_view``\  should opt-out of ``sized_range``\ ","Prague",""
 "`3364 <https://wg21.link/LWG3364>`__","Initialize data members of ranges and their iterators","Prague",""
 "`3367 <https://wg21.link/LWG3367>`__","Integer-class conversions should not throw","Prague",""
 "`3369 <https://wg21.link/LWG3369>`__","``span``\ 's deduction-guide for built-in arrays doesn't work","Prague",""
 "`3371 <https://wg21.link/LWG3371>`__","``visit_format_arg``\  and ``make_format_args``\  are not hidden friends","Prague",""
 "`3372 <https://wg21.link/LWG3372>`__","``vformat_to``\  should not try to deduce ``Out``\  twice","Prague",""
 "`3373 <https://wg21.link/LWG3373>`__","``{to,from}_chars_result``\  and ``format_to_n_result``\  need the  ""we really mean what we say"" wording","Prague",""
-"`3374 <https://wg21.link/LWG3374>`__","P0653 + P1006 should have made the other ``std::to_address``\  overload ``constexpr``\ ","Prague",""
+"`3374 <https://wg21.link/LWG3374>`__","P0653 + P1006 should have made the other ``std::to_address``\  overload ``constexpr``\ ","Prague","|Complete|"
 "`3375 <https://wg21.link/LWG3375>`__","``decay``\  in ``viewable_range``\  should be ``remove_cvref``\ ","Prague",""
 "`3377 <https://wg21.link/LWG3377>`__","``elements_view::iterator``\  befriends a specialization of itself","Prague",""
 "`3379 <https://wg21.link/LWG3379>`__","""``safe``\ "" in several library names is misleading","Prague",""
 "`3380 <https://wg21.link/LWG3380>`__","``common_type``\  and comparison categories","Prague",""
 "`3381 <https://wg21.link/LWG3381>`__","``begin``\  and ``data``\  must agree for ``contiguous_range``\ ","Prague",""
 "`3382 <https://wg21.link/LWG3382>`__","NTTP for ``pair``\  and ``array``\ ","Prague",""
 "`3383 <https://wg21.link/LWG3383>`__","|sect|\ [time.zone.leap.nonmembers] ``sys_seconds``\  should be replaced with ``seconds``\ ","Prague",""
 "`3384 <https://wg21.link/LWG3384>`__","``transform_view::*sentinel*``\  has an incorrect ``operator-``\ ","Prague",""

libcxx/include/memory

struct pointer_traits<T*>
     typedef ptrdiff_t difference_type;
 
     template <class U> using rebind = U*;
 
     static pointer pointer_to(<details>) noexcept; // constexpr in C++20
 };
 
 template <class T> constexpr T* to_address(T* p) noexcept; // C++20
-template <class Ptr> auto to_address(const Ptr& p) noexcept; // C++20
+template <class Ptr> constexpr auto to_address(const Ptr& p) noexcept; // C++20
 
 template <class Alloc>
 struct allocator_traits
 {
     typedef Alloc                        allocator_type;
     typedef typename allocator_type::value_type
                                          value_type;
 

 _Tp*
 to_address(_Tp* __p) _NOEXCEPT
 {
     static_assert(!is_function_v<_Tp>, "_Tp is a function type");
     return __p;
 }
 
 template <class _Pointer>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY constexpr
 auto
 to_address(const _Pointer& __p) _NOEXCEPT
 {
     return _VSTD::__to_address(__p);
 }
 #endif
 
 template <class _Tp, class = void>

libcxx/test/std/utilities/memory/pointer.conversion/to_address.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template <class T> constexpr T* to_address(T* p) noexcept;
-// template <class Ptr> auto to_address(const Ptr& p) noexcept;
+// template <class Ptr> constexpr auto to_address(const Ptr& p) noexcept;
 
 #include <memory>
 #include <cassert>
 #include "test_macros.h"
 
 class P1
 {
 public:
     using element_type = int;
 
-    explicit P1(int* p)
+    constexpr explicit P1(int* p)
     : p_(p) { }
 
-    int* operator->() const noexcept
+    constexpr int* operator->() const noexcept
     { return p_; }
 
 private:
     int* p_;
 };
 
 class P2
 {
 public:
     using element_type = int;
 
-    explicit P2(int* p)
+    constexpr explicit P2(int* p)
     : p_(p) { }
 
-    P1 operator->() const noexcept
+    constexpr P1 operator->() const noexcept
     { return p_; }
 
 private:
     P1 p_;
 };
 
 class P3
 {
 public:
-    explicit P3(int* p)
+    constexpr explicit P3(int* p)
     : p_(p) { }
 
-    int* get() const noexcept
+    constexpr int* get() const noexcept
     { return p_; }
 
 private:
     int* p_;
 };
 
 namespace std
 {
 template<>
 struct pointer_traits<::P3>
 {
-    static int* to_address(const ::P3& p) noexcept
+    static constexpr int* to_address(const ::P3& p) noexcept
     { return p.get(); }
 };
 }
 
 class P4
 {
 public:
-    explicit P4(int* p)
+    constexpr explicit P4(int* p)
     : p_(p) { }
 
-    int* operator->() const noexcept
+    constexpr int* operator->() const noexcept
     { return nullptr; }
 
-    int* get() const noexcept
+    constexpr int* get() const noexcept
     { return p_; }
 
 private:
     int* p_;
 };
 
 namespace std
 {
 template<>
 struct pointer_traits<::P4>
 {
-    static int* to_address(const ::P4& p) noexcept
+    constexpr static int* to_address(const ::P4& p) noexcept
     { return p.get(); }
 };
 }
 
 int n = 0;
 static_assert(std::to_address(&n) == &n);
 
-int main(int, char**)
-{
-    int i = 0;
-    ASSERT_NOEXCEPT(std::to_address(&i));
-    assert(std::to_address(&i) == &i);
-    P1 p1(&i);
-    ASSERT_NOEXCEPT(std::to_address(p1));
-    assert(std::to_address(p1) == &i);
-    P2 p2(&i);
-    ASSERT_NOEXCEPT(std::to_address(p2));
-    assert(std::to_address(p2) == &i);
-    P3 p3(&i);
-    ASSERT_NOEXCEPT(std::to_address(p3));
-    assert(std::to_address(p3) == &i);
-    P4 p4(&i);
-    ASSERT_NOEXCEPT(std::to_address(p4));
-    assert(std::to_address(p4) == &i);
+constexpr bool test() {
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
   return 0;
 }