[libc++] Remove redundant empty specialization in std::array

[ldionne]

Summary

Instead of having two full specializations for std::array, factor the
common code into an helper class. I was careful not to change the
behavior of std::array, especially ABI wise.

The only purposeful functionality change is that when the debug mode is
enabled, accessing a non-empty std::array out-of-bounds will _LIBCPP_ASSERT,
which seems like an improvement.

[ldionne]

libcxx/include/array

290

Careful -- the diff is a bit confusing since it aligns the old specialization of std::array<T, 0> with the new std::array<T, N> base template. That's why it seems like the old diff was incorrectly implemented as iterator end() _NOEXCEPT {return iterator(data());}, when it really was correctly implemented because that was for the empty-array case.

[ldionne]

Fix issues in C++14 mode

[EricWF]

Why is this code an improvement?

First, it causes substantially fewer misuses of array<T, 0> to be caught.
It admits for all sorts of out-of-bounds memory accesses that weren't possible before.

[ldionne]

In D80790#2063354, @EricWF wrote:

Why is this code an improvement?

First, it causes substantially fewer misuses of array<T, 0> to be caught.
It admits for all sorts of out-of-bounds memory accesses that weren't possible before.

How is that true? It's actually quite the opposite -- before, we would *only* catch invalid accesses on std::array<T, 0> -- with this patch, we catch them for any array size. Look at std::array<T, N>::operator[], which now has _LIBCPP_ASSERT when it previously had nothing (only the std::array<T, 0> one had an assert).

Apart from that significant improvement, it also doesn't duplicate the whole definition of std::array just to handle the empty case.

[zoecarver]

What if we did this in three patches?

1. Update everything to use data() instead of __elems_.
2. Use __array_storage in both implementations.
3. Remove the array<T, 0> specialization.

It also might be good to move data() into __array_storage and hold an instance of __array_storage itself (the element storage would exist in __array_storage). That would make it easier to have many specialized overloads, i.e. one for N = 0 where T is trivial, where N = 0 and T is not trivial, and where N != 0. Then the array implementation only has to worry about implementing itself in terms of data().

libcxx/include/array

128

Do we use a __detail namespace anywhere else? I don't have an issue with it but, it seems a bit out of place.

[ldionne]

In D80790#2063567, @zoecarver wrote:

What if we did this in three patches?

1. Update everything to use data() instead of __elems_.
2. Use __array_storage in both implementations.
3. Remove the array<T, 0> specialization.

I'm not sure what huge benefit that would yield.

It also might be good to move data() into __array_storage and hold an instance of __array_storage itself (the element storage would exist in __array_storage). That would make it easier to have many specialized overloads, i.e. one for N = 0 where T is trivial, where N = 0 and T is not trivial, and where N != 0. Then the array implementation only has to worry about implementing itself in terms of data().

We can't do that because array has to be an aggregate. It has to contain the T __elems[N] array as its sole member.

libcxx/include/array

128

True, I can remove it.

[zoecarver]

I'm not sure what huge benefit that would yield.

We don't have to, that's just a suggestion. I think it would be easier to review and if there's a bug in one part of the implementation, we have to revert less code (and it's easier to track down).

---

I think the direction here will depend on D80821.

We can't do that because array has to be an aggregate. It has to contain the T __elems[N] array as its sole member.

I think we can inherit from __array_storage as a public base. The reason I think it's important to have the data logic factored out into another object is that if we do what I suggest in D80821 we're going to have four overloads which will be more difficult to maintain if they're all in one class. If we don't do what I suggest in D80821, then I'm fine with the implementation in this patch.

[ldionne]

In D80790#2063595, @zoecarver wrote:

I'm not sure what huge benefit that would yield.

We don't have to, that's just a suggestion. I think it would be easier to review and if there's a bug in one part of the implementation, we have to revert less code (and it's easier to track down).

---

I think the direction here will depend on D80821.

We can't do that because array has to be an aggregate. It has to contain the T __elems[N] array as its sole member.

I think we can inherit from __array_storage as a public base. The reason I think it's important to have the data logic factored out into another object is that if we do what I suggest in D80821 we're going to have four overloads which will be more difficult to maintain if they're all in one class. If we don't do what I suggest in D80821, then I'm fine with the implementation in this patch.

Not prior to C++17. Aggregates can't have base classes in C++11 and C++14.

[miscco]

I have to say that this is rather worse than what we had before.

With this change we have

• A higher implementation complexity. What was previously super simple is now quite complex
• Slower debug performance trough the __data() indirection

And we gain what? It is not like there will be too much changes to array in the forseeable future that make the unification worthwile.

Note that I am totally in favor to unify span into one implementation. But this is because both the dynamically and statically typed implementation are semantically identical and there is no measurable implementation cost. That cannot be said here as array<T, 0> is completely different than array<T,N != 0>

[ldionne]

In D80790#2063869, @miscco wrote:

I have to say that this is rather worse than what we had before.

With this change we have

• A higher implementation complexity. What was previously super simple is now quite complex

How is it quite complex? I'm just de-duplicating all the member functions like size() & friends. IMO it's a lot simpler after the change. I'll abandon this for now and revisit once the situation with array<T, 0> has settled -- this patch can be made simpler then.

libcxx/include/array

struct array
     reference at(size_type n);                                  // constexpr in C++17
     const_reference at(size_type n) 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;                                         // constexpr in C++17
-    const T* data() const noexcept;                             // constexpr in C++17
+    T* data() noexcept;                                         // constexpr in C++14 (extension -- should be in C++17)
+    const T* data() const noexcept;                             // constexpr in C++14 (extension -- should be in C++17)
 };
 
 template <class T, class... 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);    // constexpr in C++20
 template <class T, size_t N>

 
 #include <__config>
 #include <__tuple>
 #include <type_traits>
 #include <utility>
 #include <iterator>
 #include <algorithm>
 #include <stdexcept>
-#include <cstdlib> // for _LIBCPP_UNREACHABLE
 #include <version>
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+namespace __detail {
+    template <typename _Tp, size_t _Size>
+    struct __array_storage {
+        typedef _Tp type[_Size];
 
-template <class _Tp, size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS array
-{
-    // types:
-    typedef array __self;
-    typedef _Tp                                   value_type;
-    typedef value_type&                           reference;
-    typedef const value_type&                     const_reference;
-    typedef value_type*                           iterator;
-    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;
-
-    _Tp __elems_[_Size];
-
-    // No explicit construct/copy/destroy for aggregate type
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    void fill(const value_type& __u) {
-      _VSTD::fill_n(__elems_, _Size, __u);
-    }
-
-    _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_);
+        static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+        _Tp* __get(type& __storage) _NOEXCEPT {
+            return __storage;
         }
+    };
 
-    // iterators:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    iterator begin() _NOEXCEPT {return iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    iterator end() _NOEXCEPT {return iterator(data() + _Size);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    const_iterator end() const _NOEXCEPT {return const_iterator(data() + _Size);}
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    const_iterator cbegin() const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _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 _Size;}
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return _Size;}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return false; }
-
-    // element access:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    reference operator[](size_type __n)             _NOEXCEPT {return __elems_[__n];}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    const_reference operator[](size_type __n) const _NOEXCEPT {return __elems_[__n];}
+#ifndef _LIBCPP_CXX03_LANG
+    template <typename _Tp>
+    struct __array_storage<_Tp, 0> {
+        union type {
+            _LIBCPP_CONSTEXPR type() : __b() { }
+            ~type() = default;
+            bool __b;
+            _Tp __t;
+        };
 
-    _LIBCPP_CONSTEXPR_AFTER_CXX14 reference at(size_type __n)
-    {
-        if (__n >= _Size)
-            __throw_out_of_range("array::at");
-        return __elems_[__n];
+        static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+        _Tp* __get(type& __storage) _NOEXCEPT {
+            return &__storage.__t;
         }
+    };
+#else // C++03
+    template <typename _Tp>
+    struct __array_storage<_Tp, 0> {
+        typedef typename conditional<is_const<_Tp>::value, const char, char>::type _CharType;
+        struct _ArrayInStructT { _Tp __data_[1]; };
+        typedef _ALIGNAS_TYPE(_ArrayInStructT) _CharType type[sizeof(_ArrayInStructT)];
 
-    _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference at(size_type __n) const
-    {
-        if (__n >= _Size)
-            __throw_out_of_range("array::at");
-        return __elems_[__n];
+        static _LIBCPP_INLINE_VISIBILITY
+        _Tp* __get(type& __storage) _NOEXCEPT {
+            return reinterpret_cast<_Tp*>(__storage);
         }
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference front()             _NOEXCEPT {return __elems_[0];}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference front() const _NOEXCEPT {return __elems_[0];}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference back()              _NOEXCEPT {return __elems_[_Size - 1];}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference back() const  _NOEXCEPT {return __elems_[_Size - 1];}
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    value_type* data() _NOEXCEPT {return __elems_;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    const value_type* data() const _NOEXCEPT {return __elems_;}
     };
+#endif
+} // end namespace __detail
 
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
+template <class _Tp, size_t _Size>
+struct _LIBCPP_TEMPLATE_VIS array
 {
     // types:
-    typedef array __self;
     typedef _Tp                                   value_type;
     typedef value_type&                           reference;
     typedef const value_type&                     const_reference;
     typedef value_type*                           iterator;
     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)];
+    // No explicit construct/copy/destroy for aggregate type
+    typedef __detail::__array_storage<_Tp, _Size> _ArrayStorage;
+    typename _ArrayStorage::type __elems_;
 
-    _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
+    template <size_t _Sz = _Size, typename = typename enable_if<_Sz != 0>::type>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    void fill(const value_type& __u) {
+        _VSTD::fill_n(data(), _Size, __u);
+    }
 
-    // No explicit construct/copy/destroy for aggregate type
+    template <size_t _Sz = _Size, typename = void, typename = typename enable_if<_Sz == 0>::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'");
     }
 
+    template <size_t _Sz = _Size, typename = typename enable_if<_Sz != 0>::type>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
+        std::swap_ranges(data(), data() + _Size, __a.data());
+    }
+
+    template <size_t _Sz = _Size, typename = void, typename = typename enable_if<_Sz == 0>::type>
     _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_CONSTEXPR_AFTER_CXX14
     iterator begin() _NOEXCEPT {return iterator(data());}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    iterator end() _NOEXCEPT {return iterator(data());}
+    iterator end() _NOEXCEPT {return iterator(data() + _Size);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    const_iterator end() const _NOEXCEPT {return const_iterator(data());}
+    const_iterator end() const _NOEXCEPT {return const_iterator(data() + _Size);}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator cbegin() const _NOEXCEPT {return begin();}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator cend() const _NOEXCEPT {return end();}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
     _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_CONSTEXPR size_type size() const _NOEXCEPT {return _Size;}
     _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return 0;}
+    _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return _Size;}
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return true;}
+    _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return _Size == 0;}
 
     // element access:
     _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();
+    reference operator[](size_type __n) _NOEXCEPT {
+        _LIBCPP_ASSERT(__n < _Size, "out-of-bounds access in std::array<T, N>");
+        return data()[__n];
     }
 
     _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();
+    const_reference operator[](size_type __n) const _NOEXCEPT {
+        _LIBCPP_ASSERT(__n < _Size, "out-of-bounds access in std::array<T, N>");
+        return data()[__n];
     }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    reference at(size_type) {
-      __throw_out_of_range("array<T, 0>::at");
-      _LIBCPP_UNREACHABLE();
+    _LIBCPP_CONSTEXPR_AFTER_CXX14 reference at(size_type __n)
+    {
+        if (__n >= _Size)
+            __throw_out_of_range("array::at");
+        return data()[__n];
     }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    const_reference at(size_type) const {
-      __throw_out_of_range("array<T, 0>::at");
-      _LIBCPP_UNREACHABLE();
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference at(size_type __n) const
+    {
+        if (__n >= _Size)
+            __throw_out_of_range("array::at");
+        return data()[__n];
     }
 
-    _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_CONSTEXPR_AFTER_CXX14 reference front()             _NOEXCEPT {return (*this)[0];}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference front() const _NOEXCEPT {return (*this)[0];}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference back()              _NOEXCEPT {return (*this)[_Size - 1];}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference back() const  _NOEXCEPT {return (*this)[_Size - 1];}
 
     _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_CONSTEXPR_AFTER_CXX14
-    reference back() _NOEXCEPT {
-      _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
-      _LIBCPP_UNREACHABLE();
+    value_type* data() _NOEXCEPT {
+        return _ArrayStorage::__get(__elems_);
     }
 
     _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();
+    const value_type* data() const _NOEXCEPT {
+        return _ArrayStorage::__get(const_cast<typename _ArrayStorage::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)>;
 #endif
 

 };
 
 template <size_t _Ip, class _Tp, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp&
 get(array<_Tp, _Size>& __a) _NOEXCEPT
 {
     static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array)");
-    return __a.__elems_[_Ip];
+    return __a.data()[_Ip];
 }
 
 template <size_t _Ip, class _Tp, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const _Tp&
 get(const array<_Tp, _Size>& __a) _NOEXCEPT
 {
     static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array)");
-    return __a.__elems_[_Ip];
+    return __a.data()[_Ip];
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <size_t _Ip, class _Tp, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp&&
 get(array<_Tp, _Size>&& __a) _NOEXCEPT
 {
     static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)");
-    return _VSTD::move(__a.__elems_[_Ip]);
+    return _VSTD::move(__a.data()[_Ip]);
 }
 
 template <size_t _Ip, class _Tp, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const _Tp&&
 get(const array<_Tp, _Size>&& __a) _NOEXCEPT
 {
     static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)");
-    return _VSTD::move(__a.__elems_[_Ip]);
+    return _VSTD::move(__a.data()[_Ip]);
 }
 
 #endif  // !_LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER > 17
 
 template <typename _Tp, size_t _Size, size_t... _Index>
 _LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>

libcxx/test/libcxx/containers/sequences/array/data_constexpr_extension.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// Check that std::array<T, N>::data() is constexpr in C++14, as an extension.
+
+#include <array>
+
+
+constexpr bool tests()
+{
+    {
+        std::array<int, 0> array = {};
+        std::array<int, 0> const carray = {};
+        int* d1 = array.data(); (void)d1;
+        int const* d2 = carray.data(); (void)d2;
+    }
+    {
+        std::array<int, 1> array = {1};
+        std::array<int, 1> const carray = {1};
+        int* d1 = array.data(); (void)d1;
+        int const* d2 = carray.data(); (void)d2;
+    }
+    {
+        std::array<int, 2> array = {1, 2};
+        std::array<int, 2> const carray = {1, 2};
+        int* d1 = array.data(); (void)d1;
+        int const* d2 = carray.data(); (void)d2;
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    static_assert(tests(), "");
+    return 0;
+}