QmlCompiler: Allow creation of actual QVariantMaps from object literals

There are places where we need this:

a, If the method in question actually takes a QVariantMap as argument.
b, If the resulting value can be shadowed. In that case we expect a
   QVariant. The engine has to internally convert to the expected type
   then.

Change-Id: Ic5b3faab4578d64ca757de644fe69660fd70e52a
Reviewed-by: Fabian Kosmale <[email protected]>
Reviewed-by: Sami Shalayel <[email protected]>
Reviewed-by: Qt CI Bot <[email protected]>

Author: ulfhermannqt

src/qmlcompiler/qqmljsbasicblocks.cpp

@@ -648,13 +648,19 @@ void QQmlJSBasicBlocks::adjustTypes()
         const InstructionAnnotation &annotation = m_annotations[object.instructionOffset];
 
         Q_ASSERT(it->trackedTypes.size() == 1);
-        Q_ASSERT(it->trackedTypes[0] == m_typeResolver->containedType(annotation.changedRegister));
+        QQmlJSScope::ConstPtr resultType = it->trackedTypes[0];
+
+        Q_ASSERT(resultType == m_typeResolver->containedType(annotation.changedRegister));
         Q_ASSERT(!annotation.readRegisters.isEmpty());
 
-        if (!m_typeResolver->adjustTrackedType(it->trackedTypes[0], it->typeReaders.values()))
-            setError(adjustErrorMessage(it->trackedTypes[0], it->typeReaders.values()));
+        if (!m_typeResolver->adjustTrackedType(resultType, it->typeReaders.values()))
+            setError(adjustErrorMessage(resultType, it->typeReaders.values()));
 
-        QQmlJSScope::ConstPtr resultType = it->trackedTypes[0];
+        if (m_typeResolver->equals(resultType, m_typeResolver->varType())
+                || m_typeResolver->equals(resultType, m_typeResolver->variantMapType())) {
+            // It's all variant anyway
+            return;
+        }
 
         const int classSize = m_jsUnitGenerator->jsClassSize(object.internalClassId);
         Q_ASSERT(object.argc >= classSize);

src/qmlcompiler/qqmljscodegenerator.cpp

@@ -2376,6 +2376,45 @@ void QQmlJSCodeGenerator::generate_DefineObjectLiteral(int internalClassId, int
 
     const QQmlJSScope::ConstPtr contained = m_typeResolver->containedType(m_state.accumulatorOut());
 
+    const int classSize = m_jsUnitGenerator->jsClassSize(internalClassId);
+    Q_ASSERT(argc >= classSize);
+
+    if (m_typeResolver->equals(contained, m_typeResolver->varType())
+        || m_typeResolver->equals(contained, m_typeResolver->variantMapType())) {
+
+        m_body += m_state.accumulatorVariableOut + u" = QVariantMap {\n";
+        const QQmlJSScope::ConstPtr propType = m_typeResolver->varType();
+        for (int i = 0; i < classSize; ++i) {
+            m_body += u"{ "_s
+                    + QQmlJSUtils::toLiteral(m_jsUnitGenerator->jsClassMember(internalClassId, i))
+                    + u", "_s;
+            const int currentArg = args + i;
+            const QQmlJSScope::ConstPtr argType = registerType(currentArg).storedType();
+            const QString consumedArg = consumedRegisterVariable(currentArg);
+            m_body += convertStored(argType, propType, consumedArg) + u" },\n";
+        }
+
+        for (int i = classSize; i < argc; i += 3) {
+            const int nameArg = argc + i + 1;
+            m_body += u"{ "_s
+                    + conversion(
+                              registerType(nameArg),
+                              m_typeResolver->globalType(m_typeResolver->stringType()),
+                              consumedRegisterVariable(nameArg))
+                    + u", "_s;
+
+            const int valueArg = argc + i + 2;
+            m_body += convertStored(
+                              registerType(valueArg).storedType(),
+                              propType,
+                              consumedRegisterVariable(valueArg))
+                    + u" },\n";
+        }
+
+        m_body += u"};\n";
+        return;
+    }
+
     m_body += m_state.accumulatorVariableOut + u" = "_s + stored->augmentedInternalName();
     const bool isVariantOrPrimitive = m_typeResolver->equals(stored, m_typeResolver->varType())
             || m_typeResolver->equals(stored, m_typeResolver->jsPrimitiveType());
@@ -2390,6 +2429,9 @@ void QQmlJSCodeGenerator::generate_DefineObjectLiteral(int internalClassId, int
     }
     m_body += u";\n";
 
+    if (argc == 0)
+        return;
+
     bool isExtension = false;
     if (!m_typeResolver->canPopulate(contained, m_typeResolver->variantMapType(), &isExtension)) {
         reject(u"storing an object literal in a non-structured value type"_s);
@@ -2399,11 +2441,6 @@ void QQmlJSCodeGenerator::generate_DefineObjectLiteral(int internalClassId, int
             ? contained->extensionType().scope
             : contained;
 
-    const int classSize = m_jsUnitGenerator->jsClassSize(internalClassId);
-    Q_ASSERT(argc >= classSize);
-    if (argc == 0)
-        return;
-
     m_body += u"{\n";
     m_body += u"    const QMetaObject *meta = ";
     if (!isExtension && isVariantOrPrimitive)

src/qmlcompiler/qqmljstypepropagator.cpp

@@ -1979,6 +1979,8 @@ void QQmlJSTypePropagator::generate_DefineObjectLiteral(int internalClassId, int
     for (int i = classSize; i < argc; i += 3) {
         // layout for remaining members is:
         // 0: ObjectLiteralArgument - Value|Method|Getter|Setter
+        // We cannot do anything useful with this. Any code that would call a getter/setter/method
+        // could not be compiled to C++. Ignore it.
 
         // 1: name of argument
         addReadRegister(

tests/auto/qml/qmlcppcodegen/data/B.qml

@@ -0,0 +1,5 @@
+import QtQml
+
+QtObject {
+    property rect r
+}

tests/auto/qml/qmlcppcodegen/data/CMakeLists.txt

@@ -30,6 +30,7 @@ set(cpp_sources
 set(qml_files
     AccessModelMethodsFromOutside.qml
     ArraySequenceLengthInterop.qml
+    B.qml
     BadType.qml
     BaseMember.qml
     BindingExpression.qml
@@ -241,6 +242,7 @@ set(qml_files
     valueTypeLists.qml
     valueTypeProperty.qml
     valueTypeReference.qml
+    variantMap.qml
     variantMapLookup.qml
     variantReturn.qml
     variantlist.qml

tests/auto/qml/qmlcppcodegen/data/variantMap.qml

@@ -0,0 +1,20 @@
+pragma Strict
+import QtQml
+
+QtObject {
+    property Component shadowable: QtObject {}
+    property B b: B { id: theB }
+    property rect r: theB.r
+
+    property Component c: Component {
+        id: unshadowable
+        QtObject {}
+    }
+
+    objectName: {
+        return shadowable.createObject(this, {objectName: "a"}).objectName
+            + " " + unshadowable.createObject(this, {objectName: "b"}).objectName
+    }
+
+    Component.onCompleted: b.r = { x: 12, y: 13, width: 14, height: 15 }
+}

tests/auto/qml/qmlcppcodegen/tst_qmlcppcodegen.cpp

@@ -206,6 +206,7 @@ private slots:
     void variantMapLookup();
     void variantReturn();
     void variantlist();
+    void variantMap();
     void voidConversion();
     void voidFunction();
     void writeBack();
@@ -4208,6 +4209,18 @@ void tst_QmlCppCodegen::variantlist()
     QCOMPARE(things[1].toInt(), 30);
 }
 
+void tst_QmlCppCodegen::variantMap()
+{
+    QQmlEngine engine;
+    QQmlComponent c(&engine, QUrl(u"qrc:/qt/qml/TestTypes/variantMap.qml"_s));
+    QVERIFY2(c.isReady(), qPrintable(c.errorString()));
+    QScopedPointer<QObject> o(c.create());
+    QVERIFY(o);
+
+    QCOMPARE(o->objectName(), "a b"_L1);
+    QCOMPARE(o->property("r"), QVariant::fromValue(QRectF(12, 13, 14, 15)));
+}
+
 void tst_QmlCppCodegen::voidConversion()
 {
     QQmlEngine engine;