QJSValue: Add toVariant() overload with conversion behavior

The QJSValue to QVariant conversion is traditionally messy. The recent
addition of a special case for FunctionObject did not make that better.
Rather, we now add a way of specifying that the conversion should be
lossless, which avoids all conversions of JS objects and arrays.

Amends commit 6b08c24297f39f3c67bc5c16f46198b33af66529.

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

1 files changed, 69 insertions, 14 deletions

diff --git a/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp b/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp
index 94068bfa12..e2f83a78ba 100644
--- a/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp
+++ b/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp
@@ -962,15 +962,18 @@ void tst_QJSValue::toUInt()
 void tst_QJSValue::toVariant()
 {
     QJSEngine eng;
-    QObject temp;
 
-    QJSValue undefined = eng.toScriptValue(QVariant());
-    QCOMPARE(undefined.toVariant(), QVariant());
-    QCOMPARE(qjsvalue_cast<QVariant>(undefined), QVariant());
+    {
+        QJSValue undefined = eng.toScriptValue(QVariant());
+        QCOMPARE(undefined.toVariant(), QVariant());
+        QCOMPARE(qjsvalue_cast<QVariant>(undefined), QVariant());
+    }
 
-    QJSValue null = eng.evaluate("null");
-    QCOMPARE(null.toVariant(), QVariant::fromValue(nullptr));
-    QCOMPARE(qjsvalue_cast<QVariant>(null), QVariant::fromValue(nullptr));
+    {
+        QJSValue null = eng.evaluate("null");
+        QCOMPARE(null.toVariant(), QVariant::fromValue(nullptr));
+        QCOMPARE(qjsvalue_cast<QVariant>(null), QVariant::fromValue(nullptr));
+    }
 
     {
         QJSValue number = eng.toScriptValue(123.0);
@@ -995,14 +998,21 @@ void tst_QJSValue::toVariant()
         QCOMPARE(qjsvalue_cast<QVariant>(str), QVariant(QString("ciao")));
     }
 
-    QJSValue object = eng.newObject();
-    QCOMPARE(object.toVariant(), QVariant(QVariantMap()));
+    {
+        QJSValue object = eng.newObject();
+        QCOMPARE(object.toVariant(), QVariant(QVariantMap()));
+        QVariant retained = object.toVariant(QJSValue::RetainJSObjects);
+        QCOMPARE(retained.metaType(), QMetaType::fromType<QJSValue>());
+        QVERIFY(retained.value<QJSValue>().strictlyEquals(object));
+    }
 
-    QJSValue qobject = eng.newQObject(&temp);
     {
+        QObject temp;
+        QJSValue qobject = eng.newQObject(&temp);
         QVariant var = qobject.toVariant();
         QCOMPARE(var.typeId(), int(QMetaType::QObjectStar));
         QCOMPARE(qvariant_cast<QObject*>(var), (QObject *)&temp);
+        QCOMPARE(qobject.toVariant(QJSValue::RetainJSObjects), var);
     }
 
     {
@@ -1010,6 +1020,7 @@ void tst_QJSValue::toVariant()
         QJSValue dateObject = eng.toScriptValue(dateTime);
         QVariant var = dateObject.toVariant();
         QCOMPARE(var, QVariant(dateTime));
+        QCOMPARE(dateObject.toVariant(QJSValue::RetainJSObjects), var);
     }
 
     {
@@ -1018,39 +1029,76 @@ void tst_QJSValue::toVariant()
         QVERIFY(rxObject.isRegExp());
         QVariant var = rxObject.toVariant();
         QCOMPARE(var, QVariant(rx));
+        QCOMPARE(rxObject.toVariant(QJSValue::RetainJSObjects), var);
     }
 
-    QJSValue inv;
-    QCOMPARE(inv.toVariant(), QVariant());
-    QCOMPARE(qjsvalue_cast<QVariant>(inv), QVariant());
+    {
+        QJSValue inv;
+        QCOMPARE(inv.toVariant(), QVariant());
+        QCOMPARE(inv.toVariant(QJSValue::RetainJSObjects), QVariant());
+        QCOMPARE(qjsvalue_cast<QVariant>(inv), QVariant());
+    }
 
     // V2 constructors
     {
         QJSValue number = QJSValue(123.0);
         QCOMPARE(number.toVariant(), QVariant(123.0));
+        QCOMPARE(number.toVariant(QJSValue::RetainJSObjects), QVariant(123.0));
         QCOMPARE(qjsvalue_cast<QVariant>(number), QVariant(123.0));
 
         QJSValue falskt = QJSValue(false);
         QCOMPARE(falskt.toVariant(), QVariant(false));
+        QCOMPARE(falskt.toVariant(QJSValue::RetainJSObjects), QVariant(false));
         QCOMPARE(qjsvalue_cast<QVariant>(falskt), QVariant(false));
 
         QJSValue sant = QJSValue(true);
         QCOMPARE(sant.toVariant(), QVariant(true));
+        QCOMPARE(sant.toVariant(QJSValue::RetainJSObjects), QVariant(true));
         QCOMPARE(qjsvalue_cast<QVariant>(sant), QVariant(true));
 
         QJSValue str = QJSValue(QString("ciao"));
         QCOMPARE(str.toVariant(), QVariant(QString("ciao")));
+        QCOMPARE(str.toVariant(QJSValue::RetainJSObjects), QVariant(QString("ciao")));
         QCOMPARE(qjsvalue_cast<QVariant>(str), QVariant(QString("ciao")));
 
         QJSValue undef = QJSValue(QJSValue::UndefinedValue);
         QCOMPARE(undef.toVariant(), QVariant());
+        QCOMPARE(undef.toVariant(QJSValue::RetainJSObjects), QVariant());
         QCOMPARE(qjsvalue_cast<QVariant>(undef), QVariant());
 
         QJSValue nil = QJSValue(QJSValue::NullValue);
         QCOMPARE(nil.toVariant(), QVariant::fromValue(nullptr));
+        QCOMPARE(nil.toVariant(QJSValue::RetainJSObjects), QVariant::fromValue(nullptr));
         QCOMPARE(qjsvalue_cast<QVariant>(nil), QVariant::fromValue(nullptr));
     }
 
+    // object
+    {
+        QVariantMap mapIn;
+        mapIn["a"] = 123;
+        mapIn["b"] = "hello";
+        QJSValue object = eng.toScriptValue(mapIn);
+        QVERIFY(object.isObject());
+
+        QVariant retained = object.toVariant(QJSValue::RetainJSObjects);
+        QCOMPARE(retained.metaType(), QMetaType::fromType<QJSValue>());
+        QVERIFY(retained.value<QJSValue>().strictlyEquals(object));
+
+        QVariant ret = object.toVariant();
+        QCOMPARE(ret.typeId(), QMetaType::QVariantMap);
+        QVariantMap mapOut = ret.toMap();
+        QCOMPARE(mapOut.size(), mapIn.size());
+        for (auto it = mapOut.begin(), end = mapOut.end(); it != end; ++it)
+            QCOMPARE(*it, mapIn[it.key()]);
+
+        // round-trip conversion
+        QJSValue object2 = eng.toScriptValue(ret);
+        QVERIFY(object2.isObject());
+        QVERIFY(object2.property("a").strictlyEquals(object.property("a")));
+        QVERIFY(object2.property("b").strictlyEquals(object.property("b")));
+    }
+
+
     // array
     {
         auto handler = qInstallMessageHandler([](QtMsgType type, const QMessageLogContext &, const QString &) {
@@ -1062,6 +1110,11 @@ void tst_QJSValue::toVariant()
         QJSValue array = eng.toScriptValue(listIn);
         QVERIFY(array.isArray());
         QCOMPARE(array.property("length").toInt(), 2);
+
+        QVariant retained = array.toVariant(QJSValue::RetainJSObjects);
+        QCOMPARE(retained.metaType(), QMetaType::fromType<QJSValue>());
+        QVERIFY(retained.value<QJSValue>().strictlyEquals(array));
+
         QVariant ret = array.toVariant();
         QCOMPARE(ret.typeId(), QMetaType::QVariantList);
         QVariantList listOut = ret.toList();
@@ -1084,13 +1137,15 @@ void tst_QJSValue::toVariant()
         QVERIFY(func.isCallable());
         QCOMPARE(func.call().toInt(), 10);
 
-        QVariant funcVar = func.toVariant();
+        QVariant funcVar = func.toVariant(QJSValue::RetainJSObjects);
         QVERIFY(funcVar.isValid());
         QCOMPARE(funcVar.metaType(), QMetaType::fromType<QJSValue>());
 
         QJSValue func2 = eng.toScriptValue(funcVar);
         QVERIFY(func2.isCallable());
         QCOMPARE(func2.call().toInt(), 10);
+
+        QCOMPARE(func.toVariant(), QVariant());
     }
 }