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

[ldionne]

libcxx/docs/Cxx2aStatusIssuesStatus.csv

0–1

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

0–1

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

 "Issue #","Issue Name","Meeting","Status","First released version"
 "`2070 <https://wg21.link/LWG2070>`__","``allocate_shared``\  should use ``allocator_traits<A>::construct``\ ","Toronto","Resolved by `P0674R1 <https://wg21.link/P0674R1>`__",""
 "`2444 <https://wg21.link/LWG2444>`__","Inconsistent complexity for ``std::sort_heap``\ ","Toronto","",""
 "`2593 <https://wg21.link/LWG2593>`__","Moved-from state of Allocators","Toronto","",""
 "`2597 <https://wg21.link/LWG2597>`__","``std::log``\  misspecified for complex numbers","Toronto","",""
 "`2783 <https://wg21.link/LWG2783>`__","``stack::emplace()``\  and ``queue::emplace()``\  should return ``decltype(auto)``\ ","Toronto","|Complete|",""
 "`2932 <https://wg21.link/LWG2932>`__","Constraints on parallel algorithm implementations are underspecified","Toronto","",""
 "`2937 <https://wg21.link/LWG2937>`__","Is ``equivalent(""existing_thing"", ""not_existing_thing"")``\  an error","Toronto","|Complete|",""
 "`2940 <https://wg21.link/LWG2940>`__","``result_of``\  specification also needs a little cleanup","Toronto","",""

 "`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|","12.0"
 "`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;
 }