[libc++] Implement P1004R2 (constexpr std::vector)

[rsmith]

Move some changes from here to the std::allocator change.

[ldionne]

I'll pick this up. I wasn't aware you had started working on this, but thanks!

[ldionne]

I've had a revision locally for a long long time. It doesn't pass everything
yet, but I've managed to get it down to ~10 failing tests with a few more hacks
locally.

[miscco]

Some quick review of the the acutal changes to the headers

libcxx/include/memory

884–885

I am wondering whether we should reuse the simplementation of std::copy_n here (or at the call site for what its worth)

909–910

As said above, we should be able to reuse the internals of std::copy_n here

956–966

I believe the inline is superfluous with the _LIBCPP_CONSTEXPR_AFTER_CXX17

Appears throughout

956–966

From here and below there is _LIBCPP_CONSTEXPR_AFTER_CXX11 rather than _LIBCPP_CONSTEXPR_AFTER_CXX17

Also the ordering of _LIBCPP_INLINE_VISIBILITY and _LIBCPP_CONSTEXPR_AFTER_CXX11 is swapped.

libcxx/include/vector

325–326

Many inline below here

[ldionne]

Rebase onto main.

@miscco's comments have not been addressed yet -- I only did the minimal amount of work to fix merge conflicts with main.

Note that not all tests have been constexpr-ified yet, and the ones that have been constexpr-ified are not all passing. Transferring to @philnik as discussed offline.

[philnik]

• Fix tests

libcxx/include/memory

884–885

I think this and the comment below have been addressed. But I'm not 100% sure what you were referring to exactly. Could you comment again at the correct line if the comments haven't been addressed?

956–966

Sorry, I don't know what you are referring to again. I guess they have been addressed since I can't see any _LIBCPP_CONSTEXPR_AFTER_CXX11 of inline in the diff.

libcxx/include/vector

325–326

Again, I guess it has been addressed?

[philnik]

• Try to fix CI

[philnik]

• Next try

[philnik]

• Try to fix GCC

[philnik]

• Try to fix CI

[philnik]

• Rebased
• Fix parts of CI

[philnik]

• Try to fix C++03

[ldionne]

libcxx/include/__bit_reference

358–362

I think we should always call std::fill_n here instead. Indeed, both are equivalent, but std::fill_n is nicer for various reasons.

I know fill_n doesn't end up calling memset directly, however the compiler will end up calling memset (when optimized). IIRC, @var-const was actually about to add this optimization to fill_n explicitly, when we realized it didn't have an impact on the code generation. @var-const can you confirm?

Also, I think we need to add a comment in std::fill_n that explains this. I think it can be done in this patch since we're switching from memset to fill_n.

This comment applies elsewhere in this patch too.

503

Why is this required?

958–961

Instead, I would begin the lifetime of the elements inside __bit_array's constructor if we are during constant evaluation. That way you shouldn't need to change this code at all.

libcxx/include/__memory/construct_at.h

43–44

Please match the style of the class = decltype above, just for consistency.

49

Let's add the _LIBCPP_ASSERT here too.

libcxx/include/__utility/move.h

40–49

I don't think this diff is needed in this patch, see my comment below.

libcxx/include/memory

902

I don't think we *need* to make this change to enable constexpr vector, right? If not, let's pull it into a separate patch, cause I'd like to have a discussion about it. Otherwise, can you please explain why it's needed?

909–910

Given that __begin2 = std::__copy(__begin1, __end1, __begin2); does not compile, I think this overload is never used. Can you please confirm this by adding static_assert(sizeof(_Alloc) == 0, "") and running the tests? If the tests don't fail, then this is a dead code path and we'll need to investigate it.

Edit Well, it looks like we've got enable_if<cond>::type above as a template parameter. IOW, we're declaring a NTTP of type void, and that's never valid. 🤦🏼‍♂️ Clang should really tell us about that. Let's fix it in a separate patch prior to this one.

910

Why are we using std::__copy here? Let's use std::copy instead.

931–936

I think this should all just be uninitialized_copy (or a __ version of it).

[philnik]

• Address comments

[philnik]

libcxx/include/__bit_reference

503

It's not. I probably changed that during some debugging.

libcxx/include/memory

931–936

Just for reference, this is D128146 now.

[var-const]

libcxx/include/__bit_reference

358–362

I can confirm that working on https://reviews.llvm.org/D118329, I found that the compiler would replace uninitialized_fill{,_n} with calls to memset in an optimized build, which made it unnecessary to write that optimization explicitly. I would expect fill_n to work similarly, but I have only tried with the uninitialized algorithms. FWIW, I have a lingering suspicion that there might be some corner cases (related to aliasing, perhaps) where the compiler would fail to do the optimization, but it was absolutely reliable in all the (simple) cases I checked.

[ldionne]

libcxx/include/__bit_reference

391–394

I think it would be more obvious if we at least used static_cast<__storage_type>(-1).

Either way we should probably add a comment.

libcxx/include/vector

1708

What happens if we remove this condition? If the issue is with comparing pointers to unrelated areas of memory, what happens when you use std::less to perform the comparison instead? std::less has a special blessing when it comes to comparing unrelated pointers (yes, it's crazy).

1805

What happens if we remove this condition?

[philnik]

• Address comments

libcxx/include/vector

1708

It still complains that the pointers are unrelated.

1805

Here it also complains about comparing unrelated pointers.

[ldionne]

libcxx/include/__bit_reference

391–394

Marked as done, but not done?

libcxx/include/vector

1805

Can you please add a comment like

// We can't compare unrelated pointers inside constant expressions

in both places?

[philnik]

• Rebased
• Address comments

[philnik]

• Rebased
• Try to fix CI

[EricWF]

libcxx/include/__bit_reference

358–362

@ldionne @var-const Can we get a godbolt showing a call to fill_n that gets lowered to memset?

libcxx/include/vector

417

Is this ever constexpr with the calls to the debug functions?

650

is this function actually constexpr-able?

[philnik]

Rebased

libcxx/include/vector

417

The std::__debug_db_* have if (!__libcpp_is_constant_evaluated()) in them.

650

Why wouldn't it? We're just comparing pointers in there.

[ldionne]

libcxx/include/__bit_reference

358–362

https://godbolt.org/z/je1PGzGds

There is a test for 0 size after the patch, because we do that in fill_n. We might or might not want to look into it, but this can be tackled as a separate issue.

[philnik]

• XFAIL tests and add a reproducer

[philnik]

• Fix CI

[alexfh]

This commit breaks some code in c++20 mode: https://gcc.godbolt.org/z/h7j93MGsb

Specifically, move assignment of a vector of incomplete type can't be compiled now. Is this expected?

#include <vector>

struct S {
  S(S&& s) { v = std::move(s.v); }
  struct Inner;
  std::vector<Inner> v;
};

struct S::Inner {
  int a;
};

In file included from <source>:1:
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:540:52: error: arithmetic on a pointer to an incomplete type 'S::Inner'
        {return static_cast<size_type>(__end_cap() - this->__begin_);}
                                       ~~~~~~~~~~~ ^
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:760:56: note: in instantiation of member function 'std::vector<S::Inner>::capacity' requested here
      __annotate_contiguous_container(data(), data() + capacity(),
                                                       ^
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:431:7: note: in instantiation of member function 'std::vector<S::Inner>::__annotate_delete' requested here
      __annotate_delete();
      ^
<source>:4:3: note: in instantiation of member function 'std::vector<S::Inner>::~vector' requested here
  S(S&& s) { v = std::move(s.v); }
  ^
<source>:5:10: note: forward declaration of 'S::Inner'
  struct Inner;
         ^
In file included from <source>:1:
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:760:54: error: arithmetic on a pointer to an incomplete type 'const value_type' (aka 'const S::Inner')
      __annotate_contiguous_container(data(), data() + capacity(),
                                              ~~~~~~ ^
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:431:7: note: in instantiation of member function 'std::vector<S::Inner>::__annotate_delete' requested here
      __annotate_delete();
      ^
<source>:4:3: note: in instantiation of member function 'std::vector<S::Inner>::~vector' requested here
  S(S&& s) { v = std::move(s.v); }
  ^
<source>:5:10: note: forward declaration of 'S::Inner'
  struct Inner;
         ^
In file included from <source>:1:
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:833:64: error: arithmetic on a pointer to an incomplete type 'S::Inner'
        __alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__soon_to_be_end));
                                                               ^ ~~~~~~~~~~~~~~~~
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:827:29: note: in instantiation of member function 'std::vector<S::Inner>::__base_destruct_at_end' requested here
  void __clear() _NOEXCEPT {__base_destruct_at_end(this->__begin_);}
                            ^
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:436:9: note: in instantiation of member function 'std::vector<S::Inner>::__clear' requested here
        __clear();
        ^
<source>:4:3: note: in instantiation of member function 'std::vector<S::Inner>::~vector' requested here
  S(S&& s) { v = std::move(s.v); }
  ^
<source>:5:10: note: forward declaration of 'S::Inner'
  struct Inner;
         ^
In file included from <source>:1:
In file included from /opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:296:
In file included from /opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/__split_buffer:20:
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/__memory/allocator.h:128:58: error: invalid application of 'sizeof' to an incomplete type 'S::Inner'
            _VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
                                                         ^~~~~~~~~~~
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/__memory/allocator_traits.h:282:13: note: in instantiation of member function 'std::allocator<S::Inner>::deallocate' requested here
        __a.deallocate(__p, __n);
            ^
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:437:25: note: in instantiation of member function 'std::allocator_traits<std::allocator<S::Inner>>::deallocate' requested here
        __alloc_traits::deallocate(__alloc(), this->__begin_, capacity());
                        ^
<source>:4:3: note: in instantiation of member function 'std::vector<S::Inner>::~vector' requested here
  S(S&& s) { v = std::move(s.v); }
  ^
<source>:5:10: note: forward declaration of 'S::Inner'
  struct Inner;
         ^
In file included from <source>:1:
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:537:53: error: arithmetic on a pointer to an incomplete type 'S::Inner'
        {return static_cast<size_type>(this->__end_ - this->__begin_);}
                                       ~~~~~~~~~~~~ ^
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:636:32: note: in instantiation of member function 'std::vector<S::Inner>::size' requested here
        size_type __old_size = size();
                               ^
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:953:9: note: in instantiation of member function 'std::vector<S::Inner>::clear' requested here
        clear();
        ^
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:1314:5: note: in instantiation of member function 'std::vector<S::Inner>::__vdeallocate' requested here
    __vdeallocate();
    ^
/opt/compiler-explorer/clang-trunk-20220809/bin/../include/c++/v1/vector:1288:5: note: in instantiation of member function 'std::vector<S::Inner>::__move_assign' requested here
    __move_assign(__x, integral_constant<bool,
    ^
<source>:4:16: note: in instantiation of member function 'std::vector<S::Inner>::operator=' requested here
  S(S&& s) { v = std::move(s.v); }
               ^
<source>:5:10: note: forward declaration of 'S::Inner'
  struct Inner;
         ^
5 errors generated.
Compiler returned: 1

[philnik]

@alexfh I'm not sure why this worked before, but you've definitely got UB there: http://eel.is/c++draft/vector#overview-4. Clang is probably less permissive when something is declared constexpr.

[alexfh]

In D68365#3711814, @philnik wrote:

@alexfh I'm not sure why this worked before, but you've definitely got UB there: http://eel.is/c++draft/vector#overview-4. Clang is probably less permissive when something is declared constexpr.

I see. Thanks for the reference!

[sberg]

For a -DLIBCXX_ENABLE_DEBUG_MODE=ON build this now causes

$ cat test.cc
#define _LIBCPP_DEBUG 1
#include <vector>
static std::vector<int> v;
int main() {
    v.push_back(0);
    int a = 0;
    for (auto i: v) a += i;
    return a;
}

$ clang++ -stdlib=libc++ -std=c++20 test.cc
$ ./a.out
~/llvm/inst/bin/../include/c++/v1/__iterator/wrap_iter.h:87: assertion ::std::__libcpp_is_constant_evaluated() || (__get_const_db()->__dereferenceable(this)) failed: Attempted to dereference a non-dereferenceable iteratorAborted (core dumped)

[philnik]

In D68365#3725775, @sberg wrote:

For a -DLIBCXX_ENABLE_DEBUG_MODE=ON build this now causes

$ cat test.cc
#define _LIBCPP_DEBUG 1
#include <vector>
static std::vector<int> v;
int main() {
    v.push_back(0);
    int a = 0;
    for (auto i: v) a += i;
    return a;
}

$ clang++ -stdlib=libc++ -std=c++20 test.cc
$ ./a.out
~/llvm/inst/bin/../include/c++/v1/__iterator/wrap_iter.h:87: assertion ::std::__libcpp_is_constant_evaluated() || (__get_const_db()->__dereferenceable(this)) failed: Attempted to dereference a non-dereferenceable iteratorAborted (core dumped)

We are aware of that. See https://llvm.org/PR56782.

libcxx/docs/ReleaseNotes.rst

 - Implemented P0627R6 (Function to mark unreachable code)
 
 - Implemented P1165R1 (Make stateful allocator propagation more consistent for ``operator+(basic_string)``)
 
 - Implemented P0674R1 (Support arrays in ``make_shared`` and ``allocate_shared``)
 
 - Implemented P0980R1 (Making ``std::string`` constexpr)
 
+- Implemented P1004R2 (Making ``std::vector`` constexpr)
+
 - Marked the following papers as "Complete" (note that some of those might have
   been implemented in a previous release but not marked as such):
 
     - P1207R4 (Movability of Single-pass Iterators);
     - P1474R1 (Helpful pointers for ``ContiguousIterator``);
     - P1522R1 (Iterator Difference Type and Integer Overflow);
     - P1523R1 (Views and Size Types);
     - P1456R1 (Move-only views);

libcxx/docs/Status/Cxx20Papers.csv

 "`P0408R7 <https://wg21.link/P0408R7>`__","LWG","Efficient Access to basic_stringbuf's Buffer","Cologne","",""
 "`P0466R5 <https://wg21.link/P0466R5>`__","LWG","Layout-compatibility and Pointer-interconvertibility Traits","Cologne","",""
 "`P0553R4 <https://wg21.link/P0553R4>`__","LWG","Bit operations","Cologne","|Complete|","9.0"
 "`P0631R8 <https://wg21.link/P0631R8>`__","LWG","Math Constants","Cologne","|Complete|","11.0"
 "`P0645R10 <https://wg21.link/P0645R10>`__","LWG","Text Formatting","Cologne","|Complete| [#note-P0645]_","14.0"
 "`P0660R10 <https://wg21.link/P0660R10>`__","LWG","Stop Token and Joining Thread, Rev 10","Cologne","",""
 "`P0784R7 <https://wg21.link/P0784R7>`__","CWG","More constexpr containers","Cologne","|Complete|","12.0"
 "`P0980R1 <https://wg21.link/P0980R1>`__","LWG","Making std::string constexpr","Cologne","|Complete|","15.0"
-"`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","",""
+"`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","|Complete|","15.0"
 "`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors","Cologne","",""
 "`P1065R2 <https://wg21.link/P1065R2>`__","LWG","Constexpr INVOKE","Cologne","|Complete|","12.0"
 "`P1135R6 <https://wg21.link/P1135R6>`__","LWG","The C++20 Synchronization Library","Cologne","|Complete|","11.0"
 "`P1207R4 <https://wg21.link/P1207R4>`__","LWG","Movability of Single-pass Iterators","Cologne","|Complete|","15.0"
 "`P1208R6 <https://wg21.link/P1208R6>`__","LWG","Adopt source_location for C++20","Cologne","",""
 "`P1355R2 <https://wg21.link/P1355R2>`__","LWG","Exposing a narrow contract for ceil2","Cologne","|Complete|","9.0"
 "`P1361R2 <https://wg21.link/P1361R2>`__","LWG","Integration of chrono with text formatting","Cologne","",""
 "`P1423R3 <https://wg21.link/P1423R3>`__","LWG","char8_t backward compatibility remediation","Cologne","|In Progress|",""

libcxx/include/__bit_reference

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___BIT_REFERENCE
 #define _LIBCPP___BIT_REFERENCE
 
+#include <__algorithm/copy_n.h>
+#include <__algorithm/fill_n.h>
 #include <__algorithm/min.h>
 #include <__bits>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <cstring>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
class __bit_reference
     __storage_pointer __seg_;
     __storage_type    __mask_;
 
     friend typename _Cp::__self;
 
     friend class __bit_const_reference<_Cp>;
     friend class __bit_iterator<_Cp, false>;
 public:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     __bit_reference(const __bit_reference&) = default;
 
-    _LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 operator bool() const _NOEXCEPT
         {return static_cast<bool>(*__seg_ & __mask_);}
-    _LIBCPP_INLINE_VISIBILITY bool operator ~() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool operator ~() const _NOEXCEPT
         {return !static_cast<bool>(*this);}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     __bit_reference& operator=(bool __x) _NOEXCEPT
     {
         if (__x)
             *__seg_ |= __mask_;
         else
             *__seg_ &= ~__mask_;
         return *this;
     }
 
 #if _LIBCPP_STD_VER > 20
-    _LIBCPP_HIDE_FROM_ABI const __bit_reference& operator=(bool __x) const noexcept {
+    _LIBCPP_HIDE_FROM_ABI constexpr const __bit_reference& operator=(bool __x) const noexcept {
         if (__x)
             *__seg_ |= __mask_;
         else
             *__seg_ &= ~__mask_;
         return *this;
     }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT
         {return operator=(static_cast<bool>(__x));}
 
-    _LIBCPP_INLINE_VISIBILITY void flip() _NOEXCEPT {*__seg_ ^= __mask_;}
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator<_Cp, false> operator&() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void flip() _NOEXCEPT {*__seg_ ^= __mask_;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, false> operator&() const _NOEXCEPT
         {return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
 private:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     explicit __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
         : __seg_(__s), __mask_(__m) {}
 };
 
 template <class _Cp>
 class __bit_reference<_Cp, false>
 {
 };
 
 template <class _Cp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) _NOEXCEPT
 {
     bool __t = __x;
     __x = __y;
     __y = __t;
 }
 
 template <class _Cp, class _Dp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) _NOEXCEPT
 {
     bool __t = __x;
     __x = __y;
     __y = __t;
 }
 
 template <class _Cp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 swap(__bit_reference<_Cp> __x, bool& __y) _NOEXCEPT
 {
     bool __t = __x;
     __x = __y;
     __y = __t;
 }
 
 template <class _Cp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 swap(bool& __x, __bit_reference<_Cp> __y) _NOEXCEPT
 {
     bool __t = __x;
     __x = __y;
     __y = __t;
 }
 
 template <class _Cp>
 class __bit_const_reference
 {
     typedef typename _Cp::__storage_type          __storage_type;
     typedef typename _Cp::__const_storage_pointer __storage_pointer;
 
     __storage_pointer        __seg_;
     __storage_type __mask_;
 
     friend typename _Cp::__self;
     friend class __bit_iterator<_Cp, true>;
 public:
     _LIBCPP_INLINE_VISIBILITY
     __bit_const_reference(const __bit_const_reference&) = default;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     __bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT
         : __seg_(__x.__seg_), __mask_(__x.__mask_) {}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT
         {return static_cast<bool>(*__seg_ & __mask_);}
 
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator<_Cp, true> operator&() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, true> operator&() const _NOEXCEPT
         {return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
 private:
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR
     explicit __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
         : __seg_(__s), __mask_(__m) {}
 
     __bit_const_reference& operator=(const __bit_const_reference&) = delete;
 };
 
 // find
 
 template <class _Cp, bool _IsConst>
-__bit_iterator<_Cp, _IsConst>
+_LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, _IsConst>
 __find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
 {
     typedef __bit_iterator<_Cp, _IsConst> _It;
     typedef typename _It::__storage_type __storage_type;
-    static const int __bits_per_word = _It::__bits_per_word;
+    const int __bits_per_word = _It::__bits_per_word;
     // do first partial word
     if (__first.__ctz_ != 0)
     {
         __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
         __storage_type __dn = _VSTD::min(__clz_f, __n);
         __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
         __storage_type __b = *__first.__seg_ & __m;
         if (__b)
if (__n > 0)
         __storage_type __b = *__first.__seg_ & __m;
         if (__b)
             return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b)));
     }
     return _It(__first.__seg_, static_cast<unsigned>(__n));
 }
 
 template <class _Cp, bool _IsConst>
-__bit_iterator<_Cp, _IsConst>
+_LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, _IsConst>
 __find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
 {
     typedef __bit_iterator<_Cp, _IsConst> _It;
     typedef typename _It::__storage_type __storage_type;
     const int __bits_per_word = _It::__bits_per_word;
     // do first partial word
     if (__first.__ctz_ != 0)
     {
if (__n > 0)
         __storage_type __b = ~*__first.__seg_ & __m;
         if (__b)
             return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b)));
     }
     return _It(__first.__seg_, static_cast<unsigned>(__n));
 }
 
 template <class _Cp, bool _IsConst, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 __bit_iterator<_Cp, _IsConst>
 find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
 {
     if (static_cast<bool>(__value_))
         return _VSTD::__find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
     return _VSTD::__find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
 }
 
count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
     if (static_cast<bool>(__value_))
         return _VSTD::__count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
     return _VSTD::__count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
 }
 
 // fill_n
 
 template <class _Cp>
-void
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void
 __fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
 {
     typedef __bit_iterator<_Cp, false> _It;
     typedef typename _It::__storage_type __storage_type;
     const int __bits_per_word = _It::__bits_per_word;
     // do first partial word
     if (__first.__ctz_ != 0)
     {
         __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
         __storage_type __dn = _VSTD::min(__clz_f, __n);
         __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
         *__first.__seg_ &= ~__m;
         __n -= __dn;
         ++__first.__seg_;
     }
     // do middle whole words
     __storage_type __nw = __n / __bits_per_word;
+    if (__libcpp_is_constant_evaluated())
+        std::fill_n(std::__to_address(__first.__seg_), 0, __nw);
+    else
         _VSTD::memset(_VSTD::__to_address(__first.__seg_), 0, __nw * sizeof(__storage_type));
     __n -= __nw * __bits_per_word;
     // do last partial word
     if (__n > 0)
     {
         __first.__seg_ += __nw;
         __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
         *__first.__seg_ &= ~__m;
     }
 }
 
 template <class _Cp>
-void
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void
 __fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
 {
     typedef __bit_iterator<_Cp, false> _It;
     typedef typename _It::__storage_type __storage_type;
     const int __bits_per_word = _It::__bits_per_word;
     // do first partial word
     if (__first.__ctz_ != 0)
     {
         __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
         __storage_type __dn = _VSTD::min(__clz_f, __n);
         __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
         *__first.__seg_ |= __m;
         __n -= __dn;
         ++__first.__seg_;
     }
     // do middle whole words
     __storage_type __nw = __n / __bits_per_word;
+    if (__libcpp_is_constant_evaluated())
+        std::fill_n(std::__to_address(__first.__seg_), __nw, -1);
+    else
         _VSTD::memset(_VSTD::__to_address(__first.__seg_), -1, __nw * sizeof(__storage_type));
     __n -= __nw * __bits_per_word;
     // do last partial word
     if (__n > 0)
     {
         __first.__seg_ += __nw;
         __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
         *__first.__seg_ |= __m;
     }
 }
 
 template <class _Cp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value_)
 {
     if (__n > 0)
     {
         if (__value_)
             _VSTD::__fill_n_true(__first, __n);
         else
             _VSTD::__fill_n_false(__first, __n);
     }
 }
 
 // fill
 
 template <class _Cp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value_)
 {
     _VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value_);
 }
 
 // copy
 
 template <class _Cp, bool _IsConst>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __bit_iterator<_Cp, false>
 __copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
                                                      __bit_iterator<_Cp, false> __result)
 {
     typedef __bit_iterator<_Cp, _IsConst> _In;
     typedef  typename _In::difference_type difference_type;
     typedef typename _In::__storage_type __storage_type;
     const int __bits_per_word = _In::__bits_per_word;
if (__n > 0)
             __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
             __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
             ++__first.__seg_;
             // __first.__ctz_ = 0;
         }
         // __first.__ctz_ == 0;
         // do middle words
         __storage_type __nw = __n / __bits_per_word;
-        _VSTD::memmove(_VSTD::__to_address(__result.__seg_),
-                       _VSTD::__to_address(__first.__seg_),
-                       __nw * sizeof(__storage_type));
+        std::copy_n(_VSTD::__to_address(__first.__seg_), __nw, _VSTD::__to_address(__result.__seg_));
         __n -= __nw * __bits_per_word;
         __result.__seg_ += __nw;
         // do last word
         if (__n > 0)
         {
             __first.__seg_ += __nw;
             __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
             __storage_type __b = *__first.__seg_ & __m;
             *__result.__seg_ &= ~__m;
             *__result.__seg_ |= __b;
             __result.__ctz_ = static_cast<unsigned>(__n);
         }
     }
     return __result;
 }
 
 template <class _Cp, bool _IsConst>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __bit_iterator<_Cp, false>
 __copy_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
                                                        __bit_iterator<_Cp, false> __result)
 {
     typedef __bit_iterator<_Cp, _IsConst> _In;
     typedef  typename _In::difference_type difference_type;
     typedef typename _In::__storage_type __storage_type;
-    static const int __bits_per_word = _In::__bits_per_word;
+    const int __bits_per_word = _In::__bits_per_word;
     difference_type __n = __last - __first;
     if (__n > 0)
     {
         // do first word
         if (__first.__ctz_ != 0)
         {
             unsigned __clz_f = __bits_per_word - __first.__ctz_;
             difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
             __n -= __dn;
             __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
             __storage_type __b = *__first.__seg_ & __m;
             unsigned __clz_r = __bits_per_word - __result.__ctz_;
             __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
             __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
-            *__result.__seg_ &= ~__m;
+            *__result.__seg_ = *__result.__seg_ & ~__m;
             if (__result.__ctz_ > __first.__ctz_)
                 *__result.__seg_ |= __b << (__result.__ctz_ - __first.__ctz_);
             else
                 *__result.__seg_ |= __b >> (__first.__ctz_ - __result.__ctz_);
             __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
             __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_)  % __bits_per_word);
             __dn -= __ddn;
             if (__dn > 0)
if (__n > 0)
                 __result.__ctz_ = static_cast<unsigned>(__n);
             }
         }
     }
     return __result;
 }
 
 template <class _Cp, bool _IsConst>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 __bit_iterator<_Cp, false>
 copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
 {
     if (__first.__ctz_ == __result.__ctz_)
         return _VSTD::__copy_aligned(__first, __last, __result);
     return _VSTD::__copy_unaligned(__first, __last, __result);
 }
 
 // copy_backward
 
 template <class _Cp, bool _IsConst>
-__bit_iterator<_Cp, false>
+_LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, false>
 __copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
                                                      __bit_iterator<_Cp, false> __result)
 {
     typedef __bit_iterator<_Cp, _IsConst> _In;
     typedef  typename _In::difference_type difference_type;
     typedef typename _In::__storage_type __storage_type;
     const int __bits_per_word = _In::__bits_per_word;
     difference_type __n = __last - __first;
if (__n > 0)
             // __last.__ctz_ = 0
          }
         // __last.__ctz_ == 0 || __n == 0
         // __result.__ctz_ == 0 || __n == 0
         // do middle words
         __storage_type __nw = __n / __bits_per_word;
         __result.__seg_ -= __nw;
         __last.__seg_ -= __nw;
-        _VSTD::memmove(_VSTD::__to_address(__result.__seg_),
-                       _VSTD::__to_address(__last.__seg_),
-                       __nw * sizeof(__storage_type));
+        std::copy_n(_VSTD::__to_address(__last.__seg_), __nw, _VSTD::__to_address(__result.__seg_));
         __n -= __nw * __bits_per_word;
         // do last word
         if (__n > 0)
         {
             __storage_type __m = ~__storage_type(0) << (__bits_per_word - __n);
             __storage_type __b = *--__last.__seg_ & __m;
             *--__result.__seg_ &= ~__m;
             *__result.__seg_ |= __b;
             __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
         }
     }
     return __result;
 }
 
 template <class _Cp, bool _IsConst>
-__bit_iterator<_Cp, false>
+_LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, false>
 __copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
                                                        __bit_iterator<_Cp, false> __result)
 {
     typedef __bit_iterator<_Cp, _IsConst> _In;
     typedef  typename _In::difference_type difference_type;
     typedef typename _In::__storage_type __storage_type;
     const int __bits_per_word = _In::__bits_per_word;
     difference_type __n = __last - __first;
if (__n > 0)
                 *__result.__seg_ |= __b << (__result.__ctz_ - (__bits_per_word - __n - __dn));
             }
         }
     }
     return __result;
 }
 
 template <class _Cp, bool _IsConst>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 __bit_iterator<_Cp, false>
 copy_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
 {
     if (__last.__ctz_ == __result.__ctz_)
         return _VSTD::__copy_backward_aligned(__first, __last, __result);
     return _VSTD::__copy_backward_unaligned(__first, __last, __result);
 }
 
struct __bit_array
     typedef typename _Cp::__storage_pointer __storage_pointer;
     typedef typename _Cp::iterator        iterator;
     static const unsigned __bits_per_word = _Cp::__bits_per_word;
     static const unsigned _Np = 4;
 
     difference_type __size_;
     __storage_type __word_[_Np];
 
-    _LIBCPP_INLINE_VISIBILITY static difference_type capacity()
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 static difference_type capacity()
         {return static_cast<difference_type>(_Np * __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY explicit __bit_array(difference_type __s) : __size_(__s) {}
-    _LIBCPP_INLINE_VISIBILITY iterator begin()
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit __bit_array(difference_type __s) : __size_(__s) {}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator begin()
     {
         return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]), 0);
     }
-    _LIBCPP_INLINE_VISIBILITY iterator end()
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator end()
     {
         return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]) + __size_ / __bits_per_word,
                                                   static_cast<unsigned>(__size_ % __bits_per_word));
     }
 };
 
 template <class _Cp>
-__bit_iterator<_Cp, false>
+_LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator<_Cp, false>
 rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle, __bit_iterator<_Cp, false> __last)
 {
     typedef __bit_iterator<_Cp, false> _I1;
     typedef  typename _I1::difference_type difference_type;
     difference_type __d1 = __middle - __first;
     difference_type __d2 = __last - __middle;
     _I1 __r = __first + __d2;
     while (__d1 != 0 && __d2 != 0)
while (__d1 != 0 && __d2 != 0)
                 __d2 -= __d1;
             }
         }
         else
         {
             if (__d2 <= __bit_array<_Cp>::capacity())
             {
                 __bit_array<_Cp> __b(__d2);
+                if (__libcpp_is_constant_evaluated()) {
+                    for (size_t __i = 0; __i != __bit_array<_Cp>::_Np; ++__i)
+                        std::__construct_at(__b.__word_ + __i, 0);
+                }
                 _VSTD::copy(__middle, __last, __b.begin());
                 _VSTD::copy_backward(__b.begin(), __b.end(), _VSTD::copy_backward(__first, __middle, __last));
                 break;
             }
             else
             {
                 __bit_iterator<_Cp, false> __mp = __first + __d2;
                 _VSTD::swap_ranges(__first, __mp, __middle);
                 __first = __mp;
                 __d1 -= __d2;
             }
         }
     }
     return __r;
 }
 
 // equal
 
 template <class _Cp, bool _IC1, bool _IC2>
-bool
+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
 __equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
                   __bit_iterator<_Cp, _IC2> __first2)
 {
     typedef __bit_iterator<_Cp, _IC1> _It;
     typedef  typename _It::difference_type difference_type;
     typedef typename _It::__storage_type __storage_type;
-    static const int __bits_per_word = _It::__bits_per_word;
+    const int __bits_per_word = _It::__bits_per_word;
     difference_type __n = __last1 - __first1;
     if (__n > 0)
     {
         // do first word
         if (__first1.__ctz_ != 0)
         {
             unsigned __clz_f = __bits_per_word - __first1.__ctz_;
             difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
if (__n > 0)
                     return false;
             }
         }
     }
     return true;
 }
 
 template <class _Cp, bool _IC1, bool _IC2>
-bool
+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
 __equal_aligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
                 __bit_iterator<_Cp, _IC2> __first2)
 {
     typedef __bit_iterator<_Cp, _IC1> _It;
     typedef  typename _It::difference_type difference_type;
     typedef typename _It::__storage_type __storage_type;
-    static const int __bits_per_word = _It::__bits_per_word;
+    const int __bits_per_word = _It::__bits_per_word;
     difference_type __n = __last1 - __first1;
     if (__n > 0)
     {
         // do first word
         if (__first1.__ctz_ != 0)
         {
             unsigned __clz = __bits_per_word - __first1.__ctz_;
             difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
if (__n > 0)
             if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
                 return false;
         }
     }
     return true;
 }
 
 template <class _Cp, bool _IC1, bool _IC2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2)
 {
     if (__first1.__ctz_ == __first2.__ctz_)
         return _VSTD::__equal_aligned(__first1, __last1, __first2);
     return _VSTD::__equal_unaligned(__first1, __last1, __first2);
 }
 
private:
     typedef typename conditional<_IsConst, typename _Cp::__const_storage_pointer,
                                            typename _Cp::__storage_pointer>::type  __storage_pointer;
     static const unsigned __bits_per_word = _Cp::__bits_per_word;
 
     __storage_pointer __seg_;
     unsigned          __ctz_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator() _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER > 11
     : __seg_(nullptr), __ctz_(0)
 #endif
     {}
 
     // When _IsConst=false, this is the copy constructor.
     // It is non-trivial. Making it trivial would break ABI.
     // When _IsConst=true, this is a converting constructor;
     // the copy and move constructors are implicitly generated
     // and trivial.
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
         : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
 
     // When _IsConst=false, we have a user-provided copy constructor,
     // so we must also provide a copy assignment operator because
     // the implicit generation of a defaulted one is deprecated.
     // When _IsConst=true, the assignment operators are
     // implicitly generated and trivial.
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     __bit_iterator& operator=(const _If<_IsConst, struct __private_nat, __bit_iterator>& __it) {
         __seg_ = __it.__seg_;
         __ctz_ = __it.__ctz_;
         return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT {
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference operator*() const _NOEXCEPT {
         return typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >
                 ::type(__seg_, __storage_type(1) << __ctz_);
     }
 
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator++()
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator& operator++()
     {
         if (__ctz_ != __bits_per_word-1)
             ++__ctz_;
         else
         {
             __ctz_ = 0;
             ++__seg_;
         }
         return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator operator++(int)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator operator++(int)
     {
         __bit_iterator __tmp = *this;
         ++(*this);
         return __tmp;
     }
 
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator--()
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator& operator--()
     {
         if (__ctz_ != 0)
             --__ctz_;
         else
         {
             __ctz_ = __bits_per_word - 1;
             --__seg_;
         }
         return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator operator--(int)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator operator--(int)
     {
         __bit_iterator __tmp = *this;
         --(*this);
         return __tmp;
     }
 
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator+=(difference_type __n)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator& operator+=(difference_type __n)
     {
         if (__n >= 0)
             __seg_ += (__n + __ctz_) / __bits_per_word;
         else
             __seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1)
                     / static_cast<difference_type>(__bits_per_word);
         __n &= (__bits_per_word - 1);
         __ctz_ = static_cast<unsigned>((__n + __ctz_)  % __bits_per_word);
         return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator-=(difference_type __n)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator& operator-=(difference_type __n)
     {
         return *this += -__n;
     }
 
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator operator+(difference_type __n) const
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator operator+(difference_type __n) const
     {
         __bit_iterator __t(*this);
         __t += __n;
         return __t;
     }
 
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator operator-(difference_type __n) const
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bit_iterator operator-(difference_type __n) const
     {
         __bit_iterator __t(*this);
         __t -= __n;
         return __t;
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     friend __bit_iterator operator+(difference_type __n, const __bit_iterator& __it) {return __it + __n;}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     friend difference_type operator-(const __bit_iterator& __x, const __bit_iterator& __y)
         {return (__x.__seg_ - __y.__seg_) * __bits_per_word + __x.__ctz_ - __y.__ctz_;}
 
-    _LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const {return *(*this + __n);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference operator[](difference_type __n) const {return *(*this + __n);}
 
-    _LIBCPP_INLINE_VISIBILITY friend bool operator==(const __bit_iterator& __x, const __bit_iterator& __y)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator==(const __bit_iterator& __x, const __bit_iterator& __y)
         {return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;}
 
-    _LIBCPP_INLINE_VISIBILITY friend bool operator!=(const __bit_iterator& __x, const __bit_iterator& __y)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator!=(const __bit_iterator& __x, const __bit_iterator& __y)
         {return !(__x == __y);}
 
-    _LIBCPP_INLINE_VISIBILITY friend bool operator<(const __bit_iterator& __x, const __bit_iterator& __y)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator<(const __bit_iterator& __x, const __bit_iterator& __y)
         {return __x.__seg_ < __y.__seg_ || (__x.__seg_ == __y.__seg_ && __x.__ctz_ < __y.__ctz_);}
 
-    _LIBCPP_INLINE_VISIBILITY friend bool operator>(const __bit_iterator& __x, const __bit_iterator& __y)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator>(const __bit_iterator& __x, const __bit_iterator& __y)
         {return __y < __x;}
 
-    _LIBCPP_INLINE_VISIBILITY friend bool operator<=(const __bit_iterator& __x, const __bit_iterator& __y)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator<=(const __bit_iterator& __x, const __bit_iterator& __y)
         {return !(__y < __x);}
 
-    _LIBCPP_INLINE_VISIBILITY friend bool operator>=(const __bit_iterator& __x, const __bit_iterator& __y)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 friend bool operator>=(const __bit_iterator& __x, const __bit_iterator& __y)
         {return !(__x < __y);}
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     explicit __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
         : __seg_(__s), __ctz_(__ctz) {}
 
     friend typename _Cp::__self;
 
     friend class __bit_reference<_Cp>;
     friend class __bit_const_reference<_Cp>;
     friend class __bit_iterator<_Cp, true>;
     template <class _Dp> friend struct __bit_array;
-    template <class _Dp> friend void __fill_n_false(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
-    template <class _Dp> friend void __fill_n_true(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
-    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_aligned(__bit_iterator<_Dp, _IC> __first,
-                                                                                  __bit_iterator<_Dp, _IC> __last,
-                                                                                  __bit_iterator<_Dp, false> __result);
-    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_unaligned(__bit_iterator<_Dp, _IC> __first,
-                                                                                    __bit_iterator<_Dp, _IC> __last,
-                                                                                    __bit_iterator<_Dp, false> __result);
-    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> copy(__bit_iterator<_Dp, _IC> __first,
-                                                                        __bit_iterator<_Dp, _IC> __last,
-                                                                        __bit_iterator<_Dp, false> __result);
-    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_backward_aligned(__bit_iterator<_Dp, _IC> __first,
-                                                                                           __bit_iterator<_Dp, _IC> __last,
-                                                                                           __bit_iterator<_Dp, false> __result);
-    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_backward_unaligned(__bit_iterator<_Dp, _IC> __first,
-                                                                                             __bit_iterator<_Dp, _IC> __last,
-                                                                                             __bit_iterator<_Dp, false> __result);
-    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> copy_backward(__bit_iterator<_Dp, _IC> __first,
-                                                                                 __bit_iterator<_Dp, _IC> __last,
-                                                                                 __bit_iterator<_Dp, false> __result);
+    template <class _Dp>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend void __fill_n_false(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
+
+    template <class _Dp>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend void __fill_n_true(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
+
+    template <class _Dp, bool _IC>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend __bit_iterator<_Dp, false> __copy_aligned(__bit_iterator<_Dp, _IC> __first,
+    template <class _Dp, bool _IC>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend __bit_iterator<_Dp, false> __copy_unaligned(__bit_iterator<_Dp, _IC> __first,
+    template <class _Dp, bool _IC>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend __bit_iterator<_Dp, false> copy(__bit_iterator<_Dp, _IC> __first,
+    template <class _Dp, bool _IC>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend __bit_iterator<_Dp, false> __copy_backward_aligned(__bit_iterator<_Dp, _IC> __first,
+    template <class _Dp, bool _IC>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend __bit_iterator<_Dp, false> __copy_backward_unaligned(__bit_iterator<_Dp, _IC> __first,
+    template <class _Dp, bool _IC>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend __bit_iterator<_Dp, false> copy_backward(__bit_iterator<_Dp, _IC> __first,
     template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>,
                                                                                            __bit_iterator<__C1, false>,
                                                                                            __bit_iterator<__C2, false>);
     template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>,
                                                                                              __bit_iterator<__C1, false>,
                                                                                              __bit_iterator<__C2, false>);
     template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>,
                                                                                  __bit_iterator<__C1, false>,
                                                                                  __bit_iterator<__C2, false>);
-    template <class _Dp> friend __bit_iterator<_Dp, false> rotate(__bit_iterator<_Dp, false>,
-                                                                __bit_iterator<_Dp, false>,
-                                                                __bit_iterator<_Dp, false>);
-    template <class _Dp, bool _IC1, bool _IC2> friend bool __equal_aligned(__bit_iterator<_Dp, _IC1>,
-                                                    __bit_iterator<_Dp, _IC1>,
-                                                    __bit_iterator<_Dp, _IC2>);
-    template <class _Dp, bool _IC1, bool _IC2> friend bool __equal_unaligned(__bit_iterator<_Dp, _IC1>,
-                                                      __bit_iterator<_Dp, _IC1>,
-                                                      __bit_iterator<_Dp, _IC2>);
-    template <class _Dp, bool _IC1, bool _IC2> friend bool equal(__bit_iterator<_Dp, _IC1>,
-                                                                __bit_iterator<_Dp, _IC1>,
-                                                                __bit_iterator<_Dp, _IC2>);
-    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, _IC> __find_bool_true(__bit_iterator<_Dp, _IC>,
-                                                                          typename _Dp::size_type);
-    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, _IC> __find_bool_false(__bit_iterator<_Dp, _IC>,
-                                                                           typename _Dp::size_type);
+    template <class _Dp>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend __bit_iterator<_Dp, false> rotate(__bit_iterator<_Dp, false>,
+    template <class _Dp, bool _IC1, bool _IC2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend bool __equal_aligned(__bit_iterator<_Dp, _IC1>,
+    template <class _Dp, bool _IC1, bool _IC2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend bool __equal_unaligned(__bit_iterator<_Dp, _IC1>,
+    template <class _Dp, bool _IC1, bool _IC2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend bool equal(__bit_iterator<_Dp, _IC1>,
+    template <class _Dp, bool _IC>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend __bit_iterator<_Dp, _IC> __find_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
+    template <class _Dp, bool _IC>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
+    friend __bit_iterator<_Dp, _IC> __find_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
     template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
                    __count_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
     template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
                    __count_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___BIT_REFERENCE

libcxx/include/__memory/construct_at.h

 _LIBCPP_HIDE_FROM_ABI
 constexpr _Tp* construct_at(_Tp* __location, _Args&& ...__args) {
     _LIBCPP_ASSERT(__location != nullptr, "null pointer given to construct_at");
     return ::new (_VSTD::__voidify(*__location)) _Tp(_VSTD::forward<_Args>(__args)...);
 }
 
 #endif
 
+template <class _Tp, class ..._Args, class = decltype(::new (declval<void*>()) _Tp(declval<_Args>()...))>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+_Tp* __construct_at(_Tp* __location, _Args&&... __args) {
+#if _LIBCPP_STD_VER > 17
+    return std::construct_at(__location, __args...);
+#else
+    return ::new (std::__voidify(*__location)) _Tp(std::forward<_Args>(__args)...);
+#endif
+}
+
 // destroy_at
 
 // The internal functions are available regardless of the language version (with the exception of the `__destroy_at`
 // taking an array).
 
 template <class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 _ForwardIterator __destroy(_ForwardIterator, _ForwardIterator);

libcxx/include/__memory/pointer_traits.h

 #else
     template <class _Up> struct rebind
         {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;};
 #endif // _LIBCPP_CXX03_LANG
 
 private:
     struct __nat {};
 public:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static pointer pointer_to(typename conditional<is_void<element_type>::value,
                                            __nat, element_type>::type& __r)
         {return pointer::pointer_to(__r);}
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*>
 {

libcxx/include/__split_buffer

public:
     pointer                                         __first_;
     pointer                                         __begin_;
     pointer                                         __end_;
     __compressed_pair<pointer, allocator_type> __end_cap_;
 
     typedef typename add_lvalue_reference<allocator_type>::type __alloc_ref;
     typedef typename add_lvalue_reference<allocator_type>::type __alloc_const_ref;
 
-    _LIBCPP_INLINE_VISIBILITY __alloc_rr&           __alloc() _NOEXCEPT         {return __end_cap_.second();}
-    _LIBCPP_INLINE_VISIBILITY const __alloc_rr&     __alloc() const _NOEXCEPT   {return __end_cap_.second();}
-    _LIBCPP_INLINE_VISIBILITY pointer&              __end_cap() _NOEXCEPT       {return __end_cap_.first();}
-    _LIBCPP_INLINE_VISIBILITY const pointer&        __end_cap() const _NOEXCEPT {return __end_cap_.first();}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY __alloc_rr&           __alloc() _NOEXCEPT         {return __end_cap_.second();}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const __alloc_rr&     __alloc() const _NOEXCEPT   {return __end_cap_.second();}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY pointer&              __end_cap() _NOEXCEPT       {return __end_cap_.first();}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const pointer&        __end_cap() const _NOEXCEPT {return __end_cap_.first();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     __split_buffer()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     explicit __split_buffer(__alloc_rr& __a);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     explicit __split_buffer(const __alloc_rr& __a);
-    __split_buffer(size_type __cap, size_type __start, __alloc_rr& __a);
-    ~__split_buffer();
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __split_buffer(size_type __cap, size_type __start, __alloc_rr& __a);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 ~__split_buffer();
 
-    __split_buffer(__split_buffer&& __c)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __split_buffer(__split_buffer&& __c)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
-    __split_buffer(__split_buffer&& __c, const __alloc_rr& __a);
-    __split_buffer& operator=(__split_buffer&& __c)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __split_buffer(__split_buffer&& __c, const __alloc_rr& __a);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __split_buffer& operator=(__split_buffer&& __c)
         _NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
                 is_nothrow_move_assignable<allocator_type>::value) ||
                !__alloc_traits::propagate_on_container_move_assignment::value);
 
-    _LIBCPP_INLINE_VISIBILITY       iterator begin() _NOEXCEPT       {return __begin_;}
-    _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return __begin_;}
-    _LIBCPP_INLINE_VISIBILITY       iterator end() _NOEXCEPT         {return __end_;}
-    _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT   {return __end_;}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY       iterator begin() _NOEXCEPT       {return __begin_;}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return __begin_;}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY       iterator end() _NOEXCEPT         {return __end_;}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT   {return __end_;}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT
         {__destruct_at_end(__begin_);}
-    _LIBCPP_INLINE_VISIBILITY size_type size() const {return static_cast<size_type>(__end_ - __begin_);}
-    _LIBCPP_INLINE_VISIBILITY bool empty()     const {return __end_ == __begin_;}
-    _LIBCPP_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __first_);}
-    _LIBCPP_INLINE_VISIBILITY size_type __front_spare() const {return static_cast<size_type>(__begin_ - __first_);}
-    _LIBCPP_INLINE_VISIBILITY size_type __back_spare() const {return static_cast<size_type>(__end_cap() - __end_);}
-
-    _LIBCPP_INLINE_VISIBILITY       reference front()       {return *__begin_;}
-    _LIBCPP_INLINE_VISIBILITY const_reference front() const {return *__begin_;}
-    _LIBCPP_INLINE_VISIBILITY       reference back()        {return *(__end_ - 1);}
-    _LIBCPP_INLINE_VISIBILITY const_reference back() const  {return *(__end_ - 1);}
-
-    void reserve(size_type __n);
-    void shrink_to_fit() _NOEXCEPT;
-    void push_front(const_reference __x);
-    _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
-    void push_front(value_type&& __x);
-    void push_back(value_type&& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY size_type size() const {return static_cast<size_type>(__end_ - __begin_);}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY bool empty()     const {return __end_ == __begin_;}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __first_);}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY size_type __front_spare() const {return static_cast<size_type>(__begin_ - __first_);}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY size_type __back_spare() const {return static_cast<size_type>(__end_cap() - __end_);}
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY       reference front()       {return *__begin_;}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_reference front() const {return *__begin_;}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY       reference back()        {return *(__end_ - 1);}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_reference back() const  {return *(__end_ - 1);}
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reserve(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void shrink_to_fit() _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void push_front(const_reference __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void push_front(value_type&& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void push_back(value_type&& __x);
     template <class... _Args>
-        void emplace_back(_Args&&... __args);
+        _LIBCPP_CONSTEXPR_AFTER_CXX17 void emplace_back(_Args&&... __args);
 
-    _LIBCPP_INLINE_VISIBILITY void pop_front() {__destruct_at_begin(__begin_+1);}
-    _LIBCPP_INLINE_VISIBILITY void pop_back() {__destruct_at_end(__end_-1);}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void pop_front() {__destruct_at_begin(__begin_+1);}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void pop_back() {__destruct_at_end(__end_-1);}
 
-    void __construct_at_end(size_type __n);
-    void __construct_at_end(size_type __n, const_reference __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_at_end(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_at_end(size_type __n, const_reference __x);
     template <class _InputIter>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename enable_if
         <
             __is_cpp17_input_iterator<_InputIter>::value &&
            !__is_cpp17_forward_iterator<_InputIter>::value,
             void
         >::type
         __construct_at_end(_InputIter __first, _InputIter __last);
     template <class _ForwardIterator>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename enable_if
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
             void
         >::type
         __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
 
-    _LIBCPP_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin)
         {__destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());}
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
         void __destruct_at_begin(pointer __new_begin, false_type);
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
         void __destruct_at_begin(pointer __new_begin, true_type);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __destruct_at_end(pointer __new_last) _NOEXCEPT
         {__destruct_at_end(__new_last, false_type());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
         void __destruct_at_end(pointer __new_last, false_type) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
         void __destruct_at_end(pointer __new_last, true_type) _NOEXCEPT;
 
-    void swap(__split_buffer& __x)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(__split_buffer& __x)
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
                    __is_nothrow_swappable<__alloc_rr>::value);
 
-    bool __invariants() const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __invariants() const;
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__split_buffer& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
             __alloc() = _VSTD::move(__c.__alloc());
         }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__split_buffer&, false_type) _NOEXCEPT
         {}
 
     struct _ConstructTransaction {
-      explicit _ConstructTransaction(pointer* __p, size_type __n) _NOEXCEPT
+      _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit _ConstructTransaction(pointer* __p, size_type __n) _NOEXCEPT
       : __pos_(*__p), __end_(*__p + __n), __dest_(__p) {
       }
-      ~_ConstructTransaction() {
+      _LIBCPP_CONSTEXPR_AFTER_CXX17 ~_ConstructTransaction() {
         *__dest_ = __pos_;
       }
       pointer __pos_;
      const pointer __end_;
     private:
      pointer *__dest_;
     };
 };
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 __split_buffer<_Tp, _Allocator>::__invariants() const
 {
     if (__first_ == nullptr)
     {
         if (__begin_ != nullptr)
             return false;
         if (__end_ != nullptr)

 }
 
 //  Default constructs __n objects starting at __end_
 //  throws if construction throws
 //  Precondition:  __n > 0
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
 {
     _ConstructTransaction __tx(&this->__end_, __n);
     for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
         __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_));
     }
 }
 
 //  Copy constructs __n objects starting at __end_ from __x
 //  throws if construction throws
 //  Precondition:  __n > 0
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == old size() + __n
 //  Postcondition:  [i] == __x for all i in [size() - __n, __n)
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
 {
     _ConstructTransaction __tx(&this->__end_, __n);
     for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
         __alloc_traits::construct(this->__alloc(),
             _VSTD::__to_address(__tx.__pos_), __x);
     }
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIter>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
      __is_cpp17_input_iterator<_InputIter>::value &&
     !__is_cpp17_forward_iterator<_InputIter>::value,
     void
 >::type
 __split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIter __last)
 {
for (; __first != __last; ++__first)
         }
         __alloc_traits::construct(__a, _VSTD::__to_address(this->__end_), *__first);
         ++this->__end_;
     }
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
     void
 >::type
 __split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
 {
     _ConstructTransaction __tx(&this->__end_, _VSTD::distance(__first, __last));
     for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void) ++__first) {
         __alloc_traits::construct(this->__alloc(),
             _VSTD::__to_address(__tx.__pos_), *__first);
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline
 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type)
 {
     while (__begin_ != __new_begin)
         __alloc_traits::destroy(__alloc(), _VSTD::__to_address(__begin_++));
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline
 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_type)
 {
     __begin_ = __new_begin;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT
 {
     while (__new_last != __end_)
         __alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__end_));
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) _NOEXCEPT
 {
     __end_ = __new_last;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __start, __alloc_rr& __a)
     : __end_cap_(nullptr, __a)
 {
     if (__cap == 0) {
         __first_ = nullptr;
     } else {
         auto __allocation = std::__allocate_at_least(__alloc(), __cap);
         __first_ = __allocation.ptr;
         __cap = __allocation.count;
     }
     __begin_ = __end_ = __first_ + __start;
     __end_cap() = __first_ + __cap;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline
 __split_buffer<_Tp, _Allocator>::__split_buffer()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __default_init_tag())
 {
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline
 __split_buffer<_Tp, _Allocator>::__split_buffer(__alloc_rr& __a)
     : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
 {
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline
 __split_buffer<_Tp, _Allocator>::__split_buffer(const __alloc_rr& __a)
     : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
 {
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __split_buffer<_Tp, _Allocator>::~__split_buffer()
 {
     clear();
     if (__first_)
         __alloc_traits::deallocate(__alloc(), __first_, capacity());
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
     : __first_(_VSTD::move(__c.__first_)),
       __begin_(_VSTD::move(__c.__begin_)),
       __end_(_VSTD::move(__c.__end_)),
       __end_cap_(_VSTD::move(__c.__end_cap_))
 {
     __c.__first_ = nullptr;
     __c.__begin_ = nullptr;
     __c.__end_ = nullptr;
     __c.__end_cap() = nullptr;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __alloc_rr& __a)
     : __end_cap_(nullptr, __a)
 {
     if (__a == __c.__alloc())
     {
         __first_ = __c.__first_;
         __begin_ = __c.__begin_;
         __end_ = __c.__end_;
else
         __begin_ = __end_ = __first_;
         __end_cap() = __first_ + __allocation.count;
         typedef move_iterator<iterator> _Ip;
         __construct_at_end(_Ip(__c.begin()), _Ip(__c.end()));
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __split_buffer<_Tp, _Allocator>&
 __split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c)
     _NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
                 is_nothrow_move_assignable<allocator_type>::value) ||
                !__alloc_traits::propagate_on_container_move_assignment::value)
 {
     clear();
     shrink_to_fit();
     __first_ = __c.__first_;
     __begin_ = __c.__begin_;
     __end_ = __c.__end_;
     __end_cap() = __c.__end_cap();
     __move_assign_alloc(__c,
         integral_constant<bool,
                           __alloc_traits::propagate_on_container_move_assignment::value>());
     __c.__first_ = __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
     return *this;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
                    __is_nothrow_swappable<__alloc_rr>::value)
 {
     _VSTD::swap(__first_, __x.__first_);
     _VSTD::swap(__begin_, __x.__begin_);
     _VSTD::swap(__end_, __x.__end_);
     _VSTD::swap(__end_cap(), __x.__end_cap());
     _VSTD::__swap_allocator(__alloc(), __x.__alloc());
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 __split_buffer<_Tp, _Allocator>::reserve(size_type __n)
 {
     if (__n < capacity())
     {
         __split_buffer<value_type, __alloc_rr&> __t(__n, 0, __alloc());
         __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                move_iterator<pointer>(__end_));
         _VSTD::swap(__first_, __t.__first_);
         _VSTD::swap(__begin_, __t.__begin_);
         _VSTD::swap(__end_, __t.__end_);
         _VSTD::swap(__end_cap(), __t.__end_cap());
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 __split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
 {
     if (capacity() > size())
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
#ifndef _LIBCPP_NO_EXCEPTIONS
         catch (...)
         {
         }
 #endif // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
 {
     if (__begin_ == __first_)
     {
         if (__end_ < __end_cap())
         {
             difference_type __d = __end_cap() - __end_;
if (__begin_ == __first_)
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
     __alloc_traits::construct(__alloc(), _VSTD::__to_address(__begin_-1), __x);
     --__begin_;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
 {
     if (__begin_ == __first_)
     {
         if (__end_ < __end_cap())
         {
             difference_type __d = __end_cap() - __end_;
if (__begin_ == __first_)
         }
     }
     __alloc_traits::construct(__alloc(), _VSTD::__to_address(__begin_-1),
             _VSTD::move(__x));
     --__begin_;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 void
 __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
 {
     if (__end_ == __end_cap())
     {
         if (__begin_ > __first_)
         {
if (__end_ == __end_cap())
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
     __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_), __x);
     ++__end_;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
 {
     if (__end_ == __end_cap())
     {
         if (__begin_ > __first_)
         {
             difference_type __d = __begin_ - __first_;
__split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
     }
     __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_),
             _VSTD::move(__x));
     ++__end_;
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
 {
     if (__end_ == __end_cap())
     {
         if (__begin_ > __first_)
         {
             difference_type __d = __begin_ - __first_;
if (__end_ == __end_cap())
         }
     }
     __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_),
                               _VSTD::forward<_Args>(__args)...);
     ++__end_;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y)
         _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___SPLIT_BUFFER

libcxx/include/__utility/move.h

typename conditional<!is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, const _Tp&,
                          _Tp&&>::type;
 
 template <class _Tp>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 __move_if_noexcept_result_t<_Tp>
 move_if_noexcept(_Tp& __x) _NOEXCEPT {
   return _VSTD::move(__x);
 }
 
+template <class _Tp>
+_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+#ifdef _LIBCPP_NO_EXCEPTIONS
+typename remove_reference<_Tp>::type&&
+#else
+__move_if_noexcept_result_t<_Tp>
+#endif
+__move_if_noexcept(_Tp& __x) _NOEXCEPT {
+  return std::move(__x);
+}
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___UTILITY_MOVE_H

libcxx/include/memory

 
 template<size_t N, class T>
 [[nodiscard]] constexpr T* assume_aligned(T* ptr); // since C++20
 
 }  // std
 
 */
 
+#include <__algorithm/copy.h>
+#include <__algorithm/move.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_traits.h>

 
 // TODO: remove these headers
 #include <__functional/binary_function.h>
 #include <__functional/invoke.h>
 #include <__functional/operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h>
 #include <__functional/weak_result_type.h>
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 #   include <__memory/auto_ptr.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Alloc, class _Ptr>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
 void __construct_forward_with_exception_guarantees(_Alloc& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2) {
     static_assert(__is_cpp17_move_insertable<_Alloc>::value,
         "The specified type does not meet the requirements of Cpp17MoveInsertable");
     typedef allocator_traits<_Alloc> _Traits;
-    for (; __begin1 != __end1; ++__begin1, (void)++__begin2) {
-        _Traits::construct(__a, _VSTD::__to_address(__begin2),
-#ifdef _LIBCPP_NO_EXCEPTIONS
-            _VSTD::move(*__begin1)
-#else
-            _VSTD::move_if_noexcept(*__begin1)
-#endif
-        );
-    }
+    for (; __begin1 != __end1; ++__begin1, (void)++__begin2)
+        _Traits::construct(__a, std::__to_address(__begin2), std::__move_if_noexcept(*__begin1));
 }
 
-template <class _Alloc, class _Tp, typename enable_if<
+template <class _Alloc, class _Tp, __enable_if_t<
     (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Tp*, _Tp>::value) &&
-    is_trivially_move_constructible<_Tp>::value
->::type>
-_LIBCPP_INLINE_VISIBILITY
+    is_trivially_move_constructible<_Tp>::value> >
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
 void __construct_forward_with_exception_guarantees(_Alloc&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2) {
-    ptrdiff_t _Np = __end1 - __begin1;
-    if (_Np > 0) {
-        _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp));
-        __begin2 += _Np;
-    }
+    __begin2 = std::__copy(__begin1, __end1, __begin2);
 }
 
 template <class _Alloc, class _Iter, class _Ptr>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
 void __construct_range_forward(_Alloc& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2) {
     typedef allocator_traits<_Alloc> _Traits;
-    for (; __begin1 != __end1; ++__begin1, (void) ++__begin2) {
+    for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)
         _Traits::construct(__a, _VSTD::__to_address(__begin2), *__begin1);
-    }
-}
 
 template <class _Alloc, class _Source, class _Dest,
           class _RawSource = typename remove_const<_Source>::type,
           class _RawDest = typename remove_const<_Dest>::type,
-          class =
-    typename enable_if<
+          class = __enable_if_t<
         is_trivially_copy_constructible<_Dest>::value &&
         is_same<_RawSource, _RawDest>::value &&
         (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Dest*, _Source&>::value)
-    >::type>
-_LIBCPP_INLINE_VISIBILITY
+    > >
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
 void __construct_range_forward(_Alloc&, _Source* __begin1, _Source* __end1, _Dest*& __begin2) {
-    ptrdiff_t _Np = __end1 - __begin1;
-    if (_Np > 0) {
-        _VSTD::memcpy(const_cast<_RawDest*>(__begin2), __begin1, _Np * sizeof(_Dest));
-        __begin2 += _Np;
+    if (__libcpp_is_constant_evaluated()) {
+        while (__begin1 != __end1)
+            std::__construct_at(__begin2++, *__begin1++);
+    } else {
+        __begin2 = std::__copy(__begin1, __end1, const_cast<_RawDest*>(__begin2)).second;
     }
 }
 
 template <class _Alloc, class _Ptr>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
 void __construct_backward_with_exception_guarantees(_Alloc& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2) {
     static_assert(__is_cpp17_move_insertable<_Alloc>::value,
         "The specified type does not meet the requirements of Cpp17MoveInsertable");
     typedef allocator_traits<_Alloc> _Traits;
     while (__end1 != __begin1) {
-        _Traits::construct(__a, _VSTD::__to_address(__end2 - 1),
-#ifdef _LIBCPP_NO_EXCEPTIONS
-            _VSTD::move(*--__end1)
-#else
-            _VSTD::move_if_noexcept(*--__end1)
-#endif
-        );
+        _Traits::construct(__a, std::__to_address(__end2 - 1), std::__move_if_noexcept(*--__end1));
         --__end2;
     }
 }
 
 template <class _Alloc, class _Tp, class = typename enable_if<
     (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Tp*, _Tp>::value) &&
     is_trivially_move_constructible<_Tp>::value
 >::type>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
 void __construct_backward_with_exception_guarantees(_Alloc&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2) {
-    ptrdiff_t _Np = __end1 - __begin1;
-    __end2 -= _Np;
-    if (_Np > 0)
-        _VSTD::memcpy(static_cast<void*>(__end2), static_cast<void const*>(__begin1), _Np * sizeof(_Tp));
+    if (__libcpp_is_constant_evaluated()) {
+        while (__end1 != __begin1) {
+            std::__construct_at(__end2 - 1, std::__move_if_noexcept(*--__end1));
+            --__end2;
+        }
+    } else {
+        ptrdiff_t __distance = __end1 - __begin1;
+        __end2 -= __distance;
+        std::move(__begin1, __end1, __end2);
+    }
 }
 
 struct __destruct_n
 {
 private:
     size_t __size_;
 
     template <class _Tp>

 #endif
     > {};
 
 
 template <class _Tp, class _Alloc>
 struct __temp_value {
     typedef allocator_traits<_Alloc> _Traits;
 
-    typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
+    union { _Tp __v; };
     _Alloc &__a;
 
-    _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); }
-    _Tp &   get() { return *__addr(); }
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp *__addr() { return std::addressof(__v); }
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp &   get() { return *__addr(); }
 
     template<class... _Args>
     _LIBCPP_NO_CFI
-    __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
-      _Traits::construct(__a, reinterpret_cast<_Tp*>(addressof(__v)),
-                         _VSTD::forward<_Args>(__args)...);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
+      _Traits::construct(__a, std::addressof(__v), std::forward<_Args>(__args)...);
     }
 
-    ~__temp_value() { _Traits::destroy(__a, __addr()); }
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 ~__temp_value() { _Traits::destroy(__a, __addr()); }
     };
 
 template<typename _Alloc, typename = void, typename = void>
 struct __is_allocator : false_type {};
 
 template<typename _Alloc>
 struct __is_allocator<_Alloc,
        typename __void_t<typename _Alloc::value_type>::type,

libcxx/include/vector

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Allocator /* = allocator<_Tp> */>
 class _LIBCPP_TEMPLATE_VIS vector
 {
 private:
     typedef allocator<_Tp>                                  __default_allocator_type;
 public:
     typedef vector                                          __self;
     typedef _Tp                                             value_type;
     typedef _Allocator                                      allocator_type;
     typedef allocator_traits<allocator_type>                __alloc_traits;
     typedef value_type&                                     reference;
     typedef const value_type&                               const_reference;
     typedef typename __alloc_traits::size_type              size_type;
     typedef typename __alloc_traits::difference_type        difference_type;
     typedef typename __alloc_traits::pointer                pointer;
     typedef typename __alloc_traits::const_pointer          const_pointer;
     typedef __wrap_iter<pointer>                            iterator;
     typedef __wrap_iter<const_pointer>                      const_iterator;
     typedef _VSTD::reverse_iterator<iterator>               reverse_iterator;
     typedef _VSTD::reverse_iterator<const_iterator>         const_reverse_iterator;
 
     static_assert((is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     {
         _VSTD::__debug_db_insert_c(this);
     }
-    _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
 #else
         _NOEXCEPT
 #endif
         : __end_cap_(nullptr, __a)
     {
         _VSTD::__debug_db_insert_c(this);
     }
-    explicit vector(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit vector(size_type __n);
 #if _LIBCPP_STD_VER > 11
-    explicit vector(size_type __n, const allocator_type& __a);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit vector(size_type __n, const allocator_type& __a);
 #endif
-    vector(size_type __n, const value_type& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(size_type __n, const value_type& __x);
 
     template <class = __enable_if_t<__is_allocator<_Allocator>::value> >
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     vector(size_type __n, const value_type& __x, const allocator_type& __a)
         : __end_cap_(nullptr, __a)
     {
       _VSTD::__debug_db_insert_c(this);
       if (__n > 0)
       {
           __vallocate(__n);
           __construct_at_end(__n, __x);
       }
     }
 
     template <class _InputIterator>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         vector(_InputIterator __first,
                typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
                                  !__is_cpp17_forward_iterator<_InputIterator>::value &&
                                  is_constructible<
                                     value_type,
                                     typename iterator_traits<_InputIterator>::reference>::value,
                                  _InputIterator>::type __last);
     template <class _InputIterator>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
                typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
                                  !__is_cpp17_forward_iterator<_InputIterator>::value &&
                                  is_constructible<
                                     value_type,
                                     typename iterator_traits<_InputIterator>::reference>::value>::type* = 0);
     template <class _ForwardIterator>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         vector(_ForwardIterator __first,
                typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
                                  is_constructible<
                                     value_type,
                                     typename iterator_traits<_ForwardIterator>::reference>::value,
                                  _ForwardIterator>::type __last);
     template <class _ForwardIterator>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
                typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
                                  is_constructible<
                                     value_type,
                                     typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     ~vector()
     {
       __annotate_delete();
       std::__debug_db_erase_c(this);
 
       if (this->__begin_ != nullptr)
       {
         __clear();
         __alloc_traits::deallocate(__alloc(), this->__begin_, capacity());
       }
     }
 
-    vector(const vector& __x);
-    vector(const vector& __x, const __type_identity_t<allocator_type>& __a);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(const vector& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(const vector& __x, const __type_identity_t<allocator_type>& __a);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     vector& operator=(const vector& __x);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     vector(initializer_list<value_type> __il);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     vector(initializer_list<value_type> __il, const allocator_type& __a);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     vector& operator=(initializer_list<value_type> __il)
         {assign(__il.begin(), __il.end()); return *this;}
 #endif // !_LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     vector(vector&& __x)
 #if _LIBCPP_STD_VER > 14
         noexcept;
 #else
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     vector(vector&& __x, const __type_identity_t<allocator_type>& __a);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     vector& operator=(vector&& __x)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
 
     template <class _InputIterator>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename enable_if
         <
              __is_cpp17_input_iterator  <_InputIterator>::value &&
             !__is_cpp17_forward_iterator<_InputIterator>::value &&
             is_constructible<
                  value_type,
                  typename iterator_traits<_InputIterator>::reference>::value,
             void
         >::type
         assign(_InputIterator __first, _InputIterator __last);
     template <class _ForwardIterator>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename enable_if
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value &&
             is_constructible<
                  value_type,
                  typename iterator_traits<_ForwardIterator>::reference>::value,
             void
         >::type
         assign(_ForwardIterator __first, _ForwardIterator __last);
 
-    void assign(size_type __n, const_reference __u);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void assign(size_type __n, const_reference __u);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void assign(initializer_list<value_type> __il)
         {assign(__il.begin(), __il.end());}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT
         {return this->__alloc();}
 
-    _LIBCPP_INLINE_VISIBILITY iterator               begin() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY const_iterator         begin()   const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY iterator               end() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY const_iterator         end()     const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY iterator               begin() _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_iterator         begin()   const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY iterator               end() _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_iterator         end()     const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     reverse_iterator       rbegin() _NOEXCEPT
         {return       reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator rbegin()  const _NOEXCEPT
         {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     reverse_iterator       rend() _NOEXCEPT
         {return       reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator rend()    const _NOEXCEPT
         {return const_reverse_iterator(begin());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     const_iterator         cbegin()  const _NOEXCEPT
         {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     const_iterator         cend()    const _NOEXCEPT
         {return end();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crbegin() const _NOEXCEPT
         {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend()   const _NOEXCEPT
         {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT
         {return static_cast<size_type>(this->__end_ - this->__begin_);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     size_type capacity() const _NOEXCEPT
         {return static_cast<size_type>(__end_cap() - this->__begin_);}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT
         {return this->__begin_ == this->__end_;}
-    size_type max_size() const _NOEXCEPT;
-    void reserve(size_type __n);
-    void shrink_to_fit() _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type max_size() const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reserve(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void shrink_to_fit() _NOEXCEPT;
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __n) _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 reference       at(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference at(size_type __n) const;
 
-    _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __n) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const _NOEXCEPT;
-    reference       at(size_type __n);
-    const_reference at(size_type __n) const;
-
-    _LIBCPP_INLINE_VISIBILITY reference       front() _NOEXCEPT
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY reference       front() _NOEXCEPT
     {
         _LIBCPP_ASSERT(!empty(), "front() called on an empty vector");
         return *this->__begin_;
     }
-    _LIBCPP_INLINE_VISIBILITY const_reference front() const _NOEXCEPT
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_reference front() const _NOEXCEPT
     {
         _LIBCPP_ASSERT(!empty(), "front() called on an empty vector");
         return *this->__begin_;
     }
-    _LIBCPP_INLINE_VISIBILITY reference       back() _NOEXCEPT
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY reference       back() _NOEXCEPT
     {
         _LIBCPP_ASSERT(!empty(), "back() called on an empty vector");
         return *(this->__end_ - 1);
     }
-    _LIBCPP_INLINE_VISIBILITY const_reference back()  const _NOEXCEPT
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const_reference back()  const _NOEXCEPT
     {
         _LIBCPP_ASSERT(!empty(), "back() called on an empty vector");
         return *(this->__end_ - 1);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     value_type*       data() _NOEXCEPT
         {return _VSTD::__to_address(this->__begin_);}
-    _LIBCPP_INLINE_VISIBILITY
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     const value_type* data() const _NOEXCEPT
         {return _VSTD::__to_address(this->__begin_);}
 
-    _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
 
-    _LIBCPP_INLINE_VISIBILITY void push_back(value_type&& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void push_back(value_type&& __x);
 
     template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
 #if _LIBCPP_STD_VER > 14
         reference emplace_back(_Args&&... __args);
 #else
         void      emplace_back(_Args&&... __args);
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void pop_back();
 
-    iterator insert(const_iterator __position, const_reference __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __position, const_reference __x);
 
-    iterator insert(const_iterator __position, value_type&& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __position, value_type&& __x);
     template <class... _Args>
-    iterator emplace(const_iterator __position, _Args&&... __args);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator emplace(const_iterator __position, _Args&&... __args);
 
-    iterator insert(const_iterator __position, size_type __n, const_reference __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __position, size_type __n, const_reference __x);
     template <class _InputIterator>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename enable_if
         <
              __is_cpp17_input_iterator  <_InputIterator>::value &&
             !__is_cpp17_forward_iterator<_InputIterator>::value &&
             is_constructible<
                  value_type,
                  typename iterator_traits<_InputIterator>::reference>::value,
             iterator
         >::type
         insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
     template <class _ForwardIterator>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename enable_if
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value &&
             is_constructible<
                  value_type,
                  typename iterator_traits<_ForwardIterator>::reference>::value,
             iterator
         >::type
         insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __position, initializer_list<value_type> __il)
         {return insert(__position, __il.begin(), __il.end());}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position);
-    iterator erase(const_iterator __first, const_iterator __last);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator erase(const_iterator __first, const_iterator __last);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT
     {
         size_type __old_size = size();
         __clear();
         __annotate_shrink(__old_size);
         std::__debug_db_invalidate_all(this);
     }
 
-    void resize(size_type __sz);
-    void resize(size_type __sz, const_reference __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void resize(size_type __sz);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void resize(size_type __sz, const_reference __x);
 
-    void swap(vector&)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(vector&)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT;
 #else
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                     __is_nothrow_swappable<allocator_type>::value);
 #endif
 
-    bool __invariants() const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __invariants() const;
 
 #if _LIBCPP_DEBUG_LEVEL == 2
 
     bool __dereferenceable(const const_iterator* __i) const;
     bool __decrementable(const const_iterator* __i) const;
     bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
     bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
 
 #endif // _LIBCPP_DEBUG_LEVEL == 2
 
 private:
     pointer __begin_ = nullptr;
     pointer __end_ = nullptr;
     __compressed_pair<pointer, allocator_type> __end_cap_ =
         __compressed_pair<pointer, allocator_type>(nullptr, __default_init_tag());
 
     _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(pointer __new_last);
 
-
     //  Allocate space for __n objects
     //  throws length_error if __n > max_size()
     //  throws (probably bad_alloc) if memory run out
     //  Precondition:  __begin_ == __end_ == __end_cap() == 0
     //  Precondition:  __n > 0
     //  Postcondition:  capacity() >= __n
     //  Postcondition:  size() == 0
-    _LIBCPP_HIDE_FROM_ABI void __vallocate(size_type __n) {
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI void __vallocate(size_type __n) {
         if (__n > max_size())
             __throw_length_error();
         auto __allocation = std::__allocate_at_least(__alloc(), __n);
         __begin_ = __allocation.ptr;
         __end_ = __allocation.ptr;
         __end_cap() = __begin_ + __allocation.count;
         __annotate_new(0);
     }
 
-    void __vdeallocate() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const;
-    void __construct_at_end(size_type __n);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __vdeallocate() _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_at_end(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __construct_at_end(size_type __n, const_reference __x);
     template <class _ForwardIterator>
+        _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename enable_if
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
             void
         >::type
         __construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n);
-    void __append(size_type __n);
-    void __append(size_type __n, const_reference __x);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __append(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __append(size_type __n, const_reference __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     iterator       __make_iter(pointer __p) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     const_iterator __make_iter(const_pointer __p) const _NOEXCEPT;
-    void __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v);
-    pointer __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p);
-    void __move_range(pointer __from_s, pointer __from_e, pointer __to);
-    void __move_assign(vector& __c, true_type)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 pointer __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __move_range(pointer __from_s, pointer __from_e, pointer __to);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __move_assign(vector& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
-    void __move_assign(vector& __c, false_type)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __move_assign(vector& __c, false_type)
         _NOEXCEPT_(__alloc_traits::is_always_equal::value);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __destruct_at_end(pointer __new_last) _NOEXCEPT
     {
+        if (!__libcpp_is_constant_evaluated())
             __invalidate_iterators_past(__new_last);
         size_type __old_size = size();
         __base_destruct_at_end(__new_last);
         __annotate_shrink(__old_size);
     }
 
     template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     inline void __push_back_slow_path(_Up&& __x);
 
     template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     inline void __emplace_back_slow_path(_Args&&... __args);
 
     // The following functions are no-ops outside of AddressSanitizer mode.
     // We call annotatations only for the default Allocator because other allocators
     // may not meet the AddressSanitizer alignment constraints.
     // See the documentation for __sanitizer_annotate_contiguous_container for more details.
 #ifndef _LIBCPP_HAS_NO_ASAN
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __annotate_contiguous_container(const void *__beg, const void *__end,
                                          const void *__old_mid,
                                          const void *__new_mid) const
     {
 
-      if (__beg && is_same<allocator_type, __default_allocator_type>::value)
+      if (!__libcpp_is_constant_evaluated() && __beg && is_same<allocator_type, __default_allocator_type>::value)
         __sanitizer_annotate_contiguous_container(__beg, __end, __old_mid, __new_mid);
     }
 #else
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __annotate_contiguous_container(const void*, const void*, const void*,
                                          const void*) const _NOEXCEPT {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __annotate_new(size_type __current_size) const _NOEXCEPT {
       __annotate_contiguous_container(data(), data() + capacity(),
                                       data() + capacity(), data() + __current_size);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __annotate_delete() const _NOEXCEPT {
       __annotate_contiguous_container(data(), data() + capacity(),
                                       data() + size(), data() + capacity());
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __annotate_increase(size_type __n) const _NOEXCEPT
     {
       __annotate_contiguous_container(data(), data() + capacity(),
                                       data() + size(), data() + size() + __n);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __annotate_shrink(size_type __old_size) const _NOEXCEPT
     {
       __annotate_contiguous_container(data(), data() + capacity(),
                                       data() + __old_size, data() + size());
     }
 
   struct _ConstructTransaction {
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     explicit _ConstructTransaction(vector &__v, size_type __n)
       : __v_(__v), __pos_(__v.__end_), __new_end_(__v.__end_ + __n) {
 #ifndef _LIBCPP_HAS_NO_ASAN
       __v_.__annotate_increase(__n);
 #endif
     }
-    ~_ConstructTransaction() {
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 ~_ConstructTransaction() {
       __v_.__end_ = __pos_;
 #ifndef _LIBCPP_HAS_NO_ASAN
       if (__pos_ != __new_end_) {
         __v_.__annotate_shrink(__new_end_ - __v_.__begin_);
       }
 #endif
     }
 
     vector &__v_;
     pointer __pos_;
     const_pointer const __new_end_;
 
   private:
     _ConstructTransaction(_ConstructTransaction const&) = delete;
     _ConstructTransaction& operator=(_ConstructTransaction const&) = delete;
   };
 
   template <class ..._Args>
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   void __construct_one_at_end(_Args&& ...__args) {
     _ConstructTransaction __tx(*this, 1);
     __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_),
         _VSTD::forward<_Args>(__args)...);
     ++__tx.__pos_;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   allocator_type& __alloc() _NOEXCEPT
       {return this->__end_cap_.second();}
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   const allocator_type& __alloc() const _NOEXCEPT
       {return this->__end_cap_.second();}
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   pointer& __end_cap() _NOEXCEPT
       {return this->__end_cap_.first();}
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   const pointer& __end_cap() const _NOEXCEPT
       {return this->__end_cap_.first();}
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   void __clear() _NOEXCEPT {__base_destruct_at_end(this->__begin_);}
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   void __base_destruct_at_end(pointer __new_last) _NOEXCEPT {
     pointer __soon_to_be_end = this->__end_;
     while (__new_last != __soon_to_be_end)
         __alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__soon_to_be_end));
     this->__end_ = __new_last;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   void __copy_assign_alloc(const vector& __c)
       {__copy_assign_alloc(__c, integral_constant<bool,
                     __alloc_traits::propagate_on_container_copy_assignment::value>());}
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   void __move_assign_alloc(vector& __c)
       _NOEXCEPT_(
           !__alloc_traits::propagate_on_container_move_assignment::value ||
           is_nothrow_move_assignable<allocator_type>::value)
       {__move_assign_alloc(__c, integral_constant<bool,
                     __alloc_traits::propagate_on_container_move_assignment::value>());}
 
   _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
   void __throw_length_error() const {
       _VSTD::__throw_length_error("vector");
   }
 
   _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
   void __throw_out_of_range() const {
       _VSTD::__throw_out_of_range("vector");
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   void __copy_assign_alloc(const vector& __c, true_type)
   {
     if (__alloc() != __c.__alloc())
     {
       __clear();
       __alloc_traits::deallocate(__alloc(), this->__begin_, capacity());
       this->__begin_ = this->__end_ = __end_cap() = nullptr;
     }
     __alloc() = __c.__alloc();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   void __copy_assign_alloc(const vector&, false_type)
   {}
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   void __move_assign_alloc(vector& __c, true_type)
       _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
   {
     __alloc() = _VSTD::move(__c.__alloc());
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   void __move_assign_alloc(vector&, false_type)
       _NOEXCEPT
   {}
 };
 
 #if _LIBCPP_STD_VER >= 17
 template<class _InputIterator,
          class _Alloc = allocator<__iter_value_type<_InputIterator>>,
          class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
          class = enable_if_t<__is_allocator<_Alloc>::value>
          >
 vector(_InputIterator, _InputIterator)
   -> vector<__iter_value_type<_InputIterator>, _Alloc>;
 
 template<class _InputIterator,
          class _Alloc,
          class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
          class = enable_if_t<__is_allocator<_Alloc>::value>
          >
 vector(_InputIterator, _InputIterator, _Alloc)
   -> vector<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v)
 {
 
     __annotate_delete();
     _VSTD::__construct_backward_with_exception_guarantees(this->__alloc(), this->__begin_, this->__end_, __v.__begin_);
     _VSTD::swap(this->__begin_, __v.__begin_);
     _VSTD::swap(this->__end_, __v.__end_);
     _VSTD::swap(this->__end_cap(), __v.__end_cap());
     __v.__first_ = __v.__begin_;
     __annotate_new(size());
     std::__debug_db_invalidate_all(this);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<_Tp, _Allocator>::pointer
 vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p)
 {
     __annotate_delete();
     pointer __r = __v.__begin_;
     _VSTD::__construct_backward_with_exception_guarantees(this->__alloc(), this->__begin_, __p, __v.__begin_);
     _VSTD::__construct_forward_with_exception_guarantees(this->__alloc(), __p, this->__end_, __v.__end_);
     _VSTD::swap(this->__begin_, __v.__begin_);
     _VSTD::swap(this->__end_, __v.__end_);
     _VSTD::swap(this->__end_cap(), __v.__end_cap());
     __v.__first_ = __v.__begin_;
     __annotate_new(size());
     std::__debug_db_invalidate_all(this);
     return __r;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__vdeallocate() _NOEXCEPT
 {
     if (this->__begin_ != nullptr)
     {
         clear();
         __alloc_traits::deallocate(this->__alloc(), this->__begin_, capacity());
         this->__begin_ = this->__end_ = this->__end_cap() = nullptr;
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<_Tp, _Allocator>::size_type
 vector<_Tp, _Allocator>::max_size() const _NOEXCEPT
 {
     return _VSTD::min<size_type>(__alloc_traits::max_size(this->__alloc()),
                                  numeric_limits<difference_type>::max());
 }
 
 //  Precondition:  __new_size > capacity()
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::size_type
 vector<_Tp, _Allocator>::__recommend(size_type __new_size) const
 {
     const size_type __ms = max_size();
     if (__new_size > __ms)
         this->__throw_length_error();
     const size_type __cap = capacity();
     if (__cap >= __ms / 2)
         return __ms;
     return _VSTD::max<size_type>(2 * __cap, __new_size);
 }
 
 //  Default constructs __n objects starting at __end_
 //  throws if construction throws
 //  Precondition:  __n > 0
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
 {
     _ConstructTransaction __tx(*this, __n);
     const_pointer __new_end = __tx.__new_end_;
     for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
         __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__pos));
     }
 }
 
 //  Copy constructs __n objects starting at __end_ from __x
 //  throws if construction throws
 //  Precondition:  __n > 0
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == old size() + __n
 //  Postcondition:  [i] == __x for all i in [size() - __n, __n)
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
 {
     _ConstructTransaction __tx(*this, __n);
     const_pointer __new_end = __tx.__new_end_;
     for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
         __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__pos), __x);
     }
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
     void
 >::type
 vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n)
 {
     _ConstructTransaction __tx(*this, __n);
     _VSTD::__construct_range_forward(this->__alloc(), __first, __last, __tx.__pos_);
 }
 
 //  Default constructs __n objects starting at __end_
 //  throws if construction throws
 //  Postcondition:  size() == size() + __n
 //  Exception safety: strong.
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__append(size_type __n)
 {
     if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
         this->__construct_at_end(__n);
     else
     {
         allocator_type& __a = this->__alloc();
         __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
         __v.__construct_at_end(__n);
         __swap_out_circular_buffer(__v);
     }
 }
 
 //  Default constructs __n objects starting at __end_
 //  throws if construction throws
 //  Postcondition:  size() == size() + __n
 //  Exception safety: strong.
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__append(size_type __n, const_reference __x)
 {
     if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
         this->__construct_at_end(__n, __x);
     else
     {
         allocator_type& __a = this->__alloc();
         __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
         __v.__construct_at_end(__n, __x);
         __swap_out_circular_buffer(__v);
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<_Tp, _Allocator>::vector(size_type __n)
 {
     _VSTD::__debug_db_insert_c(this);
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n);
     }
 }
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a)
     : __end_cap_(nullptr, __a)
 {
     _VSTD::__debug_db_insert_c(this);
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n);
     }
 }
 #endif
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<_Tp, _Allocator>::vector(size_type __n, const value_type& __x)
 {
     _VSTD::__debug_db_insert_c(this);
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, __x);
     }
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<_Tp, _Allocator>::vector(_InputIterator __first,
        typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
                          !__is_cpp17_forward_iterator<_InputIterator>::value &&
                          is_constructible<
                             value_type,
                             typename iterator_traits<_InputIterator>::reference>::value,
                           _InputIterator>::type __last)
 {
     _VSTD::__debug_db_insert_c(this);
     for (; __first != __last; ++__first)
         emplace_back(*__first);
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
        typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
                          !__is_cpp17_forward_iterator<_InputIterator>::value &&
                          is_constructible<
                             value_type,
                             typename iterator_traits<_InputIterator>::reference>::value>::type*)
     : __end_cap_(nullptr, __a)
 {
     _VSTD::__debug_db_insert_c(this);
     for (; __first != __last; ++__first)
         emplace_back(*__first);
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<_Tp, _Allocator>::vector(_ForwardIterator __first,
                                 typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
                                 is_constructible<
                                    value_type,
                                    typename iterator_traits<_ForwardIterator>::reference>::value,
                                                    _ForwardIterator>::type __last)
 {
     _VSTD::__debug_db_insert_c(this);
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__first, __last, __n);
     }
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
                                 typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
                                 is_constructible<
                                    value_type,
                                    typename iterator_traits<_ForwardIterator>::reference>::value>::type*)
     : __end_cap_(nullptr, __a)
 {
     _VSTD::__debug_db_insert_c(this);
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__first, __last, __n);
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<_Tp, _Allocator>::vector(const vector& __x)
     : __end_cap_(nullptr, __alloc_traits::select_on_container_copy_construction(__x.__alloc()))
 {
     _VSTD::__debug_db_insert_c(this);
     size_type __n = __x.size();
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__x.__begin_, __x.__end_, __n);
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<_Tp, _Allocator>::vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
     : __end_cap_(nullptr, __a)
 {
     _VSTD::__debug_db_insert_c(this);
     size_type __n = __x.size();
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__x.__begin_, __x.__end_, __n);
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>::vector(vector&& __x)
 #if _LIBCPP_STD_VER > 14
         noexcept
 #else
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
 #endif
     : __end_cap_(nullptr, _VSTD::move(__x.__alloc()))
 {
     _VSTD::__debug_db_insert_c(this);
     std::__debug_db_swap(this, std::addressof(__x));
     this->__begin_ = __x.__begin_;
     this->__end_ = __x.__end_;
     this->__end_cap() = __x.__end_cap();
     __x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>::vector(vector&& __x, const __type_identity_t<allocator_type>& __a)
     : __end_cap_(nullptr, __a)
 {
     _VSTD::__debug_db_insert_c(this);
     if (__a == __x.__alloc())
     {
         this->__begin_ = __x.__begin_;
         this->__end_ = __x.__end_;
         this->__end_cap() = __x.__end_cap();
         __x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
         std::__debug_db_swap(this, std::addressof(__x));
     }
     else
     {
         typedef move_iterator<iterator> _Ip;
         assign(_Ip(__x.begin()), _Ip(__x.end()));
     }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il)
 {
     _VSTD::__debug_db_insert_c(this);
     if (__il.size() > 0)
     {
         __vallocate(__il.size());
         __construct_at_end(__il.begin(), __il.end(), __il.size());
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
     : __end_cap_(nullptr, __a)
 {
     _VSTD::__debug_db_insert_c(this);
     if (__il.size() > 0)
     {
         __vallocate(__il.size());
         __construct_at_end(__il.begin(), __il.end(), __il.size());
     }
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>&
 vector<_Tp, _Allocator>::operator=(vector&& __x)
     _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
 {
     __move_assign(__x, integral_constant<bool,
           __alloc_traits::propagate_on_container_move_assignment::value>());
     return *this;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__move_assign(vector& __c, false_type)
     _NOEXCEPT_(__alloc_traits::is_always_equal::value)
 {
     if (__alloc() != __c.__alloc())
     {
         typedef move_iterator<iterator> _Ip;
         assign(_Ip(__c.begin()), _Ip(__c.end()));
     }
     else
         __move_assign(__c, true_type());
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__move_assign(vector& __c, true_type)
     _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
 {
     __vdeallocate();
     __move_assign_alloc(__c); // this can throw
     this->__begin_ = __c.__begin_;
     this->__end_ = __c.__end_;
     this->__end_cap() = __c.__end_cap();
     __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
     std::__debug_db_swap(this, std::addressof(__c));
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>&
 vector<_Tp, _Allocator>::operator=(const vector& __x)
 {
     if (this != _VSTD::addressof(__x))
     {
         __copy_assign_alloc(__x);
         assign(__x.__begin_, __x.__end_);
     }
     return *this;
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
      __is_cpp17_input_iterator  <_InputIterator>::value &&
     !__is_cpp17_forward_iterator<_InputIterator>::value &&
     is_constructible<
        _Tp,
        typename iterator_traits<_InputIterator>::reference>::value,
     void
 >::type
 vector<_Tp, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
     clear();
     for (; __first != __last; ++__first)
         emplace_back(*__first);
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value &&
     is_constructible<
        _Tp,
        typename iterator_traits<_ForwardIterator>::reference>::value,
     void
 >::type
else
         __vdeallocate();
         __vallocate(__recommend(__new_size));
         __construct_at_end(__first, __last, __new_size);
     }
     std::__debug_db_invalidate_all(this);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u)
 {
     if (__n <= capacity())
     {
         size_type __s = size();
         _VSTD::fill_n(this->__begin_, _VSTD::min(__n, __s), __u);
         if (__n > __s)
             __construct_at_end(__n - __s, __u);
         else
             this->__destruct_at_end(this->__begin_ + __n);
     }
     else
     {
         __vdeallocate();
         __vallocate(__recommend(static_cast<size_type>(__n)));
         __construct_at_end(__n, __u);
     }
     std::__debug_db_invalidate_all(this);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::__make_iter(pointer __p) _NOEXCEPT
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     return iterator(this, __p);
 #else
     return iterator(__p);
 #endif
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::const_iterator
 vector<_Tp, _Allocator>::__make_iter(const_pointer __p) const _NOEXCEPT
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     return const_iterator(this, __p);
 #else
     return const_iterator(__p);
 #endif
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::begin() _NOEXCEPT
 {
     return __make_iter(this->__begin_);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::const_iterator
 vector<_Tp, _Allocator>::begin() const _NOEXCEPT
 {
     return __make_iter(this->__begin_);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::end() _NOEXCEPT
 {
     return __make_iter(this->__end_);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::const_iterator
 vector<_Tp, _Allocator>::end() const _NOEXCEPT
 {
     return __make_iter(this->__end_);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::reference
 vector<_Tp, _Allocator>::operator[](size_type __n) _NOEXCEPT
 {
     _LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds");
     return this->__begin_[__n];
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::const_reference
 vector<_Tp, _Allocator>::operator[](size_type __n) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds");
     return this->__begin_[__n];
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<_Tp, _Allocator>::reference
 vector<_Tp, _Allocator>::at(size_type __n)
 {
     if (__n >= size())
         this->__throw_out_of_range();
     return this->__begin_[__n];
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<_Tp, _Allocator>::const_reference
 vector<_Tp, _Allocator>::at(size_type __n) const
 {
     if (__n >= size())
         this->__throw_out_of_range();
     return this->__begin_[__n];
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::reserve(size_type __n)
 {
     if (__n > capacity())
     {
         if (__n > max_size())
             this->__throw_length_error();
         allocator_type& __a = this->__alloc();
         __split_buffer<value_type, allocator_type&> __v(__n, size(), __a);
         __swap_out_circular_buffer(__v);
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
 {
     if (capacity() > size())
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
             allocator_type& __a = this->__alloc();
             __split_buffer<value_type, allocator_type&> __v(size(), size(), __a);
             __swap_out_circular_buffer(__v);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
         }
 #endif // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template <class _Tp, class _Allocator>
 template <class _Up>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x)
 {
     allocator_type& __a = this->__alloc();
     __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
     // __v.push_back(_VSTD::forward<_Up>(__x));
     __alloc_traits::construct(__a, _VSTD::__to_address(__v.__end_), _VSTD::forward<_Up>(__x));
     __v.__end_++;
     __swap_out_circular_buffer(__v);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::push_back(const_reference __x)
 {
     if (this->__end_ != this->__end_cap())
     {
         __construct_one_at_end(__x);
     }
     else
         __push_back_slow_path(__x);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::push_back(value_type&& __x)
 {
     if (this->__end_ < this->__end_cap())
     {
         __construct_one_at_end(_VSTD::move(__x));
     }
     else
         __push_back_slow_path(_VSTD::move(__x));
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args)
 {
     allocator_type& __a = this->__alloc();
     __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
 //    __v.emplace_back(_VSTD::forward<_Args>(__args)...);
     __alloc_traits::construct(__a, _VSTD::__to_address(__v.__end_), _VSTD::forward<_Args>(__args)...);
     __v.__end_++;
     __swap_out_circular_buffer(__v);
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline
 #if _LIBCPP_STD_VER > 14
 typename vector<_Tp, _Allocator>::reference
 #else
 void
 #endif
 vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
 {
     if (this->__end_ < this->__end_cap())
     {
         __construct_one_at_end(_VSTD::forward<_Args>(__args)...);
     }
     else
         __emplace_back_slow_path(_VSTD::forward<_Args>(__args)...);
 #if _LIBCPP_STD_VER > 14
     return this->back();
 #endif
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline
 void
 vector<_Tp, _Allocator>::pop_back()
 {
     _LIBCPP_ASSERT(!empty(), "vector::pop_back called on an empty vector");
     this->__destruct_at_end(this->__end_ - 1);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::erase(const_iterator __position)
 {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
                          "vector::erase(iterator) called with an iterator not referring to this vector");
     _LIBCPP_ASSERT(__position != end(),
         "vector::erase(iterator) called with a non-dereferenceable iterator");
     difference_type __ps = __position - cbegin();
     pointer __p = this->__begin_ + __ps;
     this->__destruct_at_end(_VSTD::move(__p + 1, this->__end_, __p));
-    this->__invalidate_iterators_past(__p-1);
+    if (!__libcpp_is_constant_evaluated())
+        this->__invalidate_iterators_past(__p - 1);
     iterator __r = __make_iter(__p);
     return __r;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::erase(const_iterator __first, const_iterator __last)
 {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__first)) == this,
                          "vector::erase(iterator, iterator) called with an iterator not referring to this vector");
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__last)) == this,
                          "vector::erase(iterator, iterator) called with an iterator not referring to this vector");
 
     _LIBCPP_ASSERT(__first <= __last, "vector::erase(first, last) called with invalid range");
     pointer __p = this->__begin_ + (__first - begin());
     if (__first != __last) {
         this->__destruct_at_end(_VSTD::move(__p + (__last - __first), this->__end_, __p));
+        if (!__libcpp_is_constant_evaluated())
             this->__invalidate_iterators_past(__p - 1);
     }
     iterator __r = __make_iter(__p);
     return __r;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointer __to)
 {
     pointer __old_last = this->__end_;
     difference_type __n = __old_last - __to;
     {
       pointer __i = __from_s + __n;
       _ConstructTransaction __tx(*this, __from_e - __i);
       for (pointer __pos = __tx.__pos_; __i < __from_e;
            ++__i, (void) ++__pos, __tx.__pos_ = __pos) {
           __alloc_traits::construct(this->__alloc(),
                                     _VSTD::__to_address(__pos),
                                     _VSTD::move(*__i));
       }
     }
     _VSTD::move_backward(__from_s, __from_s + __n, __old_last);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)
 {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
                          "vector::insert(iterator, x) called with an iterator not referring to this vector");
     pointer __p = this->__begin_ + (__position - begin());
-    if (this->__end_ < this->__end_cap())
+    if (!__libcpp_is_constant_evaluated() && this->__end_ < this->__end_cap())
     {
         if (__p == this->__end_)
         {
             __construct_one_at_end(__x);
         }
         else
         {
             __move_range(__p, this->__end_, __p + 1);
else
         __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
         __v.push_back(__x);
         __p = __swap_out_circular_buffer(__v, __p);
     }
     return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x)
 {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
                          "vector::insert(iterator, x) called with an iterator not referring to this vector");
     pointer __p = this->__begin_ + (__position - begin());
     if (this->__end_ < this->__end_cap())
     {
else
         __v.push_back(_VSTD::move(__x));
         __p = __swap_out_circular_buffer(__v, __p);
     }
     return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args)
 {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
                          "vector::emplace(iterator, x) called with an iterator not referring to this vector");
     pointer __p = this->__begin_ + (__position - begin());
     if (this->__end_ < this->__end_cap())
     {
else
         __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
         __v.emplace_back(_VSTD::forward<_Args>(__args)...);
         __p = __swap_out_circular_buffer(__v, __p);
     }
     return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_reference __x)
 {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__position)) == this,
                          "vector::insert(iterator, n, x) called with an iterator not referring to this vector");
     pointer __p = this->__begin_ + (__position - begin());
     if (__n > 0)
     {
-        if (__n <= static_cast<size_type>(this->__end_cap() - this->__end_))
+        if (!__libcpp_is_constant_evaluated() && __n <= static_cast<size_type>(this->__end_cap() - this->__end_))
         {
             size_type __old_n = __n;
             pointer __old_last = this->__end_;
             if (__n > static_cast<size_type>(this->__end_ - __p))
             {
                 size_type __cx = __n - (this->__end_ - __p);
                 __construct_at_end(__cx, __x);
                 __n -= __cx;
if (__n > 0)
             __p = __swap_out_circular_buffer(__v, __p);
         }
     }
     return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
      __is_cpp17_input_iterator  <_InputIterator>::value &&
     !__is_cpp17_forward_iterator<_InputIterator>::value &&
     is_constructible<
        _Tp,
        typename iterator_traits<_InputIterator>::reference>::value,
     typename vector<_Tp, _Allocator>::iterator
#endif // _LIBCPP_NO_EXCEPTIONS
     __p = _VSTD::rotate(__p, __old_last, this->__end_);
     insert(__make_iter(__p), _VSTD::make_move_iterator(__v.begin()),
                              _VSTD::make_move_iterator(__v.end()));
     return begin() + __off;
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value &&
     is_constructible<
        _Tp,
        typename iterator_traits<_ForwardIterator>::reference>::value,
     typename vector<_Tp, _Allocator>::iterator
 >::type
if (__n > 0)
             __v.__construct_at_end(__first, __last);
             __p = __swap_out_circular_buffer(__v, __p);
         }
     }
     return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::resize(size_type __sz)
 {
     size_type __cs = size();
     if (__cs < __sz)
         this->__append(__sz - __cs);
     else if (__cs > __sz)
         this->__destruct_at_end(this->__begin_ + __sz);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x)
 {
     size_type __cs = size();
     if (__cs < __sz)
         this->__append(__sz - __cs, __x);
     else if (__cs > __sz)
         this->__destruct_at_end(this->__begin_ + __sz);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::swap(vector& __x)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                 __is_nothrow_swappable<allocator_type>::value)
 #endif
 {
     _LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value ||
                    this->__alloc() == __x.__alloc(),
                    "vector::swap: Either propagate_on_container_swap must be true"
                    " or the allocators must compare equal");
     _VSTD::swap(this->__begin_, __x.__begin_);
     _VSTD::swap(this->__end_, __x.__end_);
     _VSTD::swap(this->__end_cap(), __x.__end_cap());
     _VSTD::__swap_allocator(this->__alloc(), __x.__alloc(),
         integral_constant<bool,__alloc_traits::propagate_on_container_swap::value>());
     std::__debug_db_swap(this, std::addressof(__x));
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 vector<_Tp, _Allocator>::__invariants() const
 {
     if (this->__begin_ == nullptr)
     {
         if (this->__end_ != nullptr || this->__end_cap() != nullptr)
             return false;
     }

 public:
     typedef __bit_reference<vector>                  reference;
 #ifdef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
     using const_reference = bool;
 #else
     typedef __bit_const_reference<vector>            const_reference;
 #endif
 private:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type& __cap() _NOEXCEPT
         {return __cap_alloc_.first();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const size_type& __cap() const _NOEXCEPT
         {return __cap_alloc_.first();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     __storage_allocator& __alloc() _NOEXCEPT
         {return __cap_alloc_.second();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const __storage_allocator& __alloc() const _NOEXCEPT
         {return __cap_alloc_.second();}
 
     static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static size_type __internal_cap_to_external(size_type __n) _NOEXCEPT
         {return __n * __bits_per_word;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static size_type __external_cap_to_internal(size_type __n) _NOEXCEPT
         {return (__n - 1) / __bits_per_word + 1;}
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
 
-    _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit vector(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
 #else
         _NOEXCEPT;
 #endif
-    ~vector();
-    explicit vector(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 ~vector();
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit vector(size_type __n);
 #if _LIBCPP_STD_VER > 11
-    explicit vector(size_type __n, const allocator_type& __a);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit vector(size_type __n, const allocator_type& __a);
 #endif
-    vector(size_type __n, const value_type& __v);
-    vector(size_type __n, const value_type& __v, const allocator_type& __a);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(size_type __n, const value_type& __v);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(size_type __n, const value_type& __v, const allocator_type& __a);
     template <class _InputIterator>
-        vector(_InputIterator __first, _InputIterator __last,
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(_InputIterator __first, _InputIterator __last,
                typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
                                  !__is_cpp17_forward_iterator<_InputIterator>::value>::type* = 0);
     template <class _InputIterator>
-        vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
                typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
                                  !__is_cpp17_forward_iterator<_InputIterator>::value>::type* = 0);
     template <class _ForwardIterator>
-        vector(_ForwardIterator __first, _ForwardIterator __last,
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(_ForwardIterator __first, _ForwardIterator __last,
                typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0);
     template <class _ForwardIterator>
-        vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
                typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0);
 
-    vector(const vector& __v);
-    vector(const vector& __v, const allocator_type& __a);
-    vector& operator=(const vector& __v);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(const vector& __v);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(const vector& __v, const allocator_type& __a);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector& operator=(const vector& __v);
 
 #ifndef _LIBCPP_CXX03_LANG
-    vector(initializer_list<value_type> __il);
-    vector(initializer_list<value_type> __il, const allocator_type& __a);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(initializer_list<value_type> __il);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(initializer_list<value_type> __il, const allocator_type& __a);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     vector& operator=(initializer_list<value_type> __il)
         {assign(__il.begin(), __il.end()); return *this;}
 
 #endif // !_LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     vector(vector&& __v)
 #if _LIBCPP_STD_VER > 14
         noexcept;
 #else
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
 #endif
-    vector(vector&& __v, const __type_identity_t<allocator_type>& __a);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(vector&& __v, const __type_identity_t<allocator_type>& __a);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     vector& operator=(vector&& __v)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
 
     template <class _InputIterator>
         typename enable_if
         <
             __is_cpp17_input_iterator<_InputIterator>::value &&
            !__is_cpp17_forward_iterator<_InputIterator>::value,
            void
         >::type
-        assign(_InputIterator __first, _InputIterator __last);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 assign(_InputIterator __first, _InputIterator __last);
     template <class _ForwardIterator>
         typename enable_if
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
            void
         >::type
-        assign(_ForwardIterator __first, _ForwardIterator __last);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 assign(_ForwardIterator __first, _ForwardIterator __last);
 
-    void assign(size_type __n, const value_type& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void assign(size_type __n, const value_type& __x);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void assign(initializer_list<value_type> __il)
         {assign(__il.begin(), __il.end());}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY allocator_type get_allocator() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(this->__alloc());}
 
-    size_type max_size() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type max_size() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type capacity() const _NOEXCEPT
         {return __internal_cap_to_external(__cap());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type size() const _NOEXCEPT
         {return __size_;}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     bool empty() const _NOEXCEPT
         {return __size_ == 0;}
-    void reserve(size_type __n);
-    void shrink_to_fit() _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reserve(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void shrink_to_fit() _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     iterator begin() _NOEXCEPT
         {return __make_iter(0);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator begin() const _NOEXCEPT
         {return __make_iter(0);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     iterator end() _NOEXCEPT
         {return __make_iter(__size_);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator end()   const _NOEXCEPT
         {return __make_iter(__size_);}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     reverse_iterator rbegin() _NOEXCEPT
         {return       reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator rbegin() const _NOEXCEPT
         {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     reverse_iterator rend() _NOEXCEPT
         {return       reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator rend()   const _NOEXCEPT
         {return const_reverse_iterator(begin());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator         cbegin()  const _NOEXCEPT
         {return __make_iter(0);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator         cend()    const _NOEXCEPT
         {return __make_iter(__size_);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator crbegin() const _NOEXCEPT
         {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator crend()   const _NOEXCEPT
         {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __n)       {return __make_ref(__n);}
-    _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const {return __make_ref(__n);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference       operator[](size_type __n)       {return __make_ref(__n);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference operator[](size_type __n) const {return __make_ref(__n);}
     reference       at(size_type __n);
     const_reference at(size_type __n) const;
 
-    _LIBCPP_INLINE_VISIBILITY reference       front()       {return __make_ref(0);}
-    _LIBCPP_INLINE_VISIBILITY const_reference front() const {return __make_ref(0);}
-    _LIBCPP_INLINE_VISIBILITY reference       back()        {return __make_ref(__size_ - 1);}
-    _LIBCPP_INLINE_VISIBILITY const_reference back()  const {return __make_ref(__size_ - 1);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference       front()       {return __make_ref(0);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference front() const {return __make_ref(0);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference       back()        {return __make_ref(__size_ - 1);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference back()  const {return __make_ref(__size_ - 1);}
 
-    void push_back(const value_type& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void push_back(const value_type& __x);
 #if _LIBCPP_STD_VER > 11
     template <class... _Args>
 #if _LIBCPP_STD_VER > 14
-    _LIBCPP_INLINE_VISIBILITY reference emplace_back(_Args&&... __args)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference emplace_back(_Args&&... __args)
 #else
     _LIBCPP_INLINE_VISIBILITY void      emplace_back(_Args&&... __args)
 #endif
     {
         push_back ( value_type ( _VSTD::forward<_Args>(__args)... ));
 #if _LIBCPP_STD_VER > 14
         return this->back();
 #endif
     }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY void pop_back() {--__size_;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void pop_back() {--__size_;}
 
 #if _LIBCPP_STD_VER > 11
     template <class... _Args>
-   _LIBCPP_INLINE_VISIBILITY iterator emplace(const_iterator position, _Args&&... __args)
+   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator emplace(const_iterator position, _Args&&... __args)
         { return insert ( position, value_type ( _VSTD::forward<_Args>(__args)... )); }
 #endif
 
-    iterator insert(const_iterator __position, const value_type& __x);
-    iterator insert(const_iterator __position, size_type __n, const value_type& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __position, const value_type& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator insert(const_iterator __position, size_type __n, const value_type& __x);
     template <class _InputIterator>
         typename enable_if
         <
              __is_cpp17_input_iterator  <_InputIterator>::value &&
             !__is_cpp17_forward_iterator<_InputIterator>::value,
             iterator
         >::type
-        insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
+        _LIBCPP_CONSTEXPR_AFTER_CXX17 insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
     template <class _ForwardIterator>
         typename enable_if
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
             iterator
         >::type
-        insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
+        _LIBCPP_CONSTEXPR_AFTER_CXX17 insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     iterator insert(const_iterator __position, initializer_list<value_type> __il)
         {return insert(__position, __il.begin(), __il.end());}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position);
-    iterator erase(const_iterator __first, const_iterator __last);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator erase(const_iterator __position);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator erase(const_iterator __first, const_iterator __last);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void clear() _NOEXCEPT {__size_ = 0;}
 
-    void swap(vector&)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(vector&)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT;
 #else
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                     __is_nothrow_swappable<allocator_type>::value);
 #endif
-    static void swap(reference __x, reference __y) _NOEXCEPT { _VSTD::swap(__x, __y); }
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 static void swap(reference __x, reference __y) _NOEXCEPT { _VSTD::swap(__x, __y); }
 
-    void resize(size_type __sz, value_type __x = false);
-    void flip() _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void resize(size_type __sz, value_type __x = false);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void flip() _NOEXCEPT;
 
-    bool __invariants() const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __invariants() const;
 
 private:
     _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
     void __throw_length_error() const {
         _VSTD::__throw_length_error("vector");
     }
 
     _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
     void __throw_out_of_range() const {
         _VSTD::__throw_out_of_range("vector");
     }
 
     //  Allocate space for __n objects
     //  throws length_error if __n > max_size()
     //  throws (probably bad_alloc) if memory run out
     //  Precondition:  __begin_ == __end_ == __cap() == 0
     //  Precondition:  __n > 0
     //  Postcondition:  capacity() >= __n
     //  Postcondition:  size() == 0
-    _LIBCPP_HIDE_FROM_ABI void __vallocate(size_type __n) {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void __vallocate(size_type __n) {
         if (__n > max_size())
             __throw_length_error();
         auto __allocation = std::__allocate_at_least(__alloc(), __external_cap_to_internal(__n));
         __begin_ = __allocation.ptr;
         __size_ = 0;
         __cap() = __allocation.count;
+        if (__libcpp_is_constant_evaluated()) {
+            for (size_type __i = 0; __i != __cap(); ++__i)
+                std::__construct_at(std::__to_address(__begin_) + __i);
+        }
     }
 
-    void __vdeallocate() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __vdeallocate() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static size_type __align_it(size_type __new_size) _NOEXCEPT
         {return (__new_size + (__bits_per_word-1)) & ~((size_type)__bits_per_word-1);}
-    _LIBCPP_INLINE_VISIBILITY  size_type __recommend(size_type __new_size) const;
-    _LIBCPP_INLINE_VISIBILITY void __construct_at_end(size_type __n, bool __x);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17  size_type __recommend(size_type __new_size) const;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_at_end(size_type __n, bool __x);
     template <class _ForwardIterator>
         typename enable_if
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
             void
         >::type
-        __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
-    void __append(size_type __n, const_reference __x);
-    _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_CONSTEXPR_AFTER_CXX17 __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __append(size_type __n, const_reference __x);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     reference __make_ref(size_type __pos) _NOEXCEPT
         {return reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reference __make_ref(size_type __pos) const _NOEXCEPT {
         return __bit_const_reference<vector>(__begin_ + __pos / __bits_per_word,
                                              __storage_type(1) << __pos % __bits_per_word);
     }
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     iterator __make_iter(size_type __pos) _NOEXCEPT
         {return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator __make_iter(size_type __pos) const _NOEXCEPT
         {return const_iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     iterator __const_iterator_cast(const_iterator __p) _NOEXCEPT
         {return begin() + (__p - cbegin());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __copy_assign_alloc(const vector& __v)
         {__copy_assign_alloc(__v, integral_constant<bool,
                       __storage_traits::propagate_on_container_copy_assignment::value>());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __copy_assign_alloc(const vector& __c, true_type)
         {
             if (__alloc() != __c.__alloc())
                 __vdeallocate();
             __alloc() = __c.__alloc();
         }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __copy_assign_alloc(const vector&, false_type)
         {}
 
-    void __move_assign(vector& __c, false_type);
-    void __move_assign(vector& __c, true_type)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __move_assign(vector& __c, false_type);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __move_assign(vector& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __move_assign_alloc(vector& __c)
         _NOEXCEPT_(
             !__storage_traits::propagate_on_container_move_assignment::value ||
             is_nothrow_move_assignable<allocator_type>::value)
         {__move_assign_alloc(__c, integral_constant<bool,
                       __storage_traits::propagate_on_container_move_assignment::value>());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __move_assign_alloc(vector& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
             __alloc() = _VSTD::move(__c.__alloc());
         }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __move_assign_alloc(vector&, false_type)
         _NOEXCEPT
         {}
 
-    size_t __hash_code() const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 size_t __hash_code() const _NOEXCEPT;
 
     friend class __bit_reference<vector>;
     friend class __bit_const_reference<vector>;
     friend class __bit_iterator<vector, false>;
     friend class __bit_iterator<vector, true>;
     friend struct __bit_array<vector>;
     friend struct _LIBCPP_TEMPLATE_VIS hash<vector>;
 };
 
 template <class _Allocator>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 void
 vector<bool, _Allocator>::__vdeallocate() _NOEXCEPT
 {
     if (this->__begin_ != nullptr)
     {
         __storage_traits::deallocate(this->__alloc(), this->__begin_, __cap());
         std::__debug_db_invalidate_all(this);
         this->__begin_ = nullptr;
         this->__size_ = this->__cap() = 0;
     }
 }
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<bool, _Allocator>::size_type
 vector<bool, _Allocator>::max_size() const _NOEXCEPT
 {
     size_type __amax = __storage_traits::max_size(__alloc());
     size_type __nmax = numeric_limits<size_type>::max() / 2;  // end() >= begin(), always
     if (__nmax / __bits_per_word <= __amax)
         return __nmax;
     return __internal_cap_to_external(__amax);
 }
 
 //  Precondition:  __new_size > capacity()
 template <class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<bool, _Allocator>::size_type
 vector<bool, _Allocator>::__recommend(size_type __new_size) const
 {
     const size_type __ms = max_size();
     if (__new_size > __ms)
         this->__throw_length_error();
     const size_type __cap = capacity();
     if (__cap >= __ms / 2)
         return __ms;
     return _VSTD::max(2 * __cap, __align_it(__new_size));
 }
 
 //  Default constructs __n objects starting at __end_
 //  Precondition:  __n > 0
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x)
 {
     size_type __old_size = this->__size_;
     this->__size_ += __n;
     if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word))
     {
         if (this->__size_ <= __bits_per_word)
             this->__begin_[0] = __storage_type(0);
         else
             this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0);
     }
     _VSTD::fill_n(__make_iter(__old_size), __n, __x);
 }
 
 template <class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
     void
 >::type
 vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __old_size = this->__size_;
     this->__size_ += _VSTD::distance(__first, __last);
     if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word))
     {
         if (this->__size_ <= __bits_per_word)
             this->__begin_[0] = __storage_type(0);
         else
             this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0);
     }
     _VSTD::copy(__first, __last, __make_iter(__old_size));
 }
 
 template <class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, __default_init_tag())
 {
 }
 
 template <class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
 #else
         _NOEXCEPT
 #endif
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 {
 }
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(size_type __n)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, __default_init_tag())
 {
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, false);
     }
 }
 
 #if _LIBCPP_STD_VER > 11
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 {
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, false);
     }
 }
 #endif
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(size_type __n, const value_type& __x)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, __default_init_tag())
 {
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, __x);
     }
 }
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const allocator_type& __a)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 {
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, __x);
     }
 }
 
 template <class _Allocator>
 template <class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
        typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
                          !__is_cpp17_forward_iterator<_InputIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, __default_init_tag())
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
catch (...)
         std::__debug_db_invalidate_all(this);
         throw;
     }
 #endif // _LIBCPP_NO_EXCEPTIONS
 }
 
 template <class _Allocator>
 template <class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
        typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
                          !__is_cpp17_forward_iterator<_InputIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
catch (...)
         std::__debug_db_invalidate_all(this);
         throw;
     }
 #endif // _LIBCPP_NO_EXCEPTIONS
 }
 
 template <class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last,
                                 typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, __default_init_tag())
 {
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__first, __last);
     }
 }
 
 template <class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
                                 typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 {
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__first, __last);
     }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(initializer_list<value_type> __il)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, __default_init_tag())
 {
     size_type __n = static_cast<size_type>(__il.size());
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__il.begin(), __il.end());
     }
 }
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 {
     size_type __n = static_cast<size_type>(__il.size());
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__il.begin(), __il.end());
     }
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::~vector()
 {
     if (__begin_ != nullptr)
         __storage_traits::deallocate(__alloc(), __begin_, __cap());
     std::__debug_db_invalidate_all(this);
 }
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(const vector& __v)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, __storage_traits::select_on_container_copy_construction(__v.__alloc()))
 {
     if (__v.size() > 0)
     {
         __vallocate(__v.size());
         __construct_at_end(__v.begin(), __v.end());
     }
 }
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(const vector& __v, const allocator_type& __a)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, __a)
 {
     if (__v.size() > 0)
     {
         __vallocate(__v.size());
         __construct_at_end(__v.begin(), __v.end());
     }
 }
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>&
 vector<bool, _Allocator>::operator=(const vector& __v)
 {
     if (this != _VSTD::addressof(__v))
     {
         __copy_assign_alloc(__v);
         if (__v.__size_)
         {
             if (__v.__size_ > capacity())
             {
                 __vdeallocate();
                 __vallocate(__v.__size_);
             }
             _VSTD::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_);
         }
         __size_ = __v.__size_;
     }
     return *this;
 }
 
 template <class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY vector<bool, _Allocator>::vector(vector&& __v)
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 vector<bool, _Allocator>::vector(vector&& __v)
 #if _LIBCPP_STD_VER > 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
 #endif
     : __begin_(__v.__begin_),
       __size_(__v.__size_),
       __cap_alloc_(_VSTD::move(__v.__cap_alloc_)) {
     __v.__begin_ = nullptr;
     __v.__size_ = 0;
     __v.__cap() = 0;
 }
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>::vector(vector&& __v, const __type_identity_t<allocator_type>& __a)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, __a)
 {
     if (__a == allocator_type(__v.__alloc()))
     {
         this->__begin_ = __v.__begin_;
         this->__size_ = __v.__size_;
         this->__cap() = __v.__cap();
         __v.__begin_ = nullptr;
         __v.__cap() = __v.__size_ = 0;
     }
     else if (__v.size() > 0)
     {
         __vallocate(__v.size());
         __construct_at_end(__v.begin(), __v.end());
     }
 }
 
 template <class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<bool, _Allocator>&
 vector<bool, _Allocator>::operator=(vector&& __v)
     _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
 {
     __move_assign(__v, integral_constant<bool,
           __storage_traits::propagate_on_container_move_assignment::value>());
     return *this;
 }
 
 template <class _Allocator>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 void
 vector<bool, _Allocator>::__move_assign(vector& __c, false_type)
 {
     if (__alloc() != __c.__alloc())
         assign(__c.begin(), __c.end());
     else
         __move_assign(__c, true_type());
 }
 
 template <class _Allocator>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 void
 vector<bool, _Allocator>::__move_assign(vector& __c, true_type)
     _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
 {
     __vdeallocate();
     __move_assign_alloc(__c);
     this->__begin_ = __c.__begin_;
     this->__size_ = __c.__size_;
     this->__cap() = __c.__cap();
     __c.__begin_ = nullptr;
     __c.__cap() = __c.__size_ = 0;
 }
 
 template <class _Allocator>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 void
 vector<bool, _Allocator>::assign(size_type __n, const value_type& __x)
 {
     __size_ = 0;
     if (__n > 0)
     {
         size_type __c = capacity();
         if (__n <= __c)
             __size_ = __n;
         else
         {
             vector __v(get_allocator());
             __v.reserve(__recommend(__n));
             __v.__size_ = __n;
             swap(__v);
         }
         _VSTD::fill_n(begin(), __n, __x);
     }
     std::__debug_db_invalidate_all(this);
 }
 
 template <class _Allocator>
 template <class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_cpp17_input_iterator<_InputIterator>::value &&
    !__is_cpp17_forward_iterator<_InputIterator>::value,
    void
 >::type
 vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
     clear();
     for (; __first != __last; ++__first)
         push_back(*__first);
 }
 
 template <class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
    void
 >::type
 vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
     clear();
     difference_type __ns = _VSTD::distance(__first, __last);
     _LIBCPP_ASSERT(__ns >= 0, "invalid range specified");
     const size_t __n = static_cast<size_type>(__ns);
     if (__n)
     {
         if (__n > capacity())
         {
             __vdeallocate();
             __vallocate(__n);
         }
         __construct_at_end(__first, __last);
     }
 }
 
 template <class _Allocator>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 void
 vector<bool, _Allocator>::reserve(size_type __n)
 {
     if (__n > capacity())
     {
         if (__n > max_size())
             this->__throw_length_error();
         vector __v(this->get_allocator());
         __v.__vallocate(__n);
         __v.__construct_at_end(this->begin(), this->end());
         swap(__v);
         std::__debug_db_invalidate_all(this);
     }
 }
 
 template <class _Allocator>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 void
 vector<bool, _Allocator>::shrink_to_fit() _NOEXCEPT
 {
     if (__external_cap_to_internal(size()) > __cap())
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS

 vector<bool, _Allocator>::at(size_type __n) const
 {
     if (__n >= size())
         this->__throw_out_of_range();
     return (*this)[__n];
 }
 
 template <class _Allocator>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 void
 vector<bool, _Allocator>::push_back(const value_type& __x)
 {
     if (this->__size_ == this->capacity())
         reserve(__recommend(this->__size_ + 1));
     ++this->__size_;
     back() = __x;
 }
 
 template <class _Allocator>
-typename vector<bool, _Allocator>::iterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 typename vector<bool, _Allocator>::iterator
 vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __x)
 {
     iterator __r;
     if (size() < capacity())
     {
         const_iterator __old_end = end();
         ++__size_;
         _VSTD::copy_backward(__position, __old_end, end());
         __r = __const_iterator_cast(__position);
     }
     else
     {
         vector __v(get_allocator());
         __v.reserve(__recommend(__size_ + 1));
         __v.__size_ = __size_ + 1;
         __r = _VSTD::copy(cbegin(), __position, __v.begin());
         _VSTD::copy_backward(__position, cend(), __v.end());
         swap(__v);
     }
     *__r = __x;
     return __r;
 }
 
 template <class _Allocator>
-typename vector<bool, _Allocator>::iterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 typename vector<bool, _Allocator>::iterator
 vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const value_type& __x)
 {
     iterator __r;
     size_type __c = capacity();
     if (__n <= __c && size() <= __c - __n)
     {
         const_iterator __old_end = end();
         __size_ += __n;
else
         swap(__v);
     }
     _VSTD::fill_n(__r, __n, __x);
     return __r;
 }
 
 template <class _Allocator>
 template <class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
      __is_cpp17_input_iterator  <_InputIterator>::value &&
     !__is_cpp17_forward_iterator<_InputIterator>::value,
     typename vector<bool, _Allocator>::iterator
 >::type
 vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
 {
#endif // _LIBCPP_NO_EXCEPTIONS
     }
     __p = _VSTD::rotate(__p, __old_end, end());
     insert(__p, __v.begin(), __v.end());
     return begin() + __off;
 }
 
 template <class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
     typename vector<bool, _Allocator>::iterator
 >::type
 vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
 {
     const difference_type __n_signed = _VSTD::distance(__first, __last);
else
         _VSTD::copy_backward(__position, cend(), __v.end());
         swap(__v);
     }
     _VSTD::copy(__first, __last, __r);
     return __r;
 }
 
 template <class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<bool, _Allocator>::iterator
 vector<bool, _Allocator>::erase(const_iterator __position)
 {
     iterator __r = __const_iterator_cast(__position);
     _VSTD::copy(__position + 1, this->cend(), __r);
     --__size_;
     return __r;
 }
 
 template <class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<bool, _Allocator>::iterator
 vector<bool, _Allocator>::erase(const_iterator __first, const_iterator __last)
 {
     iterator __r = __const_iterator_cast(__first);
     difference_type __d = __last - __first;
     _VSTD::copy(__last, this->cend(), __r);
     __size_ -= __d;
     return __r;
 }
 
 template <class _Allocator>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 void
 vector<bool, _Allocator>::swap(vector& __x)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                 __is_nothrow_swappable<allocator_type>::value)
 #endif
 {
     _VSTD::swap(this->__begin_, __x.__begin_);
     _VSTD::swap(this->__size_, __x.__size_);
     _VSTD::swap(this->__cap(), __x.__cap());
     _VSTD::__swap_allocator(this->__alloc(), __x.__alloc(),
         integral_constant<bool, __alloc_traits::propagate_on_container_swap::value>());
 }
 
 template <class _Allocator>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 void
 vector<bool, _Allocator>::resize(size_type __sz, value_type __x)
 {
     size_type __cs = size();
     if (__cs < __sz)
     {
         iterator __r;
         size_type __c = capacity();
         size_type __n = __sz - __cs;
if (__cs < __sz)
         }
         _VSTD::fill_n(__r, __n, __x);
     }
     else
         __size_ = __sz;
 }
 
 template <class _Allocator>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 void
 vector<bool, _Allocator>::flip() _NOEXCEPT
 {
     // do middle whole words
     size_type __n = __size_;
     __storage_pointer __p = __begin_;
     for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
         *__p = ~*__p;
     // do last partial word
     if (__n > 0)
     {
         __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
         __storage_type __b = *__p & __m;
         *__p &= ~__m;
         *__p |= ~__b & __m;
     }
 }
 
 template <class _Allocator>
-bool
+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
 vector<bool, _Allocator>::__invariants() const
 {
     if (this->__begin_ == nullptr)
     {
         if (this->__size_ != 0 || this->__cap() != 0)
             return false;
     }
     else
     {
         if (this->__cap() == 0)
             return false;
         if (this->__size_ > this->capacity())
             return false;
     }
     return true;
 }
 
 template <class _Allocator>
-size_t
+_LIBCPP_CONSTEXPR_AFTER_CXX17 size_t
 vector<bool, _Allocator>::__hash_code() const _NOEXCEPT
 {
     size_t __h = 0;
     // do middle whole words
     size_type __n = __size_;
     __storage_pointer __p = __begin_;
     for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
         __h ^= *__p;
     // do last partial word
     if (__n > 0)
     {
         const __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
         __h ^= *__p & __m;
     }
     return __h;
 }
 
 template <class _Allocator>
 struct _LIBCPP_TEMPLATE_VIS hash<vector<bool, _Allocator> >
     : public unary_function<vector<bool, _Allocator>, size_t>
 {
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_t operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT
         {return __vec.__hash_code();}
 };
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     const typename vector<_Tp, _Allocator>::size_type __sz = __x.size();
     return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator> (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return __y < __x;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return !(__x < __y);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return !(__y < __x);
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, class _Allocator, class _Up>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY typename vector<_Tp, _Allocator>::size_type
 erase(vector<_Tp, _Allocator>& __c, const _Up& __v) {
   auto __old_size = __c.size();
   __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end());
   return __old_size - __c.size();
 }
 
 template <class _Tp, class _Allocator, class _Predicate>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY typename vector<_Tp, _Allocator>::size_type
 erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred) {
   auto __old_size = __c.size();
   __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end());
   return __old_size - __c.size();
 }
 
 template <>

libcxx/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp

 // vector& operator=(const vector& c);
 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool, test_allocator<bool> > l(3, true, test_allocator<bool>(5));
         std::vector<bool, test_allocator<bool> > l2(l, test_allocator<bool>(3));
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == test_allocator<bool>(3));
     }
#if TEST_STD_VER >= 11
         std::vector<bool, min_allocator<bool> > l(3, true, min_allocator<bool>());
         std::vector<bool, min_allocator<bool> > l2(l, min_allocator<bool>());
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<bool>());
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp

 // void assign(initializer_list<value_type> il);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     std::vector<bool> d;
     d.assign({true, false, false, true});
     assert(d.size() == 4);
     assert(d[0] == true);
     assert(d[1] == false);
     assert(d[2] == false);
     assert(d[3] == true);
     }
     {
     std::vector<bool, min_allocator<bool>> d;
     d.assign({true, false, false, true});
     assert(d.size() == 4);
     assert(d[0] == true);
     assert(d[1] == false);
     assert(d[2] == false);
     assert(d[3] == true);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/assign_move.pass.cpp

 // vector& operator=(vector&& c);
 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
         std::vector<bool, test_allocator<bool> > lo(test_allocator<bool>(5));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
TEST_CONSTEXPR_CXX20 bool tests()
         }
         std::vector<bool, min_allocator<bool> > l2(min_allocator<bool>{});
         l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/capacity.pass.cpp

 // size_type capacity() const;
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool> v;
         assert(v.capacity() == 0);
     }
     {
         std::vector<bool> v(100);
         assert(v.capacity() >= 100);
         v.push_back(0);
         assert(v.capacity() >= 101);
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v;
         assert(v.capacity() == 0);
     }
     {
         std::vector<bool, min_allocator<bool>> v(100);
         assert(v.capacity() >= 100);
         v.push_back(0);
         assert(v.capacity() >= 101);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/compare.pass.cpp

 // bool operator> ( const vector& lhs, const vector& rhs );
 // bool operator>=( const vector& lhs, const vector& rhs );
 
 #include <vector>
 #include <cassert>
 
 #include "test_comparisons.h"
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
     typedef std::vector<bool> VB;
     {
         const VB v1, v2;
         assert(testComparisons6(v1, v2, true, false));
     }
     {
         const VB v1(1, true);
         const VB v2(1, true);
typedef std::vector<bool> VB;
         assert( (std::vector<bool>() == std::vector<bool>()));
         assert(!(std::vector<bool>() != std::vector<bool>()));
         assert(!(std::vector<bool>() < std::vector<bool>()));
         assert( (std::vector<bool>() <= std::vector<bool>()));
         assert(!(std::vector<bool>() > std::vector<bool>()));
         assert( (std::vector<bool>() >= std::vector<bool>()));
     }
 
+    return true;
+}
+
+int main(int, char**) {
+    test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/const_reference.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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 #include <cassert>
 #include <vector>
 
 #include "test_macros.h"
 
-bool test() {
+TEST_CONSTEXPR_CXX20 bool test() {
   using CRefT = std::vector<bool>::const_reference;
 #if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL)
   ASSERT_SAME_TYPE(CRefT, bool);
 #else
   ASSERT_SAME_TYPE(CRefT, std::__bit_const_reference<std::vector<bool> >);
   std::vector<bool> vec;
   vec.push_back(true);
   CRefT ref = vec[0];
   assert(ref);
   vec[0] = false;
   assert(!ref);
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/construct_default.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
-void
-test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
 #if TEST_STD_VER > 14
     LIBCPP_STATIC_ASSERT((noexcept(C{})), "" );
 #elif TEST_STD_VER >= 11
     LIBCPP_STATIC_ASSERT((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
 #endif
     C c;
     LIBCPP_ASSERT(c.__invariants());
     assert(c.empty());
     assert(c.get_allocator() == typename C::allocator_type());
 #if TEST_STD_VER >= 11
     C c1 = {};
     LIBCPP_ASSERT(c1.__invariants());
     assert(c1.empty());
     assert(c1.get_allocator() == typename C::allocator_type());
 #endif
 }
 
 template <class C>
-void
-test1(const typename C::allocator_type& a)
+TEST_CONSTEXPR_CXX20 void test1(const typename C::allocator_type& a)
 {
 #if TEST_STD_VER > 14
     LIBCPP_STATIC_ASSERT((noexcept(C{typename C::allocator_type{}})), "" );
 #elif TEST_STD_VER >= 11
     LIBCPP_STATIC_ASSERT((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
 #endif
     C c(a);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.empty());
     assert(c.get_allocator() == a);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     test0<std::vector<bool> >();
     test1<std::vector<bool, test_allocator<bool> > >(test_allocator<bool>(3));
     }
 #if TEST_STD_VER >= 11
     {
     test0<std::vector<bool, min_allocator<bool>> >();
     test1<std::vector<bool, min_allocator<bool> > >(min_allocator<bool>());
     }
     {
     test0<std::vector<bool, explicit_allocator<bool>> >();
     test1<std::vector<bool, explicit_allocator<bool> > >(explicit_allocator<bool>());
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class C, class Iterator>
-void
-test(Iterator first, Iterator last)
+TEST_CONSTEXPR_CXX20 void test(Iterator first, Iterator last)
 {
     C c(first, last);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
     bool* an = a + sizeof(a)/sizeof(a[0]);
     test<std::vector<bool> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an));
     test<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
     test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
     test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
     test<std::vector<bool> >(a, an);
 #if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(a, an);
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class C, class Iterator>
-void
-test(Iterator first, Iterator last, const typename C::allocator_type& a)
+TEST_CONSTEXPR_CXX20 void test(Iterator first, Iterator last, const typename C::allocator_type& a)
 {
     C c(first, last, a);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
     bool* an = a + sizeof(a)/sizeof(a[0]);
     {
     std::allocator<bool> alloc;
     test<std::vector<bool> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an), alloc);
     test<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc);
     test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc);
     test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
     test<std::vector<bool> >(a, an, alloc);
     }
 #if TEST_STD_VER >= 11
     {
     min_allocator<bool> alloc;
     test<std::vector<bool, min_allocator<bool>> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an), alloc);
     test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc);
     test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc);
     test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
     test<std::vector<bool, min_allocator<bool>> >(a, an, alloc);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/construct_size.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
 template <class C>
-void
-test2(typename C::size_type n,
+TEST_CONSTEXPR_CXX20 void test2(typename C::size_type n,
                                 typename C::allocator_type const& a = typename C::allocator_type ())
 {
 #if TEST_STD_VER >= 14
     C c(n, a);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
     assert(c.get_allocator() == a);
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == typename C::value_type());
 #else
   ((void)n);
   ((void)a);
 #endif
 }
 
 template <class C>
-void
-test1(typename C::size_type n)
+TEST_CONSTEXPR_CXX20 void test1(typename C::size_type n)
 {
     C c(n);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
     assert(c.get_allocator() == typename C::allocator_type());
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == typename C::value_type());
 }
 
 template <class C>
-void
-test(typename C::size_type n)
+TEST_CONSTEXPR_CXX20 void test(typename C::size_type n)
 {
     test1<C> ( n );
     test2<C> ( n );
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     test<std::vector<bool> >(50);
 #if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(50);
     test2<std::vector<bool, test_allocator<bool>> >( 100, test_allocator<bool>(23));
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp

 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
-void
-test(typename C::size_type n, const typename C::value_type& x)
+TEST_CONSTEXPR_CXX20 void test(typename C::size_type n, const typename C::value_type& x)
 {
     C c(n, x);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == x);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     test<std::vector<bool> >(50, true);
 #if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(50, true);
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp

 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
-void
-test(typename C::size_type n, const typename C::value_type& x,
+TEST_CONSTEXPR_CXX20 void test(typename C::size_type n,
+                                    const typename C::value_type& x,
                                     const typename C::allocator_type& a)
 {
     C c(n, x, a);
     LIBCPP_ASSERT(c.__invariants());
     assert(a == c.get_allocator());
     assert(c.size() == n);
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == x);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     test<std::vector<bool> >(50, true, std::allocator<bool>());
 #if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(50, true, min_allocator<bool>());
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/copy.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
-void
-test(const C& x)
+TEST_CONSTEXPR_CXX20 void test(const C& x)
 {
     typename C::size_type s = x.size();
     C c(x);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
         bool* an = a + sizeof(a)/sizeof(a[0]);
         test(std::vector<bool>(a, an));
     }
     {
         std::vector<bool, test_allocator<bool> > v(3, true, test_allocator<bool>(5));
#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool> > v(3, true, min_allocator<bool>());
         std::vector<bool, min_allocator<bool> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
-void
-test(const C& x, const typename C::allocator_type& a)
+TEST_CONSTEXPR_CXX20 void test(const C& x, const typename C::allocator_type& a)
 {
     typename C::size_type s = x.size();
     C c(x, a);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
         bool* an = a + sizeof(a)/sizeof(a[0]);
         test(std::vector<bool>(a, an), std::allocator<bool>());
     }
     {
         std::vector<bool, test_allocator<bool> > l(3, true, test_allocator<bool>(5));
#if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool> > l(3, true, min_allocator<bool>());
         std::vector<bool, min_allocator<bool> > l2(l, min_allocator<bool>());
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<bool>());
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/emplace.pass.cpp

 
 // template <class... Args> iterator emplace(const_iterator pos, Args&&... args);
 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef std::vector<bool> C;
         C c;
 
         C::iterator i = c.emplace(c.cbegin());
         assert(i == c.begin());
         assert(c.size() == 1);
TEST_CONSTEXPR_CXX20 bool tests()
         assert(i == c.begin()+1);
         assert(c.size() == 3);
         assert(c.size() == 3);
         assert(c.front() == false);
         assert(c[1] == true);
         assert(c.back() == true);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp

 // template <class... Args> reference emplace_back(Args&&... args);
 // return type is 'reference' in C++17; 'void' before
 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef std::vector<bool> C;
         C c;
 #if TEST_STD_VER > 14
         typedef C::reference Ref;
         Ref r1 = c.emplace_back();
         assert(c.size() == 1);

 #endif
         c.emplace_back(true);
         assert(c.size() == 3);
         assert(c.front() == false);
         assert(c[1] == true);
         assert(c.back() == true);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/empty.pass.cpp

 // bool empty() const noexcept;
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     typedef std::vector<bool> C;
     C c;
     ASSERT_NOEXCEPT(c.empty());
     assert(c.empty());
     c.push_back(false);
     assert(!c.empty());
     c.clear();
     assert(c.empty());
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::vector<bool, min_allocator<bool>> C;
     C c;
     ASSERT_NOEXCEPT(c.empty());
     assert(c.empty());
     c.push_back(false);
     assert(!c.empty());
     c.clear();
     assert(c.empty());
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp

 // hash specializations.
 
 #include <vector>
 
 #include "poisoned_hash_helper.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
-  test_library_hash_specializations_available();
-  {
-    test_hash_enabled_for_type<std::vector<bool> >();
-    test_hash_enabled_for_type<std::vector<bool, min_allocator<bool>>>();
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+
+  return true;
 
+int main(int, char**) {
+  test_library_hash_specializations_available();
+  test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp

 // iterator erase(const_iterator position);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     bool a1[] = {1, 0, 1};
     {
     std::vector<bool> l1(a1, a1+3);
     std::vector<bool>::const_iterator i = l1.begin();
     ++i;
     std::vector<bool>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
#if TEST_STD_VER >= 11
     assert(*l1.begin() == true);
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
     assert(std::distance(l1.begin(), l1.end()) == 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp

 // iterator erase(const_iterator first, const_iterator last);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     bool a1[] = {1, 0, 1};
     {
         std::vector<bool> l1(a1, a1+3);
         std::vector<bool>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
         assert(std::distance(l1.cbegin(), l1.cend()) == 3);
         assert(i == l1.begin());
#if TEST_STD_VER >= 11
         std::vector<bool, min_allocator<bool>> l1(a1, a1+3);
         std::vector<bool, min_allocator<bool>>::iterator i = l1.erase(l1.cbegin(), std::next(l1.cbegin(), 3));
         assert(l1.size() == 0);
         assert(std::distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/find.pass.cpp

 
 #include <vector>
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         for (unsigned i = 1; i < 256; ++i)
         {
             std::vector<bool> b(i,true);
             std::vector<bool>::iterator j = std::find(b.begin()+1, b.end(), false);
             assert(static_cast<std::size_t>(j-b.begin()) == i);
             assert(b.end() == j);
         }
     }
     {
         for (unsigned i = 1; i < 256; ++i)
         {
             std::vector<bool> b(i,false);
             std::vector<bool>::iterator j = std::find(b.begin()+1, b.end(), true);
             assert(static_cast<std::size_t>(j-b.begin()) == i);
             assert(b.end() == j);
         }
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/get_allocator.pass.cpp

 // allocator_type get_allocator() const
 
 #include <vector>
 #include <cassert>
 
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
     {
         std::allocator<bool> alloc;
         const std::vector<bool> vb(alloc);
         assert(vb.get_allocator() == alloc);
     }
     {
         other_allocator<bool> alloc(1);
         const std::vector<bool, other_allocator<bool> > vb(alloc);
         assert(vb.get_allocator() == alloc);
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp

 // vector(initializer_list<value_type> il);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     std::vector<bool> d = {true, false, false, true};
     assert(d.size() == 4);
     assert(d[0] == true);
     assert(d[1] == false);
     assert(d[2] == false);
     assert(d[3] == true);
     }
     {
     std::vector<bool, min_allocator<bool>> d = {true, false, false, true};
     assert(d.size() == 4);
     assert(d[0] == true);
     assert(d[1] == false);
     assert(d[2] == false);
     assert(d[3] == true);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp

 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     std::vector<bool, test_allocator<bool>> d({true, false, false, true}, test_allocator<bool>(3));
     assert(d.get_allocator() == test_allocator<bool>(3));
     assert(d.size() == 4);
     assert(d[0] == true);
     assert(d[1] == false);
     assert(d[2] == false);
     assert(d[3] == true);
     }
     {
     std::vector<bool, min_allocator<bool>> d({true, false, false, true}, min_allocator<bool>());
     assert(d.get_allocator() == min_allocator<bool>());
     assert(d.size() == 4);
     assert(d[0] == true);
     assert(d[1] == false);
     assert(d[2] == false);
     assert(d[3] == true);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp

 // iterator insert(const_iterator p, initializer_list<value_type> il);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     std::vector<bool> d(10, true);
     std::vector<bool>::iterator i = d.insert(d.cbegin() + 2, {false, true, true, false});
     assert(d.size() == 14);
     assert(i == d.begin() + 2);
     assert(d[0] == true);
     assert(d[1] == true);
TEST_CONSTEXPR_CXX20 bool tests()
     assert(d[8] == true);
     assert(d[9] == true);
     assert(d[10] == true);
     assert(d[11] == true);
     assert(d[12] == true);
     assert(d[13] == true);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp

 #include <vector>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool> v(100);
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const bool*>(a),
                                         cpp17_input_iterator<const bool*>(a+N));
         assert(v.size() == 100 + N);
#if TEST_STD_VER >= 11
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp

 
 #include <vector>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool> v(100);
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
         assert(i == v.begin() + 10);
         std::size_t j;
         for (j = 0; j < 10; ++j)
#if TEST_STD_VER >= 11
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp

 
 #include <vector>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool> v(100);
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == 101);
         assert(i == v.begin() + 10);
         std::size_t j;
         for (j = 0; j < 10; ++j)
#if TEST_STD_VER >= 11
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/iterators.pass.cpp

 
 #include <vector>
 #include <cassert>
 #include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     using IterRefT = std::iterator_traits<std::vector<bool>::iterator>::reference;
     ASSERT_SAME_TYPE(IterRefT, std::vector<bool>::reference);
 
     using ConstIterRefT = std::iterator_traits<std::vector<bool>::const_iterator>::reference;
 #if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL)
     ASSERT_SAME_TYPE(ConstIterRefT, bool);
 #else
#endif
         assert(i == j);
         assert(i == c.end());
     }
     {
         typedef bool T;
         typedef std::vector<T> C;
         C::iterator i;
         C::const_iterator j;
+        (void) i;
+        (void) j;
     }
 #if TEST_STD_VER >= 11
     {
         typedef bool T;
         typedef std::vector<T, min_allocator<T>> C;
         C c;
         C::iterator i = c.begin();
         C::iterator j = c.end();
#if TEST_STD_VER >= 11
         assert(i == j);
         assert(i == c.end());
     }
     {
         typedef bool T;
         typedef std::vector<T, min_allocator<T>> C;
         C::iterator i;
         C::const_iterator j;
+        (void) i;
+        (void) j;
     }
 #endif
 #if TEST_STD_VER > 11
     { // N3644 testing
         std::vector<bool>::iterator ii1{}, ii2{};
         std::vector<bool>::iterator ii4 = ii1;
         std::vector<bool>::const_iterator cii{};
         assert ( ii1 == ii2 );
#if TEST_STD_VER > 11
         assert (!(cii >  ii1 ));
         assert ( (ii1 >= cii ));
         assert ( (cii >= ii1 ));
         assert (cii - ii1 == 0);
         assert (ii1 - cii == 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/move.pass.cpp

 // vector(vector&& c);
 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     test_allocator_statistics alloc_stats;
     {
         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5, &alloc_stats));
         std::vector<bool, test_allocator<bool> > lo(test_allocator<bool>(5, &alloc_stats));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(true);
test_allocator_statistics alloc_stats;
       }
       {
         const AllocT& a = v2.get_allocator();
         assert(a.get_id() == 101);
         assert(a.get_data() == 42);
       }
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp

 // vector(vector&& c, const allocator_type& a);
 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
         std::vector<bool, test_allocator<bool> > lo(test_allocator<bool>(5));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
TEST_CONSTEXPR_CXX20 bool tests()
             lo.push_back(i);
         }
         std::vector<bool, min_allocator<bool> > l2(std::move(l), min_allocator<bool>());
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == min_allocator<bool>());
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp

 // vector& operator=(initializer_list<value_type> il);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     std::vector<bool> d;
     d = {true, false, false, true};
     assert(d.size() == 4);
     assert(d[0] == true);
     assert(d[1] == false);
     assert(d[2] == false);
     assert(d[3] == true);
     }
     {
     std::vector<bool, min_allocator<bool>> d;
     d = {true, false, false, true};
     assert(d.size() == 4);
     assert(d[0] == true);
     assert(d[1] == false);
     assert(d[2] == false);
     assert(d[3] == true);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/push_back.pass.cpp

 
 #include <vector>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         bool a[] = {0, 1, 1, 0, 1, 0, 0};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::vector<bool> c;
         for (unsigned i = 0; i < N; ++i)
         {
             c.push_back(a[i]);
#if TEST_STD_VER >= 11
             c.push_back(a[i]);
             assert(c.size() == i+1);
             for (std::size_t j = 0; j < c.size(); ++j)
                 assert(c[j] == a[j]);
         }
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp

 
 // static void swap(reference x, reference y) noexcept;
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
 
     bool a[] = {false, true, false, true};
     bool* an = a + sizeof(a)/sizeof(a[0]);
 
     std::vector<bool> v(a, an);
     std::vector<bool>::reference r1 = v[0];
     std::vector<bool>::reference r2 = v[3];
 
 #if TEST_STD_VER >= 11
     static_assert((noexcept(v.swap(r1,r2))), "");
 #endif
 
     assert(!r1);
     assert( r2);
     v.swap(r1, r2);
     assert( r1);
     assert(!r2);
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/reference/assign_bool.pass.cpp

 
 // reference& operator=(bool)
 
 #include <cassert>
 #include <vector>
 
 #include "test_macros.h"
 
-bool test() {
+TEST_CONSTEXPR_CXX20 bool test() {
   std::vector<bool> vec;
   typedef std::vector<bool>::reference Ref;
   vec.push_back(true);
   vec.push_back(false);
   Ref ref = vec[0];
   const Ref cref = vec[0];
 
   assert(ref);
#if TEST_STD_VER > 20
   assert(!vec[1]);
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/reference/assign_copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // reference& operator=(const reference&)
 
 #include <cassert>
 #include <vector>
 
-bool test() {
+#include "test_macros.h"
+
+TEST_CONSTEXPR_CXX20 bool test() {
   std::vector<bool> vec;
   typedef std::vector<bool>::reference Ref;
   vec.push_back(true);
   vec.push_back(false);
   Ref ref1 = vec[0];
   Ref ref2 = vec[1];
   ref2 = ref1;
   // Ref&
// const Ref&
     assert(!vec[0]);
     assert(!vec[1]);
   }
   return true;
 }
 
 int main(int, char**) {
   test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/reference/ctor_copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // reference(const reference&)
 
 #include <cassert>
 #include <vector>
 
-bool test() {
+#include "test_macros.h"
+
+TEST_CONSTEXPR_CXX20 bool test() {
   std::vector<bool> vec;
   typedef std::vector<bool>::reference Ref;
   vec.push_back(true);
   Ref ref = vec[0];
   Ref ref2 = ref;
   assert(ref == ref2 && ref2);
   ref.flip();
   assert(ref == ref2 && !ref2);
 
   return true;
 }
 
 int main(int, char**) {
   test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/reference/flip.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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // flip()
 
 #include <cassert>
 #include <vector>
 
-bool test() {
+#include "test_macros.h"
+
+TEST_CONSTEXPR_CXX20 bool test() {
   std::vector<bool> vec;
   typedef std::vector<bool>::reference Ref;
   vec.push_back(true);
   vec.push_back(false);
   Ref ref = vec[0];
   assert(vec[0]);
   assert(!vec[1]);
   ref.flip();
   assert(!vec[0]);
   assert(!vec[1]);
   ref.flip();
   assert(vec[0]);
   assert(!vec[1]);
 
   return true;
 }
 
 int main(int, char**) {
   test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/reference/operator_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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // operator bool()
 
 #include <cassert>
 #include <type_traits>
 #include <vector>
 
-bool test() {
+#include "test_macros.h"
+
+TEST_CONSTEXPR_CXX20 bool test() {
   std::vector<bool> vec;
   typedef std::vector<bool>::reference Ref;
   static_assert(std::is_convertible<Ref, bool>::value, "");
 
   vec.push_back(true);
   vec.push_back(false);
   Ref true_ref = vec[0];
   Ref false_ref = vec[1];
   bool b = true_ref;
   assert(b);
   assert(true_ref);
   assert(!false_ref);
 
   return true;
 }
 
 int main(int, char**) {
   test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/reserve.pass.cpp

 #include <vector>
 #include <cassert>
 #include <stdexcept>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool> v;
         v.reserve(10);
         assert(v.capacity() >= 10);
     }
     {
         std::vector<bool> v(100);
#if TEST_STD_VER >= 11
         assert(v.size() == 100);
         assert(v.capacity() >= 100);
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() >= 150);
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    {
+    if (!TEST_IS_CONSTANT_EVALUATED) {
         std::vector<bool, limited_allocator<bool, 10> > v;
         v.reserve(5);
         try {
             // A typical implementation would allocate chunks of bits.
             // In libc++ the chunk has the same size as the machine word. It is
             // reasonable to assume that in practice no implementation would use
             // 64 kB or larger chunks.
             v.reserve(10 * 65536);
             assert(false);
         } catch (const std::length_error&) {
             // no-op
         }
         assert(v.capacity() >= 5);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/resize_size.pass.cpp

 // void resize(size_type sz);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool> v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() >= 100);
         v.resize(200);
         assert(v.size() == 200);
#if TEST_STD_VER >= 11
         assert(v.capacity() >= 200);
         v.reserve(400);
         v.resize(300);  // check the case when resizing and we already have room
         assert(v.size() == 300);
         assert(v.capacity() >= 400);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp

 // void resize(size_type sz, const value_type& x);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool> v(100);
         v.resize(50, 1);
         assert(v.size() == 50);
         assert(v.capacity() >= 100);
         assert(v == std::vector<bool>(50));
         v.resize(200, 1);
#if TEST_STD_VER >= 11
         assert(v.capacity() >= 200);
         for (unsigned i = 0; i < 50; ++i)
             assert(v[i] == 0);
         for (unsigned i = 50; i < 200; ++i)
             assert(v[i] == 1);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp

 // void shrink_to_fit();
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool> v(100);
         v.push_back(1);
         v.shrink_to_fit();
         assert(v.capacity() >= 101);
         assert(v.size() >= 101);
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         v.push_back(1);
         v.shrink_to_fit();
         assert(v.capacity() >= 101);
         assert(v.size() >= 101);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/size.pass.cpp

 // size_type size() const noexcept;
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     typedef std::vector<bool> C;
     C c;
     ASSERT_NOEXCEPT(c.size());
     assert(c.size() == 0);
     c.push_back(false);
     assert(c.size() == 1);
#if TEST_STD_VER >= 11
     assert(c.size() == 2);
     c.erase(c.begin());
     assert(c.size() == 1);
     c.erase(c.begin());
     assert(c.size() == 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/swap.pass.cpp

 // void swap(vector& x);
 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<bool> v1(100);
         std::vector<bool> v2(200);
         v1.swap(v2);
         assert(v1.size() == 200);
         assert(v1.capacity() >= 200);
         assert(v2.size() == 100);
#if TEST_STD_VER >= 11
         r1 = true;
         using std::swap;
         swap(r1, r2);
         assert(v[0] == false);
         assert(v[1] == true);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp

 
 #include <vector>
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     typedef std::vector<bool> T;
     typedef std::hash<T> H;
     static_assert((std::is_same<H::argument_type, T>::value), "" );
     static_assert((std::is_same<H::result_type, std::size_t>::value), "" );
     ASSERT_NOEXCEPT(H()(T()));
 
#if TEST_STD_VER >= 11
     ASSERT_NOEXCEPT(H()(T()));
     bool ba[] = {true, false, true, true, false};
     T vb(std::begin(ba), std::end(ba));
     H h;
     assert(h(vb) != 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/access.pass.cpp

 #include <vector>
 #include <cassert>
 #include <stdexcept>
 
 #include "min_allocator.h"
 #include "test_macros.h"
 
 template <class C>
-C
-make(int size, int start)
-{
+TEST_CONSTEXPR_CXX20 C make(int size, int start) {
     C c;
     for (int i = 0; i < size; ++i)
         c.push_back(start + i);
     return c;
 }
 
 template <class Vector>
-void test_get_basic(Vector& c, int start_value) {
+TEST_CONSTEXPR_CXX20 void test_get_basic(Vector& c, int start_value) {
     const int n = static_cast<int>(c.size());
     for (int i = 0; i < n; ++i)
         assert(c[i] == start_value + i);
     for (int i = 0; i < n; ++i)
         assert(c.at(i) == start_value + i);
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
+    if (!TEST_IS_CONSTANT_EVALUATED) {
         try {
             TEST_IGNORE_NODISCARD c.at(n);
             assert(false);
         } catch (const std::out_of_range&) {}
+    }
 #endif
 
     assert(c.front() == start_value);
     assert(c.back() == start_value + n - 1);
 }
 
 template <class Vector>
-void test_get() {
+TEST_CONSTEXPR_CXX20 void test_get() {
     int start_value = 35;
     Vector c = make<Vector>(10, start_value);
     const Vector& cc = c;
     test_get_basic(c, start_value);
     test_get_basic(cc, start_value);
 }
 
 template <class Vector>
-void test_set() {
+TEST_CONSTEXPR_CXX20 void test_set() {
     int start_value = 35;
     const int n = 10;
     Vector c = make<Vector>(n, start_value);
 
     for (int i = 0; i < n; ++i) {
         assert(c[i] == start_value + i);
         c[i] = start_value + i + 1;
         assert(c[i] == start_value + i + 1);
TEST_CONSTEXPR_CXX20 void test_set() {
     assert(c.front() == start_value + 3);
 
     assert(c.back() == start_value + n + 1);
     c.back() = start_value + n + 2;
     assert(c.back() == start_value + n + 2);
 }
 
 template <class Vector>
-void test() {
+TEST_CONSTEXPR_CXX20 void test() {
     test_get<Vector>();
     test_set<Vector>();
 
     Vector c;
     const Vector& cc = c;
     ASSERT_SAME_TYPE(typename Vector::reference, decltype(c[0]));
     ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc[0]));
 
     ASSERT_SAME_TYPE(typename Vector::reference, decltype(c.at(0)));
     ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc.at(0)));
 
     ASSERT_SAME_TYPE(typename Vector::reference, decltype(c.front()));
     ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc.front()));
 
     ASSERT_SAME_TYPE(typename Vector::reference, decltype(c.back()));
     ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc.back()));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     test<std::vector<int> >();
 #if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int> > >();
 #endif
+    return true;
+}
 
+int main(int, char**) {
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/compare.pass.cpp

 // bool operator> (const vector& lhs, const vector& rhs);
 // bool operator>=(const vector& lhs, const vector& rhs);
 
 #include <vector>
 #include <cassert>
 
 #include "test_comparisons.h"
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
     {
         const std::vector<int> c1, c2;
         assert(testComparisons6(c1, c2, true, false));
     }
     {
         const std::vector<int> c1(1, 1), c2(1, 2);
         assert(testComparisons6(c1, c2, false, true));
     }
TEST_CONSTEXPR_CXX20 bool test() {
         assert((std::vector<int>() == std::vector<int>()));
         assert(!(std::vector<int>() != std::vector<int>()));
         assert(!(std::vector<int>() < std::vector<int>()));
         assert((std::vector<int>() <= std::vector<int>()));
         assert(!(std::vector<int>() > std::vector<int>()));
         assert((std::vector<int>() >= std::vector<int>()));
     }
 
+    return true;
+}
+
+int main(int, char**) {
+    test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+
     return 0;
 }

libcxx/test/std/containers/sequences/vector/contiguous.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
-void test_contiguous ( const C &c )
+TEST_CONSTEXPR_CXX20 void test_contiguous(const C &c)
 {
     for ( size_t i = 0; i < c.size(); ++i )
         assert ( *(c.begin() + static_cast<typename C::difference_type>(i)) == *(std::addressof(*c.begin()) + i));
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     typedef int T;
     typedef std::vector<T> C;
     test_contiguous(C());
     test_contiguous(C(3, 5));
     }
 
#if TEST_STD_VER >= 11
     typedef double T;
     typedef min_allocator<T> A;
     typedef std::vector<T, A> C;
     test_contiguous(C(A{}));
     test_contiguous(C(9, 11.0, A{}));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/get_allocator.pass.cpp

 // allocator_type get_allocator() const
 
 #include <vector>
 #include <cassert>
 
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
     {
         std::allocator<int> alloc;
         const std::vector<int> v(alloc);
         assert(v.get_allocator() == alloc);
     }
     {
         other_allocator<int> alloc(1);
         const std::vector<int, other_allocator<int> > v(alloc);
         assert(v.get_allocator() == alloc);
     }
 
+    return true;
+}
+
+int main(int, char**) {
+    test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+
     return 0;
 }

libcxx/test/std/containers/sequences/vector/iterators.pass.cpp

 #include "min_allocator.h"
 
 struct A
 {
     int first;
     int second;
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef int T;
         typedef std::vector<T> C;
         C c;
         C::iterator i = c.begin();
         C::iterator j = c.end();
         assert(std::distance(i, j) == 0);
#if TEST_STD_VER > 11
         assert (!(cii >  ii1 ));
         assert ( (ii1 >= cii ));
         assert ( (cii >= ii1 ));
         assert (cii - ii1 == 0);
         assert (ii1 - cii == 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/reverse_iterators.pass.cpp

 
 #include <vector>
 #include <cassert>
 #include <iterator>
 
 #include "min_allocator.h"
 
 template <class Vector>
-void check_vector_reverse_iterators() {
+TEST_CONSTEXPR_CXX20 void check_vector_reverse_iterators() {
     {
         Vector vec;
         assert(vec.rbegin() == vec.rend());
         assert(vec.crbegin() == vec.crend());
     }
     {
         const int n = 10;
         Vector vec;
TEST_CONSTEXPR_CXX20 void check_vector_reverse_iterators() {
 
         assert(std::distance(vec.rbegin(), vec.rend()) == n);
         assert(std::distance(cvec.rbegin(), cvec.rend()) == n);
         assert(std::distance(vec.crbegin(), vec.crend()) == n);
         assert(std::distance(cvec.crbegin(), cvec.crend()) == n);
     }
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
     check_vector_reverse_iterators<std::vector<int> >();
 #if TEST_STD_VER >= 11
     check_vector_reverse_iterators<std::vector<int, min_allocator<int> > >();
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+    test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp

 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<int> v;
         assert(v.capacity() == 0);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int> v(100);
#if TEST_STD_VER >= 11
         std::vector<int, min_allocator<int>> v(100);
         assert(v.capacity() == 100);
         v.push_back(0);
         assert(v.capacity() > 101);
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp

 // bool empty() const noexcept;
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
     typedef std::vector<int> C;
     C c;
     ASSERT_NOEXCEPT(c.empty());
     assert(c.empty());
     c.push_back(C::value_type(1));
     assert(!c.empty());
     c.clear();
     assert(c.empty());
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::vector<int, min_allocator<int>> C;
     C c;
     ASSERT_NOEXCEPT(c.empty());
     assert(c.empty());
     c.push_back(C::value_type(1));
     assert(!c.empty());
     c.clear();
     assert(c.empty());
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp

 #include <limits>
 #include <type_traits>
 #include <vector>
 
 #include "test_allocator.h"
 #include "test_macros.h"
 
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef limited_allocator<int, 10> A;
     typedef std::vector<int, A> C;
     C c;
     assert(c.max_size() <= 10);
     LIBCPP_ASSERT(c.max_size() == 10);
   }
   {
TEST_CONSTEXPR_CXX20 bool test() {
     typedef std::vector<char> C;
     const C::size_type max_dist =
         static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
     C c;
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp

 #include <vector>
 #include <cassert>
 #include <stdexcept>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         std::vector<int> v;
         v.reserve(10);
         assert(v.capacity() >= 10);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int> v(100);
TEST_CONSTEXPR_CXX20 bool tests() {
         assert(v.size() == 100);
         assert(v.capacity() == 100);
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() == 150);
         assert(is_contiguous_container_asan_correct(v));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    {
+    if (!TEST_IS_CONSTANT_EVALUATED) {
         std::vector<int> v;
         size_t sz = v.max_size() + 1;
 
         try {
             v.reserve(sz);
             assert(false);
         } catch (const std::length_error&) {
             assert(v.size() == 0);
             assert(v.capacity() == 0);
         }
     }
-    {
+    if (!TEST_IS_CONSTANT_EVALUATED) {
         std::vector<int> v(10, 42);
         int* previous_data = v.data();
         size_t previous_capacity = v.capacity();
         size_t sz = v.max_size() + 1;
 
         try {
             v.reserve(sz);
             assert(false);
#if TEST_STD_VER >= 11
         assert(v.capacity() == 100);
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() == 150);
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    {
+    if (!TEST_IS_CONSTANT_EVALUATED) {
         std::vector<int, limited_allocator<int, 100> > v;
         v.reserve(50);
         assert(v.capacity() == 50);
         assert(is_contiguous_container_asan_correct(v));
         try {
             v.reserve(101);
             assert(false);
         } catch (const std::length_error&) {
             // no-op
         }
         assert(v.capacity() == 50);
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+  tests();
+
+#if TEST_STD_VER > 17
+  static_assert(tests());
+#endif
+
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         std::vector<int> v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
#if TEST_STD_VER >= 11
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
+
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp

 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         std::vector<int> v(100);
         v.resize(50, 1);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         assert(v == std::vector<int>(50));
         v.resize(200, 1);
         assert(v.size() == 200);
#if TEST_STD_VER >= 11
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200, 1);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp

 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         std::vector<int> v(100);
         v.push_back(1);
         assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         assert(v.capacity() == 101);
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int, limited_allocator<int, 401> > v(100);
         v.push_back(1);
         assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         assert(v.capacity() == 101);
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    {
+    if (!TEST_IS_CONSTANT_EVALUATED) {
         std::vector<int, limited_allocator<int, 400> > v(100);
         v.push_back(1);
         assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         LIBCPP_ASSERT(v.capacity() == 200); // assumes libc++'s 2x growth factor
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 #if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v(100);
         v.push_back(1);
         assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         assert(v.capacity() == 101);
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp

 // size_type size() const noexcept;
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     typedef std::vector<int> C;
     C c;
     ASSERT_NOEXCEPT(c.size());
     assert(c.size() == 0);
     c.push_back(C::value_type(2));
     assert(c.size() == 1);
#if TEST_STD_VER >= 11
     assert(c.size() == 2);
     c.erase(c.begin());
     assert(c.size() == 1);
     c.erase(c.begin());
     assert(c.size() == 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp

 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         std::vector<int> v1(100);
         std::vector<int> v2(200);
         assert(is_contiguous_container_asan_correct(v1));
         assert(is_contiguous_container_asan_correct(v2));
         v1.swap(v2);
         assert(v1.size() == 200);
         assert(v1.capacity() == 200);
#if TEST_STD_VER >= 11
         assert(v1.capacity() == 200);
         assert(is_contiguous_container_asan_correct(v1));
         assert(v2.size() == 100);
         assert(v2.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v2));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp

 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "allocators.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         std::vector<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
         std::vector<int, test_allocator<int> > l2(l, test_allocator<int>(3));
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == test_allocator<int>(3));
     }
     {
#if TEST_STD_VER >= 11
         std::vector<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::vector<int, min_allocator<int> > l2(l, min_allocator<int>());
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <typename Vec>
-void test ( Vec &v )
+TEST_CONSTEXPR_CXX20 void test(Vec &v)
 {
     v.assign({3, 4, 5, 6});
     assert(v.size() == 4);
     assert(is_contiguous_container_asan_correct(v));
     assert(v[0] == 3);
     assert(v[1] == 4);
     assert(v[2] == 5);
     assert(v[3] == 6);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
     typedef std::vector<int> V;
     V d1;
     V d2;
     d2.reserve(10);  // no reallocation during assign.
     test(d1);
     test(d2);
     }
     {
     typedef std::vector<int, min_allocator<int>> V;
     V d1;
     V d2;
     d2.reserve(10);  // no reallocation during assign.
     test(d1);
     test(d2);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp

 #include "asan_testing.h"
 #include "test_iterators.h"
 #if TEST_STD_VER >= 11
 #include "emplace_constructible.h"
 #include "container_test_types.h"
 #endif
 
 
-void test() {
+TEST_CONSTEXPR_CXX20 bool test() {
 #if TEST_STD_VER >= 11
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructibleMoveableAndAssignable<int>;
     using It = forward_iterator<int*>;
     {
       std::vector<T> v;
// Test with a number of elements in the source range that is greater than capacity
     std::vector<int> dst(10);
 
     size_t n = dst.capacity() * 2;
     std::vector<int> src(n);
 
     dst.assign(It(src.data()), It(src.data() + src.size()));
     assert(dst == src);
   }
+
+  return true;
 }
 
 int main(int, char**) {
   test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp

 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
         std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
TEST_CONSTEXPR_CXX20 bool tests() {
         std::vector<MoveOnly, min_allocator<MoveOnly> > l2((min_allocator<MoveOnly>()));
         l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
         assert(is_contiguous_container_asan_correct(l2));
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp

 #include <vector>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-bool is6(int x) { return x == 6; }
+TEST_CONSTEXPR bool is6(int x) { return x == 6; }
 
 template <typename Vec>
-void test ( Vec &v )
+TEST_CONSTEXPR_CXX20 void test(Vec &v)
 {
     v.assign(5, 6);
     assert(v.size() == 5);
     assert(is_contiguous_container_asan_correct(v));
     assert(std::all_of(v.begin(), v.end(), is6));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
     typedef std::vector<int> V;
     V d1;
     V d2;
     d2.reserve(10);  // no reallocation during assign.
     test(d1);
     test(d2);
     }
#if TEST_STD_VER >= 11
     V d1;
     V d2;
     d2.reserve(10);  // no reallocation during assign.
     test(d1);
     test(d2);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp

 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../../../NotConstructible.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
-void
-test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
 #if TEST_STD_VER > 14
     static_assert((noexcept(C{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
 #endif
     C c;
     LIBCPP_ASSERT(c.__invariants());
     assert(c.empty());
     assert(c.get_allocator() == typename C::allocator_type());
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 #if TEST_STD_VER >= 11
     C c1 = {};
     LIBCPP_ASSERT(c1.__invariants());
     assert(c1.empty());
     assert(c1.get_allocator() == typename C::allocator_type());
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c1));
 #endif
 }
 
 template <class C>
-void
-test1(const typename C::allocator_type& a)
+TEST_CONSTEXPR_CXX20 void test1(const typename C::allocator_type& a)
 {
 #if TEST_STD_VER > 14
     static_assert((noexcept(C{typename C::allocator_type{}})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
 #endif
     C c(a);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.empty());
     assert(c.get_allocator() == a);
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
     test0<std::vector<int> >();
     test0<std::vector<NotConstructible> >();
     test1<std::vector<int, test_allocator<int> > >(test_allocator<int>(3));
     test1<std::vector<NotConstructible, test_allocator<NotConstructible> > >
         (test_allocator<NotConstructible>(5));
     }
     {
test1<std::vector<NotConstructible, explicit_allocator<NotConstructible> > >
         (explicit_allocator<NotConstructible>{});
     }
     {
         std::vector<int, explicit_allocator<int> > v;
         assert(v.empty());
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp

 #include "min_allocator.h"
 #include "asan_testing.h"
 #if TEST_STD_VER >= 11
 #include "emplace_constructible.h"
 #include "container_test_types.h"
 #endif
 
 template <class C, class Iterator>
-void test(Iterator first, Iterator last) {
+TEST_CONSTEXPR_CXX20 void test(Iterator first, Iterator last) {
   {
     C c(first, last);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e;
       ++i, ++first)
     assert(*i == *first);
   }
   // Test with an empty range
   {
     C c(first, first);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.empty());
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
   }
 }
 
-static void basic_test_cases() {
+TEST_CONSTEXPR_CXX20 void basic_test_cases() {
   int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
   int* an = a + sizeof(a) / sizeof(a[0]);
   test<std::vector<int> >(cpp17_input_iterator<const int*>(a),
                           cpp17_input_iterator<const int*>(an));
   test<std::vector<int> >(forward_iterator<const int*>(a),
                           forward_iterator<const int*>(an));
   test<std::vector<int> >(bidirectional_iterator<const int*>(a),
                           bidirectional_iterator<const int*>(an));
test<std::vector<int, min_allocator<int> > >(
       bidirectional_iterator<const int*>(an));
   test<std::vector<int, min_allocator<int> > >(
       random_access_iterator<const int*>(a),
       random_access_iterator<const int*>(an));
   test<std::vector<int> >(a, an);
 #endif
 }
 
-void emplaceable_concept_tests() {
+TEST_CONSTEXPR_CXX20 void emplaceable_concept_tests() {
 #if TEST_STD_VER >= 11
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructible<int>;
     using It = forward_iterator<int*>;
     {
       std::vector<T> v(It(arr1), It(std::end(arr1)));

 }
 
 // In C++03, you can't instantiate a template with a local type.
 struct B1 { int x; };
 struct B2 { int y; };
 struct Der : B1, B2 { int z; };
 
 // Initialize a vector with a different value type.
-void test_ctor_with_different_value_type() {
+TEST_CONSTEXPR_CXX20 void test_ctor_with_different_value_type() {
   {
     // Make sure initialization is performed with each element value, not with
     // a memory blob.
     float array[3] = {0.0f, 1.0f, 2.0f};
     TEST_DIAGNOSTIC_PUSH
     TEST_MSVC_DIAGNOSTIC_IGNORED(4244) // conversion from 'float' to 'int', possible loss of data
     std::vector<int> v(array, array + 3);
     TEST_DIAGNOSTIC_POP
TEST_CONSTEXPR_CXX20 void test_ctor_with_different_value_type() {
   {
     // Though the types are different, initialization can be done with `memcpy`.
     int32_t array[1] = { -1 };
     std::vector<uint32_t> v(array, array + 1);
     assert(v[0] == 4294967295U);
   }
 }
 
-
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool tests() {
   basic_test_cases();
   emplaceable_concept_tests(); // See PR34898
-  test_ctor_under_alloc();
   test_ctor_with_different_value_type();
 
+  return true;
+}
+
+int main(int, char**)
+{
+    tests();
+    test_ctor_under_alloc();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp

 #include "min_allocator.h"
 #include "asan_testing.h"
 #if TEST_STD_VER >= 11
 #include "emplace_constructible.h"
 #include "container_test_types.h"
 #endif
 
 template <class C, class Iterator, class A>
-void test(Iterator first, Iterator last, const A& a) {
+TEST_CONSTEXPR_CXX20 void test(Iterator first, Iterator last, const A& a) {
   C c(first, last, a);
   LIBCPP_ASSERT(c.__invariants());
   assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
   LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
   for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e;
        ++i, ++first)
     assert(*i == *first);
 }
 
 #if TEST_STD_VER >= 11
 
 template <class T>
 struct implicit_conv_allocator : min_allocator<T> {
-  implicit_conv_allocator(void*) {}
-  implicit_conv_allocator(const implicit_conv_allocator&) = default;
+  TEST_CONSTEXPR implicit_conv_allocator(void*) {}
+  TEST_CONSTEXPR implicit_conv_allocator(const implicit_conv_allocator&) = default;
 
   template <class U>
-  implicit_conv_allocator(implicit_conv_allocator<U>) {}
+  TEST_CONSTEXPR implicit_conv_allocator(implicit_conv_allocator<U>) {}
 };
 
 #endif
 
-void basic_tests() {
+TEST_CONSTEXPR_CXX20 void basic_tests() {
   {
     int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
     int* an = a + sizeof(a) / sizeof(a[0]);
     std::allocator<int> alloc;
     test<std::vector<int> >(cpp17_input_iterator<const int*>(a),
                             cpp17_input_iterator<const int*>(an), alloc);
     test<std::vector<int> >(forward_iterator<const int*>(a),
                             forward_iterator<const int*>(an), alloc);
test<std::vector<int, min_allocator<int> > >(
         random_access_iterator<const int*>(a),
         random_access_iterator<const int*>(an), alloc);
     test<std::vector<int, min_allocator<int> > >(a, an, alloc);
     test<std::vector<int, implicit_conv_allocator<int> > >(a, an, nullptr);
   }
 #endif
 }
 
-void emplaceable_concept_tests() {
+TEST_CONSTEXPR_CXX20 void emplaceable_concept_tests() {
 #if TEST_STD_VER >= 11
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructible<int>;
     using It = forward_iterator<int*>;
     using Alloc = std::allocator<T>;
     Alloc a;
int arr2[] = {1, 101, 42};
     {
       //ExpectConstructGuard<int&> G(3);
       //C v(It(arr2), It(std::end(arr2)), a);
     }
   }
 #endif
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
   basic_tests();
   emplaceable_concept_tests(); // See PR34898
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
   test_ctor_under_alloc();
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp

 
 #include "test_macros.h"
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
+TEST_CONSTEXPR_CXX20
 void test(typename C::size_type n,
           typename C::allocator_type const& a = typename C::allocator_type())
 {
     (void)a;
     // Test without a custom allocator
     {
         C c(n);
         LIBCPP_ASSERT(c.__invariants());
#if TEST_STD_VER >= 14
         assert(c.get_allocator() == a);
         LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
         for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
             assert(*i == typename C::value_type());
     }
 #endif
 }
 
-void tests() {
+TEST_CONSTEXPR_CXX20 bool tests() {
     test<std::vector<int> >(0);
     test<std::vector<int> >(50);
+#if TEST_STD_VER >= 11
+    test<std::vector<int, min_allocator<int>>>(0);
+    test<std::vector<int, min_allocator<int>>>(50);
+#endif
+
+    return true;
+}
+
+int main(int, char**) {
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     test<std::vector<DefaultOnly> >(0);
     test<std::vector<DefaultOnly> >(500);
     assert(DefaultOnly::count == 0);
+
 #if TEST_STD_VER >= 11
-    test<std::vector<int, min_allocator<int>>>(0);
-    test<std::vector<int, min_allocator<int>>>(50);
     test<std::vector<DefaultOnly, min_allocator<DefaultOnly>>>(0);
     test<std::vector<DefaultOnly, min_allocator<DefaultOnly>>>(500);
     test<std::vector<DefaultOnly, test_allocator<DefaultOnly>>>(0, test_allocator<DefaultOnly>(23));
     test<std::vector<DefaultOnly, test_allocator<DefaultOnly>>>(100, test_allocator<DefaultOnly>(23));
     assert(DefaultOnly::count == 0);
 #endif
-}
 
-int main(int, char**) {
-    tests();
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 void
 test(typename C::size_type n, const typename C::value_type& x)
 {
     C c(n, x);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     test<std::vector<int> >(0, 3);
     test<std::vector<int> >(50, 3);
     // Add 1 for implementations that dynamically allocate a container proxy.
     test<std::vector<int, limited_allocator<int, 50 + 1> > >(0, 5);
     test<std::vector<int, limited_allocator<int, 50 + 1> > >(50, 5);
     test<std::vector<int, limited_allocator<int, 50 + 1> > >(50, 5);
 #if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(0, 3);
     test<std::vector<int, min_allocator<int>> >(50, 3);
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 void
 test(typename C::size_type n, const typename C::value_type& x,
      const typename C::allocator_type& a)
 {
     C c(n, x, a);
     LIBCPP_ASSERT(c.__invariants());
     assert(a == c.get_allocator());
     assert(c.size() == n);
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     test<std::vector<int> >(0, 3, std::allocator<int>());
     test<std::vector<int> >(50, 3, std::allocator<int>());
 #if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(0, 3, min_allocator<int>());
     test<std::vector<int, min_allocator<int>> >(50, 3, min_allocator<int>());
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const C& x)
 {
     typename C::size_type s = x.size();
     C c(x);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
         int* an = a + sizeof(a)/sizeof(a[0]);
         test(std::vector<int>(a, an));
     }
     {
         std::vector<int, test_allocator<int> > v(3, 2, test_allocator<int>(5));
         std::vector<int, test_allocator<int> > v2 = v;
#if TEST_STD_VER >= 11
         assert(is_contiguous_container_asan_correct(v2));
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
         assert(is_contiguous_container_asan_correct(v));
         assert(is_contiguous_container_asan_correct(v2));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const C& x, const typename C::allocator_type& a)
 {
     typename C::size_type s = x.size();
     C c(x, a);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
         int* an = a + sizeof(a)/sizeof(a[0]);
         test(std::vector<int>(a, an), std::allocator<int>());
     }
     {
         std::vector<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
         std::vector<int, test_allocator<int> > l2(l, test_allocator<int>(3));
#if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::vector<int, min_allocator<int> > l2(l, min_allocator<int>());
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp

 
 #include "deduction_guides_sfinae_checks.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_allocator.h"
 
 struct A {};
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
 
 //  Test the explicit deduction guides
     {
     const int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
     std::vector vec(std::begin(arr), std::end(arr));
 
     static_assert(std::is_same_v<decltype(vec), std::vector<int>>, "");
     assert(std::equal(vec.begin(), vec.end(), std::begin(arr), std::end(arr)));
assert(vec.size() == 0);
         std::vector<short, Alloc> source;
         std::vector vec(std::move(source), ConvertibleToAlloc(2));
         static_assert(std::is_same_v<decltype(vec), decltype(source)>);
         }
     }
 
     SequenceContainerDeductionGuidesSfinaeAway<std::vector, std::vector<int>>();
 
+    return true;
+}
+
+int main(int, char**) {
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp

 struct X
 {
     std::vector<X> q;
 };
 
 int main(int, char**)
 {
 
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp

 template <class T>
 struct some_alloc
 {
     typedef T value_type;
     some_alloc(const some_alloc&);
     void allocate(size_t);
 };
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         typedef std::vector<MoveOnly> C;
         static_assert(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::vector<MoveOnly, test_allocator<MoveOnly>> C;
         static_assert(std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::vector<MoveOnly, other_allocator<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
     {
         typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp

 struct some_alloc
 {
     typedef T value_type;
     some_alloc(const some_alloc&);
     ~some_alloc() noexcept(false);
     void allocate(size_t);
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef std::vector<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
     {
         typedef std::vector<MoveOnly, test_allocator<MoveOnly>> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
     {
         typedef std::vector<MoveOnly, other_allocator<MoveOnly>> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
 #if defined(_LIBCPP_VERSION)
     {
         typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp

 // vector(initializer_list<value_type> il);
 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     std::vector<int> d = {3, 4, 5, 6};
     assert(d.size() == 4);
     assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
     {
     std::vector<int, min_allocator<int>> d = {3, 4, 5, 6};
     assert(d.size() == 4);
     assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     std::vector<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
     assert(d.get_allocator() == test_allocator<int>(3));
     assert(d.size() == 4);
     assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
TEST_CONSTEXPR_CXX20 bool tests()
     }
     {
     std::vector<int, min_allocator<int>> d({}, min_allocator<int>());
     assert(d.size() == 0);
     assert(d.empty());
     assert(is_contiguous_container_asan_correct(d));
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/move.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     test_allocator_statistics alloc_stats;
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5, &alloc_stats));
         std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5, &alloc_stats));
         assert(is_contiguous_container_asan_correct(l));
         assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
test_allocator_statistics alloc_stats;
       }
       {
         const test_allocator<int>& a = v2.get_allocator();
         assert(a.get_id() == 101);
         assert(a.get_data() == 42);
       }
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp

 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
         std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5));
         assert(is_contiguous_container_asan_correct(l));
         assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
TEST_CONSTEXPR_CXX20 bool tests()
         assert(is_contiguous_container_asan_correct(lo));
         std::vector<MoveOnly, min_allocator<MoveOnly> > l2(std::move(l), min_allocator<MoveOnly>());
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == min_allocator<MoveOnly>());
         assert(is_contiguous_container_asan_correct(l2));
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp

#if TEST_STD_VER > 14
         static_assert( std::is_nothrow_move_assignable<C>::value, "");
     }
     {  // POCMA false, is_always_equal false
         typedef std::vector<MoveOnly, some_alloc3<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif
 
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp

 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     std::vector<int> d;
     d = {3, 4, 5, 6};
     assert(d.size() == 4);
     assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
     {
     std::vector<int, min_allocator<int>> d;
     d = {3, 4, 5, 6};
     assert(d.size() == 4);
     assert(is_contiguous_container_asan_correct(d));
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.data/data.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 struct Nasty {
-    Nasty() : i_(0) {}
-    Nasty(int i) : i_(i) {}
-    ~Nasty() {}
+    TEST_CONSTEXPR Nasty() : i_(0) {}
+    TEST_CONSTEXPR Nasty(int i) : i_(i) {}
+    TEST_CONSTEXPR_CXX20 ~Nasty() {}
 
     Nasty * operator&() const { assert(false); return nullptr; }
     int i_;
-    };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<int> v;
         assert(v.data() == 0);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int> v(100);
#if TEST_STD_VER >= 11
     }
     {
         std::vector<Nasty, min_allocator<Nasty>> v(100);
         assert(v.data() == std::addressof(v.front()));
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 struct Nasty {
-    Nasty() : i_(0) {}
-    Nasty(int i) : i_(i) {}
-    ~Nasty() {}
+    TEST_CONSTEXPR Nasty() : i_(0) {}
+    TEST_CONSTEXPR Nasty(int i) : i_(i) {}
+    TEST_CONSTEXPR_CXX20 ~Nasty() {}
 
     Nasty * operator&() const { assert(false); return nullptr; }
     int i_;
-    };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         const std::vector<int> v;
         assert(v.data() == 0);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
         const std::vector<int> v(100);
#if TEST_STD_VER >= 11
     }
     {
         std::vector<Nasty, min_allocator<Nasty>> v(100);
         assert(v.data() == std::addressof(v.front()));
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp

 #include <vector>
 #include <optional>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class U>
-void test0(S s, U val, S expected, size_t expected_erased_count) {
+TEST_CONSTEXPR_CXX20 void test0(S s, U val, S expected, size_t expected_erased_count) {
   ASSERT_SAME_TYPE(typename S::size_type, decltype(std::erase(s, val)));
   assert(expected_erased_count == std::erase(s, val));
   assert(s == expected);
 }
 
 template <class S>
-void test()
+TEST_CONSTEXPR_CXX20 void test()
 {
-
   test0(S(), 1, S(), 0);
 
   test0(S({1}), 1, S(), 1);
   test0(S({1}), 2, S({1}), 0);
 
   test0(S({1, 2}), 1, S({2}), 1);
   test0(S({1, 2}), 2, S({1}), 1);
   test0(S({1, 2}), 3, S({1, 2}), 0);
TEST_CONSTEXPR_CXX20 void test()
   //  Test cross-type erasure
   using opt = std::optional<typename S::value_type>;
   test0(S({1, 2, 1}), opt(), S({1, 2, 1}), 0);
   test0(S({1, 2, 1}), opt(1), S({2}), 2);
   test0(S({1, 2, 1}), opt(2), S({1, 1}), 1);
   test0(S({1, 2, 1}), opt(3), S({1, 2, 1}), 0);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     test<std::vector<int>>();
     test<std::vector<int, min_allocator<int>>> ();
     test<std::vector<int, test_allocator<int>>> ();
 
     test<std::vector<long>>();
     test<std::vector<double>>();
 
+    return true;
+}
+
+int main(int, char**)
+{
+  tests();
+#if TEST_STD_VER > 17
+  static_assert(tests());
+#endif
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp

 
 #include <vector>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class Pred>
-void test0(S s, Pred p, S expected, size_t expected_erased_count) {
+TEST_CONSTEXPR_CXX20 void test0(S s, Pred p, S expected, size_t expected_erased_count) {
   ASSERT_SAME_TYPE(typename S::size_type, decltype(std::erase_if(s, p)));
   assert(expected_erased_count == std::erase_if(s, p));
   assert(s == expected);
 }
 
 template <typename S>
-void test()
+TEST_CONSTEXPR_CXX20 void test()
 {
     auto is1 = [](auto v) { return v == 1;};
     auto is2 = [](auto v) { return v == 2;};
     auto is3 = [](auto v) { return v == 3;};
     auto is4 = [](auto v) { return v == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
TEST_CONSTEXPR_CXX20 void test()
     test0(S({1, 2, 2}), is1, S({2, 2}), 1);
     test0(S({1, 2, 2}), is2, S({1}), 2);
     test0(S({1, 2, 2}), is3, S({1, 2, 2}), 0);
 
     test0(S({1, 2, 3}), True, S(), 3);
     test0(S({1, 2, 3}), False, S({1, 2, 3}), 0);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     test<std::vector<int>>();
     test<std::vector<int, min_allocator<int>>> ();
     test<std::vector<int, test_allocator<int>>> ();
 
     test<std::vector<long>>();
     test<std::vector<double>>();
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp

 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     int a[] = {1, 2, 3};
     std::vector<int> c(a, a+3);
     ASSERT_NOEXCEPT(c.clear());
     c.clear();
     assert(c.empty());
     LIBCPP_ASSERT(c.__invariants());
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     }
 #if TEST_STD_VER >= 11
     {
     int a[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> c(a, a+3);
     ASSERT_NOEXCEPT(c.clear());
     c.clear();
     assert(c.empty());
     LIBCPP_ASSERT(c.__invariants());
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp

 class A
 {
     int i_;
     double d_;
 
     A(const A&);
     A& operator=(const A&);
 public:
-    A(int i, double d)
+    TEST_CONSTEXPR_CXX14 A(int i, double d)
         : i_(i), d_(d) {}
 
-    A(A&& a)
+    TEST_CONSTEXPR_CXX14 A(A&& a)
         : i_(a.i_),
           d_(a.d_)
     {
         a.i_ = 0;
         a.d_ = 0;
     }
 
-    A& operator=(A&& a)
+    TEST_CONSTEXPR_CXX14 A& operator=(A&& a)
     {
         i_ = a.i_;
         d_ = a.d_;
         a.i_ = 0;
         a.d_ = 0;
         return *this;
     }
 
-    int geti() const {return i_;}
-    double getd() const {return d_;}
+    TEST_CONSTEXPR_CXX14 int geti() const {return i_;}
+    TEST_CONSTEXPR_CXX14 double getd() const {return d_;}
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<A> c;
         std::vector<A>::iterator i = c.emplace(c.cbegin(), 2, 3.5);
         assert(i == c.begin());
         assert(c.size() == 1);
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
TEST_CONSTEXPR_CXX20 bool tests()
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
         assert(c[1].geti() == 4);
         assert(c[1].getd() == 6.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp

 {
     int i_;
     double d_;
 
 public:
     A(const A&) = delete;
     A& operator=(const A&) = delete;
 
-    A(int i, double d)
+    TEST_CONSTEXPR_CXX14 A(int i, double d)
         : i_(i), d_(d) {}
 
-    A(A&& a)
+    TEST_CONSTEXPR_CXX14 A(A&& a)
         : i_(a.i_),
           d_(a.d_)
     {
         a.i_ = 0;
         a.d_ = 0;
     }
 
-    A& operator=(A&& a)
+    TEST_CONSTEXPR_CXX14 A& operator=(A&& a)
     {
         i_ = a.i_;
         d_ = a.d_;
         a.i_ = 0;
         a.d_ = 0;
         return *this;
     }
 
-    int geti() const {return i_;}
-    double getd() const {return d_;}
+    TEST_CONSTEXPR_CXX14 int geti() const {return i_;}
+    TEST_CONSTEXPR_CXX14 double getd() const {return d_;}
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<A> c;
 #if TEST_STD_VER > 14
         A& r1 = c.emplace_back(2, 3.5);
         assert(c.size() == 1);
         assert(&r1 == &c.back());
         assert(c.front().geti() == 2);
#endif
         std::vector<int> c(arr, arr+sz);
         while (c.size() < c.capacity())
             c.push_back(sz++);
         c.emplace_back(c.front());
         assert(c.back() == 0);
         for (int i = 0; i < sz; ++i)
             assert(c[i] == i);
     }
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp

 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     {
         std::vector<int> v;
         v.reserve(3);
         assert(is_contiguous_container_asan_correct(v));
         v = { 1, 2, 3 };
         v.emplace(v.begin(), v.back());
         assert(v[0] == 3);
         assert(is_contiguous_container_asan_correct(v));
TEST_CONSTEXPR_CXX20 bool tests() {
         v.resize(4); // keep the existing capacity
         assert(v.capacity() == old_capacity);
 
         v.emplace(v.cend(), 42);
         assert(v.size() == 5);
         assert(v.capacity() == old_capacity);
         assert(v[4] == 42);
     }
+
+    return true;
+}
+
+int main(int, char**) {
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp

struct Throws {
     Throws& operator=(      Throws &&rhs) { v_ = rhs.v_; return *this; }
     int v_;
     static bool sThrows;
     };
 
 bool Throws::sThrows = false;
 #endif
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     int a1[] = {1, 2, 3, 4, 5};
     std::vector<int> l1(a1, a1+5);
     l1.erase(l1.begin());
     assert(is_contiguous_container_asan_correct(l1));
     assert(l1 == std::vector<int>(a1+1, a1+5));
     }
#if TEST_STD_VER >= 11
     assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
     assert(std::distance(l1.begin(), l1.end()) == 0);
     assert(is_contiguous_container_asan_correct(l1));
     }
 #endif
+
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
 // Test for LWG2853:
 // Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.
     {
         Throws arr[] = {1, 2, 3};
         std::vector<Throws> v(arr, arr+3);
         Throws::sThrows = true;
         v.erase(v.begin());
         v.erase(--v.end());
         v.erase(v.begin());
         assert(v.size() == 0);
     }
 #endif
 
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp

struct Throws {
     Throws& operator=(      Throws &&rhs) { v_ = rhs.v_; return *this; }
     int v_;
     static bool sThrows;
     };
 
 bool Throws::sThrows = false;
 #endif
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     int a1[] = {1, 2, 3};
     {
         std::vector<int> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
         std::vector<int>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
         assert(std::distance(l1.cbegin(), l1.cend()) == 3);
#if TEST_STD_VER >= 11
         assert(outer.size() == 2);
         assert(outer[0].size() == 1);
         assert(outer[1].size() == 1);
         assert(is_contiguous_container_asan_correct(outer));
         assert(is_contiguous_container_asan_correct(outer[0]));
         assert(is_contiguous_container_asan_correct(outer[1]));
     }
 #endif
+
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
 // Test for LWG2853:
 // Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.
     {
         Throws arr[] = {1, 2, 3};
         std::vector<Throws> v(arr, arr+3);
         Throws::sThrows = true;
         v.erase(v.begin(), --v.end());
         assert(v.size() == 1);
         v.erase(v.begin(), v.end());
         assert(v.size() == 0);
     }
 #endif
 
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp

 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
     std::vector<int> d(10, 1);
     std::vector<int>::iterator i = d.insert(d.cbegin() + 2, {3, 4, 5, 6});
     assert(d.size() == 14);
     assert(is_contiguous_container_asan_correct(d));
     assert(i == d.begin() + 2);
     assert(d[0] == 1);
TEST_CONSTEXPR_CXX20 bool tests()
     assert(d[8] == 1);
     assert(d[9] == 1);
     assert(d[10] == 1);
     assert(d[11] == 1);
     assert(d[12] == 1);
     assert(d[13] == 1);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

 #include "min_allocator.h"
 #include "asan_testing.h"
 
 namespace adl {
 struct S {};
 void make_move_iterator(S*) {}
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef std::vector<int> V;
         V v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
         V::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const int*>(a),
                                  cpp17_input_iterator<const int*>(a+N));
#if TEST_STD_VER >= 11
     }
 #endif
 
     {
         std::vector<adl::S> s;
         s.insert(s.end(), cpp17_input_iterator<adl::S*>(nullptr), cpp17_input_iterator<adl::S*>(nullptr));
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_lvalue.pass.cpp

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
+
     {
         std::vector<int> v(100);
         const int lvalue = 1;
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, lvalue);
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
#if TEST_STD_VER >= 11
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < 101; ++j)
             assert(v[j] == 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<MoveOnly> v(100);
         std::vector<MoveOnly>::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
TEST_CONSTEXPR_CXX20 bool tests()
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == MoveOnly());
         assert(v[j] == MoveOnly(3));
         for (++j; j < 101; ++j)
             assert(v[j] == MoveOnly());
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<int> v(100);
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
#if TEST_STD_VER >= 11
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < 105; ++j)
             assert(v[j] == 0);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<int> c;
         c.push_back(1);
         assert(c.size() == 1);
         c.pop_back();
         assert(c.size() == 0);
 
#endif
         while (c.size() < c.capacity())
             c.push_back(sz++);
         c.push_back(c.front());
         assert(c.back() == 0);
         for (int i = 0; i < sz; ++i)
             assert(c[i] == i);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp

 #include <vector>
 #include <cassert>
 #include <cstddef>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<int> c;
         c.push_back(0);
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
#if TEST_STD_VER >= 11
         c.push_back(4);
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp

 #include <cassert>
 #include <cstddef>
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         std::vector<MoveOnly> c;
         c.push_back(MoveOnly(0));
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
TEST_CONSTEXPR_CXX20 bool tests()
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(4));
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.special/swap.pass.cpp

 #include <vector>
 #include <iterator>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::vector<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
#if TEST_STD_VER >= 11
         assert(c1.get_allocator() == A());
         assert((c2 == std::vector<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A());
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER > 17
+    static_assert(tests());
+#endif
     return 0;
 }

libcxx/test/support/allocators.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ALLOCATORS_H
 #define ALLOCATORS_H
 
+#include <memory>
 #include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 
 #if TEST_STD_VER >= 11
 
 template <class T>

 template <class T, bool POCCAValue>
 class MaybePOCCAAllocator {
     int id_ = 0;
     bool* copy_assigned_into_ = nullptr;
 public:
     typedef std::integral_constant<bool, POCCAValue> propagate_on_container_copy_assignment;
     typedef T value_type;
 
-    MaybePOCCAAllocator() = default;
-    MaybePOCCAAllocator(int id, bool* copy_assigned_into)
+    TEST_CONSTEXPR MaybePOCCAAllocator() = default;
+    TEST_CONSTEXPR MaybePOCCAAllocator(int id, bool* copy_assigned_into)
         : id_(id), copy_assigned_into_(copy_assigned_into) {}
 
     MaybePOCCAAllocator(const MaybePOCCAAllocator&) = default;
-    MaybePOCCAAllocator& operator=(const MaybePOCCAAllocator& a)
+    TEST_CONSTEXPR_CXX14 MaybePOCCAAllocator& operator=(const MaybePOCCAAllocator& a)
     {
         id_ = a.id();
         if (copy_assigned_into_)
             *copy_assigned_into_ = true;
         return *this;
     }
 
-    T* allocate(std::size_t n)
+    TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n)
     {
-        return static_cast<T*>(::operator new(n * sizeof(T)));
+        return std::allocator<T>().allocate(n);
     }
 
-    void deallocate(T* ptr, std::size_t)
+    TEST_CONSTEXPR_CXX20 void deallocate(T* ptr, std::size_t n)
     {
-        ::operator delete(ptr);
+        std::allocator<T>().deallocate(ptr, n);
     }
 
-    int id() const { return id_; }
+    TEST_CONSTEXPR int id() const { return id_; }
 
-    friend bool operator==(const MaybePOCCAAllocator& lhs, const MaybePOCCAAllocator& rhs)
+    TEST_CONSTEXPR friend bool operator==(const MaybePOCCAAllocator& lhs, const MaybePOCCAAllocator& rhs)
     {
         return lhs.id() == rhs.id();
     }
 
-    friend bool operator!=(const MaybePOCCAAllocator& lhs, const MaybePOCCAAllocator& rhs)
+    TEST_CONSTEXPR friend bool operator!=(const MaybePOCCAAllocator& lhs, const MaybePOCCAAllocator& rhs)
     {
         return !(lhs == rhs);
     }
 };
 
 template <class T>
 using POCCAAllocator = MaybePOCCAAllocator<T, /*POCCAValue = */true>;
 template <class T>
 using NonPOCCAAllocator = MaybePOCCAAllocator<T, /*POCCAValue = */false>;
 
 #endif // TEST_STD_VER >= 11
 
 #endif // ALLOCATORS_H

libcxx/test/support/asan_testing.h

 
 #include "test_macros.h"
 
 #if TEST_HAS_FEATURE(address_sanitizer)
 extern "C" int __sanitizer_verify_contiguous_container
      ( const void *beg, const void *mid, const void *end );
 
 template <typename T, typename Alloc>
-bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &c )
+TEST_CONSTEXPR bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &c )
 {
-    if ( std::is_same<Alloc, std::allocator<T> >::value && c.data() != NULL)
-        return __sanitizer_verify_contiguous_container (
+    if (std::__libcpp_is_constant_evaluated())
+        return true;
+    if (std::is_same<Alloc, std::allocator<T> >::value && c.data() != NULL)
+        return __sanitizer_verify_contiguous_container(
             c.data(), c.data() + c.size(), c.data() + c.capacity()) != 0;
     return true;
 }
 
 #else
 template <typename T, typename Alloc>
-bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &)
+TEST_CONSTEXPR bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &)
 {
     return true;
 }
 #endif
 
 
 #endif // ASAN_TESTING_H

libcxx/test/support/poisoned_hash_helper.h

 #if TEST_STD_VER < 11
 #error this header may only be used in C++11 or newer
 #endif
 
 template <class ...Args> struct TypeList;
 
 // Test that the specified Hash meets the requirements of an enabled hash
 template <class Hash, class Key, class InputKey = Key>
-void test_hash_enabled(InputKey const& key = InputKey{});
+TEST_CONSTEXPR_CXX20 void test_hash_enabled(InputKey const& key = InputKey{});
 
 template <class T, class InputKey = T>
-void test_hash_enabled_for_type(InputKey const& key = InputKey{}) {
+TEST_CONSTEXPR_CXX20 void test_hash_enabled_for_type(InputKey const& key = InputKey{}) {
   return test_hash_enabled<std::hash<T>, T, InputKey>(key);
 }
 
 // Test that the specified Hash meets the requirements of a disabled hash.
 template <class Hash, class Key>
 void test_hash_disabled();
 
 template <class T>

 }
 template <class Hasher, class Key>
 constexpr bool can_hash() {
   return can_hash<Hasher, Key>(0);
 }
 } // namespace PoisonedHashDetail
 
 template <class Hash, class Key, class InputKey>
-void test_hash_enabled(InputKey const& key) {
+TEST_CONSTEXPR_CXX20 void test_hash_enabled(InputKey const& key) {
   using namespace PoisonedHashDetail;
 
   static_assert(std::is_destructible<Hash>::value, "");
   // Enabled hash requirements
   static_assert(std::is_default_constructible<Hash>::value, "");
   static_assert(std::is_copy_constructible<Hash>::value, "");
   static_assert(std::is_move_constructible<Hash>::value, "");
   static_assert(std::is_copy_assignable<Hash>::value, "");

libcxx/test/support/test_allocator.h

 #include <cstddef>
 #include <cstdlib>
 #include <climits>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class Alloc>
-inline typename std::allocator_traits<Alloc>::size_type alloc_max_size(Alloc const& a) {
+TEST_CONSTEXPR_CXX20 inline typename std::allocator_traits<Alloc>::size_type alloc_max_size(Alloc const& a) {
   typedef std::allocator_traits<Alloc> AT;
   return AT::max_size(a);
 }
 
 struct test_allocator_statistics {
   int time_to_throw = 0;
   int throw_after = INT_MAX;
   int count = 0;
TEST_CONSTEXPR_CXX14 void deallocate(pointer p, size_type s) {
     if (stats_ != nullptr)
       --stats_->alloc_count;
     std::allocator<value_type>().deallocate(p, s);
   }
 
   TEST_CONSTEXPR size_type max_size() const TEST_NOEXCEPT { return UINT_MAX / sizeof(T); }
 
   template <class U>
-  TEST_CONSTEXPR_CXX14 void construct(pointer p, U&& val) {
+  TEST_CONSTEXPR_CXX20 void construct(pointer p, U&& val) {
+#if TEST_STD_VER > 17
+    std::construct_at(std::to_address(p), std::forward<U>(val));
+#else
     ::new (static_cast<void*>(p)) T(std::forward<U>(val));
+#endif
   }
 
   TEST_CONSTEXPR_CXX14 void destroy(pointer p) { p->~T(); }
   TEST_CONSTEXPR friend bool operator==(const test_allocator& x, const test_allocator& y) { return x.data_ == y.data_; }
   TEST_CONSTEXPR friend bool operator!=(const test_allocator& x, const test_allocator& y) { return !(x == y); }
 
   TEST_CONSTEXPR int get_data() const { return data_; }
   TEST_CONSTEXPR int get_id() const { return id_; }

 public:
   using value_type = T;
   TaggingAllocator() = default;
 
   template <typename U>
   TEST_CONSTEXPR TaggingAllocator(const TaggingAllocator<U>&) {}
 
   template <typename... Args>
-  void construct(Tag_X* p, Args&&... args) {
-    ::new ((void*)p) Tag_X(Ctor_Tag(), std::forward<Args>(args)...);
+  TEST_CONSTEXPR_CXX20 void construct(Tag_X* p, Args&&... args) {
+#if TEST_STD_VER > 17
+    std::construct_at(p, Ctor_Tag{}, std::forward<Args>(args)...);
+#else
+    ::new (static_cast<void*>(p)) Tag_X(Ctor_Tag(), std::forward<Args>(args)...);
+#endif
   }
 
   template <typename U>
-  void destroy(U* p) {
+  TEST_CONSTEXPR_CXX20 void destroy(U* p) {
     p->~U();
   }
 
   TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n) { return std::allocator<T>().allocate(n); }
   TEST_CONSTEXPR_CXX20 void deallocate(T* p, std::size_t n) { std::allocator<T>().deallocate(p, n); }
 };
 
 template <std::size_t MaxAllocs>
 struct limited_alloc_handle {
   std::size_t outstanding_ = 0;
   void* last_alloc_ = nullptr;
 
   template <class T>
   TEST_CONSTEXPR_CXX20 T* allocate(std::size_t N) {
     if (N + outstanding_ > MaxAllocs)
       TEST_THROW(std::bad_alloc());
-    last_alloc_ = std::allocator<T>().allocate(N);
+    auto alloc = std::allocator<T>().allocate(N);
+    last_alloc_ = alloc;
     outstanding_ += N;
-    return static_cast<T*>(last_alloc_);
+    return alloc;
   }
 
   template <class T>
   TEST_CONSTEXPR_CXX20 void deallocate(T* ptr, std::size_t N) {
     if (ptr == last_alloc_) {
       last_alloc_ = nullptr;
       assert(outstanding_ >= N);
       outstanding_ -= N;