[libcxx-commits] [libcxx] [libc++] Make `constexpr std::variant`. Implement P2231R1 (PR #83335)
via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Mar 6 02:08:32 PST 2024
https://github.com/huixie90 updated https://github.com/llvm/llvm-project/pull/83335
>From 9ba67d9e23cb4a1002cd703d4c0f516ca8bded07 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Wed, 28 Feb 2024 21:06:51 +0000
Subject: [PATCH 1/9] [libc++] Make `constexpr std::variant`. Implement P2231R1
---
libcxx/include/variant | 93 ++++++++--------
.../variant.ctor/copy.pass.cpp | 90 ++++++++++------
.../variant.ctor/move.pass.cpp | 97 +++++++++++------
.../variant.dtor/dtor.pass.cpp | 71 ++++++++-----
.../variant.mod/emplace_index_args.pass.cpp | 93 ++++------------
.../emplace_index_init_list_args.pass.cpp | 26 +++--
.../variant.mod/emplace_type_args.pass.cpp | 100 +++++-------------
.../emplace_type_init_list_args.pass.cpp | 34 +++---
8 files changed, 299 insertions(+), 305 deletions(-)
diff --git a/libcxx/include/variant b/libcxx/include/variant
index 6063739e52c86b..895f2350449e65 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -42,7 +42,7 @@ namespace std {
in_place_index_t<I>, initializer_list<U>, Args&&...);
// 20.7.2.2, destructor
- ~variant();
+ constexpr ~variant(); // constexpr since c++20
// 20.7.2.3, assignment
constexpr variant& operator=(const variant&);
@@ -52,16 +52,16 @@ namespace std {
// 20.7.2.4, modifiers
template <class T, class... Args>
- T& emplace(Args&&...);
+ constexpr T& emplace(Args&&...); // constexpr since c++20
template <class T, class U, class... Args>
- T& emplace(initializer_list<U>, Args&&...);
+ constexpr T& emplace(initializer_list<U>, Args&&...); // constexpr since c++20
template <size_t I, class... Args>
- variant_alternative_t<I, variant>& emplace(Args&&...);
+ constexpr variant_alternative_t<I, variant>& emplace(Args&&...); // constexpr since c++20
template <size_t I, class U, class... Args>
- variant_alternative_t<I, variant>& emplace(initializer_list<U>, Args&&...);
+ constexpr variant_alternative_t<I, variant>& emplace(initializer_list<U>, Args&&...); // constexpr since c++20
// 20.7.2.5, value status
constexpr bool valueless_by_exception() const noexcept;
@@ -222,6 +222,7 @@ namespace std {
#include <__functional/operations.h>
#include <__functional/unary_function.h>
#include <__memory/addressof.h>
+#include <__memory/construct_at.h>
#include <__type_traits/add_const.h>
#include <__type_traits/add_cv.h>
#include <__type_traits/add_pointer.h>
@@ -655,7 +656,8 @@ private:
template <size_t _Index, class _Tp>
struct _LIBCPP_TEMPLATE_VIS __alt {
- using __value_type = _Tp;
+ using __value_type = _Tp;
+ static constexpr size_t __index = _Index;
template <class... _Args>
_LIBCPP_HIDE_FROM_ABI explicit constexpr __alt(in_place_t, _Args&&... __args)
@@ -701,9 +703,9 @@ union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
friend struct __access::__union; \
}
-_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, ~__union() = default;);
-_LIBCPP_VARIANT_UNION(_Trait::_Available, ~__union(){});
-_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, ~__union() = delete;);
+_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union() = default;);
+_LIBCPP_VARIANT_UNION(_Trait::_Available, _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union(){});
+_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union() = delete;);
# undef _LIBCPP_VARIANT_UNION
@@ -767,13 +769,13 @@ class _LIBCPP_TEMPLATE_VIS __dtor;
}
_LIBCPP_VARIANT_DESTRUCTOR(
- _Trait::_TriviallyAvailable, ~__dtor() = default;
- , void __destroy() noexcept { this->__index = __variant_npos<__index_t>; });
+ _Trait::_TriviallyAvailable, _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() = default;
+ , _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept { this->__index = __variant_npos<__index_t>; });
_LIBCPP_VARIANT_DESTRUCTOR(
_Trait::_Available,
- ~__dtor() { __destroy(); },
- void __destroy() noexcept {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() { __destroy(); },
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept {
if (!this->valueless_by_exception()) {
__visitation::__base::__visit_alt(
[](auto& __alt) noexcept {
@@ -785,7 +787,8 @@ _LIBCPP_VARIANT_DESTRUCTOR(
this->__index = __variant_npos<__index_t>;
});
-_LIBCPP_VARIANT_DESTRUCTOR(_Trait::_Unavailable, ~__dtor() = delete;, void __destroy() noexcept = delete;);
+_LIBCPP_VARIANT_DESTRUCTOR(_Trait::_Unavailable, _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() = delete;
+ , _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept = delete;);
# undef _LIBCPP_VARIANT_DESTRUCTOR
@@ -798,23 +801,22 @@ public:
using __base_type::operator=;
protected:
- template <size_t _Ip, class _Tp, class... _Args>
- _LIBCPP_HIDE_FROM_ABI static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) {
- ::new ((void*)std::addressof(__a)) __alt<_Ip, _Tp>(in_place, std::forward<_Args>(__args)...);
- return __a.__value;
- }
-
template <class _Rhs>
- _LIBCPP_HIDE_FROM_ABI static void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI static void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) {
__lhs.__destroy();
if (!__rhs.valueless_by_exception()) {
+ // We cannot directly construct at the target __alt because its direct enclosing union is not activated yet.
+ // We will get error if we did:
+ // construction of subobject of member '__tail' of union with active member '__dummy' is not allowed in a constant
+ // expression
auto __rhs_index = __rhs.index();
__visitation::__base::__visit_alt_at(
__rhs_index,
- [](auto& __lhs_alt, auto&& __rhs_alt) {
- __construct_alt(__lhs_alt, std::forward<decltype(__rhs_alt)>(__rhs_alt).__value);
+ [&__lhs](auto&& __rhs_alt) {
+ std::__construct_at(std::addressof(__lhs.__data),
+ in_place_index<__decay_t<decltype(__rhs_alt)>::__index>,
+ std::forward<decltype(__rhs_alt)>(__rhs_alt).__value);
},
- __lhs,
std::forward<_Rhs>(__rhs));
__lhs.__index = __rhs_index;
}
@@ -840,15 +842,18 @@ class _LIBCPP_TEMPLATE_VIS __move_constructor;
__move_constructor& operator=(__move_constructor&&) = default; \
}
-_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(_Trait::_TriviallyAvailable,
- __move_constructor(__move_constructor&& __that) = default;);
+_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
+ _Trait::_TriviallyAvailable,
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&& __that) = default;);
_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
_Trait::_Available,
- __move_constructor(__move_constructor&& __that) noexcept(__all<is_nothrow_move_constructible_v<_Types>...>::value)
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&& __that) noexcept(
+ __all<is_nothrow_move_constructible_v<_Types>...>::value)
: __move_constructor(__valueless_t{}) { this->__generic_construct(*this, std::move(__that)); });
-_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(_Trait::_Unavailable, __move_constructor(__move_constructor&&) = delete;);
+_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(_Trait::_Unavailable,
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&&) = delete;);
# undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR
@@ -871,14 +876,16 @@ class _LIBCPP_TEMPLATE_VIS __copy_constructor;
__copy_constructor& operator=(__copy_constructor&&) = default; \
}
-_LIBCPP_VARIANT_COPY_CONSTRUCTOR(_Trait::_TriviallyAvailable,
- __copy_constructor(const __copy_constructor& __that) = default;);
+_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
+ _Trait::_TriviallyAvailable,
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor& __that) = default;);
_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
- _Trait::_Available, __copy_constructor(const __copy_constructor& __that)
+ _Trait::_Available, _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor& __that)
: __copy_constructor(__valueless_t{}) { this->__generic_construct(*this, __that); });
-_LIBCPP_VARIANT_COPY_CONSTRUCTOR(_Trait::_Unavailable, __copy_constructor(const __copy_constructor&) = delete;);
+_LIBCPP_VARIANT_COPY_CONSTRUCTOR(_Trait::_Unavailable,
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor&) = delete;);
# undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR
@@ -891,22 +898,24 @@ public:
using __base_type::operator=;
template <size_t _Ip, class... _Args>
- _LIBCPP_HIDE_FROM_ABI auto& __emplace(_Args&&... __args) {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI auto& __emplace(_Args&&... __args) {
this->__destroy();
- auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this), std::forward<_Args>(__args)...);
+ std::__construct_at(std::addressof(this->__data), in_place_index<_Ip>, std::forward<_Args>(__args)...);
this->__index = _Ip;
- return __res;
+ return __access::__base::__get_alt<_Ip>(*this).__value;
}
protected:
template <size_t _Ip, class _Tp, class _Arg>
- _LIBCPP_HIDE_FROM_ABI void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
if (this->index() == _Ip) {
__a.__value = std::forward<_Arg>(__arg);
} else {
struct {
- _LIBCPP_HIDE_FROM_ABI void operator()(true_type) const { __this->__emplace<_Ip>(std::forward<_Arg>(__arg)); }
- _LIBCPP_HIDE_FROM_ABI void operator()(false_type) const {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void operator()(true_type) const {
+ __this->__emplace<_Ip>(std::forward<_Arg>(__arg));
+ }
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void operator()(false_type) const {
__this->__emplace<_Ip>(_Tp(std::forward<_Arg>(__arg)));
}
__assignment* __this;
@@ -1248,7 +1257,7 @@ public:
enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI _Tp& emplace(_Args&&... __args) {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _Tp& emplace(_Args&&... __args) {
return __impl_.template __emplace<_Ip>(std::forward<_Args>(__args)...);
}
@@ -1258,7 +1267,7 @@ public:
enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
return __impl_.template __emplace<_Ip>(__il, std::forward<_Args>(__args)...);
}
@@ -1266,7 +1275,7 @@ public:
class... _Args,
size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI _Tp& emplace(_Args&&... __args) {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _Tp& emplace(_Args&&... __args) {
return __impl_.template __emplace<_Ip>(std::forward<_Args>(__args)...);
}
@@ -1275,7 +1284,7 @@ public:
class... _Args,
size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
return __impl_.template __emplace<_Ip>(__il, std::forward<_Args>(__args)...);
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
index d1e5768f58d2b1..34626a4e25f355 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -23,29 +23,29 @@
struct NonT {
NonT(int v) : value(v) {}
- NonT(const NonT &o) : value(o.value) {}
+ NonT(const NonT& o) : value(o.value) {}
int value;
};
static_assert(!std::is_trivially_copy_constructible<NonT>::value, "");
struct NoCopy {
- NoCopy(const NoCopy &) = delete;
+ NoCopy(const NoCopy&) = delete;
};
struct MoveOnly {
- MoveOnly(const MoveOnly &) = delete;
- MoveOnly(MoveOnly &&) = default;
+ MoveOnly(const MoveOnly&) = delete;
+ MoveOnly(MoveOnly&&) = default;
};
struct MoveOnlyNT {
- MoveOnlyNT(const MoveOnlyNT &) = delete;
- MoveOnlyNT(MoveOnlyNT &&) {}
+ MoveOnlyNT(const MoveOnlyNT&) = delete;
+ MoveOnlyNT(MoveOnlyNT&&) {}
};
struct NTCopy {
constexpr NTCopy(int v) : value(v) {}
- NTCopy(const NTCopy &that) : value(that.value) {}
- NTCopy(NTCopy &&) = delete;
+ NTCopy(const NTCopy& that) : value(that.value) {}
+ NTCopy(NTCopy&&) = delete;
int value;
};
@@ -54,8 +54,8 @@ static_assert(std::is_copy_constructible<NTCopy>::value, "");
struct TCopy {
constexpr TCopy(int v) : value(v) {}
- TCopy(TCopy const &) = default;
- TCopy(TCopy &&) = delete;
+ TCopy(TCopy const&) = default;
+ TCopy(TCopy&&) = delete;
int value;
};
@@ -74,20 +74,21 @@ static_assert(std::is_trivially_copy_constructible<TCopyNTMove>::value, "");
struct MakeEmptyT {
static int alive;
MakeEmptyT() { ++alive; }
- MakeEmptyT(const MakeEmptyT &) {
+ MakeEmptyT(const MakeEmptyT&) {
++alive;
// Don't throw from the copy constructor since variant's assignment
// operator performs a copy before committing to the assignment.
}
- MakeEmptyT(MakeEmptyT &&) { throw 42; }
- MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
- MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
+ MakeEmptyT(MakeEmptyT&&) { throw 42; }
+ MakeEmptyT& operator=(const MakeEmptyT&) { throw 42; }
+ MakeEmptyT& operator=(MakeEmptyT&&) { throw 42; }
~MakeEmptyT() { --alive; }
};
int MakeEmptyT::alive = 0;
-template <class Variant> void makeEmpty(Variant &v) {
+template <class Variant>
+void makeEmpty(Variant& v) {
Variant v2(std::in_place_type<MakeEmptyT>);
try {
v = std::move(v2);
@@ -214,35 +215,58 @@ void test_copy_ctor_valueless_by_exception() {
using V = std::variant<int, MakeEmptyT>;
V v1;
makeEmpty(v1);
- const V &cv1 = v1;
+ const V& cv1 = v1;
V v(cv1);
assert(v.valueless_by_exception());
#endif // TEST_HAS_NO_EXCEPTIONS
}
-template <std::size_t Idx>
-constexpr bool test_constexpr_copy_ctor_imp(std::variant<long, void*, const int> const& v) {
+template <std::size_t Idx, class T>
+constexpr bool test_constexpr_copy_ctor_imp(const T& v) {
auto v2 = v;
- return v2.index() == v.index() &&
- v2.index() == Idx &&
- std::get<Idx>(v2) == std::get<Idx>(v);
+ return v2.index() == v.index() && v2.index() == Idx && std::get<Idx>(v2) == std::get<Idx>(v);
}
+#if TEST_STD_VER >= 20
+struct NonTrivialCopyCtor {
+ int i = 0;
+ constexpr NonTrivialCopyCtor(int ii) : i(ii) {}
+ constexpr NonTrivialCopyCtor(const NonTrivialCopyCtor& other) : i(other.i) {}
+ constexpr NonTrivialCopyCtor(NonTrivialCopyCtor&& other) = default;
+ constexpr ~NonTrivialCopyCtor() = default;
+ friend constexpr bool operator==(const NonTrivialCopyCtor&, const NonTrivialCopyCtor&) = default;
+};
+#endif
void test_constexpr_copy_ctor() {
- // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
- using V = std::variant<long, void*, const int>;
+ {
+ // Test is_trivially_copy_constructible
+ // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+ using V = std::variant<long, void*, const int>;
#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_destructible<V>::value, "");
- static_assert(std::is_trivially_copy_constructible<V>::value, "");
- static_assert(std::is_trivially_move_constructible<V>::value, "");
- static_assert(!std::is_copy_assignable<V>::value, "");
- static_assert(!std::is_move_assignable<V>::value, "");
-#else // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_copyable<V>::value, "");
+ static_assert(std::is_trivially_destructible<V>::value, "");
+ static_assert(std::is_trivially_copy_constructible<V>::value, "");
+ static_assert(std::is_trivially_move_constructible<V>::value, "");
+ static_assert(!std::is_copy_assignable<V>::value, "");
+ static_assert(!std::is_move_assignable<V>::value, "");
+#else // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
+ static_assert(std::is_trivially_copyable<V>::value, "");
#endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(test_constexpr_copy_ctor_imp<0>(V(42l)), "");
- static_assert(test_constexpr_copy_ctor_imp<1>(V(nullptr)), "");
- static_assert(test_constexpr_copy_ctor_imp<2>(V(101)), "");
+ static_assert(std::is_trivially_copy_constructible<V>::value, "");
+ static_assert(test_constexpr_copy_ctor_imp<0>(V(42l)), "");
+ static_assert(test_constexpr_copy_ctor_imp<1>(V(nullptr)), "");
+ static_assert(test_constexpr_copy_ctor_imp<2>(V(101)), "");
+ }
+
+#if TEST_STD_VER >= 20
+ {
+ // Test !is_trivially_move_constructible
+ using V = std::variant<long, NonTrivialCopyCtor, void*>;
+ static_assert(!std::is_trivially_copy_constructible<V>::value, "");
+ static_assert(test_constexpr_copy_ctor_imp<0>(V(42l)), "");
+ static_assert(test_constexpr_copy_ctor_imp<1>(V(NonTrivialCopyCtor(5))), "");
+ static_assert(test_constexpr_copy_ctor_imp<2>(V(nullptr)), "");
+ }
+#endif
}
int main(int, char**) {
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
index e2518fe29caf7e..4bb6cf24b0f0e2 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
@@ -23,31 +23,31 @@
#include "test_workarounds.h"
struct ThrowsMove {
- ThrowsMove(ThrowsMove &&) noexcept(false) {}
+ ThrowsMove(ThrowsMove&&) noexcept(false) {}
};
struct NoCopy {
- NoCopy(const NoCopy &) = delete;
+ NoCopy(const NoCopy&) = delete;
};
struct MoveOnly {
int value;
MoveOnly(int v) : value(v) {}
- MoveOnly(const MoveOnly &) = delete;
- MoveOnly(MoveOnly &&) = default;
+ MoveOnly(const MoveOnly&) = delete;
+ MoveOnly(MoveOnly&&) = default;
};
struct MoveOnlyNT {
int value;
MoveOnlyNT(int v) : value(v) {}
- MoveOnlyNT(const MoveOnlyNT &) = delete;
- MoveOnlyNT(MoveOnlyNT &&other) : value(other.value) { other.value = -1; }
+ MoveOnlyNT(const MoveOnlyNT&) = delete;
+ MoveOnlyNT(MoveOnlyNT&& other) : value(other.value) { other.value = -1; }
};
struct NTMove {
constexpr NTMove(int v) : value(v) {}
- NTMove(const NTMove &) = delete;
- NTMove(NTMove &&that) : value(that.value) { that.value = -1; }
+ NTMove(const NTMove&) = delete;
+ NTMove(NTMove&& that) : value(that.value) { that.value = -1; }
int value;
};
@@ -56,8 +56,8 @@ static_assert(std::is_move_constructible<NTMove>::value, "");
struct TMove {
constexpr TMove(int v) : value(v) {}
- TMove(const TMove &) = delete;
- TMove(TMove &&) = default;
+ TMove(const TMove&) = delete;
+ TMove(TMove&&) = default;
int value;
};
@@ -76,20 +76,21 @@ static_assert(std::is_trivially_move_constructible<TMoveNTCopy>::value, "");
struct MakeEmptyT {
static int alive;
MakeEmptyT() { ++alive; }
- MakeEmptyT(const MakeEmptyT &) {
+ MakeEmptyT(const MakeEmptyT&) {
++alive;
// Don't throw from the copy constructor since variant's assignment
// operator performs a copy before committing to the assignment.
}
- MakeEmptyT(MakeEmptyT &&) { throw 42; }
- MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
- MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
+ MakeEmptyT(MakeEmptyT&&) { throw 42; }
+ MakeEmptyT& operator=(const MakeEmptyT&) { throw 42; }
+ MakeEmptyT& operator=(MakeEmptyT&&) { throw 42; }
~MakeEmptyT() { --alive; }
};
int MakeEmptyT::alive = 0;
-template <class Variant> void makeEmpty(Variant &v) {
+template <class Variant>
+void makeEmpty(Variant& v) {
Variant v2(std::in_place_type<MakeEmptyT>);
try {
v = std::move(v2);
@@ -158,7 +159,10 @@ void test_move_ctor_sfinae() {
}
template <typename T>
-struct Result { std::size_t index; T value; };
+struct Result {
+ std::size_t index;
+ T value;
+};
void test_move_ctor_basic() {
{
@@ -289,31 +293,54 @@ void test_move_ctor_valueless_by_exception() {
#endif // TEST_HAS_NO_EXCEPTIONS
}
-template <std::size_t Idx>
-constexpr bool test_constexpr_ctor_imp(std::variant<long, void*, const int> const& v) {
+template <std::size_t Idx, class T>
+constexpr bool test_constexpr_ctor_imp(const T& v) {
auto copy = v;
- auto v2 = std::move(copy);
- return v2.index() == v.index() &&
- v2.index() == Idx &&
- std::get<Idx>(v2) == std::get<Idx>(v);
+ auto v2 = std::move(copy);
+ return v2.index() == v.index() && v2.index() == Idx && std::get<Idx>(v2) == std::get<Idx>(v);
}
+#if TEST_STD_VER >= 20
+struct NonTrivialMoveCtor {
+ int i = 0;
+ constexpr NonTrivialMoveCtor(int ii) : i(ii) {}
+ constexpr NonTrivialMoveCtor(const NonTrivialMoveCtor& other) = default;
+ constexpr NonTrivialMoveCtor(NonTrivialMoveCtor&& other) : i(other.i) {}
+ constexpr ~NonTrivialMoveCtor() = default;
+ friend constexpr bool operator==(const NonTrivialMoveCtor&, const NonTrivialMoveCtor&) = default;
+};
+#endif
+
void test_constexpr_move_ctor() {
- // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
- using V = std::variant<long, void*, const int>;
+ {
+ // Test is_trivially_move_constructible
+ // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+ using V = std::variant<long, void*, const int>;
#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_destructible<V>::value, "");
- static_assert(std::is_trivially_copy_constructible<V>::value, "");
- static_assert(std::is_trivially_move_constructible<V>::value, "");
- static_assert(!std::is_copy_assignable<V>::value, "");
- static_assert(!std::is_move_assignable<V>::value, "");
-#else // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_copyable<V>::value, "");
+ static_assert(std::is_trivially_destructible<V>::value, "");
+ static_assert(std::is_trivially_copy_constructible<V>::value, "");
+ static_assert(std::is_trivially_move_constructible<V>::value, "");
+ static_assert(!std::is_copy_assignable<V>::value, "");
+ static_assert(!std::is_move_assignable<V>::value, "");
+#else // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
+ static_assert(std::is_trivially_copyable<V>::value, "");
#endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_move_constructible<V>::value, "");
- static_assert(test_constexpr_ctor_imp<0>(V(42l)), "");
- static_assert(test_constexpr_ctor_imp<1>(V(nullptr)), "");
- static_assert(test_constexpr_ctor_imp<2>(V(101)), "");
+ static_assert(std::is_trivially_move_constructible<V>::value, "");
+ static_assert(test_constexpr_ctor_imp<0>(V(42l)), "");
+ static_assert(test_constexpr_ctor_imp<1>(V(nullptr)), "");
+ static_assert(test_constexpr_ctor_imp<2>(V(101)), "");
+ }
+
+#if TEST_STD_VER >= 20
+ {
+ // Test !is_trivially_move_constructible
+ using V = std::variant<long, NonTrivialMoveCtor, void*>;
+ static_assert(!std::is_trivially_move_constructible<V>::value, "");
+ static_assert(test_constexpr_ctor_imp<0>(V(42l)), "");
+ static_assert(test_constexpr_ctor_imp<1>(V(NonTrivialMoveCtor(5))), "");
+ static_assert(test_constexpr_ctor_imp<2>(V(nullptr)), "");
+ }
+#endif
}
int main(int, char**) {
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
index 2e026038c97a3c..53c5283b2edc6f 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
@@ -21,55 +21,76 @@
#include "test_macros.h"
struct NonTDtor {
- static int count;
- NonTDtor() = default;
- ~NonTDtor() { ++count; }
+ int* count;
+ constexpr NonTDtor(int* a, int*) : count(a) {}
+ TEST_CONSTEXPR_CXX20 ~NonTDtor() { ++*count; }
};
-int NonTDtor::count = 0;
static_assert(!std::is_trivially_destructible<NonTDtor>::value, "");
struct NonTDtor1 {
- static int count;
- NonTDtor1() = default;
- ~NonTDtor1() { ++count; }
+ int* count;
+ constexpr NonTDtor1(int*, int* b) : count(b) {}
+ TEST_CONSTEXPR_CXX20 ~NonTDtor1() { ++*count; }
};
-int NonTDtor1::count = 0;
static_assert(!std::is_trivially_destructible<NonTDtor1>::value, "");
struct TDtor {
- TDtor(const TDtor &) {} // non-trivial copy
- ~TDtor() = default;
+ constexpr TDtor() = default;
+ constexpr TDtor(const TDtor&) {} // non-trivial copy
+ TEST_CONSTEXPR_CXX20 ~TDtor() = default;
};
static_assert(!std::is_trivially_copy_constructible<TDtor>::value, "");
static_assert(std::is_trivially_destructible<TDtor>::value, "");
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
{
using V = std::variant<int, long, TDtor>;
static_assert(std::is_trivially_destructible<V>::value, "");
+ [[maybe_unused]] V v(std::in_place_index<2>);
}
{
using V = std::variant<NonTDtor, int, NonTDtor1>;
static_assert(!std::is_trivially_destructible<V>::value, "");
{
- V v(std::in_place_index<0>);
- assert(NonTDtor::count == 0);
- assert(NonTDtor1::count == 0);
+ int count0 = 0;
+ int count1 = 0;
+ {
+ V v(std::in_place_index<0>, &count0, &count1);
+ assert(count0 == 0);
+ assert(count1 == 0);
+ }
+ assert(count0 == 1);
+ assert(count1 == 0);
+ }
+ {
+ int count0 = 0;
+ int count1 = 0;
+ { V v(std::in_place_index<1>); }
+ assert(count0 == 0);
+ assert(count1 == 0);
}
- assert(NonTDtor::count == 1);
- assert(NonTDtor1::count == 0);
- NonTDtor::count = 0;
- { V v(std::in_place_index<1>); }
- assert(NonTDtor::count == 0);
- assert(NonTDtor1::count == 0);
{
- V v(std::in_place_index<2>);
- assert(NonTDtor::count == 0);
- assert(NonTDtor1::count == 0);
+ int count0 = 0;
+ int count1 = 0;
+ {
+ V v(std::in_place_index<2>, &count0, &count1);
+ assert(count0 == 0);
+ assert(count1 == 0);
+ }
+ assert(count0 == 0);
+ assert(count1 == 1);
}
- assert(NonTDtor::count == 0);
- assert(NonTDtor1::count == 1);
}
+ return true;
+}
+
+int main(int, char**) {
+ test();
+
+#if TEST_STD_VER >= 20
+ static_assert(test());
+#endif
+
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
index 96fcd7e7bee481..36c78d1b22bd0c 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
@@ -26,8 +26,8 @@
#include "variant_test_helpers.h"
template <class Var, std::size_t I, class... Args>
-constexpr auto test_emplace_exists_imp(int) -> decltype(
- std::declval<Var>().template emplace<I>(std::declval<Args>()...), true) {
+constexpr auto test_emplace_exists_imp(int)
+ -> decltype(std::declval<Var>().template emplace<I>(std::declval<Args>()...), true) {
return true;
}
@@ -36,51 +36,32 @@ constexpr auto test_emplace_exists_imp(long) -> bool {
return false;
}
-template <class Var, std::size_t I, class... Args> constexpr bool emplace_exists() {
+template <class Var, std::size_t I, class... Args>
+constexpr bool emplace_exists() {
return test_emplace_exists_imp<Var, I, Args...>(0);
}
void test_emplace_sfinae() {
{
- using V = std::variant<int, void *, const void *, TestTypes::NoCtors>;
+ using V = std::variant<int, void*, const void*, TestTypes::NoCtors>;
static_assert(emplace_exists<V, 0>(), "");
static_assert(emplace_exists<V, 0, int>(), "");
- static_assert(!emplace_exists<V, 0, decltype(nullptr)>(),
- "cannot construct");
+ static_assert(!emplace_exists<V, 0, decltype(nullptr)>(), "cannot construct");
static_assert(emplace_exists<V, 1, decltype(nullptr)>(), "");
- static_assert(emplace_exists<V, 1, int *>(), "");
- static_assert(!emplace_exists<V, 1, const int *>(), "");
+ static_assert(emplace_exists<V, 1, int*>(), "");
+ static_assert(!emplace_exists<V, 1, const int*>(), "");
static_assert(!emplace_exists<V, 1, int>(), "cannot construct");
- static_assert(emplace_exists<V, 2, const int *>(), "");
- static_assert(emplace_exists<V, 2, int *>(), "");
+ static_assert(emplace_exists<V, 2, const int*>(), "");
+ static_assert(emplace_exists<V, 2, int*>(), "");
static_assert(!emplace_exists<V, 3>(), "cannot construct");
}
-#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
- {
- using V = std::variant<int, int &, const int &, int &&, TestTypes::NoCtors>;
- static_assert(emplace_exists<V, 0>(), "");
- static_assert(emplace_exists<V, 0, int>(), "");
- static_assert(emplace_exists<V, 0, long long>(), "");
- static_assert(!emplace_exists<V, 0, int, int>(), "too many args");
- static_assert(emplace_exists<V, 1, int &>(), "");
- static_assert(!emplace_exists<V, 1>(), "cannot default construct ref");
- static_assert(!emplace_exists<V, 1, const int &>(), "cannot bind ref");
- static_assert(!emplace_exists<V, 1, int &&>(), "cannot bind ref");
- static_assert(emplace_exists<V, 2, int &>(), "");
- static_assert(emplace_exists<V, 2, const int &>(), "");
- static_assert(emplace_exists<V, 2, int &&>(), "");
- static_assert(!emplace_exists<V, 2, void *>(),
- "not constructible from void*");
- static_assert(emplace_exists<V, 3, int>(), "");
- static_assert(!emplace_exists<V, 3, int &>(), "cannot bind ref");
- static_assert(!emplace_exists<V, 3, const int &>(), "cannot bind ref");
- static_assert(!emplace_exists<V, 3, const int &&>(), "cannot bind ref");
- static_assert(!emplace_exists<V, 4>(), "no ctors");
- }
-#endif
}
-void test_basic() {
+struct NoCtor {
+ NoCtor() = delete;
+};
+
+TEST_CONSTEXPR_CXX20 bool test_basic() {
{
using V = std::variant<int>;
V v(42);
@@ -93,9 +74,9 @@ void test_basic() {
assert(std::get<0>(v) == 42);
assert(&ref2 == &std::get<0>(v));
}
+
{
- using V =
- std::variant<int, long, const void *, TestTypes::NoCtors, std::string>;
+ using V = std::variant<int, long, const void*, NoCtor, std::string>;
const int x = 100;
V v(std::in_place_index<0>, -1);
// default emplace a value
@@ -113,45 +94,15 @@ void test_basic() {
assert(std::get<4>(v) == "aaa");
assert(&ref3 == &std::get<4>(v));
}
-#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
- {
- using V = std::variant<int, long, const int &, int &&, TestTypes::NoCtors,
- std::string>;
- const int x = 100;
- int y = 42;
- int z = 43;
- V v(std::in_place_index<0>, -1);
- // default emplace a value
- auto& ref1 = v.emplace<1>();
- static_assert(std::is_same_v<long&, decltype(ref1)>, "");
- assert(std::get<1>(v) == 0);
- assert(&ref1 == &std::get<1>(v));
- // emplace a reference
- auto& ref2 = v.emplace<2>(x);
- static_assert(std::is_same_v<&, decltype(ref)>, "");
- assert(&std::get<2>(v) == &x);
- assert(&ref2 == &std::get<2>(v));
- // emplace an rvalue reference
- auto& ref3 = v.emplace<3>(std::move(y));
- static_assert(std::is_same_v<&, decltype(ref)>, "");
- assert(&std::get<3>(v) == &y);
- assert(&ref3 == &std::get<3>(v));
- // re-emplace a new reference over the active member
- auto& ref4 = v.emplace<3>(std::move(z));
- static_assert(std::is_same_v<&, decltype(ref)>, "");
- assert(&std::get<3>(v) == &z);
- assert(&ref4 == &std::get<3>(v));
- // emplace with multiple args
- auto& ref5 = v.emplace<5>(3u, 'a');
- static_assert(std::is_same_v<std::string&, decltype(ref5)>, "");
- assert(std::get<5>(v) == "aaa");
- assert(&ref5 == &std::get<5>(v));
- }
-#endif
+
+ return true;
}
int main(int, char**) {
test_basic();
+#if TEST_STD_VER >= 20
+ static_assert(test_basic());
+#endif
test_emplace_sfinae();
return 0;
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
index 9068aacc435928..0bf279f41a8e52 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
@@ -32,13 +32,12 @@ struct InitList {
struct InitListArg {
std::size_t size;
int value;
- constexpr InitListArg(std::initializer_list<int> il, int v)
- : size(il.size()), value(v) {}
+ constexpr InitListArg(std::initializer_list<int> il, int v) : size(il.size()), value(v) {}
};
template <class Var, std::size_t I, class... Args>
-constexpr auto test_emplace_exists_imp(int) -> decltype(
- std::declval<Var>().template emplace<I>(std::declval<Args>()...), true) {
+constexpr auto test_emplace_exists_imp(int)
+ -> decltype(std::declval<Var>().template emplace<I>(std::declval<Args>()...), true) {
return true;
}
@@ -47,13 +46,13 @@ constexpr auto test_emplace_exists_imp(long) -> bool {
return false;
}
-template <class Var, std::size_t I, class... Args> constexpr bool emplace_exists() {
+template <class Var, std::size_t I, class... Args>
+constexpr bool emplace_exists() {
return test_emplace_exists_imp<Var, I, Args...>(0);
}
void test_emplace_sfinae() {
- using V =
- std::variant<int, TestTypes::NoCtors, InitList, InitListArg, long, long>;
+ using V = std::variant<int, TestTypes::NoCtors, InitList, InitListArg, long, long>;
using IL = std::initializer_list<int>;
static_assert(!emplace_exists<V, 1, IL>(), "no such constructor");
static_assert(emplace_exists<V, 2, IL>(), "");
@@ -65,8 +64,12 @@ void test_emplace_sfinae() {
static_assert(!emplace_exists<V, 3, IL, int, int>(), "too many args");
}
-void test_basic() {
- using V = std::variant<int, InitList, InitListArg, TestTypes::NoCtors>;
+struct NoCtor {
+ NoCtor() = delete;
+};
+
+TEST_CONSTEXPR_CXX20 bool test_basic() {
+ using V = std::variant<int, InitList, InitListArg, NoCtor>;
V v;
auto& ref1 = v.emplace<1>({1, 2, 3});
static_assert(std::is_same_v<InitList&, decltype(ref1)>, "");
@@ -81,10 +84,15 @@ void test_basic() {
static_assert(std::is_same_v<InitList&, decltype(ref3)>, "");
assert(std::get<1>(v).size == 1);
assert(&ref3 == &std::get<1>(v));
+
+ return true;
}
int main(int, char**) {
test_basic();
+#if TEST_STD_VER >= 20
+ static_assert(test_basic());
+#endif
test_emplace_sfinae();
return 0;
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
index 24305aa0a35dae..7712a8149aa116 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
@@ -25,8 +25,8 @@
#include "variant_test_helpers.h"
template <class Var, class T, class... Args>
-constexpr auto test_emplace_exists_imp(int) -> decltype(
- std::declval<Var>().template emplace<T>(std::declval<Args>()...), true) {
+constexpr auto test_emplace_exists_imp(int)
+ -> decltype(std::declval<Var>().template emplace<T>(std::declval<Args>()...), true) {
return true;
}
@@ -35,52 +35,32 @@ constexpr auto test_emplace_exists_imp(long) -> bool {
return false;
}
-template <class... Args> constexpr bool emplace_exists() {
+template <class... Args>
+constexpr bool emplace_exists() {
return test_emplace_exists_imp<Args...>(0);
}
void test_emplace_sfinae() {
{
- using V = std::variant<int, void *, const void *, TestTypes::NoCtors>;
+ using V = std::variant<int, void*, const void*, TestTypes::NoCtors>;
static_assert(emplace_exists<V, int>(), "");
static_assert(emplace_exists<V, int, int>(), "");
- static_assert(!emplace_exists<V, int, decltype(nullptr)>(),
- "cannot construct");
- static_assert(emplace_exists<V, void *, decltype(nullptr)>(), "");
- static_assert(!emplace_exists<V, void *, int>(), "cannot construct");
- static_assert(emplace_exists<V, void *, int *>(), "");
- static_assert(!emplace_exists<V, void *, const int *>(), "");
- static_assert(emplace_exists<V, const void *, const int *>(), "");
- static_assert(emplace_exists<V, const void *, int *>(), "");
+ static_assert(!emplace_exists<V, int, decltype(nullptr)>(), "cannot construct");
+ static_assert(emplace_exists<V, void*, decltype(nullptr)>(), "");
+ static_assert(!emplace_exists<V, void*, int>(), "cannot construct");
+ static_assert(emplace_exists<V, void*, int*>(), "");
+ static_assert(!emplace_exists<V, void*, const int*>(), "");
+ static_assert(emplace_exists<V, const void*, const int*>(), "");
+ static_assert(emplace_exists<V, const void*, int*>(), "");
static_assert(!emplace_exists<V, TestTypes::NoCtors>(), "cannot construct");
}
-#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
- using V = std::variant<int, int &, const int &, int &&, long, long,
- TestTypes::NoCtors>;
- static_assert(emplace_exists<V, int>(), "");
- static_assert(emplace_exists<V, int, int>(), "");
- static_assert(emplace_exists<V, int, long long>(), "");
- static_assert(!emplace_exists<V, int, int, int>(), "too many args");
- static_assert(emplace_exists<V, int &, int &>(), "");
- static_assert(!emplace_exists<V, int &>(), "cannot default construct ref");
- static_assert(!emplace_exists<V, int &, const int &>(), "cannot bind ref");
- static_assert(!emplace_exists<V, int &, int &&>(), "cannot bind ref");
- static_assert(emplace_exists<V, const int &, int &>(), "");
- static_assert(emplace_exists<V, const int &, const int &>(), "");
- static_assert(emplace_exists<V, const int &, int &&>(), "");
- static_assert(!emplace_exists<V, const int &, void *>(),
- "not constructible from void*");
- static_assert(emplace_exists<V, int &&, int>(), "");
- static_assert(!emplace_exists<V, int &&, int &>(), "cannot bind ref");
- static_assert(!emplace_exists<V, int &&, const int &>(), "cannot bind ref");
- static_assert(!emplace_exists<V, int &&, const int &&>(), "cannot bind ref");
- static_assert(!emplace_exists<V, long, long>(), "ambiguous");
- static_assert(!emplace_exists<V, TestTypes::NoCtors>(),
- "cannot construct void");
-#endif
}
-void test_basic() {
+struct NoCtor {
+ NoCtor() = delete;
+};
+
+TEST_CONSTEXPR_CXX20 bool test_basic() {
{
using V = std::variant<int>;
V v(42);
@@ -94,8 +74,7 @@ void test_basic() {
assert(&ref2 == &std::get<0>(v));
}
{
- using V =
- std::variant<int, long, const void *, TestTypes::NoCtors, std::string>;
+ using V = std::variant<int, long, const void*, NoCtor, std::string>;
const int x = 100;
V v(std::in_place_type<int>, -1);
// default emplace a value
@@ -103,8 +82,8 @@ void test_basic() {
static_assert(std::is_same_v<long&, decltype(ref1)>, "");
assert(std::get<1>(v) == 0);
assert(&ref1 == &std::get<1>(v));
- auto& ref2 = v.emplace<const void *>(&x);
- static_assert(std::is_same_v<const void *&, decltype(ref2)>, "");
+ auto& ref2 = v.emplace<const void*>(&x);
+ static_assert(std::is_same_v<const void*&, decltype(ref2)>, "");
assert(std::get<2>(v) == &x);
assert(&ref2 == &std::get<2>(v));
// emplace with multiple args
@@ -113,45 +92,14 @@ void test_basic() {
assert(std::get<4>(v) == "aaa");
assert(&ref3 == &std::get<4>(v));
}
-#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
- {
- using V = std::variant<int, long, const int &, int &&, TestTypes::NoCtors,
- std::string>;
- const int x = 100;
- int y = 42;
- int z = 43;
- V v(std::in_place_index<0>, -1);
- // default emplace a value
- auto& ref1 = v.emplace<long>();
- static_assert(std::is_same_v<long&, decltype(ref1)>, "");
- assert(std::get<long>(v) == 0);
- assert(&ref1 == &std::get<long>(v));
- // emplace a reference
- auto& ref2 = v.emplace<const int &>(x);
- static_assert(std::is_same_v<const int&, decltype(ref2)>, "");
- assert(&std::get<const int &>(v) == &x);
- assert(&ref2 == &std::get<const int &>(v));
- // emplace an rvalue reference
- auto& ref3 = v.emplace<int &&>(std::move(y));
- static_assert(std::is_same_v<int &&, decltype(ref3)>, "");
- assert(&std::get<int &&>(v) == &y);
- assert(&ref3 == &std::get<int &&>(v));
- // re-emplace a new reference over the active member
- auto& ref4 = v.emplace<int &&>(std::move(z));
- static_assert(std::is_same_v<int &, decltype(ref4)>, "");
- assert(&std::get<int &&>(v) == &z);
- assert(&ref4 == &std::get<int &&>(v));
- // emplace with multiple args
- auto& ref5 = v.emplace<std::string>(3u, 'a');
- static_assert(std::is_same_v<std::string&, decltype(ref5)>, "");
- assert(std::get<std::string>(v) == "aaa");
- assert(&ref5 == &std::get<std::string>(v));
- }
-#endif
+ return true;
}
int main(int, char**) {
test_basic();
+#if TEST_STD_VER >= 20
+ static_assert(test_basic());
+#endif
test_emplace_sfinae();
return 0;
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
index 74d834b9b34575..6cd862c7d8095b 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
@@ -32,13 +32,12 @@ struct InitList {
struct InitListArg {
std::size_t size;
int value;
- constexpr InitListArg(std::initializer_list<int> il, int v)
- : size(il.size()), value(v) {}
+ constexpr InitListArg(std::initializer_list<int> il, int v) : size(il.size()), value(v) {}
};
template <class Var, class T, class... Args>
-constexpr auto test_emplace_exists_imp(int) -> decltype(
- std::declval<Var>().template emplace<T>(std::declval<Args>()...), true) {
+constexpr auto test_emplace_exists_imp(int)
+ -> decltype(std::declval<Var>().template emplace<T>(std::declval<Args>()...), true) {
return true;
}
@@ -47,13 +46,13 @@ constexpr auto test_emplace_exists_imp(long) -> bool {
return false;
}
-template <class... Args> constexpr bool emplace_exists() {
+template <class... Args>
+constexpr bool emplace_exists() {
return test_emplace_exists_imp<Args...>(0);
}
void test_emplace_sfinae() {
- using V =
- std::variant<int, TestTypes::NoCtors, InitList, InitListArg, long, long>;
+ using V = std::variant<int, TestTypes::NoCtors, InitList, InitListArg, long, long>;
using IL = std::initializer_list<int>;
static_assert(emplace_exists<V, InitList, IL>(), "");
static_assert(!emplace_exists<V, InitList, int>(), "args don't match");
@@ -61,30 +60,37 @@ void test_emplace_sfinae() {
static_assert(emplace_exists<V, InitListArg, IL, int>(), "");
static_assert(!emplace_exists<V, InitListArg, int>(), "args don't match");
static_assert(!emplace_exists<V, InitListArg, IL>(), "too few args");
- static_assert(!emplace_exists<V, InitListArg, IL, int, int>(),
- "too many args");
+ static_assert(!emplace_exists<V, InitListArg, IL, int, int>(), "too many args");
}
-void test_basic() {
- using V = std::variant<int, InitList, InitListArg, TestTypes::NoCtors>;
+struct NoCtor {
+ NoCtor() = delete;
+};
+
+TEST_CONSTEXPR_CXX20 bool test_basic() {
+ using V = std::variant<int, InitList, InitListArg, NoCtor>;
V v;
auto& ref1 = v.emplace<InitList>({1, 2, 3});
- static_assert(std::is_same_v<InitList&,decltype(ref1)>, "");
+ static_assert(std::is_same_v<InitList&, decltype(ref1)>, "");
assert(std::get<InitList>(v).size == 3);
assert(&ref1 == &std::get<InitList>(v));
auto& ref2 = v.emplace<InitListArg>({1, 2, 3, 4}, 42);
- static_assert(std::is_same_v<InitListArg&,decltype(ref2)>, "");
+ static_assert(std::is_same_v<InitListArg&, decltype(ref2)>, "");
assert(std::get<InitListArg>(v).size == 4);
assert(std::get<InitListArg>(v).value == 42);
assert(&ref2 == &std::get<InitListArg>(v));
auto& ref3 = v.emplace<InitList>({1});
- static_assert(std::is_same_v<InitList&,decltype(ref3)>, "");
+ static_assert(std::is_same_v<InitList&, decltype(ref3)>, "");
assert(std::get<InitList>(v).size == 1);
assert(&ref3 == &std::get<InitList>(v));
+ return true;
}
int main(int, char**) {
test_basic();
+#if TEST_STD_VER >= 20
+ static_assert(test_basic());
+#endif
test_emplace_sfinae();
return 0;
>From 0c82ab4436223878a2eb5a5d37bab8ba15e00423 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Wed, 28 Feb 2024 22:02:47 +0000
Subject: [PATCH 2/9] assign
---
libcxx/include/variant | 35 +-
.../variant.variant/variant.assign/T.pass.cpp | 93 ++---
.../variant.assign/copy.pass.cpp | 367 ++++++++++--------
.../variant.assign/move.pass.cpp | 252 ++++++------
.../variant.ctor/copy.pass.cpp | 11 +-
.../variant.ctor/move.pass.cpp | 13 +-
6 files changed, 414 insertions(+), 357 deletions(-)
diff --git a/libcxx/include/variant b/libcxx/include/variant
index 895f2350449e65..dd0aa1fdeacb5c 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -926,7 +926,7 @@ protected:
}
template <class _That>
- _LIBCPP_HIDE_FROM_ABI void __generic_assign(_That&& __that) {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __generic_assign(_That&& __that) {
if (this->valueless_by_exception() && __that.valueless_by_exception()) {
// do nothing.
} else if (__that.valueless_by_exception()) {
@@ -963,19 +963,21 @@ class _LIBCPP_TEMPLATE_VIS __move_assignment;
move_assignment \
}
-_LIBCPP_VARIANT_MOVE_ASSIGNMENT(_Trait::_TriviallyAvailable,
- __move_assignment& operator=(__move_assignment&& __that) = default;);
+_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
+ _Trait::_TriviallyAvailable,
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment& operator=(__move_assignment&& __that) = default;);
_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
_Trait::_Available,
- __move_assignment&
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment&
operator=(__move_assignment&& __that) noexcept(
__all<(is_nothrow_move_constructible_v<_Types> && is_nothrow_move_assignable_v<_Types>)...>::value) {
this->__generic_assign(std::move(__that));
return *this;
});
-_LIBCPP_VARIANT_MOVE_ASSIGNMENT(_Trait::_Unavailable, __move_assignment& operator=(__move_assignment&&) = delete;);
+_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
+ _Trait::_Unavailable, _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment& operator=(__move_assignment&&) = delete;);
# undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT
@@ -998,16 +1000,19 @@ class _LIBCPP_TEMPLATE_VIS __copy_assignment;
copy_assignment __copy_assignment& operator=(__copy_assignment&&) = default; \
}
-_LIBCPP_VARIANT_COPY_ASSIGNMENT(_Trait::_TriviallyAvailable,
- __copy_assignment& operator=(const __copy_assignment& __that) = default;);
+_LIBCPP_VARIANT_COPY_ASSIGNMENT(
+ _Trait::_TriviallyAvailable,
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment& operator=(const __copy_assignment& __that) = default;);
_LIBCPP_VARIANT_COPY_ASSIGNMENT(
- _Trait::_Available, __copy_assignment& operator=(const __copy_assignment& __that) {
+ _Trait::_Available, _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment& operator=(const __copy_assignment& __that) {
this->__generic_assign(__that);
return *this;
});
-_LIBCPP_VARIANT_COPY_ASSIGNMENT(_Trait::_Unavailable, __copy_assignment& operator=(const __copy_assignment&) = delete;);
+_LIBCPP_VARIANT_COPY_ASSIGNMENT(
+ _Trait::_Unavailable,
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment& operator=(const __copy_assignment&) = delete;);
# undef _LIBCPP_VARIANT_COPY_ASSIGNMENT
@@ -1023,11 +1028,11 @@ public:
_LIBCPP_HIDE_FROM_ABI __impl& operator=(__impl&&) = default;
template <size_t _Ip, class _Arg>
- _LIBCPP_HIDE_FROM_ABI void __assign(_Arg&& __arg) {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __assign(_Arg&& __arg) {
this->__assign_alt(__access::__base::__get_alt<_Ip>(*this), std::forward<_Arg>(__arg));
}
- inline _LIBCPP_HIDE_FROM_ABI void __swap(__impl& __that) {
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void __swap(__impl& __that) {
if (this->valueless_by_exception() && __that.valueless_by_exception()) {
// do nothing.
} else if (this->index() == __that.index()) {
@@ -1072,7 +1077,7 @@ public:
}
private:
- inline _LIBCPP_HIDE_FROM_ABI bool __move_nothrow() const {
+ constexpr inline _LIBCPP_HIDE_FROM_ABI bool __move_nothrow() const {
constexpr bool __results[] = {is_nothrow_move_constructible_v<_Types>...};
return this->valueless_by_exception() || __results[this->index()];
}
@@ -1236,7 +1241,7 @@ public:
_Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>)
: __impl_(in_place_index<_Ip>, __il, std::forward<_Args>(__args)...) {}
- _LIBCPP_HIDE_FROM_ABI ~variant() = default;
+ _LIBCPP_HIDE_FROM_ABI constexpr ~variant() = default;
_LIBCPP_HIDE_FROM_ABI constexpr variant& operator=(const variant&) = default;
_LIBCPP_HIDE_FROM_ABI constexpr variant& operator=(variant&&) = default;
@@ -1246,7 +1251,7 @@ public:
class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI variant&
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI variant&
operator=(_Arg&& __arg) noexcept(is_nothrow_assignable_v<_Tp&, _Arg> && is_nothrow_constructible_v<_Tp, _Arg>) {
__impl_.template __assign<_Ip>(std::forward<_Arg>(__arg));
return *this;
@@ -1298,7 +1303,7 @@ public:
enable_if_t< __all<(__dependent_type<is_move_constructible<_Types>, _Dummy>::value &&
__dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value,
int> = 0>
- _LIBCPP_HIDE_FROM_ABI void swap(variant& __that) noexcept(
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void swap(variant& __that) noexcept(
__all<(is_nothrow_move_constructible_v<_Types> && is_nothrow_swappable_v<_Types>)...>::value) {
__impl_.__swap(__that.__impl_);
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
index b3fc2021a6b223..be9e38f893093c 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
@@ -33,17 +33,17 @@ struct Dummy {
struct ThrowsCtorT {
ThrowsCtorT(int) noexcept(false) {}
- ThrowsCtorT &operator=(int) noexcept { return *this; }
+ ThrowsCtorT& operator=(int) noexcept { return *this; }
};
struct ThrowsAssignT {
ThrowsAssignT(int) noexcept {}
- ThrowsAssignT &operator=(int) noexcept(false) { return *this; }
+ ThrowsAssignT& operator=(int) noexcept(false) { return *this; }
};
struct NoThrowT {
NoThrowT(int) noexcept {}
- NoThrowT &operator=(int) noexcept { return *this; }
+ NoThrowT& operator=(int) noexcept { return *this; }
};
} // namespace MetaHelpers
@@ -55,7 +55,7 @@ struct ThrowsCtorT {
int value;
ThrowsCtorT() : value(0) {}
ThrowsCtorT(int) noexcept(false) { throw 42; }
- ThrowsCtorT &operator=(int v) noexcept {
+ ThrowsCtorT& operator=(int v) noexcept {
value = v;
return *this;
}
@@ -64,9 +64,12 @@ struct ThrowsCtorT {
struct MoveCrashes {
int value;
MoveCrashes(int v = 0) noexcept : value{v} {}
- MoveCrashes(MoveCrashes &&) noexcept { assert(false); }
- MoveCrashes &operator=(MoveCrashes &&) noexcept { assert(false); return *this; }
- MoveCrashes &operator=(int v) noexcept {
+ MoveCrashes(MoveCrashes&&) noexcept { assert(false); }
+ MoveCrashes& operator=(MoveCrashes&&) noexcept {
+ assert(false);
+ return *this;
+ }
+ MoveCrashes& operator=(int v) noexcept {
value = v;
return *this;
}
@@ -76,8 +79,8 @@ struct ThrowsCtorTandMove {
int value;
ThrowsCtorTandMove() : value(0) {}
ThrowsCtorTandMove(int) noexcept(false) { throw 42; }
- ThrowsCtorTandMove(ThrowsCtorTandMove &&) noexcept(false) { assert(false); }
- ThrowsCtorTandMove &operator=(int v) noexcept {
+ ThrowsCtorTandMove(ThrowsCtorTandMove&&) noexcept(false) { assert(false); }
+ ThrowsCtorTandMove& operator=(int v) noexcept {
value = v;
return *this;
}
@@ -87,14 +90,14 @@ struct ThrowsAssignT {
int value;
ThrowsAssignT() : value(0) {}
ThrowsAssignT(int v) noexcept : value(v) {}
- ThrowsAssignT &operator=(int) noexcept(false) { throw 42; }
+ ThrowsAssignT& operator=(int) noexcept(false) { throw 42; }
};
struct NoThrowT {
int value;
NoThrowT() : value(0) {}
NoThrowT(int v) noexcept : value(v) {}
- NoThrowT &operator=(int v) noexcept {
+ NoThrowT& operator=(int v) noexcept {
value = v;
return *this;
}
@@ -126,29 +129,25 @@ void test_T_assignment_sfinae() {
}
{
using V = std::variant<std::string, std::string>;
- static_assert(!std::is_assignable<V, const char *>::value, "ambiguous");
+ static_assert(!std::is_assignable<V, const char*>::value, "ambiguous");
}
{
- using V = std::variant<std::string, void *>;
+ using V = std::variant<std::string, void*>;
static_assert(!std::is_assignable<V, int>::value, "no matching operator=");
}
{
using V = std::variant<std::string, float>;
- static_assert(std::is_assignable<V, int>::value == VariantAllowsNarrowingConversions,
- "no matching operator=");
+ static_assert(std::is_assignable<V, int>::value == VariantAllowsNarrowingConversions, "no matching operator=");
}
{
using V = std::variant<std::unique_ptr<int>, bool>;
- static_assert(!std::is_assignable<V, std::unique_ptr<char>>::value,
- "no explicit bool in operator=");
+ static_assert(!std::is_assignable<V, std::unique_ptr<char>>::value, "no explicit bool in operator=");
struct X {
operator void*();
};
- static_assert(!std::is_assignable<V, X>::value,
- "no boolean conversion in operator=");
+ static_assert(!std::is_assignable<V, X>::value, "no boolean conversion in operator=");
#ifndef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
- static_assert(std::is_assignable<V, std::false_type>::value,
- "converted to bool in operator=");
+ static_assert(std::is_assignable<V, std::false_type>::value, "converted to bool in operator=");
#endif
}
{
@@ -157,22 +156,21 @@ void test_T_assignment_sfinae() {
operator X();
};
using V = std::variant<X>;
- static_assert(std::is_assignable<V, Y>::value,
- "regression on user-defined conversions in operator=");
+ static_assert(std::is_assignable<V, Y>::value, "regression on user-defined conversions in operator=");
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{
- using V = std::variant<int, int &&>;
+ using V = std::variant<int, int&&>;
static_assert(!std::is_assignable<V, int>::value, "ambiguous");
}
{
- using V = std::variant<int, const int &>;
+ using V = std::variant<int, const int&>;
static_assert(!std::is_assignable<V, int>::value, "ambiguous");
}
#endif // TEST_VARIANT_HAS_NO_REFERENCES
}
-void test_T_assignment_basic() {
+TEST_CONSTEXPR_CXX20 bool test_T_assignment_basic() {
{
std::variant<int> v(43);
v = 42;
@@ -201,35 +199,18 @@ void test_T_assignment_basic() {
#endif
{
std::variant<std::string, bool> v = true;
- v = "bar";
+ v = "bar";
assert(v.index() == 0);
assert(std::get<0>(v) == "bar");
}
- {
- std::variant<bool, std::unique_ptr<int>> v;
- v = nullptr;
- assert(v.index() == 1);
- assert(std::get<1>(v) == nullptr);
- }
-#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
- {
- using V = std::variant<int &, int &&, long>;
- int x = 42;
- V v(43l);
- v = x;
- assert(v.index() == 0);
- assert(&std::get<0>(v) == &x);
- v = std::move(x);
- assert(v.index() == 1);
- assert(&std::get<1>(v) == &x);
- // 'long' is selected by FUN(const int &) since 'const int &' cannot bind
- // to 'int&'.
- const int &cx = x;
- v = cx;
- assert(v.index() == 2);
- assert(std::get<2>(v) == 42);
- }
-#endif // TEST_VARIANT_HAS_NO_REFERENCES
+ return true;
+}
+
+void test_T_assignment_basic_no_constexpr() {
+ std::variant<bool, std::unique_ptr<int>> v;
+ v = nullptr;
+ assert(v.index() == 1);
+ assert(std::get<1>(v) == nullptr);
}
void test_T_assignment_performs_construction() {
@@ -298,7 +279,7 @@ void test_T_assignment_performs_assignment() {
#endif // TEST_HAS_NO_EXCEPTIONS
}
-void test_T_assignment_vector_bool() {
+TEST_CONSTEXPR_CXX20 bool test_T_assignment_vector_bool() {
#ifndef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
std::vector<bool> vec = {true};
std::variant<bool, int> v;
@@ -306,15 +287,21 @@ void test_T_assignment_vector_bool() {
assert(v.index() == 0);
assert(std::get<0>(v) == true);
#endif
+ return true;
}
int main(int, char**) {
test_T_assignment_basic();
+ test_T_assignment_basic_no_constexpr();
test_T_assignment_performs_construction();
test_T_assignment_performs_assignment();
test_T_assignment_noexcept();
test_T_assignment_sfinae();
test_T_assignment_vector_bool();
+#if TEST_STD_VER >= 20
+ static_assert(test_T_assignment_basic());
+ static_assert(test_T_assignment_vector_bool());
+#endif
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
index 096d365d2d7525..5a5d077e8c4ba0 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
@@ -22,88 +22,108 @@
#include "test_macros.h"
struct NoCopy {
- NoCopy(const NoCopy &) = delete;
- NoCopy &operator=(const NoCopy &) = default;
+ NoCopy(const NoCopy&) = delete;
+ NoCopy& operator=(const NoCopy&) = default;
};
struct CopyOnly {
- CopyOnly(const CopyOnly &) = default;
- CopyOnly(CopyOnly &&) = delete;
- CopyOnly &operator=(const CopyOnly &) = default;
- CopyOnly &operator=(CopyOnly &&) = delete;
+ CopyOnly(const CopyOnly&) = default;
+ CopyOnly(CopyOnly&&) = delete;
+ CopyOnly& operator=(const CopyOnly&) = default;
+ CopyOnly& operator=(CopyOnly&&) = delete;
};
struct MoveOnly {
- MoveOnly(const MoveOnly &) = delete;
- MoveOnly(MoveOnly &&) = default;
- MoveOnly &operator=(const MoveOnly &) = default;
+ MoveOnly(const MoveOnly&) = delete;
+ MoveOnly(MoveOnly&&) = default;
+ MoveOnly& operator=(const MoveOnly&) = default;
};
struct MoveOnlyNT {
- MoveOnlyNT(const MoveOnlyNT &) = delete;
- MoveOnlyNT(MoveOnlyNT &&) {}
- MoveOnlyNT &operator=(const MoveOnlyNT &) = default;
+ MoveOnlyNT(const MoveOnlyNT&) = delete;
+ MoveOnlyNT(MoveOnlyNT&&) {}
+ MoveOnlyNT& operator=(const MoveOnlyNT&) = default;
};
struct CopyAssign {
- static int alive;
- static int copy_construct;
- static int copy_assign;
- static int move_construct;
- static int move_assign;
- static void reset() {
- copy_construct = copy_assign = move_construct = move_assign = alive = 0;
- }
- CopyAssign(int v) : value(v) { ++alive; }
- CopyAssign(const CopyAssign &o) : value(o.value) {
- ++alive;
- ++copy_construct;
- }
- CopyAssign(CopyAssign &&o) noexcept : value(o.value) {
+ constexpr CopyAssign(int v, int* alv, int* cpy_ctr, int* cpy_assi, int* move_ctr, int* move_assi)
+ : value(v),
+ alive(alv),
+ copy_construct(cpy_ctr),
+ copy_assign(cpy_assi),
+ move_construct(move_ctr),
+ move_assign(move_assi) {
+ ++*alive;
+ }
+ constexpr CopyAssign(const CopyAssign& o)
+ : value(o.value),
+ alive(o.alive),
+ copy_construct(o.copy_construct),
+ copy_assign(o.copy_assign),
+ move_construct(o.move_construct),
+ move_assign(o.move_assign) {
+ ++*alive;
+ ++*copy_construct;
+ }
+ constexpr CopyAssign(CopyAssign&& o) noexcept
+ : value(o.value),
+ alive(o.alive),
+ copy_construct(o.copy_construct),
+ copy_assign(o.copy_assign),
+ move_construct(o.move_construct),
+ move_assign(o.move_assign) {
o.value = -1;
- ++alive;
- ++move_construct;
- }
- CopyAssign &operator=(const CopyAssign &o) {
- value = o.value;
- ++copy_assign;
+ ++*alive;
+ ++*move_construct;
+ }
+ constexpr CopyAssign& operator=(const CopyAssign& o) {
+ value = o.value;
+ alive = o.alive;
+ copy_construct = o.copy_construct;
+ copy_assign = o.copy_assign;
+ move_construct = o.move_construct;
+ move_assign = o.move_assign;
+ ++*copy_assign;
return *this;
}
- CopyAssign &operator=(CopyAssign &&o) noexcept {
- value = o.value;
- o.value = -1;
- ++move_assign;
+ constexpr CopyAssign& operator=(CopyAssign&& o) noexcept {
+ value = o.value;
+ alive = o.alive;
+ copy_construct = o.copy_construct;
+ copy_assign = o.copy_assign;
+ move_construct = o.move_construct;
+ move_assign = o.move_assign;
+ o.value = -1;
+ ++*move_assign;
return *this;
}
- ~CopyAssign() { --alive; }
+ TEST_CONSTEXPR_CXX20 ~CopyAssign() { --*alive; }
int value;
+ int* alive;
+ int* copy_construct;
+ int* copy_assign;
+ int* move_construct;
+ int* move_assign;
};
-int CopyAssign::alive = 0;
-int CopyAssign::copy_construct = 0;
-int CopyAssign::copy_assign = 0;
-int CopyAssign::move_construct = 0;
-int CopyAssign::move_assign = 0;
-
struct CopyMaybeThrows {
- CopyMaybeThrows(const CopyMaybeThrows &);
- CopyMaybeThrows &operator=(const CopyMaybeThrows &);
+ CopyMaybeThrows(const CopyMaybeThrows&);
+ CopyMaybeThrows& operator=(const CopyMaybeThrows&);
};
struct CopyDoesThrow {
- CopyDoesThrow(const CopyDoesThrow &) noexcept(false);
- CopyDoesThrow &operator=(const CopyDoesThrow &) noexcept(false);
+ CopyDoesThrow(const CopyDoesThrow&) noexcept(false);
+ CopyDoesThrow& operator=(const CopyDoesThrow&) noexcept(false);
};
-
struct NTCopyAssign {
constexpr NTCopyAssign(int v) : value(v) {}
- NTCopyAssign(const NTCopyAssign &) = default;
- NTCopyAssign(NTCopyAssign &&) = default;
- NTCopyAssign &operator=(const NTCopyAssign &that) {
+ NTCopyAssign(const NTCopyAssign&) = default;
+ NTCopyAssign(NTCopyAssign&&) = default;
+ NTCopyAssign& operator=(const NTCopyAssign& that) {
value = that.value;
return *this;
};
- NTCopyAssign &operator=(NTCopyAssign &&) = delete;
+ NTCopyAssign& operator=(NTCopyAssign&&) = delete;
int value;
};
@@ -112,10 +132,10 @@ static_assert(std::is_copy_assignable<NTCopyAssign>::value, "");
struct TCopyAssign {
constexpr TCopyAssign(int v) : value(v) {}
- TCopyAssign(const TCopyAssign &) = default;
- TCopyAssign(TCopyAssign &&) = default;
- TCopyAssign &operator=(const TCopyAssign &) = default;
- TCopyAssign &operator=(TCopyAssign &&) = delete;
+ TCopyAssign(const TCopyAssign&) = default;
+ TCopyAssign(TCopyAssign&&) = default;
+ TCopyAssign& operator=(const TCopyAssign&) = default;
+ TCopyAssign& operator=(TCopyAssign&&) = delete;
int value;
};
@@ -123,11 +143,11 @@ static_assert(std::is_trivially_copy_assignable<TCopyAssign>::value, "");
struct TCopyAssignNTMoveAssign {
constexpr TCopyAssignNTMoveAssign(int v) : value(v) {}
- TCopyAssignNTMoveAssign(const TCopyAssignNTMoveAssign &) = default;
- TCopyAssignNTMoveAssign(TCopyAssignNTMoveAssign &&) = default;
- TCopyAssignNTMoveAssign &operator=(const TCopyAssignNTMoveAssign &) = default;
- TCopyAssignNTMoveAssign &operator=(TCopyAssignNTMoveAssign &&that) {
- value = that.value;
+ TCopyAssignNTMoveAssign(const TCopyAssignNTMoveAssign&) = default;
+ TCopyAssignNTMoveAssign(TCopyAssignNTMoveAssign&&) = default;
+ TCopyAssignNTMoveAssign& operator=(const TCopyAssignNTMoveAssign&) = default;
+ TCopyAssignNTMoveAssign& operator=(TCopyAssignNTMoveAssign&& that) {
+ value = that.value;
that.value = -1;
return *this;
}
@@ -139,17 +159,20 @@ static_assert(std::is_trivially_copy_assignable_v<TCopyAssignNTMoveAssign>, "");
#ifndef TEST_HAS_NO_EXCEPTIONS
struct CopyThrows {
CopyThrows() = default;
- CopyThrows(const CopyThrows &) { throw 42; }
- CopyThrows &operator=(const CopyThrows &) { throw 42; }
+ CopyThrows(const CopyThrows&) { throw 42; }
+ CopyThrows& operator=(const CopyThrows&) { throw 42; }
};
struct CopyCannotThrow {
static int alive;
CopyCannotThrow() { ++alive; }
- CopyCannotThrow(const CopyCannotThrow &) noexcept { ++alive; }
- CopyCannotThrow(CopyCannotThrow &&) noexcept { assert(false); }
- CopyCannotThrow &operator=(const CopyCannotThrow &) noexcept = default;
- CopyCannotThrow &operator=(CopyCannotThrow &&) noexcept { assert(false); return *this; }
+ CopyCannotThrow(const CopyCannotThrow&) noexcept { ++alive; }
+ CopyCannotThrow(CopyCannotThrow&&) noexcept { assert(false); }
+ CopyCannotThrow& operator=(const CopyCannotThrow&) noexcept = default;
+ CopyCannotThrow& operator=(CopyCannotThrow&&) noexcept {
+ assert(false);
+ return *this;
+ }
};
int CopyCannotThrow::alive = 0;
@@ -157,10 +180,10 @@ int CopyCannotThrow::alive = 0;
struct MoveThrows {
static int alive;
MoveThrows() { ++alive; }
- MoveThrows(const MoveThrows &) { ++alive; }
- MoveThrows(MoveThrows &&) { throw 42; }
- MoveThrows &operator=(const MoveThrows &) { return *this; }
- MoveThrows &operator=(MoveThrows &&) { throw 42; }
+ MoveThrows(const MoveThrows&) { ++alive; }
+ MoveThrows(MoveThrows&&) { throw 42; }
+ MoveThrows& operator=(const MoveThrows&) { return *this; }
+ MoveThrows& operator=(MoveThrows&&) { throw 42; }
~MoveThrows() { --alive; }
};
@@ -169,20 +192,21 @@ int MoveThrows::alive = 0;
struct MakeEmptyT {
static int alive;
MakeEmptyT() { ++alive; }
- MakeEmptyT(const MakeEmptyT &) {
+ MakeEmptyT(const MakeEmptyT&) {
++alive;
// Don't throw from the copy constructor since variant's assignment
// operator performs a copy before committing to the assignment.
}
- MakeEmptyT(MakeEmptyT &&) { throw 42; }
- MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
- MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
+ MakeEmptyT(MakeEmptyT&&) { throw 42; }
+ MakeEmptyT& operator=(const MakeEmptyT&) { throw 42; }
+ MakeEmptyT& operator=(MakeEmptyT&&) { throw 42; }
~MakeEmptyT() { --alive; }
};
int MakeEmptyT::alive = 0;
-template <class Variant> void makeEmpty(Variant &v) {
+template <class Variant>
+void makeEmpty(Variant& v) {
Variant v2(std::in_place_type<MakeEmptyT>);
try {
v = std::move(v2);
@@ -259,7 +283,7 @@ void test_copy_assignment_empty_empty() {
makeEmpty(v1);
V v2(std::in_place_index<0>);
makeEmpty(v2);
- V &vref = (v1 = v2);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.valueless_by_exception());
assert(v1.index() == std::variant_npos);
@@ -275,7 +299,7 @@ void test_copy_assignment_non_empty_empty() {
V v1(std::in_place_index<0>, 42);
V v2(std::in_place_index<0>);
makeEmpty(v2);
- V &vref = (v1 = v2);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.valueless_by_exception());
assert(v1.index() == std::variant_npos);
@@ -285,7 +309,7 @@ void test_copy_assignment_non_empty_empty() {
V v1(std::in_place_index<2>, "hello");
V v2(std::in_place_index<0>);
makeEmpty(v2);
- V &vref = (v1 = v2);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.valueless_by_exception());
assert(v1.index() == std::variant_npos);
@@ -301,7 +325,7 @@ void test_copy_assignment_empty_non_empty() {
V v1(std::in_place_index<0>);
makeEmpty(v1);
V v2(std::in_place_index<0>, 42);
- V &vref = (v1 = v2);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.index() == 0);
assert(std::get<0>(v1) == 42);
@@ -311,7 +335,7 @@ void test_copy_assignment_empty_non_empty() {
V v1(std::in_place_index<0>);
makeEmpty(v1);
V v2(std::in_place_type<std::string>, "hello");
- V &vref = (v1 = v2);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.index() == 2);
assert(std::get<2>(v1) == "hello");
@@ -319,14 +343,18 @@ void test_copy_assignment_empty_non_empty() {
#endif // TEST_HAS_NO_EXCEPTIONS
}
-template <typename T> struct Result { std::size_t index; T value; };
+template <typename T>
+struct Result {
+ std::size_t index;
+ T value;
+};
-void test_copy_assignment_same_index() {
+TEST_CONSTEXPR_CXX20 bool test_copy_assignment_same_index() {
{
using V = std::variant<int>;
V v1(43);
V v2(42);
- V &vref = (v1 = v2);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.index() == 0);
assert(std::get<0>(v1) == 42);
@@ -335,40 +363,28 @@ void test_copy_assignment_same_index() {
using V = std::variant<int, long, unsigned>;
V v1(43l);
V v2(42l);
- V &vref = (v1 = v2);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1) == 42);
}
{
- using V = std::variant<int, CopyAssign, unsigned>;
- V v1(std::in_place_type<CopyAssign>, 43);
- V v2(std::in_place_type<CopyAssign>, 42);
- CopyAssign::reset();
- V &vref = (v1 = v2);
+ using V = std::variant<int, CopyAssign, unsigned>;
+ int alive = 0;
+ int copy_construct = 0;
+ int copy_assign = 0;
+ int move_construct = 0;
+ int move_assign = 0;
+ V v1(std::in_place_type<CopyAssign>, 43, &alive, ©_construct, ©_assign, &move_construct, &move_assign);
+ V v2(std::in_place_type<CopyAssign>, 42, &alive, ©_construct, ©_assign, &move_construct, &move_assign);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1).value == 42);
- assert(CopyAssign::copy_construct == 0);
- assert(CopyAssign::move_construct == 0);
- assert(CopyAssign::copy_assign == 1);
- }
-#ifndef TEST_HAS_NO_EXCEPTIONS
- using MET = MakeEmptyT;
- {
- using V = std::variant<int, MET, std::string>;
- V v1(std::in_place_type<MET>);
- MET &mref = std::get<1>(v1);
- V v2(std::in_place_type<MET>);
- try {
- v1 = v2;
- assert(false);
- } catch (...) {
- }
- assert(v1.index() == 1);
- assert(&std::get<1>(v1) == &mref);
+ assert(copy_construct == 0);
+ assert(move_construct == 0);
+ assert(copy_assign == 1);
}
-#endif // TEST_HAS_NO_EXCEPTIONS
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
{
@@ -427,36 +443,93 @@ void test_copy_assignment_same_index() {
static_assert(result.index == 1, "");
static_assert(result.value == 42, "");
}
+
+ return true;
}
-void test_copy_assignment_different_index() {
+TEST_CONSTEXPR_CXX20 bool test_copy_assignment_different_index() {
{
using V = std::variant<int, long, unsigned>;
V v1(43);
V v2(42l);
- V &vref = (v1 = v2);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1) == 42);
}
{
- using V = std::variant<int, CopyAssign, unsigned>;
- CopyAssign::reset();
+ using V = std::variant<int, CopyAssign, unsigned>;
+ int alive = 0;
+ int copy_construct = 0;
+ int copy_assign = 0;
+ int move_construct = 0;
+ int move_assign = 0;
V v1(std::in_place_type<unsigned>, 43u);
- V v2(std::in_place_type<CopyAssign>, 42);
- assert(CopyAssign::copy_construct == 0);
- assert(CopyAssign::move_construct == 0);
- assert(CopyAssign::alive == 1);
- V &vref = (v1 = v2);
+ V v2(std::in_place_type<CopyAssign>, 42, &alive, ©_construct, ©_assign, &move_construct, &move_assign);
+ assert(copy_construct == 0);
+ assert(move_construct == 0);
+ assert(alive == 1);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1).value == 42);
- assert(CopyAssign::alive == 2);
- assert(CopyAssign::copy_construct == 1);
- assert(CopyAssign::move_construct == 1);
- assert(CopyAssign::copy_assign == 0);
+ assert(alive == 2);
+ assert(copy_construct == 1);
+ assert(move_construct == 1);
+ assert(copy_assign == 0);
+ }
+
+ // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+ {
+ struct {
+ constexpr Result<long> operator()() const {
+ using V = std::variant<int, long, unsigned>;
+ V v(43);
+ V v2(42l);
+ v = v2;
+ return {v.index(), std::get<1>(v)};
+ }
+ } test;
+ constexpr auto result = test();
+ static_assert(result.index == 1, "");
+ static_assert(result.value == 42l, "");
+ }
+ {
+ struct {
+ constexpr Result<int> operator()() const {
+ using V = std::variant<int, TCopyAssign, unsigned>;
+ V v(std::in_place_type<unsigned>, 43u);
+ V v2(std::in_place_type<TCopyAssign>, 42);
+ v = v2;
+ return {v.index(), std::get<1>(v).value};
+ }
+ } test;
+ constexpr auto result = test();
+ static_assert(result.index == 1, "");
+ static_assert(result.value == 42, "");
}
+ return true;
+}
+
+void test_assignment_throw() {
#ifndef TEST_HAS_NO_EXCEPTIONS
+ using MET = MakeEmptyT;
+ // same index
+ {
+ using V = std::variant<int, MET, std::string>;
+ V v1(std::in_place_type<MET>);
+ MET& mref = std::get<1>(v1);
+ V v2(std::in_place_type<MET>);
+ try {
+ v1 = v2;
+ assert(false);
+ } catch (...) {
+ }
+ assert(v1.index() == 1);
+ assert(&std::get<1>(v1) == &mref);
+ }
+
+ // difference indices
{
using V = std::variant<int, CopyThrows, std::string>;
V v1(std::in_place_type<std::string>, "hello");
@@ -496,7 +569,7 @@ void test_copy_assignment_different_index() {
using V = std::variant<int, CopyThrows, std::string>;
V v1(std::in_place_type<CopyThrows>);
V v2(std::in_place_type<std::string>, "hello");
- V &vref = (v1 = v2);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.index() == 2);
assert(std::get<2>(v1) == "hello");
@@ -507,7 +580,7 @@ void test_copy_assignment_different_index() {
using V = std::variant<int, MoveThrows, std::string>;
V v1(std::in_place_type<MoveThrows>);
V v2(std::in_place_type<std::string>, "hello");
- V &vref = (v1 = v2);
+ V& vref = (v1 = v2);
assert(&vref == &v1);
assert(v1.index() == 2);
assert(std::get<2>(v1) == "hello");
@@ -515,47 +588,13 @@ void test_copy_assignment_different_index() {
assert(std::get<2>(v2) == "hello");
}
#endif // TEST_HAS_NO_EXCEPTIONS
-
- // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
- {
- struct {
- constexpr Result<long> operator()() const {
- using V = std::variant<int, long, unsigned>;
- V v(43);
- V v2(42l);
- v = v2;
- return {v.index(), std::get<1>(v)};
- }
- } test;
- constexpr auto result = test();
- static_assert(result.index == 1, "");
- static_assert(result.value == 42l, "");
- }
- {
- struct {
- constexpr Result<int> operator()() const {
- using V = std::variant<int, TCopyAssign, unsigned>;
- V v(std::in_place_type<unsigned>, 43u);
- V v2(std::in_place_type<TCopyAssign>, 42);
- v = v2;
- return {v.index(), std::get<1>(v).value};
- }
- } test;
- constexpr auto result = test();
- static_assert(result.index == 1, "");
- static_assert(result.value == 42, "");
- }
}
template <std::size_t NewIdx, class ValueType>
-constexpr bool test_constexpr_assign_imp(
- std::variant<long, void*, int>&& v, ValueType&& new_value)
-{
- const std::variant<long, void*, int> cp(
- std::forward<ValueType>(new_value));
+constexpr bool test_constexpr_assign_imp(std::variant<long, void*, int>&& v, ValueType&& new_value) {
+ const std::variant<long, void*, int> cp(std::forward<ValueType>(new_value));
v = cp;
- return v.index() == NewIdx &&
- std::get<NewIdx>(v) == std::get<NewIdx>(cp);
+ return v.index() == NewIdx && std::get<NewIdx>(v) == std::get<NewIdx>(cp);
}
void test_constexpr_copy_assignment() {
@@ -573,11 +612,17 @@ int main(int, char**) {
test_copy_assignment_empty_empty();
test_copy_assignment_non_empty_empty();
test_copy_assignment_empty_non_empty();
+ test_assignment_throw();
test_copy_assignment_same_index();
test_copy_assignment_different_index();
test_copy_assignment_sfinae();
test_copy_assignment_not_noexcept();
test_constexpr_copy_assignment();
+#if TEST_STD_VER >= 20
+ static_assert(test_copy_assignment_same_index());
+ static_assert(test_copy_assignment_different_index());
+#endif
+
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
index 84094347aed3a7..d743c0130a22f3 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
@@ -24,71 +24,70 @@
#include "variant_test_helpers.h"
struct NoCopy {
- NoCopy(const NoCopy &) = delete;
- NoCopy &operator=(const NoCopy &) = default;
+ NoCopy(const NoCopy&) = delete;
+ NoCopy& operator=(const NoCopy&) = default;
};
struct CopyOnly {
- CopyOnly(const CopyOnly &) = default;
- CopyOnly(CopyOnly &&) = delete;
- CopyOnly &operator=(const CopyOnly &) = default;
- CopyOnly &operator=(CopyOnly &&) = delete;
+ CopyOnly(const CopyOnly&) = default;
+ CopyOnly(CopyOnly&&) = delete;
+ CopyOnly& operator=(const CopyOnly&) = default;
+ CopyOnly& operator=(CopyOnly&&) = delete;
};
struct MoveOnly {
- MoveOnly(const MoveOnly &) = delete;
- MoveOnly(MoveOnly &&) = default;
- MoveOnly &operator=(const MoveOnly &) = delete;
- MoveOnly &operator=(MoveOnly &&) = default;
+ MoveOnly(const MoveOnly&) = delete;
+ MoveOnly(MoveOnly&&) = default;
+ MoveOnly& operator=(const MoveOnly&) = delete;
+ MoveOnly& operator=(MoveOnly&&) = default;
};
struct MoveOnlyNT {
- MoveOnlyNT(const MoveOnlyNT &) = delete;
- MoveOnlyNT(MoveOnlyNT &&) {}
- MoveOnlyNT &operator=(const MoveOnlyNT &) = delete;
- MoveOnlyNT &operator=(MoveOnlyNT &&) = default;
+ MoveOnlyNT(const MoveOnlyNT&) = delete;
+ MoveOnlyNT(MoveOnlyNT&&) {}
+ MoveOnlyNT& operator=(const MoveOnlyNT&) = delete;
+ MoveOnlyNT& operator=(MoveOnlyNT&&) = default;
};
struct MoveOnlyOddNothrow {
- MoveOnlyOddNothrow(MoveOnlyOddNothrow &&) noexcept(false) {}
- MoveOnlyOddNothrow(const MoveOnlyOddNothrow &) = delete;
- MoveOnlyOddNothrow &operator=(MoveOnlyOddNothrow &&) noexcept = default;
- MoveOnlyOddNothrow &operator=(const MoveOnlyOddNothrow &) = delete;
+ MoveOnlyOddNothrow(MoveOnlyOddNothrow&&) noexcept(false) {}
+ MoveOnlyOddNothrow(const MoveOnlyOddNothrow&) = delete;
+ MoveOnlyOddNothrow& operator=(MoveOnlyOddNothrow&&) noexcept = default;
+ MoveOnlyOddNothrow& operator=(const MoveOnlyOddNothrow&) = delete;
};
struct MoveAssignOnly {
- MoveAssignOnly(MoveAssignOnly &&) = delete;
- MoveAssignOnly &operator=(MoveAssignOnly &&) = default;
+ MoveAssignOnly(MoveAssignOnly&&) = delete;
+ MoveAssignOnly& operator=(MoveAssignOnly&&) = default;
};
struct MoveAssign {
- static int move_construct;
- static int move_assign;
- static void reset() { move_construct = move_assign = 0; }
- MoveAssign(int v) : value(v) {}
- MoveAssign(MoveAssign &&o) : value(o.value) {
- ++move_construct;
+ constexpr MoveAssign(int v, int* move_ctor, int* move_assi)
+ : value(v), move_construct(move_ctor), move_assign(move_assi) {}
+ constexpr MoveAssign(MoveAssign&& o) : value(o.value), move_construct(o.move_construct), move_assign(o.move_assign) {
+ ++*move_construct;
o.value = -1;
}
- MoveAssign &operator=(MoveAssign &&o) {
- value = o.value;
- ++move_assign;
+ constexpr MoveAssign& operator=(MoveAssign&& o) {
+ value = o.value;
+ move_construct = o.move_construct;
+ move_assign = o.move_assign;
+ ++*move_assign;
o.value = -1;
return *this;
}
int value;
+ int* move_construct;
+ int* move_assign;
};
-int MoveAssign::move_construct = 0;
-int MoveAssign::move_assign = 0;
-
struct NTMoveAssign {
constexpr NTMoveAssign(int v) : value(v) {}
- NTMoveAssign(const NTMoveAssign &) = default;
- NTMoveAssign(NTMoveAssign &&) = default;
- NTMoveAssign &operator=(const NTMoveAssign &that) = default;
- NTMoveAssign &operator=(NTMoveAssign &&that) {
- value = that.value;
+ NTMoveAssign(const NTMoveAssign&) = default;
+ NTMoveAssign(NTMoveAssign&&) = default;
+ NTMoveAssign& operator=(const NTMoveAssign& that) = default;
+ NTMoveAssign& operator=(NTMoveAssign&& that) {
+ value = that.value;
that.value = -1;
return *this;
};
@@ -100,10 +99,10 @@ static_assert(std::is_move_assignable<NTMoveAssign>::value, "");
struct TMoveAssign {
constexpr TMoveAssign(int v) : value(v) {}
- TMoveAssign(const TMoveAssign &) = delete;
- TMoveAssign(TMoveAssign &&) = default;
- TMoveAssign &operator=(const TMoveAssign &) = delete;
- TMoveAssign &operator=(TMoveAssign &&) = default;
+ TMoveAssign(const TMoveAssign&) = delete;
+ TMoveAssign(TMoveAssign&&) = default;
+ TMoveAssign& operator=(const TMoveAssign&) = delete;
+ TMoveAssign& operator=(TMoveAssign&&) = default;
int value;
};
@@ -111,13 +110,13 @@ static_assert(std::is_trivially_move_assignable<TMoveAssign>::value, "");
struct TMoveAssignNTCopyAssign {
constexpr TMoveAssignNTCopyAssign(int v) : value(v) {}
- TMoveAssignNTCopyAssign(const TMoveAssignNTCopyAssign &) = default;
- TMoveAssignNTCopyAssign(TMoveAssignNTCopyAssign &&) = default;
- TMoveAssignNTCopyAssign &operator=(const TMoveAssignNTCopyAssign &that) {
+ TMoveAssignNTCopyAssign(const TMoveAssignNTCopyAssign&) = default;
+ TMoveAssignNTCopyAssign(TMoveAssignNTCopyAssign&&) = default;
+ TMoveAssignNTCopyAssign& operator=(const TMoveAssignNTCopyAssign& that) {
value = that.value;
return *this;
}
- TMoveAssignNTCopyAssign &operator=(TMoveAssignNTCopyAssign &&) = default;
+ TMoveAssignNTCopyAssign& operator=(TMoveAssignNTCopyAssign&&) = default;
int value;
};
@@ -127,15 +126,12 @@ struct TrivialCopyNontrivialMove {
TrivialCopyNontrivialMove(TrivialCopyNontrivialMove const&) = default;
TrivialCopyNontrivialMove(TrivialCopyNontrivialMove&&) noexcept {}
TrivialCopyNontrivialMove& operator=(TrivialCopyNontrivialMove const&) = default;
- TrivialCopyNontrivialMove& operator=(TrivialCopyNontrivialMove&&) noexcept {
- return *this;
- }
+ TrivialCopyNontrivialMove& operator=(TrivialCopyNontrivialMove&&) noexcept { return *this; }
};
static_assert(std::is_trivially_copy_assignable_v<TrivialCopyNontrivialMove>, "");
static_assert(!std::is_trivially_move_assignable_v<TrivialCopyNontrivialMove>, "");
-
void test_move_assignment_noexcept() {
{
using V = std::variant<int>;
@@ -228,7 +224,7 @@ void test_move_assignment_empty_empty() {
makeEmpty(v1);
V v2(std::in_place_index<0>);
makeEmpty(v2);
- V &vref = (v1 = std::move(v2));
+ V& vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.valueless_by_exception());
assert(v1.index() == std::variant_npos);
@@ -244,7 +240,7 @@ void test_move_assignment_non_empty_empty() {
V v1(std::in_place_index<0>, 42);
V v2(std::in_place_index<0>);
makeEmpty(v2);
- V &vref = (v1 = std::move(v2));
+ V& vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.valueless_by_exception());
assert(v1.index() == std::variant_npos);
@@ -254,7 +250,7 @@ void test_move_assignment_non_empty_empty() {
V v1(std::in_place_index<2>, "hello");
V v2(std::in_place_index<0>);
makeEmpty(v2);
- V &vref = (v1 = std::move(v2));
+ V& vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.valueless_by_exception());
assert(v1.index() == std::variant_npos);
@@ -270,7 +266,7 @@ void test_move_assignment_empty_non_empty() {
V v1(std::in_place_index<0>);
makeEmpty(v1);
V v2(std::in_place_index<0>, 42);
- V &vref = (v1 = std::move(v2));
+ V& vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 0);
assert(std::get<0>(v1) == 42);
@@ -280,7 +276,7 @@ void test_move_assignment_empty_non_empty() {
V v1(std::in_place_index<0>);
makeEmpty(v1);
V v2(std::in_place_type<std::string>, "hello");
- V &vref = (v1 = std::move(v2));
+ V& vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 2);
assert(std::get<2>(v1) == "hello");
@@ -288,14 +284,18 @@ void test_move_assignment_empty_non_empty() {
#endif // TEST_HAS_NO_EXCEPTIONS
}
-template <typename T> struct Result { std::size_t index; T value; };
+template <typename T>
+struct Result {
+ std::size_t index;
+ T value;
+};
-void test_move_assignment_same_index() {
+TEST_CONSTEXPR_CXX20 bool test_move_assignment_same_index() {
{
using V = std::variant<int>;
V v1(43);
V v2(42);
- V &vref = (v1 = std::move(v2));
+ V& vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 0);
assert(std::get<0>(v1) == 42);
@@ -304,39 +304,24 @@ void test_move_assignment_same_index() {
using V = std::variant<int, long, unsigned>;
V v1(43l);
V v2(42l);
- V &vref = (v1 = std::move(v2));
+ V& vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1) == 42);
}
{
- using V = std::variant<int, MoveAssign, unsigned>;
- V v1(std::in_place_type<MoveAssign>, 43);
- V v2(std::in_place_type<MoveAssign>, 42);
- MoveAssign::reset();
- V &vref = (v1 = std::move(v2));
+ using V = std::variant<int, MoveAssign, unsigned>;
+ int move_construct = 0;
+ int move_assign = 0;
+ V v1(std::in_place_type<MoveAssign>, 43, &move_construct, &move_assign);
+ V v2(std::in_place_type<MoveAssign>, 42, &move_construct, &move_assign);
+ V& vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1).value == 42);
- assert(MoveAssign::move_construct == 0);
- assert(MoveAssign::move_assign == 1);
+ assert(move_construct == 0);
+ assert(move_assign == 1);
}
-#ifndef TEST_HAS_NO_EXCEPTIONS
- using MET = MakeEmptyT;
- {
- using V = std::variant<int, MET, std::string>;
- V v1(std::in_place_type<MET>);
- MET &mref = std::get<1>(v1);
- V v2(std::in_place_type<MET>);
- try {
- v1 = std::move(v2);
- assert(false);
- } catch (...) {
- }
- assert(v1.index() == 1);
- assert(&std::get<1>(v1) == &mref);
- }
-#endif // TEST_HAS_NO_EXCEPTIONS
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
{
@@ -381,54 +366,33 @@ void test_move_assignment_same_index() {
static_assert(result.index == 1, "");
static_assert(result.value == 42, "");
}
+
+ return true;
}
-void test_move_assignment_different_index() {
+TEST_CONSTEXPR_CXX20 bool test_move_assignment_different_index() {
{
using V = std::variant<int, long, unsigned>;
V v1(43);
V v2(42l);
- V &vref = (v1 = std::move(v2));
+ V& vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1) == 42);
}
{
- using V = std::variant<int, MoveAssign, unsigned>;
+ using V = std::variant<int, MoveAssign, unsigned>;
+ int move_construct = 0;
+ int move_assign = 0;
V v1(std::in_place_type<unsigned>, 43u);
- V v2(std::in_place_type<MoveAssign>, 42);
- MoveAssign::reset();
- V &vref = (v1 = std::move(v2));
+ V v2(std::in_place_type<MoveAssign>, 42, &move_construct, &move_assign);
+ V& vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1).value == 42);
- assert(MoveAssign::move_construct == 1);
- assert(MoveAssign::move_assign == 0);
- }
-#ifndef TEST_HAS_NO_EXCEPTIONS
- using MET = MakeEmptyT;
- {
- using V = std::variant<int, MET, std::string>;
- V v1(std::in_place_type<int>);
- V v2(std::in_place_type<MET>);
- try {
- v1 = std::move(v2);
- assert(false);
- } catch (...) {
- }
- assert(v1.valueless_by_exception());
- assert(v1.index() == std::variant_npos);
- }
- {
- using V = std::variant<int, MET, std::string>;
- V v1(std::in_place_type<MET>);
- V v2(std::in_place_type<std::string>, "hello");
- V &vref = (v1 = std::move(v2));
- assert(&vref == &v1);
- assert(v1.index() == 2);
- assert(std::get<2>(v1) == "hello");
+ assert(move_construct == 1);
+ assert(move_assign == 0);
}
-#endif // TEST_HAS_NO_EXCEPTIONS
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
{
@@ -459,18 +423,59 @@ void test_move_assignment_different_index() {
static_assert(result.index == 1, "");
static_assert(result.value == 42, "");
}
+
+ return true;
+}
+
+void test_assignment_throw() {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ using MET = MakeEmptyT;
+ // same index
+ {
+ using V = std::variant<int, MET, std::string>;
+ V v1(std::in_place_type<MET>);
+ MET& mref = std::get<1>(v1);
+ V v2(std::in_place_type<MET>);
+ try {
+ v1 = std::move(v2);
+ assert(false);
+ } catch (...) {
+ }
+ assert(v1.index() == 1);
+ assert(&std::get<1>(v1) == &mref);
+ }
+
+ // different indices
+ {
+ using V = std::variant<int, MET, std::string>;
+ V v1(std::in_place_type<int>);
+ V v2(std::in_place_type<MET>);
+ try {
+ v1 = std::move(v2);
+ assert(false);
+ } catch (...) {
+ }
+ assert(v1.valueless_by_exception());
+ assert(v1.index() == std::variant_npos);
+ }
+ {
+ using V = std::variant<int, MET, std::string>;
+ V v1(std::in_place_type<MET>);
+ V v2(std::in_place_type<std::string>, "hello");
+ V& vref = (v1 = std::move(v2));
+ assert(&vref == &v1);
+ assert(v1.index() == 2);
+ assert(std::get<2>(v1) == "hello");
+ }
+#endif // TEST_HAS_NO_EXCEPTIONS
}
template <std::size_t NewIdx, class ValueType>
-constexpr bool test_constexpr_assign_imp(
- std::variant<long, void*, int>&& v, ValueType&& new_value)
-{
- std::variant<long, void*, int> v2(
- std::forward<ValueType>(new_value));
+constexpr bool test_constexpr_assign_imp(std::variant<long, void*, int>&& v, ValueType&& new_value) {
+ std::variant<long, void*, int> v2(std::forward<ValueType>(new_value));
const auto cp = v2;
- v = std::move(v2);
- return v.index() == NewIdx &&
- std::get<NewIdx>(v) == std::get<NewIdx>(cp);
+ v = std::move(v2);
+ return v.index() == NewIdx && std::get<NewIdx>(v) == std::get<NewIdx>(cp);
}
void test_constexpr_move_assignment() {
@@ -488,11 +493,16 @@ int main(int, char**) {
test_move_assignment_empty_empty();
test_move_assignment_non_empty_empty();
test_move_assignment_empty_non_empty();
+ test_assignment_throw();
test_move_assignment_same_index();
test_move_assignment_different_index();
test_move_assignment_sfinae();
test_move_assignment_noexcept();
test_constexpr_move_assignment();
+#if TEST_STD_VER >= 20
+ static_assert(test_move_assignment_same_index());
+ static_assert(test_move_assignment_different_index());
+#endif
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
index 34626a4e25f355..38e47e7bc9db18 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -22,8 +22,8 @@
#include "test_workarounds.h"
struct NonT {
- NonT(int v) : value(v) {}
- NonT(const NonT& o) : value(o.value) {}
+ constexpr NonT(int v) : value(v) {}
+ constexpr NonT(const NonT& o) : value(o.value) {}
int value;
};
static_assert(!std::is_trivially_copy_constructible<NonT>::value, "");
@@ -137,7 +137,7 @@ void test_copy_ctor_sfinae() {
}
}
-void test_copy_ctor_basic() {
+TEST_CONSTEXPR_CXX20 bool test_copy_ctor_basic() {
{
std::variant<int> v(std::in_place_index<0>, 42);
std::variant<int> v2 = v;
@@ -208,6 +208,7 @@ void test_copy_ctor_basic() {
static_assert(v2.index() == 1, "");
static_assert(std::get<1>(v2).value == 42, "");
}
+ return true;
}
void test_copy_ctor_valueless_by_exception() {
@@ -274,5 +275,9 @@ int main(int, char**) {
test_copy_ctor_valueless_by_exception();
test_copy_ctor_sfinae();
test_constexpr_copy_ctor();
+
+#if TEST_STD_VER >= 20
+ static_assert(test_copy_ctor_basic());
+#endif
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
index 4bb6cf24b0f0e2..0c931be453741f 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
@@ -32,16 +32,16 @@ struct NoCopy {
struct MoveOnly {
int value;
- MoveOnly(int v) : value(v) {}
+ constexpr MoveOnly(int v) : value(v) {}
MoveOnly(const MoveOnly&) = delete;
MoveOnly(MoveOnly&&) = default;
};
struct MoveOnlyNT {
int value;
- MoveOnlyNT(int v) : value(v) {}
+ constexpr MoveOnlyNT(int v) : value(v) {}
MoveOnlyNT(const MoveOnlyNT&) = delete;
- MoveOnlyNT(MoveOnlyNT&& other) : value(other.value) { other.value = -1; }
+ constexpr MoveOnlyNT(MoveOnlyNT&& other) : value(other.value) { other.value = -1; }
};
struct NTMove {
@@ -164,7 +164,7 @@ struct Result {
T value;
};
-void test_move_ctor_basic() {
+TEST_CONSTEXPR_CXX20 bool test_move_ctor_basic() {
{
std::variant<int> v(std::in_place_index<0>, 42);
std::variant<int> v2 = std::move(v);
@@ -281,6 +281,7 @@ void test_move_ctor_basic() {
static_assert(result.index == 1, "");
static_assert(result.value.value == 42, "");
}
+ return true;
}
void test_move_ctor_valueless_by_exception() {
@@ -350,5 +351,9 @@ int main(int, char**) {
test_move_ctor_sfinae();
test_constexpr_move_ctor();
+#if TEST_STD_VER >= 20
+ static_assert(test_move_ctor_basic());
+#endif
+
return 0;
}
>From 29d886b4e1794f921b93907ff87ccbf7821695b2 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Fri, 1 Mar 2024 07:37:19 +0000
Subject: [PATCH 3/9] CI
---
libcxx/include/variant | 69 +++++++++++++++++++++---------------------
1 file changed, 35 insertions(+), 34 deletions(-)
diff --git a/libcxx/include/variant b/libcxx/include/variant
index dd0aa1fdeacb5c..859798f9dccba4 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -48,7 +48,8 @@ namespace std {
constexpr variant& operator=(const variant&);
constexpr variant& operator=(variant&&) noexcept(see below);
- template <class T> variant& operator=(T&&) noexcept(see below);
+ template <class T>
+ constexpr variant& operator=(T&&) noexcept(see below); // constexpr since c++20
// 20.7.2.4, modifiers
template <class T, class... Args>
@@ -689,7 +690,7 @@ union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
__union(const __union&) = default; \
__union(__union&&) = default; \
\
- destructor \
+ _LIBCPP_HIDE_FROM_ABI destructor \
\
__union& \
operator=(const __union&) = default; \
@@ -759,10 +760,10 @@ class _LIBCPP_TEMPLATE_VIS __dtor;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- __dtor(const __dtor&) = default; \
- __dtor(__dtor&&) = default; \
- destructor __dtor& operator=(const __dtor&) = default; \
- __dtor& operator=(__dtor&&) = default; \
+ __dtor(const __dtor&) = default; \
+ __dtor(__dtor&&) = default; \
+ _LIBCPP_HIDE_FROM_ABI destructor __dtor& operator=(const __dtor&) = default; \
+ __dtor& operator=(__dtor&&) = default; \
\
protected: \
inline _LIBCPP_HIDE_FROM_ABI destroy \
@@ -802,7 +803,7 @@ public:
protected:
template <class _Rhs>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI static void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) {
+ _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX20 void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) {
__lhs.__destroy();
if (!__rhs.valueless_by_exception()) {
// We cannot directly construct at the target __alt because its direct enclosing union is not activated yet.
@@ -836,10 +837,10 @@ class _LIBCPP_TEMPLATE_VIS __move_constructor;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- __move_constructor(const __move_constructor&) = default; \
- move_constructor ~__move_constructor() = default; \
- __move_constructor& operator=(const __move_constructor&) = default; \
- __move_constructor& operator=(__move_constructor&&) = default; \
+ __move_constructor(const __move_constructor&) = default; \
+ _LIBCPP_HIDE_FROM_ABI move_constructor ~__move_constructor() = default; \
+ __move_constructor& operator=(const __move_constructor&) = default; \
+ __move_constructor& operator=(__move_constructor&&) = default; \
}
_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
@@ -870,10 +871,10 @@ class _LIBCPP_TEMPLATE_VIS __copy_constructor;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- copy_constructor __copy_constructor(__copy_constructor&&) = default; \
- ~__copy_constructor() = default; \
- __copy_constructor& operator=(const __copy_constructor&) = default; \
- __copy_constructor& operator=(__copy_constructor&&) = default; \
+ _LIBCPP_HIDE_FROM_ABI copy_constructor __copy_constructor(__copy_constructor&&) = default; \
+ ~__copy_constructor() = default; \
+ __copy_constructor& operator=(const __copy_constructor&) = default; \
+ __copy_constructor& operator=(__copy_constructor&&) = default; \
}
_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
@@ -898,7 +899,7 @@ public:
using __base_type::operator=;
template <size_t _Ip, class... _Args>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI auto& __emplace(_Args&&... __args) {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 auto& __emplace(_Args&&... __args) {
this->__destroy();
std::__construct_at(std::addressof(this->__data), in_place_index<_Ip>, std::forward<_Args>(__args)...);
this->__index = _Ip;
@@ -907,15 +908,15 @@ public:
protected:
template <size_t _Ip, class _Tp, class _Arg>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
if (this->index() == _Ip) {
__a.__value = std::forward<_Arg>(__arg);
} else {
struct {
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void operator()(true_type) const {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void operator()(true_type) const {
__this->__emplace<_Ip>(std::forward<_Arg>(__arg));
}
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void operator()(false_type) const {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void operator()(false_type) const {
__this->__emplace<_Ip>(_Tp(std::forward<_Arg>(__arg)));
}
__assignment* __this;
@@ -926,7 +927,7 @@ protected:
}
template <class _That>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __generic_assign(_That&& __that) {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __generic_assign(_That&& __that) {
if (this->valueless_by_exception() && __that.valueless_by_exception()) {
// do nothing.
} else if (__that.valueless_by_exception()) {
@@ -960,7 +961,7 @@ class _LIBCPP_TEMPLATE_VIS __move_assignment;
__move_assignment(__move_assignment&&) = default; \
~__move_assignment() = default; \
__move_assignment& operator=(const __move_assignment&) = default; \
- move_assignment \
+ _LIBCPP_HIDE_FROM_ABI move_assignment \
}
_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
@@ -994,10 +995,10 @@ class _LIBCPP_TEMPLATE_VIS __copy_assignment;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- __copy_assignment(const __copy_assignment&) = default; \
- __copy_assignment(__copy_assignment&&) = default; \
- ~__copy_assignment() = default; \
- copy_assignment __copy_assignment& operator=(__copy_assignment&&) = default; \
+ __copy_assignment(const __copy_assignment&) = default; \
+ __copy_assignment(__copy_assignment&&) = default; \
+ ~__copy_assignment() = default; \
+ _LIBCPP_HIDE_FROM_ABI copy_assignment __copy_assignment& operator=(__copy_assignment&&) = default; \
}
_LIBCPP_VARIANT_COPY_ASSIGNMENT(
@@ -1028,11 +1029,11 @@ public:
_LIBCPP_HIDE_FROM_ABI __impl& operator=(__impl&&) = default;
template <size_t _Ip, class _Arg>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __assign(_Arg&& __arg) {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign(_Arg&& __arg) {
this->__assign_alt(__access::__base::__get_alt<_Ip>(*this), std::forward<_Arg>(__arg));
}
- _LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void __swap(__impl& __that) {
+ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __swap(__impl& __that) {
if (this->valueless_by_exception() && __that.valueless_by_exception()) {
// do nothing.
} else if (this->index() == __that.index()) {
@@ -1241,7 +1242,7 @@ public:
_Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>)
: __impl_(in_place_index<_Ip>, __il, std::forward<_Args>(__args)...) {}
- _LIBCPP_HIDE_FROM_ABI constexpr ~variant() = default;
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~variant() = default;
_LIBCPP_HIDE_FROM_ABI constexpr variant& operator=(const variant&) = default;
_LIBCPP_HIDE_FROM_ABI constexpr variant& operator=(variant&&) = default;
@@ -1251,7 +1252,7 @@ public:
class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>, int> = 0>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI variant&
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 variant&
operator=(_Arg&& __arg) noexcept(is_nothrow_assignable_v<_Tp&, _Arg> && is_nothrow_constructible_v<_Tp, _Arg>) {
__impl_.template __assign<_Ip>(std::forward<_Arg>(__arg));
return *this;
@@ -1262,7 +1263,7 @@ public:
enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _Tp& emplace(_Args&&... __args) {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args) {
return __impl_.template __emplace<_Ip>(std::forward<_Args>(__args)...);
}
@@ -1272,7 +1273,7 @@ public:
enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, int> = 0>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
return __impl_.template __emplace<_Ip>(__il, std::forward<_Args>(__args)...);
}
@@ -1280,7 +1281,7 @@ public:
class... _Args,
size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _Tp& emplace(_Args&&... __args) {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args) {
return __impl_.template __emplace<_Ip>(std::forward<_Args>(__args)...);
}
@@ -1289,7 +1290,7 @@ public:
class... _Args,
size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, int> = 0>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
return __impl_.template __emplace<_Ip>(__il, std::forward<_Args>(__args)...);
}
@@ -1303,7 +1304,7 @@ public:
enable_if_t< __all<(__dependent_type<is_move_constructible<_Types>, _Dummy>::value &&
__dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value,
int> = 0>
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void swap(variant& __that) noexcept(
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(variant& __that) noexcept(
__all<(is_nothrow_move_constructible_v<_Types> && is_nothrow_swappable_v<_Types>)...>::value) {
__impl_.__swap(__that.__impl_);
}
>From 7389da07da20e444f4f1d5915d5d61d68b568121 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Fri, 1 Mar 2024 13:19:57 +0000
Subject: [PATCH 4/9] swap
---
libcxx/include/variant | 2 +-
.../variant.assign/copy.pass.cpp | 53 +-
.../variant.assign/move.pass.cpp | 55 +-
.../variant.ctor/copy.pass.cpp | 77 +--
.../variant.ctor/move.pass.cpp | 73 +--
.../variant.swap/swap.pass.cpp | 500 +++++++++---------
6 files changed, 427 insertions(+), 333 deletions(-)
diff --git a/libcxx/include/variant b/libcxx/include/variant
index 859798f9dccba4..2a583f6dbd2006 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -1587,7 +1587,7 @@ visit(_Visitor&& __visitor, _Vs&&... __vs) {
# endif
template <class... _Types>
-_LIBCPP_HIDE_FROM_ABI auto
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 auto
swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs) noexcept(noexcept(__lhs.swap(__rhs)))
-> decltype(__lhs.swap(__rhs)) {
return __lhs.swap(__rhs);
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
index 5a5d077e8c4ba0..095cfca3b67870 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
@@ -590,22 +590,52 @@ void test_assignment_throw() {
#endif // TEST_HAS_NO_EXCEPTIONS
}
-template <std::size_t NewIdx, class ValueType>
-constexpr bool test_constexpr_assign_imp(std::variant<long, void*, int>&& v, ValueType&& new_value) {
- const std::variant<long, void*, int> cp(std::forward<ValueType>(new_value));
+template <std::size_t NewIdx, class T, class ValueType>
+constexpr void test_constexpr_assign_imp(T&& v, ValueType&& new_value) {
+ using Variant = std::decay_t<T>;
+ const Variant cp(std::forward<ValueType>(new_value));
v = cp;
- return v.index() == NewIdx && std::get<NewIdx>(v) == std::get<NewIdx>(cp);
+ assert(v.index() == NewIdx);
+ assert(std::get<NewIdx>(v) == std::get<NewIdx>(cp));
}
-void test_constexpr_copy_assignment() {
+constexpr bool test_constexpr_copy_assignment_trivial() {
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
using V = std::variant<long, void*, int>;
static_assert(std::is_trivially_copyable<V>::value, "");
static_assert(std::is_trivially_copy_assignable<V>::value, "");
- static_assert(test_constexpr_assign_imp<0>(V(42l), 101l), "");
- static_assert(test_constexpr_assign_imp<0>(V(nullptr), 101l), "");
- static_assert(test_constexpr_assign_imp<1>(V(42l), nullptr), "");
- static_assert(test_constexpr_assign_imp<2>(V(42l), 101), "");
+ test_constexpr_assign_imp<0>(V(42l), 101l);
+ test_constexpr_assign_imp<0>(V(nullptr), 101l);
+ test_constexpr_assign_imp<1>(V(42l), nullptr);
+ test_constexpr_assign_imp<2>(V(42l), 101);
+
+ return true;
+}
+
+struct NonTrivialCopyAssign {
+ int i = 0;
+ constexpr NonTrivialCopyAssign(int ii) : i(ii) {}
+ constexpr NonTrivialCopyAssign(const NonTrivialCopyAssign& other) : i(other.i) {}
+ constexpr NonTrivialCopyAssign& operator=(const NonTrivialCopyAssign& o) {
+ i = o.i;
+ return *this;
+ }
+ TEST_CONSTEXPR_CXX20 ~NonTrivialCopyAssign() = default;
+ friend constexpr bool operator==(const NonTrivialCopyAssign& x, const NonTrivialCopyAssign& y) { return x.i == y.i; }
+};
+
+constexpr bool test_constexpr_copy_assignment_non_trivial() {
+ // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+ using V = std::variant<long, void*, NonTrivialCopyAssign>;
+ static_assert(!std::is_trivially_copyable<V>::value, "");
+ static_assert(!std::is_trivially_copy_assignable<V>::value, "");
+ test_constexpr_assign_imp<0>(V(42l), 101l);
+ test_constexpr_assign_imp<0>(V(nullptr), 101l);
+ test_constexpr_assign_imp<1>(V(42l), nullptr);
+ test_constexpr_assign_imp<2>(V(42l), NonTrivialCopyAssign(5));
+ test_constexpr_assign_imp<2>(V(NonTrivialCopyAssign(3)), NonTrivialCopyAssign(5));
+
+ return true;
}
int main(int, char**) {
@@ -617,11 +647,14 @@ int main(int, char**) {
test_copy_assignment_different_index();
test_copy_assignment_sfinae();
test_copy_assignment_not_noexcept();
- test_constexpr_copy_assignment();
+ test_constexpr_copy_assignment_trivial();
+ test_constexpr_copy_assignment_non_trivial();
+ static_assert(test_constexpr_copy_assignment_trivial());
#if TEST_STD_VER >= 20
static_assert(test_copy_assignment_same_index());
static_assert(test_copy_assignment_different_index());
+ static_assert(test_constexpr_copy_assignment_non_trivial());
#endif
return 0;
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
index d743c0130a22f3..406f5695a982ec 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
@@ -470,23 +470,54 @@ void test_assignment_throw() {
#endif // TEST_HAS_NO_EXCEPTIONS
}
-template <std::size_t NewIdx, class ValueType>
-constexpr bool test_constexpr_assign_imp(std::variant<long, void*, int>&& v, ValueType&& new_value) {
- std::variant<long, void*, int> v2(std::forward<ValueType>(new_value));
+template <std::size_t NewIdx, class T, class ValueType>
+constexpr void test_constexpr_assign_imp(T&& v, ValueType&& new_value) {
+ using Variant = std::decay_t<T>;
+ Variant v2(std::forward<ValueType>(new_value));
const auto cp = v2;
v = std::move(v2);
- return v.index() == NewIdx && std::get<NewIdx>(v) == std::get<NewIdx>(cp);
+ assert(v.index() == NewIdx);
+ assert(std::get<NewIdx>(v) == std::get<NewIdx>(cp));
}
-void test_constexpr_move_assignment() {
+constexpr bool test_constexpr_move_assignment_trivial() {
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
using V = std::variant<long, void*, int>;
static_assert(std::is_trivially_copyable<V>::value, "");
static_assert(std::is_trivially_move_assignable<V>::value, "");
- static_assert(test_constexpr_assign_imp<0>(V(42l), 101l), "");
- static_assert(test_constexpr_assign_imp<0>(V(nullptr), 101l), "");
- static_assert(test_constexpr_assign_imp<1>(V(42l), nullptr), "");
- static_assert(test_constexpr_assign_imp<2>(V(42l), 101), "");
+ test_constexpr_assign_imp<0>(V(42l), 101l);
+ test_constexpr_assign_imp<0>(V(nullptr), 101l);
+ test_constexpr_assign_imp<1>(V(42l), nullptr);
+ test_constexpr_assign_imp<2>(V(42l), 101);
+
+ return true;
+}
+
+struct NonTrivialMoveAssign {
+ int i = 0;
+ constexpr NonTrivialMoveAssign(int ii) : i(ii) {}
+ constexpr NonTrivialMoveAssign(const NonTrivialMoveAssign& other) = default;
+ constexpr NonTrivialMoveAssign(NonTrivialMoveAssign&& other) : i(other.i) {}
+ constexpr NonTrivialMoveAssign& operator=(const NonTrivialMoveAssign&) = default;
+ constexpr NonTrivialMoveAssign& operator=(NonTrivialMoveAssign&& o) {
+ i = o.i;
+ return *this;
+ }
+ TEST_CONSTEXPR_CXX20 ~NonTrivialMoveAssign() = default;
+ friend constexpr bool operator==(const NonTrivialMoveAssign& x, const NonTrivialMoveAssign& y) { return x.i == y.i; }
+};
+
+TEST_CONSTEXPR_CXX20 bool test_constexpr_move_assignment_non_trivial() {
+ using V = std::variant<long, void*, NonTrivialMoveAssign>;
+ static_assert(!std::is_trivially_copyable<V>::value);
+ static_assert(!std::is_trivially_move_assignable<V>::value);
+ test_constexpr_assign_imp<0>(V(42l), 101l);
+ test_constexpr_assign_imp<0>(V(nullptr), 101l);
+ test_constexpr_assign_imp<1>(V(42l), nullptr);
+ test_constexpr_assign_imp<2>(V(42l), NonTrivialMoveAssign(5));
+ test_constexpr_assign_imp<2>(V(NonTrivialMoveAssign(3)), NonTrivialMoveAssign(5));
+
+ return true;
}
int main(int, char**) {
@@ -498,11 +529,15 @@ int main(int, char**) {
test_move_assignment_different_index();
test_move_assignment_sfinae();
test_move_assignment_noexcept();
- test_constexpr_move_assignment();
+ test_constexpr_move_assignment_trivial();
+ test_constexpr_move_assignment_non_trivial();
+
+ static_assert(test_constexpr_move_assignment_trivial());
#if TEST_STD_VER >= 20
static_assert(test_move_assignment_same_index());
static_assert(test_move_assignment_different_index());
+ static_assert(test_constexpr_move_assignment_non_trivial());
#endif
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
index 38e47e7bc9db18..74505ddbcace44 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -223,61 +223,64 @@ void test_copy_ctor_valueless_by_exception() {
}
template <std::size_t Idx, class T>
-constexpr bool test_constexpr_copy_ctor_imp(const T& v) {
+constexpr void test_constexpr_copy_ctor_imp(const T& v) {
auto v2 = v;
- return v2.index() == v.index() && v2.index() == Idx && std::get<Idx>(v2) == std::get<Idx>(v);
+ assert(v2.index() == v.index());
+ assert(v2.index() == Idx);
+ assert(std::get<Idx>(v2) == std::get<Idx>(v));
}
-#if TEST_STD_VER >= 20
+
+constexpr bool test_constexpr_copy_ctor_trivial() {
+ // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+ using V = std::variant<long, void*, const int>;
+#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
+ static_assert(std::is_trivially_destructible<V>::value, "");
+ static_assert(std::is_trivially_copy_constructible<V>::value, "");
+ static_assert(std::is_trivially_move_constructible<V>::value, "");
+ static_assert(!std::is_copy_assignable<V>::value, "");
+ static_assert(!std::is_move_assignable<V>::value, "");
+#else // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
+ static_assert(std::is_trivially_copyable<V>::value, "");
+#endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
+ static_assert(std::is_trivially_copy_constructible<V>::value, "");
+ test_constexpr_copy_ctor_imp<0>(V(42l));
+ test_constexpr_copy_ctor_imp<1>(V(nullptr));
+ test_constexpr_copy_ctor_imp<2>(V(101));
+
+ return true;
+}
+
struct NonTrivialCopyCtor {
int i = 0;
constexpr NonTrivialCopyCtor(int ii) : i(ii) {}
constexpr NonTrivialCopyCtor(const NonTrivialCopyCtor& other) : i(other.i) {}
- constexpr NonTrivialCopyCtor(NonTrivialCopyCtor&& other) = default;
- constexpr ~NonTrivialCopyCtor() = default;
- friend constexpr bool operator==(const NonTrivialCopyCtor&, const NonTrivialCopyCtor&) = default;
+ constexpr NonTrivialCopyCtor(NonTrivialCopyCtor&& other) = default;
+ TEST_CONSTEXPR_CXX20 ~NonTrivialCopyCtor() = default;
+ friend constexpr bool operator==(const NonTrivialCopyCtor& x, const NonTrivialCopyCtor& y) { return x.i == y.i; }
};
-#endif
-void test_constexpr_copy_ctor() {
- {
- // Test is_trivially_copy_constructible
- // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
- using V = std::variant<long, void*, const int>;
-#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_destructible<V>::value, "");
- static_assert(std::is_trivially_copy_constructible<V>::value, "");
- static_assert(std::is_trivially_move_constructible<V>::value, "");
- static_assert(!std::is_copy_assignable<V>::value, "");
- static_assert(!std::is_move_assignable<V>::value, "");
-#else // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_copyable<V>::value, "");
-#endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_copy_constructible<V>::value, "");
- static_assert(test_constexpr_copy_ctor_imp<0>(V(42l)), "");
- static_assert(test_constexpr_copy_ctor_imp<1>(V(nullptr)), "");
- static_assert(test_constexpr_copy_ctor_imp<2>(V(101)), "");
- }
+TEST_CONSTEXPR_CXX20 bool test_constexpr_copy_ctor_non_trivial() {
+ // Test !is_trivially_move_constructible
+ using V = std::variant<long, NonTrivialCopyCtor, void*>;
+ static_assert(!std::is_trivially_copy_constructible<V>::value, "");
+ test_constexpr_copy_ctor_imp<0>(V(42l));
+ test_constexpr_copy_ctor_imp<1>(V(NonTrivialCopyCtor(5)));
+ test_constexpr_copy_ctor_imp<2>(V(nullptr));
-#if TEST_STD_VER >= 20
- {
- // Test !is_trivially_move_constructible
- using V = std::variant<long, NonTrivialCopyCtor, void*>;
- static_assert(!std::is_trivially_copy_constructible<V>::value, "");
- static_assert(test_constexpr_copy_ctor_imp<0>(V(42l)), "");
- static_assert(test_constexpr_copy_ctor_imp<1>(V(NonTrivialCopyCtor(5))), "");
- static_assert(test_constexpr_copy_ctor_imp<2>(V(nullptr)), "");
- }
-#endif
+ return true;
}
int main(int, char**) {
test_copy_ctor_basic();
test_copy_ctor_valueless_by_exception();
test_copy_ctor_sfinae();
- test_constexpr_copy_ctor();
+ test_constexpr_copy_ctor_trivial();
+ test_constexpr_copy_ctor_non_trivial();
+ static_assert(test_constexpr_copy_ctor_trivial());
#if TEST_STD_VER >= 20
static_assert(test_copy_ctor_basic());
+ static_assert(test_constexpr_copy_ctor_non_trivial());
#endif
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
index 0c931be453741f..bea4b32ef33b69 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
@@ -295,53 +295,51 @@ void test_move_ctor_valueless_by_exception() {
}
template <std::size_t Idx, class T>
-constexpr bool test_constexpr_ctor_imp(const T& v) {
+constexpr void test_constexpr_ctor_imp(const T& v) {
auto copy = v;
auto v2 = std::move(copy);
- return v2.index() == v.index() && v2.index() == Idx && std::get<Idx>(v2) == std::get<Idx>(v);
+ assert(v2.index() == v.index());
+ assert(v2.index() == Idx);
+ assert(std::get<Idx>(v2) == std::get<Idx>(v));
+}
+
+constexpr bool test_constexpr_move_ctor_trivial() {
+ // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+ using V = std::variant<long, void*, const int>;
+#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
+ static_assert(std::is_trivially_destructible<V>::value, "");
+ static_assert(std::is_trivially_copy_constructible<V>::value, "");
+ static_assert(std::is_trivially_move_constructible<V>::value, "");
+ static_assert(!std::is_copy_assignable<V>::value, "");
+ static_assert(!std::is_move_assignable<V>::value, "");
+#else // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
+ static_assert(std::is_trivially_copyable<V>::value, "");
+#endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
+ static_assert(std::is_trivially_move_constructible<V>::value, "");
+ test_constexpr_ctor_imp<0>(V(42l));
+ test_constexpr_ctor_imp<1>(V(nullptr));
+ test_constexpr_ctor_imp<2>(V(101));
+
+ return true;
}
-#if TEST_STD_VER >= 20
struct NonTrivialMoveCtor {
int i = 0;
constexpr NonTrivialMoveCtor(int ii) : i(ii) {}
constexpr NonTrivialMoveCtor(const NonTrivialMoveCtor& other) = default;
constexpr NonTrivialMoveCtor(NonTrivialMoveCtor&& other) : i(other.i) {}
- constexpr ~NonTrivialMoveCtor() = default;
- friend constexpr bool operator==(const NonTrivialMoveCtor&, const NonTrivialMoveCtor&) = default;
+ TEST_CONSTEXPR_CXX20 ~NonTrivialMoveCtor() = default;
+ friend constexpr bool operator==(const NonTrivialMoveCtor& x, const NonTrivialMoveCtor& y) { return x.i == y.i; }
};
-#endif
-void test_constexpr_move_ctor() {
- {
- // Test is_trivially_move_constructible
- // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
- using V = std::variant<long, void*, const int>;
-#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_destructible<V>::value, "");
- static_assert(std::is_trivially_copy_constructible<V>::value, "");
- static_assert(std::is_trivially_move_constructible<V>::value, "");
- static_assert(!std::is_copy_assignable<V>::value, "");
- static_assert(!std::is_move_assignable<V>::value, "");
-#else // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_copyable<V>::value, "");
-#endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
- static_assert(std::is_trivially_move_constructible<V>::value, "");
- static_assert(test_constexpr_ctor_imp<0>(V(42l)), "");
- static_assert(test_constexpr_ctor_imp<1>(V(nullptr)), "");
- static_assert(test_constexpr_ctor_imp<2>(V(101)), "");
- }
+TEST_CONSTEXPR_CXX20 bool test_constexpr_move_ctor_non_trivial() {
+ using V = std::variant<long, NonTrivialMoveCtor, void*>;
+ static_assert(!std::is_trivially_move_constructible<V>::value, "");
+ test_constexpr_ctor_imp<0>(V(42l));
+ test_constexpr_ctor_imp<1>(V(NonTrivialMoveCtor(5)));
+ test_constexpr_ctor_imp<2>(V(nullptr));
-#if TEST_STD_VER >= 20
- {
- // Test !is_trivially_move_constructible
- using V = std::variant<long, NonTrivialMoveCtor, void*>;
- static_assert(!std::is_trivially_move_constructible<V>::value, "");
- static_assert(test_constexpr_ctor_imp<0>(V(42l)), "");
- static_assert(test_constexpr_ctor_imp<1>(V(NonTrivialMoveCtor(5))), "");
- static_assert(test_constexpr_ctor_imp<2>(V(nullptr)), "");
- }
-#endif
+ return true;
}
int main(int, char**) {
@@ -349,10 +347,13 @@ int main(int, char**) {
test_move_ctor_valueless_by_exception();
test_move_noexcept();
test_move_ctor_sfinae();
- test_constexpr_move_ctor();
+ test_constexpr_move_ctor_trivial();
+ test_constexpr_move_ctor_non_trivial();
+ static_assert(test_constexpr_move_ctor_trivial());
#if TEST_STD_VER >= 20
static_assert(test_move_ctor_basic());
+ static_assert(test_constexpr_move_ctor_non_trivial());
#endif
return 0;
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
index 1802bc4670bba9..f20f0ed280fc44 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
@@ -25,37 +25,39 @@
#include "variant_test_helpers.h"
struct NotSwappable {};
-void swap(NotSwappable &, NotSwappable &) = delete;
+void swap(NotSwappable&, NotSwappable&) = delete;
struct NotCopyable {
- NotCopyable() = default;
- NotCopyable(const NotCopyable &) = delete;
- NotCopyable &operator=(const NotCopyable &) = delete;
+ NotCopyable() = default;
+ NotCopyable(const NotCopyable&) = delete;
+ NotCopyable& operator=(const NotCopyable&) = delete;
};
struct NotCopyableWithSwap {
- NotCopyableWithSwap() = default;
- NotCopyableWithSwap(const NotCopyableWithSwap &) = delete;
- NotCopyableWithSwap &operator=(const NotCopyableWithSwap &) = delete;
+ NotCopyableWithSwap() = default;
+ NotCopyableWithSwap(const NotCopyableWithSwap&) = delete;
+ NotCopyableWithSwap& operator=(const NotCopyableWithSwap&) = delete;
};
-void swap(NotCopyableWithSwap &, NotCopyableWithSwap) {}
+constexpr void swap(NotCopyableWithSwap&, NotCopyableWithSwap) {}
struct NotMoveAssignable {
- NotMoveAssignable() = default;
- NotMoveAssignable(NotMoveAssignable &&) = default;
- NotMoveAssignable &operator=(NotMoveAssignable &&) = delete;
+ NotMoveAssignable() = default;
+ NotMoveAssignable(NotMoveAssignable&&) = default;
+ NotMoveAssignable& operator=(NotMoveAssignable&&) = delete;
};
struct NotMoveAssignableWithSwap {
- NotMoveAssignableWithSwap() = default;
- NotMoveAssignableWithSwap(NotMoveAssignableWithSwap &&) = default;
- NotMoveAssignableWithSwap &operator=(NotMoveAssignableWithSwap &&) = delete;
+ NotMoveAssignableWithSwap() = default;
+ NotMoveAssignableWithSwap(NotMoveAssignableWithSwap&&) = default;
+ NotMoveAssignableWithSwap& operator=(NotMoveAssignableWithSwap&&) = delete;
};
-void swap(NotMoveAssignableWithSwap &, NotMoveAssignableWithSwap &) noexcept {}
+constexpr void swap(NotMoveAssignableWithSwap&, NotMoveAssignableWithSwap&) noexcept {}
-template <bool Throws> void do_throw() {}
+template <bool Throws>
+constexpr void do_throw() {}
-template <> void do_throw<true>() {
+template <>
+void do_throw<true>() {
#ifndef TEST_HAS_NO_EXCEPTIONS
throw 42;
#else
@@ -63,60 +65,49 @@ template <> void do_throw<true>() {
#endif
}
-template <bool NT_Copy, bool NT_Move, bool NT_CopyAssign, bool NT_MoveAssign,
- bool NT_Swap, bool EnableSwap = true>
+template <bool NT_Copy, bool NT_Move, bool NT_CopyAssign, bool NT_MoveAssign, bool NT_Swap, bool EnableSwap = true>
struct NothrowTypeImp {
- static int move_called;
- static int move_assign_called;
- static int swap_called;
- static void reset() { move_called = move_assign_called = swap_called = 0; }
- NothrowTypeImp() = default;
- explicit NothrowTypeImp(int v) : value(v) {}
- NothrowTypeImp(const NothrowTypeImp &o) noexcept(NT_Copy) : value(o.value) {
- assert(false);
- } // never called by test
- NothrowTypeImp(NothrowTypeImp &&o) noexcept(NT_Move) : value(o.value) {
- ++move_called;
+ int value;
+ int* move_called;
+ int* move_assign_called;
+ int* swap_called;
+
+ constexpr NothrowTypeImp(int v, int* mv_ctr, int* mv_assign, int* swap)
+ : value(v), move_called(mv_ctr), move_assign_called(mv_assign), swap_called(swap) {}
+
+ NothrowTypeImp(const NothrowTypeImp& o) noexcept(NT_Copy) : value(o.value) { assert(false); } // never called by test
+
+ constexpr NothrowTypeImp(NothrowTypeImp&& o) noexcept(NT_Move)
+ : value(o.value),
+ move_called(o.move_called),
+ move_assign_called(o.move_assign_called),
+ swap_called(o.swap_called) {
+ ++*move_called;
do_throw<!NT_Move>();
o.value = -1;
}
- NothrowTypeImp &operator=(const NothrowTypeImp &) noexcept(NT_CopyAssign) {
+
+ NothrowTypeImp& operator=(const NothrowTypeImp&) noexcept(NT_CopyAssign) {
assert(false);
return *this;
} // never called by the tests
- NothrowTypeImp &operator=(NothrowTypeImp &&o) noexcept(NT_MoveAssign) {
- ++move_assign_called;
+
+ constexpr NothrowTypeImp& operator=(NothrowTypeImp&& o) noexcept(NT_MoveAssign) {
+ ++*move_assign_called;
do_throw<!NT_MoveAssign>();
- value = o.value;
+ value = o.value;
o.value = -1;
return *this;
}
- int value;
};
-template <bool NT_Copy, bool NT_Move, bool NT_CopyAssign, bool NT_MoveAssign,
- bool NT_Swap, bool EnableSwap>
-int NothrowTypeImp<NT_Copy, NT_Move, NT_CopyAssign, NT_MoveAssign, NT_Swap,
- EnableSwap>::move_called = 0;
-template <bool NT_Copy, bool NT_Move, bool NT_CopyAssign, bool NT_MoveAssign,
- bool NT_Swap, bool EnableSwap>
-int NothrowTypeImp<NT_Copy, NT_Move, NT_CopyAssign, NT_MoveAssign, NT_Swap,
- EnableSwap>::move_assign_called = 0;
-template <bool NT_Copy, bool NT_Move, bool NT_CopyAssign, bool NT_MoveAssign,
- bool NT_Swap, bool EnableSwap>
-int NothrowTypeImp<NT_Copy, NT_Move, NT_CopyAssign, NT_MoveAssign, NT_Swap,
- EnableSwap>::swap_called = 0;
-
-template <bool NT_Copy, bool NT_Move, bool NT_CopyAssign, bool NT_MoveAssign,
- bool NT_Swap>
-void swap(NothrowTypeImp<NT_Copy, NT_Move, NT_CopyAssign, NT_MoveAssign,
- NT_Swap, true> &lhs,
- NothrowTypeImp<NT_Copy, NT_Move, NT_CopyAssign, NT_MoveAssign,
- NT_Swap, true> &rhs) noexcept(NT_Swap) {
- lhs.swap_called++;
+
+template <bool NT_Copy, bool NT_Move, bool NT_CopyAssign, bool NT_MoveAssign, bool NT_Swap>
+constexpr void
+swap(NothrowTypeImp<NT_Copy, NT_Move, NT_CopyAssign, NT_MoveAssign, NT_Swap, true>& lhs,
+ NothrowTypeImp<NT_Copy, NT_Move, NT_CopyAssign, NT_MoveAssign, NT_Swap, true>& rhs) noexcept(NT_Swap) {
+ ++*lhs.swap_called;
do_throw<!NT_Swap>();
- int tmp = lhs.value;
- lhs.value = rhs.value;
- rhs.value = tmp;
+ std::swap(lhs.value, rhs.value);
}
// throwing copy, nothrow move ctor/assign, no swap provided
@@ -124,53 +115,42 @@ using NothrowMoveable = NothrowTypeImp<false, true, false, true, false, false>;
// throwing copy and move assign, nothrow move ctor, no swap provided
using NothrowMoveCtor = NothrowTypeImp<false, true, false, false, false, false>;
// nothrow move ctor, throwing move assignment, swap provided
-using NothrowMoveCtorWithThrowingSwap =
- NothrowTypeImp<false, true, false, false, false, true>;
+using NothrowMoveCtorWithThrowingSwap = NothrowTypeImp<false, true, false, false, false, true>;
// throwing move ctor, nothrow move assignment, no swap provided
-using ThrowingMoveCtor =
- NothrowTypeImp<false, false, false, true, false, false>;
+using ThrowingMoveCtor = NothrowTypeImp<false, false, false, true, false, false>;
// throwing special members, nothrowing swap
-using ThrowingTypeWithNothrowSwap =
- NothrowTypeImp<false, false, false, false, true, true>;
-using NothrowTypeWithThrowingSwap =
- NothrowTypeImp<true, true, true, true, false, true>;
+using ThrowingTypeWithNothrowSwap = NothrowTypeImp<false, false, false, false, true, true>;
+using NothrowTypeWithThrowingSwap = NothrowTypeImp<true, true, true, true, false, true>;
// throwing move assign with nothrow move and nothrow swap
-using ThrowingMoveAssignNothrowMoveCtorWithSwap =
- NothrowTypeImp<false, true, false, false, true, true>;
+using ThrowingMoveAssignNothrowMoveCtorWithSwap = NothrowTypeImp<false, true, false, false, true, true>;
// throwing move assign with nothrow move but no swap.
-using ThrowingMoveAssignNothrowMoveCtor =
- NothrowTypeImp<false, true, false, false, false, false>;
+using ThrowingMoveAssignNothrowMoveCtor = NothrowTypeImp<false, true, false, false, false, false>;
struct NonThrowingNonNoexceptType {
- static int move_called;
- static void reset() { move_called = 0; }
- NonThrowingNonNoexceptType() = default;
- NonThrowingNonNoexceptType(int v) : value(v) {}
- NonThrowingNonNoexceptType(NonThrowingNonNoexceptType &&o) noexcept(false)
- : value(o.value) {
- ++move_called;
+ int value;
+ int* move_called;
+ constexpr NonThrowingNonNoexceptType(int v, int* mv_called) : value(v), move_called(mv_called) {}
+ constexpr NonThrowingNonNoexceptType(NonThrowingNonNoexceptType&& o) noexcept(false)
+ : value(o.value), move_called(o.move_called) {
+ ++*move_called;
o.value = -1;
}
- NonThrowingNonNoexceptType &
- operator=(NonThrowingNonNoexceptType &&) noexcept(false) {
+ NonThrowingNonNoexceptType& operator=(NonThrowingNonNoexceptType&&) noexcept(false) {
assert(false); // never called by the tests.
return *this;
}
- int value;
};
-int NonThrowingNonNoexceptType::move_called = 0;
struct ThrowsOnSecondMove {
int value;
int move_count;
ThrowsOnSecondMove(int v) : value(v), move_count(0) {}
- ThrowsOnSecondMove(ThrowsOnSecondMove &&o) noexcept(false)
- : value(o.value), move_count(o.move_count + 1) {
+ ThrowsOnSecondMove(ThrowsOnSecondMove&& o) noexcept(false) : value(o.value), move_count(o.move_count + 1) {
if (move_count == 2)
do_throw<true>();
o.value = -1;
}
- ThrowsOnSecondMove &operator=(ThrowsOnSecondMove &&) {
+ ThrowsOnSecondMove& operator=(ThrowsOnSecondMove&&) {
assert(false); // not called by test
return *this;
}
@@ -224,261 +204,294 @@ void test_swap_valueless_by_exception() {
#endif
}
-void test_swap_same_alternative() {
+TEST_CONSTEXPR_CXX20 bool test_swap_same_alternative() {
{
- using T = ThrowingTypeWithNothrowSwap;
- using V = std::variant<T, int>;
- T::reset();
- V v1(std::in_place_index<0>, 42);
- V v2(std::in_place_index<0>, 100);
+ using V = std::variant<ThrowingTypeWithNothrowSwap, int>;
+ int move_called = 0;
+ int move_assign_called = 0;
+ int swap_called = 0;
+ V v1(std::in_place_index<0>, 42, &move_called, &move_assign_called, &swap_called);
+ V v2(std::in_place_index<0>, 100, &move_called, &move_assign_called, &swap_called);
v1.swap(v2);
- assert(T::swap_called == 1);
+ assert(swap_called == 1);
assert(std::get<0>(v1).value == 100);
assert(std::get<0>(v2).value == 42);
swap(v1, v2);
- assert(T::swap_called == 2);
+ assert(swap_called == 2);
assert(std::get<0>(v1).value == 42);
assert(std::get<0>(v2).value == 100);
+
+ assert(move_called == 0);
+ assert(move_assign_called == 0);
}
{
- using T = NothrowMoveable;
- using V = std::variant<T, int>;
- T::reset();
- V v1(std::in_place_index<0>, 42);
- V v2(std::in_place_index<0>, 100);
+ using V = std::variant<NothrowMoveable, int>;
+ int move_called = 0;
+ int move_assign_called = 0;
+ int swap_called = 0;
+ V v1(std::in_place_index<0>, 42, &move_called, &move_assign_called, &swap_called);
+ V v2(std::in_place_index<0>, 100, &move_called, &move_assign_called, &swap_called);
v1.swap(v2);
- assert(T::swap_called == 0);
- assert(T::move_called == 1);
- assert(T::move_assign_called == 2);
+ assert(swap_called == 0);
+ assert(move_called == 1);
+ assert(move_assign_called == 2);
assert(std::get<0>(v1).value == 100);
assert(std::get<0>(v2).value == 42);
- T::reset();
+
+ move_called = 0;
+ move_assign_called = 0;
+ swap_called = 0;
+
swap(v1, v2);
- assert(T::swap_called == 0);
- assert(T::move_called == 1);
- assert(T::move_assign_called == 2);
+ assert(swap_called == 0);
+ assert(move_called == 1);
+ assert(move_assign_called == 2);
assert(std::get<0>(v1).value == 42);
assert(std::get<0>(v2).value == 100);
}
+ return true;
+}
+
+void test_swap_same_alternative_throws(){
#ifndef TEST_HAS_NO_EXCEPTIONS
- {
- using T = NothrowTypeWithThrowingSwap;
- using V = std::variant<T, int>;
- T::reset();
- V v1(std::in_place_index<0>, 42);
- V v2(std::in_place_index<0>, 100);
- try {
- v1.swap(v2);
- assert(false);
- } catch (int) {
- }
- assert(T::swap_called == 1);
- assert(T::move_called == 0);
- assert(T::move_assign_called == 0);
- assert(std::get<0>(v1).value == 42);
- assert(std::get<0>(v2).value == 100);
- }
- {
- using T = ThrowingMoveCtor;
- using V = std::variant<T, int>;
- T::reset();
- V v1(std::in_place_index<0>, 42);
- V v2(std::in_place_index<0>, 100);
- try {
- v1.swap(v2);
- assert(false);
- } catch (int) {
- }
- assert(T::move_called == 1); // call threw
- assert(T::move_assign_called == 0);
- assert(std::get<0>(v1).value ==
- 42); // throw happened before v1 was moved from
- assert(std::get<0>(v2).value == 100);
+ {using V = std::variant<NothrowTypeWithThrowingSwap, int>;
+int move_called = 0;
+int move_assign_called = 0;
+int swap_called = 0;
+V v1(std::in_place_index<0>, 42, &move_called, &move_assign_called, &swap_called);
+V v2(std::in_place_index<0>, 100, &move_called, &move_assign_called, &swap_called);
+try {
+ v1.swap(v2);
+ assert(false);
+} catch (int) {
+}
+assert(swap_called == 1);
+assert(move_called == 0);
+assert(move_assign_called == 0);
+assert(std::get<0>(v1).value == 42);
+assert(std::get<0>(v2).value == 100);
+}
+
+{
+ using V = std::variant<ThrowingMoveCtor, int>;
+ int move_called = 0;
+ int move_assign_called = 0;
+ int swap_called = 0;
+ V v1(std::in_place_index<0>, 42, &move_called, &move_assign_called, &swap_called);
+ V v2(std::in_place_index<0>, 100, &move_called, &move_assign_called, &swap_called);
+ try {
+ v1.swap(v2);
+ assert(false);
+ } catch (int) {
}
- {
- using T = ThrowingMoveAssignNothrowMoveCtor;
- using V = std::variant<T, int>;
- T::reset();
- V v1(std::in_place_index<0>, 42);
- V v2(std::in_place_index<0>, 100);
- try {
- v1.swap(v2);
- assert(false);
- } catch (int) {
- }
- assert(T::move_called == 1);
- assert(T::move_assign_called == 1); // call threw and didn't complete
- assert(std::get<0>(v1).value == -1); // v1 was moved from
- assert(std::get<0>(v2).value == 100);
+ assert(move_called == 1); // call threw
+ assert(move_assign_called == 0);
+ assert(swap_called == 0);
+ assert(std::get<0>(v1).value == 42); // throw happened before v1 was moved from
+ assert(std::get<0>(v2).value == 100);
+}
+{
+ using V = std::variant<ThrowingMoveAssignNothrowMoveCtor, int>;
+ int move_called = 0;
+ int move_assign_called = 0;
+ int swap_called = 0;
+ V v1(std::in_place_index<0>, 42, &move_called, &move_assign_called, &swap_called);
+ V v2(std::in_place_index<0>, 100, &move_called, &move_assign_called, &swap_called);
+ try {
+ v1.swap(v2);
+ assert(false);
+ } catch (int) {
}
+ assert(move_called == 1);
+ assert(move_assign_called == 1); // call threw and didn't complete
+ assert(swap_called == 0);
+ assert(std::get<0>(v1).value == -1); // v1 was moved from
+ assert(std::get<0>(v2).value == 100);
+}
#endif
}
-void test_swap_different_alternatives() {
+TEST_CONSTEXPR_CXX20 bool test_swap_different_alternatives() {
{
- using T = NothrowMoveCtorWithThrowingSwap;
- using V = std::variant<T, int>;
- T::reset();
- V v1(std::in_place_index<0>, 42);
+ using V = std::variant<NothrowMoveCtorWithThrowingSwap, int>;
+ int move_called = 0;
+ int move_assign_called = 0;
+ int swap_called = 0;
+ V v1(std::in_place_index<0>, 42, &move_called, &move_assign_called, &swap_called);
V v2(std::in_place_index<1>, 100);
v1.swap(v2);
- assert(T::swap_called == 0);
+ assert(swap_called == 0);
// The libc++ implementation double copies the argument, and not
// the variant swap is called on.
- LIBCPP_ASSERT(T::move_called == 1);
- assert(T::move_called <= 2);
- assert(T::move_assign_called == 0);
+ LIBCPP_ASSERT(move_called == 1);
+ assert(move_called <= 2);
+ assert(move_assign_called == 0);
assert(std::get<1>(v1) == 100);
assert(std::get<0>(v2).value == 42);
- T::reset();
+
+ move_called = 0;
+ move_assign_called = 0;
+ swap_called = 0;
+
swap(v1, v2);
- assert(T::swap_called == 0);
- LIBCPP_ASSERT(T::move_called == 2);
- assert(T::move_called <= 2);
- assert(T::move_assign_called == 0);
+ assert(swap_called == 0);
+ LIBCPP_ASSERT(move_called == 2);
+ assert(move_called <= 2);
+ assert(move_assign_called == 0);
assert(std::get<0>(v1).value == 42);
assert(std::get<1>(v2) == 100);
}
+
+ return true;
+}
+
+void test_swap_different_alternatives_throws() {
#ifndef TEST_HAS_NO_EXCEPTIONS
{
- using T1 = ThrowingTypeWithNothrowSwap;
- using T2 = NonThrowingNonNoexceptType;
- using V = std::variant<T1, T2>;
- T1::reset();
- T2::reset();
- V v1(std::in_place_index<0>, 42);
- V v2(std::in_place_index<1>, 100);
+ using V = std::variant<ThrowingTypeWithNothrowSwap, NonThrowingNonNoexceptType>;
+ int move_called1 = 0;
+ int move_assign_called1 = 0;
+ int swap_called1 = 0;
+ int move_called2 = 0;
+ V v1(std::in_place_index<0>, 42, &move_called1, &move_assign_called1, &swap_called1);
+ V v2(std::in_place_index<1>, 100, &move_called2);
try {
v1.swap(v2);
assert(false);
} catch (int) {
}
- assert(T1::swap_called == 0);
- assert(T1::move_called == 1); // throws
- assert(T1::move_assign_called == 0);
+ assert(swap_called1 == 0);
+ assert(move_called1 == 1); // throws
+ assert(move_assign_called1 == 0);
// FIXME: libc++ shouldn't move from T2 here.
- LIBCPP_ASSERT(T2::move_called == 1);
- assert(T2::move_called <= 1);
+ LIBCPP_ASSERT(move_called2 == 1);
+ assert(move_called2 <= 1);
assert(std::get<0>(v1).value == 42);
- if (T2::move_called != 0)
+ if (move_called2 != 0)
assert(v2.valueless_by_exception());
else
assert(std::get<1>(v2).value == 100);
}
{
- using T1 = NonThrowingNonNoexceptType;
- using T2 = ThrowingTypeWithNothrowSwap;
- using V = std::variant<T1, T2>;
- T1::reset();
- T2::reset();
- V v1(std::in_place_index<0>, 42);
- V v2(std::in_place_index<1>, 100);
+ using V = std::variant<NonThrowingNonNoexceptType, ThrowingTypeWithNothrowSwap>;
+ int move_called1 = 0;
+ int move_called2 = 0;
+ int move_assign_called2 = 0;
+ int swap_called2 = 0;
+ V v1(std::in_place_index<0>, 42, &move_called1);
+ V v2(std::in_place_index<1>, 100, &move_called2, &move_assign_called2, &swap_called2);
try {
v1.swap(v2);
assert(false);
} catch (int) {
}
- LIBCPP_ASSERT(T1::move_called == 0);
- assert(T1::move_called <= 1);
- assert(T2::swap_called == 0);
- assert(T2::move_called == 1); // throws
- assert(T2::move_assign_called == 0);
- if (T1::move_called != 0)
+ LIBCPP_ASSERT(move_called1 == 0);
+ assert(move_called1 <= 1);
+ assert(swap_called2 == 0);
+ assert(move_called2 == 1); // throws
+ assert(move_assign_called2 == 0);
+ if (move_called1 != 0)
assert(v1.valueless_by_exception());
else
assert(std::get<0>(v1).value == 42);
assert(std::get<1>(v2).value == 100);
}
// FIXME: The tests below are just very libc++ specific
-#ifdef _LIBCPP_VERSION
+# ifdef _LIBCPP_VERSION
{
- using T1 = ThrowsOnSecondMove;
- using T2 = NonThrowingNonNoexceptType;
- using V = std::variant<T1, T2>;
- T2::reset();
+ using T1 = ThrowsOnSecondMove;
+ using T2 = NonThrowingNonNoexceptType;
+ using V = std::variant<ThrowsOnSecondMove, NonThrowingNonNoexceptType>;
+ int move_called = 0;
V v1(std::in_place_index<0>, 42);
- V v2(std::in_place_index<1>, 100);
+ V v2(std::in_place_index<1>, 100, &move_called);
v1.swap(v2);
- assert(T2::move_called == 2);
+ assert(move_called == 2);
assert(std::get<1>(v1).value == 100);
assert(std::get<0>(v2).value == 42);
assert(std::get<0>(v2).move_count == 1);
}
{
- using T1 = NonThrowingNonNoexceptType;
- using T2 = ThrowsOnSecondMove;
- using V = std::variant<T1, T2>;
- T1::reset();
- V v1(std::in_place_index<0>, 42);
+ using V = std::variant<NonThrowingNonNoexceptType, ThrowsOnSecondMove>;
+ int move_called = 0;
+ V v1(std::in_place_index<0>, 42, &move_called);
V v2(std::in_place_index<1>, 100);
try {
v1.swap(v2);
assert(false);
} catch (int) {
}
- assert(T1::move_called == 1);
+ assert(move_called == 1);
assert(v1.valueless_by_exception());
assert(std::get<0>(v2).value == 42);
}
-#endif
-// testing libc++ extension. If either variant stores a nothrow move
-// constructible type v1.swap(v2) provides the strong exception safety
-// guarantee.
-#ifdef _LIBCPP_VERSION
+# endif
+ // testing libc++ extension. If either variant stores a nothrow move
+ // constructible type v1.swap(v2) provides the strong exception safety
+ // guarantee.
+# ifdef _LIBCPP_VERSION
{
-
- using T1 = ThrowingTypeWithNothrowSwap;
- using T2 = NothrowMoveable;
- using V = std::variant<T1, T2>;
- T1::reset();
- T2::reset();
- V v1(std::in_place_index<0>, 42);
- V v2(std::in_place_index<1>, 100);
+ using V = std::variant<ThrowingTypeWithNothrowSwap, NothrowMoveable>;
+ int move_called1 = 0;
+ int move_assign_called1 = 0;
+ int swap_called1 = 0;
+ int move_called2 = 0;
+ int move_assign_called2 = 0;
+ int swap_called2 = 0;
+ V v1(std::in_place_index<0>, 42, &move_called1, &move_assign_called1, &swap_called1);
+ V v2(std::in_place_index<1>, 100, &move_called2, &move_assign_called2, &swap_called2);
try {
v1.swap(v2);
assert(false);
} catch (int) {
}
- assert(T1::swap_called == 0);
- assert(T1::move_called == 1);
- assert(T1::move_assign_called == 0);
- assert(T2::swap_called == 0);
- assert(T2::move_called == 2);
- assert(T2::move_assign_called == 0);
+ assert(swap_called1 == 0);
+ assert(move_called1 == 1);
+ assert(move_assign_called1 == 0);
+ assert(swap_called2 == 0);
+ assert(move_called2 == 2);
+ assert(move_assign_called2 == 0);
assert(std::get<0>(v1).value == 42);
assert(std::get<1>(v2).value == 100);
// swap again, but call v2's swap.
- T1::reset();
- T2::reset();
+
+ move_called1 = 0;
+ move_assign_called1 = 0;
+ swap_called1 = 0;
+ move_called2 = 0;
+ move_assign_called2 = 0;
+ swap_called2 = 0;
+
try {
v2.swap(v1);
assert(false);
} catch (int) {
}
- assert(T1::swap_called == 0);
- assert(T1::move_called == 1);
- assert(T1::move_assign_called == 0);
- assert(T2::swap_called == 0);
- assert(T2::move_called == 2);
- assert(T2::move_assign_called == 0);
+ assert(swap_called1 == 0);
+ assert(move_called1 == 1);
+ assert(move_assign_called1 == 0);
+ assert(swap_called2 == 0);
+ assert(move_called2 == 2);
+ assert(move_assign_called2 == 0);
assert(std::get<0>(v1).value == 42);
assert(std::get<1>(v2).value == 100);
}
-#endif // _LIBCPP_VERSION
+# endif // _LIBCPP_VERSION
#endif
}
template <class Var>
-constexpr auto has_swap_member_imp(int)
- -> decltype(std::declval<Var &>().swap(std::declval<Var &>()), true) {
+constexpr auto has_swap_member_imp(int) -> decltype(std::declval<Var&>().swap(std::declval<Var&>()), true) {
return true;
}
-template <class Var> constexpr auto has_swap_member_imp(long) -> bool {
+template <class Var>
+constexpr auto has_swap_member_imp(long) -> bool {
return false;
}
-template <class Var> constexpr bool has_swap_member() {
+template <class Var>
+constexpr bool has_swap_member() {
return has_swap_member_imp<Var>(0);
}
@@ -508,7 +521,7 @@ void test_swap_sfinae() {
}
}
-void test_swap_noexcept() {
+_LIBCPP_CONSTEXPR_SINCE_CXX20 bool test_swap_noexcept() {
{
using V = std::variant<int, NothrowMoveable>;
static_assert(std::is_swappable_v<V> && has_swap_member<V>(), "");
@@ -574,19 +587,28 @@ void test_swap_noexcept() {
V v1, v2;
swap(v1, v2);
}
+
+ return true;
}
#ifdef _LIBCPP_VERSION
// This is why variant should SFINAE member swap. :-)
template class std::variant<int, NotSwappable>;
#endif
-
int main(int, char**) {
test_swap_valueless_by_exception();
test_swap_same_alternative();
+ test_swap_same_alternative_throws();
test_swap_different_alternatives();
+ test_swap_different_alternatives_throws();
test_swap_sfinae();
test_swap_noexcept();
+#if TEST_STD_VER >= 20
+ static_assert(test_swap_same_alternative());
+ static_assert(test_swap_different_alternatives());
+ static_assert(test_swap_noexcept());
+#endif
+
return 0;
}
>From 40c9ba75ff6a85fc50e4362a3461ec2618aa4436 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Fri, 1 Mar 2024 13:21:59 +0000
Subject: [PATCH 5/9] status
---
libcxx/docs/Status/Cxx20.rst | 1 -
libcxx/docs/Status/Cxx20Papers.csv | 2 +-
2 files changed, 1 insertion(+), 2 deletions(-)
diff --git a/libcxx/docs/Status/Cxx20.rst b/libcxx/docs/Status/Cxx20.rst
index 2deb82547d6310..c00d6fb2372869 100644
--- a/libcxx/docs/Status/Cxx20.rst
+++ b/libcxx/docs/Status/Cxx20.rst
@@ -47,7 +47,6 @@ Paper Status
.. [#note-P0619] P0619: Only sections D.8, D.9, D.10 and D.13 are implemented. Sections D.4, D.7, D.11, and D.12 remain undone.
.. [#note-P0883.1] P0883: shared_ptr and floating-point changes weren't applied as they themselves aren't implemented yet.
.. [#note-P0883.2] P0883: ``ATOMIC_FLAG_INIT`` was marked deprecated in version 14.0, but was undeprecated with the implementation of LWG3659 in version 15.0.
- .. [#note-P2231] P2231: Optional is complete. The changes to variant haven't been implemented yet.
.. [#note-P0660] P0660: The paper is implemented but the features are experimental and can be enabled via ``-fexperimental-library``.
.. [#note-P0355] P0355: The implementation status is:
diff --git a/libcxx/docs/Status/Cxx20Papers.csv b/libcxx/docs/Status/Cxx20Papers.csv
index db6491419a5cc3..aa79c7b5d3d409 100644
--- a/libcxx/docs/Status/Cxx20Papers.csv
+++ b/libcxx/docs/Status/Cxx20Papers.csv
@@ -192,7 +192,7 @@
"`P2106R0 <https://wg21.link/P2106R0>`__","LWG","Alternative wording for GB315 and GB316","Prague","|Complete|","15.0","|ranges|"
"`P2116R0 <https://wg21.link/P2116R0>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"
"","","","","","",""
-"`P2231R1 <https://wg21.link/P2231R1>`__","LWG","Missing constexpr in std::optional and std::variant","June 2021","|Partial| [#note-P2231]_","13.0"
+"`P2231R1 <https://wg21.link/P2231R1>`__","LWG","Missing constexpr in std::optional and std::variant","June 2021","|Complete|","19.0"
"`P2325R3 <https://wg21.link/P2325R3>`__","LWG","Views should not be required to be default constructible","June 2021","|Complete|","16.0","|ranges|"
"`P2210R2 <https://wg21.link/P2210R2>`__","LWG","Superior String Splitting","June 2021","|Complete|","16.0","|ranges|"
"`P2216R3 <https://wg21.link/P2216R3>`__","LWG","std::format improvements","June 2021","|Complete|","15.0"
>From 5805e6299b985e67f9d9a79ccff12f24a2647bf7 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Fri, 1 Mar 2024 15:14:23 +0000
Subject: [PATCH 6/9] ci
---
.../variant/variant.variant/variant.swap/swap.pass.cpp | 2 --
1 file changed, 2 deletions(-)
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
index f20f0ed280fc44..9acaf7a9ec88dc 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
@@ -399,8 +399,6 @@ void test_swap_different_alternatives_throws() {
// FIXME: The tests below are just very libc++ specific
# ifdef _LIBCPP_VERSION
{
- using T1 = ThrowsOnSecondMove;
- using T2 = NonThrowingNonNoexceptType;
using V = std::variant<ThrowsOnSecondMove, NonThrowingNonNoexceptType>;
int move_called = 0;
V v1(std::in_place_index<0>, 42);
>From 17fc1da7f08eac26026373eb6e818fe20487d319 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 3 Mar 2024 12:53:14 +0000
Subject: [PATCH 7/9] address feedback
---
libcxx/include/variant | 137 +++++++++---------
.../variant.variant/variant.assign/T.pass.cpp | 27 ++--
.../variant.assign/copy.pass.cpp | 48 +++---
.../variant.assign/move.pass.cpp | 49 ++++---
.../variant.ctor/copy.pass.cpp | 36 +++--
.../variant.ctor/move.pass.cpp | 40 +++--
.../variant.mod/emplace_index_args.pass.cpp | 15 +-
.../emplace_index_init_list_args.pass.cpp | 15 +-
.../variant.mod/emplace_type_args.pass.cpp | 16 +-
.../emplace_type_init_list_args.pass.cpp | 16 +-
.../variant.swap/swap.pass.cpp | 34 +++--
11 files changed, 249 insertions(+), 184 deletions(-)
diff --git a/libcxx/include/variant b/libcxx/include/variant
index 2a583f6dbd2006..9b0613d632ed0f 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -687,14 +687,11 @@ union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
_LIBCPP_HIDE_FROM_ABI explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args) \
: __tail(in_place_index<_Ip - 1>, std::forward<_Args>(__args)...) {} \
\
- __union(const __union&) = default; \
- __union(__union&&) = default; \
- \
- _LIBCPP_HIDE_FROM_ABI destructor \
- \
- __union& \
- operator=(const __union&) = default; \
- __union& operator=(__union&&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __union(const __union&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __union(__union&&) = default; \
+ destructor; \
+ _LIBCPP_HIDE_FROM_ABI __union& operator=(const __union&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __union& operator=(__union&&) = default; \
\
private: \
char __dummy; \
@@ -704,9 +701,10 @@ union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
friend struct __access::__union; \
}
-_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union() = default;);
-_LIBCPP_VARIANT_UNION(_Trait::_Available, _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union(){});
-_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union() = delete;);
+_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable,
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union() = default;);
+_LIBCPP_VARIANT_UNION(_Trait::_Available, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union(){});
+_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union() = delete;);
# undef _LIBCPP_VARIANT_UNION
@@ -759,24 +757,26 @@ class _LIBCPP_TEMPLATE_VIS __dtor;
public: \
using __base_type::__base_type; \
using __base_type::operator=; \
- \
- __dtor(const __dtor&) = default; \
- __dtor(__dtor&&) = default; \
- _LIBCPP_HIDE_FROM_ABI destructor __dtor& operator=(const __dtor&) = default; \
- __dtor& operator=(__dtor&&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __dtor(const __dtor&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __dtor(__dtor&&) = default; \
+ destructor; \
+ _LIBCPP_HIDE_FROM_ABI __dtor& operator=(const __dtor&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __dtor& operator=(__dtor&&) = default; \
\
protected: \
- inline _LIBCPP_HIDE_FROM_ABI destroy \
+ destroy \
}
_LIBCPP_VARIANT_DESTRUCTOR(
- _Trait::_TriviallyAvailable, _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() = default;
- , _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept { this->__index = __variant_npos<__index_t>; });
+ _Trait::_TriviallyAvailable, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() = default;
+ , _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept {
+ this->__index = __variant_npos<__index_t>;
+ });
_LIBCPP_VARIANT_DESTRUCTOR(
_Trait::_Available,
- _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() { __destroy(); },
- _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() { __destroy(); },
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept {
if (!this->valueless_by_exception()) {
__visitation::__base::__visit_alt(
[](auto& __alt) noexcept {
@@ -788,8 +788,8 @@ _LIBCPP_VARIANT_DESTRUCTOR(
this->__index = __variant_npos<__index_t>;
});
-_LIBCPP_VARIANT_DESTRUCTOR(_Trait::_Unavailable, _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() = delete;
- , _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept = delete;);
+_LIBCPP_VARIANT_DESTRUCTOR(_Trait::_Unavailable, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() = delete;
+ , _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept = delete;);
# undef _LIBCPP_VARIANT_DESTRUCTOR
@@ -806,10 +806,6 @@ protected:
_LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX20 void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) {
__lhs.__destroy();
if (!__rhs.valueless_by_exception()) {
- // We cannot directly construct at the target __alt because its direct enclosing union is not activated yet.
- // We will get error if we did:
- // construction of subobject of member '__tail' of union with active member '__dummy' is not allowed in a constant
- // expression
auto __rhs_index = __rhs.index();
__visitation::__base::__visit_alt_at(
__rhs_index,
@@ -837,24 +833,26 @@ class _LIBCPP_TEMPLATE_VIS __move_constructor;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- __move_constructor(const __move_constructor&) = default; \
- _LIBCPP_HIDE_FROM_ABI move_constructor ~__move_constructor() = default; \
- __move_constructor& operator=(const __move_constructor&) = default; \
- __move_constructor& operator=(__move_constructor&&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __move_constructor(const __move_constructor&) = default; \
+ move_constructor; \
+ _LIBCPP_HIDE_FROM_ABI ~__move_constructor() = default; \
+ _LIBCPP_HIDE_FROM_ABI __move_constructor& operator=(const __move_constructor&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __move_constructor& operator=(__move_constructor&&) = default; \
}
_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
_Trait::_TriviallyAvailable,
- _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&& __that) = default;);
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&& __that) = default;);
_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
_Trait::_Available,
- _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&& __that) noexcept(
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&& __that) noexcept(
__all<is_nothrow_move_constructible_v<_Types>...>::value)
: __move_constructor(__valueless_t{}) { this->__generic_construct(*this, std::move(__that)); });
-_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(_Trait::_Unavailable,
- _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&&) = delete;);
+_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
+ _Trait::_Unavailable,
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&&) = delete;);
# undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR
@@ -871,22 +869,25 @@ class _LIBCPP_TEMPLATE_VIS __copy_constructor;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- _LIBCPP_HIDE_FROM_ABI copy_constructor __copy_constructor(__copy_constructor&&) = default; \
- ~__copy_constructor() = default; \
- __copy_constructor& operator=(const __copy_constructor&) = default; \
- __copy_constructor& operator=(__copy_constructor&&) = default; \
+ copy_constructor; \
+ _LIBCPP_HIDE_FROM_ABI __copy_constructor(__copy_constructor&&) = default; \
+ _LIBCPP_HIDE_FROM_ABI ~__copy_constructor() = default; \
+ _LIBCPP_HIDE_FROM_ABI __copy_constructor& operator=(const __copy_constructor&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __copy_constructor& operator=(__copy_constructor&&) = default; \
}
-_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
- _Trait::_TriviallyAvailable,
- _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor& __that) = default;);
+_LIBCPP_VARIANT_COPY_CONSTRUCTOR(_Trait::_TriviallyAvailable,
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(
+ const __copy_constructor& __that) = default;);
_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
- _Trait::_Available, _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor& __that)
+ _Trait::_Available,
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor& __that)
: __copy_constructor(__valueless_t{}) { this->__generic_construct(*this, __that); });
-_LIBCPP_VARIANT_COPY_CONSTRUCTOR(_Trait::_Unavailable,
- _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor&) = delete;);
+_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
+ _Trait::_Unavailable,
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor&) = delete;);
# undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR
@@ -957,20 +958,20 @@ class _LIBCPP_TEMPLATE_VIS __move_assignment;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- __move_assignment(const __move_assignment&) = default; \
- __move_assignment(__move_assignment&&) = default; \
- ~__move_assignment() = default; \
- __move_assignment& operator=(const __move_assignment&) = default; \
- _LIBCPP_HIDE_FROM_ABI move_assignment \
+ _LIBCPP_HIDE_FROM_ABI __move_assignment(const __move_assignment&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __move_assignment(__move_assignment&&) = default; \
+ _LIBCPP_HIDE_FROM_ABI ~__move_assignment() = default; \
+ _LIBCPP_HIDE_FROM_ABI __move_assignment& operator=(const __move_assignment&) = default; \
+ move_assignment \
}
-_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
- _Trait::_TriviallyAvailable,
- _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment& operator=(__move_assignment&& __that) = default;);
+_LIBCPP_VARIANT_MOVE_ASSIGNMENT(_Trait::_TriviallyAvailable,
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment& operator=(
+ __move_assignment&& __that) = default;);
_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
_Trait::_Available,
- _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment&
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment&
operator=(__move_assignment&& __that) noexcept(
__all<(is_nothrow_move_constructible_v<_Types> && is_nothrow_move_assignable_v<_Types>)...>::value) {
this->__generic_assign(std::move(__that));
@@ -978,7 +979,8 @@ _LIBCPP_VARIANT_MOVE_ASSIGNMENT(
});
_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
- _Trait::_Unavailable, _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment& operator=(__move_assignment&&) = delete;);
+ _Trait::_Unavailable,
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment& operator=(__move_assignment&&) = delete;);
# undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT
@@ -995,25 +997,28 @@ class _LIBCPP_TEMPLATE_VIS __copy_assignment;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- __copy_assignment(const __copy_assignment&) = default; \
- __copy_assignment(__copy_assignment&&) = default; \
- ~__copy_assignment() = default; \
- _LIBCPP_HIDE_FROM_ABI copy_assignment __copy_assignment& operator=(__copy_assignment&&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __copy_assignment(const __copy_assignment&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __copy_assignment(__copy_assignment&&) = default; \
+ _LIBCPP_HIDE_FROM_ABI ~__copy_assignment() = default; \
+ copy_assignment; \
+ _LIBCPP_HIDE_FROM_ABI __copy_assignment& operator=(__copy_assignment&&) = default; \
}
-_LIBCPP_VARIANT_COPY_ASSIGNMENT(
- _Trait::_TriviallyAvailable,
- _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment& operator=(const __copy_assignment& __that) = default;);
+_LIBCPP_VARIANT_COPY_ASSIGNMENT(_Trait::_TriviallyAvailable,
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment& operator=(
+ const __copy_assignment& __that) = default;);
_LIBCPP_VARIANT_COPY_ASSIGNMENT(
- _Trait::_Available, _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment& operator=(const __copy_assignment& __that) {
+ _Trait::_Available,
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment&
+ operator=(const __copy_assignment& __that) {
this->__generic_assign(__that);
return *this;
});
-_LIBCPP_VARIANT_COPY_ASSIGNMENT(
- _Trait::_Unavailable,
- _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment& operator=(const __copy_assignment&) = delete;);
+_LIBCPP_VARIANT_COPY_ASSIGNMENT(_Trait::_Unavailable,
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment& operator=(
+ const __copy_assignment&) = delete;);
# undef _LIBCPP_VARIANT_COPY_ASSIGNMENT
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
index be9e38f893093c..befdefab885019 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
@@ -106,7 +106,7 @@ struct NoThrowT {
#endif // !defined(TEST_HAS_NO_EXCEPTIONS)
} // namespace RuntimeHelpers
-void test_T_assignment_noexcept() {
+constexpr void test_T_assignment_noexcept() {
using namespace MetaHelpers;
{
using V = std::variant<Dummy, NoThrowT>;
@@ -122,7 +122,7 @@ void test_T_assignment_noexcept() {
}
}
-void test_T_assignment_sfinae() {
+constexpr void test_T_assignment_sfinae() {
{
using V = std::variant<long, long long>;
static_assert(!std::is_assignable<V, int>::value, "ambiguous");
@@ -170,7 +170,7 @@ void test_T_assignment_sfinae() {
#endif // TEST_VARIANT_HAS_NO_REFERENCES
}
-TEST_CONSTEXPR_CXX20 bool test_T_assignment_basic() {
+TEST_CONSTEXPR_CXX20 void test_T_assignment_basic() {
{
std::variant<int> v(43);
v = 42;
@@ -203,7 +203,6 @@ TEST_CONSTEXPR_CXX20 bool test_T_assignment_basic() {
assert(v.index() == 0);
assert(std::get<0>(v) == "bar");
}
- return true;
}
void test_T_assignment_basic_no_constexpr() {
@@ -279,7 +278,7 @@ void test_T_assignment_performs_assignment() {
#endif // TEST_HAS_NO_EXCEPTIONS
}
-TEST_CONSTEXPR_CXX20 bool test_T_assignment_vector_bool() {
+TEST_CONSTEXPR_CXX20 void test_T_assignment_vector_bool() {
#ifndef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
std::vector<bool> vec = {true};
std::variant<bool, int> v;
@@ -287,21 +286,29 @@ TEST_CONSTEXPR_CXX20 bool test_T_assignment_vector_bool() {
assert(v.index() == 0);
assert(std::get<0>(v) == true);
#endif
- return true;
}
-int main(int, char**) {
- test_T_assignment_basic();
+void non_constexpr_test() {
test_T_assignment_basic_no_constexpr();
test_T_assignment_performs_construction();
test_T_assignment_performs_assignment();
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+ test_T_assignment_basic();
test_T_assignment_noexcept();
test_T_assignment_sfinae();
test_T_assignment_vector_bool();
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ non_constexpr_test();
+
#if TEST_STD_VER >= 20
- static_assert(test_T_assignment_basic());
- static_assert(test_T_assignment_vector_bool());
+ static_assert(test());
#endif
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
index 095cfca3b67870..a6d3f34114eb71 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
@@ -217,7 +217,7 @@ void makeEmpty(Variant& v) {
}
#endif // TEST_HAS_NO_EXCEPTIONS
-void test_copy_assignment_not_noexcept() {
+constexpr void test_copy_assignment_not_noexcept() {
{
using V = std::variant<CopyMaybeThrows>;
static_assert(!std::is_nothrow_copy_assignable<V>::value, "");
@@ -228,7 +228,7 @@ void test_copy_assignment_not_noexcept() {
}
}
-void test_copy_assignment_sfinae() {
+constexpr void test_copy_assignment_sfinae() {
{
using V = std::variant<int, long>;
static_assert(std::is_copy_assignable<V>::value, "");
@@ -349,7 +349,7 @@ struct Result {
T value;
};
-TEST_CONSTEXPR_CXX20 bool test_copy_assignment_same_index() {
+TEST_CONSTEXPR_CXX20 void test_copy_assignment_same_index() {
{
using V = std::variant<int>;
V v1(43);
@@ -443,11 +443,9 @@ TEST_CONSTEXPR_CXX20 bool test_copy_assignment_same_index() {
static_assert(result.index == 1, "");
static_assert(result.value == 42, "");
}
-
- return true;
}
-TEST_CONSTEXPR_CXX20 bool test_copy_assignment_different_index() {
+TEST_CONSTEXPR_CXX20 void test_copy_assignment_different_index() {
{
using V = std::variant<int, long, unsigned>;
V v1(43);
@@ -508,7 +506,6 @@ TEST_CONSTEXPR_CXX20 bool test_copy_assignment_different_index() {
static_assert(result.index == 1, "");
static_assert(result.value == 42, "");
}
- return true;
}
void test_assignment_throw() {
@@ -599,7 +596,7 @@ constexpr void test_constexpr_assign_imp(T&& v, ValueType&& new_value) {
assert(std::get<NewIdx>(v) == std::get<NewIdx>(cp));
}
-constexpr bool test_constexpr_copy_assignment_trivial() {
+constexpr void test_constexpr_copy_assignment_trivial() {
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
using V = std::variant<long, void*, int>;
static_assert(std::is_trivially_copyable<V>::value, "");
@@ -608,8 +605,6 @@ constexpr bool test_constexpr_copy_assignment_trivial() {
test_constexpr_assign_imp<0>(V(nullptr), 101l);
test_constexpr_assign_imp<1>(V(42l), nullptr);
test_constexpr_assign_imp<2>(V(42l), 101);
-
- return true;
}
struct NonTrivialCopyAssign {
@@ -624,7 +619,7 @@ struct NonTrivialCopyAssign {
friend constexpr bool operator==(const NonTrivialCopyAssign& x, const NonTrivialCopyAssign& y) { return x.i == y.i; }
};
-constexpr bool test_constexpr_copy_assignment_non_trivial() {
+constexpr void test_constexpr_copy_assignment_non_trivial() {
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
using V = std::variant<long, void*, NonTrivialCopyAssign>;
static_assert(!std::is_trivially_copyable<V>::value, "");
@@ -634,28 +629,39 @@ constexpr bool test_constexpr_copy_assignment_non_trivial() {
test_constexpr_assign_imp<1>(V(42l), nullptr);
test_constexpr_assign_imp<2>(V(42l), NonTrivialCopyAssign(5));
test_constexpr_assign_imp<2>(V(NonTrivialCopyAssign(3)), NonTrivialCopyAssign(5));
-
- return true;
}
-int main(int, char**) {
+void non_constexpr_test() {
test_copy_assignment_empty_empty();
test_copy_assignment_non_empty_empty();
test_copy_assignment_empty_non_empty();
test_assignment_throw();
- test_copy_assignment_same_index();
- test_copy_assignment_different_index();
+}
+
+constexpr bool cxx17_constexpr_test() {
test_copy_assignment_sfinae();
test_copy_assignment_not_noexcept();
test_constexpr_copy_assignment_trivial();
+
+ return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool cxx20_constexpr_test() {
+ test_copy_assignment_same_index();
+ test_copy_assignment_different_index();
test_constexpr_copy_assignment_non_trivial();
- static_assert(test_constexpr_copy_assignment_trivial());
+ return true;
+}
+
+int main(int, char**) {
+ non_constexpr_test();
+ cxx17_constexpr_test();
+ cxx20_constexpr_test();
+
+ static_assert(cxx17_constexpr_test());
#if TEST_STD_VER >= 20
- static_assert(test_copy_assignment_same_index());
- static_assert(test_copy_assignment_different_index());
- static_assert(test_constexpr_copy_assignment_non_trivial());
+ static_assert(cxx20_constexpr_test());
#endif
-
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
index 406f5695a982ec..157ff68f374825 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
@@ -132,7 +132,7 @@ struct TrivialCopyNontrivialMove {
static_assert(std::is_trivially_copy_assignable_v<TrivialCopyNontrivialMove>, "");
static_assert(!std::is_trivially_move_assignable_v<TrivialCopyNontrivialMove>, "");
-void test_move_assignment_noexcept() {
+constexpr void test_move_assignment_noexcept() {
{
using V = std::variant<int>;
static_assert(std::is_nothrow_move_assignable<V>::value, "");
@@ -159,7 +159,7 @@ void test_move_assignment_noexcept() {
}
}
-void test_move_assignment_sfinae() {
+constexpr void test_move_assignment_sfinae() {
{
using V = std::variant<int, long>;
static_assert(std::is_move_assignable<V>::value, "");
@@ -290,7 +290,7 @@ struct Result {
T value;
};
-TEST_CONSTEXPR_CXX20 bool test_move_assignment_same_index() {
+TEST_CONSTEXPR_CXX20 void test_move_assignment_same_index() {
{
using V = std::variant<int>;
V v1(43);
@@ -366,11 +366,9 @@ TEST_CONSTEXPR_CXX20 bool test_move_assignment_same_index() {
static_assert(result.index == 1, "");
static_assert(result.value == 42, "");
}
-
- return true;
}
-TEST_CONSTEXPR_CXX20 bool test_move_assignment_different_index() {
+TEST_CONSTEXPR_CXX20 void test_move_assignment_different_index() {
{
using V = std::variant<int, long, unsigned>;
V v1(43);
@@ -423,8 +421,6 @@ TEST_CONSTEXPR_CXX20 bool test_move_assignment_different_index() {
static_assert(result.index == 1, "");
static_assert(result.value == 42, "");
}
-
- return true;
}
void test_assignment_throw() {
@@ -480,7 +476,7 @@ constexpr void test_constexpr_assign_imp(T&& v, ValueType&& new_value) {
assert(std::get<NewIdx>(v) == std::get<NewIdx>(cp));
}
-constexpr bool test_constexpr_move_assignment_trivial() {
+constexpr void test_constexpr_move_assignment_trivial() {
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
using V = std::variant<long, void*, int>;
static_assert(std::is_trivially_copyable<V>::value, "");
@@ -489,8 +485,6 @@ constexpr bool test_constexpr_move_assignment_trivial() {
test_constexpr_assign_imp<0>(V(nullptr), 101l);
test_constexpr_assign_imp<1>(V(42l), nullptr);
test_constexpr_assign_imp<2>(V(42l), 101);
-
- return true;
}
struct NonTrivialMoveAssign {
@@ -507,7 +501,7 @@ struct NonTrivialMoveAssign {
friend constexpr bool operator==(const NonTrivialMoveAssign& x, const NonTrivialMoveAssign& y) { return x.i == y.i; }
};
-TEST_CONSTEXPR_CXX20 bool test_constexpr_move_assignment_non_trivial() {
+TEST_CONSTEXPR_CXX20 void test_constexpr_move_assignment_non_trivial() {
using V = std::variant<long, void*, NonTrivialMoveAssign>;
static_assert(!std::is_trivially_copyable<V>::value);
static_assert(!std::is_trivially_move_assignable<V>::value);
@@ -516,28 +510,39 @@ TEST_CONSTEXPR_CXX20 bool test_constexpr_move_assignment_non_trivial() {
test_constexpr_assign_imp<1>(V(42l), nullptr);
test_constexpr_assign_imp<2>(V(42l), NonTrivialMoveAssign(5));
test_constexpr_assign_imp<2>(V(NonTrivialMoveAssign(3)), NonTrivialMoveAssign(5));
-
- return true;
}
-int main(int, char**) {
+void non_constexpr_test() {
test_move_assignment_empty_empty();
test_move_assignment_non_empty_empty();
test_move_assignment_empty_non_empty();
test_assignment_throw();
- test_move_assignment_same_index();
- test_move_assignment_different_index();
+}
+
+constexpr bool cxx17_constexpr_test() {
test_move_assignment_sfinae();
test_move_assignment_noexcept();
-
test_constexpr_move_assignment_trivial();
+
+ return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool cxx20_constexpr_test() {
+ test_move_assignment_same_index();
+ test_move_assignment_different_index();
test_constexpr_move_assignment_non_trivial();
- static_assert(test_constexpr_move_assignment_trivial());
+ return true;
+}
+
+int main(int, char**) {
+ non_constexpr_test();
+ cxx17_constexpr_test();
+ cxx20_constexpr_test();
+
+ static_assert(cxx17_constexpr_test());
#if TEST_STD_VER >= 20
- static_assert(test_move_assignment_same_index());
- static_assert(test_move_assignment_different_index());
- static_assert(test_constexpr_move_assignment_non_trivial());
+ static_assert(cxx20_constexpr_test());
#endif
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
index 74505ddbcace44..820ff9e0d1a9d0 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -99,7 +99,7 @@ void makeEmpty(Variant& v) {
}
#endif // TEST_HAS_NO_EXCEPTIONS
-void test_copy_ctor_sfinae() {
+constexpr void test_copy_ctor_sfinae() {
{
using V = std::variant<int, long>;
static_assert(std::is_copy_constructible<V>::value, "");
@@ -137,7 +137,7 @@ void test_copy_ctor_sfinae() {
}
}
-TEST_CONSTEXPR_CXX20 bool test_copy_ctor_basic() {
+TEST_CONSTEXPR_CXX20 void test_copy_ctor_basic() {
{
std::variant<int> v(std::in_place_index<0>, 42);
std::variant<int> v2 = v;
@@ -208,7 +208,6 @@ TEST_CONSTEXPR_CXX20 bool test_copy_ctor_basic() {
static_assert(v2.index() == 1, "");
static_assert(std::get<1>(v2).value == 42, "");
}
- return true;
}
void test_copy_ctor_valueless_by_exception() {
@@ -230,7 +229,7 @@ constexpr void test_constexpr_copy_ctor_imp(const T& v) {
assert(std::get<Idx>(v2) == std::get<Idx>(v));
}
-constexpr bool test_constexpr_copy_ctor_trivial() {
+constexpr void test_constexpr_copy_ctor_trivial() {
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
using V = std::variant<long, void*, const int>;
#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
@@ -246,8 +245,6 @@ constexpr bool test_constexpr_copy_ctor_trivial() {
test_constexpr_copy_ctor_imp<0>(V(42l));
test_constexpr_copy_ctor_imp<1>(V(nullptr));
test_constexpr_copy_ctor_imp<2>(V(101));
-
- return true;
}
struct NonTrivialCopyCtor {
@@ -259,28 +256,39 @@ struct NonTrivialCopyCtor {
friend constexpr bool operator==(const NonTrivialCopyCtor& x, const NonTrivialCopyCtor& y) { return x.i == y.i; }
};
-TEST_CONSTEXPR_CXX20 bool test_constexpr_copy_ctor_non_trivial() {
+TEST_CONSTEXPR_CXX20 void test_constexpr_copy_ctor_non_trivial() {
// Test !is_trivially_move_constructible
using V = std::variant<long, NonTrivialCopyCtor, void*>;
static_assert(!std::is_trivially_copy_constructible<V>::value, "");
test_constexpr_copy_ctor_imp<0>(V(42l));
test_constexpr_copy_ctor_imp<1>(V(NonTrivialCopyCtor(5)));
test_constexpr_copy_ctor_imp<2>(V(nullptr));
+}
+
+void non_constexpr_test() { test_copy_ctor_valueless_by_exception(); }
+
+constexpr bool cxx17_constexpr_test() {
+ test_copy_ctor_sfinae();
+ test_constexpr_copy_ctor_trivial();
return true;
}
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool cxx20_constexpr_test() {
test_copy_ctor_basic();
- test_copy_ctor_valueless_by_exception();
- test_copy_ctor_sfinae();
- test_constexpr_copy_ctor_trivial();
test_constexpr_copy_ctor_non_trivial();
- static_assert(test_constexpr_copy_ctor_trivial());
+ return true;
+}
+
+int main(int, char**) {
+ non_constexpr_test();
+ cxx17_constexpr_test();
+ cxx20_constexpr_test();
+
+ static_assert(cxx17_constexpr_test());
#if TEST_STD_VER >= 20
- static_assert(test_copy_ctor_basic());
- static_assert(test_constexpr_copy_ctor_non_trivial());
+ static_assert(cxx20_constexpr_test());
#endif
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
index bea4b32ef33b69..4e8453c23cf550 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
@@ -101,7 +101,7 @@ void makeEmpty(Variant& v) {
}
#endif // TEST_HAS_NO_EXCEPTIONS
-void test_move_noexcept() {
+constexpr void test_move_noexcept() {
{
using V = std::variant<int, long>;
static_assert(std::is_nothrow_move_constructible<V>::value, "");
@@ -120,7 +120,7 @@ void test_move_noexcept() {
}
}
-void test_move_ctor_sfinae() {
+constexpr void test_move_ctor_sfinae() {
{
using V = std::variant<int, long>;
static_assert(std::is_move_constructible<V>::value, "");
@@ -164,7 +164,7 @@ struct Result {
T value;
};
-TEST_CONSTEXPR_CXX20 bool test_move_ctor_basic() {
+TEST_CONSTEXPR_CXX20 void test_move_ctor_basic() {
{
std::variant<int> v(std::in_place_index<0>, 42);
std::variant<int> v2 = std::move(v);
@@ -281,7 +281,6 @@ TEST_CONSTEXPR_CXX20 bool test_move_ctor_basic() {
static_assert(result.index == 1, "");
static_assert(result.value.value == 42, "");
}
- return true;
}
void test_move_ctor_valueless_by_exception() {
@@ -303,7 +302,7 @@ constexpr void test_constexpr_ctor_imp(const T& v) {
assert(std::get<Idx>(v2) == std::get<Idx>(v));
}
-constexpr bool test_constexpr_move_ctor_trivial() {
+constexpr void test_constexpr_move_ctor_trivial() {
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
using V = std::variant<long, void*, const int>;
#ifdef TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
@@ -319,8 +318,6 @@ constexpr bool test_constexpr_move_ctor_trivial() {
test_constexpr_ctor_imp<0>(V(42l));
test_constexpr_ctor_imp<1>(V(nullptr));
test_constexpr_ctor_imp<2>(V(101));
-
- return true;
}
struct NonTrivialMoveCtor {
@@ -332,28 +329,39 @@ struct NonTrivialMoveCtor {
friend constexpr bool operator==(const NonTrivialMoveCtor& x, const NonTrivialMoveCtor& y) { return x.i == y.i; }
};
-TEST_CONSTEXPR_CXX20 bool test_constexpr_move_ctor_non_trivial() {
+TEST_CONSTEXPR_CXX20 void test_constexpr_move_ctor_non_trivial() {
using V = std::variant<long, NonTrivialMoveCtor, void*>;
static_assert(!std::is_trivially_move_constructible<V>::value, "");
test_constexpr_ctor_imp<0>(V(42l));
test_constexpr_ctor_imp<1>(V(NonTrivialMoveCtor(5)));
test_constexpr_ctor_imp<2>(V(nullptr));
-
- return true;
}
-int main(int, char**) {
- test_move_ctor_basic();
- test_move_ctor_valueless_by_exception();
+void non_constexpr_test() { test_move_ctor_valueless_by_exception(); }
+
+constexpr bool cxx17_constexpr_test() {
test_move_noexcept();
test_move_ctor_sfinae();
test_constexpr_move_ctor_trivial();
+
+ return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool cxx20_constexpr_test() {
+ test_move_ctor_basic();
test_constexpr_move_ctor_non_trivial();
- static_assert(test_constexpr_move_ctor_trivial());
+ return true;
+}
+
+int main(int, char**) {
+ non_constexpr_test();
+ cxx17_constexpr_test();
+ cxx20_constexpr_test();
+
+ static_assert(cxx17_constexpr_test());
#if TEST_STD_VER >= 20
- static_assert(test_move_ctor_basic());
- static_assert(test_constexpr_move_ctor_non_trivial());
+ static_assert(cxx20_constexpr_test());
#endif
return 0;
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
index 36c78d1b22bd0c..f98d968f0eae04 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
@@ -41,7 +41,7 @@ constexpr bool emplace_exists() {
return test_emplace_exists_imp<Var, I, Args...>(0);
}
-void test_emplace_sfinae() {
+constexpr void test_emplace_sfinae() {
{
using V = std::variant<int, void*, const void*, TestTypes::NoCtors>;
static_assert(emplace_exists<V, 0>(), "");
@@ -61,7 +61,7 @@ struct NoCtor {
NoCtor() = delete;
};
-TEST_CONSTEXPR_CXX20 bool test_basic() {
+TEST_CONSTEXPR_CXX20 void test_basic() {
{
using V = std::variant<int>;
V v(42);
@@ -94,16 +94,21 @@ TEST_CONSTEXPR_CXX20 bool test_basic() {
assert(std::get<4>(v) == "aaa");
assert(&ref3 == &std::get<4>(v));
}
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+ test_basic();
+ test_emplace_sfinae();
return true;
}
int main(int, char**) {
- test_basic();
+ test();
+
#if TEST_STD_VER >= 20
- static_assert(test_basic());
+ static_assert(test());
#endif
- test_emplace_sfinae();
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
index 0bf279f41a8e52..4c635570bd5622 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
@@ -51,7 +51,7 @@ constexpr bool emplace_exists() {
return test_emplace_exists_imp<Var, I, Args...>(0);
}
-void test_emplace_sfinae() {
+constexpr void test_emplace_sfinae() {
using V = std::variant<int, TestTypes::NoCtors, InitList, InitListArg, long, long>;
using IL = std::initializer_list<int>;
static_assert(!emplace_exists<V, 1, IL>(), "no such constructor");
@@ -68,7 +68,7 @@ struct NoCtor {
NoCtor() = delete;
};
-TEST_CONSTEXPR_CXX20 bool test_basic() {
+TEST_CONSTEXPR_CXX20 void test_basic() {
using V = std::variant<int, InitList, InitListArg, NoCtor>;
V v;
auto& ref1 = v.emplace<1>({1, 2, 3});
@@ -84,16 +84,21 @@ TEST_CONSTEXPR_CXX20 bool test_basic() {
static_assert(std::is_same_v<InitList&, decltype(ref3)>, "");
assert(std::get<1>(v).size == 1);
assert(&ref3 == &std::get<1>(v));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+ test_basic();
+ test_emplace_sfinae();
return true;
}
int main(int, char**) {
- test_basic();
+ test();
+
#if TEST_STD_VER >= 20
- static_assert(test_basic());
+ static_assert(test());
#endif
- test_emplace_sfinae();
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
index 7712a8149aa116..c2ed54d8a6257c 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
@@ -40,7 +40,7 @@ constexpr bool emplace_exists() {
return test_emplace_exists_imp<Args...>(0);
}
-void test_emplace_sfinae() {
+constexpr void test_emplace_sfinae() {
{
using V = std::variant<int, void*, const void*, TestTypes::NoCtors>;
static_assert(emplace_exists<V, int>(), "");
@@ -60,7 +60,7 @@ struct NoCtor {
NoCtor() = delete;
};
-TEST_CONSTEXPR_CXX20 bool test_basic() {
+TEST_CONSTEXPR_CXX20 void test_basic() {
{
using V = std::variant<int>;
V v(42);
@@ -92,15 +92,21 @@ TEST_CONSTEXPR_CXX20 bool test_basic() {
assert(std::get<4>(v) == "aaa");
assert(&ref3 == &std::get<4>(v));
}
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+ test_basic();
+ test_emplace_sfinae();
+
return true;
}
int main(int, char**) {
- test_basic();
+ test();
+
#if TEST_STD_VER >= 20
- static_assert(test_basic());
+ static_assert(test());
#endif
- test_emplace_sfinae();
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
index 6cd862c7d8095b..644f2418b9255a 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
@@ -51,7 +51,7 @@ constexpr bool emplace_exists() {
return test_emplace_exists_imp<Args...>(0);
}
-void test_emplace_sfinae() {
+constexpr void test_emplace_sfinae() {
using V = std::variant<int, TestTypes::NoCtors, InitList, InitListArg, long, long>;
using IL = std::initializer_list<int>;
static_assert(emplace_exists<V, InitList, IL>(), "");
@@ -67,7 +67,7 @@ struct NoCtor {
NoCtor() = delete;
};
-TEST_CONSTEXPR_CXX20 bool test_basic() {
+TEST_CONSTEXPR_CXX20 void test_basic() {
using V = std::variant<int, InitList, InitListArg, NoCtor>;
V v;
auto& ref1 = v.emplace<InitList>({1, 2, 3});
@@ -83,15 +83,21 @@ TEST_CONSTEXPR_CXX20 bool test_basic() {
static_assert(std::is_same_v<InitList&, decltype(ref3)>, "");
assert(std::get<InitList>(v).size == 1);
assert(&ref3 == &std::get<InitList>(v));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+ test_basic();
+ test_emplace_sfinae();
+
return true;
}
int main(int, char**) {
- test_basic();
+ test();
+
#if TEST_STD_VER >= 20
- static_assert(test_basic());
+ static_assert(test());
#endif
- test_emplace_sfinae();
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
index 9acaf7a9ec88dc..db05691c55818c 100644
--- a/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
@@ -204,7 +204,7 @@ void test_swap_valueless_by_exception() {
#endif
}
-TEST_CONSTEXPR_CXX20 bool test_swap_same_alternative() {
+TEST_CONSTEXPR_CXX20 void test_swap_same_alternative() {
{
using V = std::variant<ThrowingTypeWithNothrowSwap, int>;
int move_called = 0;
@@ -249,7 +249,6 @@ TEST_CONSTEXPR_CXX20 bool test_swap_same_alternative() {
assert(std::get<0>(v1).value == 42);
assert(std::get<0>(v2).value == 100);
}
- return true;
}
void test_swap_same_alternative_throws(){
@@ -311,7 +310,7 @@ assert(std::get<0>(v2).value == 100);
#endif
}
-TEST_CONSTEXPR_CXX20 bool test_swap_different_alternatives() {
+TEST_CONSTEXPR_CXX20 void test_swap_different_alternatives() {
{
using V = std::variant<NothrowMoveCtorWithThrowingSwap, int>;
int move_called = 0;
@@ -341,8 +340,6 @@ TEST_CONSTEXPR_CXX20 bool test_swap_different_alternatives() {
assert(std::get<0>(v1).value == 42);
assert(std::get<1>(v2) == 100);
}
-
- return true;
}
void test_swap_different_alternatives_throws() {
@@ -493,7 +490,7 @@ constexpr bool has_swap_member() {
return has_swap_member_imp<Var>(0);
}
-void test_swap_sfinae() {
+constexpr void test_swap_sfinae() {
{
// This variant type does not provide either a member or non-member swap
// but is still swappable via the generic swap algorithm, since the
@@ -519,7 +516,7 @@ void test_swap_sfinae() {
}
}
-_LIBCPP_CONSTEXPR_SINCE_CXX20 bool test_swap_noexcept() {
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void test_swap_noexcept() {
{
using V = std::variant<int, NothrowMoveable>;
static_assert(std::is_swappable_v<V> && has_swap_member<V>(), "");
@@ -585,27 +582,34 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 bool test_swap_noexcept() {
V v1, v2;
swap(v1, v2);
}
-
- return true;
}
#ifdef _LIBCPP_VERSION
// This is why variant should SFINAE member swap. :-)
template class std::variant<int, NotSwappable>;
#endif
-int main(int, char**) {
+
+void non_constexpr_test() {
test_swap_valueless_by_exception();
- test_swap_same_alternative();
test_swap_same_alternative_throws();
- test_swap_different_alternatives();
test_swap_different_alternatives_throws();
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+ test_swap_same_alternative();
+ test_swap_different_alternatives();
test_swap_sfinae();
test_swap_noexcept();
+ return true;
+}
+
+int main(int, char**) {
+ non_constexpr_test();
+ test();
+
#if TEST_STD_VER >= 20
- static_assert(test_swap_same_alternative());
- static_assert(test_swap_different_alternatives());
- static_assert(test_swap_noexcept());
+ static_assert(test());
#endif
return 0;
>From 3dc65a4902e16d63f3f6d1433e5fe9375a89f943 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 3 Mar 2024 16:48:27 +0000
Subject: [PATCH 8/9] ci
---
libcxx/include/variant | 32 +++++++++++++++-----------------
1 file changed, 15 insertions(+), 17 deletions(-)
diff --git a/libcxx/include/variant b/libcxx/include/variant
index 9b0613d632ed0f..194de8ff1b458f 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -687,14 +687,13 @@ union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
_LIBCPP_HIDE_FROM_ABI explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args) \
: __tail(in_place_index<_Ip - 1>, std::forward<_Args>(__args)...) {} \
\
- _LIBCPP_HIDE_FROM_ABI __union(const __union&) = default; \
- _LIBCPP_HIDE_FROM_ABI __union(__union&&) = default; \
- destructor; \
+ _LIBCPP_HIDE_FROM_ABI __union(const __union&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __union(__union&&) = default; \
_LIBCPP_HIDE_FROM_ABI __union& operator=(const __union&) = default; \
_LIBCPP_HIDE_FROM_ABI __union& operator=(__union&&) = default; \
+ destructor \
\
- private: \
- char __dummy; \
+ private : char __dummy; \
__alt<_Index, _Tp> __head; \
__union<destructible_trait, _Index + 1, _Types...> __tail; \
\
@@ -757,14 +756,13 @@ class _LIBCPP_TEMPLATE_VIS __dtor;
public: \
using __base_type::__base_type; \
using __base_type::operator=; \
- _LIBCPP_HIDE_FROM_ABI __dtor(const __dtor&) = default; \
- _LIBCPP_HIDE_FROM_ABI __dtor(__dtor&&) = default; \
- destructor; \
+ _LIBCPP_HIDE_FROM_ABI __dtor(const __dtor&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __dtor(__dtor&&) = default; \
_LIBCPP_HIDE_FROM_ABI __dtor& operator=(const __dtor&) = default; \
_LIBCPP_HIDE_FROM_ABI __dtor& operator=(__dtor&&) = default; \
+ destructor \
\
- protected: \
- destroy \
+ protected : destroy \
}
_LIBCPP_VARIANT_DESTRUCTOR(
@@ -833,11 +831,11 @@ class _LIBCPP_TEMPLATE_VIS __move_constructor;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- _LIBCPP_HIDE_FROM_ABI __move_constructor(const __move_constructor&) = default; \
- move_constructor; \
+ _LIBCPP_HIDE_FROM_ABI __move_constructor(const __move_constructor&) = default; \
_LIBCPP_HIDE_FROM_ABI ~__move_constructor() = default; \
_LIBCPP_HIDE_FROM_ABI __move_constructor& operator=(const __move_constructor&) = default; \
_LIBCPP_HIDE_FROM_ABI __move_constructor& operator=(__move_constructor&&) = default; \
+ move_constructor \
}
_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
@@ -869,11 +867,11 @@ class _LIBCPP_TEMPLATE_VIS __copy_constructor;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- copy_constructor; \
_LIBCPP_HIDE_FROM_ABI __copy_constructor(__copy_constructor&&) = default; \
_LIBCPP_HIDE_FROM_ABI ~__copy_constructor() = default; \
_LIBCPP_HIDE_FROM_ABI __copy_constructor& operator=(const __copy_constructor&) = default; \
_LIBCPP_HIDE_FROM_ABI __copy_constructor& operator=(__copy_constructor&&) = default; \
+ copy_constructor \
}
_LIBCPP_VARIANT_COPY_CONSTRUCTOR(_Trait::_TriviallyAvailable,
@@ -997,11 +995,11 @@ class _LIBCPP_TEMPLATE_VIS __copy_assignment;
using __base_type::__base_type; \
using __base_type::operator=; \
\
- _LIBCPP_HIDE_FROM_ABI __copy_assignment(const __copy_assignment&) = default; \
- _LIBCPP_HIDE_FROM_ABI __copy_assignment(__copy_assignment&&) = default; \
- _LIBCPP_HIDE_FROM_ABI ~__copy_assignment() = default; \
- copy_assignment; \
+ _LIBCPP_HIDE_FROM_ABI __copy_assignment(const __copy_assignment&) = default; \
+ _LIBCPP_HIDE_FROM_ABI __copy_assignment(__copy_assignment&&) = default; \
+ _LIBCPP_HIDE_FROM_ABI ~__copy_assignment() = default; \
_LIBCPP_HIDE_FROM_ABI __copy_assignment& operator=(__copy_assignment&&) = default; \
+ copy_assignment \
}
_LIBCPP_VARIANT_COPY_ASSIGNMENT(_Trait::_TriviallyAvailable,
>From 0feb2143cb96e77bd215eb09d54afadd0f1f727b Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Wed, 6 Mar 2024 10:08:14 +0000
Subject: [PATCH 9/9] address feedback
---
libcxx/docs/ReleaseNotes/19.rst | 1 +
libcxx/include/variant | 11 ++++++-----
2 files changed, 7 insertions(+), 5 deletions(-)
diff --git a/libcxx/docs/ReleaseNotes/19.rst b/libcxx/docs/ReleaseNotes/19.rst
index 78c6bb87a5a402..1db26a6e48ff46 100644
--- a/libcxx/docs/ReleaseNotes/19.rst
+++ b/libcxx/docs/ReleaseNotes/19.rst
@@ -41,6 +41,7 @@ Implemented Papers
- P2637R3 - Member ``visit``
- P2652R2 - Disallow User Specialization of ``allocator_traits``
- P2819R2 - Add ``tuple`` protocol to ``complex``
+- P2231R1 - Missing ``constexpr`` in ``std::optional`` and ``std::variant``
Improvements and New Features
diff --git a/libcxx/include/variant b/libcxx/include/variant
index 194de8ff1b458f..66418f8deca63a 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -42,27 +42,28 @@ namespace std {
in_place_index_t<I>, initializer_list<U>, Args&&...);
// 20.7.2.2, destructor
- constexpr ~variant(); // constexpr since c++20
+ constexpr ~variant(); // constexpr since c++20
// 20.7.2.3, assignment
constexpr variant& operator=(const variant&);
constexpr variant& operator=(variant&&) noexcept(see below);
template <class T>
- constexpr variant& operator=(T&&) noexcept(see below); // constexpr since c++20
+ constexpr variant& operator=(T&&) noexcept(see below); // constexpr since c++20
// 20.7.2.4, modifiers
template <class T, class... Args>
- constexpr T& emplace(Args&&...); // constexpr since c++20
+ constexpr T& emplace(Args&&...); // constexpr since c++20
template <class T, class U, class... Args>
- constexpr T& emplace(initializer_list<U>, Args&&...); // constexpr since c++20
+ constexpr T& emplace(initializer_list<U>, Args&&...); // constexpr since c++20
template <size_t I, class... Args>
constexpr variant_alternative_t<I, variant>& emplace(Args&&...); // constexpr since c++20
template <size_t I, class U, class... Args>
- constexpr variant_alternative_t<I, variant>& emplace(initializer_list<U>, Args&&...); // constexpr since c++20
+ constexpr variant_alternative_t<I, variant>&
+ emplace(initializer_list<U>, Args&&...); // constexpr since c++20
// 20.7.2.5, value status
constexpr bool valueless_by_exception() const noexcept;
More information about the libcxx-commits
mailing list