[clang-tools-extra] [compiler-rt] [libc] [lldb] [llvm] [libcxx] [clang] [flang] [libc++][variant] P2637R3: Member `visit` (`std::variant`) (PR #76447)
Hristo Hristov via cfe-commits
cfe-commits at lists.llvm.org
Fri Dec 29 22:25:27 PST 2023
https://github.com/H-G-Hristov updated https://github.com/llvm/llvm-project/pull/76447
>From f8c52dc689243062ca7627c3b6ca04bea69e67e9 Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Mon, 18 Dec 2023 14:46:15 +0200
Subject: [PATCH 01/13] [libc++][variant] P2637R3 - Member visit
---
libcxx/include/variant | 22 +++++++++++++++++++
.../variant/variant.visit/visit.pass.cpp | 3 +++
2 files changed, 25 insertions(+)
diff --git a/libcxx/include/variant b/libcxx/include/variant
index 3b01e5e126d9fa..c5810c218a43a7 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -69,6 +69,12 @@ namespace std {
// 20.7.2.6, swap
void swap(variant&) noexcept(see below);
+
+ // [variant.visit], visitation
+ template<class Self, class Visitor>
+ constexpr decltype(auto) visit(this Self&&, Visitor&&);
+ template<class R, class Self, class Visitor>
+ constexpr R visit(this Self&&, Visitor&&);
};
// 20.7.3, variant helper classes
@@ -235,6 +241,7 @@ namespace std {
#include <__type_traits/void_t.h>
#include <__utility/declval.h>
#include <__utility/forward.h>
+#include <__utility/forward_like.h>
#include <__utility/in_place.h>
#include <__utility/move.h>
#include <__utility/swap.h>
@@ -1490,6 +1497,21 @@ public:
__impl_.__swap(__that.__impl_);
}
+# if _LIBCPP_STD_VER >= 26
+ // [variant.visit], visitation
+ template <class _Self, class _Visitor>
+ constexpr decltype(auto) visit(this _Self&& __self, _Visitor&& __visitor) {
+ using _V = _OverrideRef<_Self&&, _CopyConst<remove_reference_t<_Self>, variant>>;
+ return std::visit(std::forward<_Visitor>(__visitor), (_V)__self);
+ }
+
+ template <class _R, class _Self, class _Visitor>
+ constexpr _R visit(this _Self&& __self, _Visitor&& __visitor) {
+ using _V = _OverrideRef<_Self&&, _CopyConst<remove_reference_t<_Self>, variant>>;
+ return std::visit<_R>(std::forward<_Visitor>(__visitor), (_V)__self);
+ }
+# endif
+
private:
__variant_detail::__impl<_Types...> __impl_;
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 097b784f2bf2ce..0dcda177ba3f8f 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -47,6 +47,9 @@ void test_call_operator_forwarding() {
assert(Fn::check_call<int &>(CT_NonConst | CT_RValue));
std::visit(std::move(cobj), v);
assert(Fn::check_call<int &>(CT_Const | CT_RValue));
+
+ v.visit(obj);
+ assert(Fn::check_call<int &>(CT_NonConst | CT_LValue));
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
>From 68075dde56db65d8bbde8660cafe8008eba17f46 Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Sun, 24 Dec 2023 09:35:42 +0200
Subject: [PATCH 02/13] WIP: Test via macro
---
libcxx/include/variant | 28 ++-
.../variant/variant.visit/visit.pass.cpp | 197 +++++++++++-------
2 files changed, 145 insertions(+), 80 deletions(-)
diff --git a/libcxx/include/variant b/libcxx/include/variant
index a4f8371ba6acdf..0da61901ce35ff 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -1283,16 +1283,10 @@ public:
# if _LIBCPP_STD_VER >= 26
// [variant.visit], visitation
template <class _Self, class _Visitor>
- constexpr decltype(auto) visit(this _Self&& __self, _Visitor&& __visitor) {
- using _V = _OverrideRef<_Self&&, _CopyConst<remove_reference_t<_Self>, variant>>;
- return std::visit(std::forward<_Visitor>(__visitor), (_V)__self);
- }
+ constexpr decltype(auto) visit(this _Self&& __self, _Visitor&& __visitor);
template <class _R, class _Self, class _Visitor>
- constexpr _R visit(this _Self&& __self, _Visitor&& __visitor) {
- using _V = _OverrideRef<_Self&&, _CopyConst<remove_reference_t<_Self>, variant>>;
- return std::visit<_R>(std::forward<_Visitor>(__visitor), (_V)__self);
- }
+ constexpr _R visit(this _Self&& __self, _Visitor&& __visitor);
# endif
private:
@@ -1554,6 +1548,24 @@ visit(_Visitor&& __visitor, _Vs&&... __vs) {
}
# endif
+# if _LIBCPP_STD_VER >= 26
+// [variant.visit], visitation
+
+template <class... _Types>
+template <class _Self, class _Visitor>
+constexpr decltype(auto) variant<_Types...>::visit(this _Self&& __self, _Visitor&& __visitor) {
+ using _V = _OverrideRef<_Self&&, _CopyConst<remove_reference_t<_Self>, variant>>;
+ return std::visit(std::forward<_Visitor>(__visitor), (_V)__self);
+}
+
+template <class... _Types>
+template <class _Rp, class _Self, class _Visitor>
+constexpr _Rp variant<_Types...>::visit(this _Self&& __self, _Visitor&& __visitor) {
+ using _V = _OverrideRef<_Self&&, _CopyConst<remove_reference_t<_Self>, variant>>;
+ return std::visit<_Rp>(std::forward<_Visitor>(__visitor), (_V)__self);
+}
+# endif
+
template <class... _Types>
_LIBCPP_HIDE_FROM_ABI auto
swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs) noexcept(noexcept(__lhs.swap(__rhs)))
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 0dcda177ba3f8f..b46924683af66e 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -22,10 +22,22 @@
#include "test_macros.h"
#include "variant_test_helpers.h"
+#if _LIBCPP_STD_VER >= 26
+# define TEST_VISIT(object, variants, expectedValue, type, ...) \
+ std::visit(object, variants); \
+ assert(Fn::check_call<type __VA_OPT__(, ) __VA_ARGS__>(expectedValue)); \
+ variants.visit(object); \
+ assert(Fn::check_call<type __VA_OPT__(, ) __VA_ARGS__>(expectedValue));
+#else
+# define TEST_VISIT(object, variants, expectedValue, type, ...) \
+ std::visit(object, variants); \
+ assert(Fn::check_call<type __VA_OPT__(, ) __VA_ARGS__>(expectedValue));
+#endif
+
void test_call_operator_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
- const Fn &cobj = obj;
+ const Fn& cobj = obj;
{ // test call operator forwarding - no variant
std::visit(obj);
assert(Fn::check_call<>(CT_NonConst | CT_LValue));
@@ -39,67 +51,108 @@ void test_call_operator_forwarding() {
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
+
+ // non-member
std::visit(obj, v);
- assert(Fn::check_call<int &>(CT_NonConst | CT_LValue));
+ assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
std::visit(cobj, v);
- assert(Fn::check_call<int &>(CT_Const | CT_LValue));
+ assert(Fn::check_call<int&>(CT_Const | CT_LValue));
std::visit(std::move(obj), v);
- assert(Fn::check_call<int &>(CT_NonConst | CT_RValue));
+ assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
std::visit(std::move(cobj), v);
- assert(Fn::check_call<int &>(CT_Const | CT_RValue));
+ assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+ // member
+#if _LIBCPP_STD_VER >= 26
v.visit(obj);
- assert(Fn::check_call<int &>(CT_NonConst | CT_LValue));
+ assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
+ v.visit(cobj);
+ assert(Fn::check_call<int&>(CT_Const | CT_LValue));
+ v.visit(std::move(obj));
+ assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
+ v.visit(std::move(cobj));
+ assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+#endif
+
+#define TEST_VISIT1(type, object, variants, expectedValue) \
+ std::visit(object, variants); \
+ assert(Fn::check_call<type&>(expectedValue)); \
+ variants.visit(object); \
+ assert(Fn::check_call<type&>(expectedValue));
+
+ TEST_VISIT1(int, obj, v, (CT_NonConst | CT_LValue));
+ TEST_VISIT1(int, cobj, v, (CT_Const | CT_LValue));
+ TEST_VISIT1(int, std::move(obj), v, (CT_NonConst | CT_RValue));
+ TEST_VISIT1(int, std::move(cobj), v, (CT_Const | CT_RValue));
+
+ TEST_VISIT(obj, v, (CT_NonConst | CT_LValue), int&);
+ TEST_VISIT(cobj, v, (CT_Const | CT_LValue), int&);
+ TEST_VISIT(std::move(obj), v, (CT_NonConst | CT_RValue), int&);
+ TEST_VISIT(std::move(cobj), v, (CT_Const | CT_RValue), int&);
+
+ // TEST_VISIT2(td::move(cobj), v, (CT_Const | CT_RValue), int&, long&, float&);
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
V v(42l);
std::visit(obj, v);
- assert(Fn::check_call<long &>(CT_NonConst | CT_LValue));
+ assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
std::visit(cobj, v);
- assert(Fn::check_call<long &>(CT_Const | CT_LValue));
+ assert(Fn::check_call<long&>(CT_Const | CT_LValue));
std::visit(std::move(obj), v);
- assert(Fn::check_call<long &>(CT_NonConst | CT_RValue));
+ assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
std::visit(std::move(cobj), v);
- assert(Fn::check_call<long &>(CT_Const | CT_RValue));
+ assert(Fn::check_call<long&>(CT_Const | CT_RValue));
+
+ TEST_VISIT(obj, v, (CT_NonConst | CT_LValue), long&);
+ TEST_VISIT(cobj, v, (CT_Const | CT_LValue), long&);
+ TEST_VISIT(std::move(obj), v, (CT_NonConst | CT_RValue), long&);
+ TEST_VISIT(std::move(cobj), v, (CT_Const | CT_RValue), long&);
}
{ // test call operator forwarding - multi variant, multi arg
- using V = std::variant<int, long, double>;
- using V2 = std::variant<int *, std::string>;
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int*, std::string>;
V v(42l);
V2 v2("hello");
std::visit(obj, v, v2);
- assert((Fn::check_call<long &, std::string &>(CT_NonConst | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_LValue)));
std::visit(cobj, v, v2);
- assert((Fn::check_call<long &, std::string &>(CT_Const | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_LValue)));
std::visit(std::move(obj), v, v2);
- assert((Fn::check_call<long &, std::string &>(CT_NonConst | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
std::visit(std::move(cobj), v, v2);
- assert((Fn::check_call<long &, std::string &>(CT_Const | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
+
+ TEST_VISIT(obj, v, v2, CT_NonConst | CT_LValue)));
+ TEST_VISIT(cobj, v, v2, (CT_Const | CT_LValue)));
+ TEST_VISIT(std::move(obj), v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
+ TEST_VISIT(std::move(cobj), v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
}
{
using V = std::variant<int, long, double, std::string>;
V v1(42l), v2("hello"), v3(101), v4(1.1);
std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int &, double &>(CT_NonConst | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_LValue)));
std::visit(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int &, double &>(CT_Const | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_LValue)));
std::visit(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int &, double &>(CT_NonConst | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_RValue)));
std::visit(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int &, double &>(CT_Const | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_RValue)));
}
{
using V = std::variant<int, long, double, int*, std::string>;
V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_NonConst | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_LValue)));
std::visit(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_Const | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_LValue)));
std::visit(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_NonConst | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_RValue)));
std::visit(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_Const | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_RValue)));
}
}
@@ -110,76 +163,76 @@ void test_argument_forwarding() {
{ // single argument - value type
using V = std::variant<int>;
V v(42);
- const V &cv = v;
+ const V& cv = v;
std::visit(obj, v);
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit(obj, cv);
- assert(Fn::check_call<const int &>(Val));
+ assert(Fn::check_call<const int&>(Val));
std::visit(obj, std::move(v));
- assert(Fn::check_call<int &&>(Val));
+ assert(Fn::check_call<int&&>(Val));
std::visit(obj, std::move(cv));
- assert(Fn::check_call<const int &&>(Val));
+ assert(Fn::check_call<const int&&>(Val));
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{ // single argument - lvalue reference
- using V = std::variant<int &>;
- int x = 42;
+ using V = std::variant<int&>;
+ int x = 42;
V v(x);
- const V &cv = v;
+ const V& cv = v;
std::visit(obj, v);
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit(obj, cv);
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit(obj, std::move(v));
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit(obj, std::move(cv));
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
}
{ // single argument - rvalue reference
- using V = std::variant<int &&>;
- int x = 42;
+ using V = std::variant<int&&>;
+ int x = 42;
V v(std::move(x));
- const V &cv = v;
+ const V& cv = v;
std::visit(obj, v);
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit(obj, cv);
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit(obj, std::move(v));
- assert(Fn::check_call<int &&>(Val));
+ assert(Fn::check_call<int&&>(Val));
std::visit(obj, std::move(cv));
- assert(Fn::check_call<int &&>(Val));
+ assert(Fn::check_call<int&&>(Val));
}
#endif
{ // multi argument - multi variant
using V = std::variant<int, std::string, long>;
V v1(42), v2("hello"), v3(43l);
std::visit(obj, v1, v2, v3);
- assert((Fn::check_call<int &, std::string &, long &>(Val)));
+ assert((Fn::check_call<int&, std::string&, long&>(Val)));
std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
- assert((Fn::check_call<const int &, const std::string &, long &&>(Val)));
+ assert((Fn::check_call<const int&, const std::string&, long&&>(Val)));
}
{
using V = std::variant<int, long, double, std::string>;
V v1(42l), v2("hello"), v3(101), v4(1.1);
std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int &, double &>(Val)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(Val)));
std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long &, const std::string &, int &&, double &&>(Val)));
+ assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(Val)));
}
{
using V = std::variant<int, long, double, int*, std::string>;
V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int *&, double &>(Val)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(Val)));
std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long &, const std::string &, int *&&, double &&>(Val)));
+ assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(Val)));
}
}
void test_return_type() {
using Fn = ForwardingCallObject;
Fn obj{};
- const Fn &cobj = obj;
+ const Fn& cobj = obj;
{ // test call operator forwarding - no variant
static_assert(std::is_same_v<decltype(std::visit(obj)), Fn&>);
static_assert(std::is_same_v<decltype(std::visit(cobj)), const Fn&>);
@@ -203,8 +256,8 @@ void test_return_type() {
static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
}
{ // test call operator forwarding - multi variant, multi arg
- using V = std::variant<int, long, double>;
- using V2 = std::variant<int *, std::string>;
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int*, std::string>;
V v(42l);
V2 v2("hello");
static_assert(std::is_same_v<decltype(std::visit(obj, v, v2)), Fn&>);
@@ -245,7 +298,7 @@ void test_constexpr() {
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char *, long long>;
+ using V2 = std::variant<int, char*, long long>;
using V3 = std::variant<bool, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
@@ -254,20 +307,20 @@ void test_constexpr() {
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char *, long long>;
- using V3 = std::variant<void *, int, int>;
+ using V2 = std::variant<int, char*, long long>;
+ using V3 = std::variant<void*, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
static_assert(std::visit(aobj, v1, v2, v3) == 3, "");
}
{
- using V = std::variant<int, long, double, int *>;
+ using V = std::variant<int, long, double, int*>;
constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, "");
}
{
- using V = std::variant<int, long, double, long long, int *>;
+ using V = std::variant<int, long, double, long long, int*>;
constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, "");
}
@@ -276,10 +329,10 @@ void test_constexpr() {
void test_exceptions() {
#ifndef TEST_HAS_NO_EXCEPTIONS
ReturnArity obj{};
- auto test = [&](auto &&... args) {
+ auto test = [&](auto&&... args) {
try {
std::visit(obj, args...);
- } catch (const std::bad_variant_access &) {
+ } catch (const std::bad_variant_access&) {
return true;
} catch (...) {
}
@@ -292,24 +345,24 @@ void test_exceptions() {
assert(test(v));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void *>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*>;
V v;
makeEmpty(v);
V2 v2("hello");
assert(test(v, v2));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void *>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*>;
V v;
makeEmpty(v);
V2 v2("hello");
assert(test(v2, v));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void *, MakeEmptyT>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*, MakeEmptyT>;
V v;
makeEmpty(v);
V2 v2;
@@ -354,7 +407,7 @@ void get(const MyVariant&) {
} // namespace std
void test_derived_from_variant() {
- auto v1 = MyVariant{42};
+ auto v1 = MyVariant{42};
const auto cv1 = MyVariant{142};
std::visit([](auto x) { assert(x == 42); }, v1);
std::visit([](auto x) { assert(x == 142); }, cv1);
@@ -368,9 +421,7 @@ void test_derived_from_variant() {
char valueless_by_exception;
};
- struct EvilVariant1 : std::variant<int, long, double>,
- std::tuple<int>,
- EvilVariantBase {
+ struct EvilVariant1 : std::variant<int, long, double>, std::tuple<int>, EvilVariantBase {
using std::variant<int, long, double>::variant;
};
@@ -380,7 +431,10 @@ void test_derived_from_variant() {
// Check that visit unambiguously picks the variant, even if the other base has __impl member.
struct ImplVariantBase {
struct Callable {
- bool operator()() const { assert(false); return false; }
+ bool operator()() const {
+ assert(false);
+ return false;
+ }
};
Callable __impl;
@@ -399,8 +453,7 @@ struct any_visitor {
void operator()(const T&) const {}
};
-template <typename T, typename = decltype(std::visit(
- std::declval<any_visitor&>(), std::declval<T>()))>
+template <typename T, typename = decltype(std::visit(std::declval<any_visitor&>(), std::declval<T>()))>
constexpr bool has_visit(int) {
return true;
}
>From 0bc0832e848bd01c40337dab9344aa506501a792 Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Sun, 24 Dec 2023 09:43:27 +0200
Subject: [PATCH 03/13] WIP: visit.pass
---
.../variant/variant.visit/visit.pass.cpp | 115 +++++++-----------
1 file changed, 47 insertions(+), 68 deletions(-)
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index b46924683af66e..3fac6b21f2682a 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -22,18 +22,6 @@
#include "test_macros.h"
#include "variant_test_helpers.h"
-#if _LIBCPP_STD_VER >= 26
-# define TEST_VISIT(object, variants, expectedValue, type, ...) \
- std::visit(object, variants); \
- assert(Fn::check_call<type __VA_OPT__(, ) __VA_ARGS__>(expectedValue)); \
- variants.visit(object); \
- assert(Fn::check_call<type __VA_OPT__(, ) __VA_ARGS__>(expectedValue));
-#else
-# define TEST_VISIT(object, variants, expectedValue, type, ...) \
- std::visit(object, variants); \
- assert(Fn::check_call<type __VA_OPT__(, ) __VA_ARGS__>(expectedValue));
-#endif
-
void test_call_operator_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
@@ -51,63 +39,61 @@ void test_call_operator_forwarding() {
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
-
- // non-member
- std::visit(obj, v);
- assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
- std::visit(cobj, v);
- assert(Fn::check_call<int&>(CT_Const | CT_LValue));
- std::visit(std::move(obj), v);
- assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
- std::visit(std::move(cobj), v);
- assert(Fn::check_call<int&>(CT_Const | CT_RValue));
-
- // member
#if _LIBCPP_STD_VER >= 26
- v.visit(obj);
- assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
- v.visit(cobj);
- assert(Fn::check_call<int&>(CT_Const | CT_LValue));
- v.visit(std::move(obj));
- assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
- v.visit(std::move(cobj));
- assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+ // member
+ {
+ v.visit(obj);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
+ v.visit(cobj);
+ assert(Fn::check_call<int&>(CT_Const | CT_LValue));
+ v.visit(std::move(obj));
+ assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
+ v.visit(std::move(cobj));
+ assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+ }
#endif
-#define TEST_VISIT1(type, object, variants, expectedValue) \
- std::visit(object, variants); \
- assert(Fn::check_call<type&>(expectedValue)); \
- variants.visit(object); \
- assert(Fn::check_call<type&>(expectedValue));
-
- TEST_VISIT1(int, obj, v, (CT_NonConst | CT_LValue));
- TEST_VISIT1(int, cobj, v, (CT_Const | CT_LValue));
- TEST_VISIT1(int, std::move(obj), v, (CT_NonConst | CT_RValue));
- TEST_VISIT1(int, std::move(cobj), v, (CT_Const | CT_RValue));
-
- TEST_VISIT(obj, v, (CT_NonConst | CT_LValue), int&);
- TEST_VISIT(cobj, v, (CT_Const | CT_LValue), int&);
- TEST_VISIT(std::move(obj), v, (CT_NonConst | CT_RValue), int&);
- TEST_VISIT(std::move(cobj), v, (CT_Const | CT_RValue), int&);
-
- // TEST_VISIT2(td::move(cobj), v, (CT_Const | CT_RValue), int&, long&, float&);
+ // non-member
+ {
+ std::visit(obj, v);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
+ std::visit(cobj, v);
+ assert(Fn::check_call<int&>(CT_Const | CT_LValue));
+ std::visit(std::move(obj), v);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
+ std::visit(std::move(cobj), v);
+ assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+ }
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
V v(42l);
- std::visit(obj, v);
- assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
- std::visit(cobj, v);
- assert(Fn::check_call<long&>(CT_Const | CT_LValue));
- std::visit(std::move(obj), v);
- assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
- std::visit(std::move(cobj), v);
- assert(Fn::check_call<long&>(CT_Const | CT_RValue));
- TEST_VISIT(obj, v, (CT_NonConst | CT_LValue), long&);
- TEST_VISIT(cobj, v, (CT_Const | CT_LValue), long&);
- TEST_VISIT(std::move(obj), v, (CT_NonConst | CT_RValue), long&);
- TEST_VISIT(std::move(cobj), v, (CT_Const | CT_RValue), long&);
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit(obj);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
+ v.visit(cobj);
+ assert(Fn::check_call<long&>(CT_Const | CT_LValue));
+ v.visit(std::move(obj));
+ assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
+ v.visit(std::move(cobj));
+ assert(Fn::check_call<long&>(CT_Const | CT_RValue));
+ }
+#endif
+
+ // non-member
+ {
+ std::visit(obj, v);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
+ std::visit(cobj, v);
+ assert(Fn::check_call<long&>(CT_Const | CT_LValue));
+ std::visit(std::move(obj), v);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
+ std::visit(std::move(cobj), v);
+ assert(Fn::check_call<long&>(CT_Const | CT_RValue));
+ }
}
{ // test call operator forwarding - multi variant, multi arg
using V = std::variant<int, long, double>;
@@ -122,13 +108,6 @@ void test_call_operator_forwarding() {
assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
std::visit(std::move(cobj), v, v2);
assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
-
- TEST_VISIT(obj, v, v2, CT_NonConst | CT_LValue)));
- TEST_VISIT(cobj, v, v2, (CT_Const | CT_LValue)));
- TEST_VISIT(std::move(obj), v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
- TEST_VISIT(std::move(cobj), v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
}
{
using V = std::variant<int, long, double, std::string>;
>From 1de898e6d27795b159526055b400e68faa7aff11 Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Sun, 24 Dec 2023 10:09:54 +0200
Subject: [PATCH 04/13] template_argument
---
libcxx/docs/Status/Cxx2c.rst | 2 +
libcxx/docs/Status/Cxx2cPapers.csv | 2 +-
.../variant.visit/robust_against_adl.pass.cpp | 54 ++--
.../variant/variant.visit/visit.pass.cpp | 264 ++++++++++++------
.../variant.visit/visit_return_type.pass.cpp | 206 ++++++++------
.../generate_feature_test_macro_components.py | 6 +-
6 files changed, 348 insertions(+), 186 deletions(-)
diff --git a/libcxx/docs/Status/Cxx2c.rst b/libcxx/docs/Status/Cxx2c.rst
index a7ebc4662f517c..5c700d2cb0d6d3 100644
--- a/libcxx/docs/Status/Cxx2c.rst
+++ b/libcxx/docs/Status/Cxx2c.rst
@@ -40,6 +40,8 @@ Paper Status
.. note::
.. [#note-P2510R3] This paper is applied as DR against C++20. (MSVC STL and libstdc++ will do the same.)
+ .. [#note-P2637R3] P2637R3: Implemented `variant` member `visit`
+
.. _issues-status-cxx2c:
diff --git a/libcxx/docs/Status/Cxx2cPapers.csv b/libcxx/docs/Status/Cxx2cPapers.csv
index ff83648aa76830..a3214ab2bfe75c 100644
--- a/libcxx/docs/Status/Cxx2cPapers.csv
+++ b/libcxx/docs/Status/Cxx2cPapers.csv
@@ -17,7 +17,7 @@
"`P0792R14 <https://wg21.link/P0792R14>`__","LWG","``function_ref``: a type-erased callable reference","Varna June 2023","","",""
"`P2874R2 <https://wg21.link/P2874R2>`__","LWG","Mandating Annex D Require No More","Varna June 2023","","",""
"`P2757R3 <https://wg21.link/P2757R3>`__","LWG","Type-checking format args","Varna June 2023","","","|format|"
-"`P2637R3 <https://wg21.link/P2637R3>`__","LWG","Member ``visit``","Varna June 2023","","","|format|"
+"`P2637R3 <https://wg21.link/P2637R3>`__","LWG","Member ``visit``","Varna June 2023","|Partial| [#note-P2637R3]","18.0",""
"`P2641R4 <https://wg21.link/P2641R4>`__","CWG, LWG","Checking if a ``union`` alternative is active","Varna June 2023","","",""
"`P1759R6 <https://wg21.link/P1759R6>`__","LWG","Native handles and file streams","Varna June 2023","","",""
"`P2697R1 <https://wg21.link/P2697R1>`__","LWG","Interfacing ``bitset`` with ``string_view``","Varna June 2023","|Complete|","18.0",""
diff --git a/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
index 6f17fa32648d41..6f095891693867 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
@@ -9,6 +9,13 @@
// UNSUPPORTED: c++03, c++11, c++14
// <variant>
+
+// class variant;
+// template<class Self, class Visitor>
+// constexpr decltype(auto) visit(this Self&&, Visitor&&); //since C++26
+// template<class R, class Self, class Visitor>
+// constexpr R visit(this Self&&, Visitor&&); // since C++26
+
// template <class Visitor, class... Variants>
// constexpr see below visit(Visitor&& vis, Variants&&... vars);
@@ -17,27 +24,42 @@
#include "test_macros.h"
struct Incomplete;
-template<class T> struct Holder { T t; };
-
-constexpr bool test(bool do_it)
-{
- if (do_it) {
- std::variant<Holder<Incomplete>*, int> v = nullptr;
- std::visit([](auto){}, v);
- std::visit([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
+template <class T>
+struct Holder {
+ T t;
+};
+
+constexpr bool test(bool do_it) {
+ if (do_it) {
+ std::variant<Holder<Incomplete>*, int> v = nullptr;
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit([](auto) {});
+ v.visit([](auto) -> Holder<Incomplete>* { return nullptr; });
+ v.visit<void>([](auto) {});
+ v.visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; });
+ }
+#endif
+
+ // non-member
+ {
+ std::visit([](auto) {}, v);
+ std::visit([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
#if TEST_STD_VER > 17
- std::visit<void>([](auto){}, v);
- std::visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
+ std::visit<void>([](auto) {}, v);
+ std::visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
#endif
}
- return true;
+ }
+ return true;
}
-int main(int, char**)
-{
- test(true);
+int main(int, char**) {
+ test(true);
#if TEST_STD_VER > 17
- static_assert(test(true));
+ static_assert(test(true));
#endif
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 3fac6b21f2682a..72c9ca22802194 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -9,6 +9,13 @@
// UNSUPPORTED: c++03, c++11, c++14
// <variant>
+
+// class variant;
+// template<class Self, class Visitor>
+// constexpr decltype(auto) visit(this Self&&, Visitor&&); //since C++26
+// template<class R, class Self, class Visitor>
+// constexpr R visit(this Self&&, Visitor&&); // since C++26
+
// template <class Visitor, class... Variants>
// constexpr see below visit(Visitor&& vis, Variants&&... vars);
@@ -26,19 +33,24 @@ void test_call_operator_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
const Fn& cobj = obj;
+
{ // test call operator forwarding - no variant
- std::visit(obj);
- assert(Fn::check_call<>(CT_NonConst | CT_LValue));
- std::visit(cobj);
- assert(Fn::check_call<>(CT_Const | CT_LValue));
- std::visit(std::move(obj));
- assert(Fn::check_call<>(CT_NonConst | CT_RValue));
- std::visit(std::move(cobj));
- assert(Fn::check_call<>(CT_Const | CT_RValue));
+ // non-member
+ {
+ std::visit(obj);
+ assert(Fn::check_call<>(CT_NonConst | CT_LValue));
+ std::visit(cobj);
+ assert(Fn::check_call<>(CT_Const | CT_LValue));
+ std::visit(std::move(obj));
+ assert(Fn::check_call<>(CT_NonConst | CT_RValue));
+ std::visit(std::move(cobj));
+ assert(Fn::check_call<>(CT_Const | CT_RValue));
+ }
}
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
+
#if _LIBCPP_STD_VER >= 26
// member
{
@@ -67,7 +79,7 @@ void test_call_operator_forwarding() {
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
- V v(42l);
+ V v(42L);
#if _LIBCPP_STD_VER >= 26
// member
@@ -98,59 +110,77 @@ void test_call_operator_forwarding() {
{ // test call operator forwarding - multi variant, multi arg
using V = std::variant<int, long, double>;
using V2 = std::variant<int*, std::string>;
- V v(42l);
+ V v(42L);
V2 v2("hello");
- std::visit(obj, v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_LValue)));
- std::visit(cobj, v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_Const | CT_LValue)));
- std::visit(std::move(obj), v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
- std::visit(std::move(cobj), v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
+
+ // non-member
+ {
+ std::visit(obj, v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_LValue)));
+ std::visit(cobj, v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_LValue)));
+ std::visit(std::move(obj), v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
+ std::visit(std::move(cobj), v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
+ }
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42l), v2("hello"), v3(101), v4(1.1);
- std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_LValue)));
- std::visit(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_LValue)));
- std::visit(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_RValue)));
- std::visit(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_RValue)));
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
+
+ // non-member
+ {
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_LValue)));
+ std::visit(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_LValue)));
+ std::visit(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_RValue)));
+ std::visit(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_RValue)));
+ }
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
- std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_LValue)));
- std::visit(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_LValue)));
- std::visit(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_RValue)));
- std::visit(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_RValue)));
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
+
+ // non-member
+ {
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_LValue)));
+ std::visit(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_LValue)));
+ std::visit(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_RValue)));
+ std::visit(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_RValue)));
+ }
}
}
+// Applies to non-member `std::visit` only.
void test_argument_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
const auto Val = CT_LValue | CT_NonConst;
+
{ // single argument - value type
using V = std::variant<int>;
V v(42);
const V& cv = v;
- std::visit(obj, v);
- assert(Fn::check_call<int&>(Val));
- std::visit(obj, cv);
- assert(Fn::check_call<const int&>(Val));
- std::visit(obj, std::move(v));
- assert(Fn::check_call<int&&>(Val));
- std::visit(obj, std::move(cv));
- assert(Fn::check_call<const int&&>(Val));
+
+ // non-member
+ {
+ std::visit(obj, v);
+ assert(Fn::check_call<int&>(Val));
+ std::visit(obj, cv);
+ assert(Fn::check_call<const int&>(Val));
+ std::visit(obj, std::move(v));
+ assert(Fn::check_call<int&&>(Val));
+ std::visit(obj, std::move(cv));
+ assert(Fn::check_call<const int&&>(Val));
+ }
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{ // single argument - lvalue reference
@@ -158,6 +188,7 @@ void test_argument_forwarding() {
int x = 42;
V v(x);
const V& cv = v;
+
std::visit(obj, v);
assert(Fn::check_call<int&>(Val));
std::visit(obj, cv);
@@ -172,6 +203,7 @@ void test_argument_forwarding() {
int x = 42;
V v(std::move(x));
const V& cv = v;
+
std::visit(obj, v);
assert(Fn::check_call<int&>(Val));
std::visit(obj, cv);
@@ -184,7 +216,8 @@ void test_argument_forwarding() {
#endif
{ // multi argument - multi variant
using V = std::variant<int, std::string, long>;
- V v1(42), v2("hello"), v3(43l);
+ V v1(42), v2("hello"), v3(43L);
+
std::visit(obj, v1, v2, v3);
assert((Fn::check_call<int&, std::string&, long&>(Val)));
std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
@@ -193,6 +226,7 @@ void test_argument_forwarding() {
{
using V = std::variant<int, long, double, std::string>;
V v1(42l), v2("hello"), v3(101), v4(1.1);
+
std::visit(obj, v1, v2, v3, v4);
assert((Fn::check_call<long&, std::string&, int&, double&>(Val)));
std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
@@ -201,6 +235,7 @@ void test_argument_forwarding() {
{
using V = std::variant<int, long, double, int*, std::string>;
V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+
std::visit(obj, v1, v2, v3, v4);
assert((Fn::check_call<long&, std::string&, int*&, double&>(Val)));
std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
@@ -212,6 +247,7 @@ void test_return_type() {
using Fn = ForwardingCallObject;
Fn obj{};
const Fn& cobj = obj;
+
{ // test call operator forwarding - no variant
static_assert(std::is_same_v<decltype(std::visit(obj)), Fn&>);
static_assert(std::is_same_v<decltype(std::visit(cobj)), const Fn&>);
@@ -221,59 +257,114 @@ void test_return_type() {
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
- static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ static_assert(std::is_same_v<decltype(v.visit(obj)), Fn&>);
+ static_assert(std::is_same_v<decltype(v.visit(cobj)), const Fn&>);
+ static_assert(std::is_same_v<decltype(v.visit(std::move(obj))), Fn&&>);
+ static_assert(std::is_same_v<decltype(v.visit(std::move(cobj))), const Fn&&>);
+ }
+#endif
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
+ }
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
- V v(42l);
- static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
+ V v(42L);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ static_assert(std::is_same_v<decltype(v.visit(obj)), Fn&>);
+ static_assert(std::is_same_v<decltype(v.visit(cobj)), const Fn&>);
+ static_assert(std::is_same_v<decltype(v.visit(std::move(obj))), Fn&&>);
+ static_assert(std::is_same_v<decltype(v.visit(std::move(cobj))), const Fn&&>);
+ }
+#endif
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
+ }
}
{ // test call operator forwarding - multi variant, multi arg
using V = std::variant<int, long, double>;
using V2 = std::variant<int*, std::string>;
- V v(42l);
+ V v(42L);
V2 v2("hello");
- static_assert(std::is_same_v<decltype(std::visit(obj, v, v2)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj, v, v2)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v, v2)), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v, v2)), const Fn&&>);
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj, v, v2)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v, v2)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v, v2)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v, v2)), const Fn&&>);
+ }
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42l), v2("hello"), v3(101), v4(1.1);
- static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
+ }
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
- static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
+ }
}
}
void test_constexpr() {
constexpr ReturnFirst obj{};
constexpr ReturnArity aobj{};
+
{
using V = std::variant<int>;
constexpr V v(42);
- static_assert(std::visit(obj, v) == 42, "");
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert(v.visit(obj) == 42); }
+#endif
+
+ //non-member
+ { static_assert(std::visit(obj, v) == 42, ""); }
}
{
using V = std::variant<short, long, char>;
- constexpr V v(42l);
- static_assert(std::visit(obj, v) == 42, "");
+ constexpr V v(42L);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert(v.visit(obj) == 42); }
+#endif
+
+ //non-member
+ { static_assert(std::visit(obj, v) == 42, ""); }
}
{
using V1 = std::variant<int>;
@@ -282,7 +373,9 @@ void test_constexpr() {
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
- static_assert(std::visit(aobj, v1, v2, v3) == 3, "");
+
+ //non-member
+ { static_assert(std::visit(aobj, v1, v2, v3) == 3, ""); }
}
{
using V1 = std::variant<int>;
@@ -291,17 +384,23 @@ void test_constexpr() {
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
- static_assert(std::visit(aobj, v1, v2, v3) == 3, "");
+
+ //non-member
+ { static_assert(std::visit(aobj, v1, v2, v3) == 3, ""); }
}
{
using V = std::variant<int, long, double, int*>;
- constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
- static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, "");
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
+ //non-member
+ { static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, ""); }
}
{
using V = std::variant<int, long, double, long long, int*>;
- constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
- static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, "");
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
+ //non-member
+ { static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, ""); }
}
}
@@ -373,7 +472,14 @@ void test_caller_accepts_nonconst() {
void operator()(A&) {}
};
std::variant<A> v;
- std::visit(Visitor{}, v);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { v.visit(Visitor{}); }
+#endif
+
+ //non-member
+ { std::visit(Visitor{}, v); }
}
struct MyVariant : std::variant<short, long, float> {};
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
index eb425c07f93222..f8cdb70a28fa3b 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
@@ -9,6 +9,13 @@
// UNSUPPORTED: c++03, c++11, c++14, c++17
// <variant>
+
+// class variant;
+// template<class Self, class Visitor>
+// constexpr decltype(auto) visit(this Self&&, Visitor&&); //since C++26
+// template<class R, class Self, class Visitor>
+// constexpr R visit(this Self&&, Visitor&&); // since C++26
+
// template <class R, class Visitor, class... Variants>
// constexpr R visit(Visitor&& vis, Variants&&... vars);
@@ -26,78 +33,100 @@ template <typename ReturnType>
void test_call_operator_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
- const Fn &cobj = obj;
+ const Fn& cobj = obj;
+
{ // test call operator forwarding - no variant
- std::visit<ReturnType>(obj);
- assert(Fn::check_call<>(CT_NonConst | CT_LValue));
- std::visit<ReturnType>(cobj);
- assert(Fn::check_call<>(CT_Const | CT_LValue));
- std::visit<ReturnType>(std::move(obj));
- assert(Fn::check_call<>(CT_NonConst | CT_RValue));
- std::visit<ReturnType>(std::move(cobj));
- assert(Fn::check_call<>(CT_Const | CT_RValue));
+ // non-member
+ {
+ std::visit<ReturnType>(obj);
+ assert(Fn::check_call<>(CT_NonConst | CT_LValue));
+ std::visit<ReturnType>(cobj);
+ assert(Fn::check_call<>(CT_Const | CT_LValue));
+ std::visit<ReturnType>(std::move(obj));
+ assert(Fn::check_call<>(CT_NonConst | CT_RValue));
+ std::visit<ReturnType>(std::move(cobj));
+ assert(Fn::check_call<>(CT_Const | CT_RValue));
+ }
}
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
- std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int &>(CT_NonConst | CT_LValue));
- std::visit<ReturnType>(cobj, v);
- assert(Fn::check_call<int &>(CT_Const | CT_LValue));
- std::visit<ReturnType>(std::move(obj), v);
- assert(Fn::check_call<int &>(CT_NonConst | CT_RValue));
- std::visit<ReturnType>(std::move(cobj), v);
- assert(Fn::check_call<int &>(CT_Const | CT_RValue));
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
+ v.visit<ReturnType>(cobj);
+ assert(Fn::check_call<int&>(CT_Const | CT_LValue));
+ v.visit<ReturnType>(std::move(obj));
+ assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
+ v.visit<ReturnType>(std::move(cobj));
+ assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+ }
+#endif
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
+ std::visit<ReturnType>(cobj, v);
+ assert(Fn::check_call<int&>(CT_Const | CT_LValue));
+ std::visit<ReturnType>(std::move(obj), v);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
+ std::visit<ReturnType>(std::move(cobj), v);
+ assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+ }
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
V v(42l);
std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<long &>(CT_NonConst | CT_LValue));
+ assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
std::visit<ReturnType>(cobj, v);
- assert(Fn::check_call<long &>(CT_Const | CT_LValue));
+ assert(Fn::check_call<long&>(CT_Const | CT_LValue));
std::visit<ReturnType>(std::move(obj), v);
- assert(Fn::check_call<long &>(CT_NonConst | CT_RValue));
+ assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
std::visit<ReturnType>(std::move(cobj), v);
- assert(Fn::check_call<long &>(CT_Const | CT_RValue));
+ assert(Fn::check_call<long&>(CT_Const | CT_RValue));
}
{ // test call operator forwarding - multi variant, multi arg
- using V = std::variant<int, long, double>;
- using V2 = std::variant<int *, std::string>;
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int*, std::string>;
V v(42l);
V2 v2("hello");
std::visit<int>(obj, v, v2);
- assert((Fn::check_call<long &, std::string &>(CT_NonConst | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_LValue)));
std::visit<ReturnType>(cobj, v, v2);
- assert((Fn::check_call<long &, std::string &>(CT_Const | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_LValue)));
std::visit<ReturnType>(std::move(obj), v, v2);
- assert((Fn::check_call<long &, std::string &>(CT_NonConst | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
std::visit<ReturnType>(std::move(cobj), v, v2);
- assert((Fn::check_call<long &, std::string &>(CT_Const | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
}
{
using V = std::variant<int, long, double, std::string>;
V v1(42l), v2("hello"), v3(101), v4(1.1);
std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int &, double &>(CT_NonConst | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_LValue)));
std::visit<ReturnType>(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int &, double &>(CT_Const | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_LValue)));
std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int &, double &>(CT_NonConst | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_RValue)));
std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int &, double &>(CT_Const | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_RValue)));
}
{
using V = std::variant<int, long, double, int*, std::string>;
V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_NonConst | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_LValue)));
std::visit<ReturnType>(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_Const | CT_LValue)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_LValue)));
std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_NonConst | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_RValue)));
std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_Const | CT_RValue)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_RValue)));
}
}
@@ -109,69 +138,69 @@ void test_argument_forwarding() {
{ // single argument - value type
using V = std::variant<int>;
V v(42);
- const V &cv = v;
+ const V& cv = v;
std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<const int &>(Val));
+ assert(Fn::check_call<const int&>(Val));
std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int &&>(Val));
+ assert(Fn::check_call<int&&>(Val));
std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<const int &&>(Val));
+ assert(Fn::check_call<const int&&>(Val));
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{ // single argument - lvalue reference
- using V = std::variant<int &>;
- int x = 42;
+ using V = std::variant<int&>;
+ int x = 42;
V v(x);
- const V &cv = v;
+ const V& cv = v;
std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
}
{ // single argument - rvalue reference
- using V = std::variant<int &&>;
- int x = 42;
+ using V = std::variant<int&&>;
+ int x = 42;
V v(std::move(x));
- const V &cv = v;
+ const V& cv = v;
std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<int &>(Val));
+ assert(Fn::check_call<int&>(Val));
std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int &&>(Val));
+ assert(Fn::check_call<int&&>(Val));
std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<int &&>(Val));
+ assert(Fn::check_call<int&&>(Val));
}
#endif
{ // multi argument - multi variant
using V = std::variant<int, std::string, long>;
V v1(42), v2("hello"), v3(43l);
std::visit<ReturnType>(obj, v1, v2, v3);
- assert((Fn::check_call<int &, std::string &, long &>(Val)));
+ assert((Fn::check_call<int&, std::string&, long&>(Val)));
std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
- assert((Fn::check_call<const int &, const std::string &, long &&>(Val)));
+ assert((Fn::check_call<const int&, const std::string&, long&&>(Val)));
}
{
using V = std::variant<int, long, double, std::string>;
V v1(42l), v2("hello"), v3(101), v4(1.1);
std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int &, double &>(Val)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(Val)));
std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long &, const std::string &, int &&, double &&>(Val)));
+ assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(Val)));
}
{
using V = std::variant<int, long, double, int*, std::string>;
V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long &, std::string &, int *&, double &>(Val)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(Val)));
std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long &, const std::string &, int *&&, double &&>(Val)));
+ assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(Val)));
}
}
@@ -179,7 +208,7 @@ template <typename ReturnType>
void test_return_type() {
using Fn = ForwardingCallObject;
Fn obj{};
- const Fn &cobj = obj;
+ const Fn& cobj = obj;
{ // test call operator forwarding - no variant
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj)), ReturnType>);
@@ -203,8 +232,8 @@ void test_return_type() {
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
}
{ // test call operator forwarding - multi variant, multi arg
- using V = std::variant<int, long, double>;
- using V2 = std::variant<int *, std::string>;
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int*, std::string>;
V v(42l);
V2 v2("hello");
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v, v2)), ReturnType>);
@@ -245,7 +274,7 @@ void test_constexpr_void() {
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char *, long long>;
+ using V2 = std::variant<int, char*, long long>;
using V3 = std::variant<bool, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
@@ -254,20 +283,20 @@ void test_constexpr_void() {
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char *, long long>;
- using V3 = std::variant<void *, int, int>;
+ using V2 = std::variant<int, char*, long long>;
+ using V3 = std::variant<void*, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, "");
}
{
- using V = std::variant<int, long, double, int *>;
+ using V = std::variant<int, long, double, int*>;
constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, "");
}
{
- using V = std::variant<int, long, double, long long, int *>;
+ using V = std::variant<int, long, double, long long, int*>;
constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, "");
}
@@ -288,7 +317,7 @@ void test_constexpr_int() {
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char *, long long>;
+ using V2 = std::variant<int, char*, long long>;
using V3 = std::variant<bool, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
@@ -297,20 +326,20 @@ void test_constexpr_int() {
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char *, long long>;
- using V3 = std::variant<void *, int, int>;
+ using V2 = std::variant<int, char*, long long>;
+ using V3 = std::variant<void*, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, "");
}
{
- using V = std::variant<int, long, double, int *>;
+ using V = std::variant<int, long, double, int*>;
constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, "");
}
{
- using V = std::variant<int, long, double, long long, int *>;
+ using V = std::variant<int, long, double, long long, int*>;
constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, "");
}
@@ -320,10 +349,10 @@ template <typename ReturnType>
void test_exceptions() {
#ifndef TEST_HAS_NO_EXCEPTIONS
ReturnArity obj{};
- auto test = [&](auto &&... args) {
+ auto test = [&](auto&&... args) {
try {
std::visit<ReturnType>(obj, args...);
- } catch (const std::bad_variant_access &) {
+ } catch (const std::bad_variant_access&) {
return true;
} catch (...) {
}
@@ -336,24 +365,24 @@ void test_exceptions() {
assert(test(v));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void *>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*>;
V v;
makeEmpty(v);
V2 v2("hello");
assert(test(v, v2));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void *>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*>;
V v;
makeEmpty(v);
V2 v2("hello");
assert(test(v2, v));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void *, MakeEmptyT>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*, MakeEmptyT>;
V v;
makeEmpty(v);
V2 v2;
@@ -384,8 +413,7 @@ void test_caller_accepts_nonconst() {
struct A {};
struct Visitor {
auto operator()(A&) {
- if constexpr (!std::is_void_v<ReturnType>)
- {
+ if constexpr (!std::is_void_v<ReturnType>) {
return ReturnType{};
}
}
@@ -426,9 +454,7 @@ void test_derived_from_variant() {
char valueless_by_exception;
};
- struct EvilVariant1 : std::variant<int, long, double>,
- std::tuple<int>,
- EvilVariantBase {
+ struct EvilVariant1 : std::variant<int, long, double>, std::tuple<int>, EvilVariantBase {
using std::variant<int, long, double>::variant;
};
@@ -448,7 +474,10 @@ void test_derived_from_variant() {
// Check that visit unambiguously picks the variant, even if the other base has __impl member.
struct ImplVariantBase {
struct Callable {
- bool operator()() const { assert(false); return false; }
+ bool operator()() const {
+ assert(false);
+ return false;
+ }
};
Callable __impl;
@@ -479,8 +508,7 @@ struct any_visitor {
}
};
-template <typename T, typename = decltype(std::visit<bool>(
- std::declval<any_visitor&>(), std::declval<T>()))>
+template <typename T, typename = decltype(std::visit<bool>(std::declval<any_visitor&>(), std::declval<T>()))>
constexpr bool has_visit(int) {
return true;
}
diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py
index 2f506f32f565cb..ed89c1e679015f 100755
--- a/libcxx/utils/generate_feature_test_macro_components.py
+++ b/libcxx/utils/generate_feature_test_macro_components.py
@@ -1264,7 +1264,11 @@ def add_version_header(tc):
},
{
"name": "__cpp_lib_variant",
- "values": {"c++17": 202102},
+ "values": {
+ "c++17": 202102, # std::visit for classes derived from std::variant
+ # "c++20": 202106, # Fully constexpr std::variant
+ # "c++26": 202306, # Member visit
+ },
"headers": ["variant"],
},
{
>From a52349b46a758bf8d0ba0d46ef036ff1901a1e82 Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Mon, 25 Dec 2023 13:13:36 +0200
Subject: [PATCH 05/13] Implemented missing `visit` constraint + test
---
libcxx/include/variant | 4 +--
.../variant/variant.visit/visit.pass.cpp | 33 +++++++++++++++++++
2 files changed, 35 insertions(+), 2 deletions(-)
diff --git a/libcxx/include/variant b/libcxx/include/variant
index 0da61901ce35ff..4c9b04942f2779 100644
--- a/libcxx/include/variant
+++ b/libcxx/include/variant
@@ -1282,7 +1282,7 @@ public:
# if _LIBCPP_STD_VER >= 26
// [variant.visit], visitation
- template <class _Self, class _Visitor>
+ template <int=0, class _Self, class _Visitor>
constexpr decltype(auto) visit(this _Self&& __self, _Visitor&& __visitor);
template <class _R, class _Self, class _Visitor>
@@ -1552,7 +1552,7 @@ visit(_Visitor&& __visitor, _Vs&&... __vs) {
// [variant.visit], visitation
template <class... _Types>
-template <class _Self, class _Visitor>
+template <int, class _Self, class _Visitor>
constexpr decltype(auto) variant<_Types...>::visit(this _Self&& __self, _Visitor&& __visitor) {
using _V = _OverrideRef<_Self&&, _CopyConst<remove_reference_t<_Self>, variant>>;
return std::visit(std::forward<_Visitor>(__visitor), (_V)__self);
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 72c9ca22802194..adbc131a6477ae 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -562,6 +562,38 @@ void test_sfinae() {
static_assert(has_visit<GoodVariant2>(0));
}
+template <class... Ts>
+struct overloaded : Ts... {
+ using Ts::operator()...;
+};
+
+void test_overload_ambiguity() {
+#if _LIBCPP_STD_VER >= 26
+ using V = std::variant<float, long, std::string>;
+ using namespace std::string_literals;
+ V v{"baba"s};
+
+ // member
+ v.visit(
+ overloaded{[]([[maybe_unused]] auto x) { assert(false); }, [](const std::string& x) { assert(x == "baba"s); }});
+ assert(std::get<std::string>(v) == "baba"s);
+
+ // `constexpr decltype(auto) visit(this _Self&& __self, _Visitor&& __visitor);`
+ // vs
+ // `constexpr _R visit(this _Self&& __self, _Visitor&& __visitor);`
+ v = std::move(v).visit<V>(overloaded{
+ []([[maybe_unused]] auto x) {
+ assert(false);
+ return 0;
+ },
+ [](const std::string& x) {
+ assert(x == "baba"s);
+ return x + " zmt"s;
+ }});
+ assert(std::get<std::string>(v) == "baba zmt"s);
+#endif
+}
+
int main(int, char**) {
test_call_operator_forwarding();
test_argument_forwarding();
@@ -571,6 +603,7 @@ int main(int, char**) {
test_caller_accepts_nonconst();
test_derived_from_variant();
test_sfinae();
+ test_overload_ambiguity();
return 0;
}
>From 9b7064d177f5205f5540f0c13aa33cdc93032cc8 Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Wed, 27 Dec 2023 16:13:41 +0200
Subject: [PATCH 06/13] WIP: Updated visit tests
---
.../variant/variant.visit/visit.pass.cpp | 261 +++++++++++-------
.../variant.visit/visit_return_type.pass.cpp | 223 ++++++++++-----
2 files changed, 321 insertions(+), 163 deletions(-)
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index adbc131a6477ae..6aff2194fa68dd 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -163,23 +163,37 @@ void test_call_operator_forwarding() {
void test_argument_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
- const auto Val = CT_LValue | CT_NonConst;
+ const auto val = CT_LValue | CT_NonConst;
{ // single argument - value type
using V = std::variant<int>;
V v(42);
const V& cv = v;
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit(obj);
+ assert(Fn::check_call<int&>(val));
+ cv.visit(obj);
+ assert(Fn::check_call<const int&>(val));
+ std::move(v).visit(obj);
+ assert(Fn::check_call<int&&>(val));
+ std::move(cv).visit(obj);
+ assert(Fn::check_call<const int&&>(val));
+ }
+#endif
+
// non-member
{
std::visit(obj, v);
- assert(Fn::check_call<int&>(Val));
+ assert(Fn::check_call<int&>(val));
std::visit(obj, cv);
- assert(Fn::check_call<const int&>(Val));
+ assert(Fn::check_call<const int&>(val));
std::visit(obj, std::move(v));
- assert(Fn::check_call<int&&>(Val));
+ assert(Fn::check_call<int&&>(val));
std::visit(obj, std::move(cv));
- assert(Fn::check_call<const int&&>(Val));
+ assert(Fn::check_call<const int&&>(val));
}
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
@@ -189,14 +203,32 @@ void test_argument_forwarding() {
V v(x);
const V& cv = v;
- std::visit(obj, v);
- assert(Fn::check_call<int&>(Val));
- std::visit(obj, cv);
- assert(Fn::check_call<int&>(Val));
- std::visit(obj, std::move(v));
- assert(Fn::check_call<int&>(Val));
- std::visit(obj, std::move(cv));
- assert(Fn::check_call<int&>(Val));
+ // # if _LIBCPP_STD_VER >= 26
+ // // member
+ // {
+ // v.visit(obj);
+ // assert(Fn::check_call<int&>(val));
+ // cv.visit(obj);
+ // assert(Fn::check_call<int&>(val));
+ // std::move(v).visit(obj);
+ // assert(Fn::check_call<int&>(val));
+ // std::move(cv).visit(obj);
+ // assert(Fn::check_call<int>(CT_NonConst));
+ // assert(false);
+ // }
+ // # endif
+
+ // non-member
+ {
+ std::visit(obj, v);
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, cv);
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, std::move(v));
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, std::move(cv));
+ assert(Fn::check_call<int&>(val));
+ }
}
{ // single argument - rvalue reference
using V = std::variant<int&&>;
@@ -204,42 +236,54 @@ void test_argument_forwarding() {
V v(std::move(x));
const V& cv = v;
- std::visit(obj, v);
- assert(Fn::check_call<int&>(Val));
- std::visit(obj, cv);
- assert(Fn::check_call<int&>(Val));
- std::visit(obj, std::move(v));
- assert(Fn::check_call<int&&>(Val));
- std::visit(obj, std::move(cv));
- assert(Fn::check_call<int&&>(Val));
+ // non-member
+ {
+ std::visit(obj, v);
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, cv);
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, std::move(v));
+ assert(Fn::check_call<int&&>(val));
+ std::visit(obj, std::move(cv));
+ assert(Fn::check_call<int&&>(val));
+ }
}
#endif
{ // multi argument - multi variant
using V = std::variant<int, std::string, long>;
V v1(42), v2("hello"), v3(43L);
- std::visit(obj, v1, v2, v3);
- assert((Fn::check_call<int&, std::string&, long&>(Val)));
- std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
- assert((Fn::check_call<const int&, const std::string&, long&&>(Val)));
+ // non-member
+ {
+ std::visit(obj, v1, v2, v3);
+ assert((Fn::check_call<int&, std::string&, long&>(val)));
+ std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
+ assert((Fn::check_call<const int&, const std::string&, long&&>(val)));
+ }
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42l), v2("hello"), v3(101), v4(1.1);
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
- std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(Val)));
- std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(Val)));
+ // non-member
+ {
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(val)));
+ std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(val)));
+ }
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
- std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(Val)));
- std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(Val)));
+ // non-member
+ {
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(val)));
+ std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(val)));
+ }
}
}
@@ -249,10 +293,13 @@ void test_return_type() {
const Fn& cobj = obj;
{ // test call operator forwarding - no variant
- static_assert(std::is_same_v<decltype(std::visit(obj)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj))), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj))), const Fn&&>);
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj))), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj))), const Fn&&>);
+ }
}
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
@@ -351,7 +398,7 @@ void test_constexpr() {
{ static_assert(v.visit(obj) == 42); }
#endif
- //non-member
+ // non-member
{ static_assert(std::visit(obj, v) == 42, ""); }
}
{
@@ -363,7 +410,7 @@ void test_constexpr() {
{ static_assert(v.visit(obj) == 42); }
#endif
- //non-member
+ // non-member
{ static_assert(std::visit(obj, v) == 42, ""); }
}
{
@@ -374,7 +421,7 @@ void test_constexpr() {
constexpr V2 v2(nullptr);
constexpr V3 v3;
- //non-member
+ // non-member
{ static_assert(std::visit(aobj, v1, v2, v3) == 3, ""); }
}
{
@@ -385,21 +432,21 @@ void test_constexpr() {
constexpr V2 v2(nullptr);
constexpr V3 v3;
- //non-member
+ // non-member
{ static_assert(std::visit(aobj, v1, v2, v3) == 3, ""); }
}
{
using V = std::variant<int, long, double, int*>;
constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
- //non-member
+ // non-member
{ static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, ""); }
}
{
using V = std::variant<int, long, double, long long, int*>;
constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
- //non-member
+ // non-member
{ static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, ""); }
}
}
@@ -407,7 +454,22 @@ void test_constexpr() {
void test_exceptions() {
#ifndef TEST_HAS_NO_EXCEPTIONS
ReturnArity obj{};
- auto test = [&](auto&&... args) {
+
+# if _LIBCPP_STD_VER >= 26
+ // member
+ auto test_member = [&](auto&& v) {
+ try {
+ v.visit(obj);
+ } catch (const std::bad_variant_access&) {
+ return true;
+ } catch (...) {
+ }
+ return false;
+ };
+# endif
+
+ // non-member
+ auto test_nonmember = [&](auto&&... args) {
try {
std::visit(obj, args...);
} catch (const std::bad_variant_access&) {
@@ -416,11 +478,16 @@ void test_exceptions() {
}
return false;
};
+
{
using V = std::variant<int, MakeEmptyT>;
V v;
+# if _LIBCPP_STD_VER >= 26
+ makeEmpty(v);
+ assert(test_member(v));
+# endif
makeEmpty(v);
- assert(test(v));
+ assert(test_nonmember(v));
}
{
using V = std::variant<int, MakeEmptyT>;
@@ -428,7 +495,7 @@ void test_exceptions() {
V v;
makeEmpty(v);
V2 v2("hello");
- assert(test(v, v2));
+ assert(test_nonmember(v, v2));
}
{
using V = std::variant<int, MakeEmptyT>;
@@ -436,7 +503,7 @@ void test_exceptions() {
V v;
makeEmpty(v);
V2 v2("hello");
- assert(test(v2, v));
+ assert(test_nonmember(v2, v));
}
{
using V = std::variant<int, MakeEmptyT>;
@@ -445,13 +512,13 @@ void test_exceptions() {
makeEmpty(v);
V2 v2;
makeEmpty(v2);
- assert(test(v, v2));
+ assert(test_nonmember(v, v2));
}
{
using V = std::variant<int, long, double, MakeEmptyT>;
V v1(42l), v2(101), v3(202), v4(1.1);
makeEmpty(v1);
- assert(test(v1, v2, v3, v4));
+ assert(test_nonmember(v1, v2, v3, v4));
}
{
using V = std::variant<int, long, double, long long, MakeEmptyT>;
@@ -460,7 +527,7 @@ void test_exceptions() {
makeEmpty(v2);
makeEmpty(v3);
makeEmpty(v4);
- assert(test(v1, v2, v3, v4));
+ assert(test_nonmember(v1, v2, v3, v4));
}
#endif
}
@@ -478,7 +545,7 @@ void test_caller_accepts_nonconst() {
{ v.visit(Visitor{}); }
#endif
- //non-member
+ // non-member
{ std::visit(Visitor{}, v); }
}
@@ -494,11 +561,26 @@ void get(const MyVariant&) {
void test_derived_from_variant() {
auto v1 = MyVariant{42};
const auto cv1 = MyVariant{142};
- std::visit([](auto x) { assert(x == 42); }, v1);
- std::visit([](auto x) { assert(x == 142); }, cv1);
- std::visit([](auto x) { assert(x == -1.25f); }, MyVariant{-1.25f});
- std::visit([](auto x) { assert(x == 42); }, std::move(v1));
- std::visit([](auto x) { assert(x == 142); }, std::move(cv1));
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v1.visit([](auto x) { assert(x == 42); });
+ cv1.visit([](auto x) { assert(x == 142); });
+ MyVariant{-1.25f}.visit([](auto x) { assert(x == -1.25f); });
+ std::move(v1).visit([](auto x) { assert(x == 42); });
+ std::move(cv1).visit([](auto x) { assert(x == 142); });
+ }
+#endif
+
+ // non-member
+ {
+ std::visit([](auto x) { assert(x == 42); }, v1);
+ std::visit([](auto x) { assert(x == 142); }, cv1);
+ std::visit([](auto x) { assert(x == -1.25f); }, MyVariant{-1.25f});
+ std::visit([](auto x) { assert(x == 42); }, std::move(v1));
+ std::visit([](auto x) { assert(x == 142); }, std::move(cv1));
+ }
// Check that visit does not take index nor valueless_by_exception members from the base class.
struct EvilVariantBase {
@@ -510,8 +592,19 @@ void test_derived_from_variant() {
using std::variant<int, long, double>::variant;
};
- std::visit([](auto x) { assert(x == 12); }, EvilVariant1{12});
- std::visit([](auto x) { assert(x == 12.3); }, EvilVariant1{12.3});
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ EvilVariant1{12}.visit([](auto x) { assert(x == 12); });
+ EvilVariant1{12.3}.visit([](auto x) { assert(x == 12.3); });
+ }
+#endif
+
+ // non-member
+ {
+ std::visit([](auto x) { assert(x == 12); }, EvilVariant1{12});
+ std::visit([](auto x) { assert(x == 12.3); }, EvilVariant1{12.3});
+ }
// Check that visit unambiguously picks the variant, even if the other base has __impl member.
struct ImplVariantBase {
@@ -529,8 +622,19 @@ void test_derived_from_variant() {
using std::variant<int, long, double>::variant;
};
- std::visit([](auto x) { assert(x == 12); }, EvilVariant2{12});
- std::visit([](auto x) { assert(x == 12.3); }, EvilVariant2{12.3});
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ EvilVariant2{12}.visit([](auto x) { assert(x == 12); });
+ EvilVariant2{12.3}.visit([](auto x) { assert(x == 12.3); });
+ }
+#endif
+
+ // non-member
+ {
+ std::visit([](auto x) { assert(x == 12); }, EvilVariant2{12});
+ std::visit([](auto x) { assert(x == 12.3); }, EvilVariant2{12.3});
+ }
}
struct any_visitor {
@@ -562,38 +666,6 @@ void test_sfinae() {
static_assert(has_visit<GoodVariant2>(0));
}
-template <class... Ts>
-struct overloaded : Ts... {
- using Ts::operator()...;
-};
-
-void test_overload_ambiguity() {
-#if _LIBCPP_STD_VER >= 26
- using V = std::variant<float, long, std::string>;
- using namespace std::string_literals;
- V v{"baba"s};
-
- // member
- v.visit(
- overloaded{[]([[maybe_unused]] auto x) { assert(false); }, [](const std::string& x) { assert(x == "baba"s); }});
- assert(std::get<std::string>(v) == "baba"s);
-
- // `constexpr decltype(auto) visit(this _Self&& __self, _Visitor&& __visitor);`
- // vs
- // `constexpr _R visit(this _Self&& __self, _Visitor&& __visitor);`
- v = std::move(v).visit<V>(overloaded{
- []([[maybe_unused]] auto x) {
- assert(false);
- return 0;
- },
- [](const std::string& x) {
- assert(x == "baba"s);
- return x + " zmt"s;
- }});
- assert(std::get<std::string>(v) == "baba zmt"s);
-#endif
-}
-
int main(int, char**) {
test_call_operator_forwarding();
test_argument_forwarding();
@@ -603,7 +675,6 @@ int main(int, char**) {
test_caller_accepts_nonconst();
test_derived_from_variant();
test_sfinae();
- test_overload_ambiguity();
return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
index f8cdb70a28fa3b..db4fb1961c48ec 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
@@ -81,52 +81,82 @@ void test_call_operator_forwarding() {
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
V v(42l);
- std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
- std::visit<ReturnType>(cobj, v);
- assert(Fn::check_call<long&>(CT_Const | CT_LValue));
- std::visit<ReturnType>(std::move(obj), v);
- assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
- std::visit<ReturnType>(std::move(cobj), v);
- assert(Fn::check_call<long&>(CT_Const | CT_RValue));
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit<ReturnType>(obj);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
+ v.visit<ReturnType>(cobj);
+ assert(Fn::check_call<long&>(CT_Const | CT_LValue));
+ v.visit<ReturnType>(std::move(obj));
+ assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
+ v.visit<ReturnType>(std::move(cobj));
+ assert(Fn::check_call<long&>(CT_Const | CT_RValue));
+ }
+#endif
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
+ std::visit<ReturnType>(cobj, v);
+ assert(Fn::check_call<long&>(CT_Const | CT_LValue));
+ std::visit<ReturnType>(std::move(obj), v);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
+ std::visit<ReturnType>(std::move(cobj), v);
+ assert(Fn::check_call<long&>(CT_Const | CT_RValue));
+ }
}
{ // test call operator forwarding - multi variant, multi arg
using V = std::variant<int, long, double>;
using V2 = std::variant<int*, std::string>;
V v(42l);
V2 v2("hello");
- std::visit<int>(obj, v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_LValue)));
- std::visit<ReturnType>(cobj, v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_Const | CT_LValue)));
- std::visit<ReturnType>(std::move(obj), v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
- std::visit<ReturnType>(std::move(cobj), v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
+
+ // non-member
+ {
+ std::visit<int>(obj, v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_LValue)));
+ std::visit<ReturnType>(cobj, v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_LValue)));
+ std::visit<ReturnType>(std::move(obj), v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
+ std::visit<ReturnType>(std::move(cobj), v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
+ }
}
{
using V = std::variant<int, long, double, std::string>;
V v1(42l), v2("hello"), v3(101), v4(1.1);
- std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_LValue)));
- std::visit<ReturnType>(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_LValue)));
- std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_RValue)));
- std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_RValue)));
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_LValue)));
+ std::visit<ReturnType>(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_LValue)));
+ std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_RValue)));
+ std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_RValue)));
+ }
}
{
using V = std::variant<int, long, double, int*, std::string>;
V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
- std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_LValue)));
- std::visit<ReturnType>(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_LValue)));
- std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_RValue)));
- std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_RValue)));
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_LValue)));
+ std::visit<ReturnType>(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_LValue)));
+ std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_RValue)));
+ std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_RValue)));
+ }
}
}
@@ -135,18 +165,23 @@ void test_argument_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
const auto Val = CT_LValue | CT_NonConst;
+
{ // single argument - value type
using V = std::variant<int>;
V v(42);
const V& cv = v;
- std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int&>(Val));
- std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<const int&>(Val));
- std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int&&>(Val));
- std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<const int&&>(Val));
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int&>(Val));
+ std::visit<ReturnType>(obj, cv);
+ assert(Fn::check_call<const int&>(Val));
+ std::visit<ReturnType>(obj, std::move(v));
+ assert(Fn::check_call<int&&>(Val));
+ std::visit<ReturnType>(obj, std::move(cv));
+ assert(Fn::check_call<const int&&>(Val));
+ }
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{ // single argument - lvalue reference
@@ -154,53 +189,73 @@ void test_argument_forwarding() {
int x = 42;
V v(x);
const V& cv = v;
- std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int&>(Val));
- std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<int&>(Val));
- std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int&>(Val));
- std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<int&>(Val));
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int&>(Val));
+ std::visit<ReturnType>(obj, cv);
+ assert(Fn::check_call<int&>(Val));
+ std::visit<ReturnType>(obj, std::move(v));
+ assert(Fn::check_call<int&>(Val));
+ std::visit<ReturnType>(obj, std::move(cv));
+ assert(Fn::check_call<int&>(Val));
+ }
}
{ // single argument - rvalue reference
using V = std::variant<int&&>;
int x = 42;
V v(std::move(x));
const V& cv = v;
- std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int&>(Val));
- std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<int&>(Val));
- std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int&&>(Val));
- std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<int&&>(Val));
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int&>(Val));
+ std::visit<ReturnType>(obj, cv);
+ assert(Fn::check_call<int&>(Val));
+ std::visit<ReturnType>(obj, std::move(v));
+ assert(Fn::check_call<int&&>(Val));
+ std::visit<ReturnType>(obj, std::move(cv));
+ assert(Fn::check_call<int&&>(Val));
+ }
}
#endif
{ // multi argument - multi variant
using V = std::variant<int, std::string, long>;
V v1(42), v2("hello"), v3(43l);
- std::visit<ReturnType>(obj, v1, v2, v3);
- assert((Fn::check_call<int&, std::string&, long&>(Val)));
- std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
- assert((Fn::check_call<const int&, const std::string&, long&&>(Val)));
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v1, v2, v3);
+ assert((Fn::check_call<int&, std::string&, long&>(Val)));
+ std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
+ assert((Fn::check_call<const int&, const std::string&, long&&>(Val)));
+ }
}
{
using V = std::variant<int, long, double, std::string>;
V v1(42l), v2("hello"), v3(101), v4(1.1);
- std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(Val)));
- std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(Val)));
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(Val)));
+ std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(Val)));
+ }
}
{
using V = std::variant<int, long, double, int*, std::string>;
V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
- std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(Val)));
- std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(Val)));
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(Val)));
+ std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(Val)));
+ }
}
}
@@ -209,6 +264,7 @@ void test_return_type() {
using Fn = ForwardingCallObject;
Fn obj{};
const Fn& cobj = obj;
+
{ // test call operator forwarding - no variant
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj)), ReturnType>);
@@ -525,6 +581,36 @@ void test_sfinae() {
static_assert(!has_visit<BadVariant>(int()));
}
+template <class... Ts>
+struct overloaded : Ts... {
+ using Ts::operator()...;
+};
+
+void test_overload_ambiguity() {
+#if _LIBCPP_STD_VER >= 26
+ using V = std::variant<float, long, std::string>;
+ using namespace std::string_literals;
+ V v{"baba"s};
+
+ // member
+ v.visit(
+ overloaded{[]([[maybe_unused]] auto x) { assert(false); }, [](const std::string& x) { assert(x == "baba"s); }});
+ assert(std::get<std::string>(v) == "baba"s);
+
+ // Test the constraint.
+ v = std::move(v).visit<V>(overloaded{
+ []([[maybe_unused]] auto x) {
+ assert(false);
+ return 0;
+ },
+ [](const std::string& x) {
+ assert(x == "baba"s);
+ return x + " zmt"s;
+ }});
+ assert(std::get<std::string>(v) == "baba zmt"s);
+#endif
+}
+
int main(int, char**) {
test_call_operator_forwarding<void>();
test_argument_forwarding<void>();
@@ -541,6 +627,7 @@ int main(int, char**) {
test_constexpr_explicit_side_effect();
test_derived_from_variant();
test_sfinae();
+ test_overload_ambiguity();
return 0;
}
>From 2d47529005c5f4444396b039f2f889cf86835d75 Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Wed, 27 Dec 2023 16:35:24 +0200
Subject: [PATCH 07/13] WIP: tests
---
.../variant/variant.visit/visit.pass.cpp | 42 ++--
.../variant.visit/visit_return_type.pass.cpp | 194 ++++++++++++------
2 files changed, 155 insertions(+), 81 deletions(-)
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 6aff2194fa68dd..9eea5f60e31388 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -203,20 +203,20 @@ void test_argument_forwarding() {
V v(x);
const V& cv = v;
- // # if _LIBCPP_STD_VER >= 26
- // // member
- // {
- // v.visit(obj);
- // assert(Fn::check_call<int&>(val));
- // cv.visit(obj);
- // assert(Fn::check_call<int&>(val));
- // std::move(v).visit(obj);
- // assert(Fn::check_call<int&>(val));
- // std::move(cv).visit(obj);
- // assert(Fn::check_call<int>(CT_NonConst));
- // assert(false);
- // }
- // # endif
+# if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit(obj);
+ assert(Fn::check_call<int&>(val));
+ cv.visit(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(v).visit(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(cv).visit(obj);
+ assert(Fn::check_call<int&>(val));
+ assert(false);
+ }
+# endif
// non-member
{
@@ -236,6 +236,20 @@ void test_argument_forwarding() {
V v(std::move(x));
const V& cv = v;
+# if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit(obj);
+ assert(Fn::check_call<int&>(val));
+ cvstd::visit(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(v).visit(obj);
+ assert(Fn::check_call<int&&>(val));
+ std::move(cv).visit(obj);
+ assert(Fn::check_call<int&&>(val));
+ }
+# endif
+
// non-member
{
std::visit(obj, v);
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
index db4fb1961c48ec..31d7665d6b3ae4 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
@@ -29,6 +29,36 @@
#include "test_macros.h"
#include "variant_test_helpers.h"
+template <class... Ts>
+struct overloaded : Ts... {
+ using Ts::operator()...;
+};
+
+void test_overload_ambiguity() {
+#if _LIBCPP_STD_VER >= 26
+ using V = std::variant<float, long, std::string>;
+ using namespace std::string_literals;
+ V v{"baba"s};
+
+ // member
+ v.visit(
+ overloaded{[]([[maybe_unused]] auto x) { assert(false); }, [](const std::string& x) { assert(x == "baba"s); }});
+ assert(std::get<std::string>(v) == "baba"s);
+
+ // Test the constraint.
+ v = std::move(v).visit<V>(overloaded{
+ []([[maybe_unused]] auto x) {
+ assert(false);
+ return 0;
+ },
+ [](const std::string& x) {
+ assert(x == "baba"s);
+ return x + " zmt"s;
+ }});
+ assert(std::get<std::string>(v) == "baba zmt"s);
+#endif
+}
+
template <typename ReturnType>
void test_call_operator_forwarding() {
using Fn = ForwardingCallObject;
@@ -80,7 +110,7 @@ void test_call_operator_forwarding() {
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
- V v(42l);
+ V v(42L);
#if _LIBCPP_STD_VER >= 26
// member
@@ -111,7 +141,7 @@ void test_call_operator_forwarding() {
{ // test call operator forwarding - multi variant, multi arg
using V = std::variant<int, long, double>;
using V2 = std::variant<int*, std::string>;
- V v(42l);
+ V v(42L);
V2 v2("hello");
// non-member
@@ -128,7 +158,7 @@ void test_call_operator_forwarding() {
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42l), v2("hello"), v3(101), v4(1.1);
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
// non-member
{
@@ -144,7 +174,7 @@ void test_call_operator_forwarding() {
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
// non-member
{
@@ -164,23 +194,37 @@ template <typename ReturnType>
void test_argument_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
- const auto Val = CT_LValue | CT_NonConst;
+ const auto val = CT_LValue | CT_NonConst;
{ // single argument - value type
using V = std::variant<int>;
V v(42);
const V& cv = v;
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ cv.visit<ReturnType>(obj);
+ assert(Fn::check_call<const int&>(val));
+ std::move(v).visit<ReturnType>(obj);
+ assert(Fn::check_call<int&&>(val));
+ std::move(cv).visit<ReturnType>(obj);
+ assert(Fn::check_call<const int&&>(val));
+ }
+#endif
+
// non-member
{
std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int&>(Val));
+ assert(Fn::check_call<int&>(val));
std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<const int&>(Val));
+ assert(Fn::check_call<const int&>(val));
std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int&&>(Val));
+ assert(Fn::check_call<int&&>(val));
std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<const int&&>(Val));
+ assert(Fn::check_call<const int&&>(val));
}
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
@@ -190,16 +234,30 @@ void test_argument_forwarding() {
V v(x);
const V& cv = v;
+# if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ cv.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(v).visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(cv).visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ }
+# endif
+
// non-member
{
std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int&>(Val));
+ assert(Fn::check_call<int&>(val));
std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<int&>(Val));
+ assert(Fn::check_call<int&>(val));
std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int&>(Val));
+ assert(Fn::check_call<int&>(val));
std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<int&>(Val));
+ assert(Fn::check_call<int&>(val));
}
}
{ // single argument - rvalue reference
@@ -208,53 +266,67 @@ void test_argument_forwarding() {
V v(std::move(x));
const V& cv = v;
+# if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ cv.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(v).visit<ReturnType>(obj);
+ assert(Fn::check_call<int&&>(val));
+ std::move(cv).visit<ReturnType>(obj);
+ assert(Fn::check_call<int&&>(val));
+ }
+# endif
+
// non-member
{
std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int&>(Val));
+ assert(Fn::check_call<int&>(val));
std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<int&>(Val));
+ assert(Fn::check_call<int&>(val));
std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int&&>(Val));
+ assert(Fn::check_call<int&&>(val));
std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<int&&>(Val));
+ assert(Fn::check_call<int&&>(val));
}
}
#endif
{ // multi argument - multi variant
using V = std::variant<int, std::string, long>;
- V v1(42), v2("hello"), v3(43l);
+ V v1(42), v2("hello"), v3(43L);
// non-member
{
std::visit<ReturnType>(obj, v1, v2, v3);
- assert((Fn::check_call<int&, std::string&, long&>(Val)));
+ assert((Fn::check_call<int&, std::string&, long&>(val)));
std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
- assert((Fn::check_call<const int&, const std::string&, long&&>(Val)));
+ assert((Fn::check_call<const int&, const std::string&, long&&>(val)));
}
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42l), v2("hello"), v3(101), v4(1.1);
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
// non-member
{
std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(Val)));
+ assert((Fn::check_call<long&, std::string&, int&, double&>(val)));
std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(Val)));
+ assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(val)));
}
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
// non-member
{
std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(Val)));
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(val)));
std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(Val)));
+ assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(val)));
}
}
}
@@ -274,6 +346,7 @@ void test_return_type() {
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
+
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
@@ -281,7 +354,8 @@ void test_return_type() {
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
- V v(42l);
+ V v(42L);
+
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
@@ -290,8 +364,9 @@ void test_return_type() {
{ // test call operator forwarding - multi variant, multi arg
using V = std::variant<int, long, double>;
using V2 = std::variant<int*, std::string>;
- V v(42l);
+ V v(42L);
V2 v2("hello");
+
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v, v2)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v, v2)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v, v2)), ReturnType>);
@@ -299,7 +374,8 @@ void test_return_type() {
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42l), v2("hello"), v3(101), v4(1.1);
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
+
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
@@ -307,7 +383,8 @@ void test_return_type() {
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
+
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
@@ -321,11 +398,13 @@ void test_constexpr_void() {
{
using V = std::variant<int>;
constexpr V v(42);
+
static_assert((std::visit<void>(obj, v), 42) == 42, "");
}
{
using V = std::variant<short, long, char>;
- constexpr V v(42l);
+ constexpr V v(42L);
+
static_assert((std::visit<void>(obj, v), 42) == 42, "");
}
{
@@ -335,6 +414,7 @@ void test_constexpr_void() {
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
+
static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, "");
}
{
@@ -344,16 +424,19 @@ void test_constexpr_void() {
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
+
static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, "");
}
{
using V = std::variant<int, long, double, int*>;
- constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, "");
}
{
using V = std::variant<int, long, double, long long, int*>;
- constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, "");
}
}
@@ -361,14 +444,17 @@ void test_constexpr_void() {
void test_constexpr_int() {
constexpr ReturnFirst obj{};
constexpr ReturnArity aobj{};
+
{
using V = std::variant<int>;
constexpr V v(42);
+
static_assert(std::visit<int>(obj, v) == 42, "");
}
{
using V = std::variant<short, long, char>;
- constexpr V v(42l);
+ constexpr V v(42L);
+
static_assert(std::visit<int>(obj, v) == 42, "");
}
{
@@ -378,6 +464,7 @@ void test_constexpr_int() {
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
+
static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, "");
}
{
@@ -387,16 +474,19 @@ void test_constexpr_int() {
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
+
static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, "");
}
{
using V = std::variant<int, long, double, int*>;
- constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, "");
}
{
using V = std::variant<int, long, double, long long, int*>;
- constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, "");
}
}
@@ -581,37 +671,8 @@ void test_sfinae() {
static_assert(!has_visit<BadVariant>(int()));
}
-template <class... Ts>
-struct overloaded : Ts... {
- using Ts::operator()...;
-};
-
-void test_overload_ambiguity() {
-#if _LIBCPP_STD_VER >= 26
- using V = std::variant<float, long, std::string>;
- using namespace std::string_literals;
- V v{"baba"s};
-
- // member
- v.visit(
- overloaded{[]([[maybe_unused]] auto x) { assert(false); }, [](const std::string& x) { assert(x == "baba"s); }});
- assert(std::get<std::string>(v) == "baba"s);
-
- // Test the constraint.
- v = std::move(v).visit<V>(overloaded{
- []([[maybe_unused]] auto x) {
- assert(false);
- return 0;
- },
- [](const std::string& x) {
- assert(x == "baba"s);
- return x + " zmt"s;
- }});
- assert(std::get<std::string>(v) == "baba zmt"s);
-#endif
-}
-
int main(int, char**) {
+ test_overload_ambiguity();
test_call_operator_forwarding<void>();
test_argument_forwarding<void>();
test_return_type<void>();
@@ -627,7 +688,6 @@ int main(int, char**) {
test_constexpr_explicit_side_effect();
test_derived_from_variant();
test_sfinae();
- test_overload_ambiguity();
return 0;
}
>From 55516cd85c29695d58b6602e5c4f49319280cd8d Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Wed, 27 Dec 2023 17:08:46 +0200
Subject: [PATCH 08/13] WIP: more test refactoring
---
.../variant/variant.visit/visit.pass.cpp | 19 +-
.../variant.visit/visit_return_type.pass.cpp | 205 ++++++++++++++----
2 files changed, 165 insertions(+), 59 deletions(-)
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 9eea5f60e31388..4bc35edeed3e0e 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -64,7 +64,6 @@ void test_call_operator_forwarding() {
assert(Fn::check_call<int&>(CT_Const | CT_RValue));
}
#endif
-
// non-member
{
std::visit(obj, v);
@@ -94,7 +93,6 @@ void test_call_operator_forwarding() {
assert(Fn::check_call<long&>(CT_Const | CT_RValue));
}
#endif
-
// non-member
{
std::visit(obj, v);
@@ -183,7 +181,6 @@ void test_argument_forwarding() {
assert(Fn::check_call<const int&&>(val));
}
#endif
-
// non-member
{
std::visit(obj, v);
@@ -249,7 +246,6 @@ void test_argument_forwarding() {
assert(Fn::check_call<int&&>(val));
}
# endif
-
// non-member
{
std::visit(obj, v);
@@ -328,7 +324,6 @@ void test_return_type() {
static_assert(std::is_same_v<decltype(v.visit(std::move(cobj))), const Fn&&>);
}
#endif
-
// non-member
{
static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
@@ -350,7 +345,6 @@ void test_return_type() {
static_assert(std::is_same_v<decltype(v.visit(std::move(cobj))), const Fn&&>);
}
#endif
-
// non-member
{
static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
@@ -411,7 +405,6 @@ void test_constexpr() {
// member
{ static_assert(v.visit(obj) == 42); }
#endif
-
// non-member
{ static_assert(std::visit(obj, v) == 42, ""); }
}
@@ -481,7 +474,6 @@ void test_exceptions() {
return false;
};
# endif
-
// non-member
auto test_nonmember = [&](auto&&... args) {
try {
@@ -498,9 +490,11 @@ void test_exceptions() {
V v;
# if _LIBCPP_STD_VER >= 26
makeEmpty(v);
+
assert(test_member(v));
# endif
makeEmpty(v);
+
assert(test_nonmember(v));
}
{
@@ -509,6 +503,7 @@ void test_exceptions() {
V v;
makeEmpty(v);
V2 v2("hello");
+
assert(test_nonmember(v, v2));
}
{
@@ -517,6 +512,7 @@ void test_exceptions() {
V v;
makeEmpty(v);
V2 v2("hello");
+
assert(test_nonmember(v2, v));
}
{
@@ -526,12 +522,14 @@ void test_exceptions() {
makeEmpty(v);
V2 v2;
makeEmpty(v2);
+
assert(test_nonmember(v, v2));
}
{
using V = std::variant<int, long, double, MakeEmptyT>;
V v1(42l), v2(101), v3(202), v4(1.1);
makeEmpty(v1);
+
assert(test_nonmember(v1, v2, v3, v4));
}
{
@@ -541,6 +539,7 @@ void test_exceptions() {
makeEmpty(v2);
makeEmpty(v3);
makeEmpty(v4);
+
assert(test_nonmember(v1, v2, v3, v4));
}
#endif
@@ -558,7 +557,6 @@ void test_caller_accepts_nonconst() {
// member
{ v.visit(Visitor{}); }
#endif
-
// non-member
{ std::visit(Visitor{}, v); }
}
@@ -586,7 +584,6 @@ void test_derived_from_variant() {
std::move(cv1).visit([](auto x) { assert(x == 142); });
}
#endif
-
// non-member
{
std::visit([](auto x) { assert(x == 42); }, v1);
@@ -613,7 +610,6 @@ void test_derived_from_variant() {
EvilVariant1{12.3}.visit([](auto x) { assert(x == 12.3); });
}
#endif
-
// non-member
{
std::visit([](auto x) { assert(x == 12); }, EvilVariant1{12});
@@ -643,7 +639,6 @@ void test_derived_from_variant() {
EvilVariant2{12.3}.visit([](auto x) { assert(x == 12.3); });
}
#endif
-
// non-member
{
std::visit([](auto x) { assert(x == 12); }, EvilVariant2{12});
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
index 31d7665d6b3ae4..34d90c96e43f2e 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
@@ -95,7 +95,6 @@ void test_call_operator_forwarding() {
assert(Fn::check_call<int&>(CT_Const | CT_RValue));
}
#endif
-
// non-member
{
std::visit<ReturnType>(obj, v);
@@ -338,28 +337,57 @@ void test_return_type() {
const Fn& cobj = obj;
{ // test call operator forwarding - no variant
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj))), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj))), ReturnType>);
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj))), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj))), ReturnType>);
+ }
}
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(obj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(cobj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(obj))), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(cobj))), ReturnType>);
+ }
+#endif
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
+ }
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
V v(42L);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(obj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(cobj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(obj))), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(cobj))), ReturnType>);
+ }
+#endif
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
+ }
}
{ // test call operator forwarding - multi variant, multi arg
using V = std::variant<int, long, double>;
@@ -367,28 +395,37 @@ void test_return_type() {
V v(42L);
V2 v2("hello");
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v, v2)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v, v2)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v, v2)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v, v2)), ReturnType>);
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v, v2)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v, v2)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v, v2)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v, v2)), ReturnType>);
+ }
}
{
using V = std::variant<int, long, double, std::string>;
V v1(42L), v2("hello"), v3(101), v4(1.1);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
+ }
}
{
using V = std::variant<int, long, double, int*, std::string>;
V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
+ }
}
}
@@ -399,13 +436,25 @@ void test_constexpr_void() {
using V = std::variant<int>;
constexpr V v(42);
- static_assert((std::visit<void>(obj, v), 42) == 42, "");
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert((v.visit<void>(obj), 42) == 42); }
+#endif
+
+ // non-member
+ { static_assert((std::visit<void>(obj, v), 42) == 42, ""); }
}
{
using V = std::variant<short, long, char>;
constexpr V v(42L);
- static_assert((std::visit<void>(obj, v), 42) == 42, "");
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert((v.visit<void>(obj), 42) == 42); }
+#endif
+
+ // non-member
+ { static_assert((std::visit<void>(obj, v), 42) == 42, ""); }
}
{
using V1 = std::variant<int>;
@@ -415,7 +464,8 @@ void test_constexpr_void() {
constexpr V2 v2(nullptr);
constexpr V3 v3;
- static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, "");
+ // non-member
+ { static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, ""); }
}
{
using V1 = std::variant<int>;
@@ -425,19 +475,21 @@ void test_constexpr_void() {
constexpr V2 v2(nullptr);
constexpr V3 v3;
- static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, "");
+ // non-member
+ { static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, ""); }
}
{
using V = std::variant<int, long, double, int*>;
constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
- static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, "");
+ // non-member
+ { static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, ""); }
}
{
using V = std::variant<int, long, double, long long, int*>;
constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
-
- static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, "");
+ // non-member
+ { static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, ""); }
}
}
@@ -449,13 +501,25 @@ void test_constexpr_int() {
using V = std::variant<int>;
constexpr V v(42);
- static_assert(std::visit<int>(obj, v) == 42, "");
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert(v.visit<int>(obj) == 42); }
+#endif
+
+ // non-member
+ { static_assert(std::visit<int>(obj, v) == 42, ""); }
}
{
using V = std::variant<short, long, char>;
constexpr V v(42L);
- static_assert(std::visit<int>(obj, v) == 42, "");
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert(v.visit<int>(obj) == 42); }
+#endif
+
+ // non-member
+ { static_assert(std::visit<int>(obj, v) == 42, ""); }
}
{
using V1 = std::variant<int>;
@@ -465,7 +529,8 @@ void test_constexpr_int() {
constexpr V2 v2(nullptr);
constexpr V3 v3;
- static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, "");
+ // non-member
+ { static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, ""); }
}
{
using V1 = std::variant<int>;
@@ -475,19 +540,22 @@ void test_constexpr_int() {
constexpr V2 v2(nullptr);
constexpr V3 v3;
- static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, "");
+ // non-member
+ { static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, ""); }
}
{
using V = std::variant<int, long, double, int*>;
constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
- static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, "");
+ // non-member
+ { static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, ""); }
}
{
using V = std::variant<int, long, double, long long, int*>;
constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
- static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, "");
+ // non-member
+ { static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, ""); }
}
}
@@ -495,7 +563,22 @@ template <typename ReturnType>
void test_exceptions() {
#ifndef TEST_HAS_NO_EXCEPTIONS
ReturnArity obj{};
- auto test = [&](auto&&... args) {
+
+# if _LIBCPP_STD_VER >= 26
+ // member
+ auto test_member = [&](auto&& v) {
+ try {
+ v.template visit<ReturnType>(obj);
+ } catch (const std::bad_variant_access&) {
+ return true;
+ } catch (...) {
+ }
+ return false;
+ };
+# endif
+
+ // non-member
+ auto test_nonmember = [&](auto&&... args) {
try {
std::visit<ReturnType>(obj, args...);
} catch (const std::bad_variant_access&) {
@@ -504,11 +587,18 @@ void test_exceptions() {
}
return false;
};
+
{
using V = std::variant<int, MakeEmptyT>;
V v;
+# if _LIBCPP_STD_VER >= 26
+ makeEmpty(v);
+
+ assert(test_member(v));
+# endif
makeEmpty(v);
- assert(test(v));
+
+ assert(test_nonmember(v));
}
{
using V = std::variant<int, MakeEmptyT>;
@@ -516,7 +606,8 @@ void test_exceptions() {
V v;
makeEmpty(v);
V2 v2("hello");
- assert(test(v, v2));
+
+ assert(test_nonmember(v, v2));
}
{
using V = std::variant<int, MakeEmptyT>;
@@ -524,7 +615,8 @@ void test_exceptions() {
V v;
makeEmpty(v);
V2 v2("hello");
- assert(test(v2, v));
+
+ assert(test_nonmember(v2, v));
}
{
using V = std::variant<int, MakeEmptyT>;
@@ -533,13 +625,15 @@ void test_exceptions() {
makeEmpty(v);
V2 v2;
makeEmpty(v2);
- assert(test(v, v2));
+
+ assert(test_nonmember(v, v2));
}
{
using V = std::variant<int, long, double, MakeEmptyT>;
V v1(42l), v2(101), v3(202), v4(1.1);
makeEmpty(v1);
- assert(test(v1, v2, v3, v4));
+
+ assert(test_nonmember(v1, v2, v3, v4));
}
{
using V = std::variant<int, long, double, long long, MakeEmptyT>;
@@ -548,7 +642,8 @@ void test_exceptions() {
makeEmpty(v2);
makeEmpty(v3);
makeEmpty(v4);
- assert(test(v1, v2, v3, v4));
+
+ assert(test_nonmember(v1, v2, v3, v4));
}
#endif
}
@@ -565,13 +660,29 @@ void test_caller_accepts_nonconst() {
}
};
std::variant<A> v;
- std::visit<ReturnType>(Visitor{}, v);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { v.template visit<ReturnType>(Visitor{}); }
+#endif
+ // non-member
+ { std::visit<ReturnType>(Visitor{}, v); }
}
void test_constexpr_explicit_side_effect() {
auto test_lambda = [](int arg) constexpr {
std::variant<int> v = 101;
- std::visit<void>([arg](int& x) constexpr { x = arg; }, v);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.template visit<void>([arg](int& x) constexpr { x = arg; });
+ }
+#endif
+ // non-member
+ {
+ std::visit<void>([arg](int& x) constexpr { x = arg; }, v);
+ }
return std::get<int>(v);
};
>From 5097751e32cc89cdce94c77d813f38102cd5d22b Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Wed, 27 Dec 2023 17:28:02 +0200
Subject: [PATCH 09/13] Completed: visit_return_type.pass
---
.../variant.visit/robust_against_adl.pass.cpp | 1 -
.../variant/variant.visit/visit.pass.cpp | 2 -
.../variant.visit/visit_return_type.pass.cpp | 136 +++++++++++-------
3 files changed, 87 insertions(+), 52 deletions(-)
diff --git a/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
index 6f095891693867..3723037d4e6d10 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
@@ -42,7 +42,6 @@ constexpr bool test(bool do_it) {
v.visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; });
}
#endif
-
// non-member
{
std::visit([](auto) {}, v);
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 4bc35edeed3e0e..9eb2680c47ffd5 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -214,7 +214,6 @@ void test_argument_forwarding() {
assert(false);
}
# endif
-
// non-member
{
std::visit(obj, v);
@@ -416,7 +415,6 @@ void test_constexpr() {
// member
{ static_assert(v.visit(obj) == 42); }
#endif
-
// non-member
{ static_assert(std::visit(obj, v) == 42, ""); }
}
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
index 34d90c96e43f2e..b0d1055973f6c7 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
@@ -124,7 +124,6 @@ void test_call_operator_forwarding() {
assert(Fn::check_call<long&>(CT_Const | CT_RValue));
}
#endif
-
// non-member
{
std::visit<ReturnType>(obj, v);
@@ -213,7 +212,6 @@ void test_argument_forwarding() {
assert(Fn::check_call<const int&&>(val));
}
#endif
-
// non-member
{
std::visit<ReturnType>(obj, v);
@@ -246,7 +244,6 @@ void test_argument_forwarding() {
assert(Fn::check_call<int&>(val));
}
# endif
-
// non-member
{
std::visit<ReturnType>(obj, v);
@@ -278,7 +275,6 @@ void test_argument_forwarding() {
assert(Fn::check_call<int&&>(val));
}
# endif
-
// non-member
{
std::visit<ReturnType>(obj, v);
@@ -358,7 +354,6 @@ void test_return_type() {
static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(cobj))), ReturnType>);
}
#endif
-
// non-member
{
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
@@ -380,7 +375,6 @@ void test_return_type() {
static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(cobj))), ReturnType>);
}
#endif
-
// non-member
{
static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
@@ -440,7 +434,6 @@ void test_constexpr_void() {
// member
{ static_assert((v.visit<void>(obj), 42) == 42); }
#endif
-
// non-member
{ static_assert((std::visit<void>(obj, v), 42) == 42, ""); }
}
@@ -452,7 +445,6 @@ void test_constexpr_void() {
// member
{ static_assert((v.visit<void>(obj), 42) == 42); }
#endif
-
// non-member
{ static_assert((std::visit<void>(obj, v), 42) == 42, ""); }
}
@@ -488,6 +480,7 @@ void test_constexpr_void() {
{
using V = std::variant<int, long, double, long long, int*>;
constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
// non-member
{ static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, ""); }
}
@@ -505,7 +498,6 @@ void test_constexpr_int() {
// member
{ static_assert(v.visit<int>(obj) == 42); }
#endif
-
// non-member
{ static_assert(std::visit<int>(obj, v) == 42, ""); }
}
@@ -517,7 +509,6 @@ void test_constexpr_int() {
// member
{ static_assert(v.visit<int>(obj) == 42); }
#endif
-
// non-member
{ static_assert(std::visit<int>(obj, v) == 42, ""); }
}
@@ -576,7 +567,6 @@ void test_exceptions() {
return false;
};
# endif
-
// non-member
auto test_nonmember = [&](auto&&... args) {
try {
@@ -630,14 +620,14 @@ void test_exceptions() {
}
{
using V = std::variant<int, long, double, MakeEmptyT>;
- V v1(42l), v2(101), v3(202), v4(1.1);
+ V v1(42L), v2(101), v3(202), v4(1.1);
makeEmpty(v1);
assert(test_nonmember(v1, v2, v3, v4));
}
{
using V = std::variant<int, long, double, long long, MakeEmptyT>;
- V v1(42l), v2(101), v3(202), v4(1.1);
+ V v1(42L), v2(101), v3(202), v4(1.1);
makeEmpty(v1);
makeEmpty(v2);
makeEmpty(v3);
@@ -692,18 +682,34 @@ void test_constexpr_explicit_side_effect() {
void test_derived_from_variant() {
struct MyVariant : std::variant<short, long, float> {};
- std::visit<bool>(
- [](auto x) {
- assert(x == 42);
- return true;
- },
- MyVariant{42});
- std::visit<bool>(
- [](auto x) {
- assert(x == -1.3f);
- return true;
- },
- MyVariant{-1.3f});
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ MyVariant{42}.template visit<bool>([](auto x) {
+ assert(x == 42);
+ return true;
+ });
+ MyVariant{-1.3f}.template visit<bool>([](auto x) {
+ assert(x == -1.3f);
+ return true;
+ });
+ }
+#endif
+ // non-member
+ {
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 42);
+ return true;
+ },
+ MyVariant{42});
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == -1.3f);
+ return true;
+ },
+ MyVariant{-1.3f});
+ }
// Check that visit does not take index nor valueless_by_exception members from the base class.
struct EvilVariantBase {
@@ -715,18 +721,34 @@ void test_derived_from_variant() {
using std::variant<int, long, double>::variant;
};
- std::visit<bool>(
- [](auto x) {
- assert(x == 12);
- return true;
- },
- EvilVariant1{12});
- std::visit<bool>(
- [](auto x) {
- assert(x == 12.3);
- return true;
- },
- EvilVariant1{12.3});
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ EvilVariant1{12}.template visit<bool>([](auto x) {
+ assert(x == 12);
+ return true;
+ });
+ EvilVariant1{12.3}.template visit<bool>([](auto x) {
+ assert(x == 12.3);
+ return true;
+ });
+ }
+#endif
+ // non-member
+ {
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12);
+ return true;
+ },
+ EvilVariant1{12});
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12.3);
+ return true;
+ },
+ EvilVariant1{12.3});
+ }
// Check that visit unambiguously picks the variant, even if the other base has __impl member.
struct ImplVariantBase {
@@ -744,18 +766,34 @@ void test_derived_from_variant() {
using std::variant<int, long, double>::variant;
};
- std::visit<bool>(
- [](auto x) {
- assert(x == 12);
- return true;
- },
- EvilVariant2{12});
- std::visit<bool>(
- [](auto x) {
- assert(x == 12.3);
- return true;
- },
- EvilVariant2{12.3});
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ EvilVariant2{12}.template visit<bool>([](auto x) {
+ assert(x == 12);
+ return true;
+ });
+ EvilVariant2{12.3}.template visit<bool>([](auto x) {
+ assert(x == 12.3);
+ return true;
+ });
+ }
+#endif
+ // non-member
+ {
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12);
+ return true;
+ },
+ EvilVariant2{12});
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12.3);
+ return true;
+ },
+ EvilVariant2{12.3});
+ }
}
struct any_visitor {
>From 653ec7af66441bf9f9885622cec12c48322767b8 Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Wed, 27 Dec 2023 17:32:53 +0200
Subject: [PATCH 10/13] Syn cleanup
---
.../variant/variant.visit/robust_against_adl.pass.cpp | 2 +-
.../test/std/utilities/variant/variant.visit/visit.pass.cpp | 4 +---
.../variant/variant.visit/visit_return_type.pass.cpp | 2 --
3 files changed, 2 insertions(+), 6 deletions(-)
diff --git a/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
index 3723037d4e6d10..3bd305a7c62c17 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
@@ -12,7 +12,7 @@
// class variant;
// template<class Self, class Visitor>
-// constexpr decltype(auto) visit(this Self&&, Visitor&&); //since C++26
+// constexpr decltype(auto) visit(this Self&&, Visitor&&); // since C++26
// template<class R, class Self, class Visitor>
// constexpr R visit(this Self&&, Visitor&&); // since C++26
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 9eb2680c47ffd5..8781174ff7d669 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -12,9 +12,7 @@
// class variant;
// template<class Self, class Visitor>
-// constexpr decltype(auto) visit(this Self&&, Visitor&&); //since C++26
-// template<class R, class Self, class Visitor>
-// constexpr R visit(this Self&&, Visitor&&); // since C++26
+// constexpr decltype(auto) visit(this Self&&, Visitor&&); // since C++26
// template <class Visitor, class... Variants>
// constexpr see below visit(Visitor&& vis, Variants&&... vars);
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
index b0d1055973f6c7..1c73d34cacd87f 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
@@ -11,8 +11,6 @@
// <variant>
// class variant;
-// template<class Self, class Visitor>
-// constexpr decltype(auto) visit(this Self&&, Visitor&&); //since C++26
// template<class R, class Self, class Visitor>
// constexpr R visit(this Self&&, Visitor&&); // since C++26
>From 9126f034eaa28d568683d3d5e3b4e91fcf014aab Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Wed, 27 Dec 2023 17:53:59 +0200
Subject: [PATCH 11/13] Fixed formatting
---
libcxx/utils/generate_feature_test_macro_components.py | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py
index ed89c1e679015f..1944591136cbb6 100755
--- a/libcxx/utils/generate_feature_test_macro_components.py
+++ b/libcxx/utils/generate_feature_test_macro_components.py
@@ -1265,9 +1265,9 @@ def add_version_header(tc):
{
"name": "__cpp_lib_variant",
"values": {
- "c++17": 202102, # std::visit for classes derived from std::variant
- # "c++20": 202106, # Fully constexpr std::variant
- # "c++26": 202306, # Member visit
+ "c++17": 202102, # std::visit for classes derived from std::variant
+ # "c++20": 202106, # Fully constexpr std::variant
+ # "c++26": 202306, # Member visit
},
"headers": ["variant"],
},
>From ae8a8d6525320f6a5d653dfb79700cfa4e75f84a Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Sat, 30 Dec 2023 08:19:26 +0200
Subject: [PATCH 12/13] Restored original files
---
.../variant.visit/member.visit.pass.cpp | 685 ++++++++++++++
.../member.visit.robust_against_adl.pass.cpp | 64 ++
.../member.visit_return_type.pass.cpp | 840 ++++++++++++++++++
.../variant.visit/robust_against_adl.pass.cpp | 53 +-
.../variant/variant.visit/visit.pass.cpp | 606 ++++---------
.../variant.visit/visit_return_type.pass.cpp | 768 +++++-----------
6 files changed, 2006 insertions(+), 1010 deletions(-)
create mode 100644 libcxx/test/std/utilities/variant/variant.visit/member.visit.pass.cpp
create mode 100644 libcxx/test/std/utilities/variant/variant.visit/member.visit.robust_against_adl.pass.cpp
create mode 100644 libcxx/test/std/utilities/variant/variant.visit/member.visit_return_type.pass.cpp
diff --git a/libcxx/test/std/utilities/variant/variant.visit/member.visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/member.visit.pass.cpp
new file mode 100644
index 00000000000000..8781174ff7d669
--- /dev/null
+++ b/libcxx/test/std/utilities/variant/variant.visit/member.visit.pass.cpp
@@ -0,0 +1,685 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <variant>
+
+// class variant;
+// template<class Self, class Visitor>
+// constexpr decltype(auto) visit(this Self&&, Visitor&&); // since C++26
+
+// template <class Visitor, class... Variants>
+// constexpr see below visit(Visitor&& vis, Variants&&... vars);
+
+#include <cassert>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+#include "test_macros.h"
+#include "variant_test_helpers.h"
+
+void test_call_operator_forwarding() {
+ using Fn = ForwardingCallObject;
+ Fn obj{};
+ const Fn& cobj = obj;
+
+ { // test call operator forwarding - no variant
+ // non-member
+ {
+ std::visit(obj);
+ assert(Fn::check_call<>(CT_NonConst | CT_LValue));
+ std::visit(cobj);
+ assert(Fn::check_call<>(CT_Const | CT_LValue));
+ std::visit(std::move(obj));
+ assert(Fn::check_call<>(CT_NonConst | CT_RValue));
+ std::visit(std::move(cobj));
+ assert(Fn::check_call<>(CT_Const | CT_RValue));
+ }
+ }
+ { // test call operator forwarding - single variant, single arg
+ using V = std::variant<int>;
+ V v(42);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit(obj);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
+ v.visit(cobj);
+ assert(Fn::check_call<int&>(CT_Const | CT_LValue));
+ v.visit(std::move(obj));
+ assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
+ v.visit(std::move(cobj));
+ assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+ }
+#endif
+ // non-member
+ {
+ std::visit(obj, v);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
+ std::visit(cobj, v);
+ assert(Fn::check_call<int&>(CT_Const | CT_LValue));
+ std::visit(std::move(obj), v);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
+ std::visit(std::move(cobj), v);
+ assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+ }
+ }
+ { // test call operator forwarding - single variant, multi arg
+ using V = std::variant<int, long, double>;
+ V v(42L);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit(obj);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
+ v.visit(cobj);
+ assert(Fn::check_call<long&>(CT_Const | CT_LValue));
+ v.visit(std::move(obj));
+ assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
+ v.visit(std::move(cobj));
+ assert(Fn::check_call<long&>(CT_Const | CT_RValue));
+ }
+#endif
+ // non-member
+ {
+ std::visit(obj, v);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
+ std::visit(cobj, v);
+ assert(Fn::check_call<long&>(CT_Const | CT_LValue));
+ std::visit(std::move(obj), v);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
+ std::visit(std::move(cobj), v);
+ assert(Fn::check_call<long&>(CT_Const | CT_RValue));
+ }
+ }
+ { // test call operator forwarding - multi variant, multi arg
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int*, std::string>;
+ V v(42L);
+ V2 v2("hello");
+
+ // non-member
+ {
+ std::visit(obj, v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_LValue)));
+ std::visit(cobj, v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_LValue)));
+ std::visit(std::move(obj), v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
+ std::visit(std::move(cobj), v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
+ }
+ }
+ {
+ using V = std::variant<int, long, double, std::string>;
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
+
+ // non-member
+ {
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_LValue)));
+ std::visit(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_LValue)));
+ std::visit(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_RValue)));
+ std::visit(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_RValue)));
+ }
+ }
+ {
+ using V = std::variant<int, long, double, int*, std::string>;
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
+
+ // non-member
+ {
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_LValue)));
+ std::visit(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_LValue)));
+ std::visit(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_RValue)));
+ std::visit(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_RValue)));
+ }
+ }
+}
+
+// Applies to non-member `std::visit` only.
+void test_argument_forwarding() {
+ using Fn = ForwardingCallObject;
+ Fn obj{};
+ const auto val = CT_LValue | CT_NonConst;
+
+ { // single argument - value type
+ using V = std::variant<int>;
+ V v(42);
+ const V& cv = v;
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit(obj);
+ assert(Fn::check_call<int&>(val));
+ cv.visit(obj);
+ assert(Fn::check_call<const int&>(val));
+ std::move(v).visit(obj);
+ assert(Fn::check_call<int&&>(val));
+ std::move(cv).visit(obj);
+ assert(Fn::check_call<const int&&>(val));
+ }
+#endif
+ // non-member
+ {
+ std::visit(obj, v);
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, cv);
+ assert(Fn::check_call<const int&>(val));
+ std::visit(obj, std::move(v));
+ assert(Fn::check_call<int&&>(val));
+ std::visit(obj, std::move(cv));
+ assert(Fn::check_call<const int&&>(val));
+ }
+ }
+#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
+ { // single argument - lvalue reference
+ using V = std::variant<int&>;
+ int x = 42;
+ V v(x);
+ const V& cv = v;
+
+# if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit(obj);
+ assert(Fn::check_call<int&>(val));
+ cv.visit(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(v).visit(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(cv).visit(obj);
+ assert(Fn::check_call<int&>(val));
+ assert(false);
+ }
+# endif
+ // non-member
+ {
+ std::visit(obj, v);
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, cv);
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, std::move(v));
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, std::move(cv));
+ assert(Fn::check_call<int&>(val));
+ }
+ }
+ { // single argument - rvalue reference
+ using V = std::variant<int&&>;
+ int x = 42;
+ V v(std::move(x));
+ const V& cv = v;
+
+# if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit(obj);
+ assert(Fn::check_call<int&>(val));
+ cvstd::visit(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(v).visit(obj);
+ assert(Fn::check_call<int&&>(val));
+ std::move(cv).visit(obj);
+ assert(Fn::check_call<int&&>(val));
+ }
+# endif
+ // non-member
+ {
+ std::visit(obj, v);
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, cv);
+ assert(Fn::check_call<int&>(val));
+ std::visit(obj, std::move(v));
+ assert(Fn::check_call<int&&>(val));
+ std::visit(obj, std::move(cv));
+ assert(Fn::check_call<int&&>(val));
+ }
+ }
+#endif
+ { // multi argument - multi variant
+ using V = std::variant<int, std::string, long>;
+ V v1(42), v2("hello"), v3(43L);
+
+ // non-member
+ {
+ std::visit(obj, v1, v2, v3);
+ assert((Fn::check_call<int&, std::string&, long&>(val)));
+ std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
+ assert((Fn::check_call<const int&, const std::string&, long&&>(val)));
+ }
+ }
+ {
+ using V = std::variant<int, long, double, std::string>;
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
+
+ // non-member
+ {
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(val)));
+ std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(val)));
+ }
+ }
+ {
+ using V = std::variant<int, long, double, int*, std::string>;
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
+
+ // non-member
+ {
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(val)));
+ std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(val)));
+ }
+ }
+}
+
+void test_return_type() {
+ using Fn = ForwardingCallObject;
+ Fn obj{};
+ const Fn& cobj = obj;
+
+ { // test call operator forwarding - no variant
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj))), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj))), const Fn&&>);
+ }
+ }
+ { // test call operator forwarding - single variant, single arg
+ using V = std::variant<int>;
+ V v(42);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ static_assert(std::is_same_v<decltype(v.visit(obj)), Fn&>);
+ static_assert(std::is_same_v<decltype(v.visit(cobj)), const Fn&>);
+ static_assert(std::is_same_v<decltype(v.visit(std::move(obj))), Fn&&>);
+ static_assert(std::is_same_v<decltype(v.visit(std::move(cobj))), const Fn&&>);
+ }
+#endif
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
+ }
+ }
+ { // test call operator forwarding - single variant, multi arg
+ using V = std::variant<int, long, double>;
+ V v(42L);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ static_assert(std::is_same_v<decltype(v.visit(obj)), Fn&>);
+ static_assert(std::is_same_v<decltype(v.visit(cobj)), const Fn&>);
+ static_assert(std::is_same_v<decltype(v.visit(std::move(obj))), Fn&&>);
+ static_assert(std::is_same_v<decltype(v.visit(std::move(cobj))), const Fn&&>);
+ }
+#endif
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
+ }
+ }
+ { // test call operator forwarding - multi variant, multi arg
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int*, std::string>;
+ V v(42L);
+ V2 v2("hello");
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj, v, v2)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v, v2)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v, v2)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v, v2)), const Fn&&>);
+ }
+ }
+ {
+ using V = std::variant<int, long, double, std::string>;
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
+ }
+ }
+ {
+ using V = std::variant<int, long, double, int*, std::string>;
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
+ }
+ }
+}
+
+void test_constexpr() {
+ constexpr ReturnFirst obj{};
+ constexpr ReturnArity aobj{};
+
+ {
+ using V = std::variant<int>;
+ constexpr V v(42);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert(v.visit(obj) == 42); }
+#endif
+ // non-member
+ { static_assert(std::visit(obj, v) == 42, ""); }
+ }
+ {
+ using V = std::variant<short, long, char>;
+ constexpr V v(42L);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert(v.visit(obj) == 42); }
+#endif
+ // non-member
+ { static_assert(std::visit(obj, v) == 42, ""); }
+ }
+ {
+ using V1 = std::variant<int>;
+ using V2 = std::variant<int, char*, long long>;
+ using V3 = std::variant<bool, int, int>;
+ constexpr V1 v1;
+ constexpr V2 v2(nullptr);
+ constexpr V3 v3;
+
+ // non-member
+ { static_assert(std::visit(aobj, v1, v2, v3) == 3, ""); }
+ }
+ {
+ using V1 = std::variant<int>;
+ using V2 = std::variant<int, char*, long long>;
+ using V3 = std::variant<void*, int, int>;
+ constexpr V1 v1;
+ constexpr V2 v2(nullptr);
+ constexpr V3 v3;
+
+ // non-member
+ { static_assert(std::visit(aobj, v1, v2, v3) == 3, ""); }
+ }
+ {
+ using V = std::variant<int, long, double, int*>;
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
+ // non-member
+ { static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, ""); }
+ }
+ {
+ using V = std::variant<int, long, double, long long, int*>;
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
+ // non-member
+ { static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, ""); }
+ }
+}
+
+void test_exceptions() {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ ReturnArity obj{};
+
+# if _LIBCPP_STD_VER >= 26
+ // member
+ auto test_member = [&](auto&& v) {
+ try {
+ v.visit(obj);
+ } catch (const std::bad_variant_access&) {
+ return true;
+ } catch (...) {
+ }
+ return false;
+ };
+# endif
+ // non-member
+ auto test_nonmember = [&](auto&&... args) {
+ try {
+ std::visit(obj, args...);
+ } catch (const std::bad_variant_access&) {
+ return true;
+ } catch (...) {
+ }
+ return false;
+ };
+
+ {
+ using V = std::variant<int, MakeEmptyT>;
+ V v;
+# if _LIBCPP_STD_VER >= 26
+ makeEmpty(v);
+
+ assert(test_member(v));
+# endif
+ makeEmpty(v);
+
+ assert(test_nonmember(v));
+ }
+ {
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*>;
+ V v;
+ makeEmpty(v);
+ V2 v2("hello");
+
+ assert(test_nonmember(v, v2));
+ }
+ {
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*>;
+ V v;
+ makeEmpty(v);
+ V2 v2("hello");
+
+ assert(test_nonmember(v2, v));
+ }
+ {
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*, MakeEmptyT>;
+ V v;
+ makeEmpty(v);
+ V2 v2;
+ makeEmpty(v2);
+
+ assert(test_nonmember(v, v2));
+ }
+ {
+ using V = std::variant<int, long, double, MakeEmptyT>;
+ V v1(42l), v2(101), v3(202), v4(1.1);
+ makeEmpty(v1);
+
+ assert(test_nonmember(v1, v2, v3, v4));
+ }
+ {
+ using V = std::variant<int, long, double, long long, MakeEmptyT>;
+ V v1(42l), v2(101), v3(202), v4(1.1);
+ makeEmpty(v1);
+ makeEmpty(v2);
+ makeEmpty(v3);
+ makeEmpty(v4);
+
+ assert(test_nonmember(v1, v2, v3, v4));
+ }
+#endif
+}
+
+// See https://llvm.org/PR31916
+void test_caller_accepts_nonconst() {
+ struct A {};
+ struct Visitor {
+ void operator()(A&) {}
+ };
+ std::variant<A> v;
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { v.visit(Visitor{}); }
+#endif
+ // non-member
+ { std::visit(Visitor{}, v); }
+}
+
+struct MyVariant : std::variant<short, long, float> {};
+
+namespace std {
+template <std::size_t Index>
+void get(const MyVariant&) {
+ assert(false);
+}
+} // namespace std
+
+void test_derived_from_variant() {
+ auto v1 = MyVariant{42};
+ const auto cv1 = MyVariant{142};
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v1.visit([](auto x) { assert(x == 42); });
+ cv1.visit([](auto x) { assert(x == 142); });
+ MyVariant{-1.25f}.visit([](auto x) { assert(x == -1.25f); });
+ std::move(v1).visit([](auto x) { assert(x == 42); });
+ std::move(cv1).visit([](auto x) { assert(x == 142); });
+ }
+#endif
+ // non-member
+ {
+ std::visit([](auto x) { assert(x == 42); }, v1);
+ std::visit([](auto x) { assert(x == 142); }, cv1);
+ std::visit([](auto x) { assert(x == -1.25f); }, MyVariant{-1.25f});
+ std::visit([](auto x) { assert(x == 42); }, std::move(v1));
+ std::visit([](auto x) { assert(x == 142); }, std::move(cv1));
+ }
+
+ // Check that visit does not take index nor valueless_by_exception members from the base class.
+ struct EvilVariantBase {
+ int index;
+ char valueless_by_exception;
+ };
+
+ struct EvilVariant1 : std::variant<int, long, double>, std::tuple<int>, EvilVariantBase {
+ using std::variant<int, long, double>::variant;
+ };
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ EvilVariant1{12}.visit([](auto x) { assert(x == 12); });
+ EvilVariant1{12.3}.visit([](auto x) { assert(x == 12.3); });
+ }
+#endif
+ // non-member
+ {
+ std::visit([](auto x) { assert(x == 12); }, EvilVariant1{12});
+ std::visit([](auto x) { assert(x == 12.3); }, EvilVariant1{12.3});
+ }
+
+ // Check that visit unambiguously picks the variant, even if the other base has __impl member.
+ struct ImplVariantBase {
+ struct Callable {
+ bool operator()() const {
+ assert(false);
+ return false;
+ }
+ };
+
+ Callable __impl;
+ };
+
+ struct EvilVariant2 : std::variant<int, long, double>, ImplVariantBase {
+ using std::variant<int, long, double>::variant;
+ };
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ EvilVariant2{12}.visit([](auto x) { assert(x == 12); });
+ EvilVariant2{12.3}.visit([](auto x) { assert(x == 12.3); });
+ }
+#endif
+ // non-member
+ {
+ std::visit([](auto x) { assert(x == 12); }, EvilVariant2{12});
+ std::visit([](auto x) { assert(x == 12.3); }, EvilVariant2{12.3});
+ }
+}
+
+struct any_visitor {
+ template <typename T>
+ void operator()(const T&) const {}
+};
+
+template <typename T, typename = decltype(std::visit(std::declval<any_visitor&>(), std::declval<T>()))>
+constexpr bool has_visit(int) {
+ return true;
+}
+
+template <typename T>
+constexpr bool has_visit(...) {
+ return false;
+}
+
+void test_sfinae() {
+ struct BadVariant : std::variant<short>, std::variant<long, float> {};
+ struct BadVariant2 : private std::variant<long, float> {};
+ struct GoodVariant : std::variant<long, float> {};
+ struct GoodVariant2 : GoodVariant {};
+
+ static_assert(!has_visit<int>(0));
+ static_assert(!has_visit<BadVariant>(0));
+ static_assert(!has_visit<BadVariant2>(0));
+ static_assert(has_visit<std::variant<int>>(0));
+ static_assert(has_visit<GoodVariant>(0));
+ static_assert(has_visit<GoodVariant2>(0));
+}
+
+int main(int, char**) {
+ test_call_operator_forwarding();
+ test_argument_forwarding();
+ test_return_type();
+ test_constexpr();
+ test_exceptions();
+ test_caller_accepts_nonconst();
+ test_derived_from_variant();
+ test_sfinae();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/variant/variant.visit/member.visit.robust_against_adl.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/member.visit.robust_against_adl.pass.cpp
new file mode 100644
index 00000000000000..3bd305a7c62c17
--- /dev/null
+++ b/libcxx/test/std/utilities/variant/variant.visit/member.visit.robust_against_adl.pass.cpp
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <variant>
+
+// class variant;
+// template<class Self, class Visitor>
+// constexpr decltype(auto) visit(this Self&&, Visitor&&); // since C++26
+// template<class R, class Self, class Visitor>
+// constexpr R visit(this Self&&, Visitor&&); // since C++26
+
+// template <class Visitor, class... Variants>
+// constexpr see below visit(Visitor&& vis, Variants&&... vars);
+
+#include <variant>
+
+#include "test_macros.h"
+
+struct Incomplete;
+template <class T>
+struct Holder {
+ T t;
+};
+
+constexpr bool test(bool do_it) {
+ if (do_it) {
+ std::variant<Holder<Incomplete>*, int> v = nullptr;
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit([](auto) {});
+ v.visit([](auto) -> Holder<Incomplete>* { return nullptr; });
+ v.visit<void>([](auto) {});
+ v.visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; });
+ }
+#endif
+ // non-member
+ {
+ std::visit([](auto) {}, v);
+ std::visit([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
+#if TEST_STD_VER > 17
+ std::visit<void>([](auto) {}, v);
+ std::visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
+#endif
+ }
+ }
+ return true;
+}
+
+int main(int, char**) {
+ test(true);
+#if TEST_STD_VER > 17
+ static_assert(test(true));
+#endif
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/variant/variant.visit/member.visit_return_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/member.visit_return_type.pass.cpp
new file mode 100644
index 00000000000000..1c73d34cacd87f
--- /dev/null
+++ b/libcxx/test/std/utilities/variant/variant.visit/member.visit_return_type.pass.cpp
@@ -0,0 +1,840 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <variant>
+
+// class variant;
+// template<class R, class Self, class Visitor>
+// constexpr R visit(this Self&&, Visitor&&); // since C++26
+
+// template <class R, class Visitor, class... Variants>
+// constexpr R visit(Visitor&& vis, Variants&&... vars);
+
+#include <cassert>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+#include "test_macros.h"
+#include "variant_test_helpers.h"
+
+template <class... Ts>
+struct overloaded : Ts... {
+ using Ts::operator()...;
+};
+
+void test_overload_ambiguity() {
+#if _LIBCPP_STD_VER >= 26
+ using V = std::variant<float, long, std::string>;
+ using namespace std::string_literals;
+ V v{"baba"s};
+
+ // member
+ v.visit(
+ overloaded{[]([[maybe_unused]] auto x) { assert(false); }, [](const std::string& x) { assert(x == "baba"s); }});
+ assert(std::get<std::string>(v) == "baba"s);
+
+ // Test the constraint.
+ v = std::move(v).visit<V>(overloaded{
+ []([[maybe_unused]] auto x) {
+ assert(false);
+ return 0;
+ },
+ [](const std::string& x) {
+ assert(x == "baba"s);
+ return x + " zmt"s;
+ }});
+ assert(std::get<std::string>(v) == "baba zmt"s);
+#endif
+}
+
+template <typename ReturnType>
+void test_call_operator_forwarding() {
+ using Fn = ForwardingCallObject;
+ Fn obj{};
+ const Fn& cobj = obj;
+
+ { // test call operator forwarding - no variant
+ // non-member
+ {
+ std::visit<ReturnType>(obj);
+ assert(Fn::check_call<>(CT_NonConst | CT_LValue));
+ std::visit<ReturnType>(cobj);
+ assert(Fn::check_call<>(CT_Const | CT_LValue));
+ std::visit<ReturnType>(std::move(obj));
+ assert(Fn::check_call<>(CT_NonConst | CT_RValue));
+ std::visit<ReturnType>(std::move(cobj));
+ assert(Fn::check_call<>(CT_Const | CT_RValue));
+ }
+ }
+ { // test call operator forwarding - single variant, single arg
+ using V = std::variant<int>;
+ V v(42);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
+ v.visit<ReturnType>(cobj);
+ assert(Fn::check_call<int&>(CT_Const | CT_LValue));
+ v.visit<ReturnType>(std::move(obj));
+ assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
+ v.visit<ReturnType>(std::move(cobj));
+ assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+ }
+#endif
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
+ std::visit<ReturnType>(cobj, v);
+ assert(Fn::check_call<int&>(CT_Const | CT_LValue));
+ std::visit<ReturnType>(std::move(obj), v);
+ assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
+ std::visit<ReturnType>(std::move(cobj), v);
+ assert(Fn::check_call<int&>(CT_Const | CT_RValue));
+ }
+ }
+ { // test call operator forwarding - single variant, multi arg
+ using V = std::variant<int, long, double>;
+ V v(42L);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit<ReturnType>(obj);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
+ v.visit<ReturnType>(cobj);
+ assert(Fn::check_call<long&>(CT_Const | CT_LValue));
+ v.visit<ReturnType>(std::move(obj));
+ assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
+ v.visit<ReturnType>(std::move(cobj));
+ assert(Fn::check_call<long&>(CT_Const | CT_RValue));
+ }
+#endif
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
+ std::visit<ReturnType>(cobj, v);
+ assert(Fn::check_call<long&>(CT_Const | CT_LValue));
+ std::visit<ReturnType>(std::move(obj), v);
+ assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
+ std::visit<ReturnType>(std::move(cobj), v);
+ assert(Fn::check_call<long&>(CT_Const | CT_RValue));
+ }
+ }
+ { // test call operator forwarding - multi variant, multi arg
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int*, std::string>;
+ V v(42L);
+ V2 v2("hello");
+
+ // non-member
+ {
+ std::visit<int>(obj, v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_LValue)));
+ std::visit<ReturnType>(cobj, v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_LValue)));
+ std::visit<ReturnType>(std::move(obj), v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
+ std::visit<ReturnType>(std::move(cobj), v, v2);
+ assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
+ }
+ }
+ {
+ using V = std::variant<int, long, double, std::string>;
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_LValue)));
+ std::visit<ReturnType>(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_LValue)));
+ std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_RValue)));
+ std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_RValue)));
+ }
+ }
+ {
+ using V = std::variant<int, long, double, int*, std::string>;
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_LValue)));
+ std::visit<ReturnType>(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_LValue)));
+ std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_RValue)));
+ std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_RValue)));
+ }
+ }
+}
+
+template <typename ReturnType>
+void test_argument_forwarding() {
+ using Fn = ForwardingCallObject;
+ Fn obj{};
+ const auto val = CT_LValue | CT_NonConst;
+
+ { // single argument - value type
+ using V = std::variant<int>;
+ V v(42);
+ const V& cv = v;
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ cv.visit<ReturnType>(obj);
+ assert(Fn::check_call<const int&>(val));
+ std::move(v).visit<ReturnType>(obj);
+ assert(Fn::check_call<int&&>(val));
+ std::move(cv).visit<ReturnType>(obj);
+ assert(Fn::check_call<const int&&>(val));
+ }
+#endif
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int&>(val));
+ std::visit<ReturnType>(obj, cv);
+ assert(Fn::check_call<const int&>(val));
+ std::visit<ReturnType>(obj, std::move(v));
+ assert(Fn::check_call<int&&>(val));
+ std::visit<ReturnType>(obj, std::move(cv));
+ assert(Fn::check_call<const int&&>(val));
+ }
+ }
+#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
+ { // single argument - lvalue reference
+ using V = std::variant<int&>;
+ int x = 42;
+ V v(x);
+ const V& cv = v;
+
+# if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ cv.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(v).visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(cv).visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ }
+# endif
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int&>(val));
+ std::visit<ReturnType>(obj, cv);
+ assert(Fn::check_call<int&>(val));
+ std::visit<ReturnType>(obj, std::move(v));
+ assert(Fn::check_call<int&>(val));
+ std::visit<ReturnType>(obj, std::move(cv));
+ assert(Fn::check_call<int&>(val));
+ }
+ }
+ { // single argument - rvalue reference
+ using V = std::variant<int&&>;
+ int x = 42;
+ V v(std::move(x));
+ const V& cv = v;
+
+# if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ cv.visit<ReturnType>(obj);
+ assert(Fn::check_call<int&>(val));
+ std::move(v).visit<ReturnType>(obj);
+ assert(Fn::check_call<int&&>(val));
+ std::move(cv).visit<ReturnType>(obj);
+ assert(Fn::check_call<int&&>(val));
+ }
+# endif
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int&>(val));
+ std::visit<ReturnType>(obj, cv);
+ assert(Fn::check_call<int&>(val));
+ std::visit<ReturnType>(obj, std::move(v));
+ assert(Fn::check_call<int&&>(val));
+ std::visit<ReturnType>(obj, std::move(cv));
+ assert(Fn::check_call<int&&>(val));
+ }
+ }
+#endif
+ { // multi argument - multi variant
+ using V = std::variant<int, std::string, long>;
+ V v1(42), v2("hello"), v3(43L);
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v1, v2, v3);
+ assert((Fn::check_call<int&, std::string&, long&>(val)));
+ std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
+ assert((Fn::check_call<const int&, const std::string&, long&&>(val)));
+ }
+ }
+ {
+ using V = std::variant<int, long, double, std::string>;
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int&, double&>(val)));
+ std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(val)));
+ }
+ }
+ {
+ using V = std::variant<int, long, double, int*, std::string>;
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
+
+ // non-member
+ {
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long&, std::string&, int*&, double&>(val)));
+ std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(val)));
+ }
+ }
+}
+
+template <typename ReturnType>
+void test_return_type() {
+ using Fn = ForwardingCallObject;
+ Fn obj{};
+ const Fn& cobj = obj;
+
+ { // test call operator forwarding - no variant
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj))), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj))), ReturnType>);
+ }
+ }
+ { // test call operator forwarding - single variant, single arg
+ using V = std::variant<int>;
+ V v(42);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(obj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(cobj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(obj))), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(cobj))), ReturnType>);
+ }
+#endif
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
+ }
+ }
+ { // test call operator forwarding - single variant, multi arg
+ using V = std::variant<int, long, double>;
+ V v(42L);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(obj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(cobj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(obj))), ReturnType>);
+ static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(cobj))), ReturnType>);
+ }
+#endif
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
+ }
+ }
+ { // test call operator forwarding - multi variant, multi arg
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int*, std::string>;
+ V v(42L);
+ V2 v2("hello");
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v, v2)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v, v2)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v, v2)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v, v2)), ReturnType>);
+ }
+ }
+ {
+ using V = std::variant<int, long, double, std::string>;
+ V v1(42L), v2("hello"), v3(101), v4(1.1);
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
+ }
+ }
+ {
+ using V = std::variant<int, long, double, int*, std::string>;
+ V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
+
+ // non-member
+ {
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
+ }
+ }
+}
+
+void test_constexpr_void() {
+ constexpr ReturnFirst obj{};
+ constexpr ReturnArity aobj{};
+ {
+ using V = std::variant<int>;
+ constexpr V v(42);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert((v.visit<void>(obj), 42) == 42); }
+#endif
+ // non-member
+ { static_assert((std::visit<void>(obj, v), 42) == 42, ""); }
+ }
+ {
+ using V = std::variant<short, long, char>;
+ constexpr V v(42L);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert((v.visit<void>(obj), 42) == 42); }
+#endif
+ // non-member
+ { static_assert((std::visit<void>(obj, v), 42) == 42, ""); }
+ }
+ {
+ using V1 = std::variant<int>;
+ using V2 = std::variant<int, char*, long long>;
+ using V3 = std::variant<bool, int, int>;
+ constexpr V1 v1;
+ constexpr V2 v2(nullptr);
+ constexpr V3 v3;
+
+ // non-member
+ { static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, ""); }
+ }
+ {
+ using V1 = std::variant<int>;
+ using V2 = std::variant<int, char*, long long>;
+ using V3 = std::variant<void*, int, int>;
+ constexpr V1 v1;
+ constexpr V2 v2(nullptr);
+ constexpr V3 v3;
+
+ // non-member
+ { static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, ""); }
+ }
+ {
+ using V = std::variant<int, long, double, int*>;
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
+ // non-member
+ { static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, ""); }
+ }
+ {
+ using V = std::variant<int, long, double, long long, int*>;
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
+ // non-member
+ { static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, ""); }
+ }
+}
+
+void test_constexpr_int() {
+ constexpr ReturnFirst obj{};
+ constexpr ReturnArity aobj{};
+
+ {
+ using V = std::variant<int>;
+ constexpr V v(42);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert(v.visit<int>(obj) == 42); }
+#endif
+ // non-member
+ { static_assert(std::visit<int>(obj, v) == 42, ""); }
+ }
+ {
+ using V = std::variant<short, long, char>;
+ constexpr V v(42L);
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { static_assert(v.visit<int>(obj) == 42); }
+#endif
+ // non-member
+ { static_assert(std::visit<int>(obj, v) == 42, ""); }
+ }
+ {
+ using V1 = std::variant<int>;
+ using V2 = std::variant<int, char*, long long>;
+ using V3 = std::variant<bool, int, int>;
+ constexpr V1 v1;
+ constexpr V2 v2(nullptr);
+ constexpr V3 v3;
+
+ // non-member
+ { static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, ""); }
+ }
+ {
+ using V1 = std::variant<int>;
+ using V2 = std::variant<int, char*, long long>;
+ using V3 = std::variant<void*, int, int>;
+ constexpr V1 v1;
+ constexpr V2 v2(nullptr);
+ constexpr V3 v3;
+
+ // non-member
+ { static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, ""); }
+ }
+ {
+ using V = std::variant<int, long, double, int*>;
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
+ // non-member
+ { static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, ""); }
+ }
+ {
+ using V = std::variant<int, long, double, long long, int*>;
+ constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
+
+ // non-member
+ { static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, ""); }
+ }
+}
+
+template <typename ReturnType>
+void test_exceptions() {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ ReturnArity obj{};
+
+# if _LIBCPP_STD_VER >= 26
+ // member
+ auto test_member = [&](auto&& v) {
+ try {
+ v.template visit<ReturnType>(obj);
+ } catch (const std::bad_variant_access&) {
+ return true;
+ } catch (...) {
+ }
+ return false;
+ };
+# endif
+ // non-member
+ auto test_nonmember = [&](auto&&... args) {
+ try {
+ std::visit<ReturnType>(obj, args...);
+ } catch (const std::bad_variant_access&) {
+ return true;
+ } catch (...) {
+ }
+ return false;
+ };
+
+ {
+ using V = std::variant<int, MakeEmptyT>;
+ V v;
+# if _LIBCPP_STD_VER >= 26
+ makeEmpty(v);
+
+ assert(test_member(v));
+# endif
+ makeEmpty(v);
+
+ assert(test_nonmember(v));
+ }
+ {
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*>;
+ V v;
+ makeEmpty(v);
+ V2 v2("hello");
+
+ assert(test_nonmember(v, v2));
+ }
+ {
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*>;
+ V v;
+ makeEmpty(v);
+ V2 v2("hello");
+
+ assert(test_nonmember(v2, v));
+ }
+ {
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void*, MakeEmptyT>;
+ V v;
+ makeEmpty(v);
+ V2 v2;
+ makeEmpty(v2);
+
+ assert(test_nonmember(v, v2));
+ }
+ {
+ using V = std::variant<int, long, double, MakeEmptyT>;
+ V v1(42L), v2(101), v3(202), v4(1.1);
+ makeEmpty(v1);
+
+ assert(test_nonmember(v1, v2, v3, v4));
+ }
+ {
+ using V = std::variant<int, long, double, long long, MakeEmptyT>;
+ V v1(42L), v2(101), v3(202), v4(1.1);
+ makeEmpty(v1);
+ makeEmpty(v2);
+ makeEmpty(v3);
+ makeEmpty(v4);
+
+ assert(test_nonmember(v1, v2, v3, v4));
+ }
+#endif
+}
+
+// See https://bugs.llvm.org/show_bug.cgi?id=31916
+template <typename ReturnType>
+void test_caller_accepts_nonconst() {
+ struct A {};
+ struct Visitor {
+ auto operator()(A&) {
+ if constexpr (!std::is_void_v<ReturnType>) {
+ return ReturnType{};
+ }
+ }
+ };
+ std::variant<A> v;
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ { v.template visit<ReturnType>(Visitor{}); }
+#endif
+ // non-member
+ { std::visit<ReturnType>(Visitor{}, v); }
+}
+
+void test_constexpr_explicit_side_effect() {
+ auto test_lambda = [](int arg) constexpr {
+ std::variant<int> v = 101;
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ v.template visit<void>([arg](int& x) constexpr { x = arg; });
+ }
+#endif
+ // non-member
+ {
+ std::visit<void>([arg](int& x) constexpr { x = arg; }, v);
+ }
+ return std::get<int>(v);
+ };
+
+ static_assert(test_lambda(202) == 202, "");
+}
+
+void test_derived_from_variant() {
+ struct MyVariant : std::variant<short, long, float> {};
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ MyVariant{42}.template visit<bool>([](auto x) {
+ assert(x == 42);
+ return true;
+ });
+ MyVariant{-1.3f}.template visit<bool>([](auto x) {
+ assert(x == -1.3f);
+ return true;
+ });
+ }
+#endif
+ // non-member
+ {
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 42);
+ return true;
+ },
+ MyVariant{42});
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == -1.3f);
+ return true;
+ },
+ MyVariant{-1.3f});
+ }
+
+ // Check that visit does not take index nor valueless_by_exception members from the base class.
+ struct EvilVariantBase {
+ int index;
+ char valueless_by_exception;
+ };
+
+ struct EvilVariant1 : std::variant<int, long, double>, std::tuple<int>, EvilVariantBase {
+ using std::variant<int, long, double>::variant;
+ };
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ EvilVariant1{12}.template visit<bool>([](auto x) {
+ assert(x == 12);
+ return true;
+ });
+ EvilVariant1{12.3}.template visit<bool>([](auto x) {
+ assert(x == 12.3);
+ return true;
+ });
+ }
+#endif
+ // non-member
+ {
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12);
+ return true;
+ },
+ EvilVariant1{12});
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12.3);
+ return true;
+ },
+ EvilVariant1{12.3});
+ }
+
+ // Check that visit unambiguously picks the variant, even if the other base has __impl member.
+ struct ImplVariantBase {
+ struct Callable {
+ bool operator()() const {
+ assert(false);
+ return false;
+ }
+ };
+
+ Callable __impl;
+ };
+
+ struct EvilVariant2 : std::variant<int, long, double>, ImplVariantBase {
+ using std::variant<int, long, double>::variant;
+ };
+
+#if _LIBCPP_STD_VER >= 26
+ // member
+ {
+ EvilVariant2{12}.template visit<bool>([](auto x) {
+ assert(x == 12);
+ return true;
+ });
+ EvilVariant2{12.3}.template visit<bool>([](auto x) {
+ assert(x == 12.3);
+ return true;
+ });
+ }
+#endif
+ // non-member
+ {
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12);
+ return true;
+ },
+ EvilVariant2{12});
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12.3);
+ return true;
+ },
+ EvilVariant2{12.3});
+ }
+}
+
+struct any_visitor {
+ template <typename T>
+ bool operator()(const T&) {
+ return true;
+ }
+};
+
+template <typename T, typename = decltype(std::visit<bool>(std::declval<any_visitor&>(), std::declval<T>()))>
+constexpr bool has_visit(int) {
+ return true;
+}
+
+template <typename T>
+constexpr bool has_visit(...) {
+ return false;
+}
+
+void test_sfinae() {
+ struct BadVariant : std::variant<short>, std::variant<long, float> {};
+
+ static_assert(has_visit<std::variant<int> >(int()));
+ static_assert(!has_visit<BadVariant>(int()));
+}
+
+int main(int, char**) {
+ test_overload_ambiguity();
+ test_call_operator_forwarding<void>();
+ test_argument_forwarding<void>();
+ test_return_type<void>();
+ test_constexpr_void();
+ test_exceptions<void>();
+ test_caller_accepts_nonconst<void>();
+ test_call_operator_forwarding<int>();
+ test_argument_forwarding<int>();
+ test_return_type<int>();
+ test_constexpr_int();
+ test_exceptions<int>();
+ test_caller_accepts_nonconst<int>();
+ test_constexpr_explicit_side_effect();
+ test_derived_from_variant();
+ test_sfinae();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
index 3bd305a7c62c17..6f17fa32648d41 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
@@ -9,13 +9,6 @@
// UNSUPPORTED: c++03, c++11, c++14
// <variant>
-
-// class variant;
-// template<class Self, class Visitor>
-// constexpr decltype(auto) visit(this Self&&, Visitor&&); // since C++26
-// template<class R, class Self, class Visitor>
-// constexpr R visit(this Self&&, Visitor&&); // since C++26
-
// template <class Visitor, class... Variants>
// constexpr see below visit(Visitor&& vis, Variants&&... vars);
@@ -24,41 +17,27 @@
#include "test_macros.h"
struct Incomplete;
-template <class T>
-struct Holder {
- T t;
-};
-
-constexpr bool test(bool do_it) {
- if (do_it) {
- std::variant<Holder<Incomplete>*, int> v = nullptr;
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit([](auto) {});
- v.visit([](auto) -> Holder<Incomplete>* { return nullptr; });
- v.visit<void>([](auto) {});
- v.visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; });
- }
-#endif
- // non-member
- {
- std::visit([](auto) {}, v);
- std::visit([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
+template<class T> struct Holder { T t; };
+
+constexpr bool test(bool do_it)
+{
+ if (do_it) {
+ std::variant<Holder<Incomplete>*, int> v = nullptr;
+ std::visit([](auto){}, v);
+ std::visit([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
#if TEST_STD_VER > 17
- std::visit<void>([](auto) {}, v);
- std::visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
+ std::visit<void>([](auto){}, v);
+ std::visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
#endif
}
- }
- return true;
+ return true;
}
-int main(int, char**) {
- test(true);
+int main(int, char**)
+{
+ test(true);
#if TEST_STD_VER > 17
- static_assert(test(true));
+ static_assert(test(true));
#endif
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 8781174ff7d669..097b784f2bf2ce 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -9,11 +9,6 @@
// UNSUPPORTED: c++03, c++11, c++14
// <variant>
-
-// class variant;
-// template<class Self, class Visitor>
-// constexpr decltype(auto) visit(this Self&&, Visitor&&); // since C++26
-
// template <class Visitor, class... Variants>
// constexpr see below visit(Visitor&& vis, Variants&&... vars);
@@ -30,503 +25,299 @@
void test_call_operator_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
- const Fn& cobj = obj;
-
+ const Fn &cobj = obj;
{ // test call operator forwarding - no variant
- // non-member
- {
- std::visit(obj);
- assert(Fn::check_call<>(CT_NonConst | CT_LValue));
- std::visit(cobj);
- assert(Fn::check_call<>(CT_Const | CT_LValue));
- std::visit(std::move(obj));
- assert(Fn::check_call<>(CT_NonConst | CT_RValue));
- std::visit(std::move(cobj));
- assert(Fn::check_call<>(CT_Const | CT_RValue));
- }
+ std::visit(obj);
+ assert(Fn::check_call<>(CT_NonConst | CT_LValue));
+ std::visit(cobj);
+ assert(Fn::check_call<>(CT_Const | CT_LValue));
+ std::visit(std::move(obj));
+ assert(Fn::check_call<>(CT_NonConst | CT_RValue));
+ std::visit(std::move(cobj));
+ assert(Fn::check_call<>(CT_Const | CT_RValue));
}
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit(obj);
- assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
- v.visit(cobj);
- assert(Fn::check_call<int&>(CT_Const | CT_LValue));
- v.visit(std::move(obj));
- assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
- v.visit(std::move(cobj));
- assert(Fn::check_call<int&>(CT_Const | CT_RValue));
- }
-#endif
- // non-member
- {
- std::visit(obj, v);
- assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
- std::visit(cobj, v);
- assert(Fn::check_call<int&>(CT_Const | CT_LValue));
- std::visit(std::move(obj), v);
- assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
- std::visit(std::move(cobj), v);
- assert(Fn::check_call<int&>(CT_Const | CT_RValue));
- }
+ std::visit(obj, v);
+ assert(Fn::check_call<int &>(CT_NonConst | CT_LValue));
+ std::visit(cobj, v);
+ assert(Fn::check_call<int &>(CT_Const | CT_LValue));
+ std::visit(std::move(obj), v);
+ assert(Fn::check_call<int &>(CT_NonConst | CT_RValue));
+ std::visit(std::move(cobj), v);
+ assert(Fn::check_call<int &>(CT_Const | CT_RValue));
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
- V v(42L);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit(obj);
- assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
- v.visit(cobj);
- assert(Fn::check_call<long&>(CT_Const | CT_LValue));
- v.visit(std::move(obj));
- assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
- v.visit(std::move(cobj));
- assert(Fn::check_call<long&>(CT_Const | CT_RValue));
- }
-#endif
- // non-member
- {
- std::visit(obj, v);
- assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
- std::visit(cobj, v);
- assert(Fn::check_call<long&>(CT_Const | CT_LValue));
- std::visit(std::move(obj), v);
- assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
- std::visit(std::move(cobj), v);
- assert(Fn::check_call<long&>(CT_Const | CT_RValue));
- }
+ V v(42l);
+ std::visit(obj, v);
+ assert(Fn::check_call<long &>(CT_NonConst | CT_LValue));
+ std::visit(cobj, v);
+ assert(Fn::check_call<long &>(CT_Const | CT_LValue));
+ std::visit(std::move(obj), v);
+ assert(Fn::check_call<long &>(CT_NonConst | CT_RValue));
+ std::visit(std::move(cobj), v);
+ assert(Fn::check_call<long &>(CT_Const | CT_RValue));
}
{ // test call operator forwarding - multi variant, multi arg
- using V = std::variant<int, long, double>;
- using V2 = std::variant<int*, std::string>;
- V v(42L);
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int *, std::string>;
+ V v(42l);
V2 v2("hello");
-
- // non-member
- {
- std::visit(obj, v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_LValue)));
- std::visit(cobj, v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_Const | CT_LValue)));
- std::visit(std::move(obj), v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
- std::visit(std::move(cobj), v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
- }
+ std::visit(obj, v, v2);
+ assert((Fn::check_call<long &, std::string &>(CT_NonConst | CT_LValue)));
+ std::visit(cobj, v, v2);
+ assert((Fn::check_call<long &, std::string &>(CT_Const | CT_LValue)));
+ std::visit(std::move(obj), v, v2);
+ assert((Fn::check_call<long &, std::string &>(CT_NonConst | CT_RValue)));
+ std::visit(std::move(cobj), v, v2);
+ assert((Fn::check_call<long &, std::string &>(CT_Const | CT_RValue)));
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42L), v2("hello"), v3(101), v4(1.1);
-
- // non-member
- {
- std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_LValue)));
- std::visit(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_LValue)));
- std::visit(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_RValue)));
- std::visit(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_RValue)));
- }
+ V v1(42l), v2("hello"), v3(101), v4(1.1);
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int &, double &>(CT_NonConst | CT_LValue)));
+ std::visit(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int &, double &>(CT_Const | CT_LValue)));
+ std::visit(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int &, double &>(CT_NonConst | CT_RValue)));
+ std::visit(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int &, double &>(CT_Const | CT_RValue)));
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
-
- // non-member
- {
- std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_LValue)));
- std::visit(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_LValue)));
- std::visit(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_RValue)));
- std::visit(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_RValue)));
- }
+ V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_NonConst | CT_LValue)));
+ std::visit(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_Const | CT_LValue)));
+ std::visit(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_NonConst | CT_RValue)));
+ std::visit(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_Const | CT_RValue)));
}
}
-// Applies to non-member `std::visit` only.
void test_argument_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
- const auto val = CT_LValue | CT_NonConst;
-
+ const auto Val = CT_LValue | CT_NonConst;
{ // single argument - value type
using V = std::variant<int>;
V v(42);
- const V& cv = v;
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit(obj);
- assert(Fn::check_call<int&>(val));
- cv.visit(obj);
- assert(Fn::check_call<const int&>(val));
- std::move(v).visit(obj);
- assert(Fn::check_call<int&&>(val));
- std::move(cv).visit(obj);
- assert(Fn::check_call<const int&&>(val));
- }
-#endif
- // non-member
- {
- std::visit(obj, v);
- assert(Fn::check_call<int&>(val));
- std::visit(obj, cv);
- assert(Fn::check_call<const int&>(val));
- std::visit(obj, std::move(v));
- assert(Fn::check_call<int&&>(val));
- std::visit(obj, std::move(cv));
- assert(Fn::check_call<const int&&>(val));
- }
+ const V &cv = v;
+ std::visit(obj, v);
+ assert(Fn::check_call<int &>(Val));
+ std::visit(obj, cv);
+ assert(Fn::check_call<const int &>(Val));
+ std::visit(obj, std::move(v));
+ assert(Fn::check_call<int &&>(Val));
+ std::visit(obj, std::move(cv));
+ assert(Fn::check_call<const int &&>(Val));
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{ // single argument - lvalue reference
- using V = std::variant<int&>;
- int x = 42;
+ using V = std::variant<int &>;
+ int x = 42;
V v(x);
- const V& cv = v;
-
-# if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit(obj);
- assert(Fn::check_call<int&>(val));
- cv.visit(obj);
- assert(Fn::check_call<int&>(val));
- std::move(v).visit(obj);
- assert(Fn::check_call<int&>(val));
- std::move(cv).visit(obj);
- assert(Fn::check_call<int&>(val));
- assert(false);
- }
-# endif
- // non-member
- {
- std::visit(obj, v);
- assert(Fn::check_call<int&>(val));
- std::visit(obj, cv);
- assert(Fn::check_call<int&>(val));
- std::visit(obj, std::move(v));
- assert(Fn::check_call<int&>(val));
- std::visit(obj, std::move(cv));
- assert(Fn::check_call<int&>(val));
- }
+ const V &cv = v;
+ std::visit(obj, v);
+ assert(Fn::check_call<int &>(Val));
+ std::visit(obj, cv);
+ assert(Fn::check_call<int &>(Val));
+ std::visit(obj, std::move(v));
+ assert(Fn::check_call<int &>(Val));
+ std::visit(obj, std::move(cv));
+ assert(Fn::check_call<int &>(Val));
}
{ // single argument - rvalue reference
- using V = std::variant<int&&>;
- int x = 42;
+ using V = std::variant<int &&>;
+ int x = 42;
V v(std::move(x));
- const V& cv = v;
-
-# if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit(obj);
- assert(Fn::check_call<int&>(val));
- cvstd::visit(obj);
- assert(Fn::check_call<int&>(val));
- std::move(v).visit(obj);
- assert(Fn::check_call<int&&>(val));
- std::move(cv).visit(obj);
- assert(Fn::check_call<int&&>(val));
- }
-# endif
- // non-member
- {
- std::visit(obj, v);
- assert(Fn::check_call<int&>(val));
- std::visit(obj, cv);
- assert(Fn::check_call<int&>(val));
- std::visit(obj, std::move(v));
- assert(Fn::check_call<int&&>(val));
- std::visit(obj, std::move(cv));
- assert(Fn::check_call<int&&>(val));
- }
+ const V &cv = v;
+ std::visit(obj, v);
+ assert(Fn::check_call<int &>(Val));
+ std::visit(obj, cv);
+ assert(Fn::check_call<int &>(Val));
+ std::visit(obj, std::move(v));
+ assert(Fn::check_call<int &&>(Val));
+ std::visit(obj, std::move(cv));
+ assert(Fn::check_call<int &&>(Val));
}
#endif
{ // multi argument - multi variant
using V = std::variant<int, std::string, long>;
- V v1(42), v2("hello"), v3(43L);
-
- // non-member
- {
- std::visit(obj, v1, v2, v3);
- assert((Fn::check_call<int&, std::string&, long&>(val)));
- std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
- assert((Fn::check_call<const int&, const std::string&, long&&>(val)));
- }
+ V v1(42), v2("hello"), v3(43l);
+ std::visit(obj, v1, v2, v3);
+ assert((Fn::check_call<int &, std::string &, long &>(Val)));
+ std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
+ assert((Fn::check_call<const int &, const std::string &, long &&>(Val)));
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42L), v2("hello"), v3(101), v4(1.1);
-
- // non-member
- {
- std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(val)));
- std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(val)));
- }
+ V v1(42l), v2("hello"), v3(101), v4(1.1);
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int &, double &>(Val)));
+ std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long &, const std::string &, int &&, double &&>(Val)));
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
-
- // non-member
- {
- std::visit(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(val)));
- std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(val)));
- }
+ V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+ std::visit(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int *&, double &>(Val)));
+ std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long &, const std::string &, int *&&, double &&>(Val)));
}
}
void test_return_type() {
using Fn = ForwardingCallObject;
Fn obj{};
- const Fn& cobj = obj;
-
+ const Fn &cobj = obj;
{ // test call operator forwarding - no variant
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit(obj)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj))), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj))), const Fn&&>);
- }
+ static_assert(std::is_same_v<decltype(std::visit(obj)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj))), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj))), const Fn&&>);
}
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- static_assert(std::is_same_v<decltype(v.visit(obj)), Fn&>);
- static_assert(std::is_same_v<decltype(v.visit(cobj)), const Fn&>);
- static_assert(std::is_same_v<decltype(v.visit(std::move(obj))), Fn&&>);
- static_assert(std::is_same_v<decltype(v.visit(std::move(cobj))), const Fn&&>);
- }
-#endif
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
- }
+ static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
- V v(42L);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- static_assert(std::is_same_v<decltype(v.visit(obj)), Fn&>);
- static_assert(std::is_same_v<decltype(v.visit(cobj)), const Fn&>);
- static_assert(std::is_same_v<decltype(v.visit(std::move(obj))), Fn&&>);
- static_assert(std::is_same_v<decltype(v.visit(std::move(cobj))), const Fn&&>);
- }
-#endif
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
- }
+ V v(42l);
+ static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
}
{ // test call operator forwarding - multi variant, multi arg
- using V = std::variant<int, long, double>;
- using V2 = std::variant<int*, std::string>;
- V v(42L);
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int *, std::string>;
+ V v(42l);
V2 v2("hello");
-
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit(obj, v, v2)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj, v, v2)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v, v2)), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v, v2)), const Fn&&>);
- }
+ static_assert(std::is_same_v<decltype(std::visit(obj, v, v2)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v, v2)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v, v2)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v, v2)), const Fn&&>);
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42L), v2("hello"), v3(101), v4(1.1);
-
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
- }
+ V v1(42l), v2("hello"), v3(101), v4(1.1);
+ static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
-
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
- static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
- }
+ V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+ static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
+ static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
}
}
void test_constexpr() {
constexpr ReturnFirst obj{};
constexpr ReturnArity aobj{};
-
{
using V = std::variant<int>;
constexpr V v(42);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- { static_assert(v.visit(obj) == 42); }
-#endif
- // non-member
- { static_assert(std::visit(obj, v) == 42, ""); }
+ static_assert(std::visit(obj, v) == 42, "");
}
{
using V = std::variant<short, long, char>;
- constexpr V v(42L);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- { static_assert(v.visit(obj) == 42); }
-#endif
- // non-member
- { static_assert(std::visit(obj, v) == 42, ""); }
+ constexpr V v(42l);
+ static_assert(std::visit(obj, v) == 42, "");
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char*, long long>;
+ using V2 = std::variant<int, char *, long long>;
using V3 = std::variant<bool, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
-
- // non-member
- { static_assert(std::visit(aobj, v1, v2, v3) == 3, ""); }
+ static_assert(std::visit(aobj, v1, v2, v3) == 3, "");
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char*, long long>;
- using V3 = std::variant<void*, int, int>;
+ using V2 = std::variant<int, char *, long long>;
+ using V3 = std::variant<void *, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
-
- // non-member
- { static_assert(std::visit(aobj, v1, v2, v3) == 3, ""); }
+ static_assert(std::visit(aobj, v1, v2, v3) == 3, "");
}
{
- using V = std::variant<int, long, double, int*>;
- constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
-
- // non-member
- { static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, ""); }
+ using V = std::variant<int, long, double, int *>;
+ constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
+ static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, "");
}
{
- using V = std::variant<int, long, double, long long, int*>;
- constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
-
- // non-member
- { static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, ""); }
+ using V = std::variant<int, long, double, long long, int *>;
+ constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
+ static_assert(std::visit(aobj, v1, v2, v3, v4) == 4, "");
}
}
void test_exceptions() {
#ifndef TEST_HAS_NO_EXCEPTIONS
ReturnArity obj{};
-
-# if _LIBCPP_STD_VER >= 26
- // member
- auto test_member = [&](auto&& v) {
- try {
- v.visit(obj);
- } catch (const std::bad_variant_access&) {
- return true;
- } catch (...) {
- }
- return false;
- };
-# endif
- // non-member
- auto test_nonmember = [&](auto&&... args) {
+ auto test = [&](auto &&... args) {
try {
std::visit(obj, args...);
- } catch (const std::bad_variant_access&) {
+ } catch (const std::bad_variant_access &) {
return true;
} catch (...) {
}
return false;
};
-
{
using V = std::variant<int, MakeEmptyT>;
V v;
-# if _LIBCPP_STD_VER >= 26
- makeEmpty(v);
-
- assert(test_member(v));
-# endif
makeEmpty(v);
-
- assert(test_nonmember(v));
+ assert(test(v));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void*>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void *>;
V v;
makeEmpty(v);
V2 v2("hello");
-
- assert(test_nonmember(v, v2));
+ assert(test(v, v2));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void*>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void *>;
V v;
makeEmpty(v);
V2 v2("hello");
-
- assert(test_nonmember(v2, v));
+ assert(test(v2, v));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void*, MakeEmptyT>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void *, MakeEmptyT>;
V v;
makeEmpty(v);
V2 v2;
makeEmpty(v2);
-
- assert(test_nonmember(v, v2));
+ assert(test(v, v2));
}
{
using V = std::variant<int, long, double, MakeEmptyT>;
V v1(42l), v2(101), v3(202), v4(1.1);
makeEmpty(v1);
-
- assert(test_nonmember(v1, v2, v3, v4));
+ assert(test(v1, v2, v3, v4));
}
{
using V = std::variant<int, long, double, long long, MakeEmptyT>;
@@ -535,8 +326,7 @@ void test_exceptions() {
makeEmpty(v2);
makeEmpty(v3);
makeEmpty(v4);
-
- assert(test_nonmember(v1, v2, v3, v4));
+ assert(test(v1, v2, v3, v4));
}
#endif
}
@@ -548,13 +338,7 @@ void test_caller_accepts_nonconst() {
void operator()(A&) {}
};
std::variant<A> v;
-
-#if _LIBCPP_STD_VER >= 26
- // member
- { v.visit(Visitor{}); }
-#endif
- // non-member
- { std::visit(Visitor{}, v); }
+ std::visit(Visitor{}, v);
}
struct MyVariant : std::variant<short, long, float> {};
@@ -567,27 +351,13 @@ void get(const MyVariant&) {
} // namespace std
void test_derived_from_variant() {
- auto v1 = MyVariant{42};
+ auto v1 = MyVariant{42};
const auto cv1 = MyVariant{142};
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- v1.visit([](auto x) { assert(x == 42); });
- cv1.visit([](auto x) { assert(x == 142); });
- MyVariant{-1.25f}.visit([](auto x) { assert(x == -1.25f); });
- std::move(v1).visit([](auto x) { assert(x == 42); });
- std::move(cv1).visit([](auto x) { assert(x == 142); });
- }
-#endif
- // non-member
- {
- std::visit([](auto x) { assert(x == 42); }, v1);
- std::visit([](auto x) { assert(x == 142); }, cv1);
- std::visit([](auto x) { assert(x == -1.25f); }, MyVariant{-1.25f});
- std::visit([](auto x) { assert(x == 42); }, std::move(v1));
- std::visit([](auto x) { assert(x == 142); }, std::move(cv1));
- }
+ std::visit([](auto x) { assert(x == 42); }, v1);
+ std::visit([](auto x) { assert(x == 142); }, cv1);
+ std::visit([](auto x) { assert(x == -1.25f); }, MyVariant{-1.25f});
+ std::visit([](auto x) { assert(x == 42); }, std::move(v1));
+ std::visit([](auto x) { assert(x == 142); }, std::move(cv1));
// Check that visit does not take index nor valueless_by_exception members from the base class.
struct EvilVariantBase {
@@ -595,30 +365,19 @@ void test_derived_from_variant() {
char valueless_by_exception;
};
- struct EvilVariant1 : std::variant<int, long, double>, std::tuple<int>, EvilVariantBase {
+ struct EvilVariant1 : std::variant<int, long, double>,
+ std::tuple<int>,
+ EvilVariantBase {
using std::variant<int, long, double>::variant;
};
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- EvilVariant1{12}.visit([](auto x) { assert(x == 12); });
- EvilVariant1{12.3}.visit([](auto x) { assert(x == 12.3); });
- }
-#endif
- // non-member
- {
- std::visit([](auto x) { assert(x == 12); }, EvilVariant1{12});
- std::visit([](auto x) { assert(x == 12.3); }, EvilVariant1{12.3});
- }
+ std::visit([](auto x) { assert(x == 12); }, EvilVariant1{12});
+ std::visit([](auto x) { assert(x == 12.3); }, EvilVariant1{12.3});
// Check that visit unambiguously picks the variant, even if the other base has __impl member.
struct ImplVariantBase {
struct Callable {
- bool operator()() const {
- assert(false);
- return false;
- }
+ bool operator()() const { assert(false); return false; }
};
Callable __impl;
@@ -628,18 +387,8 @@ void test_derived_from_variant() {
using std::variant<int, long, double>::variant;
};
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- EvilVariant2{12}.visit([](auto x) { assert(x == 12); });
- EvilVariant2{12.3}.visit([](auto x) { assert(x == 12.3); });
- }
-#endif
- // non-member
- {
- std::visit([](auto x) { assert(x == 12); }, EvilVariant2{12});
- std::visit([](auto x) { assert(x == 12.3); }, EvilVariant2{12.3});
- }
+ std::visit([](auto x) { assert(x == 12); }, EvilVariant2{12});
+ std::visit([](auto x) { assert(x == 12.3); }, EvilVariant2{12.3});
}
struct any_visitor {
@@ -647,7 +396,8 @@ struct any_visitor {
void operator()(const T&) const {}
};
-template <typename T, typename = decltype(std::visit(std::declval<any_visitor&>(), std::declval<T>()))>
+template <typename T, typename = decltype(std::visit(
+ std::declval<any_visitor&>(), std::declval<T>()))>
constexpr bool has_visit(int) {
return true;
}
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
index 1c73d34cacd87f..eb425c07f93222 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
@@ -9,11 +9,6 @@
// UNSUPPORTED: c++03, c++11, c++14, c++17
// <variant>
-
-// class variant;
-// template<class R, class Self, class Visitor>
-// constexpr R visit(this Self&&, Visitor&&); // since C++26
-
// template <class R, class Visitor, class... Variants>
// constexpr R visit(Visitor&& vis, Variants&&... vars);
@@ -27,162 +22,82 @@
#include "test_macros.h"
#include "variant_test_helpers.h"
-template <class... Ts>
-struct overloaded : Ts... {
- using Ts::operator()...;
-};
-
-void test_overload_ambiguity() {
-#if _LIBCPP_STD_VER >= 26
- using V = std::variant<float, long, std::string>;
- using namespace std::string_literals;
- V v{"baba"s};
-
- // member
- v.visit(
- overloaded{[]([[maybe_unused]] auto x) { assert(false); }, [](const std::string& x) { assert(x == "baba"s); }});
- assert(std::get<std::string>(v) == "baba"s);
-
- // Test the constraint.
- v = std::move(v).visit<V>(overloaded{
- []([[maybe_unused]] auto x) {
- assert(false);
- return 0;
- },
- [](const std::string& x) {
- assert(x == "baba"s);
- return x + " zmt"s;
- }});
- assert(std::get<std::string>(v) == "baba zmt"s);
-#endif
-}
-
template <typename ReturnType>
void test_call_operator_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
- const Fn& cobj = obj;
-
+ const Fn &cobj = obj;
{ // test call operator forwarding - no variant
- // non-member
- {
- std::visit<ReturnType>(obj);
- assert(Fn::check_call<>(CT_NonConst | CT_LValue));
- std::visit<ReturnType>(cobj);
- assert(Fn::check_call<>(CT_Const | CT_LValue));
- std::visit<ReturnType>(std::move(obj));
- assert(Fn::check_call<>(CT_NonConst | CT_RValue));
- std::visit<ReturnType>(std::move(cobj));
- assert(Fn::check_call<>(CT_Const | CT_RValue));
- }
+ std::visit<ReturnType>(obj);
+ assert(Fn::check_call<>(CT_NonConst | CT_LValue));
+ std::visit<ReturnType>(cobj);
+ assert(Fn::check_call<>(CT_Const | CT_LValue));
+ std::visit<ReturnType>(std::move(obj));
+ assert(Fn::check_call<>(CT_NonConst | CT_RValue));
+ std::visit<ReturnType>(std::move(cobj));
+ assert(Fn::check_call<>(CT_Const | CT_RValue));
}
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit<ReturnType>(obj);
- assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
- v.visit<ReturnType>(cobj);
- assert(Fn::check_call<int&>(CT_Const | CT_LValue));
- v.visit<ReturnType>(std::move(obj));
- assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
- v.visit<ReturnType>(std::move(cobj));
- assert(Fn::check_call<int&>(CT_Const | CT_RValue));
- }
-#endif
- // non-member
- {
- std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
- std::visit<ReturnType>(cobj, v);
- assert(Fn::check_call<int&>(CT_Const | CT_LValue));
- std::visit<ReturnType>(std::move(obj), v);
- assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
- std::visit<ReturnType>(std::move(cobj), v);
- assert(Fn::check_call<int&>(CT_Const | CT_RValue));
- }
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int &>(CT_NonConst | CT_LValue));
+ std::visit<ReturnType>(cobj, v);
+ assert(Fn::check_call<int &>(CT_Const | CT_LValue));
+ std::visit<ReturnType>(std::move(obj), v);
+ assert(Fn::check_call<int &>(CT_NonConst | CT_RValue));
+ std::visit<ReturnType>(std::move(cobj), v);
+ assert(Fn::check_call<int &>(CT_Const | CT_RValue));
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
- V v(42L);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit<ReturnType>(obj);
- assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
- v.visit<ReturnType>(cobj);
- assert(Fn::check_call<long&>(CT_Const | CT_LValue));
- v.visit<ReturnType>(std::move(obj));
- assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
- v.visit<ReturnType>(std::move(cobj));
- assert(Fn::check_call<long&>(CT_Const | CT_RValue));
- }
-#endif
- // non-member
- {
- std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<long&>(CT_NonConst | CT_LValue));
- std::visit<ReturnType>(cobj, v);
- assert(Fn::check_call<long&>(CT_Const | CT_LValue));
- std::visit<ReturnType>(std::move(obj), v);
- assert(Fn::check_call<long&>(CT_NonConst | CT_RValue));
- std::visit<ReturnType>(std::move(cobj), v);
- assert(Fn::check_call<long&>(CT_Const | CT_RValue));
- }
+ V v(42l);
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<long &>(CT_NonConst | CT_LValue));
+ std::visit<ReturnType>(cobj, v);
+ assert(Fn::check_call<long &>(CT_Const | CT_LValue));
+ std::visit<ReturnType>(std::move(obj), v);
+ assert(Fn::check_call<long &>(CT_NonConst | CT_RValue));
+ std::visit<ReturnType>(std::move(cobj), v);
+ assert(Fn::check_call<long &>(CT_Const | CT_RValue));
}
{ // test call operator forwarding - multi variant, multi arg
- using V = std::variant<int, long, double>;
- using V2 = std::variant<int*, std::string>;
- V v(42L);
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int *, std::string>;
+ V v(42l);
V2 v2("hello");
-
- // non-member
- {
- std::visit<int>(obj, v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_LValue)));
- std::visit<ReturnType>(cobj, v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_Const | CT_LValue)));
- std::visit<ReturnType>(std::move(obj), v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_NonConst | CT_RValue)));
- std::visit<ReturnType>(std::move(cobj), v, v2);
- assert((Fn::check_call<long&, std::string&>(CT_Const | CT_RValue)));
- }
+ std::visit<int>(obj, v, v2);
+ assert((Fn::check_call<long &, std::string &>(CT_NonConst | CT_LValue)));
+ std::visit<ReturnType>(cobj, v, v2);
+ assert((Fn::check_call<long &, std::string &>(CT_Const | CT_LValue)));
+ std::visit<ReturnType>(std::move(obj), v, v2);
+ assert((Fn::check_call<long &, std::string &>(CT_NonConst | CT_RValue)));
+ std::visit<ReturnType>(std::move(cobj), v, v2);
+ assert((Fn::check_call<long &, std::string &>(CT_Const | CT_RValue)));
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42L), v2("hello"), v3(101), v4(1.1);
-
- // non-member
- {
- std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_LValue)));
- std::visit<ReturnType>(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_LValue)));
- std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_NonConst | CT_RValue)));
- std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(CT_Const | CT_RValue)));
- }
+ V v1(42l), v2("hello"), v3(101), v4(1.1);
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int &, double &>(CT_NonConst | CT_LValue)));
+ std::visit<ReturnType>(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int &, double &>(CT_Const | CT_LValue)));
+ std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int &, double &>(CT_NonConst | CT_RValue)));
+ std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int &, double &>(CT_Const | CT_RValue)));
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
-
- // non-member
- {
- std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_LValue)));
- std::visit<ReturnType>(cobj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_LValue)));
- std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_NonConst | CT_RValue)));
- std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(CT_Const | CT_RValue)));
- }
+ V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_NonConst | CT_LValue)));
+ std::visit<ReturnType>(cobj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_Const | CT_LValue)));
+ std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_NonConst | CT_RValue)));
+ std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int *&, double &>(CT_Const | CT_RValue)));
}
}
@@ -190,137 +105,73 @@ template <typename ReturnType>
void test_argument_forwarding() {
using Fn = ForwardingCallObject;
Fn obj{};
- const auto val = CT_LValue | CT_NonConst;
-
+ const auto Val = CT_LValue | CT_NonConst;
{ // single argument - value type
using V = std::variant<int>;
V v(42);
- const V& cv = v;
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit<ReturnType>(obj);
- assert(Fn::check_call<int&>(val));
- cv.visit<ReturnType>(obj);
- assert(Fn::check_call<const int&>(val));
- std::move(v).visit<ReturnType>(obj);
- assert(Fn::check_call<int&&>(val));
- std::move(cv).visit<ReturnType>(obj);
- assert(Fn::check_call<const int&&>(val));
- }
-#endif
- // non-member
- {
- std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int&>(val));
- std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<const int&>(val));
- std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int&&>(val));
- std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<const int&&>(val));
- }
+ const V &cv = v;
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int &>(Val));
+ std::visit<ReturnType>(obj, cv);
+ assert(Fn::check_call<const int &>(Val));
+ std::visit<ReturnType>(obj, std::move(v));
+ assert(Fn::check_call<int &&>(Val));
+ std::visit<ReturnType>(obj, std::move(cv));
+ assert(Fn::check_call<const int &&>(Val));
}
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
{ // single argument - lvalue reference
- using V = std::variant<int&>;
- int x = 42;
+ using V = std::variant<int &>;
+ int x = 42;
V v(x);
- const V& cv = v;
-
-# if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit<ReturnType>(obj);
- assert(Fn::check_call<int&>(val));
- cv.visit<ReturnType>(obj);
- assert(Fn::check_call<int&>(val));
- std::move(v).visit<ReturnType>(obj);
- assert(Fn::check_call<int&>(val));
- std::move(cv).visit<ReturnType>(obj);
- assert(Fn::check_call<int&>(val));
- }
-# endif
- // non-member
- {
- std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int&>(val));
- std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<int&>(val));
- std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int&>(val));
- std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<int&>(val));
- }
+ const V &cv = v;
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int &>(Val));
+ std::visit<ReturnType>(obj, cv);
+ assert(Fn::check_call<int &>(Val));
+ std::visit<ReturnType>(obj, std::move(v));
+ assert(Fn::check_call<int &>(Val));
+ std::visit<ReturnType>(obj, std::move(cv));
+ assert(Fn::check_call<int &>(Val));
}
{ // single argument - rvalue reference
- using V = std::variant<int&&>;
- int x = 42;
+ using V = std::variant<int &&>;
+ int x = 42;
V v(std::move(x));
- const V& cv = v;
-
-# if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit<ReturnType>(obj);
- assert(Fn::check_call<int&>(val));
- cv.visit<ReturnType>(obj);
- assert(Fn::check_call<int&>(val));
- std::move(v).visit<ReturnType>(obj);
- assert(Fn::check_call<int&&>(val));
- std::move(cv).visit<ReturnType>(obj);
- assert(Fn::check_call<int&&>(val));
- }
-# endif
- // non-member
- {
- std::visit<ReturnType>(obj, v);
- assert(Fn::check_call<int&>(val));
- std::visit<ReturnType>(obj, cv);
- assert(Fn::check_call<int&>(val));
- std::visit<ReturnType>(obj, std::move(v));
- assert(Fn::check_call<int&&>(val));
- std::visit<ReturnType>(obj, std::move(cv));
- assert(Fn::check_call<int&&>(val));
- }
+ const V &cv = v;
+ std::visit<ReturnType>(obj, v);
+ assert(Fn::check_call<int &>(Val));
+ std::visit<ReturnType>(obj, cv);
+ assert(Fn::check_call<int &>(Val));
+ std::visit<ReturnType>(obj, std::move(v));
+ assert(Fn::check_call<int &&>(Val));
+ std::visit<ReturnType>(obj, std::move(cv));
+ assert(Fn::check_call<int &&>(Val));
}
#endif
{ // multi argument - multi variant
using V = std::variant<int, std::string, long>;
- V v1(42), v2("hello"), v3(43L);
-
- // non-member
- {
- std::visit<ReturnType>(obj, v1, v2, v3);
- assert((Fn::check_call<int&, std::string&, long&>(val)));
- std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
- assert((Fn::check_call<const int&, const std::string&, long&&>(val)));
- }
+ V v1(42), v2("hello"), v3(43l);
+ std::visit<ReturnType>(obj, v1, v2, v3);
+ assert((Fn::check_call<int &, std::string &, long &>(Val)));
+ std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3));
+ assert((Fn::check_call<const int &, const std::string &, long &&>(Val)));
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42L), v2("hello"), v3(101), v4(1.1);
-
- // non-member
- {
- std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int&, double&>(val)));
- std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long&, const std::string&, int&&, double&&>(val)));
- }
+ V v1(42l), v2("hello"), v3(101), v4(1.1);
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int &, double &>(Val)));
+ std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long &, const std::string &, int &&, double &&>(Val)));
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
-
- // non-member
- {
- std::visit<ReturnType>(obj, v1, v2, v3, v4);
- assert((Fn::check_call<long&, std::string&, int*&, double&>(val)));
- std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
- assert((Fn::check_call<const long&, const std::string&, int*&&, double&&>(val)));
- }
+ V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+ std::visit<ReturnType>(obj, v1, v2, v3, v4);
+ assert((Fn::check_call<long &, std::string &, int *&, double &>(Val)));
+ std::visit<ReturnType>(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
+ assert((Fn::check_call<const long &, const std::string &, int *&&, double &&>(Val)));
}
}
@@ -328,96 +179,54 @@ template <typename ReturnType>
void test_return_type() {
using Fn = ForwardingCallObject;
Fn obj{};
- const Fn& cobj = obj;
-
+ const Fn &cobj = obj;
{ // test call operator forwarding - no variant
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj))), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj))), ReturnType>);
- }
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj))), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj))), ReturnType>);
}
{ // test call operator forwarding - single variant, single arg
using V = std::variant<int>;
V v(42);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- static_assert(std::is_same_v<decltype(v.visit<ReturnType>(obj)), ReturnType>);
- static_assert(std::is_same_v<decltype(v.visit<ReturnType>(cobj)), ReturnType>);
- static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(obj))), ReturnType>);
- static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(cobj))), ReturnType>);
- }
-#endif
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
- }
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
}
{ // test call operator forwarding - single variant, multi arg
using V = std::variant<int, long, double>;
- V v(42L);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- static_assert(std::is_same_v<decltype(v.visit<ReturnType>(obj)), ReturnType>);
- static_assert(std::is_same_v<decltype(v.visit<ReturnType>(cobj)), ReturnType>);
- static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(obj))), ReturnType>);
- static_assert(std::is_same_v<decltype(v.visit<ReturnType>(std::move(cobj))), ReturnType>);
- }
-#endif
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
- }
+ V v(42l);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v)), ReturnType>);
}
{ // test call operator forwarding - multi variant, multi arg
- using V = std::variant<int, long, double>;
- using V2 = std::variant<int*, std::string>;
- V v(42L);
+ using V = std::variant<int, long, double>;
+ using V2 = std::variant<int *, std::string>;
+ V v(42l);
V2 v2("hello");
-
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v, v2)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v, v2)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v, v2)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v, v2)), ReturnType>);
- }
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v, v2)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v, v2)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v, v2)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v, v2)), ReturnType>);
}
{
using V = std::variant<int, long, double, std::string>;
- V v1(42L), v2("hello"), v3(101), v4(1.1);
-
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
- }
+ V v1(42l), v2("hello"), v3(101), v4(1.1);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
}
{
using V = std::variant<int, long, double, int*, std::string>;
- V v1(42L), v2("hello"), v3(nullptr), v4(1.1);
-
- // non-member
- {
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
- static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
- }
+ V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
+ static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
}
}
@@ -427,124 +236,83 @@ void test_constexpr_void() {
{
using V = std::variant<int>;
constexpr V v(42);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- { static_assert((v.visit<void>(obj), 42) == 42); }
-#endif
- // non-member
- { static_assert((std::visit<void>(obj, v), 42) == 42, ""); }
+ static_assert((std::visit<void>(obj, v), 42) == 42, "");
}
{
using V = std::variant<short, long, char>;
- constexpr V v(42L);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- { static_assert((v.visit<void>(obj), 42) == 42); }
-#endif
- // non-member
- { static_assert((std::visit<void>(obj, v), 42) == 42, ""); }
+ constexpr V v(42l);
+ static_assert((std::visit<void>(obj, v), 42) == 42, "");
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char*, long long>;
+ using V2 = std::variant<int, char *, long long>;
using V3 = std::variant<bool, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
-
- // non-member
- { static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, ""); }
+ static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, "");
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char*, long long>;
- using V3 = std::variant<void*, int, int>;
+ using V2 = std::variant<int, char *, long long>;
+ using V3 = std::variant<void *, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
-
- // non-member
- { static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, ""); }
+ static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, "");
}
{
- using V = std::variant<int, long, double, int*>;
- constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
-
- // non-member
- { static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, ""); }
+ using V = std::variant<int, long, double, int *>;
+ constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
+ static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, "");
}
{
- using V = std::variant<int, long, double, long long, int*>;
- constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
-
- // non-member
- { static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, ""); }
+ using V = std::variant<int, long, double, long long, int *>;
+ constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
+ static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, "");
}
}
void test_constexpr_int() {
constexpr ReturnFirst obj{};
constexpr ReturnArity aobj{};
-
{
using V = std::variant<int>;
constexpr V v(42);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- { static_assert(v.visit<int>(obj) == 42); }
-#endif
- // non-member
- { static_assert(std::visit<int>(obj, v) == 42, ""); }
+ static_assert(std::visit<int>(obj, v) == 42, "");
}
{
using V = std::variant<short, long, char>;
- constexpr V v(42L);
-
-#if _LIBCPP_STD_VER >= 26
- // member
- { static_assert(v.visit<int>(obj) == 42); }
-#endif
- // non-member
- { static_assert(std::visit<int>(obj, v) == 42, ""); }
+ constexpr V v(42l);
+ static_assert(std::visit<int>(obj, v) == 42, "");
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char*, long long>;
+ using V2 = std::variant<int, char *, long long>;
using V3 = std::variant<bool, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
-
- // non-member
- { static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, ""); }
+ static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, "");
}
{
using V1 = std::variant<int>;
- using V2 = std::variant<int, char*, long long>;
- using V3 = std::variant<void*, int, int>;
+ using V2 = std::variant<int, char *, long long>;
+ using V3 = std::variant<void *, int, int>;
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
-
- // non-member
- { static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, ""); }
+ static_assert(std::visit<int>(aobj, v1, v2, v3) == 3, "");
}
{
- using V = std::variant<int, long, double, int*>;
- constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
-
- // non-member
- { static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, ""); }
+ using V = std::variant<int, long, double, int *>;
+ constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
+ static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, "");
}
{
- using V = std::variant<int, long, double, long long, int*>;
- constexpr V v1(42L), v2(101), v3(nullptr), v4(1.1);
-
- // non-member
- { static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, ""); }
+ using V = std::variant<int, long, double, long long, int *>;
+ constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
+ static_assert(std::visit<int>(aobj, v1, v2, v3, v4) == 4, "");
}
}
@@ -552,86 +320,60 @@ template <typename ReturnType>
void test_exceptions() {
#ifndef TEST_HAS_NO_EXCEPTIONS
ReturnArity obj{};
-
-# if _LIBCPP_STD_VER >= 26
- // member
- auto test_member = [&](auto&& v) {
- try {
- v.template visit<ReturnType>(obj);
- } catch (const std::bad_variant_access&) {
- return true;
- } catch (...) {
- }
- return false;
- };
-# endif
- // non-member
- auto test_nonmember = [&](auto&&... args) {
+ auto test = [&](auto &&... args) {
try {
std::visit<ReturnType>(obj, args...);
- } catch (const std::bad_variant_access&) {
+ } catch (const std::bad_variant_access &) {
return true;
} catch (...) {
}
return false;
};
-
{
using V = std::variant<int, MakeEmptyT>;
V v;
-# if _LIBCPP_STD_VER >= 26
- makeEmpty(v);
-
- assert(test_member(v));
-# endif
makeEmpty(v);
-
- assert(test_nonmember(v));
+ assert(test(v));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void*>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void *>;
V v;
makeEmpty(v);
V2 v2("hello");
-
- assert(test_nonmember(v, v2));
+ assert(test(v, v2));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void*>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void *>;
V v;
makeEmpty(v);
V2 v2("hello");
-
- assert(test_nonmember(v2, v));
+ assert(test(v2, v));
}
{
- using V = std::variant<int, MakeEmptyT>;
- using V2 = std::variant<long, std::string, void*, MakeEmptyT>;
+ using V = std::variant<int, MakeEmptyT>;
+ using V2 = std::variant<long, std::string, void *, MakeEmptyT>;
V v;
makeEmpty(v);
V2 v2;
makeEmpty(v2);
-
- assert(test_nonmember(v, v2));
+ assert(test(v, v2));
}
{
using V = std::variant<int, long, double, MakeEmptyT>;
- V v1(42L), v2(101), v3(202), v4(1.1);
+ V v1(42l), v2(101), v3(202), v4(1.1);
makeEmpty(v1);
-
- assert(test_nonmember(v1, v2, v3, v4));
+ assert(test(v1, v2, v3, v4));
}
{
using V = std::variant<int, long, double, long long, MakeEmptyT>;
- V v1(42L), v2(101), v3(202), v4(1.1);
+ V v1(42l), v2(101), v3(202), v4(1.1);
makeEmpty(v1);
makeEmpty(v2);
makeEmpty(v3);
makeEmpty(v4);
-
- assert(test_nonmember(v1, v2, v3, v4));
+ assert(test(v1, v2, v3, v4));
}
#endif
}
@@ -642,35 +384,20 @@ void test_caller_accepts_nonconst() {
struct A {};
struct Visitor {
auto operator()(A&) {
- if constexpr (!std::is_void_v<ReturnType>) {
+ if constexpr (!std::is_void_v<ReturnType>)
+ {
return ReturnType{};
}
}
};
std::variant<A> v;
-
-#if _LIBCPP_STD_VER >= 26
- // member
- { v.template visit<ReturnType>(Visitor{}); }
-#endif
- // non-member
- { std::visit<ReturnType>(Visitor{}, v); }
+ std::visit<ReturnType>(Visitor{}, v);
}
void test_constexpr_explicit_side_effect() {
auto test_lambda = [](int arg) constexpr {
std::variant<int> v = 101;
-
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- v.template visit<void>([arg](int& x) constexpr { x = arg; });
- }
-#endif
- // non-member
- {
- std::visit<void>([arg](int& x) constexpr { x = arg; }, v);
- }
+ std::visit<void>([arg](int& x) constexpr { x = arg; }, v);
return std::get<int>(v);
};
@@ -680,34 +407,18 @@ void test_constexpr_explicit_side_effect() {
void test_derived_from_variant() {
struct MyVariant : std::variant<short, long, float> {};
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- MyVariant{42}.template visit<bool>([](auto x) {
- assert(x == 42);
- return true;
- });
- MyVariant{-1.3f}.template visit<bool>([](auto x) {
- assert(x == -1.3f);
- return true;
- });
- }
-#endif
- // non-member
- {
- std::visit<bool>(
- [](auto x) {
- assert(x == 42);
- return true;
- },
- MyVariant{42});
- std::visit<bool>(
- [](auto x) {
- assert(x == -1.3f);
- return true;
- },
- MyVariant{-1.3f});
- }
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 42);
+ return true;
+ },
+ MyVariant{42});
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == -1.3f);
+ return true;
+ },
+ MyVariant{-1.3f});
// Check that visit does not take index nor valueless_by_exception members from the base class.
struct EvilVariantBase {
@@ -715,46 +426,29 @@ void test_derived_from_variant() {
char valueless_by_exception;
};
- struct EvilVariant1 : std::variant<int, long, double>, std::tuple<int>, EvilVariantBase {
+ struct EvilVariant1 : std::variant<int, long, double>,
+ std::tuple<int>,
+ EvilVariantBase {
using std::variant<int, long, double>::variant;
};
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- EvilVariant1{12}.template visit<bool>([](auto x) {
- assert(x == 12);
- return true;
- });
- EvilVariant1{12.3}.template visit<bool>([](auto x) {
- assert(x == 12.3);
- return true;
- });
- }
-#endif
- // non-member
- {
- std::visit<bool>(
- [](auto x) {
- assert(x == 12);
- return true;
- },
- EvilVariant1{12});
- std::visit<bool>(
- [](auto x) {
- assert(x == 12.3);
- return true;
- },
- EvilVariant1{12.3});
- }
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12);
+ return true;
+ },
+ EvilVariant1{12});
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12.3);
+ return true;
+ },
+ EvilVariant1{12.3});
// Check that visit unambiguously picks the variant, even if the other base has __impl member.
struct ImplVariantBase {
struct Callable {
- bool operator()() const {
- assert(false);
- return false;
- }
+ bool operator()() const { assert(false); return false; }
};
Callable __impl;
@@ -764,34 +458,18 @@ void test_derived_from_variant() {
using std::variant<int, long, double>::variant;
};
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- EvilVariant2{12}.template visit<bool>([](auto x) {
- assert(x == 12);
- return true;
- });
- EvilVariant2{12.3}.template visit<bool>([](auto x) {
- assert(x == 12.3);
- return true;
- });
- }
-#endif
- // non-member
- {
- std::visit<bool>(
- [](auto x) {
- assert(x == 12);
- return true;
- },
- EvilVariant2{12});
- std::visit<bool>(
- [](auto x) {
- assert(x == 12.3);
- return true;
- },
- EvilVariant2{12.3});
- }
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12);
+ return true;
+ },
+ EvilVariant2{12});
+ std::visit<bool>(
+ [](auto x) {
+ assert(x == 12.3);
+ return true;
+ },
+ EvilVariant2{12.3});
}
struct any_visitor {
@@ -801,7 +479,8 @@ struct any_visitor {
}
};
-template <typename T, typename = decltype(std::visit<bool>(std::declval<any_visitor&>(), std::declval<T>()))>
+template <typename T, typename = decltype(std::visit<bool>(
+ std::declval<any_visitor&>(), std::declval<T>()))>
constexpr bool has_visit(int) {
return true;
}
@@ -819,7 +498,6 @@ void test_sfinae() {
}
int main(int, char**) {
- test_overload_ambiguity();
test_call_operator_forwarding<void>();
test_argument_forwarding<void>();
test_return_type<void>();
>From 4d3ff8bd92f92404db1d1dd56e8ff4a5b5226dbb Mon Sep 17 00:00:00 2001
From: Zingam <zingam at outlook.com>
Date: Sat, 30 Dec 2023 08:25:02 +0200
Subject: [PATCH 13/13] Renamed files and cleanup
---
.../variant.visit/member.visit.pass.cpp | 6 ++---
.../member.visit.robust_against_adl.pass.cpp | 27 ++++---------------
.../member.visit_return_type.pass.cpp | 6 ++---
...pe.pass.cpp => visit.return_type.pass.cpp} | 0
....cpp => visit.robust_against_adl.pass.cpp} | 0
5 files changed, 9 insertions(+), 30 deletions(-)
rename libcxx/test/std/utilities/variant/variant.visit/{visit_return_type.pass.cpp => visit.return_type.pass.cpp} (100%)
rename libcxx/test/std/utilities/variant/variant.visit/{robust_against_adl.pass.cpp => visit.robust_against_adl.pass.cpp} (100%)
diff --git a/libcxx/test/std/utilities/variant/variant.visit/member.visit.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/member.visit.pass.cpp
index 8781174ff7d669..e6e9e5fe64e4bd 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/member.visit.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/member.visit.pass.cpp
@@ -6,17 +6,15 @@
//
//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
// <variant>
// class variant;
+
// template<class Self, class Visitor>
// constexpr decltype(auto) visit(this Self&&, Visitor&&); // since C++26
-// template <class Visitor, class... Variants>
-// constexpr see below visit(Visitor&& vis, Variants&&... vars);
-
#include <cassert>
#include <memory>
#include <string>
diff --git a/libcxx/test/std/utilities/variant/variant.visit/member.visit.robust_against_adl.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/member.visit.robust_against_adl.pass.cpp
index 3bd305a7c62c17..3c59d5a4c0e063 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/member.visit.robust_against_adl.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/member.visit.robust_against_adl.pass.cpp
@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
// <variant>
@@ -16,9 +16,6 @@
// template<class R, class Self, class Visitor>
// constexpr R visit(this Self&&, Visitor&&); // since C++26
-// template <class Visitor, class... Variants>
-// constexpr see below visit(Visitor&& vis, Variants&&... vars);
-
#include <variant>
#include "test_macros.h"
@@ -33,24 +30,10 @@ constexpr bool test(bool do_it) {
if (do_it) {
std::variant<Holder<Incomplete>*, int> v = nullptr;
-#if _LIBCPP_STD_VER >= 26
- // member
- {
- v.visit([](auto) {});
- v.visit([](auto) -> Holder<Incomplete>* { return nullptr; });
- v.visit<void>([](auto) {});
- v.visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; });
- }
-#endif
- // non-member
- {
- std::visit([](auto) {}, v);
- std::visit([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
-#if TEST_STD_VER > 17
- std::visit<void>([](auto) {}, v);
- std::visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
-#endif
- }
+ v.visit([](auto) {});
+ v.visit([](auto) -> Holder<Incomplete>* { return nullptr; });
+ v.visit<void>([](auto) {});
+ v.visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; });
}
return true;
}
diff --git a/libcxx/test/std/utilities/variant/variant.visit/member.visit_return_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/member.visit_return_type.pass.cpp
index 1c73d34cacd87f..a1752c834effcc 100644
--- a/libcxx/test/std/utilities/variant/variant.visit/member.visit_return_type.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.visit/member.visit_return_type.pass.cpp
@@ -6,17 +6,15 @@
//
//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
// <variant>
// class variant;
+
// template<class R, class Self, class Visitor>
// constexpr R visit(this Self&&, Visitor&&); // since C++26
-// template <class R, class Visitor, class... Variants>
-// constexpr R visit(Visitor&& vis, Variants&&... vars);
-
#include <cassert>
#include <memory>
#include <string>
diff --git a/libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.return_type.pass.cpp
similarity index 100%
rename from libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp
rename to libcxx/test/std/utilities/variant/variant.visit/visit.return_type.pass.cpp
diff --git a/libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp b/libcxx/test/std/utilities/variant/variant.visit/visit.robust_against_adl.pass.cpp
similarity index 100%
rename from libcxx/test/std/utilities/variant/variant.visit/robust_against_adl.pass.cpp
rename to libcxx/test/std/utilities/variant/variant.visit/visit.robust_against_adl.pass.cpp
More information about the cfe-commits
mailing list