Eliminate QQmlValueTypeProvider::createFromString

It can be expressed as a special case of create() with a QJSValue.

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

7 files changed, 71 insertions, 123 deletions

diff --git a/src/qml/qml/qqmlglobal.cpp b/src/qml/qml/qqmlglobal.cpp
index 558da1d64b..1fbb9889c2 100644
--- a/src/qml/qml/qqmlglobal.cpp
+++ b/src/qml/qml/qqmlglobal.cpp
@@ -80,13 +80,13 @@ QVariant QQmlValueTypeProvider::createValueType(int type, const QJSValue &params
     return QVariant();
 }
 
-bool QQmlValueTypeProvider::createValueFromString(int type, const QString &s, void *data, size_t n)
+bool QQmlValueTypeProvider::createValueFromString(int type, const QJSValue &s, QVariant *data)
 {
     Q_ASSERT(data);
 
     QQmlValueTypeProvider *p = this;
     do {
-        if (p->createFromString(type, s, data, n))
+        if (p->create(type, s, data))
             return true;
     } while ((p = p->next));
 
@@ -169,7 +169,6 @@ bool QQmlValueTypeProvider::writeValueType(int type, const void *src, QVariant&
 }
 
 bool QQmlValueTypeProvider::create(int, const QJSValue &, QVariant *) { return false; }
-bool QQmlValueTypeProvider::createFromString(int, const QString &, void *, size_t) { return false; }
 bool QQmlValueTypeProvider::variantFromString(int, const QString &, QVariant *) { return false; }
 bool QQmlValueTypeProvider::store(int, const void *, void *, size_t) { return false; }
 
diff --git a/src/qml/qml/qqmlglobal_p.h b/src/qml/qml/qqmlglobal_p.h
index a0efca8688..39ef990bd5 100644
--- a/src/qml/qml/qqmlglobal_p.h
+++ b/src/qml/qml/qqmlglobal_p.h
@@ -225,7 +225,7 @@ public:
     bool initValueType(int, QVariant&);
 
     QVariant createValueType(int, const QJSValue &params);
-    bool createValueFromString(int, const QString &, void *, size_t);
+    bool createValueFromString(int, const QJSValue &, QVariant *);
 
     QVariant createVariantFromString(int, const QString &, bool *);
     QVariant createVariantFromJsObject(int, const QJSValue &, bool *);
@@ -237,7 +237,6 @@ public:
 
 private:
     virtual bool create(int, const QJSValue &params, QVariant *);
-    virtual bool createFromString(int, const QString &, void *, size_t);
 
     virtual bool variantFromString(int, const QString &, QVariant *);
 
diff --git a/src/qml/qml/qqmlobjectcreator.cpp b/src/qml/qml/qqmlobjectcreator.cpp
index dc720349a1..310f8579bf 100644
--- a/src/qml/qml/qqmlobjectcreator.cpp
+++ b/src/qml/qml/qqmlobjectcreator.cpp
@@ -564,55 +564,18 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QMetaType::QVector2D: {
-        struct {
-            float xp;
-            float yp;
-        } vec;
-        bool ok = QQmlStringConverters::createFromString(QMetaType::QVector2D, compilationUnit->bindingValueAsString(binding), &vec, sizeof(vec));
-        assertOrNull(ok);
-        Q_UNUSED(ok);
-        property->writeProperty(_qobject, &vec, propertyWriteFlags);
-    }
-    break;
-    case QMetaType::QVector3D: {
-        struct {
-            float xp;
-            float yp;
-            float zy;
-        } vec;
-        bool ok = QQmlStringConverters::createFromString(QMetaType::QVector3D, compilationUnit->bindingValueAsString(binding), &vec, sizeof(vec));
-        assertOrNull(ok);
-        Q_UNUSED(ok);
-        property->writeProperty(_qobject, &vec, propertyWriteFlags);
-    }
-    break;
-    case QMetaType::QVector4D: {
-        struct {
-            float xp;
-            float yp;
-            float zy;
-            float wp;
-        } vec;
-        bool ok = QQmlStringConverters::createFromString(QMetaType::QVector4D, compilationUnit->bindingValueAsString(binding), &vec, sizeof(vec));
-        assertOrNull(ok);
-        Q_UNUSED(ok);
-        property->writeProperty(_qobject, &vec, propertyWriteFlags);
-    }
-    break;
+    case QMetaType::QVector2D:
+    case QMetaType::QVector3D:
+    case QMetaType::QVector4D:
     case QMetaType::QQuaternion: {
-        struct {
-            float wp;
-            float xp;
-            float yp;
-            float zp;
-        } vec;
-        bool ok = QQmlStringConverters::createFromString(QMetaType::QQuaternion, compilationUnit->bindingValueAsString(binding), &vec, sizeof(vec));
+        QVariant result;
+        bool ok = QQml_valueTypeProvider()->createValueFromString(
+                    propertyType, compilationUnit->bindingValueAsString(binding), &result);
         assertOrNull(ok);
         Q_UNUSED(ok);
-        property->writeProperty(_qobject, &vec, propertyWriteFlags);
+        property->writeProperty(_qobject, result.data(), propertyWriteFlags);
+        break;
     }
-    break;
     default: {
         // generate single literal value assignment to a list property if required
         if (property->propType() == qMetaTypeId<QList<qreal> >()) {
diff --git a/src/qml/qml/qqmlpropertyvalidator.cpp b/src/qml/qml/qqmlpropertyvalidator.cpp
index 453ffc3542..4e02e6b5e2 100644
--- a/src/qml/qml/qqmlpropertyvalidator.cpp
+++ b/src/qml/qml/qqmlpropertyvalidator.cpp
@@ -551,48 +551,25 @@ QQmlError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache *prope
         }
     }
     break;
-    case QMetaType::QVector2D: {
-        struct {
-            float xp;
-            float yp;
-        } vec;
-        if (!QQmlStringConverters::createFromString(QMetaType::QVector2D, compilationUnit->bindingValueAsString(binding), &vec, sizeof(vec))) {
-            return warnOrError(tr("Invalid property assignment: 2D vector expected"));
-        }
-    }
-    break;
-    case QMetaType::QVector3D: {
-        struct {
-            float xp;
-            float yp;
-            float zy;
-        } vec;
-        if (!QQmlStringConverters::createFromString(QMetaType::QVector3D, compilationUnit->bindingValueAsString(binding), &vec, sizeof(vec))) {
-            return warnOrError(tr("Invalid property assignment: 3D vector expected"));
-        }
-    }
-    break;
-    case QMetaType::QVector4D: {
-        struct {
-            float xp;
-            float yp;
-            float zy;
-            float wp;
-        } vec;
-        if (!QQmlStringConverters::createFromString(QMetaType::QVector4D, compilationUnit->bindingValueAsString(binding), &vec, sizeof(vec))) {
-            return warnOrError(tr("Invalid property assignment: 4D vector expected"));
-        }
-    }
-    break;
+    case QMetaType::QVector2D:
+    case QMetaType::QVector3D:
+    case QMetaType::QVector4D:
     case QMetaType::QQuaternion: {
-        struct {
-            float wp;
-            float xp;
-            float yp;
-            float zp;
-        } vec;
-        if (!QQmlStringConverters::createFromString(QMetaType::QQuaternion, compilationUnit->bindingValueAsString(binding), &vec, sizeof(vec))) {
-            return warnOrError(tr("Invalid property assignment: quaternion expected"));
+        auto typeName = [&]() {
+            switch (property->propType()) {
+            case QMetaType::QVector2D: return QStringLiteral("2D vector");
+            case QMetaType::QVector3D: return QStringLiteral("3D vector");
+            case QMetaType::QVector4D: return QStringLiteral("4D vector");
+            case QMetaType::QQuaternion: return QStringLiteral("quaternion");
+            default: return QString();
+            }
+        };
+        QVariant result;
+        if (!QQml_valueTypeProvider()->createValueFromString(
+                    property->propType(),
+                    compilationUnit->bindingValueAsString(binding), &result)) {
+            return warnOrError(tr("Invalid property assignment: %1 expected")
+                               .arg(typeName()));
         }
     }
     break;
diff --git a/src/qml/qml/qqmlstringconverters.cpp b/src/qml/qml/qqmlstringconverters.cpp
index dd86f465a1..07d6f4846d 100644
--- a/src/qml/qml/qqmlstringconverters.cpp
+++ b/src/qml/qml/qqmlstringconverters.cpp
@@ -189,10 +189,4 @@ QRectF QQmlStringConverters::rectFFromString(const QString &s, bool *ok)
     return QRectF(x, y, width, height);
 }
 
-bool QQmlStringConverters::createFromString(int type, const QString &s, void *data, size_t n)
-{
-    Q_ASSERT(data);
-    return QQml_valueTypeProvider()->createValueFromString(type, s, data, n);
-}
-
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlstringconverters_p.h b/src/qml/qml/qqmlstringconverters_p.h
index d64eb714fd..52c602c18e 100644
--- a/src/qml/qml/qqmlstringconverters_p.h
+++ b/src/qml/qml/qqmlstringconverters_p.h
@@ -79,8 +79,6 @@ namespace QQmlStringConverters
     Q_QML_PRIVATE_EXPORT QPointF pointFFromString(const QString &, bool *ok = nullptr);
     Q_QML_PRIVATE_EXPORT QSizeF sizeFFromString(const QString &, bool *ok = nullptr);
     Q_QML_PRIVATE_EXPORT QRectF rectFFromString(const QString &, bool *ok = nullptr);
-
-    Q_QML_PRIVATE_EXPORT bool createFromString(int, const QString &, void *, size_t);
 }
 
 QT_END_NAMESPACE
diff --git a/src/quick/util/qquickglobal.cpp b/src/quick/util/qquickglobal.cpp
index f32d12b6fd..48b882c218 100644
--- a/src/quick/util/qquickglobal.cpp
+++ b/src/quick/util/qquickglobal.cpp
@@ -289,7 +289,7 @@ public:
 // Note: The functions in this class provide handling only for the types
 // that the QML engine will currently actually call them for, so many
 // appear incompletely implemented.  For some functions, the implementation
-// would be obvious, but for others (particularly create and createFromString)
+// would be obvious, but for others (particularly create)
 // the exact semantics are unknown.  For this reason unused functionality
 // has been omitted.
 
@@ -546,6 +546,12 @@ public:
     bool create(int type, const QJSValue &params, QVariant *v) override
     {
         switch (type) {
+        case QMetaType::QColor:
+            if (params.isString()) {
+                *v = QVariant(QColor(params.toString()));
+                return true;
+            }
+            break;
         case QMetaType::QColorSpace: {
             bool ok = false;
             auto val = colorSpaceFromObject(params, &ok);
@@ -569,6 +575,13 @@ public:
                 *v = QVariant(QVector2D(params.property(0).toNumber(),
                                         params.property(1).toNumber()));
                 return true;
+            } else if (params.isString()) {
+                bool ok = false;
+                auto vector = vector2DFromString(params.toString(), &ok);
+                if (ok) {
+                    *v = QVariant(vector);
+                    return true;
+                }
             }
             break;
         case QMetaType::QVector3D:
@@ -577,6 +590,13 @@ public:
                                         params.property(1).toNumber(),
                                         params.property(2).toNumber()));
                 return true;
+            } else if (params.isString()) {
+                bool ok = false;
+                auto vector = vector3DFromString(params.toString(), &ok);
+                if (ok) {
+                    *v = QVariant(vector);
+                    return true;
+                }
             }
             break;
         case QMetaType::QVector4D:
@@ -586,6 +606,13 @@ public:
                                         params.property(2).toNumber(),
                                         params.property(3).toNumber()));
                 return true;
+            } else if (params.isString()) {
+                bool ok = false;
+                auto vector = vector4DFromString(params.toString(), &ok);
+                if (ok) {
+                    *v = QVariant(vector);
+                    return true;
+                }
             }
             break;
         case QMetaType::QQuaternion:
@@ -595,6 +622,13 @@ public:
                                           params.property(2).toNumber(),
                                           params.property(3).toNumber()));
                 return true;
+            } else if (params.isString()) {
+                bool ok = false;
+                auto vector = quaternionFromString(params.toString(), &ok);
+                if (ok) {
+                    *v = QVariant(vector);
+                    return true;
+                }
             }
             break;
         case QMetaType::QMatrix4x4:
@@ -621,6 +655,13 @@ public:
                                          params.property(14).toNumber(),
                                          params.property(15).toNumber()));
                 return true;
+            } else if (params.isString()) {
+                bool ok = false;
+                auto vector = matrix4x4FromString(params.toString(), &ok);
+                if (ok) {
+                    *v = QVariant(vector);
+                    return true;
+                }
             }
             break;
         default: break;
@@ -638,29 +679,6 @@ public:
         return true;
     }
 
-    bool createFromString(int type, const QString &s, void *data, size_t dataSize) override
-    {
-        bool ok = false;
-
-        switch (type) {
-        case QMetaType::QColor:
-            return createFromStringTyped<QColor>(data, dataSize, QColor(s));
-        case QMetaType::QVector2D:
-            return createFromStringTyped<QVector2D>(data, dataSize, vector2DFromString(s, &ok));
-        case QMetaType::QVector3D:
-            return createFromStringTyped<QVector3D>(data, dataSize, vector3DFromString(s, &ok));
-        case QMetaType::QVector4D:
-            return createFromStringTyped<QVector4D>(data, dataSize, vector4DFromString(s, &ok));
-        case QMetaType::QQuaternion:
-            return createFromStringTyped<QQuaternion>(data, dataSize, quaternionFromString(s, &ok));
-        case QMetaType::QMatrix4x4:
-            return createFromStringTyped<QMatrix4x4>(data, dataSize, matrix4x4FromString(s, &ok));
-        default: break;
-        }
-
-        return false;
-    }
-
     bool variantFromString(int type, const QString &s, QVariant *v) override
     {
         bool ok = false;