Fix some constexpr members in array<T, 0>

[zoecarver]

Summary

This fixes bug 40124 based on Richard Smith's suggestion. As he pointed out in the bug comments, this implementation does not take up any more space.

Currently, __wrapper is trivially destructible (I think there is an issue about this for C++20, but I cannot find any specifications about it in the standard. Feel free to post a link, and I can update the patch).

This patch relies on issue 2157 which ensures that _Tp is DefaultConstructible (maybe I should add a check for this?).

[EricWF]

This doesn't work for a number of reasons. First, the destructor is only trivial when all the union members are. second, you can't put constexpr on functions that never produce a valid constant expression

[zoecarver]

• Update tests
• Union only exist in C++17 and up

Here is an implementation where array<T, 0>{{}} errors (but I don't think it's needed anymore). Additionally, I have tested that all methods which are not intended to error are constant expressions.

Both std::array<T, x> and std::array<T, 0> are not trivially destructible if T is not. Therefore I think it is okay for this patch to be the same (let me know if I am missing something though).

If you give this implementation a thumbsup I will add more tests (and fail tests).

[zoecarver]

@EricWF do you still have issues with this patch?

[ldionne]

include/array

307

This can't be marked constexpr because it never produces a constant expression.

319

Ditto, and several times below.

356

You need to do something different based on whether you're in C++17 or not. Make sure you run the tests with multiple standards!

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

24

This test is always enabled (even in C++03 mode), so I don't think you can use constexpr here. Also, inline isn't useful here.

Finally, you only need this test in C++17, so you can use generalized constexpr and not do only one awkwardly long expression.

[zoecarver]

include/array

307

You're right. I did not implement/test this properly. There are two things I could do. A) I could remove the constexpr from these methods which would make them error at runtime or B) I could add a non-constexpr static_assert that would fail when one of these methods was used in a program at compile time. I think the later might be UB. Thoughts?

[ldionne]

include/array

307

Honestly, I think the only thing we can do here is to not mark it as constexpr. Because there's no way to implement it in a way that it's SOMETIMES a valid constant expression, and the Standard says that it's ill-formed NDR to have a function marked as constexpr that can never produce a constant expression.

@EricWF It seems like maybe I should file a LWG issue because the current spec is not implementable, any opinion?

[zoecarver]

I think it would be good to have an LWG issue that says something along the lines of, 22.3.7.5 is updated to say:

array shall provide support for the special case N == 0.
In the case that N == 0, begin() == end() == unique value. All member functions remain constexpr.
No element access members shall participate in overload resolution.
Member function swap() shall have a non-throwing exception specification.

Thoughts?

[ldionne]

I think this is superseded by https://reviews.llvm.org/D80452.

include/array

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;
 
-    typedef typename conditional<is_const<_Tp>::value, const char,
-                                char>::type _CharType;
-
-    struct  _ArrayInStructT { _Tp __data_[1]; };
-    _ALIGNAS_TYPE(_ArrayInStructT) _CharType __elems_[sizeof(_ArrayInStructT)];
+    union __wrapper {
+        constexpr __wrapper(): __b() {}
+        ~__wrapper() = default;
+
+        bool __b;
+        _Tp __t;
+    } __w;
 
     // No explicit construct/copy/destroy for aggregate type
     _LIBCPP_INLINE_VISIBILITY void fill(const value_type&) {
       static_assert(!is_const<_Tp>::value,
                     "cannot fill zero-sized array of type 'const T'");
     }
 
     _LIBCPP_INLINE_VISIBILITY
     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_CXX17
     iterator begin() _NOEXCEPT {return iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     iterator end() _NOEXCEPT {return iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator end() const _NOEXCEPT {return const_iterator(data());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator cbegin() const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
 
     // 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_CXX17
     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_CXX17
     reference at(size_type) {
       __throw_out_of_range("array<T, 0>::at");
       _LIBCPP_UNREACHABLE();
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     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_CXX17
     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_CXX14
     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_CXX17
     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_CXX14
     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_);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    value_type* data() _NOEXCEPT {return &__w.__t;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    const value_type* data() const _NOEXCEPT {return &__w.__t;}
 };
 
 
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template<class _Tp, class... _Args,
          class = typename enable_if<(is_same_v<_Tp, _Args> && ...), void>::type
          >
 array(_Tp, _Args...)

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

 
 #include <array>
 #include <iterator>
 #include <type_traits>
 #include <cstddef>
 
 #include "test_macros.h"
 
+template <class A>
+inline constexpr bool has_consexpr_members(const A& arr) {
+    return arr.begin() &&
+           arr.end()   &&
+           arr.data();
+}
 
 template <class T, size_t Size>
 struct MyArray {
   T elems[Size];
 };
 
 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)
+#if defined(_LIBCPP_VERSION) && Size > 0
   ArrayT a;
   ((void)a);
   static_assert(sizeof(ArrayT) == sizeof(a.__elems_), "");
   static_assert(TEST_ALIGNOF(ArrayT) == __alignof__(a.__elems_), "");
 #endif
+#if TEST_STD_VER > 17
+  static_assert(has_consexpr_members(ArrayT { }));
+#endif
 }
 
 template <class T>
 void test_type() {
   test<T, 1>();
   test<T, 42>();
   test<T, 0>();
 }