[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

1390–1401

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

1748

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

1984

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.

2102

I believe the inline is superfluous with the _LIBCPP_CONSTEXPR_AFTER_CXX17

Appears throughout

libcxx/include/vector

422

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

1390–1401

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?

1984

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

422

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–361 ↗

(On Diff #436255)

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 ↗

(On Diff #436255)

Why is this required?

958–961 ↗

(On Diff #436255)

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 ↗

(On Diff #436255)

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

49 ↗

(On Diff #436255)

Let's add the _LIBCPP_ASSERT here too.

libcxx/include/__utility/move.h

40–49 ↗

(On Diff #436255)

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

libcxx/include/memory

1738

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?

1745–1749

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.

1750

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

1776–1777

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

[philnik]

• Address comments

[philnik]

libcxx/include/__bit_reference

503 ↗

(On Diff #436255)

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

libcxx/include/memory

1776–1777

Just for reference, this is D128146 now.

[var-const]

libcxx/include/__bit_reference

358–361 ↗

(On Diff #436255)

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

388 ↗

(On Diff #440151)

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

1840

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

1950

What happens if we remove this condition?

[philnik]

• Address comments

libcxx/include/vector

1840

It still complains that the pointers are unrelated.

1950

Here it also complains about comparing unrelated pointers.

[ldionne]

libcxx/include/__bit_reference

388 ↗

(On Diff #440151)

Marked as done, but not done?

libcxx/include/vector

1950

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–361 ↗

(On Diff #436255)

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

libcxx/include/vector

554

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

799

is this function actually constexpr-able?

[philnik]

Rebased

libcxx/include/vector

554

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

799

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

[ldionne]

libcxx/include/__bit_reference

358–361 ↗

(On Diff #436255)

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/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_, std::distance(__first, __last));
     for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, ++__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(), __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(), __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)
 {
     __first_ = __cap != 0 ? __alloc_traits::allocate(__alloc(), __cap) : nullptr;
     __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_ + __cap;
         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());
     __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/algorithm

 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
 __copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     return __copy_constexpr(__first, __last, __result);
 }
 
 template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
     is_trivially_copy_assignable<_Up>::value,
     _Up*
 >::type
 __copy(_Tp* __first, _Tp* __last, _Up* __result)
 {

 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
 __copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
 {
     return __copy_backward_constexpr(__first, __last, __result);
 }
 
 template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
     is_trivially_copy_assignable<_Up>::value,
     _Up*
 >::type
 __copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
 {

libcxx/include/memory

template <> struct __to_address_helper<false> {
     using __return_type = typename pointer_traits<_Pointer>::element_type*;
 
     template <class _Pointer>
     _LIBCPP_CONSTEXPR
     static __return_type<_Pointer>
     __do_it(const _Pointer &__p) _NOEXCEPT { return std::__to_address(__p.operator->()); }
 };
 
-
 #if _LIBCPP_STD_VER > 17
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY constexpr
 _Tp*
 to_address(_Tp* __p) _NOEXCEPT
 {
     static_assert(!is_function_v<_Tp>, "_Tp is a function type");
     return __p;

 template <class _Alloc>
 struct __is_cpp17_copy_insertable<_Alloc, true> : __is_cpp17_move_insertable<_Alloc> {};
 template <class _Alloc>
 struct __is_cpp17_copy_insertable<_Alloc, false> : integral_constant<bool,
     std::is_copy_constructible<typename _Alloc::value_type>::value &&
     __is_cpp17_move_insertable<_Alloc>::value>
   {};
 
-
+template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
+_Tp* __libcpp_memcpy(_Tp* __dest, _Tp const* __src, std::size_t __count) {
+    if (__libcpp_is_constant_evaluated()) {
+        for (std::size_t __n = 0; __n != __count; ++__n)
+            __dest[__n] = __src[__n];
+    } else {
+        _VSTD::memcpy(__dest, __src, __count);
+    }
+    return __dest + __count;
+}
 
 template <class _Alloc>
 struct _LIBCPP_TEMPLATE_VIS allocator_traits
 {
     typedef _Alloc                              allocator_type;
     typedef typename allocator_type::value_type value_type;
 
     typedef typename __pointer_type<value_type, allocator_type>::type pointer;
     typedef typename __const_pointer<value_type, pointer, allocator_type>::type const_pointer;

 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;}
 
 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;}
 
 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 Cpp17MoveInsertible");
     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
         );
     }
 }
 
 template <class _Alloc, class _Tp, 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_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));
+        _VSTD::__libcpp_memcpy(__begin2, __begin1, _Np * sizeof(_Tp));
         __begin2 += _Np;
     }
 }
 
 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) {
         _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<
         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));
+        _VSTD::__libcpp_memcpy(const_cast<_RawDest*>(__begin2), __begin1, _Np * sizeof(_Dest));
         __begin2 += _Np;
     }
 }
 
 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
         );
         --__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(__end2, __begin1, _Np * sizeof(_Tp));
+        _VSTD::__libcpp_memcpy(__end2, __begin1, _Np * sizeof(_Tp));
 }
 
 template <class _OutputIterator, class _Tp>
 class _LIBCPP_TEMPLATE_VIS raw_storage_iterator
     : public iterator<output_iterator_tag,
                       _Tp,                                         // purposefully not C++03
                       ptrdiff_t,                                   // purposefully not C++03
                       _Tp*,                                        // purposefully not C++03

 #ifndef _LIBCPP_CXX03_LANG
   template <class... _Args, size_t... _Indexes>
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
   __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args,
                          __tuple_indices<_Indexes...>)
       : __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
 #endif
 
-
-  _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return __value_; }
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+  reference __get() _NOEXCEPT { return __value_; }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
   const_reference __get() const _NOEXCEPT { return __value_; }
 
 private:
   _Tp __value_;
 };
 
 template <class _Tp, int _Idx>
 struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {

 #ifndef _LIBCPP_CXX03_LANG
   template <class... _Args, size_t... _Indexes>
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
   __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args,
                          __tuple_indices<_Indexes...>)
       : __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
 #endif
 
-  _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return *this; }
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+  reference __get() _NOEXCEPT { return *this; }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
   const_reference __get() const _NOEXCEPT { return *this; }
 };
 
 template <class _T1, class _T2>
 class __compressed_pair : private __compressed_pair_elem<_T1, 0>,
                           private __compressed_pair_elem<_T2, 1> {
   typedef _LIBCPP_NODEBUG_TYPE __compressed_pair_elem<_T1, 0> _Base1;
   typedef _LIBCPP_NODEBUG_TYPE __compressed_pair_elem<_T2, 1> _Base2;
#ifndef _LIBCPP_CXX03_LANG
   __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
                     tuple<_Args2...> __second_args)
       : _Base1(__pc, _VSTD::move(__first_args),
                typename __make_tuple_indices<sizeof...(_Args1)>::type()),
         _Base2(__pc, _VSTD::move(__second_args),
                typename __make_tuple_indices<sizeof...(_Args2)>::type()) {}
 #endif
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
   typename _Base1::reference first() _NOEXCEPT {
     return static_cast<_Base1&>(*this).__get();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
   typename _Base1::const_reference first() const _NOEXCEPT {
     return static_cast<_Base1 const&>(*this).__get();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
   typename _Base2::reference second() _NOEXCEPT {
     return static_cast<_Base2&>(*this).__get();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
   typename _Base2::const_reference second() const _NOEXCEPT {
     return static_cast<_Base2 const&>(*this).__get();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
   void swap(__compressed_pair& __x)
     _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                __is_nothrow_swappable<_T2>::value)
   {
     using std::swap;
     swap(first(), __x.first());
     swap(second(), __x.second());
   }
 };
 
 template <class _T1, class _T2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y)
     _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                __is_nothrow_swappable<_T2>::value) {
   __x.swap(__y);
 }
 
 // default_delete
 

 {
     return static_cast<_Tp*>(__undeclare_reachable(__p));
 }
 
 _LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
 
 // --- Helper for container swap --
 template <typename _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
 #endif
 {
     __swap_allocator(__a1, __a2,
       integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>());
 }
 
 template <typename _Alloc>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
 #endif
 {
     using _VSTD::swap;
     swap(__a1, __a2);
 }
 
 template <typename _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {}
 
 template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
 struct __noexcept_move_assign_container : public integral_constant<bool,
     _Traits::propagate_on_container_move_assignment::value
 #if _LIBCPP_STD_VER > 14
         || _Traits::is_always_equal::value
 #else

libcxx/include/vector

 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <bool>
 class _LIBCPP_TEMPLATE_VIS __vector_base_common
 {
 protected:
-    _LIBCPP_INLINE_VISIBILITY __vector_base_common() {}
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY __vector_base_common() {}
     _LIBCPP_NORETURN void __throw_length_error() const;
     _LIBCPP_NORETURN void __throw_out_of_range() const;
 };
 
 template <bool __b>
 void
 __vector_base_common<__b>::__throw_length_error() const
 {
protected:
     typedef typename __alloc_traits::const_pointer   const_pointer;
     typedef pointer                                  iterator;
     typedef const_pointer                            const_iterator;
 
     pointer                                         __begin_;
     pointer                                         __end_;
     __compressed_pair<pointer, allocator_type> __end_cap_;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     allocator_type& __alloc() _NOEXCEPT
         {return __end_cap_.second();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     const allocator_type& __alloc() const _NOEXCEPT
         {return __end_cap_.second();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     pointer& __end_cap() _NOEXCEPT
         {return __end_cap_.first();}
-    _LIBCPP_INLINE_VISIBILITY
+    _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
     __vector_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
-    _LIBCPP_INLINE_VISIBILITY __vector_base(const allocator_type& __a);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY __vector_base(const allocator_type& __a);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY __vector_base(allocator_type&& __a) _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY __vector_base(allocator_type&& __a) _NOEXCEPT;
 #endif
-    ~__vector_base();
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 ~__vector_base();
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT {__destruct_at_end(__begin_);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     size_type capacity() const _NOEXCEPT
         {return static_cast<size_type>(__end_cap() - __begin_);}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __destruct_at_end(pointer __new_last) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __vector_base& __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_base& __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>());}
 private:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __vector_base& __c, true_type)
         {
             if (__alloc() != __c.__alloc())
             {
                 clear();
                 __alloc_traits::deallocate(__alloc(), __begin_, capacity());
                 __begin_ = __end_ = __end_cap() = nullptr;
             }
             __alloc() = __c.__alloc();
         }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __vector_base&, false_type)
         {}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__vector_base& __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_base&, false_type)
         _NOEXCEPT
         {}
 };
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
 void
 __vector_base<_Tp, _Allocator>::__destruct_at_end(pointer __new_last) _NOEXCEPT
 {
     pointer __soon_to_be_end = __end_;
     while (__new_last != __soon_to_be_end)
         __alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__soon_to_be_end));
     __end_ = __new_last;
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
 __vector_base<_Tp, _Allocator>::__vector_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __begin_(nullptr),
       __end_(nullptr),
       __end_cap_(nullptr, __default_init_tag())
 {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
 __vector_base<_Tp, _Allocator>::__vector_base(const allocator_type& __a)
     : __begin_(nullptr),
       __end_(nullptr),
       __end_cap_(nullptr, __a)
 {
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
 __vector_base<_Tp, _Allocator>::__vector_base(allocator_type&& __a) _NOEXCEPT
     : __begin_(nullptr),
       __end_(nullptr),
       __end_cap_(nullptr, std::move(__a)) {}
 #endif
 
 template <class _Tp, class _Allocator>
-__vector_base<_Tp, _Allocator>::~__vector_base()
+_LIBCPP_CONSTEXPR_AFTER_CXX17 __vector_base<_Tp, _Allocator>::~__vector_base()
 {
     if (__begin_ != nullptr)
     {
         clear();
         __alloc_traits::deallocate(__alloc(), __begin_, capacity());
     }
 }
 
public:
     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)
         {
 #if _LIBCPP_DEBUG_LEVEL == 2
             __get_db()->__insert_c(this);
 #endif
         }
-    _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
         : __base(__a)
     {
 #if _LIBCPP_DEBUG_LEVEL == 2
         __get_db()->__insert_c(this);
 #endif
     }
-    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);
-    vector(size_type __n, const value_type& __x, const allocator_type& __a);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(size_type __n, const value_type& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(size_type __n, const value_type& __x, const allocator_type& __a);
     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();
 #if _LIBCPP_DEBUG_LEVEL == 2
         __get_db()->__erase_c(this);
 #endif
     }
 
-    vector(const vector& __x);
-    vector(const vector& __x, const allocator_type& __a);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(const vector& __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 vector(const vector& __x, const 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(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 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));
 
-    _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
 
     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 __base::capacity();}
-    _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 for 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 for 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 for 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 for 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_);}
 
 #ifdef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __emplace_back(const value_type& __x) { push_back(__x); }
 #else
     template <class _Arg>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     void __emplace_back(_Arg&& __arg) {
       emplace_back(_VSTD::forward<_Arg>(__arg));
     }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _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
 #endif // !_LIBCPP_CXX03_LANG
 
-    _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);
 
 #ifndef _LIBCPP_CXX03_LANG
-    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);
 #endif  // !_LIBCPP_CXX03_LANG
 
-    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();
         __base::clear();
         __annotate_shrink(__old_size);
         __invalidate_all_iterators();
     }
 
-    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;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __dereferenceable(const const_iterator* __i) const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __decrementable(const const_iterator* __i) const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
 
 #endif  // _LIBCPP_DEBUG_LEVEL == 2
 
 private:
-    _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
-    _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(pointer __new_last);
-    void __vallocate(size_type __n);
-    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 _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(pointer __new_last);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __vallocate(size_type __n);
+    _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
     {
         __invalidate_iterators_past(__new_last);
         size_type __old_size = size();
         __base::__destruct_at_end(__new_last);
         __annotate_shrink(__old_size);
     }
 
 #ifndef _LIBCPP_CXX03_LANG
     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);
 #else
     template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     inline void __push_back_slow_path(_Up& __x);
 #endif
 
     // 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)
         __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 {
-    explicit _ConstructTransaction(vector &__v, size_type __n)
+    explicit _LIBCPP_CONSTEXPR_AFTER_CXX17 _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_;
   }
 };
 
template<class _InputIterator,
          class _Alloc,
          class = typename enable_if<__is_allocator<_Alloc>::value, void>::type
          >
 vector(_InputIterator, _InputIterator, _Alloc)
   -> vector<typename iterator_traits<_InputIterator>::value_type, _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();
     __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());
     __invalidate_all_iterators();
 }
 
 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_;
     __construct_backward_with_exception_guarantees(this->__alloc(), this->__begin_, __p, __v.__begin_);
     __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());
     __invalidate_all_iterators();
     return __r;
 }
 
 //  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
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 vector<_Tp, _Allocator>::__vallocate(size_type __n)
 {
     if (__n > max_size())
         this->__throw_length_error();
     this->__begin_ = this->__end_ = __alloc_traits::allocate(this->__alloc(), __n);
     this->__end_cap() = this->__begin_ + __n;
     __annotate_new(0);
 }
 
 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; ++__pos, __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; ++__pos, __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);
     __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)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     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)
     : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     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)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, __x);
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 vector<_Tp, _Allocator>::vector(size_type __n, const value_type& __x, const allocator_type& __a)
     : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     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)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     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*)
     : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     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)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     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*)
     : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     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)
     : __base(__alloc_traits::select_on_container_copy_construction(__x.__alloc()))
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     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 allocator_type& __a)
     : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     size_type __n = __x.size();
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__x.__begin_, __x.__end_, __n);
     }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 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
     : __base(_VSTD::move(__x.__alloc()))
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
     __get_db()->swap(this, &__x);
 #endif
     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 allocator_type& __a)
     : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     if (__a == __x.__alloc())
#endif
     else
     {
         typedef move_iterator<iterator> _Ip;
         assign(_Ip(__x.begin()), _Ip(__x.end()));
     }
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     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)
     : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     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<_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 (__base::__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();
     __base::__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;
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->swap(this, &__c);
 #endif
 }
 
 #endif  // !_LIBCPP_CXX03_LANG
 
 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 != &__x)
     {
         __base::__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);
     }
     __invalidate_all_iterators();
 }
 
 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);
     }
     __invalidate_all_iterators();
 }
 
 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())
     {
         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
 #ifndef _LIBCPP_CXX03_LANG
 vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x)
 #else
 vector<_Tp, _Allocator>::__push_back_slow_path(_Up& __x)
 #endif
 {
     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);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 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
 }
 
 #endif  // !_LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline
 void
 vector<_Tp, _Allocator>::pop_back()
 {
     _LIBCPP_ASSERT(!empty(), "vector::pop_back called for 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)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
         "vector::erase(iterator) called with an iterator not"
         " referring to this vector");
 #endif
     _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);
     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)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
         "vector::erase(iterator,  iterator) called with an iterator not"
         " referring to this vector");
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__last) == this,
         "vector::erase(iterator,  iterator) called with an iterator not"
         " referring to this vector");
 #endif
     _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));
         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, ++__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)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
         "vector::insert(iterator, x) called with an iterator not"
         " referring to this vector");
 #endif
     pointer __p = this->__begin_ + (__position - begin());
     if (this->__end_ < this->__end_cap())
     {
         if (__p == this->__end_)
         {
             __construct_one_at_end(__x);
         }
         else
         {
             __move_range(__p, this->__end_, __p + 1);
else
         __p = __swap_out_circular_buffer(__v, __p);
     }
     return __make_iter(__p);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
         "vector::insert(iterator, x) called with an iterator not"
         " referring to this vector");
 #endif
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)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
         "vector::emplace(iterator, x) called with an iterator not"
         " referring to this vector");
 #endif
else
         __p = __swap_out_circular_buffer(__v, __p);
     }
     return __make_iter(__p);
 }
 
 #endif  // !_LIBCPP_CXX03_LANG
 
 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)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
         "vector::insert(iterator, n, x) called with an iterator not"
         " referring to this vector");
 #endif
     pointer __p = this->__begin_ + (__position - begin());
     if (__n > 0)
     {
         if (__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());
     __swap_allocator(this->__alloc(), __x.__alloc(),
         integral_constant<bool,__alloc_traits::propagate_on_container_swap::value>());
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->swap(this, &__x);
 #endif
 }
 
 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;
     }
     else
     {
         if (this->__begin_ > this->__end_)
             return false;
         if (this->__begin_ == this->__end_cap())
             return false;
         if (this->__end_ > this->__end_cap())
             return false;
     }
     return true;
 }
 
 #if _LIBCPP_DEBUG_LEVEL == 2
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 vector<_Tp, _Allocator>::__dereferenceable(const const_iterator* __i) const
 {
     return this->__begin_ <= __i->base() && __i->base() < this->__end_;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 vector<_Tp, _Allocator>::__decrementable(const const_iterator* __i) const
 {
     return this->__begin_ < __i->base() && __i->base() <= this->__end_;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 vector<_Tp, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
 {
     const_pointer __p = __i->base() + __n;
     return this->__begin_ <= __p && __p <= this->__end_;
 }
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 vector<_Tp, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
 {
     const_pointer __p = __i->base() + __n;
     return this->__begin_ <= __p && __p < this->__end_;
 }
 
 #endif  // _LIBCPP_DEBUG_LEVEL == 2
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::__invalidate_all_iterators()
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__invalidate_all(this);
 #endif
 }
 
 
 template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::__invalidate_iterators_past(pointer __new_last) {
 #if _LIBCPP_DEBUG_LEVEL == 2
   __c_node* __c = __get_db()->__find_c_and_lock(this);
   for (__i_node** __p = __c->end_; __p != __c->beg_; ) {
     --__p;
     const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
struct _LIBCPP_TEMPLATE_VIS hash<vector<bool, _Allocator> >
     : public unary_function<vector<bool, _Allocator>, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     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();
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_VECTOR

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/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 do_checks(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> >(input_iterator<const bool*>(a), 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);
+    do_checks<std::vector<bool> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an));
+    do_checks<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
+    do_checks<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
+    do_checks<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
+    do_checks<std::vector<bool> >(a, an);
 #if TEST_STD_VER >= 11
-    test<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), 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);
+    do_checks<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an));
+    do_checks<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
+    do_checks<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
+    do_checks<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
+    do_checks<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 do_checks(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> >(input_iterator<const bool*>(a), 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);
+    do_checks<std::vector<bool> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an), alloc);
+    do_checks<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc);
+    do_checks<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc);
+    do_checks<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
+    do_checks<std::vector<bool> >(a, an, alloc);
     }
 #if TEST_STD_VER >= 11
     {
     min_allocator<bool> alloc;
-    test<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), 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);
+    do_checks<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an), alloc);
+    do_checks<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc);
+    do_checks<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc);
+    do_checks<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
+    do_checks<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 do_checks(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);
+    do_checks<std::vector<bool> >(50, true);
 #if TEST_STD_VER >= 11
-    test<std::vector<bool, min_allocator<bool>> >(50, true);
+    do_checks<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 do_checks(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>());
+    do_checks<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>());
+    do_checks<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 do_checks(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));
+        do_checks(std::vector<bool>(a, an));
     }
     {
         std::vector<bool, test_allocator<bool> > v(3, true, test_allocator<bool>(5));
         std::vector<bool, test_allocator<bool> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<bool, other_allocator<bool> > v(3, true, other_allocator<bool>(5));
         std::vector<bool, other_allocator<bool> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == other_allocator<bool>(-2));
     }
     {
         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, min_allocator<bool>>(a, an));
+        do_checks(std::vector<bool, min_allocator<bool>>(a, an));
     }
     {
         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 do_checks(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>());
+        do_checks(std::vector<bool>(a, an), std::allocator<bool>());
     }
     {
         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));
         assert(l2 == l);
         assert(l2.get_allocator() == test_allocator<bool>(3));
     }
     {
         std::vector<bool, other_allocator<bool> > l(3, true, other_allocator<bool>(5));
         std::vector<bool, other_allocator<bool> > l2(l, other_allocator<bool>(3));
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<bool>(3));
     }
 #if TEST_STD_VER >= 11
     {
         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, min_allocator<bool>>(a, an), min_allocator<bool>());
+        do_checks(std::vector<bool, min_allocator<bool>>(a, an), min_allocator<bool>());
     }
     {
         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 0;
 }
+
+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/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(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(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(), next(l1.cbegin(), 3));
         assert(l1.size() == 0);
         assert(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/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, input_iterator<const bool*>(a),
                                         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()
 {
     {
         typedef bool 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.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()
 {
     {
         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(true);
             lo.push_back(true);
TEST_CONSTEXPR_CXX20 bool tests()
       }
       {
         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/reserve.pass.cpp

 // void reserve(size_type n);
 
 #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;
         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
 
+    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 "min_allocator.h"
 #include "test_macros.h"
 
 template <class C>
-C
-make(int size, int start = 0)
+TEST_CONSTEXPR_CXX20 C make(int size, int start = 0)
 {
     C c;
     for (int i = 0; i < size; ++i)
         c.push_back(start + i);
     return c;
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef std::vector<int> C;
         C c = make<C>(10);
         LIBCPP_ASSERT_NOEXCEPT(c[0]);
         LIBCPP_ASSERT_NOEXCEPT(c.front());
         LIBCPP_ASSERT_NOEXCEPT(c.back());
         // at() is NOT noexcept
#if TEST_STD_VER >= 11
             assert(c[i] == N + i);
         for (int i = 0; i < 10; ++i)
             assert(c.at(i) == N + i);
         assert(c.front() == N);
         assert(c.back() == N + 9);
     }
 #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/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/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/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 "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);
#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
 
+    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));
#if TEST_STD_VER >= 11
         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

 // 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<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));
     }
     {
         std::vector<int, other_allocator<int> > l(3, 2, other_allocator<int>(5));
         std::vector<int, other_allocator<int> > l2(l, other_allocator<int>(3));
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(5));
     }
 #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 do_checks(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);
+        do_checks(d1);
+        do_checks(d2);
     }
     {
         typedef std::vector<int, min_allocator<int>> V;
         V d1;
         V d2;
         d2.reserve(10);  // no reallocation during assign.
-    test(d1);
-    test(d2);
-    }
+        do_checks(d1);
+        do_checks(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_emplaceable_concept() {
+TEST_CONSTEXPR_CXX20 bool test_emplaceable_concept() {
 #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;
using It = input_iterator<int*>;
       assert(v[0].value == 1);
       //assert(v[1].copied == 0);
       assert(v[1].value == 101);
       assert(v[2].copied == 0);
       assert(v[2].value == 42);
     }
   }
 #endif
-}
-
 
+  return true;
+}
 
 int main(int, char**)
 {
     test_emplaceable_concept();
 
+#if TEST_STD_VER > 17
+    static_assert(test_emplaceable_concept());
+#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 do_checks(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);
+        do_checks(d1);
+        do_checks(d2);
     }
 
 #if TEST_STD_VER >= 11
     {
         typedef std::vector<int, min_allocator<int>> V;
         V d1;
         V d2;
         d2.reserve(10);  // no reallocation during assign.
-    test(d1);
-    test(d2);
+        do_checks(d1);
+        do_checks(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 do_checks(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);
 }
 
-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> >(input_iterator<const int*>(a),
+  do_checks<std::vector<int> >(input_iterator<const int*>(a),
                                input_iterator<const int*>(an));
-  test<std::vector<int> >(forward_iterator<const int*>(a),
+  do_checks<std::vector<int> >(forward_iterator<const int*>(a),
                                forward_iterator<const int*>(an));
-  test<std::vector<int> >(bidirectional_iterator<const int*>(a),
+  do_checks<std::vector<int> >(bidirectional_iterator<const int*>(a),
                                bidirectional_iterator<const int*>(an));
-  test<std::vector<int> >(random_access_iterator<const int*>(a),
+  do_checks<std::vector<int> >(random_access_iterator<const int*>(a),
                                random_access_iterator<const int*>(an));
-  test<std::vector<int> >(a, an);
+  do_checks<std::vector<int> >(a, an);
 
-  test<std::vector<int, limited_allocator<int, 63> > >(
+  do_checks<std::vector<int, limited_allocator<int, 63> > >(
       input_iterator<const int*>(a), input_iterator<const int*>(an));
   // Add 1 for implementations that dynamically allocate a container proxy.
-  test<std::vector<int, limited_allocator<int, 18 + 1> > >(
+  do_checks<std::vector<int, limited_allocator<int, 18 + 1> > >(
       forward_iterator<const int*>(a), forward_iterator<const int*>(an));
-  test<std::vector<int, limited_allocator<int, 18 + 1> > >(
+  do_checks<std::vector<int, limited_allocator<int, 18 + 1> > >(
       bidirectional_iterator<const int*>(a),
       bidirectional_iterator<const int*>(an));
-  test<std::vector<int, limited_allocator<int, 18 + 1> > >(
+  do_checks<std::vector<int, limited_allocator<int, 18 + 1> > >(
       random_access_iterator<const int*>(a),
       random_access_iterator<const int*>(an));
-  test<std::vector<int, limited_allocator<int, 18 + 1> > >(a, an);
+  do_checks<std::vector<int, limited_allocator<int, 18 + 1> > >(a, an);
 #if TEST_STD_VER >= 11
-  test<std::vector<int, min_allocator<int> > >(input_iterator<const int*>(a),
+  do_checks<std::vector<int, min_allocator<int> > >(input_iterator<const int*>(a),
                                                     input_iterator<const int*>(an));
-  test<std::vector<int, min_allocator<int> > >(
+  do_checks<std::vector<int, min_allocator<int> > >(
       forward_iterator<const int*>(a), forward_iterator<const int*>(an));
-  test<std::vector<int, min_allocator<int> > >(
+  do_checks<std::vector<int, min_allocator<int> > >(
       bidirectional_iterator<const int*>(a),
       bidirectional_iterator<const int*>(an));
-  test<std::vector<int, min_allocator<int> > >(
+  do_checks<std::vector<int, min_allocator<int> > >(
       random_access_iterator<const int*>(a),
       random_access_iterator<const int*>(an));
-  test<std::vector<int> >(a, an);
+  do_checks<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)));
using It = input_iterator<int*>;
       assert(v[1].value == 101);
       assert(v[2].copied == 0);
       assert(v[2].value == 42);
     }
   }
 #endif
 }
 
-void test_ctor_under_alloc() {
+TEST_CONSTEXPR_CXX20 void test_ctor_under_alloc() {
 #if TEST_STD_VER >= 11
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
     using C = TCT::vector<>;
     using It = forward_iterator<int*>;
     {
       ExpectConstructGuard<int&> G(1);

 }
 
 // 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};
 #ifdef TEST_COMPILER_C1XX
     #pragma warning(push)
     #pragma warning(disable: 4244) // conversion from 'float' to 'int', possible loss of data
 #endif // TEST_COMPILER_C1XX
#endif // TEST_COMPILER_C1XX
     // 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();
+#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 do_checks(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*) {}
+  TEST_CONSTEXPR_CXX20 implicit_conv_allocator(void*) {}
   implicit_conv_allocator(const implicit_conv_allocator&) = default;
 
   template <class U>
-  implicit_conv_allocator(implicit_conv_allocator<U>) {}
+  TEST_CONSTEXPR_CXX20 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> >(input_iterator<const int*>(a),
+    do_checks<std::vector<int> >(input_iterator<const int*>(a),
                                  input_iterator<const int*>(an), alloc);
-    test<std::vector<int> >(forward_iterator<const int*>(a),
+    do_checks<std::vector<int> >(forward_iterator<const int*>(a),
                                  forward_iterator<const int*>(an), alloc);
-    test<std::vector<int> >(bidirectional_iterator<const int*>(a),
+    do_checks<std::vector<int> >(bidirectional_iterator<const int*>(a),
                                  bidirectional_iterator<const int*>(an), alloc);
-    test<std::vector<int> >(random_access_iterator<const int*>(a),
+    do_checks<std::vector<int> >(random_access_iterator<const int*>(a),
                                  random_access_iterator<const int*>(an), alloc);
-    test<std::vector<int> >(a, an, alloc);
+    do_checks<std::vector<int> >(a, an, alloc);
   }
 #if TEST_STD_VER >= 11
   {
     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]);
     min_allocator<int> alloc;
-    test<std::vector<int, min_allocator<int> > >(
+    do_checks<std::vector<int, min_allocator<int> > >(
         input_iterator<const int*>(a), input_iterator<const int*>(an), alloc);
-    test<std::vector<int, min_allocator<int> > >(
+    do_checks<std::vector<int, min_allocator<int> > >(
         forward_iterator<const int*>(a), forward_iterator<const int*>(an),
         alloc);
-    test<std::vector<int, min_allocator<int> > >(
+    do_checks<std::vector<int, min_allocator<int> > >(
         bidirectional_iterator<const int*>(a),
         bidirectional_iterator<const int*>(an), alloc);
-    test<std::vector<int, min_allocator<int> > >(
+    do_checks<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);
+    do_checks<std::vector<int, min_allocator<int> > >(a, an, alloc);
+    do_checks<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;
Alloc a;
       assert(v[1].value == 101);
       assert(v[2].copied == 0);
       assert(v[2].value == 42);
     }
   }
 #endif
 }
 
-void test_ctor_under_alloc() {
+TEST_CONSTEXPR_CXX20 void test_ctor_under_alloc() {
 #if TEST_STD_VER >= 11
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
     using C = TCT::vector<>;
     using It = forward_iterator<int*>;
     using Alloc = typename C::allocator_type;
     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 tests() {
   basic_tests();
   emplaceable_concept_tests(); // See PR34898
   test_ctor_under_alloc();
 
+  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.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>
 
 // explicit vector(size_type n);
+// explicit vector(size_type n, const Allocator& alloc = Allocator());
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
-void
-test2(typename C::size_type n, typename C::allocator_type const& a = typename C::allocator_type ())
+TEST_CONSTEXPR_CXX20
+void test(typename C::size_type n,
+          typename C::allocator_type const& a = typename C::allocator_type())
 {
-#if TEST_STD_VER >= 14
-    C c(n, a);
+    // Test without a custom allocator
+    {
+        C c(n);
         LIBCPP_ASSERT(c.__invariants());
         assert(c.size() == n);
-    assert(c.get_allocator() == a);
+        assert(c.get_allocator() == typename C::allocator_type());
         LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+#if TEST_STD_VER >= 11
         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 with a custom allocator
+#if TEST_STD_VER >= 14
     {
-    C c(n);
+        C c(n, a);
         LIBCPP_ASSERT(c.__invariants());
         assert(c.size() == n);
-    assert(c.get_allocator() == typename C::allocator_type());
+        assert(c.get_allocator() == a);
         LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
-#if TEST_STD_VER >= 11
         for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
             assert(*i == typename C::value_type());
-#endif
     }
-
-template <class C>
-void
-test(typename C::size_type n)
-{
-    test1<C> ( n );
-    test2<C> ( n );
+#endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool tests() {
     test<std::vector<int> >(50);
     test<std::vector<DefaultOnly> >(500);
     assert(DefaultOnly::count == 0);
 #if TEST_STD_VER >= 11
-    test<std::vector<int, min_allocator<int>> >(50);
-    test<std::vector<DefaultOnly, min_allocator<DefaultOnly>> >(500);
-    test2<std::vector<DefaultOnly, test_allocator<DefaultOnly>> >( 100, test_allocator<DefaultOnly>(23));
+    test<std::vector<int, min_allocator<int> > >(50);
+    test<std::vector<DefaultOnly, min_allocator<DefaultOnly> > >(500);
+    test<std::vector<DefaultOnly, test_allocator<DefaultOnly> > >(100, test_allocator<DefaultOnly>(23));
     assert(DefaultOnly::count == 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.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> >(50, 3);
     // Add 1 for implementations that dynamically allocate a container proxy.
     test<std::vector<int, limited_allocator<int, 50 + 1> > >(50, 5);
 #if TEST_STD_VER >= 11
     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> >(50, 3, std::allocator<int>());
 #if TEST_STD_VER >= 11
     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

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 <climits> // INT_MAX
 
 #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)));
//  A couple of vector<bool> tests, too!
     {
     std::vector<bool> source;
     std::vector vec(source); // vector(vector &)
     static_assert(std::is_same_v<decltype(vec)::value_type, bool>, "");
     static_assert(std::is_same_v<decltype(vec)::allocator_type, std::allocator<bool>>, "");
     assert(vec.size() == 0);
     }
 
+    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&);
 };
 
-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

 template <class T>
 struct some_alloc
 {
     typedef T value_type;
     some_alloc(const some_alloc&);
     ~some_alloc() noexcept(false);
 };
 
-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);
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
     {
     std::vector<int, min_allocator<int>> d({3, 4, 5, 6}, min_allocator<int>());
     assert(d.get_allocator() == min_allocator<int>());
     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/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()
 {
     {
         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()
       }
       {
         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 ~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 ~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 check_erase(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 do_checks()
 {
+    check_erase(S(), 1, S(), 0);
 
-  test0(S(), 1, S(), 0);
+    check_erase(S({1}), 1, S(), 1);
+    check_erase(S({1}), 2, S({1}), 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);
-  test0(S({1, 1}), 1, S(), 2);
-  test0(S({1, 1}), 3, S({1, 1}), 0);
-
-  test0(S({1, 2, 3}), 1, S({2, 3}), 1);
-  test0(S({1, 2, 3}), 2, S({1, 3}), 1);
-  test0(S({1, 2, 3}), 3, S({1, 2}), 1);
-  test0(S({1, 2, 3}), 4, S({1, 2, 3}), 0);
-
-  test0(S({1, 1, 1}), 1, S(), 3);
-  test0(S({1, 1, 1}), 2, S({1, 1, 1}), 0);
-  test0(S({1, 1, 2}), 1, S({2}), 2);
-  test0(S({1, 1, 2}), 2, S({1, 1}), 1);
-  test0(S({1, 1, 2}), 3, S({1, 1, 2}), 0);
-  test0(S({1, 2, 2}), 1, S({2, 2}), 1);
-  test0(S({1, 2, 2}), 2, S({1}), 2);
-  test0(S({1, 2, 2}), 3, S({1, 2, 2}), 0);
+    check_erase(S({1, 2}), 1, S({2}), 1);
+    check_erase(S({1, 2}), 2, S({1}), 1);
+    check_erase(S({1, 2}), 3, S({1, 2}), 0);
+    check_erase(S({1, 1}), 1, S(), 2);
+    check_erase(S({1, 1}), 3, S({1, 1}), 0);
+
+    check_erase(S({1, 2, 3}), 1, S({2, 3}), 1);
+    check_erase(S({1, 2, 3}), 2, S({1, 3}), 1);
+    check_erase(S({1, 2, 3}), 3, S({1, 2}), 1);
+    check_erase(S({1, 2, 3}), 4, S({1, 2, 3}), 0);
+
+    check_erase(S({1, 1, 1}), 1, S(), 3);
+    check_erase(S({1, 1, 1}), 2, S({1, 1, 1}), 0);
+    check_erase(S({1, 1, 2}), 1, S({2}), 2);
+    check_erase(S({1, 1, 2}), 2, S({1, 1}), 1);
+    check_erase(S({1, 1, 2}), 3, S({1, 1, 2}), 0);
+    check_erase(S({1, 2, 2}), 1, S({2, 2}), 1);
+    check_erase(S({1, 2, 2}), 2, S({1}), 2);
+    check_erase(S({1, 2, 2}), 3, S({1, 2, 2}), 0);
 
     //  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);
+    check_erase(S({1, 2, 1}), opt(), S({1, 2, 1}), 0);
+    check_erase(S({1, 2, 1}), opt(1), S({2}), 2);
+    check_erase(S({1, 2, 1}), opt(2), S({1, 1}), 1);
+    check_erase(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>>> ();
+    do_checks<std::vector<int>>();
+    do_checks<std::vector<int, min_allocator<int>>> ();
+    do_checks<std::vector<int, test_allocator<int>>> ();
+
+    do_checks<std::vector<long>>();
+    do_checks<std::vector<double>>();
 
-    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 check_erase_if(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 do_checks()
 {
     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; };
 
-    test0(S(), is1, S(), 0);
+    check_erase_if(S(), is1, S(), 0);
 
-    test0(S({1}), is1, S(), 1);
-    test0(S({1}), is2, S({1}), 0);
+    check_erase_if(S({1}), is1, S(), 1);
+    check_erase_if(S({1}), is2, S({1}), 0);
 
-    test0(S({1, 2}), is1, S({2}), 1);
-    test0(S({1, 2}), is2, S({1}), 1);
-    test0(S({1, 2}), is3, S({1, 2}), 0);
-    test0(S({1, 1}), is1, S(), 2);
-    test0(S({1, 1}), is3, S({1, 1}), 0);
-
-    test0(S({1, 2, 3}), is1, S({2, 3}), 1);
-    test0(S({1, 2, 3}), is2, S({1, 3}), 1);
-    test0(S({1, 2, 3}), is3, S({1, 2}), 1);
-    test0(S({1, 2, 3}), is4, S({1, 2, 3}), 0);
-
-    test0(S({1, 1, 1}), is1, S(), 3);
-    test0(S({1, 1, 1}), is2, S({1, 1, 1}), 0);
-    test0(S({1, 1, 2}), is1, S({2}), 2);
-    test0(S({1, 1, 2}), is2, S({1, 1}), 1);
-    test0(S({1, 1, 2}), is3, S({1, 1, 2}), 0);
-    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);
+    check_erase_if(S({1, 2}), is1, S({2}), 1);
+    check_erase_if(S({1, 2}), is2, S({1}), 1);
+    check_erase_if(S({1, 2}), is3, S({1, 2}), 0);
+    check_erase_if(S({1, 1}), is1, S(), 2);
+    check_erase_if(S({1, 1}), is3, S({1, 1}), 0);
+
+    check_erase_if(S({1, 2, 3}), is1, S({2, 3}), 1);
+    check_erase_if(S({1, 2, 3}), is2, S({1, 3}), 1);
+    check_erase_if(S({1, 2, 3}), is3, S({1, 2}), 1);
+    check_erase_if(S({1, 2, 3}), is4, S({1, 2, 3}), 0);
+
+    check_erase_if(S({1, 1, 1}), is1, S(), 3);
+    check_erase_if(S({1, 1, 1}), is2, S({1, 1, 1}), 0);
+    check_erase_if(S({1, 1, 2}), is1, S({2}), 2);
+    check_erase_if(S({1, 1, 2}), is2, S({1, 1}), 1);
+    check_erase_if(S({1, 1, 2}), is3, S({1, 1, 2}), 0);
+    check_erase_if(S({1, 2, 2}), is1, S({2, 2}), 1);
+    check_erase_if(S({1, 2, 2}), is2, S({1}), 2);
+    check_erase_if(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);
+    check_erase_if(S({1, 2, 3}), True, S(), 3);
+    check_erase_if(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>>> ();
+    do_checks<std::vector<int>>();
+    do_checks<std::vector<int, min_allocator<int>>> ();
+    do_checks<std::vector<int, test_allocator<int>>> ();
+
+    do_checks<std::vector<long>>();
+    do_checks<std::vector<double>>();
 
-    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

 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;
 #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);
TEST_CONSTEXPR_CXX20 bool tests()
         v.reserve(4);
         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));
     }
 
+    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));
     }
// Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.
     Throws::sThrows = true;
     v.erase(v.begin());
     v.erase(--v.end());
     v.erase(v.begin());
     assert(v.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.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(distance(l1.cbegin(), l1.cend()) == 3);
// Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.
     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 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_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, input_iterator<const int*>(a),
                                  input_iterator<const int*>(a+N));
#if TEST_STD_VER >= 11
     }
 #endif
 
     {
         std::vector<adl::S> s;
         s.insert(s.end(), input_iterator<adl::S*>(), input_iterator<adl::S*>());
     }
 
+    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_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/insert_iter_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, 1);
         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**)
+{
+    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(is_contiguous_container_asan_correct(c));
         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
     {
         // libc++ needs 15 because it grows by 2x (1 + 2 + 4 + 8).
         // Use 17 for implementations that dynamically allocate a container proxy
         // and grow by 1.5x (1 for proxy + 1 + 2 + 3 + 4 + 6).
-        std::vector<MoveOnly, limited_allocator<MoveOnly, 17> > c;
+        std::vector<MoveOnly, limited_allocator<MoveOnly, 17>> 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));
         c.push_back(MoveOnly(1));
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));
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/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp

 #if TEST_STD_VER >= 14
     {
         typedef std::vector<MoveOnly, some_alloc2<MoveOnly>> C;
     //  if the allocators are always equal, then the swap can be noexcept
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
 #endif
 
     return 0;
 }

libcxx/test/support/DefaultOnly.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 DEFAULTONLY_H
-#define DEFAULTONLY_H
+#ifndef TEST_SUPPORT_DEFAULT_ONLY_H
+#define TEST_SUPPORT_DEFAULT_ONLY_H
 
 #include <cassert>
 
-class DefaultOnly
-{
+#include "test_macros.h"
+
+class DefaultOnly {
     int data_;
 
     DefaultOnly(const DefaultOnly&);
     DefaultOnly& operator=(const DefaultOnly&);
 public:
-    static int count;
-
-    DefaultOnly() : data_(-1) {++count;}
-    ~DefaultOnly() {data_ = 0; --count;}
+    TEST_CONSTEXPR DefaultOnly() : data_(-1) { }
+    TEST_CONSTEXPR ~DefaultOnly() { data_ = 0; }
 
-    friend bool operator==(const DefaultOnly& x, const DefaultOnly& y)
-        {return x.data_ == y.data_;}
-    friend bool operator< (const DefaultOnly& x, const DefaultOnly& y)
-        {return x.data_ < y.data_;}
+    TEST_CONSTEXPR friend bool operator==(const DefaultOnly& x, const DefaultOnly& y)
+    TEST_CONSTEXPR friend bool operator< (const DefaultOnly& x, const DefaultOnly& y)
 };
 
-int DefaultOnly::count = 0;
-
-#endif  // DEFAULTONLY_H
+#endif  // TEST_SUPPORT_DEFAULT_ONLY_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 )
+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> &)
+constexpr bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &)
 {
     return true;
 }
 #endif
 
 
 #endif  // ASAN_TESTING_H

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) {
-  typedef std::allocator_traits<Alloc> AT;
-  return AT::max_size(a);
+TEST_CONSTEXPR
+typename std::allocator_traits<Alloc>::size_type alloc_max_size(Alloc const &a) {
+  return std::allocator_traits<Alloc>::max_size(a);
 }
 
 class test_alloc_base
 {
 protected:
-    static int time_to_throw;
+    int time_to_throw;
 public:
-    static int throw_after;
-    static int count;
-    static int alloc_count;
-    static int copied;
-    static int moved;
-    static int converted;
+    int throw_after;
+    int count;
+    int alloc_count;
+    int copied;
+    int moved;
+    int converted;
+
+    TEST_CONSTEXPR test_alloc_base()
+      : time_to_throw(0)
+      , throw_after(INT_MAX)
+      , count(0)
+      , alloc_count(0)
+      , copied(0)
+      , moved(0)
+      , converted(0)
+    { }
 
     const static int destructed_value = -1;
     const static int default_value = 0;
     const static int moved_value = INT_MAX;
 
-    static void clear() {
+    TEST_CONSTEXPR_CXX14 void clear() {
       assert(count == 0 && "clearing leaking allocator data?");
       count = 0;
       time_to_throw = 0;
       alloc_count = 0;
       throw_after = INT_MAX;
       clear_ctor_counters();
     }
 
-    static void clear_ctor_counters() {
+    TEST_CONSTEXPR_CXX14 void clear_ctor_counters() {
       copied = 0;
       moved = 0;
       converted = 0;
     }
 };
 
-int test_alloc_base::count = 0;
-int test_alloc_base::time_to_throw = 0;
-int test_alloc_base::alloc_count = 0;
-int test_alloc_base::throw_after = INT_MAX;
-int test_alloc_base::copied = 0;
-int test_alloc_base::moved = 0;
-int test_alloc_base::converted = 0;
-
 template <class T>
 class test_allocator
     : public test_alloc_base
 {
     int data_; // participates in equality
     int id_; // unique identifier, doesn't participate in equality
     template <class U> friend class test_allocator;
 public:
 
     typedef unsigned                                                   size_type;
     typedef int                                                        difference_type;
     typedef T                                                          value_type;
     typedef value_type*                                                pointer;
     typedef const value_type*                                          const_pointer;
     typedef typename std::add_lvalue_reference<value_type>::type       reference;
     typedef typename std::add_lvalue_reference<const value_type>::type const_reference;
 
     template <class U> struct rebind {typedef test_allocator<U> other;};
 
-    test_allocator() TEST_NOEXCEPT : data_(0), id_(0) {++count;}
-    explicit test_allocator(int i, int id = 0) TEST_NOEXCEPT : data_(i), id_(id)
-      {++count;}
-    test_allocator(const test_allocator& a) TEST_NOEXCEPT : data_(a.data_),
-                                                            id_(a.id_) {
+    TEST_CONSTEXPR_CXX14 test_allocator() TEST_NOEXCEPT
+      : data_(0), id_(0)
+    { ++count; }
+
+    TEST_CONSTEXPR_CXX14 explicit test_allocator(int i, int id = 0) TEST_NOEXCEPT
+      : data_(i), id_(id)
+    { ++count; }
+
+    TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator& a) TEST_NOEXCEPT
+      : data_(a.data_), id_(a.id_)
+    {
       ++count;
       ++copied;
       assert(a.data_ != destructed_value && a.id_ != destructed_value &&
              "copying from destroyed allocator");
     }
+
 #if TEST_STD_VER >= 11
-    test_allocator(test_allocator&& a) TEST_NOEXCEPT : data_(a.data_),
-                                                       id_(a.id_) {
+    TEST_CONSTEXPR_CXX14 test_allocator(test_allocator&& a) TEST_NOEXCEPT
+      : data_(a.data_), id_(a.id_)
+    {
       ++count;
       ++moved;
       assert(a.data_ != destructed_value && a.id_ != destructed_value &&
              "moving from destroyed allocator");
       a.data_ = moved_value;
       a.id_ = moved_value;
     }
 #endif
     template <class U>
-    test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT : data_(a.data_),
-                                                               id_(a.id_) {
+    TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
+      : data_(a.data_), id_(a.id_)
+    {
       ++count;
       ++converted;
     }
-    ~test_allocator() TEST_NOEXCEPT {
+
+    TEST_CONSTEXPR_CXX20 ~test_allocator() TEST_NOEXCEPT {
       assert(data_ >= 0); assert(id_ >= 0);
       --count;
       data_ = destructed_value;
       id_ = destructed_value;
     }
-    pointer address(reference x) const {return &x;}
-    const_pointer address(const_reference x) const {return &x;}
-    pointer allocate(size_type n, const void* = 0)
-        {
-            assert(data_ >= 0);
-            if (time_to_throw >= throw_after) {
+    TEST_CONSTEXPR pointer address(reference x) const {return &x;}
+    TEST_CONSTEXPR const_pointer address(const_reference x) const {return &x;}
+    TEST_CONSTEXPR_CXX20 pointer allocate(size_type n, const void* = 0) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-                throw std::bad_alloc();
 #else
-                std::terminate();
 #endif
-            }
-            ++time_to_throw;
-            ++alloc_count;
-            return (pointer)::operator new(n * sizeof(T));
-        }
-    void deallocate(pointer p, size_type)
-        {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p);}
-    size_type max_size() const TEST_NOEXCEPT
-        {return UINT_MAX / sizeof(T);}
+      return std::allocator<T>().allocate(n);
+    }
+    TEST_CONSTEXPR_CXX20 void deallocate(pointer p, size_type n) {
+      assert(data_ >= 0);
+      --alloc_count;
+      std::allocator<T>().deallocate(p, n);
+    }
+    TEST_CONSTEXPR size_type max_size() const TEST_NOEXCEPT {
+      return UINT_MAX / sizeof(T);
 #if TEST_STD_VER < 11
-    void construct(pointer p, const T& val)
-        {::new(static_cast<void*>(p)) T(val);}
+    void construct(pointer p, const T& val) {
+      ::new(static_cast<void*>(p)) T(val);
+    }
+#elif TEST_STD_VER < 20
+    template <class U>
+    void construct(pointer p, U&& val) {
+      ::new(static_cast<void*>(p)) T(std::forward<U>(val));
+    }
 #else
-    template <class U> void construct(pointer p, U&& val)
-        {::new(static_cast<void*>(p)) T(std::forward<U>(val));}
+    template <class U>
+    constexpr void construct(pointer p, U&& val) {
+      std::construct_at(p, std::forward<U>(val));
+    }
 #endif
-    void destroy(pointer p)
-        {p->~T();}
-    friend bool operator==(const test_allocator& x, const test_allocator& y)
-        {return x.data_ == y.data_;}
-    friend bool operator!=(const test_allocator& x, const test_allocator& y)
-        {return !(x == y);}
+    TEST_CONSTEXPR_CXX20 void destroy(pointer p) {
+      p->~T();
+    }
 
-    int get_data() const { return data_; }
-    int get_id() const { return id_; }
+    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_; }
 };
 
 template <class T>
 class non_default_test_allocator
     : public test_alloc_base
 {
     int data_;
 
     template <class U> friend class non_default_test_allocator;
 public:
 
     typedef unsigned                                                   size_type;
     typedef int                                                        difference_type;
     typedef T                                                          value_type;
     typedef value_type*                                                pointer;
     typedef const value_type*                                          const_pointer;
     typedef typename std::add_lvalue_reference<value_type>::type       reference;
     typedef typename std::add_lvalue_reference<const value_type>::type const_reference;
 
     template <class U> struct rebind {typedef non_default_test_allocator<U> other;};
 
-//    non_default_test_allocator() TEST_NOEXCEPT : data_(0) {++count;}
-    explicit non_default_test_allocator(int i) TEST_NOEXCEPT : data_(i) {++count;}
-    non_default_test_allocator(const non_default_test_allocator& a) TEST_NOEXCEPT
-        : data_(a.data_) {++count;}
-    template <class U> non_default_test_allocator(const non_default_test_allocator<U>& a) TEST_NOEXCEPT
-        : data_(a.data_) {++count;}
-    ~non_default_test_allocator() TEST_NOEXCEPT {assert(data_ >= 0); --count; data_ = -1;}
-    pointer address(reference x) const {return &x;}
-    const_pointer address(const_reference x) const {return &x;}
-    pointer allocate(size_type n, const void* = 0)
-        {
-            assert(data_ >= 0);
-            if (time_to_throw >= throw_after) {
+    // No default constructor
+    TEST_CONSTEXPR_CXX14 explicit non_default_test_allocator(int i) TEST_NOEXCEPT
+      : data_(i)
+    { ++count; }
+
+    TEST_CONSTEXPR_CXX14 non_default_test_allocator(const non_default_test_allocator& a) TEST_NOEXCEPT
+      : data_(a.data_)
+    { ++count; }
+
+    template <class U>
+    TEST_CONSTEXPR_CXX14 non_default_test_allocator(const non_default_test_allocator<U>& a) TEST_NOEXCEPT
+      : data_(a.data_)
+    { ++count; }
+
+    TEST_CONSTEXPR_CXX20 ~non_default_test_allocator() TEST_NOEXCEPT {
+      assert(data_ >= 0);
+      --count;
+      data_ = -1;
+    }
+    TEST_CONSTEXPR pointer address(reference x) const { return &x; }
+    TEST_CONSTEXPR const_pointer address(const_reference x) const { return &x; }
+    TEST_CONSTEXPR_CXX20 pointer allocate(size_type n, const void* = 0) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-                throw std::bad_alloc();
 #else
-                std::terminate();
 #endif
-            }
-            ++time_to_throw;
-            ++alloc_count;
-            return (pointer)::operator new (n * sizeof(T));
-        }
-    void deallocate(pointer p, size_type)
-        {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p); }
-    size_type max_size() const TEST_NOEXCEPT
-        {return UINT_MAX / sizeof(T);}
+      return std::allocator<T>().allocate(n);
+    }
+    TEST_CONSTEXPR_CXX20 void deallocate(pointer p, size_type n) {
+      assert(data_ >= 0);
+      --alloc_count;
+      std::allocator<T>().deallocate(p, n);
+    }
+    TEST_CONSTEXPR size_type max_size() const TEST_NOEXCEPT {
+      return UINT_MAX / sizeof(T);
 #if TEST_STD_VER < 11
-    void construct(pointer p, const T& val)
-        {::new(static_cast<void*>(p)) T(val);}
+    void construct(pointer p, const T& val) {
+      ::new(static_cast<void*>(p)) T(val);
+    }
+#elif TEST_STD_VER < 20
+    template <class U>
+    void construct(pointer p, U&& val) {
+      ::new(static_cast<void*>(p)) T(std::forward<U>(val));
+    }
 #else
-    template <class U> void construct(pointer p, U&& val)
-        {::new(static_cast<void*>(p)) T(std::forward<U>(val));}
+    template <class U>
+    constexpr void construct(pointer p, U&& val) {
+      std::construct_at(p, std::forward<U>(val));
+    }
 #endif
-    void destroy(pointer p) {p->~T();}
+    TEST_CONSTEXPR_CXX20 void destroy(pointer p) {
+      p->~T();
+    }
 
-    friend bool operator==(const non_default_test_allocator& x, const non_default_test_allocator& y)
-        {return x.data_ == y.data_;}
-    friend bool operator!=(const non_default_test_allocator& x, const non_default_test_allocator& y)
-        {return !(x == y);}
+    TEST_CONSTEXPR friend bool operator==(const non_default_test_allocator& x, const non_default_test_allocator& y) {
+      return x.data_ == y.data_;
+    }
+    TEST_CONSTEXPR friend bool operator!=(const non_default_test_allocator& x, const non_default_test_allocator& y) {
+      return !(x == y);
+    }
 };
 
 template <>
 class test_allocator<void>
     : public test_alloc_base
 {
     int data_;
     int id_;
 
     template <class U> friend class test_allocator;
 public:
 
     typedef unsigned                                                   size_type;
     typedef int                                                        difference_type;
     typedef void                                                       value_type;
     typedef value_type*                                                pointer;
     typedef const value_type*                                          const_pointer;
 
     template <class U> struct rebind {typedef test_allocator<U> other;};
 
-    test_allocator() TEST_NOEXCEPT : data_(0), id_(0) {}
-    explicit test_allocator(int i, int id = 0) TEST_NOEXCEPT : data_(i), id_(id) {}
-    test_allocator(const test_allocator& a) TEST_NOEXCEPT
-        : data_(a.data_), id_(a.id_) {}
-    template <class U> test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
-        : data_(a.data_), id_(a.id_) {}
-    ~test_allocator() TEST_NOEXCEPT {data_ = -1; id_ = -1; }
-
-    int get_id() const { return id_; }
-    int get_data() const { return data_; }
-
-    friend bool operator==(const test_allocator& x, const test_allocator& y)
-        {return x.data_ == y.data_;}
-    friend bool operator!=(const test_allocator& x, const test_allocator& y)
-        {return !(x == y);}
+    TEST_CONSTEXPR test_allocator() TEST_NOEXCEPT : data_(0), id_(0) {}
+    TEST_CONSTEXPR explicit test_allocator(int i, int id = 0) TEST_NOEXCEPT
+      : data_(i), id_(id)
+    { }
+    TEST_CONSTEXPR test_allocator(const test_allocator& a) TEST_NOEXCEPT
+      : data_(a.data_), id_(a.id_)
+    { }
+    template <class U>
+    TEST_CONSTEXPR test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
+      : data_(a.data_), id_(a.id_)
+    { }
+    TEST_CONSTEXPR_CXX20 ~test_allocator() TEST_NOEXCEPT {
+      data_ = -1;
+      id_ = -1;
+    }
+
+    TEST_CONSTEXPR int get_id() const { return id_; }
+    TEST_CONSTEXPR int get_data() const { return data_; }
+
+    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);
+    }
 };
 
 template <class T>
 class other_allocator
 {
     int data_;
 
     template <class U> friend class other_allocator;
 
 public:
     typedef T value_type;
 
-    other_allocator() : data_(-1) {}
-    explicit other_allocator(int i) : data_(i) {}
-    template <class U> other_allocator(const other_allocator<U>& a)
-        : data_(a.data_) {}
-    T* allocate(std::size_t n)
-        {return (T*)::operator new(n * sizeof(T));}
-    void deallocate(T* p, std::size_t)
-        {::operator delete((void*)p);}
-
-    other_allocator select_on_container_copy_construction() const
-        {return other_allocator(-2);}
-
-    friend bool operator==(const other_allocator& x, const other_allocator& y)
-        {return x.data_ == y.data_;}
-    friend bool operator!=(const other_allocator& x, const other_allocator& y)
-        {return !(x == y);}
+    TEST_CONSTEXPR other_allocator() : data_(-1) {}
+    TEST_CONSTEXPR explicit other_allocator(int i) : data_(i) {}
+    template <class U>
+    TEST_CONSTEXPR other_allocator(const other_allocator<U>& a)
+      : data_(a.data_)
+    { }
+    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);
+    }
+
+    TEST_CONSTEXPR other_allocator select_on_container_copy_construction() const {
+      return other_allocator(-2);
+    }
+
+    TEST_CONSTEXPR friend bool operator==(const other_allocator& x, const other_allocator& y) {
+      return x.data_ == y.data_;
+    }
+    TEST_CONSTEXPR friend bool operator!=(const other_allocator& x, const other_allocator& y) {
+      return !(x == y);
+    }
 
     typedef std::true_type propagate_on_container_copy_assignment;
     typedef std::true_type propagate_on_container_move_assignment;
     typedef std::true_type propagate_on_container_swap;
 
 #if TEST_STD_VER < 11
-    std::size_t max_size() const
-        {return UINT_MAX / sizeof(T);}
+    std::size_t max_size() const {
+      return UINT_MAX / sizeof(T);
+    }
 #endif
 
 };
 
 #if TEST_STD_VER >= 11
 
 struct Ctor_Tag {};
 

 
 template<typename T>
 class TaggingAllocator {
 public:
     using value_type = T;
     TaggingAllocator() = default;
 
     template<typename U>
-      TaggingAllocator(const TaggingAllocator<U>&) { }
+    constexpr TaggingAllocator(const TaggingAllocator<U>&) { }
+
+    TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n) {
+      return std::allocator<T>{}.allocate(n);
+    }
 
-    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);
+    }
 
-    void deallocate(T* p, std::size_t n) { std::allocator<T>{}.deallocate(p, n); }
+#if TEST_STD_VER >= 20
+    template<typename... Args>
+    constexpr void construct(Tag_X* p, Args&&... args) {
+      std::construct_at(p, Ctor_Tag{}, std::forward<Args>(args)...);
+    }
 
+    template<typename U, typename... Args>
+    constexpr void construct(U* p, Args&&... args) {
+      std::construct_at(p, std::forward<Args>(args)...);
+    }
+#else
     template<typename... Args>
-    void construct(Tag_X* p, Args&&... args)
-    { ::new((void*)p) Tag_X(Ctor_Tag{}, std::forward<Args>(args)...); }
+    void construct(Tag_X* p, Args&&... args) {
+      ::new((void*)p) Tag_X(Ctor_Tag{}, std::forward<Args>(args)...);
+    }
 
     template<typename U, typename... Args>
-    void construct(U* p, Args&&... args)
-    { ::new((void*)p) U(std::forward<Args>(args)...); }
+    void construct(U* p, Args&&... args) {
+      ::new((void*)p) U(std::forward<Args>(args)...);
+    }
+#endif
 
     template<typename U, typename... Args>
-    void destroy(U* p)
-    { p->~U(); }
+    TEST_CONSTEXPR_CXX20 void destroy(U* p) {
+      p->~U();
+    }
 };
 
 template<typename T, typename U>
-bool
-operator==(const TaggingAllocator<T>&, const TaggingAllocator<U>&)
-{ return true; }
+TEST_CONSTEXPR bool operator==(const TaggingAllocator<T>&, const TaggingAllocator<U>&) {
+  return true;
+}
 
 template<typename T, typename U>
-bool
-operator!=(const TaggingAllocator<T>&, const TaggingAllocator<U>&)
-{ return false; }
-#endif
+TEST_CONSTEXPR bool operator!=(const TaggingAllocator<T>&, const TaggingAllocator<U>&) {
+  return false;
+}
+#endif // >= C++11
+
+namespace detail {
+  // A naive shared_ptr that works within constexpr contexts, but that isn't
+  // thread safe.
+  template <typename T>
+  struct cheap_shared_ptr {
+    struct control_block {
+      int references_;
+      T resource_;
+    };
+
+    control_block* block_;
+
+    TEST_CONSTEXPR cheap_shared_ptr() : block_(nullptr) { }
+
+    TEST_CONSTEXPR_CXX14 cheap_shared_ptr(cheap_shared_ptr const& other)
+      : block_(other.block_)
+    {
+      block_->references_++;
+    }
+
+    TEST_CONSTEXPR_CXX20 ~cheap_shared_ptr() {
+      block_->references_--;
+      if (block_->references_ == 0) {
+        std::allocator<control_block> alloc;
+        typedef std::allocator_traits<std::allocator<control_block> > AllocTraits;
+        AllocTraits::destroy(alloc, block_);
+        AllocTraits::deallocate(alloc, block_, 1);
+      }
+    }
+
+    TEST_CONSTEXPR T& operator*() const {
+      return block_->resource_;
+    }
+
+    TEST_CONSTEXPR T* operator->() const {
+      return &block_->resource_;
+    }
+  };
+
+  template <typename T>
+  TEST_CONSTEXPR_CXX20 cheap_shared_ptr<T> make_cheap_shared() {
+    cheap_shared_ptr<T> ptr;
+    typedef typename cheap_shared_ptr<T>::control_block ControlBlock;
+    typedef std::allocator_traits<std::allocator<ControlBlock> > AllocTraits;
+
+    std::allocator<ControlBlock> alloc;
+    ptr.block_ = AllocTraits::allocate(alloc, 1);
+    AllocTraits::construct(alloc, ptr.block_);
+    ptr.block_->references_ = 1;
+    return ptr;
+  }
+} // end namespace detail
 
 template <std::size_t MaxAllocs>
 struct limited_alloc_handle {
   std::size_t outstanding_;
   void* last_alloc_;
 
-  limited_alloc_handle() : outstanding_(0), last_alloc_(nullptr) {}
+  TEST_CONSTEXPR limited_alloc_handle()
+    : outstanding_(0), last_alloc_(nullptr)
+  { }
 
   template <class T>
-  T *allocate(std::size_t N) {
+  TEST_CONSTEXPR_CXX20 T *allocate(std::size_t N) {
     if (N + outstanding_ > MaxAllocs)
       TEST_THROW(std::bad_alloc());
-    last_alloc_ = ::operator new(N*sizeof(T));
+    T* allocated = std::allocator<T>().allocate(N);
+    last_alloc_ = allocated;
     outstanding_ += N;
-    return static_cast<T*>(last_alloc_);
+    return allocated;
   }
 
-  void deallocate(void* ptr, std::size_t N) {
+  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;
     }
-    ::operator delete(ptr);
+    std::allocator<T>().deallocate(ptr, N);
   }
 };
 
 template <class T, std::size_t N>
 class limited_allocator
 {
     template <class U, std::size_t UN> friend class limited_allocator;
+    template <class U> friend bool operator==(limited_allocator<T, N> const&, limited_allocator<U, N> const&);
+
     typedef limited_alloc_handle<N> BuffT;
-    std::shared_ptr<BuffT> handle_;
+    detail::cheap_shared_ptr<BuffT> handle_;
 public:
     typedef T                 value_type;
     typedef value_type*       pointer;
     typedef const value_type* const_pointer;
     typedef value_type&       reference;
     typedef const value_type& const_reference;
     typedef std::size_t       size_type;
     typedef std::ptrdiff_t    difference_type;
 
     template <class U> struct rebind { typedef limited_allocator<U, N> other; };
 
-    limited_allocator() : handle_(new BuffT) {}
-
-    limited_allocator(limited_allocator const& other) : handle_(other.handle_) {}
+    TEST_CONSTEXPR_CXX20 limited_allocator()
+      : handle_(detail::make_cheap_shared<BuffT>())
+    { }
+
+    TEST_CONSTEXPR limited_allocator(limited_allocator const& other)
+      : handle_(other.handle_)
+    { }
 
     template <class U>
-    explicit limited_allocator(limited_allocator<U, N> const& other)
-        : handle_(other.handle_) {}
+    TEST_CONSTEXPR explicit limited_allocator(limited_allocator<U, N> const& other)
+      : handle_(other.handle_)
+    { }
 
 private:
     limited_allocator& operator=(const limited_allocator&);// = delete;
 
 public:
-    pointer allocate(size_type n) { return handle_->template allocate<T>(n); }
-    void deallocate(pointer p, size_type n) { handle_->deallocate(p, n); }
-    size_type max_size() const {return N;}
+    TEST_CONSTEXPR_CXX20 pointer allocate(size_type n) {
+      return handle_->template allocate<T>(n);
+    }
+
+    TEST_CONSTEXPR_CXX20 void deallocate(pointer p, size_type n) {
+      handle_->deallocate(p, n);
+    }
 
-    BuffT* getHandle() const { return handle_.get(); }
+    TEST_CONSTEXPR size_type max_size() const {
+      return N;
+    }
 };
 
 template <class T, class U, std::size_t N>
-inline bool operator==(limited_allocator<T, N> const& LHS,
-                       limited_allocator<U, N> const& RHS) {
-  return LHS.getHandle() == RHS.getHandle();
-}
+TEST_CONSTEXPR bool operator==(limited_allocator<T, N> const& LHS,
+                               limited_allocator<U, N> const& RHS)
+{ return LHS.handle_ == RHS.handle_; }
 
 template <class T, class U, std::size_t N>
-inline bool operator!=(limited_allocator<T, N> const& LHS,
-                       limited_allocator<U, N> const& RHS) {
-  return !(LHS == RHS);
-}
+TEST_CONSTEXPR bool operator!=(limited_allocator<T, N> const& LHS,
+                               limited_allocator<U, N> const& RHS)
+{ return !(LHS == RHS); }
 
 
 #endif  // TEST_ALLOCATOR_H