7265ff928a
The Standard is currently unimplementable. We have to pick between:
1. Not implementing constexpr support properly in std::array<T, 0>
2. Making std::array<T, 0> non-trivial even when T is trivial
3. Returning nullptr from std::array<T, 0>::begin()
Libc++ initially picked (1). In 77b9abfc8e, we started implementing constexpr properly, but lost the guarantee of triviality. Since it seems like both (1) and (2) are really important, it seems like (3) is the only viable option for libc++, after all. This is also what other implementations are doing.
This patch moves libc++ from (1) to (3).
It also:
- Improves the test coverage for the various ways of initializing std::array
- Adds tests for the triviality of std::array
- Adds tests for the aggregate-ness of std::array
Reviewed By: #libc, miscco, EricWF, zoecarver
Differential Revision: https://reviews.llvm.org/D80821
48 lines
1.4 KiB
C++
48 lines
1.4 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// 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 check_aggregate()
|
|
{
|
|
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, "");
|
|
}
|
|
|
|
struct Empty { };
|
|
struct Trivial { int i; int j; };
|
|
struct NonTrivial {
|
|
int i; int j;
|
|
NonTrivial(NonTrivial const&) { }
|
|
};
|
|
|
|
int main(int, char**)
|
|
{
|
|
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;
|
|
}
|