QJSPrimitiveValue: Add a toVariant() method and ctor from QVariant

This is rather handy. Without it, we have to go through either QJSValue
or QJSManagedValue, which causes much greater overhead.

Change-Id: I40e2ecb6e2005f80c8f52b5e9a59028b3984eea4
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

2 files changed, 82 insertions, 0 deletions

diff --git a/src/qml/jsapi/qjsprimitivevalue.h b/src/qml/jsapi/qjsprimitivevalue.h
index 27f38aec93..f9cc9f3089 100644
--- a/src/qml/jsapi/qjsprimitivevalue.h
+++ b/src/qml/jsapi/qjsprimitivevalue.h
@@ -45,6 +45,7 @@
 
 #include <QtCore/qstring.h>
 #include <QtCore/qnumeric.h>
+#include <QtCore/qvariant.h>
 
 #include <variant>
 
@@ -160,6 +161,32 @@ public:
     constexpr QJSPrimitiveValue(int value) : d(value) {}
     constexpr QJSPrimitiveValue(double value) : d(value) {}
     QJSPrimitiveValue(QString string) : d(std::move(string)) {}
+    QJSPrimitiveValue(const QVariant &variant)
+    {
+        switch (variant.typeId()) {
+        case QMetaType::UnknownType:
+            d = QJSPrimitiveUndefined();
+            break;
+        case QMetaType::Nullptr:
+            d = QJSPrimitiveNull();
+            break;
+        case QMetaType::Bool:
+            d = variant.toBool();
+            break;
+        case QMetaType::Int:
+            d = variant.toInt();
+            break;
+        case QMetaType::Double:
+            d = variant.toDouble();
+            break;
+        case QMetaType::QString:
+            d = variant.toString();
+            break;
+        default:
+            // Unsupported. Remains undefined.
+            break;
+        }
+    }
 
     constexpr bool toBoolean() const
     {
@@ -230,6 +257,21 @@ public:
         return QString();
     }
 
+    QVariant toVariant() const
+    {
+        switch (type()) {
+        case Undefined: return QVariant();
+        case Null:      return QVariant::fromValue<std::nullptr_t>(nullptr);
+        case Boolean:   return QVariant(asBoolean());
+        case Integer:   return QVariant(asInteger());
+        case Double:    return QVariant(asDouble());
+        case String:    return QVariant(asString());
+        }
+
+        Q_UNREACHABLE();
+        return QVariant();
+    }
+
     friend inline QJSPrimitiveValue operator+(const QJSPrimitiveValue &lhs,
                                               const QJSPrimitiveValue &rhs)
     {
diff --git a/tests/auto/qml/qjsprimitivevalue/tst_qjsprimitivevalue.cpp b/tests/auto/qml/qjsprimitivevalue/tst_qjsprimitivevalue.cpp
index b957e7a18b..5189ea4b94 100644
--- a/tests/auto/qml/qjsprimitivevalue/tst_qjsprimitivevalue.cpp
+++ b/tests/auto/qml/qjsprimitivevalue/tst_qjsprimitivevalue.cpp
@@ -40,6 +40,8 @@ private slots:
     void operators_data();
     void operators();
 
+    void toFromVariant();
+
 private:
     QJSEngine engine;
 
@@ -221,6 +223,44 @@ void tst_QJSPrimitiveValue::operators()
     doTestForAllOperators(&engine, lhs, "foo" + rhs.toString());
 }
 
+void tst_QJSPrimitiveValue::toFromVariant()
+{
+    for (const auto &operand : operands) {
+        const QVariant var = operand.toVariant();
+        switch (operand.type()) {
+        case QJSPrimitiveValue::Undefined:
+            QVERIFY(!var.isValid());
+            break;
+        case QJSPrimitiveValue::Null:
+            QCOMPARE(var.typeId(), QMetaType::Nullptr);
+            break;
+        case QJSPrimitiveValue::Boolean:
+            QCOMPARE(var.typeId(), QMetaType::Bool);
+            QCOMPARE(var.toBool(), operand.toBoolean());
+            break;
+        case QJSPrimitiveValue::Integer:
+            QCOMPARE(var.typeId(), QMetaType::Int);
+            QCOMPARE(var.toInt(), operand.toInteger());
+            break;
+        case QJSPrimitiveValue::Double:
+            QCOMPARE(var.typeId(), QMetaType::Double);
+            QCOMPARE(var.toDouble(), operand.toDouble());
+            break;
+        case QJSPrimitiveValue::String:
+            QCOMPARE(var.typeId(), QMetaType::QString);
+            QCOMPARE(var.toString(), operand.toString());
+            break;
+        }
+
+        QJSPrimitiveValue fromVar(var);
+        QCOMPARE(fromVar.type(), operand.type());
+        if (operand.type() == QJSPrimitiveValue::Double && std::isnan(operand.toDouble()))
+            QVERIFY(fromVar != operand);
+        else
+            QCOMPARE(fromVar, operand);
+    }
+}
+
 QTEST_MAIN(tst_QJSPrimitiveValue)
 
 #include "tst_qjsprimitivevalue.moc"