replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "[libc++] Fix PR35491 - std::array of zero-size doesn't work with non-default constructible types." 

Revert "Fix initialization of array<const T, 0> with GCC."
Revert "Make array<const T, 0> non-CopyAssignable and make swap and fill ill-formed."

This reverts commit r324182, r324185, and r324194 which were causing issues with zero-length std::arrays.

llvm-svn: 324309
This commit is contained in:
Nirav Dave 2018-02-06 03:03:37 +00:00
parent 2bf6c058a1
commit 936ff58476
8 changed files with 17 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
libcxx/include/array
View File

@ -117,57 +117,6 @@ template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexce
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, size_t _Size>
struct __array_traits {
typedef _Tp _StorageT[_Size];
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR_AFTER_CXX14 typename remove_const<_Tp>::type*
__data(typename remove_const<_StorageT>::type& __store) {
return __store;
}
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR_AFTER_CXX14 _Tp const* __data(const _StorageT& __store) {
return __store;
}
_LIBCPP_INLINE_VISIBILITY
static void __swap(_StorageT& __lhs, _StorageT& __rhs) {
std::swap_ranges(__lhs, __lhs + _Size, __rhs);
}
_LIBCPP_INLINE_VISIBILITY
static void __fill(_StorageT& __arr, _Tp const& __val) {
_VSTD::fill_n(__arr, _Size, __val);
}
};
template <class _Tp>
struct __array_traits<_Tp, 0> {
typedef typename aligned_storage<sizeof(_Tp), alignment_of<_Tp>::value>::type
_NonConstStorageT[1];
typedef typename conditional<is_const<_Tp>::value, const _NonConstStorageT,
_NonConstStorageT>::type _StorageT;
typedef typename remove_const<_Tp>::type _NonConstTp;
_LIBCPP_INLINE_VISIBILITY
static _NonConstTp* __data(_NonConstStorageT &__store) {
return reinterpret_cast<_NonConstTp*>(__store);
}
_LIBCPP_INLINE_VISIBILITY
static const _Tp* __data(const _StorageT &__store) {
return reinterpret_cast<const _Tp*>(__store);
}
_LIBCPP_INLINE_VISIBILITY
static void __swap(_StorageT&, _StorageT&) {}
_LIBCPP_INLINE_VISIBILITY
static void __fill(_StorageT&, _Tp const&) {}
};
template <class _Tp, size_t _Size>
struct _LIBCPP_TEMPLATE_VIS array
{
@ -185,33 +134,31 @@ struct _LIBCPP_TEMPLATE_VIS array
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef __array_traits<_Tp, _Size> _Traits;
typename _Traits::_StorageT __elems_;
value_type __elems_[_Size > 0 ? _Size : 1];
// No explicit construct/copy/destroy for aggregate type
_LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u) {
static_assert(_Size != 0 || !is_const<_Tp>::value,
"cannot fill zero-sized array of type 'const T'");
_Traits::__fill(__elems_, __u);
}
_LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u)
{_VSTD::fill_n(__elems_, _Size, __u);}
_LIBCPP_INLINE_VISIBILITY
void swap(array& __a) _NOEXCEPT_(_Size == 0 || __is_nothrow_swappable<_Tp>::value)
{ __swap_dispatch((std::integral_constant<bool, _Size == 0>()), __a); }
_LIBCPP_INLINE_VISIBILITY
void swap(array& __a)
_NOEXCEPT_(_Size == 0 || __is_nothrow_swappable<_Tp>::value) {
static_assert(_Size != 0 || !is_const<_Tp>::value,
"cannot swap zero-sized array of type 'const T'");
_Traits::__swap(__elems_, __a.__elems_);
}
void __swap_dispatch(std::true_type, array&) {}
_LIBCPP_INLINE_VISIBILITY
void __swap_dispatch(std::false_type, array& __a)
{ _VSTD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
// iterators:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
iterator begin() _NOEXCEPT {return iterator(data());}
iterator begin() _NOEXCEPT {return iterator(__elems_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
const_iterator begin() const _NOEXCEPT {return const_iterator(__elems_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
iterator end() _NOEXCEPT {return iterator(data() + _Size);}
iterator end() _NOEXCEPT {return iterator(__elems_ + _Size);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
const_iterator end() const _NOEXCEPT {return const_iterator(data() + _Size);}
const_iterator end() const _NOEXCEPT {return const_iterator(__elems_ + _Size);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
@ -254,9 +201,9 @@ struct _LIBCPP_TEMPLATE_VIS array
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference back() const {return __elems_[_Size > 0 ? _Size-1 : 0];}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
value_type* data() _NOEXCEPT {return _Traits::__data(__elems_);}
value_type* data() _NOEXCEPT {return __elems_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
const value_type* data() const _NOEXCEPT {return _Traits::__data(__elems_);}
const value_type* data() const _NOEXCEPT {return __elems_;}
};
template <class _Tp, size_t _Size>

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

@ -14,14 +14,6 @@
#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"
struct NoDefault {
NoDefault(int) {}
};
int main()
{
{
@ -36,13 +28,4 @@ int main()
C c;
assert(c.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);
}
}

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

@ -1,93 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <array>
// implicitly generated array constructors / assignment operators
#include <array>
#include <type_traits>
#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"
// 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)
#else
#define TEST_NOT_COPY_ASSIGNABLE(T) static_assert(!std::is_copy_assignable<T>::value, "")
#endif
struct NoDefault {
NoDefault(int) {}
};
int main() {
{
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);
}
}

18
libcxx/test/std/containers/sequences/array/array.data/data.pass.cpp
View File

@ -36,22 +36,4 @@ int main()
T* p = c.data();
(void)p; // to placate scan-build
}
{
typedef double T;
typedef std::array<const T, 0> C;
C c = {};
const T* p = c.data();
static_assert((std::is_same<decltype(c.data()), const T*>::value), "");
(void)p; // to placate scan-build
}
{
struct NoDefault {
NoDefault(int) {}
};
typedef NoDefault T;
typedef std::array<T, 0> C;
C c = {};
T* p = c.data();
assert(p != nullptr);
}
}

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

@ -38,16 +38,6 @@ int main()
const T* p = c.data();
(void)p; // to placate scan-build
}
{
struct NoDefault {
NoDefault(int) {}
};
typedef NoDefault T;
typedef std::array<T, 0> C;
const C c = {};
const T* p = c.data();
assert(p != nullptr);
}
#if TEST_STD_VER > 14
{
typedef std::array<int, 5> C;

29
libcxx/test/std/containers/sequences/array/array.fill/fill.fail.cpp
View File

@ -1,29 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <array>
// void fill(const T& u);
#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() {
{
typedef double T;
typedef std::array<const T, 0> C;
C c = {};
// expected-error@array:* {{static_assert failed "cannot fill zero-sized array of type 'const T'"}}
c.fill(5.5); // expected-note {{requested here}}
}
}

30
libcxx/test/std/containers/sequences/array/array.swap/swap.fail.cpp
View File

@ -1,30 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <array>
// void swap(array& a);
#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() {
{
typedef double T;
typedef std::array<const T, 0> C;
C c = {};
C c2 = {};
// expected-error@array:* {{static_assert failed "cannot swap zero-sized array of type 'const T'"}}
c.swap(c2); // expected-note {{requested here}}
}
}

9
libcxx/test/std/containers/sequences/array/begin.pass.cpp
View File

@ -31,13 +31,4 @@ int main()
*i = 5.5;
assert(c[0] == 5.5);
}
{
struct NoDefault {
NoDefault(int) {}
};
typedef NoDefault T;
typedef std::array<T, 0> C;
C c = {};
assert(c.begin() == c.end());
}
}