[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

46–47

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

52–55

[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.)

513

This isn't used in C++23.

553

You missed this one after rebasing

561

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

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 ↗

(On Diff #450736)

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!

479

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

488–491

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

26–33

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

50

Please add return 0;.

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

46

Please add return 0;.

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

45

Please add return 0;.

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

48

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_bind_back``                           *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_byteswap``                            ``202110L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_bitset``                    ``202207L``
     ------------------------------------------------- -----------------
     ``__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

 
 What's New in Libc++ 16.0.0?
 ============================
 
 Implemented Papers
 ------------------
 - P2499R0 - ``string_view`` range constructor should be ``explicit``
 - P2417R2 - A more constexpr bitset
+- P2273R3 - Making ``std::unique_ptr`` constexpr
 
 Improvements and New Features
 -----------------------------
 
 Deprecations and Removals
 -------------------------
 - Several incidental transitive includes have been removed from libc++. Those
   includes are removed based on the language version used. Incidental transitive

libcxx/docs/Status/Cxx2b.rst

 Paper Status
 ====================================
 
 .. csv-table::
    :file: Cxx2bPapers.csv
    :header-rows: 1
    :widths: auto
 
+.. note::
+
+   .. [#note-P2273] P2273: ``make_unique_for_overwrite`` isn't done yet since `P1020` hasn't been implemented yet.
+
 .. _issues-status-cxx2b:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx2bIssues.csv
    :header-rows: 1
    :widths: auto

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","|Partial| [#note-P2273]_","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/__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
-  default_delete(const default_delete<_Up>&,
-                 typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* =
-                     0) _NOEXCEPT {}
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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_SINCE_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
-  default_delete(const default_delete<_Up[]>&,
-                 typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPT {}
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
+  default_delete(const default_delete<_Up[]>&, typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPT {}
 
   template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY
-  typename _EnableIfConvertible<_Up>::type
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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>
 struct __unique_ptr_deleter_sfinae {
public:
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(__value_init_tag(), __value_init_tag()) {}
 
   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
-  explicit unique_ptr(pointer __p) _NOEXCEPT : __ptr_(__p, __value_init_tag()) {}
+  template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy> >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit unique_ptr(pointer __p) _NOEXCEPT
+      : __ptr_(__p, __value_init_tag()) {}
 
-  template <bool _Dummy = true,
-            class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr(pointer __p, _LValRefType<_Dummy> __d) _NOEXCEPT
+  template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(pointer __p, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, __d) {}
 
-  template <bool _Dummy = true,
-            class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
-      : __ptr_(__p, _VSTD::move(__d)) {
+  template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-  unique_ptr(unique_ptr&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
-  }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr&& __u) _NOEXCEPT
+      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {}
 
-  template <class _Up, class _Ep,
+  template <class _Up,
+            class _Ep,
             class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
-      class = _EnableIfDeleterConvertible<_Ep>
-  >
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
+            class = _EnableIfDeleterConvertible<_Ep> >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-  unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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,
+  template <class _Up,
+            class _Ep,
             class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
-      class = _EnableIfDeleterAssignable<_Ep>
-  >
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
+            class = _EnableIfDeleterAssignable<_Ep> >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-  ~unique_ptr() { reset(); }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 ~unique_ptr() { reset(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr& operator=(nullptr_t) _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  typename add_lvalue_reference<_Tp>::type
-  operator*() const {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 typename add_lvalue_reference<_Tp>::type operator*() const {
     return *__ptr_.first();
   }
-  _LIBCPP_INLINE_VISIBILITY
-  pointer operator->() const _NOEXCEPT {
-    return __ptr_.first();
-  }
-  _LIBCPP_INLINE_VISIBILITY
-  pointer get() const _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer operator->() const _NOEXCEPT {
     return __ptr_.first();
   }
-  _LIBCPP_INLINE_VISIBILITY
-  deleter_type& get_deleter() _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer get() const _NOEXCEPT { return __ptr_.first(); }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 deleter_type& get_deleter() _NOEXCEPT {
     return __ptr_.second();
   }
-  _LIBCPP_INLINE_VISIBILITY
-  const deleter_type& get_deleter() const _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 const deleter_type& get_deleter() const _NOEXCEPT {
     return __ptr_.second();
   }
-  _LIBCPP_INLINE_VISIBILITY
-  explicit operator bool() const _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit operator bool() const _NOEXCEPT {
     return __ptr_.first() != nullptr;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  pointer release() _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer release() _NOEXCEPT {
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void reset(pointer __p = pointer()) _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(pointer __p = pointer()) _NOEXCEPT {
     pointer __tmp = __ptr_.first();
     __ptr_.first() = __p;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void swap(unique_ptr& __u) _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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:
public:
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(__value_init_tag(), __value_init_tag()) {}
 
   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
-  explicit unique_ptr(_Pp __p) _NOEXCEPT
+  template <class _Pp,
+            bool _Dummy = true,
+            class       = _EnableIfDeleterDefaultConstructible<_Dummy>,
+            class       = _EnableIfPointerConvertible<_Pp> >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-  unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) _NOEXCEPT
+  template <class _Pp,
+            bool _Dummy = true,
+            class       = _EnableIfDeleterConstructible<_LValRefType<_Dummy> >,
+            class       = _EnableIfPointerConvertible<_Pp> >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, __d) {}
 
-  template <bool _Dummy = true,
-            class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) _NOEXCEPT
+  template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-  unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
+  template <class _Pp,
+            bool _Dummy = true,
+            class       = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> >,
+            class       = _EnableIfPointerConvertible<_Pp> >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-  unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
+  template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-  unique_ptr(unique_ptr&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
-  }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr&& __u) _NOEXCEPT
+      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {}
 
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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,
+  template <class _Up,
+            class _Ep,
             class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
-      class = _EnableIfDeleterConvertible<_Ep>
-  >
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {
-  }
+            class = _EnableIfDeleterConvertible<_Ep> >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
+      : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
 
-  template <class _Up, class _Ep,
+  template <class _Up,
+            class _Ep,
             class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
-      class = _EnableIfDeleterAssignable<_Ep>
-  >
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr&
-  operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
+            class = _EnableIfDeleterAssignable<_Ep> >
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-  ~unique_ptr() { reset(); }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 ~unique_ptr() { reset(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr& operator=(nullptr_t) _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  typename add_lvalue_reference<_Tp>::type
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 typename add_lvalue_reference<_Tp>::type
   operator[](size_t __i) const {
     return __ptr_.first()[__i];
   }
-  _LIBCPP_INLINE_VISIBILITY
-  pointer get() const _NOEXCEPT {
-    return __ptr_.first();
-  }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer get() const _NOEXCEPT { return __ptr_.first(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  deleter_type& get_deleter() _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 deleter_type& get_deleter() _NOEXCEPT {
     return __ptr_.second();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  const deleter_type& get_deleter() const _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 const deleter_type& get_deleter() const _NOEXCEPT {
     return __ptr_.second();
   }
-  _LIBCPP_INLINE_VISIBILITY
-  explicit operator bool() const _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit operator bool() const _NOEXCEPT {
     return __ptr_.first() != nullptr;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  pointer release() _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer release() _NOEXCEPT {
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;
   }
 
   template <class _Pp>
-  _LIBCPP_INLINE_VISIBILITY
-  typename enable_if<
-      _CheckArrayPointerConversion<_Pp>::value
-  >::type
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-  void reset(nullptr_t = nullptr) _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(nullptr_t = nullptr) _NOEXCEPT {
     pointer __tmp = __ptr_.first();
     __ptr_.first() = nullptr;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void swap(unique_ptr& __u) _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void swap(unique_ptr& __u) _NOEXCEPT {
     __ptr_.swap(__u.__ptr_);
   }
-
 };
 
 template <class _Tp, class _Dp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<
-    __is_swappable<_Dp>::value,
-    void
->::type
-swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {__x.swap(__y);}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-bool
-operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();}
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_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
-bool
-operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT
-{
-    return !__x;
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT {
 }
 
 #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
-bool
-operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t)
-{
-    typedef typename unique_ptr<_T1, _D1>::pointer _P1;
-    return less<_P1>()(__x.get(), nullptr);
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x)
-{
-    typedef typename unique_ptr<_T1, _D1>::pointer _P1;
-    return less<_P1>()(nullptr, __x.get());
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t)
-{
-    return nullptr < __x;
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x)
-{
-    return __x < nullptr;
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
-{
-    return !(nullptr < __x);
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
-{
-    return !(__x < nullptr);
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
-{
-    return !(__x < nullptr);
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
-{
-    return !(nullptr < __x);
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __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
+  requires three_way_comparable<
+      typename unique_ptr<_T1, _D1>::pointer> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_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>

 };
 
 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
-typename __unique_if<_Tp>::__unique_single
-make_unique(_Args&&... __args)
-{
-    return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...));
+template <class _Tp, class... _Args>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __unique_if<_Tp>::__unique_single
+make_unique(_Args&&... __args) {
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-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>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __unique_if<_Tp>::__unique_array_unknown_bound
+make_unique(size_t __n) {
 }
 
 template<class _Tp, class... _Args>
     typename __unique_if<_Tp>::__unique_array_known_bound
     make_unique(_Args&&...) = delete;
 
 #endif // _LIBCPP_STD_VER > 11
 

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> constexpr default_delete(const default_delete<U>&) noexcept; // constexpr since C++23
 
-    void operator()(T*) const noexcept;
+    constexpr 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> constexpr default_delete(const default_delete <U[]>&) noexcept; // constexpr since C++23
+    constexpr 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() { }
+    constexpr explicit unique_ptr(pointer p) noexcept;           // constexpr since C++23
+    constexpr unique_ptr(pointer p, see below d1) noexcept;      // constexpr since C++23
+    constexpr unique_ptr(pointer p, see below d2) noexcept;      // constexpr since C++23
+    constexpr 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;
+        constexpr 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
+        unique_ptr(auto_ptr<U>&& u) noexcept;                    // removed in C++17
 
     // destructor
-    ~unique_ptr();
+    constexpr ~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;
+    constexpr unique_ptr& operator=(unique_ptr&& u) noexcept;                         // constexpr since C++23
+    template <class U, class E>
+    constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;                   // constexpr since C++23
+    constexpr 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 constexpr add_lvalue_reference<T>::type operator*() const;               // constexpr since C++23
+    constexpr pointer operator->() const noexcept;                                    // constexpr since C++23
+    constexpr pointer get() const noexcept;                                           // constexpr since C++23
+    constexpr deleter_type& get_deleter() noexcept;                                   // constexpr since C++23
+    constexpr const deleter_type& get_deleter() const noexcept;                       // constexpr since C++23
+    constexpr 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;
+    constexpr pointer release() noexcept;                                             // constexpr since C++23
+    constexpr void reset(pointer p = pointer()) noexcept;                             // constexpr since C++23
+    constexpr 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() { }
+    constexpr explicit unique_ptr(pointer p) noexcept;          // constexpr since C++23
+    constexpr unique_ptr(pointer p, see below d) noexcept;      // constexpr since C++23
+    constexpr unique_ptr(pointer p, see below d) noexcept;      // constexpr since C++23
+    constexpr unique_ptr(unique_ptr&& u) noexcept;              // constexpr since C++23
+    template <class U, class E>
+    constexpr unique_ptr(unique_ptr <U, E>&& u) noexcept;       // constexpr since C++23
+    constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
 
     // destructor
-    ~unique_ptr();
+    constexpr ~unique_ptr();                                    // constexpr since C++23
 
     // assignment
-    unique_ptr& operator=(unique_ptr&& u) noexcept;
-    unique_ptr& operator=(nullptr_t) noexcept;
+    constexpr unique_ptr& operator=(unique_ptr&& u) noexcept;        // constexpr since C++23
+    template <class U, class E>
+    constexpr unique_ptr& operator=(unique_ptr <U, E>&& u) noexcept; // constexpr since C++23
+    constexpr 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;
+    constexpr T& operator[](size_t i) const;                    // constexpr since C++23
+    constexpr pointer get() const noexcept;                     // constexpr since C++23
+    constexpr deleter_type& get_deleter() noexcept;             // constexpr since C++23
+    constexpr const deleter_type& get_deleter() const noexcept; // constexpr since C++23
+    constexpr explicit operator bool() const noexcept;          // constexpr since C++23
 
     // modifiers
-    pointer release() noexcept;
-    void reset(pointer p = pointer()) noexcept;
-    void reset(nullptr_t) noexcept;
+    constexpr pointer release() noexcept;                       // constexpr since C++23
+    constexpr void reset(pointer p = pointer()) noexcept;       // constexpr since C++23
+    constexpr void reset(nullptr_t) noexcept;                   // constexpr since C++23
   template <class U> void reset(U) = delete;
-    void swap(unique_ptr& u) noexcept;
+    constexpr 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;
+    constexpr 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);
+    constexpr 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
+    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;
+    constexpr 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
+    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
+    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
+    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);
+    constexpr 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);
+    constexpr 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);
+    constexpr 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);
+    constexpr 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);
+    constexpr 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);
+    constexpr 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);
+    constexpr 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);
+    constexpr 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
+    constexpr 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>
+constexpr unique_ptr<T> make_unique(Args&&... args);                            // C++14, constexpr since C++23
+template<class T>
+constexpr 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_concepts                                      202002L <concepts>
 __cpp_lib_constexpr_algorithms                          201806L <algorithm>
 __cpp_lib_constexpr_bitset                              202207L <bitset>
 __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_bitset                     202207L
 // # 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_constexpr_algorithms                 201806L [C++20]
     __cpp_lib_constexpr_bitset                     202207L [C++2b]
     __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/pointer_type.pass.cpp

private:
   typedef void pointer;
 };
 
 struct D3 {
   static long pointer;
 };
 
 template <bool IsArray>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<IsArray, int[], int>::type VT;
   {
     typedef std::unique_ptr<VT> P;
     static_assert((std::is_same<typename P::pointer, int*>::value), "");
   }
   {
     typedef std::unique_ptr<VT, Deleter> P;
     static_assert((std::is_same<typename P::pointer, Deleter::pointer>::value),
                   "");
   }
 #if TEST_STD_VER >= 11
   {
     typedef std::unique_ptr<VT, D2> P;
     static_assert(std::is_same<typename P::pointer, int*>::value, "");
   }
   {
     typedef std::unique_ptr<VT, D3> P;
     static_assert(std::is_same<typename P::pointer, int*>::value, "");
   }
 #endif
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
+  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.asgn/move.pass.cpp

 #include "deleter_types.h"
 #include "unique_ptr_test_helper.h"
 
 struct GenericDeleter {
   void operator()(void*) const;
 };
 
 template <bool IsArray>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
   {
     std::unique_ptr<VT> s1(newValue<VT>(expect_alive));
     A* p = s1.get();
     std::unique_ptr<VT> s2(newValue<VT>(expect_alive));
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == (expect_alive * 2));
     s2 = std::move(s1);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     assert(s2.get() == p);
     assert(s1.get() == 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   {
     std::unique_ptr<VT, Deleter<VT> > s1(newValue<VT>(expect_alive),
                                          Deleter<VT>(5));
     A* p = s1.get();
     std::unique_ptr<VT, Deleter<VT> > s2(newValue<VT>(expect_alive));
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == (expect_alive * 2));
     s2 = std::move(s1);
     assert(s2.get() == p);
     assert(s1.get() == 0);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     assert(s2.get_deleter().state() == 5);
     assert(s1.get_deleter().state() == 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   {
     CDeleter<VT> d1(5);
     std::unique_ptr<VT, CDeleter<VT>&> s1(newValue<VT>(expect_alive), d1);
     A* p = s1.get();
     CDeleter<VT> d2(6);
     std::unique_ptr<VT, CDeleter<VT>&> s2(newValue<VT>(expect_alive), d2);
     s2 = std::move(s1);
     assert(s2.get() == p);
     assert(s1.get() == 0);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     assert(d1.state() == 5);
     assert(d2.state() == 5);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   {
     std::unique_ptr<VT> s(newValue<VT>(expect_alive));
     A* p = s.get();
     s = std::move(s);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     assert(s.get() == p);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 }
 
 template <bool IsArray>
-void test_sfinae() {
+TEST_CONSTEXPR_CXX23 void test_sfinae() {
   typedef typename std::conditional<IsArray, int[], int>::type VT;
   {
     typedef std::unique_ptr<VT> U;
     static_assert(!std::is_assignable<U, U&>::value, "");
     static_assert(!std::is_assignable<U, const U&>::value, "");
     static_assert(!std::is_assignable<U, const U&&>::value, "");
     static_assert(std::is_nothrow_assignable<U, U&&>::value, "");
   }
typedef typename std::conditional<IsArray, int[], int>::type VT;
     typedef std::unique_ptr<VT, const NCDeleter<VT>&> U;
     static_assert(!std::is_assignable<U, U&>::value, "");
     static_assert(!std::is_assignable<U, const U&>::value, "");
     static_assert(!std::is_assignable<U, const U&&>::value, "");
     static_assert(std::is_nothrow_assignable<U, U&&>::value, "");
   }
 }
 
-
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_basic</*IsArray*/ false>();
     test_sfinae<false>();
   }
   {
     test_basic</*IsArray*/ true>();
     test_sfinae<true>();
   }
 
+  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.asgn/move_convert.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 #include "type_id.h"
 
 template <int ID = 0>
 struct GenericDeleter {
-  void operator()(void*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
 };
 
 template <int ID = 0>
 struct GenericConvertingDeleter {
-
   template <int OID>
-  GenericConvertingDeleter(GenericConvertingDeleter<OID>) {}
+  TEST_CONSTEXPR_CXX23 GenericConvertingDeleter(GenericConvertingDeleter<OID>) {}
 
   template <int OID>
-  GenericConvertingDeleter& operator=(GenericConvertingDeleter<OID> const&) {
+  TEST_CONSTEXPR_CXX23 GenericConvertingDeleter& operator=(GenericConvertingDeleter<OID> const&) {
     return *this;
   }
 
-  void operator()(void*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
 };
 
 template <class T, class U>
 using EnableIfNotSame = typename std::enable_if<
     !std::is_same<typename std::decay<T>::type, typename std::decay<U>::type>::value
 >::type;
 
 template <class Templ, class Other>

 
 template <class ExpectT, int ID>
 bool checkArg(ConstTrackingDeleter<ID> const& d) {
   return d.arg_type && *d.arg_type == makeArgumentID<ExpectT>();
 }
 
 template <class From, bool AssignIsConst = false>
 struct AssignDeleter {
-  AssignDeleter() = default;
-  AssignDeleter(AssignDeleter const&) = default;
-  AssignDeleter(AssignDeleter&&) = default;
+  TEST_CONSTEXPR_CXX23 AssignDeleter()                     = default;
+  TEST_CONSTEXPR_CXX23 AssignDeleter(AssignDeleter const&) = default;
+  TEST_CONSTEXPR_CXX23 AssignDeleter(AssignDeleter&&)      = default;
 
   AssignDeleter& operator=(AssignDeleter const&) = delete;
   AssignDeleter& operator=(AssignDeleter &&) = delete;
 
   template <class T> AssignDeleter& operator=(T&&) && = delete;
   template <class T> AssignDeleter& operator=(T&&) const && = delete;
 
-  template <class T, class = typename std::enable_if<
-      std::is_same<T&&, From>::value && !AssignIsConst
-    >::type>
-  AssignDeleter& operator=(T&&) & { return *this; }
-
-  template <class T, class = typename std::enable_if<
-      std::is_same<T&&, From>::value && AssignIsConst
-    >::type>
-  const AssignDeleter& operator=(T&&) const & { return *this; }
+  template <class T, class = typename std::enable_if< std::is_same<T&&, From>::value && !AssignIsConst >::type>
+  TEST_CONSTEXPR_CXX23 AssignDeleter& operator=(T&&) & {
+    return *this;
+  }
+
+  template <class T, class = typename std::enable_if< std::is_same<T&&, From>::value && AssignIsConst >::type>
+  TEST_CONSTEXPR_CXX23 const AssignDeleter& operator=(T&&) const& {
+    return *this;
+  }
 
   template <class T>
-  void operator()(T) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(T) const {}
 };
 
 template <class VT, class DDest, class DSource>
-  void doDeleterTest() {
-    using U1 = std::unique_ptr<VT, DDest>;
-    using U2 = std::unique_ptr<VT, DSource>;
-    static_assert(std::is_nothrow_assignable<U1, U2&&>::value, "");
-    typename std::decay<DDest>::type ddest;
-    typename std::decay<DSource>::type dsource;
-    U1 u1(nullptr, ddest);
-    U2 u2(nullptr, dsource);
-    u1 = std::move(u2);
+TEST_CONSTEXPR_CXX23 void doDeleterTest() {
 }
 
 template <bool IsArray>
-void test_sfinae() {
+TEST_CONSTEXPR_CXX23 void test_sfinae() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
 
   { // Test that different non-reference deleter types are allowed so long
     // as they convert to each other.
     using U1 = std::unique_ptr<VT, GenericConvertingDeleter<0> >;
     using U2 = std::unique_ptr<VT, GenericConvertingDeleter<1> >;
     static_assert(std::is_assignable<U1, U2&&>::value, "");
   }
/////////////////////////////////////////////////////////////////////////////
     using AD = AssignDeleter<Del const&>;
     using ADC = AssignDeleter<Del const&, /*AllowConstAssign*/true>;
     doDeleterTest<VT, AD, Del const&>();
     doDeleterTest<VT, AD&, Del const&>();
     doDeleterTest<VT, ADC const&, Del const&>();
   }
 }
 
-
 template <bool IsArray>
-void test_noexcept() {
+TEST_CONSTEXPR_CXX23 void test_noexcept() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   {
     typedef std::unique_ptr<const VT> APtr;
     typedef std::unique_ptr<VT> BPtr;
     static_assert(std::is_nothrow_assignable<APtr, BPtr>::value, "");
   }
   {
     typedef std::unique_ptr<const VT, CDeleter<const VT> > APtr;
CD2 cd2;
     U1 u1(nullptr, cd1);
     U2 u2(nullptr, cd2);
     u1.get_deleter().reset();
     u1 = std::move(u2);
     assert(checkArg<CD2 const&>(u1.get_deleter()));
   }
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_sfinae</*IsArray*/false>();
     test_noexcept<false>();
+    if (!TEST_IS_CONSTANT_EVALUATED)
       test_deleter_value_category<false>();
   }
   {
     test_sfinae</*IsArray*/true>();
     test_noexcept<true>();
+    if (!TEST_IS_CONSTANT_EVALUATED)
       test_deleter_value_category<true>();
   }
 
+  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.asgn/move_convert.single.pass.cpp

 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "deleter_types.h"
 #include "unique_ptr_test_helper.h"
 
 template <class APtr, class BPtr>
-void testAssign(APtr& aptr, BPtr& bptr) {
+TEST_CONSTEXPR_CXX23 void testAssign(APtr& aptr, BPtr& bptr) {
   A* p = bptr.get();
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 2);
   aptr = std::move(bptr);
   assert(aptr.get() == p);
   assert(bptr.get() == 0);
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 1);
     assert(B::count == 1);
   }
+}
 
 template <class LHS, class RHS>
-void checkDeleter(LHS& lhs, RHS& rhs, int LHSState, int RHSState) {
+TEST_CONSTEXPR_CXX23 void checkDeleter(LHS& lhs, RHS& rhs, int LHSState, int RHSState) {
   assert(lhs.get_deleter().state() == LHSState);
   assert(rhs.get_deleter().state() == RHSState);
 }
 
 template <class T>
 struct NCConvertingDeleter {
-  NCConvertingDeleter() = default;
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter()                      = default;
   NCConvertingDeleter(NCConvertingDeleter const&) = delete;
-  NCConvertingDeleter(NCConvertingDeleter&&) = default;
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter(NCConvertingDeleter&&) = default;
 
   template <class U>
-  NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
 
-  void operator()(T*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(T*) const {}
 };
 
 template <class T>
 struct NCConvertingDeleter<T[]> {
-  NCConvertingDeleter() = default;
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter()                      = default;
   NCConvertingDeleter(NCConvertingDeleter const&) = delete;
-  NCConvertingDeleter(NCConvertingDeleter&&) = default;
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter(NCConvertingDeleter&&) = default;
 
   template <class U>
-  NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
 
-  void operator()(T*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(T*) const {}
 };
 
 struct NCGenericDeleter {
-  NCGenericDeleter() = default;
+  TEST_CONSTEXPR_CXX23 NCGenericDeleter()                   = default;
   NCGenericDeleter(NCGenericDeleter const&) = delete;
-  NCGenericDeleter(NCGenericDeleter&&) = default;
+  TEST_CONSTEXPR_CXX23 NCGenericDeleter(NCGenericDeleter&&) = default;
 
-  void operator()(void*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
 };
 
-void test_sfinae() {
+TEST_CONSTEXPR_CXX23 void test_sfinae() {
   using DA = NCConvertingDeleter<A>; // non-copyable deleters
   using DB = NCConvertingDeleter<B>;
   using UA = std::unique_ptr<A>;
   using UB = std::unique_ptr<B>;
   using UAD = std::unique_ptr<A, DA>;
   using UBD = std::unique_ptr<B, DB>;
   { // cannot move from an lvalue
     static_assert(std::is_assignable<UA, UB&&>::value, "");
using UBD = std::unique_ptr<B, DB>;
     using UA1 = std::unique_ptr<A, NCGenericDeleter>;
     using UA2 = std::unique_ptr<A[], NCGenericDeleter>;
     using UB1 = std::unique_ptr<B[], NCGenericDeleter>;
     static_assert(!std::is_assignable<UA1, UA2&&>::value, "");
     static_assert(!std::is_assignable<UA1, UB1&&>::value, "");
   }
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   test_sfinae();
   {
     std::unique_ptr<B> bptr(new B);
     std::unique_ptr<A> aptr(new A);
     testAssign(aptr, bptr);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
+  }
   {
     Deleter<B> del(42);
     std::unique_ptr<B, Deleter<B> > bptr(new B, std::move(del));
     std::unique_ptr<A, Deleter<A> > aptr(new A);
     testAssign(aptr, bptr);
     checkDeleter(aptr, bptr, 42, 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
+  }
   {
     CDeleter<A> adel(6);
     CDeleter<B> bdel(42);
     std::unique_ptr<B, CDeleter<B>&> bptr(new B, bdel);
     std::unique_ptr<A, CDeleter<A>&> aptr(new A, adel);
     testAssign(aptr, bptr);
     checkDeleter(aptr, bptr, 42, 42);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
+  }
+
+  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.asgn/null.pass.cpp

 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 // test assignment from null
 template <bool IsArray>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
   {
     std::unique_ptr<VT> s2(newValue<VT>(expect_alive));
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     s2 = NULL;
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == 0);
     assert(s2.get() == 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
+  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.asgn/nullptr.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 // test assignment from null
 
 template <bool IsArray>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
   {
     std::unique_ptr<VT> s2(newValue<VT>(expect_alive));
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     s2 = nullptr;
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == 0);
     assert(s2.get() == 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
+  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.ctor/deduct.pass.cpp

 
 // <memory>
 
 // unique_ptr
 
 // The following constructors should not be selected by class template argument
 // deduction:
 //
-// explicit unique_ptr(pointer p)
-// unique_ptr(pointer p, const D& d) noexcept
-// unique_ptr(pointer p, remove_reference_t<D>&& d) noexcept
+// constexpr explicit unique_ptr(pointer p) // constexpr since C++23
+// constexpr unique_ptr(pointer p, const D& d) noexcept // constexpr since C++23
+// constexpr unique_ptr(pointer p, remove_reference_t<D>&& d) noexcept // constexpr since C++23
 
 #include <memory>
 
 #include "deduction_guides_sfinae_checks.h"
 
 struct Deleter {
   void operator()(int* p) const { delete p; }
 };

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() {
+TEST_CONSTEXPR_CXX23 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_CONSTEXPR_CXX23 bool test() {
   {
     test_sfinae<int>();
     test_basic<int>();
   }
   {
     test_sfinae<int[]>();
     test_basic<int[]>();
   }
 
+  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.ctor/move.pass.cpp

 //  1 Explicitly construct unique_ptr<T, D> for various deleter types 'D'.
 //    check that the value and deleter have been properly moved. (C-1,2,3)
 //
 //  2 Use the expression 'sink(source())' to move construct a unique_ptr<T, D>
 //    from a temporary. 'source' should return the unique_ptr by value and
 //    'sink' should accept the unique_ptr by value. (C-1,2,4)
 
 template <class VT>
-std::unique_ptr<VT> source1() {
+TEST_CONSTEXPR_CXX23 std::unique_ptr<VT> source1() {
   return std::unique_ptr<VT>(newValue<VT>(1));
 }
 
 template <class VT>
-std::unique_ptr<VT, Deleter<VT> > source2() {
+TEST_CONSTEXPR_CXX23 std::unique_ptr<VT, Deleter<VT> > source2() {
   return std::unique_ptr<VT, Deleter<VT> >(newValue<VT>(1), Deleter<VT>(5));
 }
 
 template <class VT>
 std::unique_ptr<VT, NCDeleter<VT>&> source3() {
   static NCDeleter<VT> d(5);
   return std::unique_ptr<VT, NCDeleter<VT>&>(newValue<VT>(1), d);
 }
 
 template <class VT>
-void sink1(std::unique_ptr<VT> p) {
+TEST_CONSTEXPR_CXX23 void sink1(std::unique_ptr<VT> p) {
   assert(p.get() != nullptr);
 }
 
 template <class VT>
-void sink2(std::unique_ptr<VT, Deleter<VT> > p) {
+TEST_CONSTEXPR_CXX23 void sink2(std::unique_ptr<VT, Deleter<VT> > p) {
   assert(p.get() != nullptr);
   assert(p.get_deleter().state() == 5);
 }
 
 template <class VT>
 void sink3(std::unique_ptr<VT, NCDeleter<VT>&> p) {
   assert(p.get() != nullptr);
   assert(p.get_deleter().state() == 5);
   assert(&p.get_deleter() == &source3<VT>().get_deleter());
 }
 
 template <class ValueT>
-void test_sfinae() {
+TEST_CONSTEXPR_CXX23 void test_sfinae() {
   typedef std::unique_ptr<ValueT> U;
   { // Ensure unique_ptr is non-copyable
     static_assert((!std::is_constructible<U, U const&>::value), "");
     static_assert((!std::is_constructible<U, U&>::value), "");
   }
 }
 
 template <bool IsArray>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<!IsArray, A, A[]>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
   {
     typedef std::unique_ptr<VT> APtr;
     APtr s(newValue<VT>(expect_alive));
     A* p = s.get();
     APtr s2 = std::move(s);
     assert(s2.get() == p);
     assert(s.get() == 0);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   {
     typedef Deleter<VT> MoveDel;
     typedef std::unique_ptr<VT, MoveDel> APtr;
     MoveDel d(5);
     APtr s(newValue<VT>(expect_alive), std::move(d));
     assert(d.state() == 0);
     assert(s.get_deleter().state() == 5);
     A* p = s.get();
     APtr s2 = std::move(s);
     assert(s2.get() == p);
     assert(s.get() == 0);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     assert(s2.get_deleter().state() == 5);
     assert(s.get_deleter().state() == 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   {
     typedef NCDeleter<VT> NonCopyDel;
     typedef std::unique_ptr<VT, NonCopyDel&> APtr;
 
     NonCopyDel d;
     APtr s(newValue<VT>(expect_alive), d);
     A* p = s.get();
     APtr s2 = std::move(s);
     assert(s2.get() == p);
     assert(s.get() == 0);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     d.set_state(6);
     assert(s2.get_deleter().state() == d.state());
     assert(s.get_deleter().state() == d.state());
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   {
     sink1<VT>(source1<VT>());
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == 0);
     sink2<VT>(source2<VT>());
-    assert(A::count == 0);
-    sink3<VT>(source3<VT>());
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 }
 
 template <class VT>
-void test_noexcept() {
+TEST_CONSTEXPR_CXX23 void test_noexcept() {
 #if TEST_STD_VER >= 11
   {
     typedef std::unique_ptr<VT> U;
     static_assert(std::is_nothrow_move_constructible<U>::value, "");
   }
   {
     typedef std::unique_ptr<VT, Deleter<VT> > U;
     static_assert(std::is_nothrow_move_constructible<U>::value, "");
   }
   {
     typedef std::unique_ptr<VT, NCDeleter<VT> &> U;
     static_assert(std::is_nothrow_move_constructible<U>::value, "");
   }
   {
     typedef std::unique_ptr<VT, const NCConstDeleter<VT> &> U;
     static_assert(std::is_nothrow_move_constructible<U>::value, "");
   }
 #endif
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_basic</*IsArray*/ false>();
     test_sfinae<int>();
     test_noexcept<int>();
   }
   {
     test_basic</*IsArray*/ true>();
     test_sfinae<int[]>();
     test_noexcept<int[]>();
   }
 
+  return true;
+}
+
+template <bool IsArray>
+void test_sink3() {
+  typedef typename std::conditional<!IsArray, A, A[]>::type VT;
+  sink3<VT>(source3<VT>());
+  assert(A::count == 0);
+}
+
+int main(int, char**) {
+  test_sink3</*IsArray*/ false>();
+  test_sink3</*IsArray*/ true>();
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <cassert>
 
 #include "test_macros.h"
 #include "type_id.h"
 #include "unique_ptr_test_helper.h"
 
 template <int ID = 0>
 struct GenericDeleter {
-  void operator()(void*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
 };
 
 template <int ID = 0>
 struct GenericConvertingDeleter {
   template <int OID>
-  GenericConvertingDeleter(GenericConvertingDeleter<OID>) {}
-  void operator()(void*) const {}
+  TEST_CONSTEXPR_CXX23 GenericConvertingDeleter(GenericConvertingDeleter<OID>) {}
+  TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
 };
 
 template <class Templ, class Other>
 struct is_specialization;
 
 template <template <int> class Templ, int ID1, class Other>
 struct is_specialization<Templ<ID1>, Other> : std::false_type {};
 
 template <template <int> class Templ, int ID1, int ID2>
 struct is_specialization<Templ<ID1>, Templ<ID2> > : std::true_type {};
 
 template <class Templ, class Other>
 using EnableIfSpecialization = typename std::enable_if<
     is_specialization<Templ, typename std::decay<Other>::type >::value
   >::type;
 
 
 template <int ID>
 struct TrackingDeleter {
-  TrackingDeleter() : arg_type(&makeArgumentID<>()) {}
+  TEST_CONSTEXPR_CXX23 TrackingDeleter() : arg_type(&makeArgumentID<>()) {}
 
-  TrackingDeleter(TrackingDeleter const&)
-      : arg_type(&makeArgumentID<TrackingDeleter const&>()) {}
+  TEST_CONSTEXPR_CXX23 TrackingDeleter(TrackingDeleter const&) : arg_type(&makeArgumentID<TrackingDeleter const&>()) {}
 
-  TrackingDeleter(TrackingDeleter&&)
-      : arg_type(&makeArgumentID<TrackingDeleter &&>()) {}
+  TEST_CONSTEXPR_CXX23 TrackingDeleter(TrackingDeleter&&) : arg_type(&makeArgumentID<TrackingDeleter&&>()) {}
 
   template <class T, class = EnableIfSpecialization<TrackingDeleter, T> >
-  TrackingDeleter(T&&) : arg_type(&makeArgumentID<T&&>()) {}
+  TEST_CONSTEXPR_CXX23 TrackingDeleter(T&&) : arg_type(&makeArgumentID<T&&>()) {}
 
-  TrackingDeleter& operator=(TrackingDeleter const&) {
+  TEST_CONSTEXPR_CXX23 TrackingDeleter& operator=(TrackingDeleter const&) {
     arg_type = &makeArgumentID<TrackingDeleter const&>();
     return *this;
   }
 
-  TrackingDeleter& operator=(TrackingDeleter &&) {
+  TEST_CONSTEXPR_CXX23 TrackingDeleter& operator=(TrackingDeleter&&) {
     arg_type = &makeArgumentID<TrackingDeleter &&>();
     return *this;
   }
 
   template <class T, class = EnableIfSpecialization<TrackingDeleter, T> >
-  TrackingDeleter& operator=(T&&) {
+  TEST_CONSTEXPR_CXX23 TrackingDeleter& operator=(T&&) {
     arg_type = &makeArgumentID<T&&>();
     return *this;
   }
 
-  void operator()(void*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
 
 public:
-  TypeID const* reset() const {
+  TEST_CONSTEXPR_CXX23 TypeID const* reset() const {
     TypeID const* tmp = arg_type;
     arg_type = nullptr;
     return tmp;
   }
 
   mutable TypeID const* arg_type;
 };
 
 
 template <class ExpectT, int ID>
 bool checkArg(TrackingDeleter<ID> const& d) {
   return d.arg_type && *d.arg_type == makeArgumentID<ExpectT>();
 }
 
-
 template <bool IsArray>
-void test_sfinae() {
+TEST_CONSTEXPR_CXX23 void test_sfinae() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
 
   { // Test that different non-reference deleter types are allowed so long
     // as they convert to each other.
     using U1 = std::unique_ptr<VT, GenericConvertingDeleter<0> >;
     using U2 = std::unique_ptr<VT, GenericConvertingDeleter<1> >;
     static_assert(std::is_constructible<U1, U2&&>::value, "");
   }
typedef typename std::conditional<IsArray, A[], A>::type VT;
     static_assert(std::is_constructible<U1, U2&&>::value, "");
     static_assert(std::is_constructible<U1, U3&&>::value, "");
     static_assert(std::is_constructible<U1, U4&&>::value, "");
     static_assert(std::is_constructible<U1, U5&&>::value, "");
     static_assert(std::is_constructible<U1, U6&&>::value, "");
   }
 }
 
-
 template <bool IsArray>
-void test_noexcept() {
+TEST_CONSTEXPR_CXX23 void test_noexcept() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   {
     typedef std::unique_ptr<const VT> APtr;
     typedef std::unique_ptr<VT> BPtr;
     static_assert(std::is_nothrow_constructible<APtr, BPtr>::value, "");
   }
   {
     typedef std::unique_ptr<const VT, CDeleter<const VT> > APtr;
     typedef std::unique_ptr<VT, CDeleter<VT> > BPtr;
     static_assert(std::is_nothrow_constructible<APtr, BPtr>::value, "");
   }
   {
     typedef std::unique_ptr<const VT, NCDeleter<const VT>&> APtr;
     typedef std::unique_ptr<VT, NCDeleter<const VT>&> BPtr;
     static_assert(std::is_nothrow_constructible<APtr, BPtr>::value, "");
   }
   {
     typedef std::unique_ptr<const VT, const NCConstDeleter<const VT>&> APtr;
     typedef std::unique_ptr<VT, const NCConstDeleter<const VT>&> BPtr;
     static_assert(std::is_nothrow_constructible<APtr, BPtr>::value, "");
   }
 }
 
-
 template <bool IsArray>
-void test_deleter_value_category() {
+TEST_CONSTEXPR_CXX23 void test_deleter_value_category() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   using TD1 = TrackingDeleter<1>;
   using TD2 = TrackingDeleter<2>;
   TD1 d1;
   TD2 d2;
 
   { // Test non-reference deleter conversions
     using U1 = std::unique_ptr<VT, TD1 >;
TD2 d2;
     using U1 = std::unique_ptr<VT, TD1 >;
     using U2 = std::unique_ptr<VT, TD2 const& >;
     U2 u2(nullptr, d2);
     U1 u1(std::move(u2));
     assert(checkArg<TD2 const&>(u1.get_deleter()));
   }
 }
 
-
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_sfinae</*IsArray*/false>();
     test_noexcept<false>();
+    if (!TEST_IS_CONSTANT_EVALUATED)
       test_deleter_value_category<false>();
   }
   {
     test_sfinae</*IsArray*/true>();
     test_noexcept<true>();
+    if (!TEST_IS_CONSTANT_EVALUATED)
       test_deleter_value_category<true>();
   }
 
+  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.ctor/move_convert.runtime.pass.cpp

 
 template <int ID = 0>
 struct GenericConvertingDeleter {
   template <int OID>
   GenericConvertingDeleter(GenericConvertingDeleter<OID>) {}
   void operator()(void*) const {}
 };
 
-void test_sfinae() {
+TEST_CONSTEXPR_CXX23 void test_sfinae() {
   { // Disallow copying
     using U1 = std::unique_ptr<A[], GenericConvertingDeleter<0> >;
     using U2 = std::unique_ptr<A[], GenericConvertingDeleter<1> >;
     static_assert(std::is_constructible<U1, U2&&>::value, "");
     static_assert(!std::is_constructible<U1, U2&>::value, "");
     static_assert(!std::is_constructible<U1, const U2&>::value, "");
     static_assert(!std::is_constructible<U1, const U2&&>::value, "");
   }
TEST_CONSTEXPR_CXX23 void test_sfinae() {
   {
     using U1 = std::unique_ptr<A[]>;
     using U2 = std::unique_ptr<A>;
     static_assert(!std::is_constructible<U1, U2&&>::value, "");
     static_assert(!std::is_constructible<U2, U1&&>::value, "");
   }
 }
 
+TEST_CONSTEXPR_CXX23 bool test() {
+  test_sfinae();
+
+  return true;
+}
 
 int main(int, char**) {
-  test_sfinae();
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
 
   return 0;
 }

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

 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 // test converting move ctor.  Should only require a MoveConstructible deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
 template <class LHS, class RHS>
-void checkReferenceDeleter(LHS& lhs, RHS& rhs) {
+TEST_CONSTEXPR_CXX23 void checkReferenceDeleter(LHS& lhs, RHS& rhs) {
   typedef typename LHS::deleter_type NewDel;
   static_assert(std::is_reference<NewDel>::value, "");
   rhs.get_deleter().set_state(42);
   assert(rhs.get_deleter().state() == 42);
   assert(lhs.get_deleter().state() == 42);
   lhs.get_deleter().set_state(99);
   assert(lhs.get_deleter().state() == 99);
   assert(rhs.get_deleter().state() == 99);
 }
 
 template <class LHS, class RHS>
-void checkDeleter(LHS& lhs, RHS& rhs, int LHSVal, int RHSVal) {
+TEST_CONSTEXPR_CXX23 void checkDeleter(LHS& lhs, RHS& rhs, int LHSVal, int RHSVal) {
   assert(lhs.get_deleter().state() == LHSVal);
   assert(rhs.get_deleter().state() == RHSVal);
 }
 
 template <class LHS, class RHS>
-void checkCtor(LHS& lhs, RHS& rhs, A* RHSVal) {
+TEST_CONSTEXPR_CXX23 void checkCtor(LHS& lhs, RHS& rhs, A* RHSVal) {
   assert(lhs.get() == RHSVal);
   assert(rhs.get() == nullptr);
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 1);
     assert(B::count == 1);
   }
+}
 
-void checkNoneAlive() {
+TEST_CONSTEXPR_CXX23 void checkNoneAlive() {
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
+}
 
 template <class T>
 struct NCConvertingDeleter {
-  NCConvertingDeleter() = default;
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter()                      = default;
   NCConvertingDeleter(NCConvertingDeleter const&) = delete;
-  NCConvertingDeleter(NCConvertingDeleter&&) = default;
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter(NCConvertingDeleter&&) = default;
 
   template <class U>
-  NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
 
-  void operator()(T*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(T*) const {}
 };
 
 template <class T>
 struct NCConvertingDeleter<T[]> {
-  NCConvertingDeleter() = default;
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter()                      = default;
   NCConvertingDeleter(NCConvertingDeleter const&) = delete;
-  NCConvertingDeleter(NCConvertingDeleter&&) = default;
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter(NCConvertingDeleter&&) = default;
 
   template <class U>
-  NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
+  TEST_CONSTEXPR_CXX23 NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
 
-  void operator()(T*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(T*) const {}
 };
 
 struct NCGenericDeleter {
-  NCGenericDeleter() = default;
+  TEST_CONSTEXPR_CXX23 NCGenericDeleter()                   = default;
   NCGenericDeleter(NCGenericDeleter const&) = delete;
-  NCGenericDeleter(NCGenericDeleter&&) = default;
+  TEST_CONSTEXPR_CXX23 NCGenericDeleter(NCGenericDeleter&&) = default;
 
-  void operator()(void*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
 };
 
-void test_sfinae() {
+TEST_CONSTEXPR_CXX23 void test_sfinae() {
   using DA = NCConvertingDeleter<A>; // non-copyable deleters
   using DB = NCConvertingDeleter<B>;
   using UA = std::unique_ptr<A>;
   using UB = std::unique_ptr<B>;
   using UAD = std::unique_ptr<A, DA>;
   using UBD = std::unique_ptr<B, DB>;
   { // cannot move from an lvalue
     static_assert(std::is_constructible<UA, UB&&>::value, "");
using UBD = std::unique_ptr<B, DB>;
     using UA1 = std::unique_ptr<A, NCGenericDeleter>;
     using UA2 = std::unique_ptr<A[], NCGenericDeleter>;
     using UB1 = std::unique_ptr<B[], NCGenericDeleter>;
     static_assert(!std::is_constructible<UA1, UA2&&>::value, "");
     static_assert(!std::is_constructible<UA1, UB1&&>::value, "");
   }
 }
 
-void test_noexcept() {
+TEST_CONSTEXPR_CXX23 void test_noexcept() {
   {
     typedef std::unique_ptr<A> APtr;
     typedef std::unique_ptr<B> BPtr;
     static_assert(std::is_nothrow_constructible<APtr, BPtr>::value, "");
   }
   {
     typedef std::unique_ptr<A, Deleter<A> > APtr;
     typedef std::unique_ptr<B, Deleter<B> > BPtr;
     static_assert(std::is_nothrow_constructible<APtr, BPtr>::value, "");
   }
   {
     typedef std::unique_ptr<A, NCDeleter<A>&> APtr;
     typedef std::unique_ptr<B, NCDeleter<A>&> BPtr;
     static_assert(std::is_nothrow_constructible<APtr, BPtr>::value, "");
   }
   {
     typedef std::unique_ptr<A, const NCConstDeleter<A>&> APtr;
     typedef std::unique_ptr<B, const NCConstDeleter<A>&> BPtr;
     static_assert(std::is_nothrow_constructible<APtr, BPtr>::value, "");
   }
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_sfinae();
     test_noexcept();
   }
   {
     typedef std::unique_ptr<A> APtr;
     typedef std::unique_ptr<B> BPtr;
     { // explicit
checkNoneAlive();
       A* p = b.get();
       APtr a = std::move(b);
       checkCtor(a, b, p);
       checkDeleter(a, b, 5, 5);
     }
     checkNoneAlive();
   }
 
+  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.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 void 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);
   }
 }
 
 template <class VT>
-void test_pointer_deleter_ctor() {
+TEST_CONSTEXPR_CXX23 void 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);
   }
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   {
     // test_pointer_ctor<int>();
     test_pointer_deleter_ctor<int>();
   }
   {
     test_pointer_ctor<int[]>();
     test_pointer_deleter_ctor<int[]>();
   }
 
+  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.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);
+// constexpr unique_ptr(nullptr_t);  // constexpr since C++23
 
 #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 void 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);
   }
 }
 
 template <class VT>
-void test_sfinae() {
+TEST_CONSTEXPR_CXX23 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<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
 }
 
 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_CONSTEXPR_CXX23 bool test() {
   {
     test_basic<int>();
     test_sfinae<int>();
   }
   {
     test_basic<int[]>();
     test_sfinae<int[]>();
   }
 
+  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.ctor/pointer.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 // unique_ptr(pointer) ctor should only require default Deleter ctor
 
 template <bool IsArray>
-void test_pointer() {
+TEST_CONSTEXPR_CXX23 void test_pointer() {
   typedef typename std::conditional<!IsArray, A, A[]>::type ValueT;
   const int expect_alive = IsArray ? 5 : 1;
 #if TEST_STD_VER >= 11
   {
     using U1 = std::unique_ptr<ValueT>;
     using U2 = std::unique_ptr<ValueT, Deleter<ValueT> >;
 
     // Test for noexcept
     static_assert(std::is_nothrow_constructible<U1, A*>::value, "");
     static_assert(std::is_nothrow_constructible<U2, A*>::value, "");
 
     // Test for explicit
     static_assert(!std::is_convertible<A*, U1>::value, "");
     static_assert(!std::is_convertible<A*, U2>::value, "");
   }
 #endif
   {
     A* p = newValue<ValueT>(expect_alive);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
+
     std::unique_ptr<ValueT> s(p);
     assert(s.get() == p);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   {
     A* p = newValue<ValueT>(expect_alive);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
+
     std::unique_ptr<ValueT, NCDeleter<ValueT> > s(p);
     assert(s.get() == p);
     assert(s.get_deleter().state() == 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   {
     A* p = newValue<ValueT>(expect_alive);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
+
     std::unique_ptr<ValueT, DefaultCtorDeleter<ValueT> > s(p);
     assert(s.get() == p);
     assert(s.get_deleter().state() == 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 }
 
-void test_derived() {
+TEST_CONSTEXPR_CXX23 void test_derived() {
   {
     B* p = new B;
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert(A::count == 1);
       assert(B::count == 1);
+    }
     std::unique_ptr<A> s(p);
     assert(s.get() == p);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
+  }
   {
     B* p = new B;
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert(A::count == 1);
       assert(B::count == 1);
+    }
     std::unique_ptr<A, NCDeleter<A> > s(p);
     assert(s.get() == p);
     assert(s.get_deleter().state() == 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
+}
 
 #if TEST_STD_VER >= 11
 struct NonDefaultDeleter {
   NonDefaultDeleter() = delete;
   void operator()(void*) const {}
 };
 
 struct GenericDeleter {
   void operator()(void*) const;
 };
 #endif
 
 template <class T>
-void test_sfinae() {
+void TEST_CONSTEXPR_CXX23 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<T, void (*)(void*)>;
     static_assert(!std::is_constructible<U, T*>::value, "");
   }
   { // the constructor does not participate in overload resolution when
     // the deleter is not default constructible
     using Del = CDeleter<T>;
     using U1 = std::unique_ptr<T, NonDefaultDeleter>;
     using U2 = std::unique_ptr<T, Del&>;
     using U3 = std::unique_ptr<T, Del const&>;
     static_assert(!std::is_constructible<U1, T*>::value, "");
     static_assert(!std::is_constructible<U2, T*>::value, "");
     static_assert(!std::is_constructible<U3, T*>::value, "");
   }
 #endif
 }
 
-static void test_sfinae_runtime() {
+static TEST_CONSTEXPR_CXX23 void test_sfinae_runtime() {
 #if TEST_STD_VER >= 11
   { // the constructor does not participate in overload resolution when
     // a base <-> derived conversion would occur.
     using UA = std::unique_ptr<A[]>;
     using UAD = std::unique_ptr<A[], GenericDeleter>;
     using UAC = std::unique_ptr<const A[]>;
     using UB = std::unique_ptr<B[]>;
     using UBD = std::unique_ptr<B[], GenericDeleter>;
DEFINE_AND_RUN_IS_INCOMPLETE_TEST({
   checkNumIncompleteTypeAlive(0);
   {
     doIncompleteTypeTest<IncompleteType, NCDeleter<IncompleteType> >(
         1, getNewIncomplete());
   }
   checkNumIncompleteTypeAlive(0);
 })
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_pointer</*IsArray*/ false>();
     test_derived();
     test_sfinae<int>();
   }
   {
     test_pointer</*IsArray*/ true>();
     test_sfinae<int[]>();
     test_sfinae_runtime();
   }
 
+  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.ctor/pointer_deleter.pass.cpp

 #include "unique_ptr_test_helper.h"
 
 bool my_free_called = false;
 
 void my_free(void*) { my_free_called = true; }
 
 #if TEST_STD_VER >= 11
 struct DeleterBase {
-  void operator()(void*) const {}
+  TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
 };
 struct CopyOnlyDeleter : DeleterBase {
-  CopyOnlyDeleter() = default;
-  CopyOnlyDeleter(CopyOnlyDeleter const&) = default;
+  TEST_CONSTEXPR_CXX23 CopyOnlyDeleter()                       = default;
+  TEST_CONSTEXPR_CXX23 CopyOnlyDeleter(CopyOnlyDeleter const&) = default;
   CopyOnlyDeleter(CopyOnlyDeleter&&) = delete;
 };
 struct MoveOnlyDeleter : DeleterBase {
-  MoveOnlyDeleter() = default;
-  MoveOnlyDeleter(MoveOnlyDeleter&&) = default;
+  TEST_CONSTEXPR_CXX23 MoveOnlyDeleter()                  = default;
+  TEST_CONSTEXPR_CXX23 MoveOnlyDeleter(MoveOnlyDeleter&&) = default;
 };
 struct NoCopyMoveDeleter : DeleterBase {
-  NoCopyMoveDeleter() = default;
+  TEST_CONSTEXPR_CXX23 NoCopyMoveDeleter()    = default;
   NoCopyMoveDeleter(NoCopyMoveDeleter const&) = delete;
 };
 #endif
 
 template <bool IsArray>
-void test_sfinae() {
+TEST_CONSTEXPR_CXX23 void test_sfinae() {
 #if TEST_STD_VER >= 11
   typedef typename std::conditional<!IsArray, int, int[]>::type VT;
   {
     using D = CopyOnlyDeleter;
     using U = std::unique_ptr<VT, D>;
     static_assert(std::is_constructible<U, int*, D const&>::value, "");
     static_assert(std::is_constructible<U, int*, D&>::value, "");
     static_assert(std::is_constructible<U, int*, D&&>::value, "");
typedef typename std::conditional<!IsArray, int, int[]>::type VT;
     static_assert(std::is_constructible<U, int*, D&>::value, "");
     static_assert(!std::is_constructible<U, int*, D&&>::value, "");
     static_assert(!std::is_constructible<U, int*, const D&&>::value, "");
   }
 #endif
 }
 
 template <bool IsArray>
-void test_noexcept() {
+TEST_CONSTEXPR_CXX23 void test_noexcept() {
 #if TEST_STD_VER >= 11
   typedef typename std::conditional<!IsArray, int, int[]>::type VT;
   {
     using D = CopyOnlyDeleter;
     using U = std::unique_ptr<VT, D>;
     static_assert(std::is_nothrow_constructible<U, int*, D const&>::value, "");
     static_assert(std::is_nothrow_constructible<U, int*, D&>::value, "");
     static_assert(std::is_nothrow_constructible<U, int*, D&&>::value, "");
typedef typename std::conditional<!IsArray, int, int[]>::type VT;
     using D = NoCopyMoveDeleter;
     using U = std::unique_ptr<VT, const D&>;
     static_assert(std::is_nothrow_constructible<U, int*, D const&>::value, "");
     static_assert(std::is_nothrow_constructible<U, int*, D&>::value, "");
   }
 #endif
 }
 
-void test_sfinae_runtime() {
+TEST_CONSTEXPR_CXX23 void test_sfinae_runtime() {
 #if TEST_STD_VER >= 11
   {
     using D = CopyOnlyDeleter;
     using U = std::unique_ptr<A[], D>;
     static_assert(std::is_nothrow_constructible<U, A*, D const&>::value, "");
     static_assert(std::is_nothrow_constructible<U, A*, D&>::value, "");
     static_assert(std::is_nothrow_constructible<U, A*, D&&>::value, "");
 
#if TEST_STD_VER >= 11
     static_assert(!std::is_constructible<U, B*, D&>::value, "");
     static_assert(!std::is_constructible<U, B*, D&&>::value, "");
     static_assert(!std::is_constructible<U, B*, const D&&>::value, "");
   }
 #endif
 }
 
 template <bool IsArray>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<!IsArray, A, A[]>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
   { // MoveConstructible deleter (C-1)
     A* p = newValue<VT>(expect_alive);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     std::unique_ptr<VT, Deleter<VT> > s(p, Deleter<VT>(5));
     assert(s.get() == p);
     assert(s.get_deleter().state() == 5);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   { // CopyConstructible deleter (C-2)
     A* p = newValue<VT>(expect_alive);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     CopyDeleter<VT> d(5);
     std::unique_ptr<VT, CopyDeleter<VT> > s(p, d);
     assert(s.get() == p);
     assert(s.get_deleter().state() == 5);
     d.set_state(6);
     assert(s.get_deleter().state() == 5);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   { // Reference deleter (C-3)
     A* p = newValue<VT>(expect_alive);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     NCDeleter<VT> d(5);
     std::unique_ptr<VT, NCDeleter<VT>&> s(p, d);
     assert(s.get() == p);
     assert(&s.get_deleter() == &d);
     assert(s.get_deleter().state() == 5);
     d.set_state(6);
     assert(s.get_deleter().state() == 6);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   { // Const Reference deleter (C-4)
     A* p = newValue<VT>(expect_alive);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     NCConstDeleter<VT> d(5);
     std::unique_ptr<VT, NCConstDeleter<VT> const&> s(p, d);
     assert(s.get() == p);
     assert(s.get_deleter().state() == 5);
     assert(&s.get_deleter() == &d);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     { // Void and function pointers (C-6,7)
       typedef typename std::conditional<IsArray, int[], int>::type VT2;
       my_free_called = false;
       {
         int i = 0;
         std::unique_ptr<VT2, void (*)(void*)> s(&i, my_free);
         assert(s.get() == &i);
         assert(s.get_deleter() == my_free);
         assert(!my_free_called);
       }
       assert(my_free_called);
     }
   }
+}
 
-void test_basic_single() {
+TEST_CONSTEXPR_CXX23 void test_basic_single() {
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
+  }
   { // Derived pointers (C-5)
     B* p = new B;
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert(A::count == 1);
       assert(B::count == 1);
+    }
     std::unique_ptr<A, Deleter<A> > s(p, Deleter<A>(5));
     assert(s.get() == p);
     assert(s.get_deleter().state() == 5);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
+
     { // Void and function pointers (C-6,7)
       my_free_called = false;
       {
         int i = 0;
         std::unique_ptr<void, void (*)(void*)> s(&i, my_free);
         assert(s.get() == &i);
         assert(s.get_deleter() == my_free);
         assert(!my_free_called);
       }
       assert(my_free_called);
     }
   }
+}
 
 template <bool IsArray>
-void test_nullptr() {
+TEST_CONSTEXPR_CXX23 void test_nullptr() {
 #if TEST_STD_VER >= 11
   typedef typename std::conditional<!IsArray, A, A[]>::type VT;
   {
     std::unique_ptr<VT, Deleter<VT> > u(nullptr, Deleter<VT>{});
     assert(u.get() == nullptr);
   }
   {
     NCDeleter<VT> d;
     std::unique_ptr<VT, NCDeleter<VT>& > u(nullptr, d);
     assert(u.get() == nullptr);
   }
   {
     NCConstDeleter<VT> d;
     std::unique_ptr<VT, NCConstDeleter<VT> const& > u(nullptr, d);
     assert(u.get() == nullptr);
   }
 #endif
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_basic</*IsArray*/ false>();
     test_nullptr<false>();
     test_basic_single();
     test_sfinae<false>();
     test_noexcept<false>();
   }
   {
     test_basic</*IsArray*/ true>();
     test_nullptr<true>();
     test_sfinae<true>();
     test_sfinae_runtime();
     test_noexcept<true>();
   }
 
+  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.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 void 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);
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   test_basic<int>();
   test_basic<int[]>();
 
+  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.modifiers/release.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 void test_basic() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 3 : 1;
 #if TEST_STD_VER >= 11
   {
     using U = std::unique_ptr<VT>;
     U u; ((void)u);
     ASSERT_NOEXCEPT(u.release());
   }
 #endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     A* ap = p.get();
     A* a = p.release();
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     assert(p.get() == nullptr);
     assert(ap == a);
     assert(a != nullptr);
 
     if (IsArray)
       delete[] a;
     else
       delete a;
 
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == 0);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
+  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.modifiers/reset.pass.cpp

 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 template <bool IsArray>
-void test_reset_pointer() {
+TEST_CONSTEXPR_CXX23 void test_reset_pointer() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 3 : 1;
 #if TEST_STD_VER >= 11
   {
     using U = std::unique_ptr<VT>;
-    U u; ((void)u);
+    U u;
+    ((void)u);
     ASSERT_NOEXCEPT(u.reset((A*)nullptr));
   }
 #endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     A* i = p.get();
     assert(i != nullptr);
     A* new_value = newValue<VT>(expect_alive);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == (expect_alive * 2));
     p.reset(new_value);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     assert(p.get() == new_value);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
   {
     std::unique_ptr<const VT> p(newValue<const VT>(expect_alive));
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     const A* i = p.get();
     assert(i != nullptr);
     A* new_value = newValue<VT>(expect_alive);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == (expect_alive * 2));
     p.reset(new_value);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     assert(p.get() == new_value);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 }
 
 template <bool IsArray>
-void test_reset_nullptr() {
+TEST_CONSTEXPR_CXX23 void test_reset_nullptr() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 3 : 1;
 #if TEST_STD_VER >= 11
   {
     using U = std::unique_ptr<VT>;
-    U u; ((void)u);
+    U u;
+    ((void)u);
     ASSERT_NOEXCEPT(u.reset(nullptr));
   }
 #endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     A* i = p.get();
     assert(i != nullptr);
     p.reset(nullptr);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == 0);
     assert(p.get() == nullptr);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 }
 
-
 template <bool IsArray>
-void test_reset_no_arg() {
+TEST_CONSTEXPR_CXX23 void test_reset_no_arg() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 3 : 1;
 #if TEST_STD_VER >= 11
   {
     using U = std::unique_ptr<VT>;
-    U u; ((void)u);
+    U u;
+    ((void)u);
     ASSERT_NOEXCEPT(u.reset());
   }
 #endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == expect_alive);
     A* i = p.get();
     assert(i != nullptr);
     p.reset();
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == 0);
     assert(p.get() == nullptr);
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_reset_pointer</*IsArray*/ false>();
     test_reset_nullptr<false>();
     test_reset_no_arg<false>();
   }
   {
     test_reset_pointer</*IsArray*/true>();
     test_reset_nullptr<true>();
     test_reset_no_arg<true>();
   }
 
+  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.modifiers/reset.single.pass.cpp

 // test reset
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   {
     std::unique_ptr<A> p(new A);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert(A::count == 1);
       assert(B::count == 0);
+    }
     A* i = p.get();
     assert(i != nullptr);
     p.reset(new B);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert(A::count == 1);
       assert(B::count == 1);
     }
+  }
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
+  }
   {
     std::unique_ptr<A> p(new B);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert(A::count == 1);
       assert(B::count == 1);
+    }
     A* i = p.get();
     assert(i != nullptr);
     p.reset(new B);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert(A::count == 1);
       assert(B::count == 1);
     }
+  }
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
+  }
+
+  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.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 "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.modifiers/swap.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 struct TT {
   int state_;
   static int count;
-  TT() : state_(-1) { ++count; }
-  explicit TT(int i) : state_(i) { ++count; }
-  TT(const TT& a) : state_(a.state_) { ++count; }
-  TT& operator=(const TT& a) {
+  TEST_CONSTEXPR_CXX23 TT() : state_(-1) {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      ++count;
+  }
+  TEST_CONSTEXPR_CXX23 explicit TT(int i) : state_(i) {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      ++count;
+  }
+  TEST_CONSTEXPR_CXX23 TT(const TT& a) : state_(a.state_) {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      ++count;
+  }
+  TEST_CONSTEXPR_CXX23 TT& operator=(const TT& a) {
     state_ = a.state_;
     return *this;
   }
-  ~TT() { --count; }
-
-  friend bool operator==(const TT& x, const TT& y) {
-    return x.state_ == y.state_;
+  TEST_CONSTEXPR_CXX23 ~TT() {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      --count;
   }
+
+  friend TEST_CONSTEXPR_CXX23 bool operator==(const TT& x, const TT& y) { return x.state_ == y.state_; }
 };
 
 int TT::count = 0;
 
 template <class T>
-typename std::remove_all_extents<T>::type* newValueInit(int size,
-                                                        int new_value) {
+TEST_CONSTEXPR_CXX23 typename std::remove_all_extents<T>::type* newValueInit(int size, int new_value) {
   typedef typename std::remove_all_extents<T>::type VT;
   VT* p = newValue<T>(size);
   for (int i = 0; i < size; ++i)
     (p + i)->state_ = new_value;
   return p;
 }
 
 template <bool IsArray>
-void test_basic() {
+TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<IsArray, TT[], TT>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
 #if TEST_STD_VER >= 11
   {
     using U = std::unique_ptr<VT, Deleter<VT> >;
     U u; ((void)u);
     ASSERT_NOEXCEPT(u.swap(u));
   }
#endif
     assert(s2.get_deleter().state() == 2);
     s1.swap(s2);
     assert(s1.get() == p2);
     assert(*s1.get() == TT(2));
     assert(s1.get_deleter().state() == 2);
     assert(s2.get() == p1);
     assert(*s2.get() == TT(1));
     assert(s2.get_deleter().state() == 1);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(TT::count == (expect_alive * 2));
   }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(TT::count == 0);
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
+  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

 //===----------------------------------------------------------------------===//
 //
 // 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 op*()
+// test constexpr explicit operator bool() const noexcept; // constexpr since C++23
 
 #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 void 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
   {
#endif
   {
     U p;
     const U& cp = p;
     doTest(p, false);
     doTest(cp, false);
   }
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
-  return 0;
+  return true;
 }
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
+
+  return 0;
+}
 No newline at end of file

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 void 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());
   }
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
+  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/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 void 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;
     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);
   }
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
+  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/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.class/unique.ptr.observers/op_subscript.runtime.pass.cpp

 // test op[](size_t)
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A {
-  int state_;
+  int state_{0};
   static int next_;
 
 public:
-  A() : state_(++next_) {}
-  int get() const { return state_; }
+  TEST_CONSTEXPR_CXX23 A() {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      state_ = ++next_;
+  }
+
+  TEST_CONSTEXPR_CXX23 int get() const { return state_; }
 
-  friend bool operator==(const A& x, int y) { return x.state_ == y; }
+  friend TEST_CONSTEXPR_CXX23 bool operator==(const A& x, int y) { return x.state_ == y; }
 
-  A& operator=(int i) {
+  TEST_CONSTEXPR_CXX23 A& operator=(int i) {
     state_ = i;
     return *this;
   }
 };
 
 int A::next_ = 0;
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   std::unique_ptr<A[]> p(new A[3]);
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(p[0] == 1);
     assert(p[1] == 2);
     assert(p[2] == 3);
+  }
   p[0] = 3;
   p[1] = 2;
   p[2] = 1;
   assert(p[0] == 3);
   assert(p[1] == 2);
   assert(p[2] == 1);
 
+  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.create/make_unique.sizezero.pass.cpp

#if TEST_STD_VER > 11
     std::unique_ptr<A> p = std::make_unique<A>();
     assert(p != nullptr);
   }
   {
     std::unique_ptr<A[]> p = std::make_unique<A[]>(1);
     assert(p != nullptr);
   }
 #endif
+
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/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
 
+// convert constructor
+
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
+#include "unique_ptr_test_helper.h"
 
-struct A
-{
-    static int count;
-    A() {++count;}
-    A(const A&) {++count;}
-    virtual ~A() {--count;}
-};
-
-int A::count = 0;
-
-struct B
-    : public A
-{
-    static int count;
-    B() {++count;}
-    B(const B& other) : A(other) {++count;}
-    virtual ~B() {--count;}
-};
-
-int B::count = 0;
-
-int main(int, char**)
-{
-    std::default_delete<B> d2;
-    std::default_delete<A> d1 = d2;
-    A* p = new B;
+TEST_CONSTEXPR_CXX23 bool test() {
+  A* p                      = new B;
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 1);
     assert(B::count == 1);
-    d1(p);
+  }
+
+
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     assert(A::count == 0);
     assert(B::count == 0);
+  }
+
+  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.dflt/default.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
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
+#include "unique_ptr_test_helper.h"
 
-struct A
-{
-    static int count;
-    A() {++count;}
-    A(const A&) {++count;}
-    ~A() {--count;}
-};
-
-int A::count = 0;
-
-int main(int, char**)
-{
-    std::default_delete<A> d;
-    A* p = new A;
+TEST_CONSTEXPR_CXX23 bool test() {
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 1);
-    d(p);
+
+
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 
+  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[]>&);
+//   constexpr 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 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/default.pass.cpp

 // default_delete
 
 // Test that default_delete<T[]> has a working default constructor
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
+#include "unique_ptr_test_helper.h"
 
-struct A
-{
-    static int count;
-    A() {++count;}
-    A(const A&) {++count;}
-    ~A() {--count;}
-};
-
-int A::count = 0;
-
-int main(int, char**)
-{
-    std::default_delete<A[]> d;
-    A* p = new A[3];
+TEST_CONSTEXPR_CXX23 bool test() {
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 3);
-    d(p);
+
+
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 
+  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.msvc/test.compile.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, c++14, c++17, c++20
+
+// Includes Microsoft's test that tests the entire header.
+
+#include "test.cpp"

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.msvc/test.cpp

+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <memory>
+#include <utility>
+
+#include "test_macros.h"
+
+using namespace std;
+
+struct Dummy {
+  constexpr int test() const { return 10; }
+};
+
+constexpr bool test() {
+  // [memory.syn]
+  {
+    // FIXME no make_unique_for_overwrite support
+    //auto p1 = make_unique<int>(42);
+    //auto p2 = make_unique_for_overwrite<int>();
+    //swap(p1, p2);
+    //assert(p1 == p1);
+    //assert(p1 != p2);
+
+    //auto p3 = make_unique<int[]>(10);
+    //auto p4 = make_unique_for_overwrite<int[]>(4);
+    //swap(p3, p4);
+    //assert(p3 == p3);
+    //assert(p3 != p4);
+
+    auto p5 = unique_ptr<int>{nullptr};
+    assert(p5 == nullptr);
+    assert(nullptr == p5);
+    assert(!(p5 != nullptr));
+    assert(!(nullptr != p5));
+    assert(!(p5 < nullptr));
+    assert(!(nullptr < p5));
+    assert(p5 <= nullptr);
+    assert(nullptr <= p5);
+    assert(!(p5 > nullptr));
+    assert(!(nullptr > p5));
+    assert(p5 >= nullptr);
+    assert(nullptr >= p5);
+    assert((p5 <=> nullptr) == strong_ordering::equal);
+    assert((nullptr <=> p5) == strong_ordering::equal);
+  }
+
+  // changes in [unique.ptr.dltr.dflt] and [unique.ptr.dltr.dflt1]
+  // will be tested via destructors and copy assign/constructors
+
+  // [unique.ptr.single.general]
+  {
+    // constructors
+    auto p1 = unique_ptr<int>{new int{}};
+    auto d1 = default_delete<int>{};
+    auto p2 = unique_ptr<int>{new int{}, d1};
+    auto p3 = unique_ptr<int>{new int{}, default_delete<int>{}};
+    auto p4 = std::move(p3);
+    auto p5 = unique_ptr<int>{nullptr};
+    auto p6 = unique_ptr<int, default_delete<int>&>{new int{}, d1};
+    auto p7 = unique_ptr<int>{std::move(p6)};
+
+    // assignment
+    p3      = std::move(p4);
+    auto p8 = unique_ptr<int, default_delete<int>&>{new int{}, d1};
+    p7      = std::move(p8);
+    p1      = nullptr;
+
+    // observers
+    assert(*p2 == 0);
+    auto p9 = unique_ptr<Dummy>{new Dummy};
+    assert(p9->test() == 10);
+    assert(p2.get() != nullptr);
+    [[maybe_unused]] auto& d2 = p2.get_deleter();
+    [[maybe_unused]] auto& d3 = as_const(p2).get_deleter();
+    auto b1                   = static_cast<bool>(p2);
+    assert(b1);
+
+    // modifiers
+    p1.reset();
+    p1.reset(new int{});
+    auto manual_delete = p2.release();
+    delete manual_delete;
+    p5.swap(p1);
+  }
+
+  // [unique.ptr.runtime.general]
+  {
+    // constructors
+    auto p1 = unique_ptr<int[]>{new int[5]};
+    auto d1 = default_delete<int[]>{};
+    auto p2 = unique_ptr<int[]>{new int[5], d1};
+    auto p3 = unique_ptr<int[]>{new int[5], default_delete<int[]>{}};
+    auto p4 = std::move(p1);
+    auto p5 = unique_ptr<int[], default_delete<int[]>&>{new int[5], d1};
+    auto p6 = unique_ptr<int[]>{std::move(p5)};
+
+    // assignment
+    p1      = std::move(p4);
+    auto p7 = unique_ptr<int[], default_delete<int[]>&>{new int[5], d1};
+    p6      = std::move(p7);
+    p4      = nullptr;
+
+    // observers
+    p1[0] = 50;
+    assert(p1[0] == 50);
+    assert(p1.get() != nullptr);
+    [[maybe_unused]] auto& d2 = p1.get_deleter();
+    [[maybe_unused]] auto& d3 = as_const(p1).get_deleter();
+    auto b1                   = static_cast<bool>(p1);
+    assert(b1);
+
+    // modifiers
+    auto manual_delete = p1.release();
+    delete[] manual_delete;
+    p1.reset(new int[3]);
+    p1.reset(nullptr);
+    p1.reset();
+    p1.swap(p4);
+  }
+
+  return true;
+}
+
+static_assert(test());
+
+int main() {} // COMPILE-ONLY

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

 //     operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "deleter_types.h"
 #include "test_comparisons.h"
+#include "unique_ptr_test_helper.h"
 
-struct A {
-  static int count;
-  A() { ++count; }
-  A(const A&) { ++count; }
-  virtual ~A() { --count; }
-};
-
-int A::count = 0;
-
-struct B : public A {
-  static int count;
-  B() { ++count; }
-  B(const B& other) : A(other) { ++count; }
-  virtual ~B() { --count; }
-};
-
-int B::count = 0;
-
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   AssertComparisonsReturnBool<std::unique_ptr<int> >();
 #if TEST_STD_VER > 17
   AssertOrderReturn<std::strong_ordering, std::unique_ptr<int>>();
 #endif
 
   // Pointers of same type
   {
     A* ptr1 = new A;
     A* ptr2 = new A;
     const std::unique_ptr<A, Deleter<A> > p1(ptr1);
     const std::unique_ptr<A, Deleter<A> > p2(ptr2);
 
     assert(!(p1 == p2));
     assert(p1 != p2);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert((p1 < p2) == (ptr1 < ptr2));
       assert((p1 <= p2) == (ptr1 <= ptr2));
       assert((p1 > p2) == (ptr1 > ptr2));
       assert((p1 >= p2) == (ptr1 >= ptr2));
 #if TEST_STD_VER > 17
       assert((p1 <=> p2) != std::strong_ordering::equal);
       assert((p1 <=> p2) == (ptr1 <=> ptr2));
 #endif
     }
+  }
   // Pointers of different type
   {
     A* ptr1 = new A;
     B* ptr2 = new B;
     const std::unique_ptr<A, Deleter<A> > p1(ptr1);
     const std::unique_ptr<B, Deleter<B> > p2(ptr2);
     assert(!(p1 == p2));
     assert(p1 != p2);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert((p1 < p2) == (ptr1 < ptr2));
       assert((p1 <= p2) == (ptr1 <= ptr2));
       assert((p1 > p2) == (ptr1 > ptr2));
       assert((p1 >= p2) == (ptr1 >= ptr2));
 #if TEST_STD_VER > 17
     assert((p1 <=> p2) != std::strong_ordering::equal);
     assert((p1 <=> p2) == (ptr1 <=> ptr2));
 #endif
     }
+  }
   // Pointers of same array type
   {
     A* ptr1 = new A[3];
     A* ptr2 = new A[3];
     const std::unique_ptr<A[], Deleter<A[]> > p1(ptr1);
     const std::unique_ptr<A[], Deleter<A[]> > p2(ptr2);
     assert(!(p1 == p2));
     assert(p1 != p2);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert((p1 < p2) == (ptr1 < ptr2));
       assert((p1 <= p2) == (ptr1 <= ptr2));
       assert((p1 > p2) == (ptr1 > ptr2));
       assert((p1 >= p2) == (ptr1 >= ptr2));
 #if TEST_STD_VER > 17
     assert((p1 <=> p2) != std::strong_ordering::equal);
     assert((p1 <=> p2) == (ptr1 <=> ptr2));
 #endif
     }
+  }
   // Pointers of different array types
   {
     A* ptr1 = new A[3];
     B* ptr2 = new B[3];
     const std::unique_ptr<A[], Deleter<A[]> > p1(ptr1);
     const std::unique_ptr<B[], Deleter<B[]> > p2(ptr2);
     assert(!(p1 == p2));
     assert(p1 != p2);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       assert((p1 < p2) == (ptr1 < ptr2));
       assert((p1 <= p2) == (ptr1 <= ptr2));
       assert((p1 > p2) == (ptr1 > ptr2));
       assert((p1 >= p2) == (ptr1 >= ptr2));
 #if TEST_STD_VER > 17
     assert((p1 <=> p2) != std::strong_ordering::equal);
     assert((p1 <=> p2) == (ptr1 <=> ptr2));
 #endif
     }
+  }
   // Default-constructed pointers of same type
   {
     const std::unique_ptr<A, Deleter<A> > p1;
     const std::unique_ptr<A, Deleter<A> > p2;
     assert(p1 == p2);
 #if TEST_STD_VER > 17
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert((p1 <=> p2) == std::strong_ordering::equal);
 #endif
   }
   // Default-constructed pointers of different type
   {
     const std::unique_ptr<A, Deleter<A> > p1;
     const std::unique_ptr<B, Deleter<B> > p2;
     assert(p1 == p2);
 #if TEST_STD_VER > 17
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert((p1 <=> p2) == std::strong_ordering::equal);
 #endif
   }
 
+  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.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;
+//     constexpr 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;           // removed in 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;           // removed in C++20
 // 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;           // removed in C++20
 // template <class T, class D>
-//     bool operator<(const unique_ptr<T, D>& x, nullptr_t);
+//     constexpr 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);
+//     constexpr 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);
+//     constexpr 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);
+//     constexpr 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);
+//     constexpr 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);
+//     constexpr 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);
+//     constexpr 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);
+//     constexpr 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
+//     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() {
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     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/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp

 
 #include "test_macros.h"
 #include "deleter_types.h"
 
 struct A
 {
     int state_;
     static int count;
-    A() : state_(0) {++count;}
-    explicit A(int i) : state_(i) {++count;}
-    A(const A& a) : state_(a.state_) {++count;}
-    A& operator=(const A& a) {state_ = a.state_; return *this;}
-    ~A() {--count;}
+    TEST_CONSTEXPR_CXX23 A() : state_(0) {
+      if (!TEST_IS_CONSTANT_EVALUATED)
+        ++count;
+    }
+    TEST_CONSTEXPR_CXX23 explicit A(int i) : state_(i) {
+      if (!TEST_IS_CONSTANT_EVALUATED)
+        ++count;
+    }
+    TEST_CONSTEXPR_CXX23 A(const A& a) : state_(a.state_) {
+      if (!TEST_IS_CONSTANT_EVALUATED)
+        ++count;
+    }
+    TEST_CONSTEXPR_CXX23 A& operator=(const A& a) {
+      state_ = a.state_;
+      return *this;
+    }
+    TEST_CONSTEXPR_CXX23 ~A() {
+      if (!TEST_IS_CONSTANT_EVALUATED)
+        --count;
+    }
 
-    friend bool operator==(const A& x, const A& y)
-        {return x.state_ == y.state_;}
+    friend TEST_CONSTEXPR_CXX23 bool operator==(const A& x, const A& y) { return x.state_ == y.state_; }
 };
 
 int A::count = 0;
 
 template <class T>
 struct NonSwappableDeleter {
-  explicit NonSwappableDeleter(int) {}
-  NonSwappableDeleter& operator=(NonSwappableDeleter const&) { return *this; }
-  void operator()(T*) const {}
+  TEST_CONSTEXPR_CXX23 explicit NonSwappableDeleter(int) {}
+  TEST_CONSTEXPR_CXX23 NonSwappableDeleter& operator=(NonSwappableDeleter const&) { return *this; }
+  TEST_CONSTEXPR_CXX23 void operator()(T*) const {}
+
 private:
   NonSwappableDeleter(NonSwappableDeleter const&);
 
 };
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX23 bool test() {
     A* p1 = new A(1);
     std::unique_ptr<A, Deleter<A> > s1(p1, Deleter<A>(1));
     A* p2 = new A(2);
     std::unique_ptr<A, Deleter<A> > s2(p2, Deleter<A>(2));
     assert(s1.get() == p1);
     assert(*s1 == A(1));
     assert(s1.get_deleter().state() == 1);
     assert(s2.get() == p2);
     assert(*s2 == A(2));
     assert(s2.get_deleter().state() == 2);
     swap(s1, s2);
     assert(s1.get() == p2);
     assert(*s1 == A(2));
     assert(s1.get_deleter().state() == 2);
     assert(s2.get() == p1);
     assert(*s2 == A(1));
     assert(s2.get_deleter().state() == 1);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == 2);
-    }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
-    {
     A* p1 = new A[3];
     std::unique_ptr<A[], Deleter<A[]> > s1(p1, Deleter<A[]>(1));
     A* p2 = new A[3];
     std::unique_ptr<A[], Deleter<A[]> > s2(p2, Deleter<A[]>(2));
     assert(s1.get() == p1);
     assert(s1.get_deleter().state() == 1);
     assert(s2.get() == p2);
     assert(s2.get_deleter().state() == 2);
     swap(s1, s2);
     assert(s1.get() == p2);
     assert(s1.get_deleter().state() == 2);
     assert(s2.get() == p1);
     assert(s2.get_deleter().state() == 1);
+    if (!TEST_IS_CONSTANT_EVALUATED)
       assert(A::count == 6);
-    }
+  if (!TEST_IS_CONSTANT_EVALUATED)
     assert(A::count == 0);
 #if TEST_STD_VER >= 11
     {
         // test that unique_ptr's specialized swap is disabled when the deleter
         // is non-swappable. Instead we should pick up the generic swap(T, T)
         // and perform 3 move constructions.
         typedef NonSwappableDeleter<int> D;
         D  d(42);
         int x = 42;
         int y = 43;
         std::unique_ptr<int, D&> p(&x, d);
         std::unique_ptr<int, D&> p2(&y, d);
         std::swap(p, p2);
     }
 #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_macros.h

 #endif
 
 #if TEST_STD_VER >= 20
 # define TEST_CONSTEXPR_CXX20 constexpr
 #else
 # define TEST_CONSTEXPR_CXX20
 #endif
 
-#if TEST_STD_VER > 20
+#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) \

libcxx/test/support/unique_ptr_test_helper.h

 #include <memory>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "deleter_types.h"
 
 struct A {
   static int count;
-  A() { ++count; }
-  A(const A&) { ++count; }
-  virtual ~A() { --count; }
+  TEST_CONSTEXPR_CXX23 A() {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      ++count;
+  }
+  TEST_CONSTEXPR_CXX23 A(const A&) {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      ++count;
+  }
+  TEST_CONSTEXPR_CXX23 virtual ~A() {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      --count;
+  }
 };
 
 int A::count = 0;
 
 struct B : public A {
   static int count;
-  B() { ++count; }
-  B(const B& other) : A(other) { ++count; }
-  virtual ~B() { --count; }
+  TEST_CONSTEXPR_CXX23 B() {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      ++count;
+  }
+  TEST_CONSTEXPR_CXX23 B(const B& other) : A(other) {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      ++count;
+  }
+  TEST_CONSTEXPR_CXX23 virtual ~B() {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      --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 },