llvm/libcxx
1
0
Fork 0
mirror of https://github.com/llvm-mirror/libcxx.git synced 2025-10-23 18:38:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

Implement LWG 2904.

Browse Source 
Summary:
- Removed the move-constructibe requirement from copy-assignable.
- Updated `__assign_alt` such that we direct initialize if
  `_Tp` can be `nothrow`-constructible from `_Arg`, or `_Tp`'s
  move construction can throw. Otherwise, construct a temporary and move it.
- Updated the tests to remove the pre-LWG2904 path.

Depends on D32671.

Reviewers: EricWF, CaseyCarter

Reviewed By: EricWF

Differential Revision: https://reviews.llvm.org/D33965

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@304891 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Michael Park
2017-06-07 10:22:43 +00:00
parent 7457967300
commit 3762fe69d2
4 changed files with 8 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
View File

@@ -199,12 +199,8 @@ void test_T_assignment_performs_construction() {
assert(false);
} catch (...) { /* ... */
}
#ifdef _LIBCPP_VERSION // LWG2904
assert(v.valueless_by_exception());
#else // _LIBCPP_VERSION
assert(v.index() == 0);
assert(std::get<0>(v) == "hello");
#endif // _LIBCPP_VERSION
}
{
using V = std::variant<ThrowsAssignT, std::string>;
@@ -213,28 +209,6 @@ void test_T_assignment_performs_construction() {
assert(v.index() == 0);
assert(std::get<0>(v).value == 42);
}
#ifdef _LIBCPP_VERSION // LWG2904
{
// Test that nothrow direct construction is preferred to nothrow move.
using V = std::variant<MoveCrashes, std::string>;
V v(std::in_place_type<std::string>, "hello");
v = 42;
assert(v.index() == 0);
assert(std::get<0>(v).value == 42);
}
{
// Test that throwing direct construction is preferred to copy-and-move when
// move can throw.
using V = std::variant<ThrowsCtorTandMove, std::string>;
V v(std::in_place_type<std::string>, "hello");
try {
v = 42;
assert(false);
} catch(...) { /* ... */
}
assert(v.valueless_by_exception());
}
#endif // _LIBCPP_VERSION // LWG2904
#endif // TEST_HAS_NO_EXCEPTIONS
}

29
test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
View File

@@ -224,13 +224,7 @@ void test_copy_assignment_sfinae() {
}
{
using V = std::variant<int, CopyOnly>;
#ifdef _LIBCPP_VERSION // LWG2904
// variant only provides copy assignment when both the copy and move
// constructors are well formed
static_assert(!std::is_copy_assignable<V>::value, "");
#else // _LIBCPP_VERSION // LWG2904
static_assert(std::is_copy_assignable<V>::value, "");
#endif // _LIBCPP_VERSION // LWG2904
}
{
using V = std::variant<int, NoCopy>;
@@ -263,12 +257,10 @@ void test_copy_assignment_sfinae() {
using V = std::variant<int, TCopyAssignNTMoveAssign>;
static_assert(std::is_trivially_copy_assignable<V>::value, "");
}
#ifndef _LIBCPP_VERSION // LWG2904
{
using V = std::variant<int, CopyOnly>;
static_assert(std::is_trivially_copy_assignable<V>::value, "");
}
#endif // _LIBCPP_VERSION
}
void test_copy_assignment_empty_empty() {
@@ -487,41 +479,21 @@ void test_copy_assignment_different_index() {
assert(false);
} catch (...) { /* ... */
}
#ifdef _LIBCPP_VERSION // LWG2904
// Test that if copy construction throws then original value is unchanged.
assert(v1.index() == 2);
assert(std::get<2>(v1) == "hello");
#else // _LIBCPP_VERSION // LWG2904
// Test that copy construction is used directly if move construction may throw,
// resulting in a valueless variant if copy throws.
assert(v1.valueless_by_exception());
#endif // _LIBCPP_VERSION // LWG2904
}
{
using V = std::variant<int, MoveThrows, std::string>;
V v1(std::in_place_type<std::string>, "hello");
V v2(std::in_place_type<MoveThrows>);
assert(MoveThrows::alive == 1);
#ifdef _LIBCPP_VERSION // LWG2904
// Test that if move construction throws then the variant is left
// valueless by exception.
try {
v1 = v2;
assert(false);
} catch (...) { /* ... */
}
assert(v1.valueless_by_exception());
assert(v2.index() == 1);
assert(MoveThrows::alive == 1);
#else // _LIBCPP_VERSION // LWG2904
// Test that copy construction is used directly if move construction may throw.
v1 = v2;
assert(v1.index() == 1);
assert(v2.index() == 1);
assert(MoveThrows::alive == 2);
#endif // _LIBCPP_VERSION // LWG2904
}
#ifndef _LIBCPP_VERSION // LWG2904
{
// Test that direct copy construction is preferred when it cannot throw.
using V = std::variant<int, CopyCannotThrow, std::string>;
@@ -533,7 +505,6 @@ void test_copy_assignment_different_index() {
assert(v2.index() == 1);
assert(CopyCannotThrow::alive == 2);
}
#endif // _LIBCPP_VERSION // LWG2904
{
using V = std::variant<int, CopyThrows, std::string>;
V v1(std::in_place_type<CopyThrows>);

8
test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
View File

@@ -183,13 +183,7 @@ void test_move_assignment_sfinae() {
}
{
using V = std::variant<int, CopyOnly>;
#ifdef _LIBCPP_VERSION // LWG2904
// variant only provides move assignment when both the move constructor
// and move assignment operator are well formed.
static_assert(!std::is_move_assignable<V>::value, "");
#else // _LIBCPP_VERSION // LWG2904
static_assert(std::is_move_assignable<V>::value, "");
#endif // _LIBCPP_VERSION // LWG2904
}
{
using V = std::variant<int, NoCopy>;
@@ -232,12 +226,10 @@ void test_move_assignment_sfinae() {
using V = std::variant<int, TrivialCopyNontrivialMove>;
static_assert(!std::is_trivially_move_assignable<V>::value, "");
}
#ifndef _LIBCPP_VERSION // LWG2904
{
using V = std::variant<int, CopyOnly>;
static_assert(std::is_trivially_move_assignable<V>::value, "");
}
#endif // _LIBCPP_VERSION // LWG2904
}
void test_move_assignment_empty_empty() {