lichray updated this revision to Diff 172514.
lichray added a comment.
Herald added subscribers: libcxx-commits, ldionne.
Updated implementation for https://reviews.llvm.org/source/clang/
Repository:
rCXX libc++
https://reviews.llvm.org/D44865
Files:
include/variant
test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
Index: test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
@@ -20,8 +20,8 @@
#include <string>
#include <type_traits>
#include <variant>
+#include <memory>
-#include "test_convertible.hpp"
#include "test_macros.h"
#include "variant_test_helpers.hpp"
@@ -39,6 +39,8 @@
struct AnyConstructible { template <typename T> AnyConstructible(T&&) {} };
struct NoConstructible { NoConstructible() = delete; };
+template <class T>
+struct RValueConvertibleFrom { RValueConvertibleFrom(T&&) {} };
void test_T_ctor_noexcept() {
{
@@ -53,7 +55,7 @@
void test_T_ctor_sfinae() {
{
- using V = std::variant<long, unsigned>;
+ using V = std::variant<long, long long>;
static_assert(!std::is_constructible<V, int>::value, "ambiguous");
}
{
@@ -66,6 +68,32 @@
"no matching constructor");
}
{
+ using V = std::variant<std::string, float>;
+ static_assert(!std::is_constructible<V, int>::value,
+ "no matching constructor");
+ }
+ {
+ using V = std::variant<std::unique_ptr<int>, bool>;
+ static_assert(!std::is_constructible<V, std::unique_ptr<char>>::value,
+ "no explicit bool in constructor");
+ struct X {
+ operator void*();
+ };
+ static_assert(!std::is_constructible<V, X>::value,
+ "no boolean conversion in constructor");
+ static_assert(!std::is_constructible<V, std::false_type>::value,
+ "no converted to bool in constructor");
+ }
+ {
+ struct X {};
+ struct Y {
+ operator X();
+ };
+ using V = std::variant<X>;
+ static_assert(std::is_constructible<V, Y>::value,
+ "regression on user-defined conversions in constructor");
+ }
+ {
using V = std::variant<AnyConstructible, NoConstructible>;
static_assert(
!std::is_constructible<V, std::in_place_type_t<NoConstructible>>::value,
@@ -99,6 +127,34 @@
static_assert(v.index() == 1, "");
static_assert(std::get<1>(v) == 42, "");
}
+ {
+ constexpr std::variant<unsigned, long> v(42);
+ static_assert(v.index() == 1, "");
+ static_assert(std::get<1>(v) == 42, "");
+ }
+ {
+ std::variant<std::string, bool const> v = "foo";
+ assert(v.index() == 0);
+ assert(std::get<0>(v) == "foo");
+ }
+ {
+ std::variant<bool volatile, std::unique_ptr<int>> v = nullptr;
+ assert(v.index() == 1);
+ assert(std::get<1>(v) == nullptr);
+ }
+ {
+ std::variant<bool volatile const, int> v = true;
+ assert(v.index() == 0);
+ assert(std::get<0>(v));
+ }
+ {
+ std::variant<RValueConvertibleFrom<int>> v1 = 42;
+ assert(v1.index() == 0);
+
+ int x = 42;
+ std::variant<RValueConvertibleFrom<int>, AnyConstructible> v2 = x;
+ assert(v2.index() == 1);
+ }
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{
using V = std::variant<const int &, int &&, long>;
Index: test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
@@ -28,6 +28,7 @@
#include <string>
#include <type_traits>
#include <variant>
+#include <memory>
#include "test_macros.h"
#include "variant_test_helpers.hpp"
@@ -128,7 +129,7 @@
void test_T_assignment_sfinae() {
{
- using V = std::variant<long, unsigned>;
+ using V = std::variant<long, long long>;
static_assert(!std::is_assignable<V, int>::value, "ambiguous");
}
{
@@ -139,6 +140,31 @@
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, "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=");
+ struct X {
+ operator void*();
+ };
+ static_assert(!std::is_assignable<V, X>::value,
+ "no boolean conversion in operator=");
+ static_assert(!std::is_assignable<V, std::false_type>::value,
+ "no converted to bool in operator=");
+ }
+ {
+ struct X {};
+ struct Y {
+ operator X();
+ };
+ using V = std::variant<X>;
+ 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 &&>;
@@ -167,6 +193,37 @@
assert(v.index() == 1);
assert(std::get<1>(v) == 43);
}
+ {
+ std::variant<unsigned, long> v;
+ v = 42;
+ assert(v.index() == 1);
+ assert(std::get<1>(v) == 42);
+ v = 43u;
+ assert(v.index() == 0);
+ assert(std::get<0>(v) == 43);
+ }
+ {
+ std::variant<std::string, bool> v = true;
+ 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);
+ }
+ {
+ std::variant<bool volatile, int> v = 42;
+ v = false;
+ assert(v.index() == 0);
+ assert(!std::get<0>(v));
+ bool lvt = true;
+ v = lvt;
+ assert(v.index() == 0);
+ assert(std::get<0>(v));
+ }
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{
using V = std::variant<int &, int &&, long>;
Index: include/variant
===================================================================
--- include/variant
+++ include/variant
@@ -1098,11 +1098,39 @@
template <class _Tp, class... _Types>
struct __overload<_Tp, _Types...> : __overload<_Types...> {
using __overload<_Types...>::operator();
- __identity<_Tp> operator()(_Tp) const;
+
+ static auto __test(_Tp (&&)[1]) -> __identity<_Tp>;
+
+ template <class _Up>
+ auto operator()(_Tp, _Up&& __t) const
+ -> decltype(__test({ _VSTD::forward<_Up>(__t) }));
};
+template <class _Base, class _Tp>
+struct __overload_bool : _Base {
+ using _Base::operator();
+
+ template <class _Up, class _Ap = __uncvref_t<_Up>>
+ auto operator()(bool, _Up&&) const
+ -> enable_if_t<is_same_v<_Ap, bool>, __identity<_Tp>>;
+};
+
+template <class... _Types>
+struct __overload<bool, _Types...>
+ : __overload_bool<__overload<_Types...>, bool> {};
+template <class... _Types>
+struct __overload<bool const, _Types...>
+ : __overload_bool<__overload<_Types...>, bool const> {};
+template <class... _Types>
+struct __overload<bool volatile, _Types...>
+ : __overload_bool<__overload<_Types...>, bool volatile> {};
+template <class... _Types>
+struct __overload<bool const volatile, _Types...>
+ : __overload_bool<__overload<_Types...>, bool const volatile> {};
+
template <class _Tp, class... _Types>
-using __best_match_t = typename result_of_t<__overload<_Types...>(_Tp&&)>::type;
+using __best_match_t =
+ typename invoke_result_t<__overload<_Types...>, _Tp, _Tp>::type;
} // __variant_detail
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
