[libc++] Implement P2273R3 (`constexpr` `unique_ptr`)

[fsb4000]

add more _LIBCPP_CONSTEXPR_CXX23

[fsb4000]

skip failed checks in compile time.

and I will continue modifying other unique_ptr tests.

[philnik]

Thanks for working on this! This obviously needs more testing. I've got a few nit-picks, otherwise the diff looks good for now.

libcxx/include/__memory/unique_ptr.h

48–49

I'd prefer it if you leave the operator() on the same line.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp

53–56

[fsb4000]

I added some constexpr tests.

But many tests are not constexpr friendly and I don't know how to fix them :(

Not full list:

unique.ptr.special/eq.pass.cpp
unique.ptr.special/rel.pass.cpp
unique.ptr.special/swap.pass.cpp

unique.ptr.dltr.dflt1/default.pass.cpp
unique.ptr.dltr.dflt1/convert_ctor.pass.cpp

unique.ptr.dltr.dflt/default.pass.cpp
unique.ptr.dltr.dflt/convert_ctor.pass.cpp

unique.ptr.class/pointer_type.pass.cpp only static_asserts

unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp

/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp
/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp

/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp

They use static variables and sometimes global variables...

[fsb4000]

fix one nit-pick

[fsb4000]

It seems my clang-format 14 is too old or I use it wrong.

I use

$ llvm-project\libcxx\clang-format -i file_name.cpp

Do you use clang-format 15 or 16?

[fsb4000]

rebase

[Mordante]

Thanks for working on this! Since the patch is marked as WIP I didn't validate everything, but in general it looks fine. However the formatting changes make it a bit hard to see all relevant changes.

libcxx/include/__memory/unique_ptr.h

31

Please also update the synopsis in memory to mention the addition of constexpr.

36

In general we only format the changes in the diff instead of the entire file. That makes reviewing a bit easier.
(Unlike MSVC STL we (IMO unfortunately) haven't applied clang-format to our entire code base.)

567

This isn't used in C++23.

607

You missed this one after rebasing

617

The three operators here are also not used in C++23

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp

105–108

We normally ignore the result of these tests except when we use it in a static_assert. Basically we use static_assert to force compile-time evaluation.

[fsb4000]

I updated the synopsis in memory to mention the addition of constexpr and rewrote my changes of unique_ptr.h without clang-format

[fsb4000]

ignore the result of these tests except when we use it in a static_assert

[fsb4000]

I renamed the revision but I'm still unsure if these tests are enough.

libcxx/include/__memory/unique_ptr.h

36

Yes, sorry :(
I updated unique_ptr.h without clang-format so it should be easier for review now.

[fsb4000]

fix test

[fsb4000]

libcxx\test\std\utilities\smartptr\unique.ptr\unique.ptr.create\make_unique.sizezero.pass.cpp is not constexpr friendly.

[Mordante]

SGTM, but some requests remain, once done I'll have a closer look; probably next weekend.

libcxx/include/memory

409

We normally add the constexpr to the wording too, that way the wording in the synopsis matches the Standard. (Except we don't remove entries.)

libcxx/test/support/test_comparisons.h

32

Can you mention what changed in this file?

[fsb4000]

revert test_comparisons.h changes and add constexpr in comments.

[fsb4000]

one more comment change.

[fsb4000]

add Microsoft STL test.

[fsb4000]

move => std::move

[fsb4000]

rerun tests

[Mordante]

While checking I missed several tests, but it seems you mentioned that.

In D131315#3704130, @fsb4000 wrote:

I added some constexpr tests.

But many tests are not constexpr friendly and I don't know how to fix them :(

Not full list:

/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp

They use static variables and sometimes global variables...

I have looked at a solution and for the reset test I've created a fix. This basically removes the parts that can't be tested in a constexpr way; in this case a static class member. So this means our coverage during constant evaluation is a bit lower, but we can still test the basics. (We've done this in other tests too.) Maybe some day when the constexpr restrictions will be reduced further we can then re-enable these tests.

I've tested my patch locally with all supported language standards, feel free to use this in your patch.
http://paste.debian.net/1250391/

(I want to validate this patch against the paper when all tests are done.)

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/constexpr.pass.cpp

9 ↗

(On Diff #452384)

I would propose a different way to include this test, in a similar fashion we did with the charconv tests

• make a subdirectory p2273r3.msvc
• rename this file to test.compile.cpp and remove all libc++ specifics (except for the overwrite when it doesn't compile) like the EDG work-arounds
• add a test.compile.pass.cpp that has the libc++ specific which includes test.compile.cpp, in a similar fashion as like test/std/utilities/charconv/charconv.msvc/test.pass.cpp

This means the diff between us and MSVC STL remains minimal. (I still want to look at using more MSVC STL tests in the future, but that's very low on my priority list.)

142 ↗

(On Diff #452384)

I wonder whether that's needed, but I'll ask the MSVC STL team, we don't use it for compile-time only tests.

[fsb4000]

Rebase and fix conflicts.
Also rename constexpr.pass.cpp to constexpr.compile.pass.cpp and add comment "// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20"

[fsb4000]

add more tests and move the msvc test to unique.ptr.msvc folder.

[fsb4000]

add missing newline to the end of some files.

[fsb4000]

_LIBCPP_CONSTEXPR_CXX23 => _LIBCPP_CONSTEXPR_SINCE_CXX23

[fsb4000]

fix -Wunreachable-code warning

[fsb4000]

refactor tests a bit.

[Mordante]

In general LGTM but several minor issue.
When you update the patch please do *not* rebase. That makes it a lot easier to just view the diff.

libcxx/docs/Status/Cxx2bPapers.csv

47

Can you add a note that make_unique_for_overwrite isn't done yet since P1020 hasn't been implemented yet.

libcxx/include/memory

437

Nice catch!

478

It seems

template<class U, class E>
  constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;

is missing. In general this section seems to already miss template<class U>.

485–486

Pre existing issue: here too seems to be a member to be missing.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp

13

Please update the synopsis. Also validate the other tests please.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp

16

There's no assert added.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp

21 ↗

(On Diff #454866)

26–33 ↗

(On Diff #454866)

Combined with setting the default value to 0 this seems easier to read.
Before C++23 the code will never be constant evaluated.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp

42 ↗

(On Diff #454866)

Please add return 0;.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp

37 ↗

(On Diff #454866)

Please add return 0;.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp

36

Please add return 0;.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp

39 ↗

(On Diff #454866)

Please add return 0;.

[fsb4000]

code review from Mordante

[fsb4000]

rebase

[fsb4000]

fix code formatting

[fsb4000]

compatibility with C++03

[fsb4000]

rebase after forward_likepatch was commited.
Fix conflict at libcxx\docs\ReleaseNotes.rst

[fsb4000]

forward_like.msvc tests CRLF => LF

[fsb4000]

rebase because https://github.com/llvm/llvm-project/commit/ff06c2ded367d71eee6e879b4c9934af35d7a7e8 already fixed one file.

[Mordante]

Thanks a lot, LGTM! One small remark remaining, but not really related to this patch itself.

libcxx/test/std/utilities/utility/forward_like/forward_like.msvc/test.pass.cpp

1 ↗

(On Diff #457776)

This file is already fixed in main.

[ldionne]

Thanks for the patch. I just stumbled on this and noticed that it was adding the MSVC test. In general, let's try to write our tests ourselves and keep them consistent with the libc++ testing style. This avoids falling into a trap where all implementations could have the same issue because they all use the same tests. This comment doesn't apply for significant things like std::to_chars that we literally copied the implementation from MSVC, however in this case it's pretty simple.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_associative_heterogeneous_erasure``   *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_bind_back``                           *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_byteswap``                            ``202110L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_cmath``                     *unimplemented*
     ------------------------------------------------- -----------------
+    ``__cpp_lib_constexpr_memory``                    ``202202L``
+    ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_typeinfo``                  *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_invoke_r``                            *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_scoped_enum``                      ``202011L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_move_only_function``                  *unimplemented*
     ------------------------------------------------- -----------------

libcxx/docs/ReleaseNotes.rst

 see the `releases page <https://llvm.org/releases/>`_.
 
 What's New in Libc++ 16.0.0?
 ============================
 
 Implemented Papers
 ------------------
 - P2499R0 - ``string_view`` range constructor should be ``explicit``
+- P2273R3 - Making ``std::unique_ptr`` constexpr
 
 Improvements and New Features
 -----------------------------
 
 Deprecations and Removals
 -------------------------
 
 Upcoming Deprecations and Removals
 ----------------------------------
 
 ABI Affecting Changes
 ---------------------
 
 Build System Changes
 --------------------

libcxx/docs/Status/Cxx2bPapers.csv

 "`P2401R0 <https://wg21.link/P2401R0>`__","LWG","Add a conditional ``noexcept`` specification to ``std::exchange``","October 2021","|Complete|","14.0"
 "","","","","",""
 "`P0323R12 <https://wg21.link/P0323R12>`__","LWG","``std::expected``","February 2022","",""
 "`P0533R9 <https://wg21.link/P0533R9>`__","LWG","``constexpr`` for ``<cmath>`` and ``<cstdlib>``","February 2022","",""
 "`P0627R6 <https://wg21.link/P0627R6>`__","LWG","Function to mark unreachable code","February 2022","|Complete|","15.0"
 "`P1206R7 <https://wg21.link/P1206R7>`__","LWG","``ranges::to``: A function to convert any range to a container","February 2022","",""
 "`P1413R3 <https://wg21.link/P1413R3>`__","LWG","Deprecate ``std::aligned_storage`` and ``std::aligned_union``","February 2022","",""
 "`P2255R3 <https://wg21.link/P2255R3>`__","LWG","A type trait to detect reference binding to temporary","February 2022","",""
-"`P2273R3 <https://wg21.link/P2273R3>`__","LWG","Making ``std::unique_ptr`` constexpr","February 2022","",""
+"`P2273R3 <https://wg21.link/P2273R3>`__","LWG","Making ``std::unique_ptr`` constexpr","February 2022","|Complete|","16.0"
 "`P2387R3 <https://wg21.link/P2387R3>`__","LWG","Pipe support for user-defined range adaptors","February 2022","",""
 "`P2440R1 <https://wg21.link/P2440R1>`__","LWG","``ranges::iota``, ``ranges::shift_left`` and ``ranges::shift_right``","February 2022","",""
 "`P2441R2 <https://wg21.link/P2441R2>`__","LWG","``views::join_view``","February 2022","",""
 "`P2442R1 <https://wg21.link/P2442R1>`__","LWG","Windowing range adaptors: ``views::chunk`` and ``views::slide``","February 2022","",""
 "`P2443R1 <https://wg21.link/P2443R1>`__","LWG","``views::chunk_by``","February 2022","",""
 "","","","","",""
 "`P0009R18 <https://wg21.link/P0009R18>`__","LWG","mdspan: A Non-Owning Multidimensional Array Reference","July 2022","",""
 "`P0429R9 <https://wg21.link/P0429R9>`__","LWG","A Standard ``flat_map``","July 2022","",""

libcxx/include/__config

 #  endif
 
 #  if _LIBCPP_STD_VER > 17
 #    define _LIBCPP_CONSTEXPR_AFTER_CXX17 constexpr
 #  else
 #    define _LIBCPP_CONSTEXPR_AFTER_CXX17
 #  endif
 
+#  if _LIBCPP_STD_VER > 20
+#    define _LIBCPP_CONSTEXPR_CXX23 constexpr
+#  else
+#    define _LIBCPP_CONSTEXPR_CXX23
+#  endif
+
 #  if __has_cpp_attribute(nodiscard) || defined(_LIBCPP_COMPILER_MSVC)
 #    define _LIBCPP_NODISCARD [[nodiscard]]
 #  elif defined(_LIBCPP_COMPILER_CLANG_BASED) && !defined(_LIBCPP_CXX03_LANG)
 #    define _LIBCPP_NODISCARD [[clang::warn_unused_result]]
 #  else
 // We can't use GCC's [[gnu::warn_unused_result]] and
 // __attribute__((warn_unused_result)), because GCC does not silence them via
 // (void) cast.

libcxx/include/__memory/unique_ptr.h

 #include <__utility/move.h>
 #include <cstddef>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS default_delete {
     static_assert(!is_function<_Tp>::value,
                   "default_delete cannot be instantiated for function types");
 #ifndef _LIBCPP_CXX03_LANG
   _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default;
 #else
   _LIBCPP_INLINE_VISIBILITY default_delete() {}
 #endif
   template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   default_delete(const default_delete<_Up>&,
                  typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* =
                      0) _NOEXCEPT {}
 
-  _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __ptr) const _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23 void operator()(_Tp* __ptr) const _NOEXCEPT {
     static_assert(sizeof(_Tp) >= 0, "cannot delete an incomplete type");
     static_assert(!is_void<_Tp>::value, "cannot delete an incomplete type");
     delete __ptr;
   }
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]> {
 private:
   template <class _Up>
   struct _EnableIfConvertible
       : enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {};
 
 public:
 #ifndef _LIBCPP_CXX03_LANG
   _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default;
 #else
   _LIBCPP_INLINE_VISIBILITY default_delete() {}
 #endif
 
   template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   default_delete(const default_delete<_Up[]>&,
                  typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPT {}
 
   template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   typename _EnableIfConvertible<_Up>::type
   operator()(_Up* __ptr) const _NOEXCEPT {
     static_assert(sizeof(_Up) >= 0, "cannot delete an incomplete type");
     delete[] __ptr;
   }
 };
 
 template <class _Deleter>
public:
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(__value_init_tag(), __value_init_tag()) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   explicit unique_ptr(pointer __p) _NOEXCEPT : __ptr_(__p, __value_init_tag()) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr(pointer __p, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, __d) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, _VSTD::move(__d)) {
     static_assert(!is_reference<deleter_type>::value,
                   "rvalue deleter bound to reference");
   }
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete;
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr(unique_ptr&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterConvertible<_Ep>
   >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(auto_ptr<_Up>&& __p,
              typename enable_if<is_convertible<_Up*, _Tp*>::value &&
                                     is_same<_Dp, default_delete<_Tp> >::value,
                                 __nat>::type = __nat()) _NOEXCEPT
       : __ptr_(__p.release(), __value_init_tag()) {}
 #endif
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
     return *this;
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterAssignable<_Ep>
   >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
     return *this;
   }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
       typename enable_if<is_convertible<_Up*, _Tp*>::value &&
                              is_same<_Dp, default_delete<_Tp> >::value,
                          unique_ptr&>::type
       operator=(auto_ptr<_Up> __p) {
     reset(__p.release());
     return *this;
   }
 #endif
 
 #ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
 #endif
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   ~unique_ptr() { reset(); }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   typename add_lvalue_reference<_Tp>::type
   operator*() const {
     return *__ptr_.first();
   }
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   pointer operator->() const _NOEXCEPT {
     return __ptr_.first();
   }
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   pointer get() const _NOEXCEPT {
     return __ptr_.first();
   }
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   deleter_type& get_deleter() _NOEXCEPT {
     return __ptr_.second();
   }
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   const deleter_type& get_deleter() const _NOEXCEPT {
     return __ptr_.second();
   }
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   explicit operator bool() const _NOEXCEPT {
     return __ptr_.first() != nullptr;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   pointer release() _NOEXCEPT {
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   void reset(pointer __p = pointer()) _NOEXCEPT {
     pointer __tmp = __ptr_.first();
     __ptr_.first() = __p;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   void swap(unique_ptr& __u) _NOEXCEPT {
     __ptr_.swap(__u.__ptr_);
   }
 };
 
 
 template <class _Tp, class _Dp>
 class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> {
public:
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(__value_init_tag(), __value_init_tag()) {}
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy>,
             class = _EnableIfPointerConvertible<_Pp> >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   explicit unique_ptr(_Pp __p) _NOEXCEPT
       : __ptr_(__p, __value_init_tag()) {}
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, __d) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(nullptr, __d) {}
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, _VSTD::move(__d)) {
     static_assert(!is_reference<deleter_type>::value,
                   "rvalue deleter bound to reference");
   }
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(nullptr, _VSTD::move(__d)) {
     static_assert(!is_reference<deleter_type>::value,
                   "rvalue deleter bound to reference");
   }
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete;
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr(unique_ptr&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
     return *this;
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterConvertible<_Ep>
   >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterAssignable<_Ep>
   >
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr&
   operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
     return *this;
   }
 
 #ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
 #endif
 public:
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   ~unique_ptr() { reset(); }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   typename add_lvalue_reference<_Tp>::type
   operator[](size_t __i) const {
     return __ptr_.first()[__i];
   }
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   pointer get() const _NOEXCEPT {
     return __ptr_.first();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   deleter_type& get_deleter() _NOEXCEPT {
     return __ptr_.second();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   const deleter_type& get_deleter() const _NOEXCEPT {
     return __ptr_.second();
   }
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   explicit operator bool() const _NOEXCEPT {
     return __ptr_.first() != nullptr;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   pointer release() _NOEXCEPT {
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;
   }
 
   template <class _Pp>
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   typename enable_if<
       _CheckArrayPointerConversion<_Pp>::value
   >::type
   reset(_Pp __p) _NOEXCEPT {
     pointer __tmp = __ptr_.first();
     __ptr_.first() = __p;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   void reset(nullptr_t = nullptr) _NOEXCEPT {
     pointer __tmp = __ptr_.first();
     __ptr_.first() = nullptr;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
   void swap(unique_ptr& __u) _NOEXCEPT {
     __ptr_.swap(__u.__ptr_);
   }
 
 };
 
 template <class _Tp, class _Dp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 typename enable_if<
     __is_swappable<_Dp>::value,
     void
 >::type
 swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {__x.swap(__y);}
 
 template <class _T1, class _D1, class _T2, class _D2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 bool
 operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();}
 
 #if _LIBCPP_STD_VER <= 17
 template <class _T1, class _D1, class _T2, class _D2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);}
 #endif
 
 template <class _T1, class _D1, class _T2, class _D2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
 {
     typedef typename unique_ptr<_T1, _D1>::pointer _P1;

 requires three_way_comparable_with<typename unique_ptr<_T1, _D1>::pointer,
                                    typename unique_ptr<_T2, _D2>::pointer>
 _LIBCPP_HIDE_FROM_ABI
 compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer,
                            typename unique_ptr<_T2, _D2>::pointer>
 operator<=>(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {
    return compare_three_way()(__x.get(), __y.get());
 }
 #endif
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 bool
 operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT
 {
     return !__x;
 }
 
 #if _LIBCPP_STD_VER <= 17
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT
 {
     return !__x;
 }
 

 bool
 operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT
 {
     return static_cast<bool>(__x);
 }
 #endif // _LIBCPP_STD_VER <= 17
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 bool
 operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t)
 {
     typedef typename unique_ptr<_T1, _D1>::pointer _P1;
     return less<_P1>()(__x.get(), nullptr);
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 bool
 operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x)
 {
     typedef typename unique_ptr<_T1, _D1>::pointer _P1;
     return less<_P1>()(nullptr, __x.get());
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 bool
 operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t)
 {
     return nullptr < __x;
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 bool
 operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x)
 {
     return __x < nullptr;
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 bool
 operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
 {
     return !(nullptr < __x);
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 bool
 operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
 {
     return !(__x < nullptr);
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 bool
 operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
 {
     return !(__x < nullptr);
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 bool
 operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
 {
     return !(nullptr < __x);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _T1, class _D1>
 requires three_way_comparable<typename unique_ptr<_T1, _D1>::pointer>
-_LIBCPP_HIDE_FROM_ABI
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_CXX23
 compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer>
 operator<=>(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
    return compare_three_way()(__x.get(), static_cast<typename unique_ptr<_T1, _D1>::pointer>(nullptr));
 }
 #endif
 
 #if _LIBCPP_STD_VER > 11
 

 
 template<class _Tp, size_t _Np>
 struct __unique_if<_Tp[_Np]>
 {
     typedef void __unique_array_known_bound;
 };
 
 template<class _Tp, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 typename __unique_if<_Tp>::__unique_single
 make_unique(_Args&&... __args)
 {
     return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...));
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_CXX23
 typename __unique_if<_Tp>::__unique_array_unknown_bound
 make_unique(size_t __n)
 {
     typedef typename remove_extent<_Tp>::type _Up;
     return unique_ptr<_Tp>(new _Up[__n]());
 }
 
 template<class _Tp, class... _Args>

libcxx/include/memory

public:
     template<class Y> operator auto_ptr_ref<Y>() throw();
     template<class Y> operator auto_ptr<Y>() throw();
 };
 
 template <class T>
 struct default_delete
 {
     constexpr default_delete() noexcept = default;
-    template <class U> default_delete(const default_delete<U>&) noexcept;
+    template <class U> default_delete(const default_delete<U>&) noexcept; // constexpr since C++23
 
-    void operator()(T*) const noexcept;
+    void operator()(T*) const noexcept;                                   // constexpr since C++23
 };
 
 template <class T>
 struct default_delete<T[]>
 {
     constexpr default_delete() noexcept = default;
-    void operator()(T*) const noexcept;
+    template <class U> default_delete(const default_delete <U[]>&) noexcept; // constexpr since C++23
+    void operator()(T*) const noexcept;                                      // constexpr since C++23
     template <class U> void operator()(U*) const = delete;
 };
 
 template <class T, class D = default_delete<T>>
 class unique_ptr
 {
 public:
     typedef see below pointer;
     typedef T element_type;
     typedef D deleter_type;
 
     // constructors
     constexpr unique_ptr() noexcept;
-    explicit unique_ptr(pointer p) noexcept;
-    unique_ptr(pointer p, see below d1) noexcept;
-    unique_ptr(pointer p, see below d2) noexcept;
-    unique_ptr(unique_ptr&& u) noexcept;
-    unique_ptr(nullptr_t) noexcept : unique_ptr() { }
+    explicit unique_ptr(pointer p) noexcept;           // constexpr since C++23
+    unique_ptr(pointer p, see below d1) noexcept;      // constexpr since C++23
+    unique_ptr(pointer p, see below d2) noexcept;      // constexpr since C++23
+    unique_ptr(unique_ptr&& u) noexcept;               // constexpr since C++23
+    constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
     template <class U, class E>
-        unique_ptr(unique_ptr<U, E>&& u) noexcept;
+        unique_ptr(unique_ptr<U, E>&& u) noexcept;     // constexpr since C++23
     template <class U>
         unique_ptr(auto_ptr<U>&& u) noexcept;       // removed in C++17
 
     // destructor
-    ~unique_ptr();
+    ~unique_ptr();                                      // constexpr since C++23
 
     // assignment
-    unique_ptr& operator=(unique_ptr&& u) noexcept;
-    template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
-    unique_ptr& operator=(nullptr_t) noexcept;
+    unique_ptr& operator=(unique_ptr&& u) noexcept;                                   // constexpr since C++23
+    template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept; // constexpr since C++23
+    unique_ptr& operator=(nullptr_t) noexcept;                                        // constexpr since C++23
 
     // observers
-    typename add_lvalue_reference<T>::type operator*() const;
-    pointer operator->() const noexcept;
-    pointer get() const noexcept;
-    deleter_type& get_deleter() noexcept;
-    const deleter_type& get_deleter() const noexcept;
-    explicit operator bool() const noexcept;
+    typename add_lvalue_reference<T>::type operator*() const;                         // constexpr since C++23
+    pointer operator->() const noexcept;                                              // constexpr since C++23
+    pointer get() const noexcept;                                                     // constexpr since C++23
+    deleter_type& get_deleter() noexcept;                                             // constexpr since C++23
+    const deleter_type& get_deleter() const noexcept;                                 // constexpr since C++23
+    explicit operator bool() const noexcept;                                          // constexpr since C++23
 
     // modifiers
-    pointer release() noexcept;
-    void reset(pointer p = pointer()) noexcept;
-    void swap(unique_ptr& u) noexcept;
+    pointer release() noexcept;                                                       // constexpr since C++23
+    void reset(pointer p = pointer()) noexcept;                                       // constexpr since C++23
+    void swap(unique_ptr& u) noexcept;                                                // constexpr since C++23
 };
 
 template <class T, class D>
 class unique_ptr<T[], D>
 {
 public:
     typedef implementation-defined pointer;
     typedef T element_type;
     typedef D deleter_type;
 
     // constructors
     constexpr unique_ptr() noexcept;
-    explicit unique_ptr(pointer p) noexcept;
-    unique_ptr(pointer p, see below d) noexcept;
-    unique_ptr(pointer p, see below d) noexcept;
-    unique_ptr(unique_ptr&& u) noexcept;
-    unique_ptr(nullptr_t) noexcept : unique_ptr() { }
+    explicit unique_ptr(pointer p) noexcept;          // constexpr since C++23
+    unique_ptr(pointer p, see below d) noexcept;      // constexpr since C++23
+    unique_ptr(pointer p, see below d) noexcept;      // constexpr since C++23
+    unique_ptr(unique_ptr&& u) noexcept;              // constexpr since C++23
+    unique_ptr(nullptr_t) noexcept : unique_ptr() { } // constexpr since C++23
 
     // destructor
-    ~unique_ptr();
+    ~unique_ptr();                                     // constexpr since C++23
 
     // assignment
-    unique_ptr& operator=(unique_ptr&& u) noexcept;
-    unique_ptr& operator=(nullptr_t) noexcept;
+    unique_ptr& operator=(unique_ptr&& u) noexcept;    // constexpr since C++23
+    unique_ptr& operator=(nullptr_t) noexcept;         // constexpr since C++23
 
     // observers
-    T& operator[](size_t i) const;
-    pointer get() const noexcept;
-    deleter_type& get_deleter() noexcept;
-    const deleter_type& get_deleter() const noexcept;
-    explicit operator bool() const noexcept;
+    T& operator[](size_t i) const;                     // constexpr since C++23
+    pointer get() const noexcept;                      // constexpr since C++23
+    deleter_type& get_deleter() noexcept;              // constexpr since C++23
+    const deleter_type& get_deleter() const noexcept;  // constexpr since C++23
+    explicit operator bool() const noexcept;           // constexpr since C++23
 
     // modifiers
-    pointer release() noexcept;
-    void reset(pointer p = pointer()) noexcept;
-    void reset(nullptr_t) noexcept;
+    pointer release() noexcept;                        // constexpr since C++23
+    void reset(pointer p = pointer()) noexcept;        // constexpr since C++23
+    void reset(nullptr_t) noexcept;                    // constexpr since C++23
   template <class U> void reset(U) = delete;
-    void swap(unique_ptr& u) noexcept;
+    void swap(unique_ptr& u) noexcept;                 // constexpr since C++23
 };
 
 template <class T, class D>
-    void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
+    void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;                 // constexpr since C++23
 
 template <class T1, class D1, class T2, class D2>
-    bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+    bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);    // constexpr since C++23
 template <class T1, class D1, class T2, class D2>
     bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);    // removed in C++20
 template <class T1, class D1, class T2, class D2>
     bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 template <class T1, class D1, class T2, class D2>
     bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 template <class T1, class D1, class T2, class D2>
     bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 template <class T1, class D1, class T2, class D2>
     bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 template<class T1, class D1, class T2, class D2>
   requires three_way_comparable_with<typename unique_ptr<T1, D1>::pointer,
                                      typename unique_ptr<T2, D2>::pointer>
   compare_three_way_result_t<typename unique_ptr<T1, D1>::pointer,
                              typename unique_ptr<T2, D2>::pointer>
     operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);      // C++20
 
 template <class T, class D>
-    bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
+    bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;     // constexpr since C++23
 template <class T, class D>
     bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept;     // removed in C++20
 template <class T, class D>
     bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept;     // removed in C++20
 template <class T, class D>
     bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept;     // removed in C++20
 
 template <class T, class D>
-    bool operator<(const unique_ptr<T, D>& x, nullptr_t);
+    bool operator<(const unique_ptr<T, D>& x, nullptr_t);     // constexpr since C++23
 template <class T, class D>
-    bool operator<(nullptr_t, const unique_ptr<T, D>& y);
+    bool operator<(nullptr_t, const unique_ptr<T, D>& y);     // constexpr since C++23
 template <class T, class D>
-    bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
+    bool operator<=(const unique_ptr<T, D>& x, nullptr_t);    // constexpr since C++23
 template <class T, class D>
-    bool operator<=(nullptr_t, const unique_ptr<T, D>& y);
+    bool operator<=(nullptr_t, const unique_ptr<T, D>& y);    // constexpr since C++23
 template <class T, class D>
-    bool operator>(const unique_ptr<T, D>& x, nullptr_t);
+    bool operator>(const unique_ptr<T, D>& x, nullptr_t);     // constexpr since C++23
 template <class T, class D>
-    bool operator>(nullptr_t, const unique_ptr<T, D>& y);
+    bool operator>(nullptr_t, const unique_ptr<T, D>& y);     // constexpr since C++23
 template <class T, class D>
-    bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
+    bool operator>=(const unique_ptr<T, D>& x, nullptr_t);    // constexpr since C++23
 template <class T, class D>
-    bool operator>=(nullptr_t, const unique_ptr<T, D>& y);
+    bool operator>=(nullptr_t, const unique_ptr<T, D>& y);    // constexpr since C++23
 template<class T, class D>
   requires three_way_comparable<typename unique_ptr<T, D>::pointer>
   compare_three_way_result_t<typename unique_ptr<T, D>::pointer>
-    operator<=>(const unique_ptr<T, D>& x, nullptr_t);                          // C++20
+    operator<=>(const unique_ptr<T, D>& x, nullptr_t);                          // C++20, constexpr since C++23
 
 class bad_weak_ptr
     : public std::exception
 {
     bad_weak_ptr() noexcept;
 };
 
-template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);     // C++14
-template<class T>                unique_ptr<T> make_unique(size_t n);           // C++14
+template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);     // C++14, constexpr since C++23
+template<class T>                unique_ptr<T> make_unique(size_t n);           // C++14, constexpr since C++23
 template<class T, class... Args> unspecified   make_unique(Args&&...) = delete; // C++14, T == U[N]
 
 template<class E, class T, class Y, class D>
     basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, unique_ptr<Y, D> const& p);
 
 template<class T>
 class shared_ptr
 {

libcxx/include/version

 __cpp_lib_complex_udls                                  201309L <complex>
 __cpp_lib_concepts                                      202002L <concepts>
 __cpp_lib_constexpr_algorithms                          201806L <algorithm>
 __cpp_lib_constexpr_cmath                               202202L <cmath> <cstdlib>
 __cpp_lib_constexpr_complex                             201711L <complex>
 __cpp_lib_constexpr_dynamic_alloc                       201907L <memory>
 __cpp_lib_constexpr_functional                          201907L <functional>
 __cpp_lib_constexpr_iterator                            201811L <iterator>
-__cpp_lib_constexpr_memory                              201811L <memory>
+__cpp_lib_constexpr_memory                              202202L <memory>
+                                                        201811L // C++20
 __cpp_lib_constexpr_numeric                             201911L <numeric>
 __cpp_lib_constexpr_string                              201907L <string>
 __cpp_lib_constexpr_string_view                         201811L <string_view>
 __cpp_lib_constexpr_tuple                               201811L <tuple>
 __cpp_lib_constexpr_typeinfo                            202106L <typeinfo>
 __cpp_lib_constexpr_utility                             201811L <utility>
 __cpp_lib_constexpr_vector                              201907L <vector>
 __cpp_lib_coroutine                                     201902L <coroutine>

 
 #if _LIBCPP_STD_VER > 20
 # define __cpp_lib_adaptor_iterator_pair_constructor    202106L
 # define __cpp_lib_allocate_at_least                    202106L
 // # define __cpp_lib_associative_heterogeneous_erasure    202110L
 // # define __cpp_lib_bind_back                            202202L
 # define __cpp_lib_byteswap                             202110L
 // # define __cpp_lib_constexpr_cmath                      202202L
+# undef  __cpp_lib_constexpr_memory
+# define __cpp_lib_constexpr_memory                     202202L
 // # define __cpp_lib_constexpr_typeinfo                   202106L
 // # define __cpp_lib_invoke_r                             202106L
 # define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_move_only_function                   202110L
 # undef  __cpp_lib_optional
 # define __cpp_lib_optional                             202110L
 // # define __cpp_lib_out_ptr                              202106L
 // # define __cpp_lib_ranges_chunk                         202202L

libcxx/test/std/language.support/support.limits/support.limits.general/memory.version.compile.pass.cpp

 /*  Constant                                      Value
     __cpp_lib_addressof_constexpr                 201603L [C++17]
     __cpp_lib_allocate_at_least                   202106L [C++2b]
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
     __cpp_lib_assume_aligned                      201811L [C++20]
     __cpp_lib_atomic_value_initialization         201911L [C++20]
     __cpp_lib_constexpr_dynamic_alloc             201907L [C++20]
     __cpp_lib_constexpr_memory                    201811L [C++20]
+                                                  202202L [C++2b]
     __cpp_lib_enable_shared_from_this             201603L [C++17]
     __cpp_lib_make_unique                         201304L [C++14]
     __cpp_lib_out_ptr                             202106L [C++2b]
     __cpp_lib_ranges                              201811L [C++20]
     __cpp_lib_raw_memory_algorithms               201606L [C++17]
     __cpp_lib_shared_ptr_arrays                   201611L [C++17]
                                                   201707L [C++20]
     __cpp_lib_shared_ptr_weak_type                201606L [C++17]

 # endif
 # if __cpp_lib_constexpr_dynamic_alloc != 201907L
 #   error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++2b"
 # endif
 
 # ifndef __cpp_lib_constexpr_memory
 #   error "__cpp_lib_constexpr_memory should be defined in c++2b"
 # endif
-# if __cpp_lib_constexpr_memory != 201811L
-#   error "__cpp_lib_constexpr_memory should have the value 201811L in c++2b"
+# if __cpp_lib_constexpr_memory != 202202L
+#   error "__cpp_lib_constexpr_memory should have the value 202202L in c++2b"
 # endif
 
 # ifndef __cpp_lib_enable_shared_from_this
 #   error "__cpp_lib_enable_shared_from_this should be defined in c++2b"
 # endif
 # if __cpp_lib_enable_shared_from_this != 201603L
 #   error "__cpp_lib_enable_shared_from_this should have the value 201603L in c++2b"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

/*  Constant                                       Value
     __cpp_lib_concepts                             202002L [C++20]
     __cpp_lib_constexpr_algorithms                 201806L [C++20]
     __cpp_lib_constexpr_cmath                      202202L [C++2b]
     __cpp_lib_constexpr_complex                    201711L [C++20]
     __cpp_lib_constexpr_dynamic_alloc              201907L [C++20]
     __cpp_lib_constexpr_functional                 201907L [C++20]
     __cpp_lib_constexpr_iterator                   201811L [C++20]
     __cpp_lib_constexpr_memory                     201811L [C++20]
+                                                   202202L [C++2b]
     __cpp_lib_constexpr_numeric                    201911L [C++20]
     __cpp_lib_constexpr_string                     201907L [C++20]
     __cpp_lib_constexpr_string_view                201811L [C++20]
     __cpp_lib_constexpr_tuple                      201811L [C++20]
     __cpp_lib_constexpr_typeinfo                   202106L [C++2b]
     __cpp_lib_constexpr_utility                    201811L [C++20]
     __cpp_lib_constexpr_vector                     201907L [C++20]
     __cpp_lib_coroutine                            201902L [C++20]

 # endif
 # if __cpp_lib_constexpr_iterator != 201811L
 #   error "__cpp_lib_constexpr_iterator should have the value 201811L in c++2b"
 # endif
 
 # ifndef __cpp_lib_constexpr_memory
 #   error "__cpp_lib_constexpr_memory should be defined in c++2b"
 # endif
-# if __cpp_lib_constexpr_memory != 201811L
-#   error "__cpp_lib_constexpr_memory should have the value 201811L in c++2b"
+# if __cpp_lib_constexpr_memory != 202202L
+#   error "__cpp_lib_constexpr_memory should have the value 202202L in c++2b"
 # endif
 
 # ifndef __cpp_lib_constexpr_numeric
 #   error "__cpp_lib_constexpr_numeric should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_numeric != 201911L
 #   error "__cpp_lib_constexpr_numeric should have the value 201911L in c++2b"
 # endif

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp

 #include "unique_ptr_test_helper.h"
 
 #if TEST_STD_VER >= 11
 TEST_CONSTINIT std::unique_ptr<int> global_static_unique_ptr_single;
 TEST_CONSTINIT std::unique_ptr<int[]> global_static_unique_ptr_runtime;
 
 struct NonDefaultDeleter {
   NonDefaultDeleter() = delete;
-  void operator()(void*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
 };
 #endif
 
 template <class ElemType>
 void test_sfinae() {
 #if TEST_STD_VER >= 11
   { // the constructor does not participate in overload resolution when
     // the deleter is a pointer type
     using U = std::unique_ptr<ElemType, void (*)(void*)>;
     static_assert(!std::is_default_constructible<U>::value, "");
   }
   { // the constructor does not participate in overload resolution when
     // the deleter is not default constructible
     using Del = CDeleter<ElemType>;
-    using U1 = std::unique_ptr<ElemType, NonDefaultDeleter>;
-    using U2 = std::unique_ptr<ElemType, Del&>;
-    using U3 = std::unique_ptr<ElemType, Del const&>;
+    using U1  = std::unique_ptr<ElemType, NonDefaultDeleter>;
+    using U2  = std::unique_ptr<ElemType, Del&>;
+    using U3  = std::unique_ptr<ElemType, Del const&>;
     static_assert(!std::is_default_constructible<U1>::value, "");
     static_assert(!std::is_default_constructible<U2>::value, "");
     static_assert(!std::is_default_constructible<U3>::value, "");
   }
 #endif
 }
 
 template <class ElemType>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 bool test_basic() {
 #if TEST_STD_VER >= 11
   {
     using U1 = std::unique_ptr<ElemType>;
     using U2 = std::unique_ptr<ElemType, Deleter<ElemType> >;
     static_assert(std::is_nothrow_default_constructible<U1>::value, "");
     static_assert(std::is_nothrow_default_constructible<U2>::value, "");
   }
 #endif
   {
     std::unique_ptr<ElemType> p;
     assert(p.get() == 0);
   }
   {
     std::unique_ptr<ElemType, NCDeleter<ElemType> > p;
     assert(p.get() == 0);
     assert(p.get_deleter().state() == 0);
     p.get_deleter().set_state(5);
     assert(p.get_deleter().state() == 5);
   }
   {
     std::unique_ptr<ElemType, DefaultCtorDeleter<ElemType> > p;
     assert(p.get() == 0);
     assert(p.get_deleter().state() == 0);
   }
+
+  return true;
 }
 
 DEFINE_AND_RUN_IS_INCOMPLETE_TEST({
   doIncompleteTypeTest(0);
   doIncompleteTypeTest<IncompleteType, Deleter<IncompleteType> >(0);
 } {
   doIncompleteTypeTest<IncompleteType[]>(0);
   doIncompleteTypeTest<IncompleteType[], Deleter<IncompleteType[]> >(0);
 })
 
 int main(int, char**) {
   {
     test_sfinae<int>();
     test_basic<int>();
+#if TEST_STD_VER >= 23
+    static_assert(test_basic<int>());
+#endif
   }
   {
     test_sfinae<int[]>();
     test_basic<int[]>();
+#if TEST_STD_VER >= 23
+    static_assert(test_basic<int[]>());
+#endif
   }
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp

 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 template <class VT>
-void test_pointer_ctor() {
+TEST_CONSTEXPR_CXX23 bool test_pointer_ctor() {
   {
     std::unique_ptr<VT> p(0);
     assert(p.get() == 0);
   }
   {
     std::unique_ptr<VT, Deleter<VT> > p(0);
     assert(p.get() == 0);
     assert(p.get_deleter().state() == 0);
   }
+
+  return true;
 }
 
 template <class VT>
-void test_pointer_deleter_ctor() {
+TEST_CONSTEXPR_CXX23 bool test_pointer_deleter_ctor() {
   {
     std::default_delete<VT> d;
     std::unique_ptr<VT> p(0, d);
     assert(p.get() == 0);
   }
   {
     std::unique_ptr<VT, Deleter<VT> > p(0, Deleter<VT>(5));
     assert(p.get() == 0);
     assert(p.get_deleter().state() == 5);
   }
   {
     NCDeleter<VT> d(5);
     std::unique_ptr<VT, NCDeleter<VT>&> p(0, d);
     assert(p.get() == 0);
     assert(p.get_deleter().state() == 5);
   }
   {
     NCConstDeleter<VT> d(5);
     std::unique_ptr<VT, NCConstDeleter<VT> const&> p(0, d);
     assert(p.get() == 0);
     assert(p.get_deleter().state() == 5);
   }
+
+  return true;
 }
 
 int main(int, char**) {
   {
     // test_pointer_ctor<int>();
     test_pointer_deleter_ctor<int>();
+#if TEST_STD_VER >= 23
+    static_assert(test_pointer_deleter_ctor<int>());
+#endif
   }
   {
     test_pointer_ctor<int[]>();
     test_pointer_deleter_ctor<int[]>();
+#if TEST_STD_VER >= 23
+    static_assert(test_pointer_ctor<int[]>());
+    static_assert(test_pointer_deleter_ctor<int[]>());
+#endif
   }
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.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>
 
 // unique_ptr
 
 // unique_ptr(nullptr_t);
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
-
 #if TEST_STD_VER >= 11
 TEST_CONSTINIT std::unique_ptr<int> global_static_unique_ptr_single(nullptr);
 TEST_CONSTINIT std::unique_ptr<int[]> global_static_unique_ptr_runtime(nullptr);
 
 struct NonDefaultDeleter {
   NonDefaultDeleter() = delete;
   void operator()(void*) const {}
 };
 #endif
 
 template <class VT>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 bool test_basic() {
 #if TEST_STD_VER >= 11
   {
     using U1 = std::unique_ptr<VT>;
     using U2 = std::unique_ptr<VT, Deleter<VT> >;
-    static_assert(std::is_nothrow_constructible<U1, decltype(nullptr)>::value,
-                  "");
-    static_assert(std::is_nothrow_constructible<U2, decltype(nullptr)>::value,
-                  "");
+    static_assert(std::is_nothrow_constructible<U1, decltype(nullptr)>::value, "");
+    static_assert(std::is_nothrow_constructible<U2, decltype(nullptr)>::value, "");
   }
 #endif
   {
     std::unique_ptr<VT> p(nullptr);
     assert(p.get() == 0);
   }
   {
     std::unique_ptr<VT, NCDeleter<VT> > p(nullptr);
     assert(p.get() == 0);
     assert(p.get_deleter().state() == 0);
   }
   {
     std::unique_ptr<VT, DefaultCtorDeleter<VT> > p(nullptr);
     assert(p.get() == 0);
     assert(p.get_deleter().state() == 0);
   }
+
+  return true;
 }
 
 template <class VT>
-void test_sfinae() {
+TEST_CONSTEXPR_CXX23 bool test_sfinae() {
 #if TEST_STD_VER >= 11
   { // the constructor does not participate in overload resolution when
     // the deleter is a pointer type
     using U = std::unique_ptr<VT, void (*)(void*)>;
     static_assert(!std::is_constructible<U, decltype(nullptr)>::value, "");
   }
   { // the constructor does not participate in overload resolution when
     // the deleter is not default constructible
     using Del = CDeleter<VT>;
-    using U1 = std::unique_ptr<VT, NonDefaultDeleter>;
-    using U2 = std::unique_ptr<VT, Del&>;
-    using U3 = std::unique_ptr<VT, Del const&>;
+    using U1  = std::unique_ptr<VT, NonDefaultDeleter>;
+    using U2  = std::unique_ptr<VT, Del&>;
+    using U3  = std::unique_ptr<VT, Del const&>;
     static_assert(!std::is_constructible<U1, decltype(nullptr)>::value, "");
     static_assert(!std::is_constructible<U2, decltype(nullptr)>::value, "");
     static_assert(!std::is_constructible<U3, decltype(nullptr)>::value, "");
   }
 #endif
+
+  return true;
 }
 
 DEFINE_AND_RUN_IS_INCOMPLETE_TEST({
   { doIncompleteTypeTest(0, nullptr); }
   checkNumIncompleteTypeAlive(0);
-  {
-    doIncompleteTypeTest<IncompleteType, NCDeleter<IncompleteType> >(0,
-                                                                     nullptr);
-  }
+  { doIncompleteTypeTest<IncompleteType, NCDeleter<IncompleteType> >(0, nullptr); }
   checkNumIncompleteTypeAlive(0);
   { doIncompleteTypeTest<IncompleteType[]>(0, nullptr); }
   checkNumIncompleteTypeAlive(0);
-  {
-    doIncompleteTypeTest<IncompleteType[], NCDeleter<IncompleteType[]> >(
-        0, nullptr);
-  }
+  { doIncompleteTypeTest<IncompleteType[], NCDeleter<IncompleteType[]> >(0, nullptr); }
   checkNumIncompleteTypeAlive(0);
 })
 
 int main(int, char**) {
   {
     test_basic<int>();
     test_sfinae<int>();
+#if TEST_STD_VER >= 23
+    static_assert(test_basic<int>());
+    static_assert(test_sfinae<int>());
+#endif
   }
   {
     test_basic<int[]>();
     test_sfinae<int[]>();
+#if TEST_STD_VER >= 23
+    static_assert(test_basic<int[]>());
+    static_assert(test_sfinae<int[]>());
+#endif
   }
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp

 
 class Deleter {
   int state_;
 
   Deleter(Deleter&);
   Deleter& operator=(Deleter&);
 
 public:
-  Deleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 Deleter() : state_(0) {}
 
-  int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
 
-  void operator()(void*) { ++state_; }
+  TEST_CONSTEXPR_CXX23 void operator()(void*) { ++state_; }
 };
 
 template <class T>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 bool test_basic() {
   Deleter d;
   assert(d.state() == 0);
   {
     std::unique_ptr<T, Deleter&> p(nullptr, d);
     assert(p.get() == nullptr);
     assert(&p.get_deleter() == &d);
   }
   assert(d.state() == 0);
+
+  return true;
 }
 
 int main(int, char**) {
   test_basic<int>();
   test_basic<int[]>();
+#if TEST_STD_VER >= 23
+  static_assert(test_basic<int>());
+  static_assert(test_basic<int[]>());
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.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>
 
 // unique_ptr
 
 // test reset against resetting self
 
 #include <memory>
+#include <cassert>
 
 #include "test_macros.h"
 
 struct A {
   std::unique_ptr<A> ptr_;
 
-  A() : ptr_(this) {}
-  void reset() { ptr_.reset(); }
+  TEST_CONSTEXPR_CXX23 A() : ptr_(this) {}
+  TEST_CONSTEXPR_CXX23 void reset() { ptr_.reset(); }
 };
 
-int main(int, char**) { (new A)->reset();
+TEST_CONSTEXPR_CXX23 bool test() {
+  (new A)->reset();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp

 
 // test op*()
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   std::unique_ptr<int> p(new int(3));
   assert(*p == 3);
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp

 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 template <class UPtr>
-void doTest(UPtr& p, bool ExpectTrue) {
+TEST_CONSTEXPR_CXX23 void doTest(UPtr& p, bool ExpectTrue) {
   if (p)
     assert(ExpectTrue);
   else
     assert(!ExpectTrue);
 
   if (!p)
     assert(!ExpectTrue);
   else
     assert(ExpectTrue);
 }
 
 template <bool IsArray>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 bool test_basic() {
   typedef typename std::conditional<IsArray, int[], int>::type VT;
   typedef std::unique_ptr<VT> U;
   {
     static_assert((std::is_constructible<bool, U>::value), "");
     static_assert((std::is_constructible<bool, U const&>::value), "");
   }
 #if TEST_STD_VER >= 11
   {
     static_assert(!std::is_convertible<U, bool>::value, "");
     static_assert(!std::is_convertible<U const&, bool>::value, "");
   }
 #endif
   {
     U p(newValue<VT>(1));
     U const& cp = p;
     doTest(p, true);
     doTest(cp, true);
   }
   {
     U p;
     const U& cp = p;
     doTest(p, false);
     doTest(cp, false);
   }
+
+  return true;
 }
 
 int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+#if TEST_STD_VER >= 23
+  static_assert(test_basic</*IsArray*/ false>());
+  static_assert(test_basic<true>());
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp

 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 template <bool IsArray>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 bool test_basic() {
   typedef typename std::conditional<IsArray, int[], int>::type VT;
   typedef const VT CVT;
   {
     typedef std::unique_ptr<VT> U;
     int* p = newValue<VT>(1);
     U s(p);
     U const& sc = s;
     ASSERT_SAME_TYPE(decltype(s.get()), int*);
     ASSERT_SAME_TYPE(decltype(sc.get()), int*);
     assert(s.get() == p);
     assert(sc.get() == s.get());
   }
   {
     typedef std::unique_ptr<CVT> U;
     const int* p = newValue<VT>(1);
     U s(p);
     U const& sc = s;
     ASSERT_SAME_TYPE(decltype(s.get()), const int*);
     ASSERT_SAME_TYPE(decltype(sc.get()), const int*);
     assert(s.get() == p);
     assert(sc.get() == s.get());
   }
+
+  return true;
 }
 
 int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+#if TEST_STD_VER >= 23
+  static_assert(test_basic</*IsArray*/ false>());
+  static_assert(test_basic<true>());
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp

 
 // test get_deleter()
 
 #include <memory>
 #include <cassert>
 #include "test_macros.h"
 
 struct Deleter {
-  Deleter() {}
+  TEST_CONSTEXPR_CXX23 Deleter() {}
 
-  void operator()(void*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
 
-  int test() { return 5; }
-  int test() const { return 6; }
+  TEST_CONSTEXPR_CXX23 int test() { return 5; }
+  TEST_CONSTEXPR_CXX23 int test() const { return 6; }
 };
 
 template <bool IsArray>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 bool test_basic() {
   typedef typename std::conditional<IsArray, int[], int>::type VT;
   {
     std::unique_ptr<int, Deleter> p;
     assert(p.get_deleter().test() == 5);
   }
   {
     const std::unique_ptr<VT, Deleter> p;
     assert(p.get_deleter().test() == 6);
typedef typename std::conditional<IsArray, int[], int>::type VT;
     Deleter d;
     UPtr p(nullptr, d);
     const UPtr& cp = p;
     ASSERT_SAME_TYPE(decltype(p.get_deleter()), Deleter&);
     ASSERT_SAME_TYPE(decltype(cp.get_deleter()), Deleter&);
     assert(p.get_deleter().test() == 5);
     assert(cp.get_deleter().test() == 5);
   }
+
+  return true;
 }
 
 int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+#if TEST_STD_VER >= 23
+  static_assert(test_basic</*IsArray*/ false>());
+  static_assert(test_basic<true>());
+#endif
 
   return 0;
-}
+}
 No newline at end of file

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp

 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A {
   int i_;
 
-  A() : i_(7) {}
+  TEST_CONSTEXPR_CXX23 A() : i_(7) {}
 };
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   std::unique_ptr<A> p(new A);
   assert(p->i_ == 7);
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 //    The only way to create an unique_ptr<T[]> is to default construct them.
 
 class foo {
 public:
-    foo () : val_(3) {}
-    int get () const { return val_; }
+  TEST_CONSTEXPR_CXX23 foo() : val_(3) {}
+  TEST_CONSTEXPR_CXX23 int get() const { return val_; }
+
 private:
-    int val_;
-    };
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX23 bool test() {
     auto p1 = std::make_unique<int[]>(5);
-    for ( int i = 0; i < 5; ++i )
-        assert ( p1[i] == 0 );
-    }
+    for (int i = 0; i < 5; ++i)
+      assert(p1[i] == 0);
 
-    {
     auto p2 = std::make_unique<std::string[]>(5);
-    for ( int i = 0; i < 5; ++i )
-        assert ( p2[i].size () == 0 );
-    }
+    for (int i = 0; i < 5; ++i)
+      assert(p2[i].size() == 0);
 
-    {
     auto p3 = std::make_unique<foo[]>(7);
-    for ( int i = 0; i < 7; ++i )
-        assert ( p3[i].get () == 3 );
-    }
+    for (int i = 0; i < 7; ++i)
+      assert(p3[i].get() == 3);
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 #include <memory>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX23 bool test() {
     std::unique_ptr<int> p1 = std::make_unique<int>(1);
-    assert ( *p1 == 1 );
-    p1 = std::make_unique<int> ();
-    assert ( *p1 == 0 );
-    }
+    assert(*p1 == 1);
+    p1 = std::make_unique<int>();
+    assert(*p1 == 0);
 
-    {
-    std::unique_ptr<std::string> p2 = std::make_unique<std::string> ( "Meow!" );
-    assert ( *p2 == "Meow!" );
-    p2 = std::make_unique<std::string> ();
-    assert ( *p2 == "" );
-    p2 = std::make_unique<std::string> ( 6, 'z' );
-    assert ( *p2 == "zzzzzz" );
-    }
+    std::unique_ptr<std::string> p2 = std::make_unique<std::string>("Meow!");
+    assert(*p2 == "Meow!");
+    p2 = std::make_unique<std::string>();
+    assert(*p2 == "");
+    p2 = std::make_unique<std::string>(6, 'z');
+    assert(*p2 == "zzzzzz");
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.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>
 
 // default_delete[]
 
 // template <class U>
-//   default_delete(const default_delete<U[]>&);
+//   default_delete(const default_delete<U[]>&); // constexpr since C++23
 //
 // This constructor shall not participate in overload resolution unless
 //   U(*)[] is convertible to T(*)[].
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::default_delete<int[]> d1;
-    std::default_delete<const int[]> d2 = d1;
-    ((void)d2);
+TEST_CONSTEXPR_CXX23 bool test() {
 
-  return 0;
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.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>
 
-// shared_ptr
+// unique_ptr
 
 // template <class T, class D>
-//     bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
+//     bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept; // constexpr since C++23
 // template <class T, class D>
-//     bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept;
+//     bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept; // constexpr since C++23
 // template <class T, class D>
-//     bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept;
+//     bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept; // constexpr since C++23
 // template <class T, class D>
-//     bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept;
+//     bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept; // constexpr since C++23
 // template <class T, class D>
-//     bool operator<(const unique_ptr<T, D>& x, nullptr_t);
+//     bool operator<(const unique_ptr<T, D>& x, nullptr_t); // constexpr since C++23
 // template <class T, class D>
-//     bool operator<(nullptr_t, const unique_ptr<T, D>& y);
+//     bool operator<(nullptr_t, const unique_ptr<T, D>& y); // constexpr since C++23
 // template <class T, class D>
-//     bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
+//     bool operator<=(const unique_ptr<T, D>& x, nullptr_t); // constexpr since C++23
 // template <class T, class D>
-//     bool operator<=(nullptr_t, const unique_ptr<T, D>& y);
+//     bool operator<=(nullptr_t, const unique_ptr<T, D>& y); // constexpr since C++23
 // template <class T, class D>
-//     bool operator>(const unique_ptr<T, D>& x, nullptr_t);
+//     bool operator>(const unique_ptr<T, D>& x, nullptr_t); // constexpr since C++23
 // template <class T, class D>
-//     bool operator>(nullptr_t, const unique_ptr<T, D>& y);
+//     bool operator>(nullptr_t, const unique_ptr<T, D>& y); // constexpr since C++23
 // template <class T, class D>
-//     bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
+//     bool operator>=(const unique_ptr<T, D>& x, nullptr_t); // constexpr since C++23
 // template <class T, class D>
-//     bool operator>=(nullptr_t, const unique_ptr<T, D>& y);
+//     bool operator>=(nullptr_t, const unique_ptr<T, D>& y); // constexpr since C++23
 // template<class T, class D>
 //   requires three_­way_­comparable<typename unique_ptr<T, D>::pointer>
 //   constexpr compare_three_way_result_t<typename unique_ptr<T, D>::pointer>
 //     operator<=>(const unique_ptr<T, D>& x, nullptr_t);                            // C++20
 
 #include <memory>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX23 bool test() {
   AssertEqualityAreNoexcept<std::unique_ptr<int>, nullptr_t>();
   AssertEqualityAreNoexcept<nullptr_t, std::unique_ptr<int> >();
   AssertComparisonsReturnBool<std::unique_ptr<int>, nullptr_t>();
   AssertComparisonsReturnBool<nullptr_t, std::unique_ptr<int> >();
 #if TEST_STD_VER > 17
   AssertOrderReturn<std::strong_ordering, std::unique_ptr<int>, nullptr_t>();
   AssertOrderReturn<std::strong_ordering, nullptr_t, std::unique_ptr<int>>();
 #endif
 
   const std::unique_ptr<int> p1(new int(1));
   assert(!(p1 == nullptr));
   assert(!(nullptr == p1));
+  // A pointer to allocated storage and a nullptr can't be compared at compile-time
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(!(p1 < nullptr));
     assert((nullptr < p1));
     assert(!(p1 <= nullptr));
     assert((nullptr <= p1));
     assert((p1 > nullptr));
     assert(!(nullptr > p1));
     assert((p1 >= nullptr));
     assert(!(nullptr >= p1));
 #if TEST_STD_VER > 17
     assert((nullptr <=> p1) == std::strong_ordering::less);
     assert((p1 <=> nullptr) == std::strong_ordering::greater);
 #endif
+  }
 
   const std::unique_ptr<int> p2;
   assert((p2 == nullptr));
   assert((nullptr == p2));
   assert(!(p2 < nullptr));
   assert(!(nullptr < p2));
   assert((p2 <= nullptr));
   assert((nullptr <= p2));
   assert(!(p2 > nullptr));
   assert(!(nullptr > p2));
   assert((p2 >= nullptr));
   assert((nullptr >= p2));
 #if TEST_STD_VER > 17
   assert((nullptr <=> p2) == std::strong_ordering::equivalent);
 #endif
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/support/deleter_types.h

 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 #if TEST_STD_VER >= 11
 
 template <class T>
-class Deleter
-{
-    int state_;
+class Deleter {
 
-    Deleter(const Deleter&);
-    Deleter& operator=(const Deleter&);
 
 public:
-    Deleter(Deleter&& r) : state_(r.state_) {r.state_ = 0;}
-    Deleter& operator=(Deleter&& r)
-    {
-        state_ = r.state_;
-        r.state_ = 0;
-        return *this;
-    }
+  TEST_CONSTEXPR_CXX23 Deleter(Deleter&& r) : state_(r.state_) { r.state_ = 0; }
+  TEST_CONSTEXPR_CXX23 Deleter& operator=(Deleter&& r) {
+    state_   = r.state_;
 
-
-    Deleter() : state_(0) {}
-    explicit Deleter(int s) : state_(s) {}
-    ~Deleter() {assert(state_ >= 0); state_ = -1;}
+  TEST_CONSTEXPR_CXX23 Deleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 explicit Deleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 ~Deleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    template <class U>
-        Deleter(Deleter<U>&& d,
-            typename std::enable_if<!std::is_same<U, T>::value>::type* = 0)
-            : state_(d.state()) {d.set_state(0);}
+  TEST_CONSTEXPR_CXX23 Deleter(Deleter<U>&& d, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0)
+      : state_(d.state()) {
+    d.set_state(0);
+  }
 
 private:
-    template <class U>
-        Deleter(const Deleter<U>& d,
-            typename std::enable_if<!std::is_same<U, T>::value>::type* = 0);
+  Deleter(const Deleter<U>& d, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0);
+
 public:
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {delete p;}
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete p; }
 };
 
 template <class T>
-class Deleter<T[]>
-{
-    int state_;
+class Deleter<T[]> {
 
-    Deleter(const Deleter&);
-    Deleter& operator=(const Deleter&);
 
 public:
-
-    Deleter(Deleter&& r) : state_(r.state_) {r.state_ = 0;}
-    Deleter& operator=(Deleter&& r)
-    {
-        state_ = r.state_;
-        r.state_ = 0;
-        return *this;
-    }
+  TEST_CONSTEXPR_CXX23 Deleter(Deleter&& r) : state_(r.state_) { r.state_ = 0; }
+  TEST_CONSTEXPR_CXX23 Deleter& operator=(Deleter&& r) {
+    state_   = r.state_;
 
-    Deleter() : state_(0) {}
-    explicit Deleter(int s) : state_(s) {}
-    ~Deleter() {assert(state_ >= 0); state_ = -1;}
+  TEST_CONSTEXPR_CXX23 Deleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 explicit Deleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 ~Deleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {delete [] p;}
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete[] p; }
 };
 
 #else // TEST_STD_VER < 11
 
 template <class T>
-class Deleter
-{
-    mutable int state_;
+class Deleter {
 
 public:
-    Deleter() : state_(0) {}
-    explicit Deleter(int s) : state_(s) {}
 
-    Deleter(Deleter const & other) : state_(other.state_) {
-        other.state_ = 0;
-    }
-    Deleter& operator=(Deleter const& other) {
-        state_ = other.state_;
-        other.state_ = 0;
-        return *this;
-    }
+  Deleter(Deleter const& other) : state_(other.state_) { other.state_ = 0; }
+    state_       = other.state_;
 
-    ~Deleter() {assert(state_ >= 0); state_ = -1;}
+  ~Deleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    template <class U>
-        Deleter(Deleter<U> d,
-            typename std::enable_if<!std::is_same<U, T>::value>::type* = 0)
-            : state_(d.state()) {}
+  Deleter(Deleter<U> d, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0) : state_(d.state()) {}
 
 public:
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  int state() const { return state_; }
+  void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {delete p;}
+  void operator()(T* p) { delete p; }
 };
 
 template <class T>
-class Deleter<T[]>
-{
-    mutable int state_;
+class Deleter<T[]> {
 
 public:
-
-    Deleter(Deleter const& other) : state_(other.state_) {
-        other.state_ = 0;
-    }
-    Deleter& operator=(Deleter const& other) {
-        state_ = other.state_;
-        other.state_ = 0;
-        return *this;
-    }
+  Deleter(Deleter const& other) : state_(other.state_) { other.state_ = 0; }
+    state_       = other.state_;
 
-    Deleter() : state_(0) {}
-    explicit Deleter(int s) : state_(s) {}
-    ~Deleter() {assert(state_ >= 0); state_ = -1;}
+  ~Deleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  int state() const { return state_; }
+  void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {delete [] p;}
+  void operator()(T* p) { delete[] p; }
 };
 
 #endif
 
 template <class T>
-void
-swap(Deleter<T>& x, Deleter<T>& y)
-{
-    Deleter<T> t(std::move(x));
-    x = std::move(y);
-    y = std::move(t);
+TEST_CONSTEXPR_CXX23 void swap(Deleter<T>& x, Deleter<T>& y) {
 }
 
-
 template <class T>
-class CDeleter
-{
-    int state_;
+class CDeleter {
 
 public:
-
-    CDeleter() : state_(0) {}
-    explicit CDeleter(int s) : state_(s) {}
-    ~CDeleter() {assert(state_ >= 0); state_ = -1;}
+  TEST_CONSTEXPR_CXX23 CDeleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 explicit CDeleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 ~CDeleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    template <class U>
-        CDeleter(const CDeleter<U>& d)
-            : state_(d.state()) {}
+  TEST_CONSTEXPR_CXX23 CDeleter(const CDeleter<U>& d) : state_(d.state()) {}
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {delete p;}
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete p; }
 };
 
 template <class T>
-class CDeleter<T[]>
-{
-    int state_;
+class CDeleter<T[]> {
 
 public:
-
-    CDeleter() : state_(0) {}
-    explicit CDeleter(int s) : state_(s) {}
-    template <class U>
-        CDeleter(const CDeleter<U>& d)
-            : state_(d.state()) {}
+  TEST_CONSTEXPR_CXX23 CDeleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 explicit CDeleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 CDeleter(const CDeleter<U>& d) : state_(d.state()) {}
 
-    ~CDeleter() {assert(state_ >= 0); state_ = -1;}
+  TEST_CONSTEXPR_CXX23 ~CDeleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {delete [] p;}
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete[] p; }
 };
 
 template <class T>
-void
-swap(CDeleter<T>& x, CDeleter<T>& y)
-{
-    CDeleter<T> t(std::move(x));
-    x = std::move(y);
-    y = std::move(t);
+TEST_CONSTEXPR_CXX23 void swap(CDeleter<T>& x, CDeleter<T>& y) {
 }
 
 // Non-copyable deleter
 template <class T>
-class NCDeleter
-{
-    int state_;
-    NCDeleter(NCDeleter const&);
-    NCDeleter& operator=(NCDeleter const&);
-public:
+class NCDeleter {
 
-    NCDeleter() : state_(0) {}
-    explicit NCDeleter(int s) : state_(s) {}
-    ~NCDeleter() {assert(state_ >= 0); state_ = -1;}
+public:
+  TEST_CONSTEXPR_CXX23 NCDeleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 explicit NCDeleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 ~NCDeleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {delete p;}
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete p; }
 };
 
-
 template <class T>
-class NCDeleter<T[]>
-{
-    int state_;
-    NCDeleter(NCDeleter const&);
-    NCDeleter& operator=(NCDeleter const&);
-public:
+class NCDeleter<T[]> {
 
-    NCDeleter() : state_(0) {}
-    explicit NCDeleter(int s) : state_(s) {}
-    ~NCDeleter() {assert(state_ >= 0); state_ = -1;}
+public:
+  TEST_CONSTEXPR_CXX23 NCDeleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 explicit NCDeleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 ~NCDeleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {delete [] p;}
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete[] p; }
 };
 
-
 // Non-copyable deleter
 template <class T>
-class NCConstDeleter
-{
-    int state_;
-    NCConstDeleter(NCConstDeleter const&);
-    NCConstDeleter& operator=(NCConstDeleter const&);
-public:
+class NCConstDeleter {
 
-    NCConstDeleter() : state_(0) {}
-    explicit NCConstDeleter(int s) : state_(s) {}
-    ~NCConstDeleter() {assert(state_ >= 0); state_ = -1;}
+public:
+  TEST_CONSTEXPR_CXX23 NCConstDeleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 explicit NCConstDeleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 ~NCConstDeleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) const {delete p;}
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) const { delete p; }
 };
 
-
 template <class T>
-class NCConstDeleter<T[]>
-{
-    int state_;
-    NCConstDeleter(NCConstDeleter const&);
-    NCConstDeleter& operator=(NCConstDeleter const&);
-public:
+class NCConstDeleter<T[]> {
 
-    NCConstDeleter() : state_(0) {}
-    explicit NCConstDeleter(int s) : state_(s) {}
-    ~NCConstDeleter() {assert(state_ >= 0); state_ = -1;}
+public:
+  TEST_CONSTEXPR_CXX23 NCConstDeleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 explicit NCConstDeleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 ~NCConstDeleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) const {delete [] p;}
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) const { delete[] p; }
 };
 
-
 // Non-copyable deleter
 template <class T>
-class CopyDeleter
-{
-    int state_;
-public:
+class CopyDeleter {
 
-    CopyDeleter() : state_(0) {}
-    explicit CopyDeleter(int s) : state_(s) {}
-    ~CopyDeleter() {assert(state_ >= 0); state_ = -1;}
+public:
+  TEST_CONSTEXPR_CXX23 CopyDeleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 explicit CopyDeleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 ~CopyDeleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    CopyDeleter(CopyDeleter const& other) : state_(other.state_) {}
-    CopyDeleter& operator=(CopyDeleter const& other) {
-        state_ = other.state_;
-        return *this;
-    }
+  TEST_CONSTEXPR_CXX23 CopyDeleter(CopyDeleter const& other) : state_(other.state_) {}
+  TEST_CONSTEXPR_CXX23 CopyDeleter& operator=(CopyDeleter const& other) {
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {delete p;}
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete p; }
 };
 
-
 template <class T>
-class CopyDeleter<T[]>
-{
-    int state_;
+class CopyDeleter<T[]> {
 
 public:
+  TEST_CONSTEXPR_CXX23 CopyDeleter() : state_(0) {}
+  TEST_CONSTEXPR_CXX23 explicit CopyDeleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 ~CopyDeleter() {
+    assert(state_ >= 0);
+    state_ = -1;
+  }
 
-    CopyDeleter() : state_(0) {}
-    explicit CopyDeleter(int s) : state_(s) {}
-    ~CopyDeleter() {assert(state_ >= 0); state_ = -1;}
-
-    CopyDeleter(CopyDeleter const& other) : state_(other.state_) {}
-    CopyDeleter& operator=(CopyDeleter const& other) {
-        state_ = other.state_;
-        return *this;
-    }
+  TEST_CONSTEXPR_CXX23 CopyDeleter(CopyDeleter const& other) : state_(other.state_) {}
+  TEST_CONSTEXPR_CXX23 CopyDeleter& operator=(CopyDeleter const& other) {
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {delete [] p;}
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete[] p; }
 };
 
-
-struct test_deleter_base
-{
-    static int count;
-    static int dealloc_count;
+struct test_deleter_base {
 };
 
-int test_deleter_base::count = 0;
+int test_deleter_base::count         = 0;
 int test_deleter_base::dealloc_count = 0;
 
 template <class T>
-class test_deleter
-    : public test_deleter_base
-{
-    int state_;
+class test_deleter : public test_deleter_base {
 
 public:
-
-    test_deleter() : state_(0) {++count;}
-    explicit test_deleter(int s) : state_(s) {++count;}
-    test_deleter(const test_deleter& d)
-        : state_(d.state_) {++count;}
-    ~test_deleter() {assert(state_ >= 0); --count; state_ = -1;}
+  test_deleter() : state_(0) { ++count; }
+  explicit test_deleter(int s) : state_(s) { ++count; }
+  test_deleter(const test_deleter& d) : state_(d.state_) { ++count; }
+  ~test_deleter() {
+    assert(state_ >= 0);
+    --count;
+    state_ = -1;
+  }
 
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
+  int state() const { return state_; }
+  void set_state(int i) { state_ = i; }
 
-    void operator()(T* p) {assert(state_ >= 0); ++dealloc_count; delete p;}
+  void operator()(T* p) {
+    assert(state_ >= 0);
+    ++dealloc_count;
+    delete p;
+  }
 #if TEST_STD_VER >= 11
-    test_deleter* operator&() const = delete;
 #else
+
 private:
   test_deleter* operator&() const;
 #endif
 };
 
 template <class T>
-void
-swap(test_deleter<T>& x, test_deleter<T>& y)
-{
-    test_deleter<T> t(std::move(x));
-    x = std::move(y);
-    y = std::move(t);
+void swap(test_deleter<T>& x, test_deleter<T>& y) {
 }
 
 #if TEST_STD_VER >= 11
 
 template <class T, size_t ID = 0>
-class PointerDeleter
-{
-    PointerDeleter(const PointerDeleter&);
-    PointerDeleter& operator=(const PointerDeleter&);
+class PointerDeleter {
 
 public:
-    typedef min_pointer<T, std::integral_constant<size_t, ID>> pointer;
 
-    PointerDeleter() = default;
-    PointerDeleter(PointerDeleter&&) = default;
-    PointerDeleter& operator=(PointerDeleter&&) = default;
-    explicit PointerDeleter(int) {}
+  TEST_CONSTEXPR_CXX23 PointerDeleter()                            = default;
+  TEST_CONSTEXPR_CXX23 PointerDeleter(PointerDeleter&&)            = default;
+  TEST_CONSTEXPR_CXX23 PointerDeleter& operator=(PointerDeleter&&) = default;
+  TEST_CONSTEXPR_CXX23 explicit PointerDeleter(int) {}
 
-    template <class U>
-        PointerDeleter(PointerDeleter<U, ID>&&,
-            typename std::enable_if<!std::is_same<U, T>::value>::type* = 0)
-    {}
+  TEST_CONSTEXPR_CXX23
+  PointerDeleter(PointerDeleter<U, ID>&&, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0) {}
 
-    void operator()(pointer p) { if (p) { delete std::addressof(*p); }}
+  TEST_CONSTEXPR_CXX23 void operator()(pointer p) {
+    if (p) {
+      delete std::addressof(*p);
+    }
+  }
 
 private:
-    template <class U>
-        PointerDeleter(const PointerDeleter<U, ID>&,
-            typename std::enable_if<!std::is_same<U, T>::value>::type* = 0);
+  PointerDeleter(const PointerDeleter<U, ID>&, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0);
 };
 
-
 template <class T, size_t ID>
-class PointerDeleter<T[], ID>
-{
-    PointerDeleter(const PointerDeleter&);
-    PointerDeleter& operator=(const PointerDeleter&);
+class PointerDeleter<T[], ID> {
 
 public:
-    typedef min_pointer<T, std::integral_constant<size_t, ID> > pointer;
 
-    PointerDeleter() = default;
-    PointerDeleter(PointerDeleter&&) = default;
-    PointerDeleter& operator=(PointerDeleter&&) = default;
-    explicit PointerDeleter(int) {}
+  TEST_CONSTEXPR_CXX23 PointerDeleter()                            = default;
+  TEST_CONSTEXPR_CXX23 PointerDeleter(PointerDeleter&&)            = default;
+  TEST_CONSTEXPR_CXX23 PointerDeleter& operator=(PointerDeleter&&) = default;
+  TEST_CONSTEXPR_CXX23 explicit PointerDeleter(int) {}
 
-    template <class U>
-        PointerDeleter(PointerDeleter<U, ID>&&,
-            typename std::enable_if<!std::is_same<U, T>::value>::type* = 0)
-    {}
+  TEST_CONSTEXPR_CXX23
+  PointerDeleter(PointerDeleter<U, ID>&&, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0) {}
 
-    void operator()(pointer p) { if (p) { delete [] std::addressof(*p); }}
+  TEST_CONSTEXPR_CXX23 void operator()(pointer p) {
+    if (p) {
+      delete[] std::addressof(*p);
+    }
+  }
 
 private:
-    template <class U>
-        PointerDeleter(const PointerDeleter<U, ID>&,
-            typename std::enable_if<!std::is_same<U, T>::value>::type* = 0);
+  PointerDeleter(const PointerDeleter<U, ID>&, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0);
 };
 
 #endif // TEST_STD_VER >= 11
 
 template <class T>
-class DefaultCtorDeleter
-{
-    int state_;
+class DefaultCtorDeleter {
 
 public:
-    int state() const {return state_;}
-    void operator()(T* p) {delete p;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete p; }
 };
 
 template <class T>
-class DefaultCtorDeleter<T[]>
-{
-    int state_;
+class DefaultCtorDeleter<T[]> {
 
 public:
-    int state() const {return state_;}
-    void operator()(T* p) {delete [] p;}
+  TEST_CONSTEXPR_CXX23 int state() const { return state_; }
+  TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete[] p; }
 };
 
 #endif // SUPPORT_DELETER_TYPES_H

libcxx/test/support/test_comparisons.h

 #define TEST_COMPARISONS_H
 
 #include <type_traits>
 #include <cassert>
 #include <concepts>
 #include "test_macros.h"
 
 //  Test all six comparison operations for sanity
 template <class T, class U = T>
-TEST_CONSTEXPR_CXX14 bool testComparisons(const T& t1, const U& t2, bool isEqual, bool isLess)
-{
-    assert(!(isEqual && isLess) && "isEqual and isLess cannot be both true");
-    if (isEqual)
-        {
-        if (!(t1 == t2)) return false;
-        if (!(t2 == t1)) return false;
-        if ( (t1 != t2)) return false;
-        if ( (t2 != t1)) return false;
-        if ( (t1  < t2)) return false;
-        if ( (t2  < t1)) return false;
-        if (!(t1 <= t2)) return false;
-        if (!(t2 <= t1)) return false;
-        if ( (t1  > t2)) return false;
-        if ( (t2  > t1)) return false;
-        if (!(t1 >= t2)) return false;
-        if (!(t2 >= t1)) return false;
-        }
-    else if (isLess)
-        {
-        if ( (t1 == t2)) return false;
-        if ( (t2 == t1)) return false;
-        if (!(t1 != t2)) return false;
-        if (!(t2 != t1)) return false;
-        if (!(t1  < t2)) return false;
-        if ( (t2  < t1)) return false;
-        if (!(t1 <= t2)) return false;
-        if ( (t2 <= t1)) return false;
-        if ( (t1  > t2)) return false;
-        if (!(t2  > t1)) return false;
-        if ( (t1 >= t2)) return false;
-        if (!(t2 >= t1)) return false;
-        }
-    else /* greater */
-        {
-        if ( (t1 == t2)) return false;
-        if ( (t2 == t1)) return false;
-        if (!(t1 != t2)) return false;
-        if (!(t2 != t1)) return false;
-        if ( (t1  < t2)) return false;
-        if (!(t2  < t1)) return false;
-        if ( (t1 <= t2)) return false;
-        if (!(t2 <= t1)) return false;
-        if (!(t1  > t2)) return false;
-        if ( (t2  > t1)) return false;
-        if (!(t1 >= t2)) return false;
-        if ( (t2 >= t1)) return false;
-        }
+TEST_CONSTEXPR_CXX14 bool testComparisons(const T& t1, const U& t2, bool isEqual, bool isLess) {
+  if (isEqual) {
+    if (!(t1 == t2))
+      return false;
+    if (!(t2 == t1))
+      return false;
+    if ((t1 != t2))
+      return false;
+    if ((t2 != t1))
+      return false;
+    if ((t1 < t2))
+      return false;
+    if ((t2 < t1))
+      return false;
+    if (!(t1 <= t2))
+      return false;
+    if (!(t2 <= t1))
+      return false;
+    if ((t1 > t2))
+      return false;
+    if ((t2 > t1))
+      return false;
+    if (!(t1 >= t2))
+      return false;
+    if (!(t2 >= t1))
+      return false;
+  } else if (isLess) {
+    if ((t1 == t2))
+      return false;
+    if ((t2 == t1))
+      return false;
+    if (!(t1 != t2))
+      return false;
+    if (!(t2 != t1))
+      return false;
+    if (!(t1 < t2))
+      return false;
+    if ((t2 < t1))
+      return false;
+    if (!(t1 <= t2))
+      return false;
+    if ((t2 <= t1))
+      return false;
+    if ((t1 > t2))
+      return false;
+    if (!(t2 > t1))
+      return false;
+    if ((t1 >= t2))
+      return false;
+    if (!(t2 >= t1))
+      return false;
+  } else /* greater */
+  {
+    if ((t1 == t2))
+      return false;
+    if ((t2 == t1))
+      return false;
+    if (!(t1 != t2))
+      return false;
+    if (!(t2 != t1))
+      return false;
+    if ((t1 < t2))
+      return false;
+    if (!(t2 < t1))
+      return false;
+    if ((t1 <= t2))
+      return false;
+    if (!(t2 <= t1))
+      return false;
+    if (!(t1 > t2))
+      return false;
+    if ((t2 > t1))
+      return false;
+    if (!(t1 >= t2))
+      return false;
+    if ((t2 >= t1))
+      return false;
 
-    return true;
 }
 
 //  Easy call when you can init from something already comparable.
 template <class T, class Param>
-TEST_CONSTEXPR_CXX14 bool testComparisonsValues(Param val1, Param val2)
-{
-    const bool isEqual = val1 == val2;
-    const bool isLess  = val1  < val2;
+TEST_CONSTEXPR_CXX14 bool testComparisonsValues(Param val1, Param val2) {
+  const bool isLess  = val1 < val2;
 
-    return testComparisons(T(val1), T(val2), isEqual, isLess);
 }
 
 template <class T, class U = T>
 TEST_CONSTEXPR_CXX14 void AssertComparisonsAreNoexcept() {
-    ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() <  std::declval<const U&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() <= std::declval<const U&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() >  std::declval<const U&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() >= std::declval<const U&>());
+  ASSERT_NOEXCEPT(std::declval<const T&>() < std::declval<const U&>());
+  ASSERT_NOEXCEPT(std::declval<const T&>() > std::declval<const U&>());
 }
 
 template <class T, class U = T>
 TEST_CONSTEXPR_CXX14 void AssertComparisonsReturnBool() {
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <  std::declval<const U&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <= std::declval<const U&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >  std::declval<const U&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >= std::declval<const U&>()), bool);
+  ASSERT_SAME_TYPE(decltype(std::declval<const T&>() < std::declval<const U&>()), bool);
+  ASSERT_SAME_TYPE(decltype(std::declval<const T&>() > std::declval<const U&>()), bool);
 }
 
 template <class T, class U = T>
-void AssertComparisonsConvertibleToBool()
-{
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() <  std::declval<const U&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() <= std::declval<const U&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() >  std::declval<const U&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() >= std::declval<const U&>()), bool>::value), "");
+void AssertComparisonsConvertibleToBool() {
+  static_assert((std::is_convertible<decltype(std::declval<const T&>() < std::declval<const U&>()), bool>::value), "");
+  static_assert((std::is_convertible<decltype(std::declval<const T&>() > std::declval<const U&>()), bool>::value), "");
 }
 
 #if TEST_STD_VER > 17
 template <class T, class U = T>
 constexpr void AssertOrderAreNoexcept() {
-    AssertComparisonsAreNoexcept<T, U>();
-    ASSERT_NOEXCEPT(std::declval<const T&>() <=> std::declval<const U&>());
 }
 
 template <class Order, class T, class U = T>
 constexpr void AssertOrderReturn() {
-    AssertComparisonsReturnBool<T, U>();
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <=> std::declval<const U&>()), Order);
 }
 
 template <class Order, class T, class U = T>
 constexpr bool testOrder(const T& t1, const U& t2, Order order) {
-    bool equal = order == Order::equivalent;
-    if constexpr (std::same_as<Order, std::strong_ordering>)
-        equal |= order == Order::equal;
 
-    bool less = order == Order::less;
 
-    return (t1 <=> t2 == order) && testComparisons(t1, t2, equal, less);
 }
 
 template <class T, class Param>
 constexpr bool testOrderValues(Param val1, Param val2) {
   return testOrder(T(val1), T(val2), val1 <=> val2);
 }
 
 #endif
 
 //  Test all two comparison operations for sanity
 template <class T, class U = T>
-TEST_CONSTEXPR_CXX14 bool testEquality(const T& t1, const U& t2, bool isEqual)
-{
-    if (isEqual)
-        {
-        if (!(t1 == t2)) return false;
-        if (!(t2 == t1)) return false;
-        if ( (t1 != t2)) return false;
-        if ( (t2 != t1)) return false;
-        }
-    else /* not equal */
-        {
-        if ( (t1 == t2)) return false;
-        if ( (t2 == t1)) return false;
-        if (!(t1 != t2)) return false;
-        if (!(t2 != t1)) return false;
-        }
+TEST_CONSTEXPR_CXX14 bool testEquality(const T& t1, const U& t2, bool isEqual) {
+  if (isEqual) {
+    if (!(t1 == t2))
+      return false;
+    if (!(t2 == t1))
+      return false;
+    if ((t1 != t2))
+      return false;
+    if ((t2 != t1))
+      return false;
+  } else /* not equal */
+  {
+    if ((t1 == t2))
+      return false;
+    if ((t2 == t1))
+      return false;
+    if (!(t1 != t2))
+      return false;
+    if (!(t2 != t1))
+      return false;
 
-    return true;
 }
 
 //  Easy call when you can init from something already comparable.
 template <class T, class Param>
-TEST_CONSTEXPR_CXX14 bool testEqualityValues(Param val1, Param val2)
-{
-    const bool isEqual = val1 == val2;
+TEST_CONSTEXPR_CXX14 bool testEqualityValues(Param val1, Param val2) {
 
-    return testEquality(T(val1), T(val2), isEqual);
 }
 
 template <class T, class U = T>
-void AssertEqualityAreNoexcept()
-{
-    ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
+TEST_CONSTEXPR_CXX23 void AssertEqualityAreNoexcept() {
 }
 
 template <class T, class U = T>
-void AssertEqualityReturnBool()
-{
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
+void AssertEqualityReturnBool() {
 }
 
-
 template <class T, class U = T>
-void AssertEqualityConvertibleToBool()
-{
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
+void AssertEqualityConvertibleToBool() {
 }
 
 struct LessAndEqComp {
   int value;
 
   TEST_CONSTEXPR_CXX14 LessAndEqComp(int v) : value(v) {}
 
   friend TEST_CONSTEXPR_CXX14 bool operator<(const LessAndEqComp& lhs, const LessAndEqComp& rhs) {
     return lhs.value < rhs.value;
   }
 
   friend TEST_CONSTEXPR_CXX14 bool operator==(const LessAndEqComp& lhs, const LessAndEqComp& rhs) {
     return lhs.value == rhs.value;
   }
 };
 #endif // TEST_COMPARISONS_H

libcxx/test/support/test_macros.h

 #endif
 
 #if TEST_STD_VER >= 20
 # define TEST_CONSTEXPR_CXX20 constexpr
 #else
 # define TEST_CONSTEXPR_CXX20
 #endif
 
+#if TEST_STD_VER >= 23
+# define TEST_CONSTEXPR_CXX23 constexpr
+#else
+# define TEST_CONSTEXPR_CXX23
+#endif
+
 #define TEST_ALIGNAS_TYPE(...) TEST_ALIGNAS(TEST_ALIGNOF(__VA_ARGS__))
 
 #if !TEST_HAS_FEATURE(cxx_rtti) && !defined(__cpp_rtti) \
     && !defined(__GXX_RTTI)
 #define TEST_HAS_NO_RTTI
 #endif
 
 #if !defined(TEST_HAS_NO_RTTI)

libcxx/test/support/unique_ptr_test_helper.h

struct B : public A {
   B() { ++count; }
   B(const B& other) : A(other) { ++count; }
   virtual ~B() { --count; }
 };
 
 int B::count = 0;
 
 template <class T>
-typename std::enable_if<!std::is_array<T>::value, T*>::type
-newValue(int num_elements) {
+TEST_CONSTEXPR_CXX23 typename std::enable_if<!std::is_array<T>::value, T*>::type newValue(int num_elements) {
   assert(num_elements == 1);
   return new T;
 }
 
 template <class T>
-typename std::enable_if<std::is_array<T>::value,
-                        typename std::remove_all_extents<T>::type*>::type
+TEST_CONSTEXPR_CXX23 typename std::enable_if<std::is_array<T>::value, typename std::remove_all_extents<T>::type*>::type
 newValue(int num_elements) {
   typedef typename std::remove_all_extents<T>::type VT;
   assert(num_elements >= 1);
   return new VT[num_elements];
 }
 
 struct IncompleteType;
 
 void checkNumIncompleteTypeAlive(int i);
 int getNumIncompleteTypeAlive();
 IncompleteType* getNewIncomplete();
 IncompleteType* getNewIncompleteArray(int size);
 
 #if TEST_STD_VER >= 11
-template <class ThisT, class ...Args>
+template <class ThisT, class... Args>
 struct args_is_this_type : std::false_type {};
 
 template <class ThisT, class A1>
 struct args_is_this_type<ThisT, A1> : std::is_same<ThisT, typename std::decay<A1>::type> {};
 #endif
 
-template <class IncompleteT = IncompleteType,
-          class Del = std::default_delete<IncompleteT> >
+template <class IncompleteT = IncompleteType, class Del = std::default_delete<IncompleteT> >
 struct StoresIncomplete {
-  static_assert((std::is_same<IncompleteT, IncompleteType>::value ||
-                 std::is_same<IncompleteT, IncompleteType[]>::value), "");
+  static_assert(
+      (std::is_same<IncompleteT, IncompleteType>::value || std::is_same<IncompleteT, IncompleteType[]>::value), "");
 
   std::unique_ptr<IncompleteT, Del> m_ptr;
 
 #if TEST_STD_VER >= 11
   StoresIncomplete(StoresIncomplete const&) = delete;
-  StoresIncomplete(StoresIncomplete&&) = default;
+  StoresIncomplete(StoresIncomplete&&)      = default;
 
-  template <class ...Args>
+  template <class... Args>
   StoresIncomplete(Args&&... args) : m_ptr(std::forward<Args>(args)...) {
     static_assert(!args_is_this_type<StoresIncomplete, Args...>::value, "");
   }
 #else
+
 private:
   StoresIncomplete();
   StoresIncomplete(StoresIncomplete const&);
+
 public:
 #endif
 
   ~StoresIncomplete();
 
   IncompleteType* get() const { return m_ptr.get(); }
   Del& get_deleter() { return m_ptr.get_deleter(); }
 };
 
 #if TEST_STD_VER >= 11
-template <class IncompleteT = IncompleteType,
-          class Del = std::default_delete<IncompleteT>, class... Args>
+template <class IncompleteT = IncompleteType, class Del = std::default_delete<IncompleteT>, class... Args>
 void doIncompleteTypeTest(int expect_alive, Args&&... ctor_args) {
   checkNumIncompleteTypeAlive(expect_alive);
   {
     StoresIncomplete<IncompleteT, Del> sptr(std::forward<Args>(ctor_args)...);
     checkNumIncompleteTypeAlive(expect_alive);
     if (expect_alive == 0)
       assert(sptr.get() == nullptr);
     else
       assert(sptr.get() != nullptr);
   }
   checkNumIncompleteTypeAlive(0);
 }
 #endif
 
-#define INCOMPLETE_TEST_EPILOGUE()                                             \
-  int is_incomplete_test_anchor = is_incomplete_test();                        \
+#define INCOMPLETE_TEST_EPILOGUE()                                                                                     \
+  int is_incomplete_test_anchor = is_incomplete_test();                                                                \
                                                                                                                        \
-  struct IncompleteType {                                                      \
-    static int count;                                                          \
-    IncompleteType() { ++count; }                                              \
-    ~IncompleteType() { --count; }                                             \
-  };                                                                           \
+  struct IncompleteType {                                                                                              \
+    static int count;                                                                                                  \
+    IncompleteType() { ++count; }                                                                                      \
+    ~IncompleteType() { --count; }                                                                                     \
+  };                                                                                                                   \
                                                                                                                        \
-  int IncompleteType::count = 0;                                               \
+  int IncompleteType::count = 0;                                                                                       \
                                                                                                                        \
-  void checkNumIncompleteTypeAlive(int i) {                                    \
-    assert(IncompleteType::count == i);                                        \
-  }                                                                            \
-  int getNumIncompleteTypeAlive() { return IncompleteType::count; }            \
-  IncompleteType* getNewIncomplete() { return new IncompleteType; }            \
-  IncompleteType* getNewIncompleteArray(int size) {                            \
-    return new IncompleteType[size];                                           \
-  }                                                                            \
+  void checkNumIncompleteTypeAlive(int i) { assert(IncompleteType::count == i); }                                      \
+  int getNumIncompleteTypeAlive() { return IncompleteType::count; }                                                    \
+  IncompleteType* getNewIncomplete() { return new IncompleteType; }                                                    \
+  IncompleteType* getNewIncompleteArray(int size) { return new IncompleteType[size]; }                                 \
                                                                                                                        \
-  template <class IncompleteT, class Del>                                      \
+  template <class IncompleteT, class Del>                                                                              \
   StoresIncomplete<IncompleteT, Del>::~StoresIncomplete() {}
 #
 
 #if TEST_STD_VER >= 11
-#define DEFINE_AND_RUN_IS_INCOMPLETE_TEST(...)                                 \
-  static int is_incomplete_test() { __VA_ARGS__ return 0; }                    \
+#  define DEFINE_AND_RUN_IS_INCOMPLETE_TEST(...)                                                                       \
+    static int is_incomplete_test() { __VA_ARGS__ return 0; }                                                          \
     INCOMPLETE_TEST_EPILOGUE()
 #else
-#define DEFINE_AND_RUN_IS_INCOMPLETE_TEST(...)                                 \
-  static int is_incomplete_test() { return 0; }                                \
+#  define DEFINE_AND_RUN_IS_INCOMPLETE_TEST(...)                                                                       \
+    static int is_incomplete_test() { return 0; }                                                                      \
     INCOMPLETE_TEST_EPILOGUE()
 #endif
 
 #endif // TEST_SUPPORT_UNIQUE_PTR_TEST_HELPER_H

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "values": { "c++20": 201907 },
     "headers": ["functional"],
   }, {
     "name": "__cpp_lib_constexpr_iterator",
     "values": { "c++20": 201811 },
     "headers": ["iterator"],
   }, {
     "name": "__cpp_lib_constexpr_memory",
-    "values": { "c++20": 201811 },
+    "values": { "c++20": 201811, "c++2b": 202202 },
     "headers": ["memory"],
   }, {
     "name": "__cpp_lib_constexpr_numeric",
     "values": { "c++20": 201911 },
     "headers": ["numeric"],
   }, {
     "name": "__cpp_lib_constexpr_string",
     "values": { "c++20": 201907 },