[libc++] Overhaul initialization tests in std::array

[ldionne]

Summary

We had a few tests for the different ways to initialize a std::array
here and there, but they were split up and patchy in their coverage.
This patch improves that situation.

It also adds tests for the triviality and aggregate-ness of std::array.
Even though the Standard doesn't explicitly require it, libc++ has been
making std::array<T, N> trivial whenever T is trivial for any value of N.

The patch also adds tests checking that std::array<T, N> is an aggregate
for all values of N.

[ldionne]

This patch adds tests that highlight some problems with the current array implementation. Basically, it highlights that we need to pick between:

1. Don't implement constexpr support properly in std::array<T, 0>
2. Make std::array<T, 0> non-trivial even when T is trivial (which is an ABI break)
3. Return nullptr from std::array<T, 0>::begin() (which is also an ABI break)

Note that both ABI breaks are benign -- I would be surprised if folks relied on std::array<T, 0> at ABI boundaries.

Next, I'll submit a patch that picks (3) as the best solution for now, which is also what other implementations do.

[ldionne]

I'll merge the tests into https://reviews.llvm.org/D80821 -- abandoning this.

Sorry for the confusion.

libcxx/test/libcxx/containers/sequences/array/triviality.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<T, N> is trivially copyable whenever T is trivially copyable.
+// This is not technically mandated by the Standard, but libc++ has been providing
+// this property.
+
+#include <array>
+#include <type_traits>
+
+
+struct Empty { };
+
+struct TrivialCopy {
+    int i;
+    double j;
+};
+
+struct NonTrivialCopy {
+    NonTrivialCopy(NonTrivialCopy const&) { }
+    NonTrivialCopy& operator=(NonTrivialCopy const&) { return *this; }
+};
+
+template <typename T>
+void check_trivially_copyable()
+{
+    static_assert(std::is_trivially_copyable<std::array<T, 0> >::value, "");
+    static_assert(std::is_trivially_copyable<std::array<T, 1> >::value, "");
+    static_assert(std::is_trivially_copyable<std::array<T, 2> >::value, "");
+    static_assert(std::is_trivially_copyable<std::array<T, 3> >::value, "");
+}
+
+int main(int, char**)
+{
+    check_trivially_copyable<int>();
+    check_trivially_copyable<long>();
+    check_trivially_copyable<double>();
+    check_trivially_copyable<long double>();
+    check_trivially_copyable<Empty>();
+    check_trivially_copyable<TrivialCopy>();
+
+    // Check that std::array<T, 0> is still trivially copyable when T is not
+    static_assert( std::is_trivially_copyable<std::array<NonTrivialCopy, 0> >::value, "");
+    static_assert(!std::is_trivially_copyable<std::array<NonTrivialCopy, 1> >::value, "");
+    static_assert(!std::is_trivially_copyable<std::array<NonTrivialCopy, 2> >::value, "");
+    static_assert(!std::is_trivially_copyable<std::array<NonTrivialCopy, 3> >::value, "");
+
+    return 0;
+}

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.
+// We can only check this in C++17 and above, because we don't have the
+// trait before that.
+// UNSUPPORTED: c++03, c++11, c++14
 
 #include <array>
 #include <type_traits>
 
 template <typename T>
-void tests()
+void check_aggregate()
 {
-    // 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; };
+struct Trivial { int i; int j; };
+struct NonTrivial {
+    int i; int j;
+    NonTrivial(NonTrivial const&) { }
+};
 
 int main(int, char**)
 {
-    tests<char>();
-    tests<int>();
-    tests<long>();
-    tests<float>();
-    tests<double>();
-    tests<long double>();
-    tests<NonEmpty>();
-    tests<Empty>();
+    check_aggregate<char>();
+    check_aggregate<int>();
+    check_aggregate<long>();
+    check_aggregate<float>();
+    check_aggregate<double>();
+    check_aggregate<long double>();
+    check_aggregate<Empty>();
+    check_aggregate<Trivial>();
+    check_aggregate<NonTrivial>();
 
     return 0;
 }

libcxx/test/std/containers/sequences/array/array.cons/default.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>
-
-// array();
-
-#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"
-
-struct NoDefault {
-    TEST_CONSTEXPR NoDefault(int) { }
-};
-
-struct Default {
-    TEST_CONSTEXPR Default() { }
-};
-
-TEST_CONSTEXPR_CXX14 bool tests()
-{
-    {
-        std::array<Default, 3> array;
-        assert(array.size() == 3);
-    }
-
-    {
-        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

 #else
 #   define TEST_NOT_COPY_ASSIGNABLE(T) static_assert(!std::is_copy_assignable<T>::value, "")
 #endif
 
 struct NoDefault {
     TEST_CONSTEXPR NoDefault(int) { }
 };
 
+struct NonTrivialCopy {
+    TEST_CONSTEXPR NonTrivialCopy() { }
+    NonTrivialCopy(NonTrivialCopy const&) { }
+    NonTrivialCopy& operator=(NonTrivialCopy const&) { return *this; }
+};
+
 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, "");
+        typedef std::array<double, 3> Array;
+        Array array = {1.1, 2.2, 3.3};
+        Array copy = array;
+        copy = array;
+        static_assert(std::is_copy_constructible<Array>::value, "");
+        static_assert(std::is_copy_assignable<Array>::value, "");
+    }
+    {
+        typedef std::array<double const, 3> Array;
+        Array array = {1.1, 2.2, 3.3};
+        Array copy = array; (void)copy;
+        static_assert(std::is_copy_constructible<Array>::value, "");
+        TEST_NOT_COPY_ASSIGNABLE(Array);
+    }
+    {
+        typedef std::array<double, 0> Array;
+        Array array = {};
+        Array copy = array;
+        copy = array;
+        static_assert(std::is_copy_constructible<Array>::value, "");
+        static_assert(std::is_copy_assignable<Array>::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);
+        typedef std::array<double const, 0> Array;
+        Array array = {};
+        Array copy = array; (void)copy;
+        static_assert(std::is_copy_constructible<Array>::value, "");
+        TEST_NOT_COPY_ASSIGNABLE(Array);
+    }
+    {
+        typedef std::array<NoDefault, 0> Array;
+        Array array = {};
+        Array copy = array;
+        copy = array;
+        static_assert(std::is_copy_constructible<Array>::value, "");
+        static_assert(std::is_copy_assignable<Array>::value, "");
+    }
+    {
+        typedef std::array<NoDefault const, 0> Array;
+        Array array = {};
+        Array copy = array; (void)copy;
+        static_assert(std::is_copy_constructible<Array>::value, "");
+        TEST_NOT_COPY_ASSIGNABLE(Array);
+    }
+
+    // Make sure we can implicitly copy a std::array of a non-trivially copyable type
+    {
+        typedef std::array<NonTrivialCopy, 0> Array;
+        Array array = {};
+        Array copy = array;
+        copy = array;
+        static_assert(std::is_copy_constructible<Array>::value, "");
+    }
+    {
+        typedef std::array<NonTrivialCopy, 1> Array;
+        Array array = {};
+        Array copy = array;
+        copy = array;
+        static_assert(std::is_copy_constructible<Array>::value, "");
+    }
+    {
+        typedef std::array<NonTrivialCopy, 2> Array;
+        Array array = {};
+        Array copy = array;
+        copy = array;
+        static_assert(std::is_copy_constructible<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.cons/initialization.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
+//
+//===----------------------------------------------------------------------===//
+
+// Test all the ways of initializing a std::array.
+
+#include <array>
+#include <cassert>
+#include <type_traits>
+#include "test_macros.h"
+
+
+struct NoDefault {
+    TEST_CONSTEXPR NoDefault(int) { }
+};
+
+// Test default initialization
+// This one isn't constexpr because omitting to initialize fundamental types
+// isn't valid in a constexpr context.
+struct test_default_initialization {
+    template <typename T>
+    void operator()() const
+    {
+        std::array<T, 0> a0; (void)a0;
+        std::array<T, 1> a1; (void)a1;
+        std::array<T, 2> a2; (void)a2;
+        std::array<T, 3> a3; (void)a3;
+
+        std::array<NoDefault, 0> nodefault; (void)nodefault;
+    }
+};
+
+struct test_nondefault_initialization {
+    template <typename T>
+    TEST_CONSTEXPR_CXX14 void operator()() const
+    {
+        // Check direct-list-initialization syntax (introduced in C++11)
+    #if TEST_STD_VER >= 11
+        {
+            {
+                std::array<T, 0> a0_0{}; (void)a0_0;
+            }
+            {
+                std::array<T, 1> a1_0{}; (void)a1_0;
+                std::array<T, 1> a1_1{T()}; (void)a1_1;
+            }
+            {
+                std::array<T, 2> a2_0{}; (void)a2_0;
+                std::array<T, 2> a2_1{T()}; (void)a2_1;
+                std::array<T, 2> a2_2{T(), T()}; (void)a2_2;
+            }
+            {
+                std::array<T, 3> a3_0{}; (void)a3_0;
+                std::array<T, 3> a3_1{T()}; (void)a3_1;
+                std::array<T, 3> a3_2{T(), T()}; (void)a3_2;
+                std::array<T, 3> a3_3{T(), T(), T()}; (void)a3_3;
+            }
+
+            std::array<NoDefault, 0> nodefault{}; (void)nodefault;
+        }
+    #endif
+
+        // Check copy-list-initialization syntax
+        {
+            {
+                std::array<T, 0> a0_0 = {}; (void)a0_0;
+            }
+            {
+                std::array<T, 1> a1_0 = {}; (void)a1_0;
+                std::array<T, 1> a1_1 = {T()}; (void)a1_1;
+            }
+            {
+                std::array<T, 2> a2_0 = {}; (void)a2_0;
+                std::array<T, 2> a2_1 = {T()}; (void)a2_1;
+                std::array<T, 2> a2_2 = {T(), T()}; (void)a2_2;
+            }
+            {
+                std::array<T, 3> a3_0 = {}; (void)a3_0;
+                std::array<T, 3> a3_1 = {T()}; (void)a3_1;
+                std::array<T, 3> a3_2 = {T(), T()}; (void)a3_2;
+                std::array<T, 3> a3_3 = {T(), T(), T()}; (void)a3_3;
+            }
+
+            std::array<NoDefault, 0> nodefault = {}; (void)nodefault;
+        }
+
+        // Test aggregate initialization
+        {
+            {
+                std::array<T, 0> a0_0 = {{}}; (void)a0_0;
+            }
+            {
+                std::array<T, 1> a1_0 = {{}}; (void)a1_0;
+                std::array<T, 1> a1_1 = {{T()}}; (void)a1_1;
+            }
+            {
+                std::array<T, 2> a2_0 = {{}}; (void)a2_0;
+                std::array<T, 2> a2_1 = {{T()}}; (void)a2_1;
+                std::array<T, 2> a2_2 = {{T(), T()}}; (void)a2_2;
+            }
+            {
+                std::array<T, 3> a3_0 = {{}}; (void)a3_0;
+                std::array<T, 3> a3_1 = {{T()}}; (void)a3_1;
+                std::array<T, 3> a3_2 = {{T(), T()}}; (void)a3_2;
+                std::array<T, 3> a3_3 = {{T(), T(), T()}}; (void)a3_3;
+            }
+
+            // See http://wg21.link/LWG2157
+            std::array<NoDefault, 0> nodefault = {{}}; (void)nodefault;
+        }
+    }
+};
+
+// Test construction from an initializer-list
+TEST_CONSTEXPR_CXX14 bool test_initializer_list()
+{
+    {
+        std::array<double, 3> const a3_0 = {};
+        assert(a3_0[0] == double());
+        assert(a3_0[1] == double());
+        assert(a3_0[2] == double());
+    }
+    {
+        std::array<double, 3> const a3_1 = {1};
+        assert(a3_1[0] == double(1));
+        assert(a3_1[1] == double());
+        assert(a3_1[2] == double());
+    }
+    {
+        std::array<double, 3> const a3_2 = {1, 2.2};
+        assert(a3_2[0] == double(1));
+        assert(a3_2[1] == 2.2);
+        assert(a3_2[2] == double());
+    }
+    {
+        std::array<double, 3> const a3_3 = {1, 2, 3.5};
+        assert(a3_3[0] == double(1));
+        assert(a3_3[1] == double(2));
+        assert(a3_3[2] == 3.5);
+    }
+
+    return true;
+}
+
+struct Empty { };
+struct Trivial { int i; int j; };
+struct NonTrivial {
+    TEST_CONSTEXPR NonTrivial() { }
+    TEST_CONSTEXPR NonTrivial(NonTrivial const&) { }
+};
+struct NonEmptyNonTrivial {
+    int i; int j;
+    TEST_CONSTEXPR NonEmptyNonTrivial() : i(22), j(33) { }
+    TEST_CONSTEXPR NonEmptyNonTrivial(NonEmptyNonTrivial const&) : i(22), j(33) { }
+};
+
+template <typename F>
+TEST_CONSTEXPR_CXX14 bool with_all_types()
+{
+    F().template operator()<char>();
+    F().template operator()<int>();
+    F().template operator()<long>();
+    F().template operator()<float>();
+    F().template operator()<double>();
+    F().template operator()<long double>();
+    F().template operator()<Empty>();
+    F().template operator()<Trivial>();
+    F().template operator()<NonTrivial>();
+    F().template operator()<NonEmptyNonTrivial>();
+    return true;
+}
+
+int main(int, char**)
+{
+    with_all_types<test_nondefault_initialization>();
+    with_all_types<test_default_initialization>(); // not constexpr
+    test_initializer_list();
+#if TEST_STD_VER >= 14
+    static_assert(with_all_types<test_nondefault_initialization>(), "");
+    static_assert(test_initializer_list(), "");
+#endif
+
+    return 0;
+}

libcxx/test/std/containers/sequences/array/array.cons/initializer_list.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>
-
-// Construct with initializer list
-
-#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"
-
-TEST_CONSTEXPR_CXX14 bool tests()
-{
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        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 const c = {};
-        assert(c.size() == 0);
-    }
-
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        C const c = {1};
-        assert(c.size() == 3.0);
-        assert(c[0] == 1);
-    }
-    {
-        typedef int T;
-        typedef std::array<T, 1> 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;
-}