QVariant: add rvalue overload of fromStdVariant()

Extract Method fromStdVariantImpl() to share the otherwise
more-or-less identical implementation between the two overloads.

Don't use a constrained template version of fromStdVariantImpl() as
fromStdVariant(), because the constraint would have to be very complex
to continue allowing subclasses of std::variant to be passed.

As a drive-by, mark the valueless_by_exception() path Q_UNLIKELY.

[ChangeLog][QtCore][QVariant] Added overload of fromStdVariant()
taking rvalue std::variant<>s.

Fixes: QTBUG-114134
Change-Id: Ia1c7ae93ab421e6689dc9f2d8d0c2295b23cbbf6
Reviewed-by: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

1 files changed, 45 insertions, 0 deletions

diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
index addf7ceec9..23fa969edd 100644
--- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
+++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
@@ -5392,6 +5392,16 @@ void tst_QVariant::shouldDeleteVariantDataWorksForAssociative()
 
 void tst_QVariant::fromStdVariant()
 {
+#define CHECK_EQUAL(lhs, rhs, type) do { \
+        QCOMPARE(lhs.typeId(), rhs.typeId()); \
+        if (lhs.isNull()) { \
+            QVERIFY(rhs.isNull()); \
+        } else { \
+            QVERIFY(!rhs.isNull()); \
+            QCOMPARE(get< type >(lhs), get< type >(rhs)); \
+        } \
+    } while (false)
+
     {
         typedef std::variant<int, bool> intorbool_t;
         intorbool_t stdvar = 5;
@@ -5399,21 +5409,38 @@ void tst_QVariant::fromStdVariant()
         QVERIFY(!qvar.isNull());
         QCOMPARE(qvar.typeId(), QMetaType::Int);
         QCOMPARE(qvar.value<int>(), std::get<int>(stdvar));
+        {
+            const auto qv2 = QVariant::fromStdVariant(std::move(stdvar));
+            CHECK_EQUAL(qv2, qvar, int);
+        }
+
         stdvar = true;
         qvar = QVariant::fromStdVariant(stdvar);
         QVERIFY(!qvar.isNull());
         QCOMPARE(qvar.typeId(), QMetaType::Bool);
         QCOMPARE(qvar.value<bool>(), std::get<bool>(stdvar));
+        {
+            const auto qv2 = QVariant::fromStdVariant(std::move(stdvar));
+            CHECK_EQUAL(qv2, qvar, bool);
+        }
     }
     {
         std::variant<std::monostate, int> stdvar;
         QVariant qvar = QVariant::fromStdVariant(stdvar);
         QVERIFY(!qvar.isValid());
+        {
+            const auto qv2 = QVariant::fromStdVariant(std::move(stdvar));
+            CHECK_EQUAL(qv2, qvar, int); // fake type, they're empty
+        }
         stdvar = -4;
         qvar = QVariant::fromStdVariant(stdvar);
         QVERIFY(!qvar.isNull());
         QCOMPARE(qvar.typeId(), QMetaType::Int);
         QCOMPARE(qvar.value<int>(), std::get<int>(stdvar));
+        {
+            const auto qv2 = QVariant::fromStdVariant(std::move(stdvar));
+            CHECK_EQUAL(qv2, qvar, int);
+        }
     }
     {
         std::variant<int, bool, QChar> stdvar = QChar::fromLatin1(' ');
@@ -5421,7 +5448,25 @@ void tst_QVariant::fromStdVariant()
         QVERIFY(!qvar.isNull());
         QCOMPARE(qvar.typeId(), QMetaType::QChar);
         QCOMPARE(qvar.value<QChar>(), std::get<QChar>(stdvar));
+        {
+            const auto qv2 = QVariant::fromStdVariant(std::move(stdvar));
+            CHECK_EQUAL(qv2, qvar, QChar);
+        }
     }
+    // rvalue fromStdVariant() actually moves:
+    {
+        const auto foo = u"foo"_s;
+        std::variant<QString, QByteArray> stdvar = foo;
+        QVariant qvar = QVariant::fromStdVariant(std::move(stdvar));
+        const auto ps = get_if<QString>(&stdvar);
+        QVERIFY(ps);
+        QVERIFY(ps->isNull()); // QString was moved from
+        QVERIFY(!qvar.isNull());
+        QCOMPARE(qvar.typeId(), QMetaType::QString);
+        QCOMPARE(get<QString>(qvar), foo);
+    }
+
+#undef CHECK_EQUAL
 }
 
 void tst_QVariant::qt4UuidDataStream()