[libc++] Complete overhaul of constexpr support in std::array

[ldionne]

Summary

This commit adds missing support for constexpr in std::array under all
standard modes up to and including C++20. It also transforms the <array>
tests to check for constexpr-friendliness under the right standard modes.

It does change one bit of behavior from the previous array implementation,
notably the fact that begin() and end() on an empty std::array will now
return nullptr. This implementation is allowed by the current wording
for std::array, however if https://wg21.link/LWG2157 goes through, we'll
have to change that strategy for one where different empty arrays have
iterators to different underlying ranges.

Fixes https://llvm.org/PR40124
Fixes rdar://57522096
Supersedes https://reviews.llvm.org/D60666

[ldionne]

I know there's been discussion before about having to return nullptr from begin() and end() for empty arrays and we didn't want to do it. However, doing so is a valid implementation strategy with the given Standard IIUC, and it would only become incorrect if we adopted https://wg21.link/LWG2157. Given that LWG2157 hasn't made it through yet, I think it's a lot more important to fix the situation of std::array in libc++ than implement a maybe-future LWG issue resolution.

Also note that if LWG goes through, there's presumably a way to implement it, so we can just switch to that. However, I don't think removing constexpr for the empty std::arrays is ever going to happen, because that would be way too inconsistent.

[miscco]

Thanks a lot for improving the tests. I am not yet comfortable with libc++ tests so I have some general questions inline

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

33

being new to the party, what is the reason for the template?

libcxx/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp

39

Would it make sense to consistently drop all those typedefs?

If not what is their purpose?

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

26

preexisting: Are those conversions from into double intentional?

42

Same here int -> double conversion

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

37

This is TEST_CONSTEXPR_CXX14 but the constexpr test is #if TEST_STD_VER >= 17

Could we define a macro TEST_CONSTEXPR_CXX14?

Notably this should not compile for C++14 as data is not constexpr.

Occurs at other places too

[zoecarver]

Thanks for all the test improvements @ldionne!

---

What's the point of all the Dummy templates?

libcxx/include/array

368

This will probably break some people's code. I would much prefer not returning nullptr here. What's the downside of using something similar to D60666's implementation of data()?

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

33

I don't think the template is needed.

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

52

I don't see the point of this test anymore (lines 48-54).

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

87

Same as above.

112

pint will always be zero, no? I think it would make more sense to test this with non-null data (std::array<T, 1> maybe).

[miscco]

What I completely forgot, thisimplements the array portion of the [[ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html | misc_constexpr ]]paper so you should adopt/add the feature test macro `__cpp_lib_array_constexpr = 201811L``

[zoecarver]

libcxx/include/array

261

Why use a new _Empty struct? char makes more sense and has a defined size in the standard.

261

Nit: this could be add_const.

[ldionne]

Address review comments. Main change: an empty array begin()/end() doesn't return nullptr anymore, i.e. there is no behavior change.

[ldionne]

Thanks @zoecarver and @miscco for the comments and review! I'm addressing your comments.

In D80452#2051973, @miscco wrote:

What I completely forgot, thisimplements the array portion of the [[ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html | misc_constexpr ]]paper so you should adopt/add the feature test macro `__cpp_lib_array_constexpr = 201811L``

Good catch! Will add in the next update.

libcxx/include/array

261

Default constructing a char leaves it to an undefined value, which you can't do inside constexpr. So something like std::array<int, 0> a; isn't valid inside constexpr if the empty-array implementation holds a char internally, but it does work with an empty struct.

But regardless, this is being undone anyway since I'm moving to the union trick.

368

Indeed -- I spent some more time on this and it does work. Updated.

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

33

It's to avoid this error:

at.pass.cpp:27:27: error: constexpr function never produces a constant expression [-Winvalid-constexpr]
TEST_CONSTEXPR_CXX14 bool tests()

It triggers when e.g. at() is not marked as constexpr in the given standard mode, but the tests() function that calls it is.

However, in this specific case, it's not useful because the test is only enabled in c++17 and above, so there's no constexpr mismatch. But it is useful in other tests, like the ones for at, data and probably others. I'll remove the unnecessary ones.

libcxx/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp

39

I think it would make sense to drop them -- I'm not a big fan. It's just the way the tests were written originally I guess. I don't really want to systematically remove the typedefs in this patch, though.

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

26

I am pretty sure they are, we're likely testing that aggregate initialization works as expected.

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

37

Could we define a macro TEST_CONSTEXPR_CXX14?

Do you mean TEST_CONSTEXPR_CXX17?

I'm making the test code constexpr whenever it can be marked as such, I'm just not checking the constexpr-ness of std::array itself unless the Standard mandates it. That's the purpose of the Dummy template parameter -- it makes it OK to have constexpr on the tests() function in C++14, despite its body not being constexpr-friendly (because data() isn't constexpr as you mention).

52

I've re-added the check for p != nullptr, so this is moot.

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

112

Moot since I'm using the union trick.

[miscco]

libcxx/include/array

368

I would like to note that this will break users code once they want to try different standard library implementations.

Given that the other two major implementations use nullptr as return value this is a clear portability issue. Is there any other benefit to doing so?

I would note that
a. This seems like an supremely rare case anyway
b. I would consider breaking code that relies on UB to be less or equally severe than breaking code when switching standard libraries

That said I wouldn't shed any tears if you go with that implementation

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

33

But if one chooses the "right" TEST_CONSTEXPR_CXX macro this should not happen?

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

37

Again, Why not simply declare this as TEST_CONSTEXPR_CXX17 and be correct in every case. Is there any benefit to not doing so?

[ldionne]

libcxx/include/array

368

The main problem is that once https://cplusplus.github.io/LWG/issue2157 gets through, we'll have to reimplement it the way this patch currently does anyway (i.e. not return nullptr). It's also technically an ABI break and a behavior change to start returning nullptr, but frankly I don't think it's an important enough one to be bothered. But I do think doing the same thing as other implementations is not something we should strive for *in this case* because of the LWG issue.

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

33

Indeed. Ok, I'll do that instead.

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

37

I guess there isn't much benefit after all. I liked that the standard we tested constexpr under was defined in a single place (where we call tests()), but I guess that's minor for the annoyance it causes.

[ldionne]

Use the right constexpr qualifiers.

[ldionne]

@zoecarver @miscco Please take a look and LMK if you see other problems with the patch. I'll ship it when I get your LGTMs.

[ldionne]

Remove forgotten dummy template.

[zoecarver]

Thanks for fixing the nullptr thing, and thanks for all the work to improve tests here. Other than my one comment, this LGTM.

libcxx/include/array

245

This should be after C++11. In C++11 this won't be an aggregate (__w is a non-static member without initialization).

269

Nit: will you put a comment here?

[zoecarver]

libcxx/include/array

245

__w is a non-static member without initialization.

This should say: "__w is a non-static member with default initialization."

245

After a quick scan it looks like there is no test for is_aggregate<array<T, N>>. Any chance you could add that (note: I think it is important to have checks for both is_aggregate<array<T, N>> and is_aggregate<array<T, 0>>)?

[miscco]

I had two minor nits and a general OMG moment about the diverging constexpr status wrt indexing .

Besides that LGTM

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

83–84

Nit: In the other C++17 defines you use #if TEST_STD_VER >= 17 and not #if TEST_STD_VER > 14

84–89

Nit: This always tests compile time. It would be more consistent with the other tests to use assert here and test the constexpr behavior via the static_assert(tests(), "");

libcxx/test/std/containers/sequences/array/front_back_const.pass.cpp

25

Comment: I wrote multiple comments to check whether this is really different. than the non-const version.

Checking with the standard shows it indeed is (terrible).

[zoecarver]

This LGTM!

libcxx/include/array

245

Never mind about this. I got confused about the aggregate/default initialization requirements.

[ldionne]

Add tests for is_aggregate

libcxx/include/array

245

This should be after C++11. In C++11 this won't be an aggregate (__w is a non-static member without initialization).

I don't think that's correct. I think it is an aggregate -- __w doesn't have a member initializer. Clang seems to agree with me using __is_aggregate. In all cases, I'm adding tests.

269

IMO the code block is small enough that a comment on the closing #endif isn't useful.

libcxx/test/std/containers/sequences/array/front_back_const.pass.cpp

25

Yes it is -- initially constexpr implied const on variables, which sheds some light on why things evolved that way.

[ldionne]

Thanks all for your comments, it was really useful in improving the patch. I'll try to ship this now and we'll see if it breaks something unexpectedly.

[MaskRay]

#include <array>
#include <string>

int main() {
  std::array<std::string, 0> cells;
}

>

a.cc:5:30: error: call to implicitly-deleted default constructor of 'std::array<std::string, 0>' (aka 'array<basic_string<char, char_traits<char>, all
ocator<char>>, 0>')
  std::array<std::string, 0> cells;
                             ^
/tmp/ReleaseA/bin/../include/c++/v1/array:252:7: note: default constructor of 'array<std::__1::basic_string<char, std::__1::char_traits<char>, std::__
1::allocator<char>>, 0>' is implicitly deleted because field '__w' has a deleted destructor
    } __w;                    
      ^                                                                                                                                               
/tmp/ReleaseA/bin/../include/c++/v1/array:248:9: note: explicitly defaulted function was implicitly deleted here
        ~__wrapper() = default;
        ^
/tmp/ReleaseA/bin/../include/c++/v1/array:251:13: note: destructor of '__wrapper' is implicitly deleted because variant field '__t' has a non-trivial 
destructor                     
        _Tp __t;

tensorflow/core/lib/monitoring/gauge.h can have such a use case of 0 with certain instantiations.

Edit: just saw D80821. Thanks for the patch.

[leonardchan]

Hi! I think this patch might be the cause of the bug at https://bugs.llvm.org/show_bug.cgi?id=46137.

Essentially, we get an error when attempting to create std::array<S, 0> if S has a non-trivial destructor (full example at the bug link):

test.cc:20:20: error: call to implicitly-deleted default constructor of 'std::array<S, 0>'
  std::array<S, 0> x;  // bad
                   ^
/usr/local/google/home/leonardchan/llvm-monorepo/llvm-build-1-master-fuchsia-toolchain/install/bin/../include/c++/v1/array:252:7: note: default constructor of 'array<S, 0>' is implicitly deleted because field '__w' has a deleted destructor
    } __w;
      ^
/usr/local/google/home/leonardchan/llvm-monorepo/llvm-build-1-master-fuchsia-toolchain/install/bin/../include/c++/v1/array:248:9: note: explicitly defaulted function was implicitly deleted here
        ~__wrapper() = default;
        ^
/usr/local/google/home/leonardchan/llvm-monorepo/llvm-build-1-master-fuchsia-toolchain/install/bin/../include/c++/v1/array:251:13: note: destructor of '__wrapper' is implicitly deleted because variant field '__t' has a non-trivial destructor
        _Tp __t;
            ^
test.cc:20:20: error: attempt to use a deleted function
  std::array<S, 0> x;  // bad
                   ^

I believe std::arrays of size 0 should be legal regardless of constraints on the element type.

[leonardchan]

In D80452#2064445, @leonardchan wrote:

Hi! I think this patch might be the cause of the bug at https://bugs.llvm.org/show_bug.cgi?id=46137.

Essentially, we get an error when attempting to create std::array<S, 0> if S has a non-trivial destructor (full example at the bug link):

test.cc:20:20: error: call to implicitly-deleted default constructor of 'std::array<S, 0>'
  std::array<S, 0> x;  // bad
                   ^
/usr/local/google/home/leonardchan/llvm-monorepo/llvm-build-1-master-fuchsia-toolchain/install/bin/../include/c++/v1/array:252:7: note: default constructor of 'array<S, 0>' is implicitly deleted because field '__w' has a deleted destructor
    } __w;
      ^
/usr/local/google/home/leonardchan/llvm-monorepo/llvm-build-1-master-fuchsia-toolchain/install/bin/../include/c++/v1/array:248:9: note: explicitly defaulted function was implicitly deleted here
        ~__wrapper() = default;
        ^
/usr/local/google/home/leonardchan/llvm-monorepo/llvm-build-1-master-fuchsia-toolchain/install/bin/../include/c++/v1/array:251:13: note: destructor of '__wrapper' is implicitly deleted because variant field '__t' has a non-trivial destructor
        _Tp __t;
            ^
test.cc:20:20: error: attempt to use a deleted function
  std::array<S, 0> x;  // bad
                   ^

I believe std::arrays of size 0 should be legal regardless of constraints on the element type.

Woops. Sorry. Disregard my comment. Didn't refresh and see @MaskRay's comment or D80821. Thanks for the fix!

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_unordered_map_try_emplace``           ``201411L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_variant``                             ``201606L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_void_t``                              ``201411L``      
     ------------------------------------------------- -----------------
     **C++ 2a**                                                         
     -------------------------------------------------------------------
+    ``__cpp_lib_array_constexpr``                     ``201811L``      
+    ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_ref``                          *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_bind_front``                          *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_bit_cast``                            *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_char8_t``                             ``201811L``      
     ------------------------------------------------- -----------------

libcxx/include/array

struct array
     typedef ptrdiff_t difference_type;
     typedef T value_type;
     typedef T* pointer;
     typedef const T* const_pointer;
     typedef std::reverse_iterator<iterator> reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
     // No explicit construct/copy/destroy for aggregate type
-    void fill(const T& u);
-    void swap(array& a) noexcept(is_nothrow_swappable_v<T>);
+    void fill(const T& u);                                      // constexpr in C++20
+    void swap(array& a) noexcept(is_nothrow_swappable_v<T>);    // constexpr in C++20
 
     // iterators:
-    iterator begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator end() noexcept;
-    const_iterator end() const noexcept;
-
-    reverse_iterator rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-
-    const_iterator cbegin() const noexcept;
-    const_iterator cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
+    iterator begin() noexcept;                                  // constexpr in C++17
+    const_iterator begin() const noexcept;                      // constexpr in C++17
+    iterator end() noexcept;                                    // constexpr in C++17
+    const_iterator end() const noexcept;                        // constexpr in C++17
+
+    reverse_iterator rbegin() noexcept;                         // constexpr in C++17
+    const_reverse_iterator rbegin() const noexcept;             // constexpr in C++17
+    reverse_iterator rend() noexcept;                           // constexpr in C++17
+    const_reverse_iterator rend() const noexcept;               // constexpr in C++17
+
+    const_iterator cbegin() const noexcept;                     // constexpr in C++17
+    const_iterator cend() const noexcept;                       // constexpr in C++17
+    const_reverse_iterator crbegin() const noexcept;            // constexpr in C++17
+    const_reverse_iterator crend() const noexcept;              // constexpr in C++17
 
     // capacity:
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
     constexpr bool empty() const noexcept;
 
     // element access:
-    reference operator[](size_type n);
-    const_reference operator[](size_type n) const; // constexpr in C++14
-    const_reference at(size_type n) const; // constexpr in C++14
-    reference at(size_type n);
+    reference operator[](size_type n);                          // constexpr in C++17
+    const_reference operator[](size_type n) const;              // constexpr in C++14
+    reference at(size_type n);                                  // constexpr in C++17
+    const_reference at(size_type n) const;                      // constexpr in C++14
 
-    reference front();
-    const_reference front() const; // constexpr in C++14
-    reference back();
-    const_reference back() const; // constexpr in C++14
+    reference front();                                          // constexpr in C++17
+    const_reference front() const;                              // constexpr in C++14
+    reference back();                                           // constexpr in C++17
+    const_reference back() const;                               // constexpr in C++14
 
-    T* data() noexcept;
-    const T* data() const noexcept;
+    T* data() noexcept;                                         // constexpr in C++17
+    const T* data() const noexcept;                             // constexpr in C++17
 };
 
-  template <class T, class... U>
-    array(T, U...) -> array<T, 1 + sizeof...(U)>;
+  array(T, U...) -> array<T, 1 + sizeof...(U)>;                 // C++17
 
 template <class T, size_t N>
-  bool operator==(const array<T,N>& x, const array<T,N>& y);
+  bool operator==(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
 template <class T, size_t N>
-  bool operator!=(const array<T,N>& x, const array<T,N>& y);
+  bool operator!=(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
 template <class T, size_t N>
-  bool operator<(const array<T,N>& x, const array<T,N>& y);
+  bool operator<(const array<T,N>& x, const array<T,N>& y);     // constexpr in C++20
 template <class T, size_t N>
-  bool operator>(const array<T,N>& x, const array<T,N>& y);
+  bool operator>(const array<T,N>& x, const array<T,N>& y);     // constexpr in C++20
 template <class T, size_t N>
-  bool operator<=(const array<T,N>& x, const array<T,N>& y);
+  bool operator<=(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
 template <class T, size_t N>
-  bool operator>=(const array<T,N>& x, const array<T,N>& y);
+  bool operator>=(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
 
 template <class T, size_t N >
-  void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y))); // C++17
+  void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y))); // constexpr in C++20
+
+template <class T, size_t N>
+  constexpr array<remove_cv_t<T>, N> to_array(T (&a)[N]);  // C++20
+template <class T, size_t N>
+  constexpr array<remove_cv_t<T>, N> to_array(T (&&a)[N]); // C++20
 
 template <class T> struct tuple_size;
 template <size_t I, class T> struct tuple_element;
 template <class T, size_t N> struct tuple_size<array<T, N>>;
 template <size_t I, class T, size_t N> struct tuple_element<I, array<T, N>>;
-template <size_t I, class T, size_t N> T& get(array<T, N>&) noexcept; // constexpr in C++14
-template <size_t I, class T, size_t N> const T& get(const array<T, N>&) noexcept; // constexpr in C++14
-template <size_t I, class T, size_t N> T&& get(array<T, N>&&) noexcept; // constexpr in C++14
+template <size_t I, class T, size_t N> T& get(array<T, N>&) noexcept;               // constexpr in C++14
+template <size_t I, class T, size_t N> const T& get(const array<T, N>&) noexcept;   // constexpr in C++14
+template <size_t I, class T, size_t N> T&& get(array<T, N>&&) noexcept;             // constexpr in C++14
 template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexcept; // constexpr in C++14
 
 }  // std
 
 */
 
 #include <__config>
 #include <__tuple>
struct _LIBCPP_TEMPLATE_VIS array
     typedef size_t                                size_type;
     typedef ptrdiff_t                             difference_type;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
     _Tp __elems_[_Size];
 
     // No explicit construct/copy/destroy for aggregate type
-    _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u) {
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    void fill(const value_type& __u) {
       _VSTD::fill_n(__elems_, _Size, __u);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
       std::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);
     }
 
     // iterators:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     iterator begin() _NOEXCEPT {return iterator(data());}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
     typedef const value_type*                     const_iterator;
     typedef value_type*                           pointer;
     typedef const value_type*                     const_pointer;
     typedef size_t                                size_type;
     typedef ptrdiff_t                             difference_type;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
+#ifndef _LIBCPP_CXX03_LANG
+    union __wrapper {
+        _LIBCPP_CONSTEXPR __wrapper() : __b() { }
+        ~__wrapper() = default;
+
+        bool __b;
+        _Tp __t;
+    } __w;
+
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    value_type* data() _NOEXCEPT {return &__w.__t;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    const value_type* data() const _NOEXCEPT {return &__w.__t;}
+#else // C++03
     typedef typename conditional<is_const<_Tp>::value, const char,
                                 char>::type _CharType;
 
     struct  _ArrayInStructT { _Tp __data_[1]; };
     _ALIGNAS_TYPE(_ArrayInStructT) _CharType __elems_[sizeof(_ArrayInStructT)];
 
+    _LIBCPP_INLINE_VISIBILITY
+    value_type* data() _NOEXCEPT {return reinterpret_cast<value_type*>(__elems_);}
+    _LIBCPP_INLINE_VISIBILITY
+    const value_type* data() const _NOEXCEPT {return reinterpret_cast<const value_type*>(__elems_);}
+#endif
+
     // No explicit construct/copy/destroy for aggregate type
-    _LIBCPP_INLINE_VISIBILITY void fill(const value_type&) {
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    void fill(const value_type&) {
       static_assert(!is_const<_Tp>::value,
                     "cannot fill zero-sized array of type 'const T'");
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void swap(array&) _NOEXCEPT {
       static_assert(!is_const<_Tp>::value,
                     "cannot swap zero-sized array of type 'const T'");
     }
 
     // iterators:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     iterator begin() _NOEXCEPT {return iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     iterator end() _NOEXCEPT {return iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator end() const _NOEXCEPT {return const_iterator(data());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator cbegin() const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
 
     // capacity:
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return 0; }
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return 0;}
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return true;}
 
     // element access:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator[](size_type) _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
       _LIBCPP_UNREACHABLE();
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference operator[](size_type) const _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
       _LIBCPP_UNREACHABLE();
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference at(size_type) {
       __throw_out_of_range("array<T, 0>::at");
       _LIBCPP_UNREACHABLE();
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference at(size_type) const {
       __throw_out_of_range("array<T, 0>::at");
       _LIBCPP_UNREACHABLE();
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference front() _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
       _LIBCPP_UNREACHABLE();
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference front() const _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
       _LIBCPP_UNREACHABLE();
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference back() _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
       _LIBCPP_UNREACHABLE();
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference back() const _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
       _LIBCPP_UNREACHABLE();
     }
-
-    _LIBCPP_INLINE_VISIBILITY
-    value_type* data() _NOEXCEPT {return reinterpret_cast<value_type*>(__elems_);}
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type* data() const _NOEXCEPT {return reinterpret_cast<const value_type*>(__elems_);}
 };
 
 
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template<class _Tp, class... _Args,
          class = _EnableIf<__all<_IsSame<_Tp, _Args>::value...>::value>
          >
 array(_Tp, _Args...)
   -> array<_Tp, 1 + sizeof...(_Args)>;

 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR_AFTER_CXX17 bool
 operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
     return !(__x < __y);
 }
 
 template <class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     _Size == 0 ||
     __is_swappable<_Tp>::value,
     void
 >::type
 swap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y)
                                   _NOEXCEPT_(noexcept(__x.swap(__y)))

libcxx/include/version

 Macro name                                              Value   Headers
 __cpp_lib_addressof_constexpr                           201603L <memory>
 __cpp_lib_allocator_traits_is_always_equal              201411L <memory> <scoped_allocator> <string>
                                                                 <deque> <forward_list> <list>
                                                                 <vector> <map> <set>
                                                                 <unordered_map> <unordered_set>
 __cpp_lib_any                                           201606L <any>
 __cpp_lib_apply                                         201603L <tuple>
-__cpp_lib_array_constexpr                               201603L <iterator> <array>
+__cpp_lib_array_constexpr                               201811L <iterator> <array>
+                                                        201603L // C++17
 __cpp_lib_as_const                                      201510L <utility>
 __cpp_lib_atomic_is_always_lock_free                    201603L <atomic>
 __cpp_lib_atomic_ref                                    201806L <atomic>
 __cpp_lib_bind_front                                    201811L <functional>
 __cpp_lib_bit_cast                                      201806L <bit>
 __cpp_lib_bool_constant                                 201505L <type_traits>
 __cpp_lib_boyer_moore_searcher                          201603L <functional>
 __cpp_lib_byte                                          201603L <cstddef>

 # define __cpp_lib_type_trait_variable_templates        201510L
 # define __cpp_lib_uncaught_exceptions                  201411L
 # define __cpp_lib_unordered_map_try_emplace            201411L
 # define __cpp_lib_variant                              201606L
 # define __cpp_lib_void_t                               201411L
 #endif
 
 #if _LIBCPP_STD_VER > 17
+# undef  __cpp_lib_array_constexpr
+# define __cpp_lib_array_constexpr                      201811L
 # if !defined(_LIBCPP_HAS_NO_THREADS)
 // #   define __cpp_lib_atomic_ref                         201806L
 # endif
 // # define __cpp_lib_bind_front                           201811L
 // # define __cpp_lib_bit_cast                             201806L
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif

libcxx/test/std/containers/sequences/array/aggregate.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
+//
+//===----------------------------------------------------------------------===//
+
+// Make sure std::array is an aggregate type.
+
+#include <array>
+#include <type_traits>
+
+template <typename T>
+void tests()
+{
+    // Test aggregate initialization
+    {
+        std::array<T, 0> a0 = {}; (void)a0;
+        std::array<T, 1> a1 = {T()}; (void)a1;
+        std::array<T, 2> a2 = {T(), T()}; (void)a2;
+        std::array<T, 3> a3 = {T(), T(), T()}; (void)a3;
+    }
+
+    // Test the is_aggregate trait.
+#if TEST_STD_VER >= 17 // The trait is only available in C++17 and above
+    static_assert(std::is_aggregate<std::array<T, 0> >::value, "");
+    static_assert(std::is_aggregate<std::array<T, 1> >::value, "");
+    static_assert(std::is_aggregate<std::array<T, 2> >::value, "");
+    static_assert(std::is_aggregate<std::array<T, 3> >::value, "");
+    static_assert(std::is_aggregate<std::array<T, 4> >::value, "");
+#endif
+}
+
+struct Empty { };
+struct NonEmpty { int i; int j; };
+
+int main(int, char**)
+{
+    tests<char>();
+    tests<int>();
+    tests<long>();
+    tests<float>();
+    tests<double>();
+    tests<long double>();
+    tests<NonEmpty>();
+    tests<Empty>();
+
+    return 0;
+}

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

 #include <cstddef>
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 #include "test_macros.h"
 
-int main(int, char**)
+constexpr bool tests()
 {
     //  Test the explicit deduction guides
     {
         std::array arr{1,2,3};  // array(T, U...)
         static_assert(std::is_same_v<decltype(arr), std::array<int, 3>>, "");
         assert(arr[0] == 1);
         assert(arr[1] == 2);
         assert(arr[2] == 3);
     }
 
     {
         const long l1 = 42;
         std::array arr{1L, 4L, 9L, l1}; // array(T, U...)
         static_assert(std::is_same_v<decltype(arr)::value_type, long>, "");
         static_assert(arr.size() == 4, "");
         assert(arr[0] == 1);
         assert(arr[1] == 4);
         assert(arr[2] == 9);
         assert(arr[3] == l1);
     }
 
     //  Test the implicit deduction guides
     {
         std::array<double, 2> source = {4.0, 5.0};
         std::array arr(source);   // array(array)
         static_assert(std::is_same_v<decltype(arr), decltype(source)>, "");
         static_assert(std::is_same_v<decltype(arr), std::array<double, 2>>, "");
         assert(arr[0] == 4.0);
         assert(arr[1] == 5.0);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+    static_assert(tests(), "");
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.cons/default.pass.cpp

 #include <cassert>
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "test_macros.h"
 #include "disable_missing_braces_warning.h"
 
 struct NoDefault {
-  NoDefault(int) {}
+    TEST_CONSTEXPR NoDefault(int) { }
 };
 
-int main(int, char**)
+struct Default {
+    TEST_CONSTEXPR Default() { }
+};
+
+TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        C c;
-        assert(c.size() == 3);
+        std::array<Default, 3> array;
+        assert(array.size() == 3);
     }
+
     {
-        typedef double T;
-        typedef std::array<T, 0> C;
-        C c;
-        assert(c.size() == 0);
+        std::array<Default, 0> array;
+        assert(array.size() == 0);
     }
+
     {
         typedef std::array<NoDefault, 0> C;
         C c;
         assert(c.size() == 0);
         C c1 = {};
         assert(c1.size() == 0);
         C c2 = {{}};
         assert(c2.size() == 0);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 14
+    static_assert(tests(), "");
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp

 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 // In C++03 the copy assignment operator is not deleted when the implicitly
 // generated operator would be ill-formed; like in the case of a struct with a
 // const member.
 #if TEST_STD_VER < 11
-#define TEST_NOT_COPY_ASSIGNABLE(T) ((void)0)
+#   define TEST_NOT_COPY_ASSIGNABLE(T) ((void)0)
 #else
-#define TEST_NOT_COPY_ASSIGNABLE(T) static_assert(!std::is_copy_assignable<T>::value, "")
+#   define TEST_NOT_COPY_ASSIGNABLE(T) static_assert(!std::is_copy_assignable<T>::value, "")
 #endif
 
 struct NoDefault {
-  NoDefault(int) {}
+    TEST_CONSTEXPR NoDefault(int) { }
 };
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX14 bool tests()
+{
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1.1, 2.2, 3.3};
         C c2 = c;
         c2 = c;
         static_assert(std::is_copy_constructible<C>::value, "");
         static_assert(std::is_copy_assignable<C>::value, "");
     }
     {
         typedef double T;
         typedef std::array<const T, 3> C;
         C c = {1.1, 2.2, 3.3};
         C c2 = c;
         ((void)c2);
         static_assert(std::is_copy_constructible<C>::value, "");
         TEST_NOT_COPY_ASSIGNABLE(C);
     }
     {
         typedef double T;
         typedef std::array<T, 0> C;
         C c = {};
         C c2 = c;
         c2 = c;
         static_assert(std::is_copy_constructible<C>::value, "");
         static_assert(std::is_copy_assignable<C>::value, "");
     }
     {
         // const arrays of size 0 should disable the implicit copy assignment operator.
         typedef double T;
         typedef std::array<const T, 0> C;
         C c = {{}};
         C c2 = c;
         ((void)c2);
         static_assert(std::is_copy_constructible<C>::value, "");
         TEST_NOT_COPY_ASSIGNABLE(C);
     }
     {
         typedef NoDefault T;
         typedef std::array<T, 0> C;
         C c = {};
         C c2 = c;
         c2 = c;
         static_assert(std::is_copy_constructible<C>::value, "");
         static_assert(std::is_copy_assignable<C>::value, "");
     }
     {
         typedef NoDefault T;
         typedef std::array<const T, 0> C;
         C c = {{}};
         C c2 = c;
         ((void)c2);
         static_assert(std::is_copy_constructible<C>::value, "");
         TEST_NOT_COPY_ASSIGNABLE(C);
     }
 
+    return true;
+}
 
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 14
+    static_assert(tests(), "");
+#endif
     return 0;
 }

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

 #include <array>
 #include <cassert>
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "test_macros.h"
 #include "disable_missing_braces_warning.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
-        C c = {1, 2, 3.5};
+        C const c = {1, 2, 3.5};
         assert(c.size() == 3);
         assert(c[0] == 1);
         assert(c[1] == 2);
         assert(c[2] == 3.5);
     }
     {
         typedef double T;
         typedef std::array<T, 0> C;
-        C c = {};
+        C const c = {};
         assert(c.size() == 0);
     }
 
     {
         typedef double T;
         typedef std::array<T, 3> C;
-        C c = {1};
+        C const c = {1};
         assert(c.size() == 3.0);
         assert(c[0] == 1);
     }
     {
         typedef int T;
         typedef std::array<T, 1> C;
-        C c = {};
+        C const c = {};
         assert(c.size() == 1);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 14
+    static_assert(tests(), "");
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.creation/to_array.pass.cpp

 //    -> array<remove_cv_t<T>, Size>;
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main(int, char**) {
+constexpr bool tests()
+{
   //  Test deduced type.
   {
     auto arr = std::to_array({1, 2, 3});
     ASSERT_SAME_TYPE(decltype(arr), std::array<int, 3>);
     assert(arr[0] == 1);
     assert(arr[1] == 2);
     assert(arr[2] == 3);
   }
//  Test explicit type.
     };
 
     auto arr = std::to_array<A>({{3, .1}});
     ASSERT_SAME_TYPE(decltype(arr), std::array<A, 1>);
     assert(arr[0].a == 3);
     assert(arr[0].b == .1);
   }
 
-  // Test constexpr.
-  {
-    constexpr std::array<int, 3> arr = std::to_array({1, 2, 3});
-    static_assert(arr[0] == 1);
-    static_assert(arr[1] == 2);
-    static_assert(arr[2] == 3);
-  }
+  return true;
 
+int main(int, char**)
+{
+  tests();
+  static_assert(tests(), "");
   return 0;
 }

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

 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 struct NoDefault {
-  NoDefault(int) {}
+    TEST_CONSTEXPR NoDefault(int) { }
 };
 
 #if TEST_STD_VER < 11
 struct natural_alignment {
     long t1;
     long long t2;
     double t3;
     long double t4;
 };
 #endif
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
         T* p = c.data();
         assert(p[0] == 1);
         assert(p[1] == 2);
         assert(p[2] == 3.5);
     }
     {
         typedef double T;
         typedef std::array<T, 0> C;
         C c = {};
         T* p = c.data();
         LIBCPP_ASSERT(p != nullptr);
     }
     {
         typedef double T;
         typedef std::array<const T, 0> C;
         C c = {{}};
         const T* p = c.data();
+        LIBCPP_ASSERT(p != nullptr);
         static_assert((std::is_same<decltype(c.data()), const T*>::value), "");
+    }
+    {
+        typedef NoDefault T;
+        typedef std::array<T, 0> C;
+        C c = {};
+        T* p = c.data();
         LIBCPP_ASSERT(p != nullptr);
     }
     {
+        std::array<int, 5> c = {0, 1, 2, 3, 4};
+        assert(c.data() == &c[0]);
+        assert(*c.data() == c[0]);
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 17
+    static_assert(tests(), "");
+#endif
+
+    // Test the alignment of data()
+    {
 #if TEST_STD_VER < 11
         typedef natural_alignment T;
 #else
         typedef std::max_align_t T;
 #endif
         typedef std::array<T, 0> C;
         const C c = {};
         const T* p = c.data();
         LIBCPP_ASSERT(p != nullptr);
         std::uintptr_t pint = reinterpret_cast<std::uintptr_t>(p);
         assert(pint % TEST_ALIGNOF(T) == 0);
     }
-    {
-      typedef NoDefault T;
-      typedef std::array<T, 0> C;
-      C c = {};
-      T* p = c.data();
-      LIBCPP_ASSERT(p != nullptr);
-    }
-
     return 0;
 }

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

 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 struct NoDefault {
-  NoDefault(int) {}
+    TEST_CONSTEXPR NoDefault(int) { }
 };
 
 #if TEST_STD_VER < 11
 struct natural_alignment {
     long t1;
     long long t2;
     double t3;
     long double t4;
 };
 #endif
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         const C c = {1, 2, 3.5};
         const T* p = c.data();
         assert(p[0] == 1);
         assert(p[1] == 2);
         assert(p[2] == 3.5);
     }
     {
         typedef double T;
         typedef std::array<T, 0> C;
         const C c = {};
         const T* p = c.data();
-        (void)p; // to placate scan-build
+        LIBCPP_ASSERT(p != nullptr);
     }
     {
         typedef NoDefault T;
         typedef std::array<T, 0> C;
         const C c = {};
         const T* p = c.data();
         LIBCPP_ASSERT(p != nullptr);
     }
     {
+        std::array<int, 5> const c = {0, 1, 2, 3, 4};
+        assert(c.data() == &c[0]);
+        assert(*c.data() == c[0]);
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 17
+    static_assert(tests(), "");
+#endif
+
+    // Test the alignment of data()
+    {
 #if TEST_STD_VER < 11
         typedef natural_alignment T;
 #else
         typedef std::max_align_t T;
 #endif
         typedef std::array<T, 0> C;
         const C c = {};
         const T* p = c.data();
         LIBCPP_ASSERT(p != nullptr);
         std::uintptr_t pint = reinterpret_cast<std::uintptr_t>(p);
         assert(pint % TEST_ALIGNOF(T) == 0);
     }
-#if TEST_STD_VER > 14
-    {
-        typedef std::array<int, 5> C;
-        constexpr C c1{0,1,2,3,4};
-        constexpr const C c2{0,1,2,3,4};
-
-        static_assert (  c1.data()  == &c1[0], "");
-        static_assert ( *c1.data()  ==  c1[0], "");
-        static_assert (  c2.data()  == &c2[0], "");
-        static_assert ( *c2.data()  ==  c2[0], "");
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.fill/fill.pass.cpp

 #include <array>
 #include <cassert>
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "test_macros.h"
 #include "disable_missing_braces_warning.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
         c.fill(5.5);
         assert(c.size() == 3);
         assert(c[0] == 5.5);
         assert(c[1] == 5.5);
         assert(c[2] == 5.5);
     }
+
     {
         typedef double T;
         typedef std::array<T, 0> C;
         C c = {};
         c.fill(5.5);
         assert(c.size() == 0);
     }
+    return true;
+}
 
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 20
+    static_assert(tests(), "");
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.size/size.pass.cpp

#if TEST_STD_VER >= 11
         typedef std::array<T, 0> C;
         constexpr C c = {};
         static_assert(c.size() == 0, "");
         static_assert(c.max_size() == 0, "");
         static_assert(c.empty(), "");
     }
 #endif
 
     return 0;
 }

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

 #include <cassert>
 
 #include "test_macros.h"
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 struct NonSwappable {
-  NonSwappable() {}
+    TEST_CONSTEXPR NonSwappable() { }
 private:
     NonSwappable(NonSwappable const&);
     NonSwappable& operator=(NonSwappable const&);
 };
 
 template <class Tp>
 decltype(swap(std::declval<Tp>(), std::declval<Tp>()))
 can_swap_imp(int);
 
 template <class Tp>
 std::false_type can_swap_imp(...);
 
 template <class Tp>
-struct can_swap : std::is_same<decltype(can_swap_imp<Tp>(0)), void> {};
+struct can_swap : std::is_same<decltype(can_swap_imp<Tp>(0)), void> { };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c1 = {1, 2, 3.5};
         C c2 = {4, 5, 6.5};
         swap(c1, c2);
         assert(c1.size() == 3);
#if TEST_STD_VER >= 11
         // NonSwappable is still considered swappable in C++03 because there
         // is no access control SFINAE.
         typedef NonSwappable T;
         typedef std::array<T, 42> C1;
         static_assert(!can_swap<C1&>::value, "");
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 20
+    static_assert(tests(), "");
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.swap/swap.pass.cpp

 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 struct NonSwappable {
-  NonSwappable() {}
+    TEST_CONSTEXPR NonSwappable() { }
 private:
     NonSwappable(NonSwappable const&);
     NonSwappable& operator=(NonSwappable const&);
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c1 = {1, 2, 3.5};
         C c2 = {4, 5, 6.5};
         c1.swap(c2);
         assert(c1.size() == 3);
TEST_CONSTEXPR_CXX20 bool tests()
         C0 l = {};
         C0 r = {};
         l.swap(r);
 #if TEST_STD_VER >= 11
         static_assert(noexcept(l.swap(r)), "");
 #endif
     }
 
+    return true;
+}
 
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 20
+    static_assert(tests(), "");
+#endif
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/get.pass.cpp

 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 
-#if TEST_STD_VER > 11
-struct S {
-   std::array<int, 3> a;
-   int k;
-   constexpr S() : a{1,2,3}, k(std::get<2>(a)) {}
-};
-
-constexpr std::array<int, 2> getArr () { return { 3, 4 }; }
-#endif
+template <typename ...T>
+TEST_CONSTEXPR std::array<int, sizeof...(T)> tempArray(T ...args)
+{
+    return {args...};
+}
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        C c = {1, 2, 3.5};
-        std::get<1>(c) = 5.5;
-        assert(c[0] == 1);
-        assert(c[1] == 5.5);
-        assert(c[2] == 3.5);
-    }
-#if TEST_STD_VER > 11
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        constexpr C c = {1, 2, 3.5};
-        static_assert(std::get<0>(c) == 1, "");
-        static_assert(std::get<1>(c) == 2, "");
-        static_assert(std::get<2>(c) == 3.5, "");
+        std::array<double, 1> array = {3.3};
+        assert(std::get<0>(array) == 3.3);
+        std::get<0>(array) = 99.1;
+        assert(std::get<0>(array) == 99.1);
     }
     {
-        static_assert(S().k == 3, "");
-        static_assert(std::get<1>(getArr()) == 4, "");
-    }
-#endif
+        std::array<double, 2> array = {3.3, 4.4};
+        assert(std::get<0>(array) == 3.3);
+        assert(std::get<1>(array) == 4.4);
+        std::get<0>(array) = 99.1;
+        std::get<1>(array) = 99.2;
+        assert(std::get<0>(array) == 99.1);
+        assert(std::get<1>(array) == 99.2);
+    }
+    {
+        std::array<double, 3> array = {3.3, 4.4, 5.5};
+        assert(std::get<0>(array) == 3.3);
+        assert(std::get<1>(array) == 4.4);
+        assert(std::get<2>(array) == 5.5);
+        std::get<1>(array) = 99.2;
+        assert(std::get<0>(array) == 3.3);
+        assert(std::get<1>(array) == 99.2);
+        assert(std::get<2>(array) == 5.5);
+    }
+    {
+        std::array<double, 1> array = {3.3};
+        static_assert(std::is_same<double&, decltype(std::get<0>(array))>::value, "");
+    }
+    {
+        assert(std::get<0>(tempArray(1, 2, 3)) == 1);
+        assert(std::get<1>(tempArray(1, 2, 3)) == 2);
+        assert(std::get<2>(tempArray(1, 2, 3)) == 3);
+    }
+
+    return true;
 
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 14
+    static_assert(tests(), "");
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/get_const.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        const C c = {1, 2, 3.5};
-        assert(std::get<0>(c) == 1);
-        assert(std::get<1>(c) == 2);
-        assert(std::get<2>(c) == 3.5);
-    }
-#if TEST_STD_VER > 11
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        constexpr const C c = {1, 2, 3.5};
-        static_assert(std::get<0>(c) == 1, "");
-        static_assert(std::get<1>(c) == 2, "");
-        static_assert(std::get<2>(c) == 3.5, "");
-    }
-#endif
+        std::array<double, 1> const array = {3.3};
+        assert(std::get<0>(array) == 3.3);
+    }
+    {
+        std::array<double, 2> const array = {3.3, 4.4};
+        assert(std::get<0>(array) == 3.3);
+        assert(std::get<1>(array) == 4.4);
+    }
+    {
+        std::array<double, 3> const array = {3.3, 4.4, 5.5};
+        assert(std::get<0>(array) == 3.3);
+        assert(std::get<1>(array) == 4.4);
+        assert(std::get<2>(array) == 5.5);
+    }
+    {
+        std::array<double, 1> const array = {3.3};
+        static_assert(std::is_same<double const&, decltype(std::get<0>(array))>::value, "");
+    }
+
+    return true;
 
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 14
+    static_assert(tests(), "");
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp

 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 int main(int, char**)
 {
 
     {
         typedef std::unique_ptr<double> T;
         typedef std::array<T, 1> C;
         const C c = {std::unique_ptr<double>(new double(3.5))};
         static_assert(std::is_same<const T&&, decltype(std::get<0>(std::move(c)))>::value, "");
         static_assert(noexcept(std::get<0>(std::move(c))), "");
         const T&& t = std::get<0>(std::move(c));
         assert(*t == 3.5);
     }
 
-#if TEST_STD_VER > 11
+#if TEST_STD_VER >= 14
     {
         typedef double T;
         typedef std::array<T, 3> C;
         constexpr const C c = {1, 2, 3.5};
         static_assert(std::get<0>(std::move(c)) == 1, "");
         static_assert(std::get<1>(std::move(c)) == 2, "");
         static_assert(std::get<2>(std::move(c)) == 3.5, "");
     }
 #endif
 
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp

int main(int, char**)
     {
         typedef std::unique_ptr<double> T;
         typedef std::array<T, 1> C;
         C c = {std::unique_ptr<double>(new double(3.5))};
         T t = std::get<0>(std::move(c));
         assert(*t == 3.5);
     }
 
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp

 // Prevent -Warray-bounds from issuing a diagnostic when testing with clang verify.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Warray-bounds"
 #endif
 
 #include <array>
 #include <cassert>
 
-
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 int main(int, char**)
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         std::tuple_element<3, C> foo; // expected-note {{requested here}}
         // expected-error-re@array:* {{static_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}} "Index out of bounds in std::tuple_element<> (std::array)"}}
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/at.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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
-// reference operator[] (size_type)
-// const_reference operator[] (size_type); // constexpr in C++14
-// reference at (size_type)
-// const_reference at (size_type); // constexpr in C++14
+// reference at (size_type); // constexpr in C++17
 
 #include <array>
 #include <cassert>
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 #include <stdexcept>
 #endif
 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-#if TEST_STD_VER > 14
-constexpr bool check_idx( size_t idx, double val )
-{
-    std::array<double, 3> arr = {1, 2, 3.5};
-    return arr.at(idx) == val;
-}
-#endif
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
-        C::reference r1 = c.at(0);
+        typename C::reference r1 = c.at(0);
         assert(r1 == 1);
         r1 = 5.5;
-        assert(c.front() == 5.5);
+        assert(c[0] == 5.5);
 
-        C::reference r2 = c.at(2);
+        typename C::reference r2 = c.at(2);
         assert(r2 == 3.5);
         r2 = 7.5;
-        assert(c.back() == 7.5);
-
-#ifndef TEST_HAS_NO_EXCEPTIONS
-        try
-        {
-            TEST_IGNORE_NODISCARD  c.at(3);
-            assert(false);
-        }
-        catch (const std::out_of_range &) {}
-#endif
-    }
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    {
-        typedef double T;
-        typedef std::array<T, 0> C;
-        C c = {};
-        C const& cc = c;
-        try
-        {
-            TEST_IGNORE_NODISCARD  c.at(0);
+        assert(c[2] == 7.5);
+    return true;
+
+void test_exceptions()
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        std::array<int, 4> array = {1, 2, 3, 4};
+
+        try {
+            TEST_IGNORE_NODISCARD array.at(4);
             assert(false);
-        }
-        catch (const std::out_of_range &) {}
-        try
-        {
-            TEST_IGNORE_NODISCARD  cc.at(0);
+        } catch (std::out_of_range const&) {
+            // pass
+        } catch (...) {
             assert(false);
         }
-        catch (const std::out_of_range &) {}
+
+        try {
+            TEST_IGNORE_NODISCARD array.at(5);
+            assert(false);
+        } catch (std::out_of_range const&) {
+            // pass
+        } catch (...) {
+            assert(false);
         }
-#endif
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        const C c = {1, 2, 3.5};
-        C::const_reference r1 = c.at(0);
-        assert(r1 == 1);
 
-        C::const_reference r2 = c.at(2);
-        assert(r2 == 3.5);
+        try {
+            TEST_IGNORE_NODISCARD array.at(6);
+            assert(false);
+        } catch (std::out_of_range const&) {
+            // pass
+        } catch (...) {
+            assert(false);
+        }
 
-#ifndef TEST_HAS_NO_EXCEPTIONS
-        try
-        {
-            TEST_IGNORE_NODISCARD  c.at(3);
+        try {
+            TEST_IGNORE_NODISCARD array.at(-1);
+            assert(false);
+        } catch (std::out_of_range const&) {
+            // pass
+        } catch (...) {
             assert(false);
         }
-        catch (const std::out_of_range &) {}
-#endif
     }
 
-#if TEST_STD_VER > 11
     {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        constexpr C c = {1, 2, 3.5};
-
-        constexpr T t1 = c.at(0);
-        static_assert (t1 == 1, "");
+        std::array<int, 0> array = {};
 
-        constexpr T t2 = c.at(2);
-        static_assert (t2 == 3.5, "");
+        try {
+            TEST_IGNORE_NODISCARD array.at(0);
+            assert(false);
+        } catch (std::out_of_range const&) {
+            // pass
+        } catch (...) {
+            assert(false);
+        }
     }
 #endif
+}
 
-#if TEST_STD_VER > 14
-    {
-        static_assert (check_idx(0, 1), "");
-        static_assert (check_idx(1, 2), "");
-        static_assert (check_idx(2, 3.5), "");
-    }
-#endif
+int main(int, char**)
+    tests();
+    test_exceptions();
 
+#if TEST_STD_VER >= 17
+    static_assert(tests(), "");
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/array/at_const.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
+//
+//===----------------------------------------------------------------------===//
+
+// <array>
+
+// const_reference at (size_type) const; // constexpr in C++14
+
+#include <array>
+#include <cassert>
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+#include <stdexcept>
+#endif
+
+#include "test_macros.h"
+
+// std::array is explicitly allowed to be initialized with A a = { init-list };.
+// Disable the missing braces warning for this reason.
+#include "disable_missing_braces_warning.h"
+
+
+TEST_CONSTEXPR_CXX14 bool tests()
+{
+    {
+        typedef double T;
+        typedef std::array<T, 3> C;
+        C const c = {1, 2, 3.5};
+        typename C::const_reference r1 = c.at(0);
+        assert(r1 == 1);
+
+        typename C::const_reference r2 = c.at(2);
+        assert(r2 == 3.5);
+    }
+    return true;
+}
+
+void test_exceptions()
+{
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        std::array<int, 4> const array = {1, 2, 3, 4};
+
+        try {
+            TEST_IGNORE_NODISCARD array.at(4);
+            assert(false);
+        } catch (std::out_of_range const&) {
+            // pass
+        } catch (...) {
+            assert(false);
+        }
+
+        try {
+            TEST_IGNORE_NODISCARD array.at(5);
+            assert(false);
+        } catch (std::out_of_range const&) {
+            // pass
+        } catch (...) {
+            assert(false);
+        }
+
+        try {
+            TEST_IGNORE_NODISCARD array.at(6);
+            assert(false);
+        } catch (std::out_of_range const&) {
+            // pass
+        } catch (...) {
+            assert(false);
+        }
+
+        try {
+            TEST_IGNORE_NODISCARD array.at(-1);
+            assert(false);
+        } catch (std::out_of_range const&) {
+            // pass
+        } catch (...) {
+            assert(false);
+        }
+    }
+
+    {
+        std::array<int, 0> array = {};
+
+        try {
+            TEST_IGNORE_NODISCARD array.at(0);
+            assert(false);
+        } catch (std::out_of_range const&) {
+            // pass
+        } catch (...) {
+            assert(false);
+        }
+    }
+#endif
+}
+
+int main(int, char**)
+{
+    tests();
+    test_exceptions();
+
+#if TEST_STD_VER >= 14
+    static_assert(tests(), "");
+#endif
+    return 0;
+}

libcxx/test/std/containers/sequences/array/begin.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
-//
-//===----------------------------------------------------------------------===//
-
-// <array>
-
-// iterator begin();
-
-#include <array>
-#include <cassert>
-
-#include "test_macros.h"
-
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-struct NoDefault {
-  NoDefault(int) {}
-};
-
-
-int main(int, char**)
-{
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        C c = {1, 2, 3.5};
-        C::iterator i;
-        i = c.begin();
-        assert(*i == 1);
-        assert(&*i == c.data());
-        *i = 5.5;
-        assert(c[0] == 5.5);
-    }
-    {
-      typedef NoDefault T;
-      typedef std::array<T, 0> C;
-      C c = {};
-      C::iterator ib, ie;
-      ib = c.begin();
-      ie = c.end();
-      assert(ib == ie);
-      LIBCPP_ASSERT(ib != nullptr);
-      LIBCPP_ASSERT(ie != nullptr);
-    }
-
-  return 0;
-}

libcxx/test/std/containers/sequences/array/compare.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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
-//  These are all constexpr in C++20
-// bool operator==(array<T, N> const&, array<T, N> const&);
-// bool operator!=(array<T, N> const&, array<T, N> const&);
-// bool operator<(array<T, N> const&, array<T, N> const&);
-// bool operator<=(array<T, N> const&, array<T, N> const&);
-// bool operator>(array<T, N> const&, array<T, N> const&);
-// bool operator>=(array<T, N> const&, array<T, N> const&);
+// bool operator==(array<T, N> const&, array<T, N> const&);   // constexpr in C++20
+// bool operator!=(array<T, N> const&, array<T, N> const&);   // constexpr in C++20
+// bool operator<(array<T, N> const&, array<T, N> const&);    // constexpr in C++20
+// bool operator<=(array<T, N> const&, array<T, N> const&);   // constexpr in C++20
+// bool operator>(array<T, N> const&, array<T, N> const&);    // constexpr in C++20
+// bool operator>=(array<T, N> const&, array<T, N> const&);   // constexpr in C++20
 
 
 #include <array>
-#include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
-    typedef int T;
-    typedef std::array<T, 3> C;
+        typedef std::array<int, 3> C;
         C c1 = {1, 2, 3};
         C c2 = {1, 2, 3};
         C c3 = {3, 2, 1};
         C c4 = {1, 2, 1};
         assert(testComparisons6(c1, c2, true, false));
         assert(testComparisons6(c1, c3, false, true));
         assert(testComparisons6(c1, c4, false, false));
     }
     {
-    typedef int T;
-    typedef std::array<T, 0> C;
+        typedef std::array<int, 0> C;
         C c1 = {};
         C c2 = {};
         assert(testComparisons6(c1, c2, true, false));
     }
 
-#if TEST_STD_VER > 17
-  {
-  constexpr std::array<int, 3> a1 = {1, 2, 3};
-  constexpr std::array<int, 3> a2 = {2, 3, 4};
-  static_assert(testComparisons6(a1, a1, true, false), "");
-  static_assert(testComparisons6(a1, a2, false, true), "");
-  static_assert(testComparisons6(a2, a1, false, false), "");
-  }
-#endif
+    return true;
 
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 20
+    static_assert(tests(), "");
+#endif
     return 0;
 }

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

 
 // An array is a contiguous container
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 
-template <class C>
-void test_contiguous ( const C &c )
+template <class Container>
+TEST_CONSTEXPR_CXX14 void assert_contiguous(Container const& c)
 {
-    for ( size_t i = 0; i < c.size(); ++i )
-        assert ( *(c.begin() + i) == *(std::addressof(*c.begin()) + i));
+    for (size_t i = 0; i < c.size(); ++i)
+        assert(*(c.begin() + i) == *(std::addressof(*c.begin()) + i));
 }
 
-int main(int, char**)
-{
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        test_contiguous (C());
-    }
+TEST_CONSTEXPR_CXX17 bool tests()
+    assert_contiguous(std::array<double, 0>());
+    assert_contiguous(std::array<double, 1>());
+    assert_contiguous(std::array<double, 2>());
+    assert_contiguous(std::array<double, 3>());
+
+    assert_contiguous(std::array<char, 0>());
+    assert_contiguous(std::array<char, 1>());
+    assert_contiguous(std::array<char, 2>());
+    assert_contiguous(std::array<char, 3>());
+
+    return true;
 
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 17 // begin() & friends are constexpr in >= C++17 only
+    static_assert(tests(), "");
+#endif
     return 0;
 }

libcxx/test/std/containers/sequences/array/empty.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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // class array
 
-// bool empty() const noexcept;
+// constexpr bool empty() const noexcept;
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
-#include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
         typedef std::array<int, 2> C;
-    C c;
+        C c = {};
         ASSERT_NOEXCEPT(c.empty());
         assert(!c.empty());
     }
     {
         typedef std::array<int, 0> C;
-    C c;
+        C c = {};
         ASSERT_NOEXCEPT(c.empty());
-    assert( c.empty());
+        assert(c.empty());
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 14
+    static_assert(tests(), "");
+#endif
+
+#if TEST_STD_VER >= 11
+    // Sanity check for constexpr in C++11
+    {
+        constexpr std::array<int, 3> array = {};
+        static_assert(!array.empty(), "");
+    }
+#endif
+
     return 0;
 }

libcxx/test/std/containers/sequences/array/front_back.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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
-// reference front();       // constexpr in C++17
-// reference back();        // constexpr in C++17
-// const_reference front(); // constexpr in C++14
-// const_reference back();  // constexpr in C++14
+// reference front();  // constexpr in C++17
+// reference back();   // constexpr in C++17
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-#if TEST_STD_VER > 14
-constexpr bool check_front( double val )
-{
-    std::array<double, 3> arr = {1, 2, 3.5};
-    return arr.front() == val;
-}
-
-constexpr bool check_back( double val )
-{
-    std::array<double, 3> arr = {1, 2, 3.5};
-    return arr.back() == val;
-}
-#endif
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
 
         C::reference r1 = c.front();
         assert(r1 == 1);
         r1 = 5.5;
         assert(c[0] == 5.5);
 
         C::reference r2 = c.back();
         assert(r2 == 3.5);
         r2 = 7.5;
         assert(c[2] == 7.5);
     }
     {
         typedef double T;
-        typedef std::array<T, 3> C;
-        const C c = {1, 2, 3.5};
-        C::const_reference r1 = c.front();
-        assert(r1 == 1);
-
-        C::const_reference r2 = c.back();
-        assert(r2 == 3.5);
-    }
-    {
-      typedef double T;
         typedef std::array<T, 0> C;
         C c = {};
-      C const& cc = c;
-      ASSERT_SAME_TYPE(decltype( c.back()), typename C::reference);
-      ASSERT_SAME_TYPE(decltype(cc.back()), typename C::const_reference);
-      LIBCPP_ASSERT_NOEXCEPT(    c.back());
-      LIBCPP_ASSERT_NOEXCEPT(   cc.back());
-      ASSERT_SAME_TYPE(decltype( c.front()), typename C::reference);
-      ASSERT_SAME_TYPE(decltype(cc.front()), typename C::const_reference);
-      LIBCPP_ASSERT_NOEXCEPT(    c.front());
-      LIBCPP_ASSERT_NOEXCEPT(   cc.front());
+        ASSERT_SAME_TYPE(decltype(c.back()), C::reference);
+        LIBCPP_ASSERT_NOEXCEPT(c.back());
+        ASSERT_SAME_TYPE(decltype(c.front()), C::reference);
+        LIBCPP_ASSERT_NOEXCEPT(c.front());
         if (c.size() > (0)) { // always false
             TEST_IGNORE_NODISCARD c.front();
             TEST_IGNORE_NODISCARD c.back();
-        TEST_IGNORE_NODISCARD cc.front();
-        TEST_IGNORE_NODISCARD cc.back();
         }
     }
     {
         typedef double T;
         typedef std::array<const T, 0> C;
-      C c = {{}};
-      C const& cc = c;
-      ASSERT_SAME_TYPE(decltype( c.back()), typename C::reference);
-      ASSERT_SAME_TYPE(decltype(cc.back()), typename C::const_reference);
+        C c = {};
+        ASSERT_SAME_TYPE(decltype( c.back()), C::reference);
         LIBCPP_ASSERT_NOEXCEPT(    c.back());
-      LIBCPP_ASSERT_NOEXCEPT(   cc.back());
-      ASSERT_SAME_TYPE(decltype( c.front()), typename C::reference);
-      ASSERT_SAME_TYPE(decltype(cc.front()), typename C::const_reference);
+        ASSERT_SAME_TYPE(decltype( c.front()), C::reference);
         LIBCPP_ASSERT_NOEXCEPT(    c.front());
-      LIBCPP_ASSERT_NOEXCEPT(   cc.front());
         if (c.size() > (0)) {
             TEST_IGNORE_NODISCARD c.front();
             TEST_IGNORE_NODISCARD c.back();
-        TEST_IGNORE_NODISCARD cc.front();
-        TEST_IGNORE_NODISCARD cc.back();
         }
     }
-#if TEST_STD_VER > 11
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        constexpr C c = {1, 2, 3.5};
 
-        constexpr T t1 = c.front();
-        static_assert (t1 == 1, "");
-
-        constexpr T t2 = c.back();
-        static_assert (t2 == 3.5, "");
-    }
-#endif
+    return true;
 
-#if TEST_STD_VER > 14
-    {
-        static_assert (check_front(1),   "");
-        static_assert (check_back (3.5), "");
-    }
+int main(int, char**)
+    tests();
+#if TEST_STD_VER >= 17
+    static_assert(tests(), "");
 #endif
-
     return 0;
 }

libcxx/test/std/containers/sequences/array/front_back_const.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
+//
+//===----------------------------------------------------------------------===//
+
+// <array>
+
+// const_reference front() const; // constexpr in C++14
+// const_reference back() const;  // constexpr in C++14
+
+#include <array>
+#include <cassert>
+
+#include "test_macros.h"
+
+// std::array is explicitly allowed to be initialized with A a = { init-list };.
+// Disable the missing braces warning for this reason.
+#include "disable_missing_braces_warning.h"
+
+
+TEST_CONSTEXPR_CXX14 bool tests()
+{
+    {
+        typedef double T;
+        typedef std::array<T, 3> C;
+        C const c = {1, 2, 3.5};
+        C::const_reference r1 = c.front();
+        assert(r1 == 1);
+
+        C::const_reference r2 = c.back();
+        assert(r2 == 3.5);
+    }
+    {
+        typedef double T;
+        typedef std::array<T, 0> C;
+        C const c = {};
+        ASSERT_SAME_TYPE(decltype(c.back()), C::const_reference);
+        LIBCPP_ASSERT_NOEXCEPT(c.back());
+        ASSERT_SAME_TYPE(decltype(c.front()), C::const_reference);
+        LIBCPP_ASSERT_NOEXCEPT(c.front());
+        if (c.size() > (0)) { // always false
+            TEST_IGNORE_NODISCARD c.front();
+            TEST_IGNORE_NODISCARD c.back();
+        }
+    }
+    {
+        typedef double T;
+        typedef std::array<const T, 0> C;
+        C const c = {};
+        ASSERT_SAME_TYPE(decltype(c.back()), C::const_reference);
+        LIBCPP_ASSERT_NOEXCEPT(c.back());
+        ASSERT_SAME_TYPE(decltype(c.front()), C::const_reference);
+        LIBCPP_ASSERT_NOEXCEPT(c.front());
+        if (c.size() > (0)) {
+            TEST_IGNORE_NODISCARD c.front();
+            TEST_IGNORE_NODISCARD c.back();
+        }
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 14
+    static_assert(tests(), "");
+#endif
+    return 0;
+}

libcxx/test/std/containers/sequences/array/indexing.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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
-// reference operator[] (size_type)
-// const_reference operator[] (size_type); // constexpr in C++14
-// reference at (size_type)
-// const_reference at (size_type); // constexpr in C++14
-// Libc++ marks these as noexcept
+// reference operator[](size_type); // constexpr in C++17
+// Libc++ marks it as noexcept
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-#if TEST_STD_VER > 14
-constexpr bool check_idx( size_t idx, double val )
-{
-    std::array<double, 3> arr = {1, 2, 3.5};
-    return arr[idx] == val;
-}
-#endif
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
         LIBCPP_ASSERT_NOEXCEPT(c[0]);
         ASSERT_SAME_TYPE(C::reference, decltype(c[0]));
         C::reference r1 = c[0];
         assert(r1 == 1);
         r1 = 5.5;
         assert(c.front() == 5.5);
 
         C::reference r2 = c[2];
         assert(r2 == 3.5);
         r2 = 7.5;
         assert(c.back() == 7.5);
     }
+
+    // Test operator[] "works" on zero sized arrays
+    {
         {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        const C c = {1, 2, 3.5};
-        LIBCPP_ASSERT_NOEXCEPT(c[0]);
-        ASSERT_SAME_TYPE(C::const_reference, decltype(c[0]));
-        C::const_reference r1 = c[0];
-        assert(r1 == 1);
-        C::const_reference r2 = c[2];
-        assert(r2 == 3.5);
-    }
-    { // Test operator[] "works" on zero sized arrays
             typedef double T;
             typedef std::array<T, 0> C;
             C c = {};
-        C const& cc = c;
             LIBCPP_ASSERT_NOEXCEPT(c[0]);
-        LIBCPP_ASSERT_NOEXCEPT(cc[0]);
             ASSERT_SAME_TYPE(C::reference, decltype(c[0]));
-        ASSERT_SAME_TYPE(C::const_reference, decltype(cc[0]));
             if (c.size() > (0)) { // always false
-          C::reference r1 = c[0];
-          C::const_reference r2 = cc[0];
-          ((void)r1);
-          ((void)r2);
+              C::reference r = c[0];
+              (void)r;
             }
         }
-    { // Test operator[] "works" on zero sized arrays
+        {
             typedef double T;
             typedef std::array<const T, 0> C;
-        C c = {{}};
-        C const& cc = c;
+            C c = {};
             LIBCPP_ASSERT_NOEXCEPT(c[0]);
-        LIBCPP_ASSERT_NOEXCEPT(cc[0]);
             ASSERT_SAME_TYPE(C::reference, decltype(c[0]));
-        ASSERT_SAME_TYPE(C::const_reference, decltype(cc[0]));
             if (c.size() > (0)) { // always false
-          C::reference r1 = c[0];
-          C::const_reference r2 = cc[0];
-          ((void)r1);
-          ((void)r2);
+              C::reference r = c[0];
+              (void)r;
+            }
         }
     }
-#if TEST_STD_VER > 11
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        constexpr C c = {1, 2, 3.5};
-        LIBCPP_ASSERT_NOEXCEPT(c[0]);
-        ASSERT_SAME_TYPE(C::const_reference, decltype(c[0]));
-
-        constexpr T t1 = c[0];
-        static_assert (t1 == 1, "");
 
-        constexpr T t2 = c[2];
-        static_assert (t2 == 3.5, "");
-    }
-#endif
+    return true;
 
-#if TEST_STD_VER > 14
-    {
-        static_assert (check_idx(0, 1), "");
-        static_assert (check_idx(1, 2), "");
-        static_assert (check_idx(2, 3.5), "");
-    }
+int main(int, char**)
+    tests();
+#if TEST_STD_VER >= 17
+    static_assert(tests(), "");
 #endif
-
     return 0;
 }

libcxx/test/std/containers/sequences/array/indexing_const.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
+//
+//===----------------------------------------------------------------------===//
+
+// <array>
+
+// const_reference operator[](size_type) const; // constexpr in C++14
+// Libc++ marks it as noexcept
+
+#include <array>
+#include <cassert>
+
+#include "test_macros.h"
+
+// std::array is explicitly allowed to be initialized with A a = { init-list };.
+// Disable the missing braces warning for this reason.
+#include "disable_missing_braces_warning.h"
+
+
+TEST_CONSTEXPR_CXX14 bool tests()
+{
+    {
+        typedef double T;
+        typedef std::array<T, 3> C;
+        C const c = {1, 2, 3.5};
+        LIBCPP_ASSERT_NOEXCEPT(c[0]);
+        ASSERT_SAME_TYPE(C::const_reference, decltype(c[0]));
+        C::const_reference r1 = c[0];
+        assert(r1 == 1);
+        C::const_reference r2 = c[2];
+        assert(r2 == 3.5);
+    }
+    // Test operator[] "works" on zero sized arrays
+    {
+        {
+            typedef double T;
+            typedef std::array<T, 0> C;
+            C const c = {};
+            LIBCPP_ASSERT_NOEXCEPT(c[0]);
+            ASSERT_SAME_TYPE(C::const_reference, decltype(c[0]));
+            if (c.size() > (0)) { // always false
+                C::const_reference r = c[0];
+                (void)r;
+            }
+        }
+        {
+            typedef double T;
+            typedef std::array<T const, 0> C;
+            C const c = {};
+            LIBCPP_ASSERT_NOEXCEPT(c[0]);
+            ASSERT_SAME_TYPE(C::const_reference, decltype(c[0]));
+            if (c.size() > (0)) { // always false
+              C::const_reference r = c[0];
+              (void)r;
+            }
+        }
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 14
+    static_assert(tests(), "");
+#endif
+  return 0;
+}

libcxx/test/std/containers/sequences/array/iterators.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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
-// iterator, const_iterator
+// iterator begin() noexcept;                         // constexpr in C++17
+// const_iterator begin() const noexcept;             // constexpr in C++17
+// iterator end() noexcept;                           // constexpr in C++17
+// const_iterator end() const noexcept;               // constexpr in C++17
+//
+// reverse_iterator rbegin() noexcept;                // constexpr in C++17
+// const_reverse_iterator rbegin() const noexcept;    // constexpr in C++17
+// reverse_iterator rend() noexcept;                  // constexpr in C++17
+// const_reverse_iterator rend() const noexcept;      // constexpr in C++17
+//
+// const_iterator cbegin() const noexcept;            // constexpr in C++17
+// const_iterator cend() const noexcept;              // constexpr in C++17
+// const_reverse_iterator crbegin() const noexcept;   // constexpr in C++17
+// const_reverse_iterator crend() const noexcept;     // constexpr in C++17
 
 #include <array>
 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main(int, char**)
+struct NoDefault {
+    TEST_CONSTEXPR NoDefault(int) { }
+};
+
+TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
         typedef std::array<int, 5> C;
-    C c;
-    C::iterator i;
-    i = c.begin();
-    C::const_iterator j;
-    j = c.cbegin();
+        C array = {};
+        typename C::iterator i = array.begin();
+        typename C::const_iterator j = array.cbegin();
         assert(i == j);
     }
     {
         typedef std::array<int, 0> C;
-    C c;
-    C::iterator i;
-    i = c.begin();
-    C::const_iterator j;
-    j = c.cbegin();
+        C array = {};
+        typename C::iterator i = array.begin();
+        typename C::const_iterator j = array.cbegin();
         assert(i == j);
+        LIBCPP_ASSERT(i != nullptr);
+        LIBCPP_ASSERT(j != nullptr);
+    }
+
+    {
+        typedef std::array<int, 0> C;
+        C array = {};
+        typename C::iterator i = array.begin();
+        typename C::const_iterator j = array.cbegin();
+        assert(i == array.end());
+        assert(j == array.cend());
+        LIBCPP_ASSERT(i != nullptr);
+        LIBCPP_ASSERT(j != nullptr);
+    }
+    {
+        typedef std::array<int, 1> C;
+        C array = {1};
+        typename C::iterator i = array.begin();
+        assert(*i == 1);
+        assert(&*i == array.data());
+        *i = 99;
+        assert(array[0] == 99);
+    }
+    {
+        typedef std::array<int, 2> C;
+        C array = {1, 2};
+        typename C::iterator i = array.begin();
+        assert(*i == 1);
+        assert(&*i == array.data());
+        *i = 99;
+        assert(array[0] == 99);
+        assert(array[1] == 2);
+    }
+    {
+        typedef std::array<double, 3> C;
+        C array = {1, 2, 3.5};
+        typename C::iterator i = array.begin();
+        assert(*i == 1);
+        assert(&*i == array.data());
+        *i = 5.5;
+        assert(array[0] == 5.5);
+        assert(array[1] == 2.0);
+    }
+    {
+        typedef std::array<NoDefault, 0> C;
+        C array = {};
+        typename C::iterator ib = array.begin();
+        typename C::iterator ie = array.end();
+        assert(ib == ie);
+        LIBCPP_ASSERT(ib != nullptr);
+        LIBCPP_ASSERT(ie != nullptr);
     }
 
-#if TEST_STD_VER > 11
+#if TEST_STD_VER >= 14
     { // N3644 testing
         {
             typedef std::array<int, 5> C;
             C::iterator ii1{}, ii2{};
             C::iterator ii4 = ii1;
             C::const_iterator cii{};
-        assert ( ii1 == ii2 );
-        assert ( ii1 == ii4 );
-        assert ( ii1 == cii );
+            assert(ii1 == ii2);
+            assert(ii1 == ii4);
+            assert(ii1 == cii);
 
-        assert ( !(ii1 != ii2 ));
-        assert ( !(ii1 != cii ));
+            assert(!(ii1 != ii2));
+            assert(!(ii1 != cii));
 
-        C c;
-        assert ( c.begin()   == std::begin(c));
-        assert ( c.cbegin()  == std::cbegin(c));
-        assert ( c.rbegin()  == std::rbegin(c));
-        assert ( c.crbegin() == std::crbegin(c));
-        assert ( c.end()     == std::end(c));
-        assert ( c.cend()    == std::cend(c));
-        assert ( c.rend()    == std::rend(c));
-        assert ( c.crend()   == std::crend(c));
+            C c = {};
+            assert(c.begin()   == std::begin(c));
+            assert(c.cbegin()  == std::cbegin(c));
+            assert(c.rbegin()  == std::rbegin(c));
+            assert(c.crbegin() == std::crbegin(c));
+            assert(c.end()     == std::end(c));
+            assert(c.cend()    == std::cend(c));
+            assert(c.rend()    == std::rend(c));
+            assert(c.crend()   == std::crend(c));
 
-        assert ( std::begin(c)   != std::end(c));
-        assert ( std::rbegin(c)  != std::rend(c));
-        assert ( std::cbegin(c)  != std::cend(c));
-        assert ( std::crbegin(c) != std::crend(c));
+            assert(std::begin(c)   != std::end(c));
+            assert(std::rbegin(c)  != std::rend(c));
+            assert(std::cbegin(c)  != std::cend(c));
+            assert(std::crbegin(c) != std::crend(c));
         }
         {
             typedef std::array<int, 0> C;
             C::iterator ii1{}, ii2{};
             C::iterator ii4 = ii1;
             C::const_iterator cii{};
-        assert ( ii1 == ii2 );
-        assert ( ii1 == ii4 );
+            assert(ii1 == ii2);
+            assert(ii1 == ii4);
 
-        assert (!(ii1 != ii2 ));
+            assert(!(ii1 != ii2));
 
-        assert ( (ii1 == cii ));
-        assert ( (cii == ii1 ));
-        assert (!(ii1 != cii ));
-        assert (!(cii != ii1 ));
-        assert (!(ii1 <  cii ));
-        assert (!(cii <  ii1 ));
-        assert ( (ii1 <= cii ));
-        assert ( (cii <= ii1 ));
-        assert (!(ii1 >  cii ));
-        assert (!(cii >  ii1 ));
-        assert ( (ii1 >= cii ));
-        assert ( (cii >= ii1 ));
-        assert (cii - ii1 == 0);
-        assert (ii1 - cii == 0);
+            assert( (ii1 == cii));
+            assert( (cii == ii1));
+            assert(!(ii1 != cii));
+            assert(!(cii != ii1));
+            assert(!(ii1 <  cii));
+            assert(!(cii <  ii1));
+            assert( (ii1 <= cii));
+            assert( (cii <= ii1));
+            assert(!(ii1 >  cii));
+            assert(!(cii >  ii1));
+            assert( (ii1 >= cii));
+            assert( (cii >= ii1));
+            assert(cii - ii1 == 0);
+            assert(ii1 - cii == 0);
 
-        C c;
-        assert ( c.begin()   == std::begin(c));
-        assert ( c.cbegin()  == std::cbegin(c));
-        assert ( c.rbegin()  == std::rbegin(c));
-        assert ( c.crbegin() == std::crbegin(c));
-        assert ( c.end()     == std::end(c));
-        assert ( c.cend()    == std::cend(c));
-        assert ( c.rend()    == std::rend(c));
-        assert ( c.crend()   == std::crend(c));
+            C c = {};
+            assert(c.begin()   == std::begin(c));
+            assert(c.cbegin()  == std::cbegin(c));
+            assert(c.rbegin()  == std::rbegin(c));
+            assert(c.crbegin() == std::crbegin(c));
+            assert(c.end()     == std::end(c));
+            assert(c.cend()    == std::cend(c));
+            assert(c.rend()    == std::rend(c));
+            assert(c.crend()   == std::crend(c));
 
-        assert ( std::begin(c)   == std::end(c));
-        assert ( std::rbegin(c)  == std::rend(c));
-        assert ( std::cbegin(c)  == std::cend(c));
-        assert ( std::crbegin(c) == std::crend(c));
+            assert(std::begin(c)   == std::end(c));
+            assert(std::rbegin(c)  == std::rend(c));
+            assert(std::cbegin(c)  == std::cend(c));
+            assert(std::crbegin(c) == std::crend(c));
         }
     }
 #endif
-#if TEST_STD_VER > 14
-    {
-        typedef std::array<int, 5> C;
-        constexpr C c{0,1,2,3,4};
-
-        static_assert ( c.begin()   == std::begin(c), "");
-        static_assert ( c.cbegin()  == std::cbegin(c), "");
-        static_assert ( c.end()     == std::end(c), "");
-        static_assert ( c.cend()    == std::cend(c), "");
-
-        static_assert ( c.rbegin()  == std::rbegin(c), "");
-        static_assert ( c.crbegin() == std::crbegin(c), "");
-        static_assert ( c.rend()    == std::rend(c), "");
-        static_assert ( c.crend()   == std::crend(c), "");
-
-        static_assert ( std::begin(c)   != std::end(c), "");
-        static_assert ( std::rbegin(c)  != std::rend(c), "");
-        static_assert ( std::cbegin(c)  != std::cend(c), "");
-        static_assert ( std::crbegin(c) != std::crend(c), "");
-
-        static_assert ( *c.begin()  == 0, "");
-        static_assert ( *c.rbegin()  == 4, "");
-
-        static_assert ( *std::begin(c)   == 0, "" );
-        static_assert ( *std::cbegin(c)  == 0, "" );
-        static_assert ( *std::rbegin(c)  == 4, "" );
-        static_assert ( *std::crbegin(c) == 4, "" );
-    }
-#endif
+    return true;
 
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 17
+    static_assert(tests(), "");
+#endif
   return 0;
 }

libcxx/test/std/containers/sequences/array/max_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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // class array
 
-// bool max_size() const noexcept;
+// constexpr bool max_size() const noexcept;
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
-#include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
         typedef std::array<int, 2> C;
-    C c;
+        C c = {};
         ASSERT_NOEXCEPT(c.max_size());
         assert(c.max_size() == 2);
     }
     {
         typedef std::array<int, 0> C;
-    C c;
+        C c = {};
         ASSERT_NOEXCEPT(c.max_size());
         assert(c.max_size() == 0);
     }
 
+    return true;
+}
+
+int main(int, char**)
+{
+    tests();
+#if TEST_STD_VER >= 14
+    static_assert(tests(), "");
+#endif
+
+#if TEST_STD_VER >= 11
+    // Sanity check for constexpr in C++11
+    {
+        constexpr std::array<int, 3> array = {};
+        static_assert(array.max_size() == 3, "");
+    }
+#endif
+
     return 0;
 }

libcxx/test/std/containers/sequences/array/size_and_alignment.pass.cpp

 template <class T, size_t Size>
 void test() {
   typedef T CArrayT[Size == 0 ? 1 : Size];
   typedef std::array<T, Size> ArrayT;
   typedef MyArray<T, Size == 0 ? 1 : Size> MyArrayT;
   static_assert(sizeof(ArrayT) == sizeof(CArrayT), "");
   static_assert(sizeof(ArrayT) == sizeof(MyArrayT), "");
   static_assert(TEST_ALIGNOF(ArrayT) == TEST_ALIGNOF(MyArrayT), "");
-#if defined(_LIBCPP_VERSION)
-  ArrayT a;
-  ((void)a);
-  static_assert(sizeof(ArrayT) == sizeof(a.__elems_), "");
-  static_assert(TEST_ALIGNOF(ArrayT) == __alignof__(a.__elems_), "");
-#endif
 }
 
 template <class T>
 void test_type() {
   test<T, 1>();
   test<T, 42>();
   test<T, 0>();
 }

 
 };
 
 struct TEST_ALIGNAS(TEST_ALIGNOF(std::max_align_t) * 2) TestType2 {
   char data[1000];
 };
 #endif
 
-//static_assert(sizeof(void*) == 4, "");
-
 int main(int, char**) {
   test_type<char>();
   test_type<int>();
   test_type<double>();
   test_type<long double>();
 
 #if TEST_STD_VER >= 11
   test_type<std::max_align_t>();
 #endif
   test_type<TestType1>();
   test_type<TestType2>();
 
   return 0;
 }

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

 // and should not be edited manually.
 
 // <array>
 
 // Test the feature test macros defined by <array>
 
 /*  Constant                                Value
     __cpp_lib_array_constexpr               201603L [C++17]
+                                            201811L [C++2a]
     __cpp_lib_constexpr_misc                201811L [C++2a]
     __cpp_lib_nonmember_container_access    201411L [C++17]
     __cpp_lib_to_array                      201907L [C++2a]
 */
 
 #include <array>
 #include "test_macros.h"
 

 #   error "__cpp_lib_to_array should not be defined before c++2a"
 # endif
 
 #elif TEST_STD_VER > 17
 
 # ifndef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should be defined in c++2a"
 # endif
-# if __cpp_lib_array_constexpr != 201603L
-#   error "__cpp_lib_array_constexpr should have the value 201603L in c++2a"
+# if __cpp_lib_array_constexpr != 201811L
+#   error "__cpp_lib_array_constexpr should have the value 201811L in c++2a"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_constexpr_misc
 #     error "__cpp_lib_constexpr_misc should be defined in c++2a"
 #   endif
 #   if __cpp_lib_constexpr_misc != 201811L
 #     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"

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

 // and should not be edited manually.
 
 // <iterator>
 
 // Test the feature test macros defined by <iterator>
 
 /*  Constant                                Value
     __cpp_lib_array_constexpr               201603L [C++17]
+                                            201811L [C++2a]
     __cpp_lib_constexpr_misc                201811L [C++2a]
     __cpp_lib_make_reverse_iterator         201402L [C++14]
     __cpp_lib_nonmember_container_access    201411L [C++17]
     __cpp_lib_null_iterators                201304L [C++14]
     __cpp_lib_ranges                        201811L [C++2a]
 */
 
 #include <iterator>

 #   error "__cpp_lib_ranges should not be defined before c++2a"
 # endif
 
 #elif TEST_STD_VER > 17
 
 # ifndef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should be defined in c++2a"
 # endif
-# if __cpp_lib_array_constexpr != 201603L
-#   error "__cpp_lib_array_constexpr should have the value 201603L in c++2a"
+# if __cpp_lib_array_constexpr != 201811L
+#   error "__cpp_lib_array_constexpr should have the value 201811L in c++2a"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_constexpr_misc
 #     error "__cpp_lib_constexpr_misc should be defined in c++2a"
 #   endif
 #   if __cpp_lib_constexpr_misc != 201811L
 #     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"

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

 // Test the feature test macros defined by <version>
 
 /*  Constant                                       Value
     __cpp_lib_addressof_constexpr                  201603L [C++17]
     __cpp_lib_allocator_traits_is_always_equal     201411L [C++17]
     __cpp_lib_any                                  201606L [C++17]
     __cpp_lib_apply                                201603L [C++17]
     __cpp_lib_array_constexpr                      201603L [C++17]
+                                                   201811L [C++2a]
     __cpp_lib_as_const                             201510L [C++17]
     __cpp_lib_atomic_is_always_lock_free           201603L [C++17]
     __cpp_lib_atomic_ref                           201806L [C++2a]
     __cpp_lib_bind_front                           201811L [C++2a]
     __cpp_lib_bit_cast                             201806L [C++2a]
     __cpp_lib_bool_constant                        201505L [C++17]
     __cpp_lib_boyer_moore_searcher                 201603L [C++17]
     __cpp_lib_byte                                 201603L [C++17]

 # endif
 # if __cpp_lib_apply != 201603L
 #   error "__cpp_lib_apply should have the value 201603L in c++2a"
 # endif
 
 # ifndef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should be defined in c++2a"
 # endif
-# if __cpp_lib_array_constexpr != 201603L
-#   error "__cpp_lib_array_constexpr should have the value 201603L in c++2a"
+# if __cpp_lib_array_constexpr != 201811L
+#   error "__cpp_lib_array_constexpr should have the value 201811L in c++2a"
 # endif
 
 # ifndef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should be defined in c++2a"
 # endif
 # if __cpp_lib_as_const != 201510L
 #   error "__cpp_lib_as_const should have the value 201510L in c++2a"
 # endif

libcxx/test/support/test_macros.h

 #endif
 
 #if TEST_STD_VER >= 14
 # define TEST_CONSTEXPR_CXX14 constexpr
 #else
 # define TEST_CONSTEXPR_CXX14
 #endif
 
+#if TEST_STD_VER >= 17
+# define TEST_CONSTEXPR_CXX17 constexpr
+#else
+# define TEST_CONSTEXPR_CXX17
+#endif
+
 #if TEST_STD_VER >= 20
 # define TEST_CONSTEXPR_CXX20 constexpr
 #else
 # define TEST_CONSTEXPR_CXX20
 #endif
 
 // Sniff out to see if the underlying C library has C11 features
 // Note that at this time (July 2018), MacOS X and iOS do NOT.

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = sorted([ add_version_header(x) for x in [
    "values": {
      "c++17": int(201411),
    },
    "headers": ["unordered_map"],
    },
   {"name": "__cpp_lib_array_constexpr",
    "values": {
      "c++17": int(201603),
+     "c++2a": int(201811),
    },
    "headers": ["iterator", "array"],
    },
   {"name": "__cpp_lib_nonmember_container_access",
    "values": {
      "c++17": int(201411),
    },
    "headers": ["iterator", "array", "deque", "forward_list", "list", "map", "regex",