Merge remote-tracking branch 'origin/5.15' into dev

 Conflicts:
	src/qml/qml/qqmlvaluetype.cpp
	tests/auto/qml/qml.pro

Change-Id: I78f992f83212bb9fd5e09b64163f15f046185224

59 files changed, 618 insertions, 275 deletions

diff --git a/src/imports/labsmodels/qqmltablemodel.cpp b/src/imports/labsmodels/qqmltablemodel.cpp
index f190ad86b1..b6468d760f 100644
--- a/src/imports/labsmodels/qqmltablemodel.cpp
+++ b/src/imports/labsmodels/qqmltablemodel.cpp
@@ -271,7 +271,7 @@ QQmlTableModel::ColumnRoleMetadata QQmlTableModel::fetchColumnRoleData(const QSt
 
     if (columnRoleGetter.isString()) {
         // The role is set as a string, so we assume the row is a simple object.
-        if (firstRow.type() != QVariant::Map) {
+        if (firstRow.userType() != QMetaType::QVariantMap) {
             qmlWarning(this).quote() << "expected row for role "
                 << roleNameKey << " of TableModelColumn at index "
                 << columnIndex << " to be a simple object, but it's "
@@ -284,7 +284,7 @@ QQmlTableModel::ColumnRoleMetadata QQmlTableModel::fetchColumnRoleData(const QSt
 
         roleData.isStringRole = true;
         roleData.name = rolePropertyName;
-        roleData.type = roleProperty.type();
+        roleData.type = roleProperty.userType();
         roleData.typeName = QString::fromLatin1(roleProperty.typeName());
     } else if (columnRoleGetter.isCallable()) {
         // The role is provided via a function, which means the row is complex and
@@ -296,7 +296,7 @@ QQmlTableModel::ColumnRoleMetadata QQmlTableModel::fetchColumnRoleData(const QSt
         // We don't know the property name since it's provided through the function.
         // roleData.name = ???
         roleData.isStringRole = false;
-        roleData.type = cellData.type();
+        roleData.type = cellData.userType();
         roleData.typeName = QString::fromLatin1(cellData.typeName());
     } else {
         // Invalid role.
@@ -326,7 +326,7 @@ void QQmlTableModel::fetchColumnMetadata()
         for (const int builtInRoleKey : builtInRoleKeys) {
             const QString builtInRoleName = supportedRoleNames.value(builtInRoleKey);
             ColumnRoleMetadata roleData = fetchColumnRoleData(builtInRoleName, column, columnIndex);
-            if (roleData.type == QVariant::Invalid) {
+            if (roleData.type == QMetaType::UnknownType) {
                 // This built-in role was not specified in this column.
                 continue;
             }
@@ -847,7 +847,7 @@ bool QQmlTableModel::setData(const QModelIndex &index, const QVariant &value, in
     // If the value set is not of the expected type, we can try to convert it automatically.
     const ColumnRoleMetadata roleData = columnMetadata.roles.value(roleName);
     QVariant effectiveValue = value;
-    if (value.type() != roleData.type) {
+    if (value.userType() != roleData.type) {
         if (!value.canConvert(int(roleData.type))) {
             qmlWarning(this).nospace() << "setData(): the value " << value
                 << " set at row " << row << " column " << column << " with role " << roleName
@@ -933,7 +933,7 @@ QQmlTableModel::ColumnRoleMetadata::ColumnRoleMetadata()
 }
 
 QQmlTableModel::ColumnRoleMetadata::ColumnRoleMetadata(
-    bool isStringRole, const QString &name, QVariant::Type type, const QString &typeName) :
+    bool isStringRole, const QString &name, int type, const QString &typeName) :
     isStringRole(isStringRole),
     name(name),
     type(type),
@@ -995,7 +995,7 @@ bool QQmlTableModel::validateNewRow(const char *functionName, const QVariant &ro
 
     const QVariant rowAsVariant = operation == SetRowsOperation
         ? row : row.value<QJSValue>().toVariant();
-    if (rowAsVariant.type() != QVariant::Map) {
+    if (rowAsVariant.userType() != QMetaType::QVariantMap) {
         qmlWarning(this) << functionName << ": row manipulation functions "
             << "do not support complex rows (row index: " << rowIndex << ")";
         return false;
@@ -1028,7 +1028,7 @@ bool QQmlTableModel::validateNewRow(const char *functionName, const QVariant &ro
             }
 
             const QVariant rolePropertyValue = rowAsMap.value(roleData.name);
-            if (rolePropertyValue.type() != roleData.type) {
+            if (rolePropertyValue.userType() != roleData.type) {
                 qmlWarning(this).quote() << functionName << ": expected the property named "
                     << roleData.name << " to be of type " << roleData.typeName
                     << ", but got " << QString::fromLatin1(rolePropertyValue.typeName()) << " instead";
diff --git a/src/imports/labsmodels/qqmltablemodel_p.h b/src/imports/labsmodels/qqmltablemodel_p.h
index 6bf3e6df19..d6e982d19a 100644
--- a/src/imports/labsmodels/qqmltablemodel_p.h
+++ b/src/imports/labsmodels/qqmltablemodel_p.h
@@ -116,14 +116,14 @@ private:
     {
     public:
         ColumnRoleMetadata();
-        ColumnRoleMetadata(bool isStringRole, const QString &name, QVariant::Type type, const QString &typeName);
+        ColumnRoleMetadata(bool isStringRole, const QString &name, int type, const QString &typeName);
 
         bool isValid() const;
 
         // If this is false, it's a function role.
         bool isStringRole = false;
         QString name;
-        QVariant::Type type = QVariant::Invalid;
+        int type = QMetaType::UnknownType;
         QString typeName;
     };
 
diff --git a/src/imports/settings/qqmlsettings.cpp b/src/imports/settings/qqmlsettings.cpp
index d43f9bafb7..de45f87638 100644
--- a/src/imports/settings/qqmlsettings.cpp
+++ b/src/imports/settings/qqmlsettings.cpp
@@ -335,7 +335,7 @@ void QQmlSettingsPrivate::load()
         const QVariant currentValue = instance()->value(property.name(), previousValue);
 
         if (!currentValue.isNull() && (!previousValue.isValid()
-                || (currentValue.canConvert(previousValue.type()) && previousValue != currentValue))) {
+                || (currentValue.canConvert(previousValue.userType()) && previousValue != currentValue))) {
             property.write(q, currentValue);
             qCDebug(lcSettings) << "QQmlSettings: load" << property.name() << "setting:" << currentValue << "default:" << previousValue;
         }
diff --git a/src/imports/testlib/quicktestevent.cpp b/src/imports/testlib/quicktestevent.cpp
index 56faff9f7e..f2d7f93d26 100644
--- a/src/imports/testlib/quicktestevent.cpp
+++ b/src/imports/testlib/quicktestevent.cpp
@@ -125,7 +125,7 @@ bool QuickTestEvent::keyClickChar(const QString &character, int modifiers, int d
 // valueToKeySequence() is copied from qquickshortcut.cpp
 static QKeySequence valueToKeySequence(const QVariant &value)
 {
-    if (value.type() == QVariant::Int)
+    if (value.userType() == QMetaType::Int)
         return QKeySequence(static_cast<QKeySequence::StandardKey>(value.toInt()));
     return QKeySequence::fromString(value.toString());
 }
diff --git a/src/particles/qquickcumulativedirection.cpp b/src/particles/qquickcumulativedirection.cpp
index 905d44cae9..e37435e960 100644
--- a/src/particles/qquickcumulativedirection.cpp
+++ b/src/particles/qquickcumulativedirection.cpp
@@ -56,7 +56,7 @@ QQuickCumulativeDirection::QQuickCumulativeDirection(QObject *parent):QQuickDire
 
 QQmlListProperty<QQuickDirection> QQuickCumulativeDirection::directions()
 {
-    return QQmlListProperty<QQuickDirection>(this, m_directions);//TODO: Proper list property
+    return QQmlListProperty<QQuickDirection>(this, &m_directions);//TODO: Proper list property
 }
 
 QPointF QQuickCumulativeDirection::sample(const QPointF &from)
diff --git a/src/plugins/qmltooling/qmldbg_debugger/qqmlenginedebugservice.cpp b/src/plugins/qmltooling/qmldbg_debugger/qqmlenginedebugservice.cpp
index 029004ffd1..a3d19841cf 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qqmlenginedebugservice.cpp
+++ b/src/plugins/qmltooling/qmldbg_debugger/qqmlenginedebugservice.cpp
@@ -96,7 +96,7 @@ static bool isSaveable(const QVariant &value)
 {
     NullDevice nullDevice;
     QDataStream fakeStream(&nullDevice);
-    return QMetaType::save(fakeStream, static_cast<int>(value.type()), value.constData());
+    return QMetaType::save(fakeStream, static_cast<int>(value.userType()), value.constData());
 }
 
 QQmlEngineDebugServiceImpl::QQmlEngineDebugServiceImpl(QObject *parent) :
@@ -217,7 +217,7 @@ QVariant QQmlEngineDebugServiceImpl::valueContents(QVariant value) const
     //QObject * is not streamable.
     //Convert all such instances to a String value
 
-    if (value.type() == QVariant::List) {
+    if (value.userType() == QMetaType::QVariantList) {
         QVariantList contents;
         QVariantList list = value.toList();
         int count = list.size();
@@ -227,7 +227,7 @@ QVariant QQmlEngineDebugServiceImpl::valueContents(QVariant value) const
         return contents;
     }
 
-    if (value.type() == QVariant::Map) {
+    if (value.userType() == QMetaType::QVariantMap) {
         QVariantMap contents;
         const auto map = value.toMap();
         for (auto i = map.cbegin(), end = map.cend(); i != end; ++i)
diff --git a/src/qml/jsapi/qjsvalue.cpp b/src/qml/jsapi/qjsvalue.cpp
index c2957dd294..b40bc1f18b 100644
--- a/src/qml/jsapi/qjsvalue.cpp
+++ b/src/qml/jsapi/qjsvalue.cpp
@@ -314,7 +314,7 @@ bool QJSValue::isBool() const
     if (val)
         return val->isBoolean();
     QVariant *variant = QJSValuePrivate::getVariant(this);
-    return variant && variant->type() == QVariant::Bool;
+    return variant && variant->userType() == QMetaType::Bool;
 }
 
 /*!
@@ -520,9 +520,9 @@ QString QJSValue::toString() const
     if (!val) {
         QVariant *variant = QJSValuePrivate::getVariant(this);
         Q_ASSERT(variant);
-        if (variant->type() == QVariant::Map)
+        if (variant->userType() == QMetaType::QVariantMap)
             return QStringLiteral("[object Object]");
-        else if (variant->type() == QVariant::List) {
+        else if (variant->userType() == QMetaType::QVariantList) {
             const QVariantList list = variant->toList();
             QString result;
             for (int i = 0; i < list.count(); ++i) {
@@ -558,7 +558,7 @@ double QJSValue::toNumber() const
         QVariant *variant = QJSValuePrivate::getVariant(this);
         Q_ASSERT(variant);
 
-        if (variant->type() == QVariant::String)
+        if (variant->userType() == QMetaType::QString)
             return RuntimeHelpers::stringToNumber(variant->toString());
         else if (variant->canConvert<double>())
             return variant->value<double>();
@@ -1040,7 +1040,7 @@ bool QJSValue::equals(const QJSValue& other) const
         Q_ASSERT(variant);
         if (!ov)
             return *variant == *QJSValuePrivate::getVariant(&other);
-        if (variant->type() == QVariant::Map || variant->type() == QVariant::List)
+        if (variant->userType() == QMetaType::QVariantMap || variant->userType() == QMetaType::QVariantList)
             return false;
         return js_equal(variant->toString(), *ov);
         }
@@ -1083,7 +1083,7 @@ bool QJSValue::strictlyEquals(const QJSValue& other) const
         Q_ASSERT(variant);
         if (!ov)
             return *variant == *QJSValuePrivate::getVariant(&other);
-        if (variant->type() == QVariant::Map || variant->type() == QVariant::List)
+        if (variant->userType() == QMetaType::QVariantMap || variant->userType() == QMetaType::QVariantList)
             return false;
         if (String *s = ov->stringValue())
             return variant->toString() == s->toQString();
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 14eaa5bce8..dcdebfb398 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -1461,7 +1461,7 @@ static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::Value &value, int
     if (const QV4::VariantObject *v = value.as<QV4::VariantObject>())
         return v->d()->data();
 
-    if (typeHint == QVariant::Bool)
+    if (typeHint == QMetaType::Bool)
         return QVariant(value.toBoolean());
 
     if (typeHint == QMetaType::QJsonValue)
@@ -1533,7 +1533,7 @@ static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::Value &value, int
     if (String *s = value.stringValue()) {
         const QString &str = s->toQString();
         // QChars are stored as a strings
-        if (typeHint == QVariant::Char && str.size() == 1)
+        if (typeHint == QMetaType::QChar && str.size() == 1)
             return str.at(0);
         return str;
     }
@@ -1832,7 +1832,7 @@ QV4::ReturnedValue ExecutionEngine::metaTypeToJS(int type, const void *data)
     Q_ASSERT(data != nullptr);
 
     QVariant variant(type, data);
-    if (QMetaType::Type(variant.type()) == QMetaType::QVariant) {
+    if (QMetaType::Type(variant.userType()) == QMetaType::QVariant) {
         // unwrap it: this is tested in QJSEngine, and makes the most sense for
         // end-user code too.
         return variantToJS(this, *reinterpret_cast<const QVariant*>(data));
diff --git a/src/qml/jsruntime/qv4include.cpp b/src/qml/jsruntime/qv4include.cpp
index 92face6f94..64ca719e29 100644
--- a/src/qml/jsruntime/qv4include.cpp
+++ b/src/qml/jsruntime/qv4include.cpp
@@ -163,7 +163,7 @@ void QV4Include::finished()
     QV4::Scope scope(v4);
     QV4::ScopedObject resultObj(scope, m_resultObject.value());
     QV4::ScopedString status(scope, v4->newString(QStringLiteral("status")));
-    if (m_reply->error() == QNetworkReply::NoError) {
+    if (m_reply->networkError() == QNetworkReply::NoError) {
         QByteArray data = m_reply->readAll();
 
         QString code = QString::fromUtf8(data);
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index 5a81f24e06..9613d064c4 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -1654,7 +1654,7 @@ static QV4::ReturnedValue CallOverloaded(const QQmlObjectOrGadget &object, const
 }
 
 CallArgument::CallArgument()
-: type(QVariant::Invalid)
+: type(QMetaType::UnknownType)
 {
 }
 
diff --git a/src/qml/jsruntime/qv4variantobject.cpp b/src/qml/jsruntime/qv4variantobject.cpp
index e117e509ab..9d7b3c6e9a 100644
--- a/src/qml/jsruntime/qv4variantobject.cpp
+++ b/src/qml/jsruntime/qv4variantobject.cpp
@@ -65,8 +65,8 @@ void Heap::VariantObject::init(const QVariant &value)
 
 bool VariantObject::Data::isScarce() const
 {
-    QVariant::Type t = data().type();
-    return t == QVariant::Pixmap || t == QVariant::Image;
+    int t = data().userType();
+    return t == QMetaType::QPixmap || t == QMetaType::QImage;
 }
 
 bool VariantObject::virtualIsEqualTo(Managed *m, Managed *other)
@@ -139,7 +139,7 @@ ReturnedValue VariantPrototype::method_toString(const FunctionObject *b, const V
         RETURN_UNDEFINED();
     const QVariant variant = o->d()->data();
     QString result = variant.toString();
-    if (result.isEmpty() && !variant.canConvert(QVariant::String)) {
+    if (result.isEmpty() && !variant.canConvert(QMetaType::QString)) {
         QDebug dbg(&result);
         dbg << variant;
         // QDebug appends a space, we're not interested in continuing the stream so we chop it off.
@@ -154,17 +154,17 @@ ReturnedValue VariantPrototype::method_valueOf(const FunctionObject *b, const Va
     const VariantObject *o = thisObject->as<QV4::VariantObject>();
     if (o) {
         QVariant v = o->d()->data();
-        switch (v.type()) {
-        case QVariant::Invalid:
+        switch (v.userType()) {
+        case QMetaType::UnknownType:
             return Encode::undefined();
-        case QVariant::String:
+        case QMetaType::QString:
             return Encode(b->engine()->newString(v.toString()));
-        case QVariant::Int:
+        case QMetaType::Int:
             return Encode(v.toInt());
-        case QVariant::Double:
-        case QVariant::UInt:
+        case QMetaType::Double:
+        case QMetaType::UInt:
             return Encode(v.toDouble());
-        case QVariant::Bool:
+        case QMetaType::Bool:
             return Encode(v.toBool());
         default:
             if (QMetaType::typeFlags(v.userType()) & QMetaType::IsEnumeration)
diff --git a/src/qml/qml/ftw/qhashedstring.cpp b/src/qml/qml/ftw/qhashedstring.cpp
index bbe374044d..4553fa9359 100644
--- a/src/qml/qml/ftw/qhashedstring.cpp
+++ b/src/qml/qml/ftw/qhashedstring.cpp
@@ -102,6 +102,25 @@ QHashedStringRef QHashedStringRef::mid(int offset, int length) const
                             (length == -1 || (offset + length) > m_length)?(m_length - offset):length);
 }
 
+QVector<QHashedStringRef> QHashedStringRef::split(const QChar sep) const
+{
+    QVector<QHashedStringRef> ret;
+    auto curLength = 0;
+    auto curOffset = m_data;
+    for (int offset = 0; offset < m_length; ++offset) {
+        if (*(m_data + offset) == sep) {
+            ret.push_back({curOffset, curLength});
+            curOffset = m_data + offset + 1;
+            curLength = 0;
+        } else {
+            ++curLength;
+        }
+    }
+    if (curLength > 0)
+        ret.push_back({curOffset, curLength});
+    return ret;
+}
+
 bool QHashedStringRef::endsWith(const QString &s) const
 {
     return s.length() < m_length &&
diff --git a/src/qml/qml/ftw/qhashedstring_p.h b/src/qml/qml/ftw/qhashedstring_p.h
index b9f3f81219..a2e10ff143 100644
--- a/src/qml/qml/ftw/qhashedstring_p.h
+++ b/src/qml/qml/ftw/qhashedstring_p.h
@@ -125,6 +125,7 @@ public:
     bool endsWith(const QString &) const;
     int indexOf(const QChar &, int from=0) const;
     QHashedStringRef mid(int, int) const;
+    QVector<QHashedStringRef> split(const QChar sep) const;
 
     inline bool isEmpty() const;
     inline int length() const;
diff --git a/src/qml/qml/qqmlbinding.cpp b/src/qml/qml/qqmlbinding.cpp
index 162adf8364..e14b00af22 100644
--- a/src/qml/qml/qqmlbinding.cpp
+++ b/src/qml/qml/qqmlbinding.cpp
@@ -479,7 +479,7 @@ Q_NEVER_INLINE bool QQmlBinding::slowWrite(const QQmlPropertyData &core,
                 if (!propertyMetaObject.isNull())
                     propertyType = propertyMetaObject.className();
             }
-        } else if (userType != QVariant::Invalid) {
+        } else if (userType != QMetaType::UnknownType) {
             if (userType == QMetaType::Nullptr || userType == QMetaType::VoidStar)
                 valueType = "null";
             else
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index 6cdb012e26..9b6f83f144 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -101,8 +101,6 @@
 #  endif
 #endif // Q_OS_WIN
 
-Q_DECLARE_METATYPE(QQmlProperty)
-
 QT_BEGIN_NAMESPACE
 
 // Declared in qqml.h
diff --git a/src/qml/qml/qqmlfile.cpp b/src/qml/qml/qqmlfile.cpp
index 465a342129..ee54359d0f 100644
--- a/src/qml/qml/qqmlfile.cpp
+++ b/src/qml/qml/qqmlfile.cpp
@@ -187,7 +187,7 @@ void QQmlFileNetworkReply::networkFinished()
         }
     }
 
-    if (m_reply->error()) {
+    if (m_reply->networkError()) {
         m_p->errorString = m_reply->errorString();
         m_p->error = QQmlFilePrivate::Network;
     } else {
diff --git a/src/qml/qml/qqmllist.cpp b/src/qml/qml/qqmllist.cpp
index 5425bf498c..b504fdf22d 100644
--- a/src/qml/qml/qqmllist.cpp
+++ b/src/qml/qml/qqmllist.cpp
@@ -250,10 +250,37 @@ bool QQmlListReference::canCount() const
 }
 
 /*!
-    Return true if at(), count(), append() and clear() are implemented, so you can manipulate
-    the list.
+Returns true if items in the list property can be replaced, otherwise false.
+Returns false if the reference is invalid.
+
+\sa replace()
+*/
+bool QQmlListReference::canReplace() const
+{
+    return (isValid() && d->property.replace);
+}
+
+/*!
+Returns true if the last item can be removed from the list property, otherwise false.
+Returns false if the reference is invalid.
+
+\sa removeLast()
+*/
+bool QQmlListReference::canRemoveLast() const
+{
+    return (isValid() && d->property.removeLast);
+}
+
+/*!
+    Return true if at(), count(), append(), and either clear() or removeLast()
+    are implemented, so you can manipulate the list.
+
+    Mind that replace() and removeLast() can be emulated by stashing all
+    items and rebuilding the list using clear() and append(). Therefore,
+    they are not required for the list to be manipulable. Furthermore,
+    clear() can be emulated using removeLast().
 
-\sa isReadable(), at(), count(), append(), clear()
+\sa isReadable(), at(), count(), append(), clear(), replace(), removeLast()
 */
 bool QQmlListReference::isManipulable() const
 {
@@ -329,6 +356,39 @@ int QQmlListReference::count() const
 }
 
 /*!
+Replaces the item at \a index in the list with \a object.
+Returns true if the operation succeeded, otherwise false.
+
+\sa canReplace()
+*/
+bool QQmlListReference::replace(int index, QObject *object) const
+{
+    if (!canReplace())
+        return false;
+
+    if (object && !QQmlMetaObject::canConvert(object, d->elementType))
+        return false;
+
+    d->property.replace(&d->property, index, object);
+    return true;
+}
+
+/*!
+Removes the last item in the list.
+Returns true if the operation succeeded, otherwise false.
+
+\sa canRemoveLast()
+*/
+bool QQmlListReference::removeLast() const
+{
+    if (!canRemoveLast())
+        return false;
+
+    d->property.removeLast(&d->property);
+    return true;
+}
+
+/*!
 \class QQmlListProperty
 \since 5.0
 \inmodule QtQml
@@ -375,14 +435,25 @@ QML list properties are type-safe - in this case \c {Fruit} is a QObject type th
 
 /*!
 \fn template<typename T> QQmlListProperty<T>::QQmlListProperty(QObject *object, QList<T *> &list)
+\deprecated
 
 Convenience constructor for making a QQmlListProperty value from an existing
 QList \a list.  The \a list reference must remain valid for as long as \a object
 exists.  \a object must be provided.
 
-Generally this constructor should not be used in production code, as a
-writable QList violates QML's memory management rules.  However, this constructor
-can be very useful while prototyping.
+This constructor synthesizes the removeLast() and replace() methods
+introduced in Qt 5.15, using count(), at(), clear(), and append(). This is slow.
+If you intend to manipulate the list beyond clearing it, you should explicitly
+provide these methods.
+*/
+
+/*!
+\fn template<typename T> QQmlListProperty<T>::QQmlListProperty(QObject *object, QList<T *> *list)
+\since 5.15
+
+Convenience constructor for making a QQmlListProperty value from an existing
+QList \a list. The \a list reference must remain valid for as long as \a object
+exists. \a object must be provided.
 */
 
 /*!
@@ -408,6 +479,39 @@ remains valid while \a object exists.
 Null pointers can be passed for any function. If any null pointers are passed in, the list
 will be neither designable nor alterable by the debugger. It is recommended to provide valid
 pointers for all functions.
+
+\note The resulting QQmlListProperty will synthesize the removeLast() and
+replace() methods using \a count, \a at, \a clear, and \a append if all of those
+are given. This is slow. If you intend to manipulate the list beyond clearing it,
+you should explicitly provide these methods.
+*/
+
+/*!
+\fn template<typename T> QQmlListProperty<T>::QQmlListProperty(
+        QObject *object, void *data, AppendFunction append, CountFunction count,
+        AtFunction at, ClearFunction clear, ReplaceFunction replace,
+        RemoveLastFunction removeLast)
+
+Construct a QQmlListProperty from a set of operation functions \a append,
+\a count, \a at, \a clear, \a replace, and \removeLast. An opaque \a data handle
+may be passed which can be accessed from within the operation functions. The
+list property remains valid while \a object exists.
+
+Null pointers can be passed for any function, causing the respective function to
+be synthesized using the others, if possible. QQmlListProperty can synthesize
+\list
+    \li \a clear using \a count and \a removeLast
+    \li \a replace using \a count, \a at, \a clear, and \a append
+    \li \a replace using \a count, \a at, \a removeLast, and \a append
+    \li \a removeLast using \a count, \a at, \a clear, and \a append
+\endlist
+if those are given. This is slow, but if your list does not natively provide
+faster options for these primitives, you may want to use the synthesized ones.
+
+Furthermore, if either of \a count, \a at, \a append, and \a clear are neither
+given explicitly nor synthesized, the list will be neither designable nor
+alterable by the debugger. It is recommended to provide enough valid pointers
+to avoid this situation.
 */
 
 /*!
@@ -448,4 +552,20 @@ Synonym for \c {void (*)(QQmlListProperty<T> *property)}.
 Clear the list \a property.
 */
 
+/*!
+\typedef QQmlListProperty::ReplaceFunction
+
+Synonym for \c {void (*)(QQmlListProperty<T> *property, int index, T *value)}.
+
+Replace the element at position \a index in the list \a property with \a value.
+*/
+
+/*!
+\typedef QQmlListProperty::RemoveLastFunction
+
+Synonym for \c {void (*)(QQmlListProperty<T> *property)}.
+
+Remove the last element from the list \a property.
+*/
+
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmllist.h b/src/qml/qml/qqmllist.h
index 90ec57c911..17333ca9e4 100644
--- a/src/qml/qml/qqmllist.h
+++ b/src/qml/qml/qqmllist.h
@@ -55,22 +55,28 @@ struct QMetaObject;
 template<typename T>
 class QQmlListProperty {
 public:
-    typedef void (*AppendFunction)(QQmlListProperty<T> *, T*);
-    typedef int (*CountFunction)(QQmlListProperty<T> *);
-    typedef T *(*AtFunction)(QQmlListProperty<T> *, int);
-    typedef void (*ClearFunction)(QQmlListProperty<T> *);
-
-    QQmlListProperty()
-        : append(nullptr),
-          count(nullptr),
-          at(nullptr),
-          clear(nullptr)
-    {}
+    using AppendFunction = void (*)(QQmlListProperty<T> *, T *);
+    using CountFunction = int (*)(QQmlListProperty<T> *);
+    using AtFunction = T *(*)(QQmlListProperty<T> *, int);
+    using ClearFunction = void (*)(QQmlListProperty<T> *);
+    using ReplaceFunction = void (*)(QQmlListProperty<T> *, int, T *);
+    using RemoveLastFunction = void (*)(QQmlListProperty<T> *);
+
+    QQmlListProperty() = default;
+
+#if QT_DEPRECATED_SINCE(5,15)
+    QT_DEPRECATED_X("Use constructor taking QList pointer, and gain improved performance")
     QQmlListProperty(QObject *o, QList<T *> &list)
         : object(o), data(&list), append(qlist_append), count(qlist_count), at(qlist_at),
-          clear(qlist_clear)
+          clear(qlist_clear), replace(qslow_replace), removeLast(qslow_removeLast)
+    {}
+#endif
 
+    QQmlListProperty(QObject *o, QList<T *> *list)
+        : object(o), data(list), append(qlist_append), count(qlist_count), at(qlist_at),
+          clear(qlist_clear), replace(qlist_replace), removeLast(qlist_removeLast)
     {}
+
     QQmlListProperty(QObject *o, void *d, AppendFunction a, CountFunction c, AtFunction t,
                     ClearFunction r )
         : object(o),
@@ -78,37 +84,47 @@ public:
           append(a),
           count(c),
           at(t),
-          clear(r)
-
+          clear(r),
+          replace((a && c && t && r) ? qslow_replace : nullptr),
+          removeLast((a && c && t && r) ? qslow_removeLast : nullptr)
     {}
-    QQmlListProperty(QObject *o, void *d, CountFunction c, AtFunction t)
+
+    QQmlListProperty(QObject *o, void *d, AppendFunction a, CountFunction c, AtFunction t,
+                     ClearFunction r, ReplaceFunction s, RemoveLastFunction p)
         : object(o),
           data(d),
-          append(nullptr),
-          count(c), at(t),
-          clear(nullptr)
+          append(a),
+          count(c),
+          at(t),
+          clear((!r && p && c) ? qslow_clear : r),
+          replace((!s && a && c && t && (r || p)) ? qslow_replace : s),
+          removeLast((!p && a && c && t && r) ? qslow_removeLast : p)
+    {}
+
+    QQmlListProperty(QObject *o, void *d, CountFunction c, AtFunction a)
+        : object(o), data(d), count(c), at(a)
     {}
+
     bool operator==(const QQmlListProperty &o) const {
         return object == o.object &&
                data == o.data &&
                append == o.append &&
                count == o.count &&
                at == o.at &&
-               clear == o.clear;
+               clear == o.clear &&
+               replace == o.replace &&
+               removeLast == o.removeLast;
     }
 
     QObject *object = nullptr;
     void *data = nullptr;
 
-    AppendFunction append;
-
-    CountFunction count;
-    AtFunction at;
-
-    ClearFunction clear;
-
-    void *dummy1 = nullptr;
-    void *dummy2 = nullptr;
+    AppendFunction append = nullptr;
+    CountFunction count = nullptr;
+    AtFunction at = nullptr;
+    ClearFunction clear = nullptr;
+    ReplaceFunction replace = nullptr;
+    RemoveLastFunction removeLast = nullptr;
 
 private:
     static void qlist_append(QQmlListProperty *p, T *v) {
@@ -123,6 +139,59 @@ private:
     static void qlist_clear(QQmlListProperty *p) {
         return reinterpret_cast<QList<T *> *>(p->data)->clear();
     }
+    static void qlist_replace(QQmlListProperty *p, int idx, T *v) {
+        return reinterpret_cast<QList<T *> *>(p->data)->replace(idx, v);
+    }
+    static void qlist_removeLast(QQmlListProperty *p) {
+        return reinterpret_cast<QList<T *> *>(p->data)->removeLast();
+    }
+
+    static void qslow_replace(QQmlListProperty<T> *list, int idx, T *v)
+    {
+        const int length = list->count(list);
+        if (idx < 0 || idx >= length)
+            return;
+
+        QVector<T *> stash;
+        if (list->clear != qslow_clear) {
+            stash.reserve(length);
+            for (int i = 0; i < length; ++i)
+                stash.append(i == idx ? v : list->at(list, i));
+            list->clear(list);
+            for (T *item : qAsConst(stash))
+                list->append(list, item);
+        } else {
+            stash.reserve(length - idx - 1);
+            for (int i = length - 1; i > idx; --i) {
+                stash.append(list->at(list, i));
+                list->removeLast(list);
+            }
+            list->removeLast(list);
+            list->append(list, v);
+            while (!stash.isEmpty())
+                list->append(list, stash.takeLast());
+        }
+    }
+
+    static void qslow_clear(QQmlListProperty<T> *list)
+    {
+        for (int i = 0, end = list->count(list); i < end; ++i)
+            list->removeLast(list);
+    }
+
+    static void qslow_removeLast(QQmlListProperty<T> *list)
+    {
+        const int length = list->count(list) - 1;
+        if (length < 0)
+            return;
+        QVector<T *> stash;
+        stash.reserve(length);
+        for (int i = 0; i < length; ++i)
+            stash.append(list->at(list, i));
+        list->clear(list);
+        for (T *item : qAsConst(stash))
+            list->append(list, item);
+    }
 };
 #endif
 
@@ -146,6 +215,8 @@ public:
     bool canAt() const;
     bool canClear() const;
     bool canCount() const;
+    bool canReplace() const;
+    bool canRemoveLast() const;
 
     bool isManipulable() const;
     bool isReadable() const;
@@ -154,6 +225,8 @@ public:
     QObject *at(int) const;
     bool clear() const;
     int count() const;
+    bool replace(int, QObject *) const;
+    bool removeLast() const;
 
 private:
     friend class QQmlListReferencePrivate;
diff --git a/src/qml/qml/qqmllistwrapper.cpp b/src/qml/qml/qqmllistwrapper.cpp
index 5349572921..e5c1cb04a9 100644
--- a/src/qml/qml/qqmllistwrapper.cpp
+++ b/src/qml/qml/qqmllistwrapper.cpp
@@ -119,11 +119,13 @@ ReturnedValue QmlListWrapper::virtualGet(const Managed *m, PropertyKey id, const
         if (hasProperty)
             *hasProperty = false;
         return Value::undefinedValue().asReturnedValue();
-    } else if (id.isString()) {
-        if (id == v4->id_length()->propertyKey() && !w->d()->object.isNull()) {
-            quint32 count = w->d()->property().count ? w->d()->property().count(&w->d()->property()) : 0;
-            return Value::fromUInt32(count).asReturnedValue();
-        }
+    }
+
+    if (id.isString() && id == v4->id_length()->propertyKey()) {
+        if (hasProperty)
+            *hasProperty = true;
+        quint32 count = w->d()->property().count ? w->d()->property().count(&w->d()->property()) : 0;
+        return Value::fromUInt32(count).asReturnedValue();
     }
 
     return Object::virtualGet(m, id, receiver, hasProperty);
@@ -131,12 +133,70 @@ ReturnedValue QmlListWrapper::virtualGet(const Managed *m, PropertyKey id, const
 
 bool QmlListWrapper::virtualPut(Managed *m, PropertyKey id, const Value &value, Value *receiver)
 {
-    // doesn't do anything. Should we throw?
-    Q_UNUSED(m);
-    Q_UNUSED(id);
-    Q_UNUSED(value);
-    Q_UNUSED(receiver);
-    return false;
+    Q_ASSERT(m->as<QmlListWrapper>());
+
+    const auto *w = static_cast<const QmlListWrapper *>(m);
+    QV4::ExecutionEngine *v4 = w->engine();
+
+    QQmlListProperty<QObject> *prop = &(w->d()->property());
+
+    if (id.isArrayIndex()) {
+        if (!prop->count || !prop->replace)
+            return false;
+
+        const uint index = id.asArrayIndex();
+        const int count = prop->count(prop);
+        if (count < 0 || index >= uint(count))
+            return false;
+
+        QV4::Scope scope(v4);
+        QV4::ScopedObject so(scope, value.toObject(scope.engine));
+        if (auto *wrapper = so->as<QV4::QObjectWrapper>()) {
+            prop->replace(prop, index, wrapper->object());
+            return true;
+        }
+
+        return false;
+    }
+
+    if (id.isString() && id == v4->id_length()->propertyKey()) {
+        if (!prop->count)
+            return false;
+
+        const quint32 count = prop->count(prop);
+
+        bool ok = false;
+        const uint newLength = value.asArrayLength(&ok);
+        if (!ok)
+            return false;
+
+        if (newLength == 0) {
+            if (!prop->clear)
+                return false;
+            prop->clear(prop);
+            return true;
+        }
+
+        if (newLength < count) {
+            if (!prop->removeLast)
+                return false;
+
+            for (uint i = newLength; i < count; ++i)
+                prop->removeLast(prop);
+
+            return true;
+        }
+
+        if (!prop->append)
+            return false;
+
+        for (uint i = count; i < newLength; ++i)
+            prop->append(prop, nullptr);
+
+        return true;
+    }
+
+    return Object::virtualPut(m, id, value, receiver);
 }
 
 struct QmlListWrapperOwnPropertyKeyIterator : ObjectOwnPropertyKeyIterator
diff --git a/src/qml/qml/qqmlobjectcreator.cpp b/src/qml/qml/qqmlobjectcreator.cpp
index d68ad69260..78df02554c 100644
--- a/src/qml/qml/qqmlobjectcreator.cpp
+++ b/src/qml/qml/qqmlobjectcreator.cpp
@@ -414,25 +414,25 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         }
     }
     break;
-    case QVariant::String: {
+    case QMetaType::QString: {
         assertOrNull(binding->evaluatesToString());
         QString value = compilationUnit->bindingValueAsString(binding);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::StringList: {
+    case QMetaType::QStringList: {
         assertOrNull(binding->evaluatesToString());
         QStringList value(compilationUnit->bindingValueAsString(binding));
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::ByteArray: {
+    case QMetaType::QByteArray: {
         assertType(QV4::CompiledData::Binding::Type_String);
         QByteArray value(compilationUnit->bindingValueAsString(binding).toUtf8());
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::Url: {
+    case QMetaType::QUrl: {
         assertType(QV4::CompiledData::Binding::Type_String);
         QString string = compilationUnit->bindingValueAsString(binding);
         // Encoded dir-separators defeat QUrl processing - decode them first
@@ -444,7 +444,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::UInt: {
+    case QMetaType::UInt: {
         assertType(QV4::CompiledData::Binding::Type_Number);
         double d = compilationUnit->bindingValueAsNumber(binding);
         uint value = uint(d);
@@ -452,7 +452,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         break;
     }
     break;
-    case QVariant::Int: {
+    case QMetaType::Int: {
         assertType(QV4::CompiledData::Binding::Type_Number);
         double d = compilationUnit->bindingValueAsNumber(binding);
         int value = int(d);
@@ -466,13 +466,13 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::Double: {
+    case QMetaType::Double: {
         assertType(QV4::CompiledData::Binding::Type_Number);
         double value = compilationUnit->bindingValueAsNumber(binding);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::Color: {
+    case QMetaType::QColor: {
         bool ok = false;
         uint colorValue = QQmlStringConverters::rgbaFromString(compilationUnit->bindingValueAsString(binding), &ok);
         assertOrNull(ok);
@@ -483,21 +483,21 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     }
     break;
 #if QT_CONFIG(datestring)
-    case QVariant::Date: {
+    case QMetaType::QDate: {
         bool ok = false;
         QDate value = QQmlStringConverters::dateFromString(compilationUnit->bindingValueAsString(binding), &ok);
         assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::Time: {
+    case QMetaType::QTime: {
         bool ok = false;
         QTime value = QQmlStringConverters::timeFromString(compilationUnit->bindingValueAsString(binding), &ok);
         assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::DateTime: {
+    case QMetaType::QDateTime: {
         bool ok = false;
         QDateTime value = QQmlStringConverters::dateTimeFromString(compilationUnit->bindingValueAsString(binding), &ok);
         // ### VME compatibility :(
@@ -511,55 +511,55 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     }
     break;
 #endif // datestring
-    case QVariant::Point: {
+    case QMetaType::QPoint: {
         bool ok = false;
         QPoint value = QQmlStringConverters::pointFFromString(compilationUnit->bindingValueAsString(binding), &ok).toPoint();
         assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::PointF: {
+    case QMetaType::QPointF: {
         bool ok = false;
         QPointF value = QQmlStringConverters::pointFFromString(compilationUnit->bindingValueAsString(binding), &ok);
         assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::Size: {
+    case QMetaType::QSize: {
         bool ok = false;
         QSize value = QQmlStringConverters::sizeFFromString(compilationUnit->bindingValueAsString(binding), &ok).toSize();
         assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::SizeF: {
+    case QMetaType::QSizeF: {
         bool ok = false;
         QSizeF value = QQmlStringConverters::sizeFFromString(compilationUnit->bindingValueAsString(binding), &ok);
         assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::Rect: {
+    case QMetaType::QRect: {
         bool ok = false;
         QRect value = QQmlStringConverters::rectFFromString(compilationUnit->bindingValueAsString(binding), &ok).toRect();
         assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::RectF: {
+    case QMetaType::QRectF: {
         bool ok = false;
         QRectF value = QQmlStringConverters::rectFFromString(compilationUnit->bindingValueAsString(binding), &ok);
         assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::Bool: {
+    case QMetaType::Bool: {
         assertType(QV4::CompiledData::Binding::Type_Boolean);
         bool value = binding->valueAsBoolean();
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
-    case QVariant::Vector2D: {
+    case QMetaType::QVector2D: {
         struct {
             float xp;
             float yp;
@@ -570,7 +570,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         property->writeProperty(_qobject, &vec, propertyWriteFlags);
     }
     break;
-    case QVariant::Vector3D: {
+    case QMetaType::QVector3D: {
         struct {
             float xp;
             float yp;
@@ -582,7 +582,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         property->writeProperty(_qobject, &vec, propertyWriteFlags);
     }
     break;
-    case QVariant::Vector4D: {
+    case QMetaType::QVector4D: {
         struct {
             float xp;
             float yp;
@@ -595,7 +595,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         property->writeProperty(_qobject, &vec, propertyWriteFlags);
     }
     break;
-    case QVariant::Quaternion: {
+    case QMetaType::QQuaternion: {
         struct {
             float wp;
             float xp;
@@ -608,7 +608,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         property->writeProperty(_qobject, &vec, propertyWriteFlags);
     }
     break;
-    case QVariant::RegExp:
+    case QMetaType::QRegExp:
         assertOrNull(!"not possible");
         break;
     default: {
@@ -673,7 +673,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         QVariant value = (*converter)(stringValue);
 
         QMetaProperty metaProperty = _qobject->metaObject()->property(property->coreIndex());
-        if (value.isNull() || ((int)metaProperty.type() != property->propType() && metaProperty.userType() != property->propType())) {
+        if (value.isNull() || metaProperty.userType() != property->propType()) {
             recordError(binding->location, tr("Cannot assign value %1 to property %2").arg(stringValue).arg(QString::fromUtf8(metaProperty.name())));
             break;
         }
diff --git a/src/qml/qml/qqmlproperty.cpp b/src/qml/qml/qqmlproperty.cpp
index 871bec1c17..93020661e2 100644
--- a/src/qml/qml/qqmlproperty.cpp
+++ b/src/qml/qml/qqmlproperty.cpp
@@ -471,7 +471,7 @@ QQmlPropertyPrivate::propertyTypeCategory() const
         return QQmlProperty::Normal;
     } else if (type & QQmlProperty::Property) {
         int type = propertyType();
-        if (type == QVariant::Invalid)
+        if (type == QMetaType::UnknownType)
             return QQmlProperty::InvalidCategory;
         else if (QQmlValueTypeFactory::isValueType((uint)type))
             return QQmlProperty::Normal;
@@ -526,7 +526,7 @@ bool QQmlProperty::operator==(const QQmlProperty &other) const
 */
 int QQmlProperty::propertyType() const
 {
-    return d ? d->propertyType() : int(QVariant::Invalid);
+    return d ? d->propertyType() : int(QMetaType::UnknownType);
 }
 
 bool QQmlPropertyPrivate::isValueType() const
@@ -542,7 +542,7 @@ int QQmlPropertyPrivate::propertyType() const
     } else if (type & QQmlProperty::Property) {
         return core.propType();
     } else {
-        return QVariant::Invalid;
+        return QMetaType::UnknownType;
     }
 }
 
@@ -1133,7 +1133,7 @@ bool QQmlPropertyPrivate::writeEnumProperty(const QMetaProperty &prop, int idx,
     QVariant v = value;
     if (prop.isEnumType()) {
         QMetaEnum menum = prop.enumerator();
-        if (v.userType() == QVariant::String
+        if (v.userType() == QMetaType::QString
 #ifdef QT3_SUPPORT
             || v.userType() == QVariant::CString
 #endif
@@ -1145,13 +1145,13 @@ bool QQmlPropertyPrivate::writeEnumProperty(const QMetaProperty &prop, int idx,
                 v = QVariant(menum.keyToValue(value.toByteArray(), &ok));
             if (!ok)
                 return false;
-        } else if (v.userType() != QVariant::Int && v.userType() != QVariant::UInt) {
+        } else if (v.userType() != QMetaType::Int && v.userType() != QMetaType::UInt) {
             int enumMetaTypeId = QMetaType::type(QByteArray(menum.scope() + QByteArray("::") + menum.name()));
             if ((enumMetaTypeId == QMetaType::UnknownType) || (v.userType() != enumMetaTypeId) || !v.constData())
                 return false;
             v = QVariant(*reinterpret_cast<const int *>(v.constData()));
         }
-        v.convert(QVariant::Int);
+        v.convert(QMetaType::Int);
     }
 
     // the status variable is changed by qt_metacall to indicate what it did
@@ -1206,17 +1206,17 @@ bool QQmlPropertyPrivate::write(QObject *object,
         QMetaProperty prop = object->metaObject()->property(property.coreIndex());
         QVariant v = value;
         // Enum values come through the script engine as doubles
-        if (variantType == QVariant::Double) {
+        if (variantType == QMetaType::Double) {
             double integral;
             double fractional = std::modf(value.toDouble(), &integral);
             if (qFuzzyIsNull(fractional))
-                v.convert(QVariant::Int);
+                v.convert(QMetaType::Int);
         }
         return writeEnumProperty(prop, property.coreIndex(), object, v, flags);
     }
 
     QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(context);
-    const bool isUrl = propertyType == QVariant::Url; // handled separately
+    const bool isUrl = propertyType == QMetaType::QUrl; // handled separately
 
     // The cases below are in approximate order of likelyhood:
     if (propertyType == variantType && !isUrl && propertyType != qMetaTypeId<QList<QUrl>>() && !property.isQList()) {
@@ -1249,7 +1249,7 @@ bool QQmlPropertyPrivate::write(QObject *object,
         } else {
             return false;
         }
-    } else if (value.canConvert(propertyType) && !isUrl && variantType != QVariant::String && propertyType != qMetaTypeId<QList<QUrl>>() && !property.isQList()) {
+    } else if (value.canConvert(propertyType) && !isUrl && variantType != QMetaType::QString && propertyType != qMetaTypeId<QList<QUrl>>() && !property.isQList()) {
         // common cases:
         switch (propertyType) {
         case QMetaType::Bool: {
@@ -1282,14 +1282,14 @@ bool QQmlPropertyPrivate::write(QObject *object,
         return property.writeProperty(object, const_cast<QVariant *>(&value), flags);
     } else if (isUrl) {
         QUrl u;
-        if (variantType == QVariant::Url) {
+        if (variantType == QMetaType::QUrl) {
             u = value.toUrl();
-        } else if (variantType == QVariant::ByteArray) {
+        } else if (variantType == QMetaType::QByteArray) {
             QString input(QString::fromUtf8(value.toByteArray()));
             // Encoded dir-separators defeat QUrl processing - decode them first
             input.replace(QLatin1String("%2f"), QLatin1String("/"), Qt::CaseInsensitive);
             u = QUrl(input);
-        } else if (variantType == QVariant::String) {
+        } else if (variantType == QMetaType::QString) {
             QString input(value.toString());
             // Encoded dir-separators defeat QUrl processing - decode them first
             input.replace(QLatin1String("%2f"), QLatin1String("/"), Qt::CaseInsensitive);
@@ -1355,7 +1355,7 @@ bool QQmlPropertyPrivate::write(QObject *object,
 
         bool ok = false;
         QVariant v;
-        if (variantType == QVariant::String)
+        if (variantType == QMetaType::QString)
             v = QQmlStringConverters::variantFromString(value.toString(), propertyType, &ok);
 
         if (!ok) {
@@ -1368,8 +1368,8 @@ bool QQmlPropertyPrivate::write(QObject *object,
                 // successful conversion.
                 Q_ASSERT(v.userType() == propertyType);
                 ok = true;
-            } else if (static_cast<uint>(propertyType) >= QVariant::UserType &&
-                       variantType == QVariant::String) {
+            } else if (static_cast<uint>(propertyType) >= QMetaType::User &&
+                       variantType == QMetaType::QString) {
                 QQmlMetaType::StringConverter con = QQmlMetaType::customStringConverter(propertyType);
                 if (con) {
                     v = con(value.toString());
@@ -1383,28 +1383,28 @@ bool QQmlPropertyPrivate::write(QObject *object,
             // to a sequence type property (eg, an int to a QList<int> property).
             // or that we encountered an interface type
             // Note that we've already handled single-value assignment to QList<QUrl> properties.
-            if (variantType == QVariant::Int && propertyType == qMetaTypeId<QList<int> >()) {
+            if (variantType == QMetaType::Int && propertyType == qMetaTypeId<QList<int> >()) {
                 QList<int> list;
                 list << value.toInt();
                 v = QVariant::fromValue<QList<int> >(list);
                 ok = true;
-            } else if ((variantType == QVariant::Double || variantType == QVariant::Int)
+            } else if ((variantType == QMetaType::Double || variantType == QMetaType::Int)
                        && (propertyType == qMetaTypeId<QList<qreal> >())) {
                 QList<qreal> list;
                 list << value.toReal();
                 v = QVariant::fromValue<QList<qreal> >(list);
                 ok = true;
-            } else if (variantType == QVariant::Bool && propertyType == qMetaTypeId<QList<bool> >()) {
+            } else if (variantType == QMetaType::Bool && propertyType == qMetaTypeId<QList<bool> >()) {
                 QList<bool> list;
                 list << value.toBool();
                 v = QVariant::fromValue<QList<bool> >(list);
                 ok = true;
-            } else if (variantType == QVariant::String && propertyType == qMetaTypeId<QList<QString> >()) {
+            } else if (variantType == QMetaType::QString && propertyType == qMetaTypeId<QList<QString> >()) {
                 QList<QString> list;
                 list << value.toString();
                 v = QVariant::fromValue<QList<QString> >(list);
                 ok = true;
-            } else if (variantType == QVariant::String && propertyType == qMetaTypeId<QStringList>()) {
+            } else if (variantType == QMetaType::QString && propertyType == qMetaTypeId<QStringList>()) {
                 QStringList list;
                 list << value.toString();
                 v = QVariant::fromValue<QStringList>(list);
diff --git a/src/qml/qml/qqmlpropertycache.cpp b/src/qml/qml/qqmlpropertycache.cpp
index 6336ff28b3..71a8a255a9 100644
--- a/src/qml/qml/qqmlpropertycache.cpp
+++ b/src/qml/qml/qqmlpropertycache.cpp
@@ -92,7 +92,7 @@ static void flagsForPropertyType(int propType, QQmlPropertyData::Flags &flags)
         flags.type = QQmlPropertyData::Flags::QObjectDerivedType;
     } else if (propType == QMetaType::QVariant) {
         flags.type = QQmlPropertyData::Flags::QVariantType;
-    } else if (propType < static_cast<int>(QVariant::UserType)) {
+    } else if (propType < static_cast<int>(QMetaType::User)) {
         // nothing to do
     } else if (propType == qMetaTypeId<QQmlBinding *>()) {
         flags.type = QQmlPropertyData::Flags::QmlBindingType;
@@ -136,14 +136,14 @@ static void populate(QQmlPropertyData *data, const QMetaProperty &p)
 void QQmlPropertyData::lazyLoad(const QMetaProperty &p)
 {
     populate(this, p);
-    int type = static_cast<int>(p.type());
+    int type = static_cast<int>(p.userType());
     if (type == QMetaType::QObjectStar) {
         setPropType(type);
         m_flags.type = Flags::QObjectDerivedType;
     } else if (type == QMetaType::QVariant) {
         setPropType(type);
         m_flags.type = Flags::QVariantType;
-    } else if (type == QVariant::UserType || type == -1) {
+    } else if (type >= QMetaType::User || type == 0) {
         m_flags.notFullyResolved = true;
     } else {
         setPropType(type);
@@ -314,7 +314,7 @@ void QQmlPropertyCache::appendSignal(const QString &name, QQmlPropertyData::Flag
                                      const QList<QByteArray> &names)
 {
     QQmlPropertyData data;
-    data.setPropType(QVariant::Invalid);
+    data.setPropType(QMetaType::UnknownType);
     data.setCoreIndex(coreIndex);
     data.setFlags(flags);
     data.setArguments(nullptr);
diff --git a/src/qml/qml/qqmlpropertycachecreator_p.h b/src/qml/qml/qqmlpropertycachecreator_p.h
index 8571b0c9b3..1f636c8347 100644
--- a/src/qml/qml/qqmlpropertycachecreator_p.h
+++ b/src/qml/qml/qqmlpropertycachecreator_p.h
@@ -806,12 +806,12 @@ inline QQmlJS::DiagnosticMessage QQmlPropertyCacheAliasCreator<ObjectContainer>:
             if (valueTypeIndex != -1) {
                 const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(*type);
                 if (valueTypeMetaObject->property(valueTypeIndex).isEnumType())
-                    *type = QVariant::Int;
+                    *type = QMetaType::Int;
                 else
                     *type = valueTypeMetaObject->property(valueTypeIndex).userType();
             } else {
                 if (targetProperty->isEnum()) {
-                    *type = QVariant::Int;
+                    *type = QMetaType::Int;
                 } else {
                     // Copy type flags
                     propertyFlags->copyPropertyTypeFlags(targetProperty->flags());
diff --git a/src/qml/qml/qqmlpropertyvalidator.cpp b/src/qml/qml/qqmlpropertyvalidator.cpp
index 238a535b89..8f6e2737cc 100644
--- a/src/qml/qml/qqmlpropertyvalidator.cpp
+++ b/src/qml/qml/qqmlpropertyvalidator.cpp
@@ -398,31 +398,31 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
     switch (property->propType()) {
     case QMetaType::QVariant:
     break;
-    case QVariant::String: {
+    case QMetaType::QString: {
         if (!binding->evaluatesToString()) {
             return warnOrError(tr("Invalid property assignment: string expected"));
         }
     }
     break;
-    case QVariant::StringList: {
+    case QMetaType::QStringList: {
         if (!binding->evaluatesToString()) {
             return warnOrError(tr("Invalid property assignment: string or string list expected"));
         }
     }
     break;
-    case QVariant::ByteArray: {
+    case QMetaType::QByteArray: {
         if (binding->type != QV4::CompiledData::Binding::Type_String) {
             return warnOrError(tr("Invalid property assignment: byte array expected"));
         }
     }
     break;
-    case QVariant::Url: {
+    case QMetaType::QUrl: {
         if (binding->type != QV4::CompiledData::Binding::Type_String) {
             return warnOrError(tr("Invalid property assignment: url expected"));
         }
     }
     break;
-    case QVariant::UInt: {
+    case QMetaType::UInt: {
         if (binding->type == QV4::CompiledData::Binding::Type_Number) {
             double d = compilationUnit->bindingValueAsNumber(binding);
             if (double(uint(d)) == d)
@@ -431,7 +431,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         return warnOrError(tr("Invalid property assignment: unsigned int expected"));
     }
     break;
-    case QVariant::Int: {
+    case QMetaType::Int: {
         if (binding->type == QV4::CompiledData::Binding::Type_Number) {
             double d = compilationUnit->bindingValueAsNumber(binding);
             if (double(int(d)) == d)
@@ -446,13 +446,13 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::Double: {
+    case QMetaType::Double: {
         if (binding->type != QV4::CompiledData::Binding::Type_Number) {
             return warnOrError(tr("Invalid property assignment: number expected"));
         }
     }
     break;
-    case QVariant::Color: {
+    case QMetaType::QColor: {
         bool ok = false;
         QQmlStringConverters::rgbaFromString(compilationUnit->bindingValueAsString(binding), &ok);
         if (!ok) {
@@ -461,7 +461,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
     }
     break;
 #if QT_CONFIG(datestring)
-    case QVariant::Date: {
+    case QMetaType::QDate: {
         bool ok = false;
         QQmlStringConverters::dateFromString(compilationUnit->bindingValueAsString(binding), &ok);
         if (!ok) {
@@ -469,7 +469,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::Time: {
+    case QMetaType::QTime: {
         bool ok = false;
         QQmlStringConverters::timeFromString(compilationUnit->bindingValueAsString(binding), &ok);
         if (!ok) {
@@ -477,7 +477,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::DateTime: {
+    case QMetaType::QDateTime: {
         bool ok = false;
         QQmlStringConverters::dateTimeFromString(compilationUnit->bindingValueAsString(binding), &ok);
         if (!ok) {
@@ -486,7 +486,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
     }
     break;
 #endif // datestring
-    case QVariant::Point: {
+    case QMetaType::QPoint: {
         bool ok = false;
         QQmlStringConverters::pointFFromString(compilationUnit->bindingValueAsString(binding), &ok);
         if (!ok) {
@@ -494,7 +494,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::PointF: {
+    case QMetaType::QPointF: {
         bool ok = false;
         QQmlStringConverters::pointFFromString(compilationUnit->bindingValueAsString(binding), &ok);
         if (!ok) {
@@ -502,7 +502,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::Size: {
+    case QMetaType::QSize: {
         bool ok = false;
         QQmlStringConverters::sizeFFromString(compilationUnit->bindingValueAsString(binding), &ok);
         if (!ok) {
@@ -510,7 +510,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::SizeF: {
+    case QMetaType::QSizeF: {
         bool ok = false;
         QQmlStringConverters::sizeFFromString(compilationUnit->bindingValueAsString(binding), &ok);
         if (!ok) {
@@ -518,7 +518,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::Rect: {
+    case QMetaType::QRect: {
         bool ok = false;
         QQmlStringConverters::rectFFromString(compilationUnit->bindingValueAsString(binding), &ok);
         if (!ok) {
@@ -526,7 +526,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::RectF: {
+    case QMetaType::QRectF: {
         bool ok = false;
         QQmlStringConverters::rectFFromString(compilationUnit->bindingValueAsString(binding), &ok);
         if (!ok) {
@@ -534,13 +534,13 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::Bool: {
+    case QMetaType::Bool: {
         if (binding->type != QV4::CompiledData::Binding::Type_Boolean) {
             return warnOrError(tr("Invalid property assignment: boolean expected"));
         }
     }
     break;
-    case QVariant::Vector2D: {
+    case QMetaType::QVector2D: {
         struct {
             float xp;
             float yp;
@@ -550,7 +550,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::Vector3D: {
+    case QMetaType::QVector3D: {
         struct {
             float xp;
             float yp;
@@ -561,7 +561,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::Vector4D: {
+    case QMetaType::QVector4D: {
         struct {
             float xp;
             float yp;
@@ -573,7 +573,7 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::Quaternion: {
+    case QMetaType::QQuaternion: {
         struct {
             float wp;
             float xp;
@@ -585,8 +585,8 @@ QQmlJS::DiagnosticMessage QQmlPropertyValidator::validateLiteralBinding(QQmlProp
         }
     }
     break;
-    case QVariant::RegExp:
-    case QVariant::RegularExpression:
+    case QMetaType::QRegExp:
+    case QMetaType::QRegularExpression:
         return warnOrError(tr("Invalid property assignment: regular expression expected; use /pattern/ syntax"));
     default: {
         // generate single literal value assignment to a list property if required
diff --git a/src/qml/qml/qqmltypeloader.cpp b/src/qml/qml/qqmltypeloader.cpp
index 2de158884b..e9a38945fa 100644
--- a/src/qml/qml/qqmltypeloader.cpp
+++ b/src/qml/qml/qqmltypeloader.cpp
@@ -357,8 +357,8 @@ void QQmlTypeLoader::networkReplyFinished(QNetworkReply *reply)
         }
     }
 
-    if (reply->error()) {
-        blob->networkError(reply->error());
+    if (reply->networkError()) {
+        blob->networkError(reply->networkError());
     } else {
         QByteArray data = reply->readAll();
         setData(blob, data);
diff --git a/src/qml/qml/qqmlvaluetype.cpp b/src/qml/qml/qqmlvaluetype.cpp
index d83fc4bb48..4beb6a4d07 100644
--- a/src/qml/qml/qqmlvaluetype.cpp
+++ b/src/qml/qml/qqmlvaluetype.cpp
@@ -48,6 +48,8 @@
 #endif
 #include <private/qmetatype_p.h>
 
+Q_DECLARE_METATYPE(QQmlProperty)
+
 QT_BEGIN_NAMESPACE
 
 namespace {
@@ -62,7 +64,7 @@ struct QQmlValueTypeFactoryImpl
     const QMetaObject *metaObjectForMetaType(int);
     QQmlValueType *valueType(int);
 
-    QQmlValueType *valueTypes[QVariant::UserType];
+    QQmlValueType *valueTypes[QMetaType::User];
     QHash<int, QQmlValueType *> userTypes;
     QMutex mutex;
 
@@ -71,7 +73,7 @@ struct QQmlValueTypeFactoryImpl
 
 QQmlValueTypeFactoryImpl::QQmlValueTypeFactoryImpl()
 {
-    std::fill_n(valueTypes, int(QVariant::UserType), &invalidValueType);
+    std::fill_n(valueTypes, int(QMetaType::User), &invalidValueType);
 
 #if QT_CONFIG(qml_itemmodel)
     // See types wrapped in qqmlmodelindexvaluetype_p.h
@@ -118,26 +120,26 @@ bool QQmlValueTypeFactoryImpl::isValueType(int idx)
 const QMetaObject *QQmlValueTypeFactoryImpl::metaObjectForMetaType(int t)
 {
     switch (t) {
-    case QVariant::Point:
+    case QMetaType::QPoint:
         return &QQmlPointValueType::staticMetaObject;
-    case QVariant::PointF:
+    case QMetaType::QPointF:
         return &QQmlPointFValueType::staticMetaObject;
-    case QVariant::Size:
+    case QMetaType::QSize:
         return &QQmlSizeValueType::staticMetaObject;
-    case QVariant::SizeF:
+    case QMetaType::QSizeF:
         return &QQmlSizeFValueType::staticMetaObject;
-    case QVariant::Rect:
+    case QMetaType::QRect:
         return &QQmlRectValueType::staticMetaObject;
-    case QVariant::RectF:
+    case QMetaType::QRectF:
         return &QQmlRectFValueType::staticMetaObject;
 #if QT_CONFIG(easingcurve)
-    case QVariant::EasingCurve:
+    case QMetaType::QEasingCurve:
         return &QQmlEasingValueType::staticMetaObject;
 #endif
 #if QT_CONFIG(qml_itemmodel)
-    case QVariant::ModelIndex:
+    case QMetaType::QModelIndex:
         return &QQmlModelIndexValueType::staticMetaObject;
-    case QVariant::PersistentModelIndex:
+    case QMetaType::QPersistentModelIndex:
         return &QQmlPersistentModelIndexValueType::staticMetaObject;
 #endif
     default:
@@ -145,7 +147,8 @@ const QMetaObject *QQmlValueTypeFactoryImpl::metaObjectForMetaType(int t)
         if (t == qMetaTypeId<QItemSelectionRange>())
             return &QQmlItemSelectionRangeValueType::staticMetaObject;
 #endif
-
+        if (t == qMetaTypeId<QQmlProperty>())
+            return &QQmlPropertyValueType::staticMetaObject;
         if (const QMetaObject *mo = QQml_valueTypeProvider()->metaObjectForMetaType(t))
             return mo;
         break;
@@ -159,7 +162,7 @@ const QMetaObject *QQmlValueTypeFactoryImpl::metaObjectForMetaType(int t)
 
 QQmlValueType *QQmlValueTypeFactoryImpl::valueType(int idx)
 {
-    if (idx >= (int)QVariant::UserType) {
+    if (idx >= (int)QMetaType::User) {
         // Protect the hash with a mutex
         mutex.lock();
 
@@ -585,6 +588,16 @@ void QQmlEasingValueType::setBezierCurve(const QVariantList &customCurveVariant)
     v = newEasingCurve;
 }
 
+QObject *QQmlPropertyValueType::object() const
+{
+    return v.object();
+}
+
+QString QQmlPropertyValueType::name() const
+{
+    return v.name();
+}
+
 QVariantList QQmlEasingValueType::bezierCurve() const
 {
     QVariantList rv;
diff --git a/src/qml/qml/qqmlvaluetype_p.h b/src/qml/qml/qqmlvaluetype_p.h
index 0601237c4b..ff664adbe7 100644
--- a/src/qml/qml/qqmlvaluetype_p.h
+++ b/src/qml/qml/qqmlvaluetype_p.h
@@ -268,6 +268,17 @@ public:
 };
 #endif
 
+struct QQmlPropertyValueType
+{
+    QQmlProperty v;
+    Q_PROPERTY(QObject *object READ object CONSTANT FINAL)
+    Q_PROPERTY(QString name READ name CONSTANT FINAL)
+    Q_GADGET
+public:
+    QObject *object() const;
+    QString name() const;
+};
+
 template<typename T>
 int qmlRegisterValueTypeEnums(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
 {
diff --git a/src/qml/qml/qqmlvaluetypewrapper.cpp b/src/qml/qml/qqmlvaluetypewrapper.cpp
index f23921497c..ba5ba96cbe 100644
--- a/src/qml/qml/qqmlvaluetypewrapper.cpp
+++ b/src/qml/qml/qqmlvaluetypewrapper.cpp
@@ -601,7 +601,7 @@ bool QQmlValueTypeWrapper::virtualPut(Managed *m, PropertyKey id, const Value &v
 
     QVariant v = v4->toVariant(value, property.userType());
 
-    if (property.isEnumType() && (QMetaType::Type)v.type() == QMetaType::Double)
+    if (property.isEnumType() && (QMetaType::Type)v.userType() == QMetaType::Double)
         v = v.toInt();
 
     void *gadget = r->d()->gadgetPtr();
diff --git a/src/qml/qml/qqmlvmemetaobject.cpp b/src/qml/qml/qqmlvmemetaobject.cpp
index 42a90e234c..ecb86e2f10 100644
--- a/src/qml/qml/qqmlvmemetaobject.cpp
+++ b/src/qml/qml/qqmlvmemetaobject.cpp
@@ -291,7 +291,7 @@ bool QQmlInterceptorMetaObject::intercept(QMetaObject::Call c, int id, void **a)
             const int valueIndex = vi->m_propertyIndex.valueTypeIndex();
             int type = QQmlData::get(object)->propertyCache->property(id)->propType();
 
-            if (type != QVariant::Invalid) {
+            if (type != QMetaType::UnknownType) {
                 if (valueIndex != -1) {
                     QQmlValueType *valueType = QQmlValueTypeFactory::valueType(type);
                     Q_ASSERT(valueType);
@@ -534,7 +534,7 @@ QUrl QQmlVMEMetaObject::readPropertyAsUrl(int id) const
     QV4::Scope scope(engine);
     QV4::ScopedValue sv(scope, *(md->data() + id));
     const QV4::VariantObject *v = sv->as<QV4::VariantObject>();
-    if (!v || v->d()->data().type() != QVariant::Url)
+    if (!v || v->d()->data().userType() != QMetaType::QUrl)
         return QUrl();
     return v->d()->data().value<QUrl>();
 }
@@ -548,7 +548,7 @@ QDate QQmlVMEMetaObject::readPropertyAsDate(int id) const
     QV4::Scope scope(engine);
     QV4::ScopedValue sv(scope, *(md->data() + id));
     const QV4::VariantObject *v = sv->as<QV4::VariantObject>();
-    if (!v || v->d()->data().type() != QVariant::Date)
+    if (!v || v->d()->data().userType() != QMetaType::QDate)
         return QDate();
     return v->d()->data().value<QDate>();
 }
@@ -562,7 +562,7 @@ QDateTime QQmlVMEMetaObject::readPropertyAsDateTime(int id)
     QV4::Scope scope(engine);
     QV4::ScopedValue sv(scope, *(md->data() + id));
     const QV4::VariantObject *v = sv->as<QV4::VariantObject>();
-    if (!v || v->d()->data().type() != QVariant::DateTime)
+    if (!v || v->d()->data().userType() != QMetaType::QDateTime)
         return QDateTime();
     return v->d()->data().value<QDateTime>();
 }
@@ -576,7 +576,7 @@ QSizeF QQmlVMEMetaObject::readPropertyAsSizeF(int id) const
     QV4::Scope scope(engine);
     QV4::ScopedValue sv(scope, *(md->data() + id));
     const QV4::VariantObject *v = sv->as<QV4::VariantObject>();
-    if (!v || v->d()->data().type() != QVariant::SizeF)
+    if (!v || v->d()->data().userType() != QMetaType::QSizeF)
         return QSizeF();
     return v->d()->data().value<QSizeF>();
 }
@@ -590,7 +590,7 @@ QPointF QQmlVMEMetaObject::readPropertyAsPointF(int id) const
     QV4::Scope scope(engine);
     QV4::ScopedValue sv(scope, *(md->data() + id));
     const QV4::VariantObject *v = sv->as<QV4::VariantObject>();
-    if (!v || v->d()->data().type() != QVariant::PointF)
+    if (!v || v->d()->data().userType() != QMetaType::QPointF)
         return QPointF();
     return v->d()->data().value<QPointF>();
 }
@@ -634,7 +634,7 @@ QRectF QQmlVMEMetaObject::readPropertyAsRectF(int id) const
     QV4::Scope scope(engine);
     QV4::ScopedValue sv(scope, *(md->data() + id));
     const QV4::VariantObject *v = sv->as<QV4::VariantObject>();
-    if (!v || v->d()->data().type() != QVariant::RectF)
+    if (!v || v->d()->data().userType() != QMetaType::QRectF)
         return QRectF();
     return v->d()->data().value<QRectF>();
 }
diff --git a/src/qml/qml/qqmlxmlhttprequest.cpp b/src/qml/qml/qqmlxmlhttprequest.cpp
index 2afbdb616b..c820499703 100644
--- a/src/qml/qml/qqmlxmlhttprequest.cpp
+++ b/src/qml/qml/qqmlxmlhttprequest.cpp
@@ -1291,7 +1291,7 @@ void QQmlXMLHttpRequest::requestFromUrl(const QUrl &url)
         if (m_network->bytesAvailable() > 0)
             readyRead();
 
-        QNetworkReply::NetworkError networkError = m_network->error();
+        QNetworkReply::NetworkError networkError = m_network->networkError();
         if (networkError != QNetworkReply::NoError) {
             error(networkError);
         } else {
diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
index 2c1956553f..2d3c03cedb 100644
--- a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
+++ b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
@@ -340,22 +340,22 @@ ReturnedValue QtObject::method_colorEqual(const FunctionObject *b, const Value *
     bool ok = false;
 
     QVariant lhs = scope.engine->toVariant(argv[0], -1);
-    if (lhs.userType() == QVariant::String) {
+    if (lhs.userType() == QMetaType::QString) {
         lhs = QQmlStringConverters::colorFromString(lhs.toString(), &ok);
         if (!ok) {
             THROW_GENERIC_ERROR("Qt.colorEqual(): Invalid color name");
         }
-    } else if (lhs.userType() != QVariant::Color) {
+    } else if (lhs.userType() != QMetaType::QColor) {
         THROW_GENERIC_ERROR("Qt.colorEqual(): Invalid arguments");
     }
 
     QVariant rhs = scope.engine->toVariant(argv[1], -1);
-    if (rhs.userType() == QVariant::String) {
+    if (rhs.userType() == QMetaType::QString) {
         rhs = QQmlStringConverters::colorFromString(rhs.toString(), &ok);
         if (!ok) {
             THROW_GENERIC_ERROR("Qt.colorEqual(): Invalid color name");
         }
-    } else if (rhs.userType() != QVariant::Color) {
+    } else if (rhs.userType() != QMetaType::QColor) {
         THROW_GENERIC_ERROR("Qt.colorEqual(): Invalid arguments");
     }
 
@@ -606,13 +606,13 @@ ReturnedValue QtObject::method_lighter(const FunctionObject *b, const Value *, c
         THROW_GENERIC_ERROR("Qt.lighter(): Invalid arguments");
 
     QVariant v = scope.engine->toVariant(argv[0], -1);
-    if (v.userType() == QVariant::String) {
+    if (v.userType() == QMetaType::QString) {
         bool ok = false;
         v = QQmlStringConverters::colorFromString(v.toString(), &ok);
         if (!ok) {
             return QV4::Encode::null();
         }
-    } else if (v.userType() != QVariant::Color) {
+    } else if (v.userType() != QMetaType::QColor) {
         return QV4::Encode::null();
     }
 
@@ -646,13 +646,13 @@ ReturnedValue QtObject::method_darker(const FunctionObject *b, const Value *, co
         THROW_GENERIC_ERROR("Qt.darker(): Invalid arguments");
 
     QVariant v = scope.engine->toVariant(argv[0], -1);
-    if (v.userType() == QVariant::String) {
+    if (v.userType() == QMetaType::QString) {
         bool ok = false;
         v = QQmlStringConverters::colorFromString(v.toString(), &ok);
         if (!ok) {
             return QV4::Encode::null();
         }
-    } else if (v.userType() != QVariant::Color) {
+    } else if (v.userType() != QMetaType::QColor) {
         return QV4::Encode::null();
     }
 
@@ -697,25 +697,25 @@ ReturnedValue QtObject::method_tint(const FunctionObject *b, const Value *, cons
 
     // base color
     QVariant v1 = scope.engine->toVariant(argv[0], -1);
-    if (v1.userType() == QVariant::String) {
+    if (v1.userType() == QMetaType::QString) {
         bool ok = false;
         v1 = QQmlStringConverters::colorFromString(v1.toString(), &ok);
         if (!ok) {
             return QV4::Encode::null();
         }
-    } else if (v1.userType() != QVariant::Color) {
+    } else if (v1.userType() != QMetaType::QColor) {
         return QV4::Encode::null();
     }
 
     // tint color
     QVariant v2 = scope.engine->toVariant(argv[1], -1);
-    if (v2.userType() == QVariant::String) {
+    if (v2.userType() == QMetaType::QString) {
         bool ok = false;
         v2 = QQmlStringConverters::colorFromString(v2.toString(), &ok);
         if (!ok) {
             return QV4::Encode::null();
         }
-    } else if (v2.userType() != QVariant::Color) {
+    } else if (v2.userType() != QMetaType::QColor) {
         return QV4::Encode::null();
     }
 
@@ -789,7 +789,7 @@ ReturnedValue QtObject::method_formatTime(const FunctionObject *b, const Value *
 
     QVariant argVariant = scope.engine->toVariant(argv[0], -1);
     QTime time;
-    if (argv[0].as<DateObject>() || (argVariant.type() == QVariant::String))
+    if (argv[0].as<DateObject>() || (argVariant.userType() == QMetaType::QString))
         time = argVariant.toDateTime().time();
     else // if (argVariant.type() == QVariant::Time), or invalid.
         time = argVariant.toTime();
diff --git a/src/qmlmodels/qqmladaptormodel.cpp b/src/qmlmodels/qqmladaptormodel.cpp
index cf0d8fbb2f..fbb85327a7 100644
--- a/src/qmlmodels/qqmladaptormodel.cpp
+++ b/src/qmlmodels/qqmladaptormodel.cpp
@@ -367,10 +367,10 @@ QV4::ReturnedValue QQmlDMCachedModelData::set_property(const QV4::FunctionObject
         QQmlDMCachedModelData *modelData = static_cast<QQmlDMCachedModelData *>(o->d()->item);
         if (!modelData->cachedData.isEmpty()) {
             if (modelData->cachedData.count() > 1) {
-                modelData->cachedData[propertyId] = scope.engine->toVariant(argv[0], QVariant::Invalid);
+                modelData->cachedData[propertyId] = scope.engine->toVariant(argv[0], QMetaType::UnknownType);
                 QMetaObject::activate(o->d()->item, o->d()->item->metaObject(), propertyId, nullptr);
             } else if (modelData->cachedData.count() == 1) {
-                modelData->cachedData[0] = scope.engine->toVariant(argv[0], QVariant::Invalid);
+                modelData->cachedData[0] = scope.engine->toVariant(argv[0], QMetaType::UnknownType);
                 QMetaObject::activate(o->d()->item, o->d()->item->metaObject(), 0, nullptr);
                 QMetaObject::activate(o->d()->item, o->d()->item->metaObject(), 1, nullptr);
             }
@@ -601,7 +601,7 @@ public:
         if (!argc)
             return v4->throwTypeError();
 
-        static_cast<QQmlDMListAccessorData *>(o->d()->item)->setModelData(v4->toVariant(argv[0], QVariant::Invalid));
+        static_cast<QQmlDMListAccessorData *>(o->d()->item)->setModelData(v4->toVariant(argv[0], QMetaType::UnknownType));
         return QV4::Encode::undefined();
     }
 
diff --git a/src/qmlmodels/qqmldelegatemodel.cpp b/src/qmlmodels/qqmldelegatemodel.cpp
index 7ad53eeb6c..3a3903965c 100644
--- a/src/qmlmodels/qqmldelegatemodel.cpp
+++ b/src/qmlmodels/qqmldelegatemodel.cpp
@@ -2011,7 +2011,7 @@ bool QQmlDelegateModelPrivate::insert(Compositor::insert_iterator &before, const
         propertyName = it.nextPropertyNameAsString(v);
         if (propertyName->isNull())
             break;
-        cacheItem->setValue(propertyName->toQStringNoThrow(), scope.engine->toVariant(v, QVariant::Invalid));
+        cacheItem->setValue(propertyName->toQStringNoThrow(), scope.engine->toVariant(v, QMetaType::UnknownType));
     }
 
     cacheItem->groups = groups | Compositor::UnresolvedFlag | Compositor::CacheFlag;
diff --git a/src/qmlmodels/qqmllistaccessor.cpp b/src/qmlmodels/qqmllistaccessor.cpp
index 46a11e2bc2..c450c616e7 100644
--- a/src/qmlmodels/qqmllistaccessor.cpp
+++ b/src/qmlmodels/qqmllistaccessor.cpp
@@ -76,11 +76,11 @@ void QQmlListAccessor::setList(const QVariant &v, QQmlEngine *engine)
 
     if (!d.isValid()) {
         m_type = Invalid;
-    } else if (d.userType() == QVariant::StringList) {
+    } else if (d.userType() == QMetaType::QStringList) {
         m_type = StringList;
     } else if (d.userType() == QMetaType::QVariantList) {
         m_type = VariantList;
-    } else if (d.canConvert(QVariant::Int)) {
+    } else if (d.canConvert(QMetaType::Int)) {
         // Here we have to check for an upper limit, because down the line code might (well, will)
         // allocate memory depending on the number of elements. The upper limit cannot be INT_MAX:
         //      QVector<QPointer<QQuickItem>> something;
diff --git a/src/qmlmodels/qqmllistmodel.cpp b/src/qmlmodels/qqmllistmodel.cpp
index 1bbe9360bb..2c05b04429 100644
--- a/src/qmlmodels/qqmllistmodel.cpp
+++ b/src/qmlmodels/qqmllistmodel.cpp
@@ -219,14 +219,14 @@ const ListLayout::Role *ListLayout::getRoleOrCreate(const QString &key, const QV
 {
     Role::DataType type;
 
-    switch (data.type()) {
-        case QVariant::Double:      type = Role::Number;      break;
-        case QVariant::Int:         type = Role::Number;      break;
-        case QVariant::Bool:        type = Role::Bool;        break;
-        case QVariant::String:      type = Role::String;      break;
-        case QVariant::Map:         type = Role::VariantMap;  break;
-        case QVariant::DateTime:    type = Role::DateTime;    break;
-        case QVariant::UserType:    {
+    switch (data.userType()) {
+        case QMetaType::Double:      type = Role::Number;      break;
+        case QMetaType::Int:         type = Role::Number;      break;
+        case QMetaType::Bool:        type = Role::Bool;        break;
+        case QMetaType::QString:      type = Role::String;      break;
+        case QMetaType::QVariantMap:         type = Role::VariantMap;  break;
+        case QMetaType::QDateTime:    type = Role::DateTime;    break;
+        default:    {
             if (data.userType() == qMetaTypeId<QJSValue>() &&
                 data.value<QJSValue>().isCallable()) {
                 type = Role::Function;
@@ -235,12 +235,14 @@ const ListLayout::Role *ListLayout::getRoleOrCreate(const QString &key, const QV
                        && data.value<const QV4::CompiledData::Binding*>()->isTranslationBinding()) {
                 type = Role::String;
                 break;
-            } else {
+            } else if (data.userType() >= QMetaType::User) {
                 type = Role::List;
                 break;
+            } else {
+                type = Role::Invalid;
+                break;
             }
         }
-        default:                    type = Role::Invalid;     break;
     }
 
     if (type == Role::Invalid) {
@@ -1722,7 +1724,7 @@ void DynamicRoleModelNode::updateValues(const QVariantMap &object, QVector<int>
         if (value.userType() == qMetaTypeId<QJSValue>())
             value = value.value<QJSValue>().toVariant();
 
-        if (value.type() == QVariant::List) {
+        if (value.userType() == QMetaType::QVariantList) {
             QQmlListModel *subModel = QQmlListModel::createWithOwner(m_owner);
 
             QVariantList subArray = value.toList();
@@ -1785,7 +1787,7 @@ void DynamicRoleModelNodeMetaObject::propertyWritten(int index)
     if (v.userType() == qMetaTypeId<QJSValue>())
         v= v.value<QJSValue>().toVariant();
 
-    if (v.type() == QVariant::List) {
+    if (v.userType() == QMetaType::QVariantList) {
         QQmlListModel *subModel = QQmlListModel::createWithOwner(parentModel);
 
         QVariantList subArray = v.toList();
diff --git a/src/qmltest/quicktestresult.cpp b/src/qmltest/quicktestresult.cpp
index 49552e1901..d5ab267cec 100644
--- a/src/qmltest/quicktestresult.cpp
+++ b/src/qmltest/quicktestresult.cpp
@@ -500,8 +500,8 @@ bool QuickTestResult::verify
 
 bool QuickTestResult::fuzzyCompare(const QVariant &actual, const QVariant &expected, qreal delta)
 {
-    if (actual.type() == QVariant::Color || expected.type() == QVariant::Color) {
-        if (!actual.canConvert(QVariant::Color) || !expected.canConvert(QVariant::Color))
+    if (actual.userType() == QMetaType::QColor || expected.userType() == QMetaType::QColor) {
+        if (!actual.canConvert(QMetaType::QColor) || !expected.canConvert(QMetaType::QColor))
             return false;
 
         //fuzzy color comparison
@@ -556,20 +556,20 @@ void QuickTestResult::stringify(QQmlV4Function *args)
         && !value->as<QV4::ArrayObject>()) {
         QVariant v = scope.engine->toVariant(value, QMetaType::UnknownType);
         if (v.isValid()) {
-            switch (v.type()) {
-            case QVariant::Vector3D:
+            switch (v.userType()) {
+            case QMetaType::QVector3D:
             {
                 QVector3D v3d = v.value<QVector3D>();
                 result = QString::fromLatin1("Qt.vector3d(%1, %2, %3)").arg(v3d.x()).arg(v3d.y()).arg(v3d.z());
                 break;
             }
-            case QVariant::Url:
+            case QMetaType::QUrl:
             {
                 QUrl url = v.value<QUrl>();
                 result = QString::fromLatin1("Qt.url(%1)").arg(url.toString());
                 break;
             }
-            case QVariant::DateTime:
+            case QMetaType::QDateTime:
             {
                 QDateTime dt = v.value<QDateTime>();
                 result = dt.toString(Qt::ISODateWithMs);
diff --git a/src/quick/designer/qqmldesignermetaobject.cpp b/src/quick/designer/qqmldesignermetaobject.cpp
index de7da7f9be..0aa5dc2613 100644
--- a/src/quick/designer/qqmldesignermetaobject.cpp
+++ b/src/quick/designer/qqmldesignermetaobject.cpp
@@ -240,7 +240,7 @@ int QQmlDesignerMetaObject::metaCall(QObject *o, QMetaObject::Call call, int id,
 
     if (call == QMetaObject::WriteProperty
             && propertyById.userType() == QMetaType::QVariant
-            && reinterpret_cast<QVariant *>(a[0])->type() == QVariant::Double
+            && reinterpret_cast<QVariant *>(a[0])->userType() == QMetaType::Double
             && qt_is_nan(reinterpret_cast<QVariant *>(a[0])->toDouble())) {
         return -1;
     }
diff --git a/src/quick/designer/qquickdesignercustomobjectdata.cpp b/src/quick/designer/qquickdesignercustomobjectdata.cpp
index 6b39f5157b..66a86bffd5 100644
--- a/src/quick/designer/qquickdesignercustomobjectdata.cpp
+++ b/src/quick/designer/qquickdesignercustomobjectdata.cpp
@@ -278,7 +278,7 @@ void QQuickDesignerCustomObjectData::setPropertyBinding(QQmlContext *context,
         //Refcounting is taking take care of deletion
         binding->update();
         if (binding->hasError()) {
-            if (property.property().userType() == QVariant::String)
+            if (property.property().userType() == QMetaType::QString)
                 property.write(QVariant(QLatin1Char('#') + expression + QLatin1Char('#')));
         }
 
diff --git a/src/quick/items/qquickborderimage.cpp b/src/quick/items/qquickborderimage.cpp
index 462a44634e..edd3805d7c 100644
--- a/src/quick/items/qquickborderimage.cpp
+++ b/src/quick/items/qquickborderimage.cpp
@@ -560,7 +560,7 @@ void QQuickBorderImage::sciRequestFinished()
     }
     d->redirectCount=0;
 
-    if (d->sciReply->error() != QNetworkReply::NoError) {
+    if (d->sciReply->networkError() != QNetworkReply::NoError) {
         d->status = Error;
         d->sciReply->deleteLater();
         d->sciReply = nullptr;
diff --git a/src/quick/items/qquickitem.cpp b/src/quick/items/qquickitem.cpp
index 8454010ee9..b5932c6f80 100644
--- a/src/quick/items/qquickitem.cpp
+++ b/src/quick/items/qquickitem.cpp
@@ -1478,7 +1478,7 @@ QVariant QQuickKeysAttached::inputMethodQuery(Qt::InputMethodQuery query) const
             if (i && i->isVisible() && (i->flags() & QQuickItem::ItemAcceptsInputMethod) && i == d->imeItem) {
                 //### how robust is i == d->imeItem check?
                 QVariant v = i->inputMethodQuery(query);
-                if (v.userType() == QVariant::RectF)
+                if (v.userType() == QMetaType::QRectF)
                     v = d->item->mapRectFromItem(i, v.toRectF());  //### cost?
                 return v;
             }
diff --git a/src/quick/items/qquickitem_p.h b/src/quick/items/qquickitem_p.h
index baef37a0ff..3c0517cb3b 100644
--- a/src/quick/items/qquickitem_p.h
+++ b/src/quick/items/qquickitem_p.h
@@ -867,7 +867,7 @@ public:
 
     QQmlListProperty<QQuickItem> forwardTo() {
         Q_D(QQuickKeysAttached);
-        return QQmlListProperty<QQuickItem>(this, d->targets);
+        return QQmlListProperty<QQuickItem>(this, &(d->targets));
     }
 
     void componentComplete() override;
diff --git a/src/quick/items/qquickitemanimation.cpp b/src/quick/items/qquickitemanimation.cpp
index 8251282736..23694e2de3 100644
--- a/src/quick/items/qquickitemanimation.cpp
+++ b/src/quick/items/qquickitemanimation.cpp
@@ -456,7 +456,7 @@ QQuickAnchorAnimation::~QQuickAnchorAnimation()
 QQmlListProperty<QQuickItem> QQuickAnchorAnimation::targets()
 {
     Q_D(QQuickAnchorAnimation);
-    return QQmlListProperty<QQuickItem>(this, d->targets);
+    return QQmlListProperty<QQuickItem>(this, &(d->targets));
 }
 
 /*!
diff --git a/src/quick/items/qquickitemviewtransition.cpp b/src/quick/items/qquickitemviewtransition.cpp
index 109851608b..b7649c9952 100644
--- a/src/quick/items/qquickitemviewtransition.cpp
+++ b/src/quick/items/qquickitemviewtransition.cpp
@@ -925,7 +925,7 @@ QQuickViewTransitionAttached::QQuickViewTransitionAttached(QObject *parent)
 */
 QQmlListProperty<QObject> QQuickViewTransitionAttached::targetItems()
 {
-    return QQmlListProperty<QObject>(this, m_targetItems);
+    return QQmlListProperty<QObject>(this, &m_targetItems);
 }
 
 QQuickViewTransitionAttached *QQuickViewTransitionAttached::qmlAttachedProperties(QObject *obj)
diff --git a/src/quick/items/qquickmultipointtoucharea_p.h b/src/quick/items/qquickmultipointtoucharea_p.h
index 42b42a45c5..363e62593b 100644
--- a/src/quick/items/qquickmultipointtoucharea_p.h
+++ b/src/quick/items/qquickmultipointtoucharea_p.h
@@ -198,7 +198,7 @@ public:
     bool wantsGrab() const { return _grab; }
 
     QQmlListProperty<QObject> touchPoints() {
-        return QQmlListProperty<QObject>(this, _touchPoints);
+        return QQmlListProperty<QObject>(this, &_touchPoints);
     }
     qreal dragThreshold() const { return _dragThreshold; }
 
diff --git a/src/quick/items/qquickopenglshadereffectnode.cpp b/src/quick/items/qquickopenglshadereffectnode.cpp
index 26ef59c20e..5721f116e8 100644
--- a/src/quick/items/qquickopenglshadereffectnode.cpp
+++ b/src/quick/items/qquickopenglshadereffectnode.cpp
@@ -178,7 +178,7 @@ void QQuickCustomMaterialShader::updateState(const RenderState &state, QSGMateri
                 if (state.isMatrixDirty())
                     program()->setUniformValue(loc, state.combinedMatrix());
             } else if (d.specialType == UniformData::None) {
-                switch (int(d.value.type())) {
+                switch (int(d.value.userType())) {
                 case QMetaType::QColor:
                     program()->setUniformValue(loc, qt_premultiply_color(qvariant_cast<QColor>(d.value)));
                     break;
diff --git a/src/quick/items/qquickrectangle.cpp b/src/quick/items/qquickrectangle.cpp
index f3cefc7463..c1f2b77f5b 100644
--- a/src/quick/items/qquickrectangle.cpp
+++ b/src/quick/items/qquickrectangle.cpp
@@ -257,7 +257,7 @@ QQuickGradient::~QQuickGradient()
 
 QQmlListProperty<QQuickGradientStop> QQuickGradient::stops()
 {
-    return QQmlListProperty<QQuickGradientStop>(this, m_stops);
+    return QQmlListProperty<QQuickGradientStop>(this, &m_stops);
 }
 
 /*!
diff --git a/src/quick/items/qquickspriteengine_p.h b/src/quick/items/qquickspriteengine_p.h
index da505be911..d76055c831 100644
--- a/src/quick/items/qquickspriteengine_p.h
+++ b/src/quick/items/qquickspriteengine_p.h
@@ -196,7 +196,7 @@ public:
 
     QQmlListProperty<QQuickStochasticState> states()
     {
-        return QQmlListProperty<QQuickStochasticState>(this, m_states);
+        return QQmlListProperty<QQuickStochasticState>(this, &m_states);
     }
 
     QString globalGoal() const
@@ -272,7 +272,7 @@ public:
     ~QQuickSpriteEngine() override;
     QQmlListProperty<QQuickSprite> sprites()
     {
-        return QQmlListProperty<QQuickSprite>(this, m_sprites);
+        return QQmlListProperty<QQuickSprite>(this, &m_sprites);
     }
 
     QQuickSprite* sprite(int sprite = 0) const;
diff --git a/src/quick/items/qquicktextcontrol.cpp b/src/quick/items/qquicktextcontrol.cpp
index 3c392be751..4c741f67e3 100644
--- a/src/quick/items/qquicktextcontrol.cpp
+++ b/src/quick/items/qquicktextcontrol.cpp
@@ -60,6 +60,7 @@
 #include <QtCore/qloggingcategory.h>
 
 #include <qtextformat.h>
+#include <qtransform.h>
 #include <qdatetime.h>
 #include <qbuffer.h>
 #include <qguiapplication.h>
@@ -718,12 +719,12 @@ void QQuickTextControl::selectAll()
 
 void QQuickTextControl::processEvent(QEvent *e, const QPointF &coordinateOffset)
 {
-    QMatrix m;
-    m.translate(coordinateOffset.x(), coordinateOffset.y());
-    processEvent(e, m);
+    QTransform t;
+    t.translate(coordinateOffset.x(), coordinateOffset.y());
+    processEvent(e, t);
 }
 
-void QQuickTextControl::processEvent(QEvent *e, const QMatrix &matrix)
+void QQuickTextControl::processEvent(QEvent *e, const QTransform &transform)
 {
     Q_D(QQuickTextControl);
     if (d->interactionFlags == Qt::NoTextInteraction) {
@@ -740,25 +741,25 @@ void QQuickTextControl::processEvent(QEvent *e, const QMatrix &matrix)
             break;
         case QEvent::MouseButtonPress: {
             QMouseEvent *ev = static_cast<QMouseEvent *>(e);
-            d->mousePressEvent(ev, matrix.map(ev->localPos()));
+            d->mousePressEvent(ev, transform.map(ev->localPos()));
             break; }
         case QEvent::MouseMove: {
             QMouseEvent *ev = static_cast<QMouseEvent *>(e);
-            d->mouseMoveEvent(ev, matrix.map(ev->localPos()));
+            d->mouseMoveEvent(ev, transform.map(ev->localPos()));
             break; }
         case QEvent::MouseButtonRelease: {
             QMouseEvent *ev = static_cast<QMouseEvent *>(e);
-            d->mouseReleaseEvent(ev, matrix.map(ev->localPos()));
+            d->mouseReleaseEvent(ev, transform.map(ev->localPos()));
             break; }
         case QEvent::MouseButtonDblClick: {
             QMouseEvent *ev = static_cast<QMouseEvent *>(e);
-            d->mouseDoubleClickEvent(ev, matrix.map(ev->localPos()));
+            d->mouseDoubleClickEvent(ev, transform.map(ev->localPos()));
             break; }
         case QEvent::HoverEnter:
         case QEvent::HoverMove:
         case QEvent::HoverLeave: {
             QHoverEvent *ev = static_cast<QHoverEvent *>(e);
-            d->hoverEvent(ev, matrix.map(ev->posF()));
+            d->hoverEvent(ev, transform.map(ev->posF()));
             break; }
 #if QT_CONFIG(im)
         case QEvent::InputMethod:
diff --git a/src/quick/items/qquicktextcontrol_p.h b/src/quick/items/qquicktextcontrol_p.h
index 41b8ed7821..eb5cd27994 100644
--- a/src/quick/items/qquicktextcontrol_p.h
+++ b/src/quick/items/qquicktextcontrol_p.h
@@ -71,6 +71,7 @@ class QQuickTextControlPrivate;
 class QAbstractScrollArea;
 class QEvent;
 class QTimerEvent;
+class QTransform;
 
 class Q_AUTOTEST_EXPORT QQuickTextControl : public QInputControl
 {
@@ -169,7 +170,7 @@ Q_SIGNALS:
     void markerHovered(bool marker);
 
 public:
-    virtual void processEvent(QEvent *e, const QMatrix &matrix);
+    virtual void processEvent(QEvent *e, const QTransform &transform);
     void processEvent(QEvent *e, const QPointF &coordinateOffset = QPointF());
 
 #if QT_CONFIG(im)
diff --git a/src/quick/items/qquicktextnodeengine.cpp b/src/quick/items/qquicktextnodeengine.cpp
index a0ae4e5f97..2356ab36ef 100644
--- a/src/quick/items/qquicktextnodeengine.cpp
+++ b/src/quick/items/qquicktextnodeengine.cpp
@@ -532,7 +532,7 @@ void QQuickTextNodeEngine::addGlyphsForRanges(const QVarLengthArray<QTextLayout:
     int remainingLength = end - start;
     for (int j=0; j<ranges.size(); ++j) {
         const QTextLayout::FormatRange &range = ranges.at(j);
-        if (range.start + range.length >= currentPosition
+        if (range.start + range.length > currentPosition
                 && range.start < currentPosition + remainingLength) {
 
             if (range.start > currentPosition) {
diff --git a/src/quick/scenegraph/qsgrhishadereffectnode.cpp b/src/quick/scenegraph/qsgrhishadereffectnode.cpp
index 6f6544548c..e86dae7c09 100644
--- a/src/quick/scenegraph/qsgrhishadereffectnode.cpp
+++ b/src/quick/scenegraph/qsgrhishadereffectnode.cpp
@@ -136,7 +136,7 @@ void QSGRhiShaderLinker::linkTextureSubRects()
     // texture binding point.
     for (Constant &c : m_constants) {
         if (c.specialType == QSGShaderEffectNode::VariableData::SubRect) {
-            if (c.value.type() == QVariant::ByteArray) {
+            if (c.value.userType() == QMetaType::QByteArray) {
                 const QByteArray name = c.value.toByteArray();
                 if (!m_samplerNameMap.contains(name))
                     qWarning("ShaderEffect: qt_SubRect_%s refers to unknown source texture", name.constData());
@@ -270,7 +270,7 @@ bool QSGRhiShaderEffectMaterialShader::updateUniformData(RenderState &state, QSG
             memcpy(dst, f, sizeof(f));
         } else if (c.specialType == QSGShaderEffectNode::VariableData::None) {
             changed = true;
-            switch (int(c.value.type())) {
+            switch (int(c.value.userType())) {
             case QMetaType::QColor: {
                 const QColor v = qsg_premultiply_color(qvariant_cast<QColor>(c.value));
                 const float f[4] = { float(v.redF()), float(v.greenF()), float(v.blueF()), float(v.alphaF()) };
diff --git a/src/quick/util/qquickanimation.cpp b/src/quick/util/qquickanimation.cpp
index 5e9722e6b4..763b0aa171 100644
--- a/src/quick/util/qquickanimation.cpp
+++ b/src/quick/util/qquickanimation.cpp
@@ -490,7 +490,7 @@ QQuickAnimationGroup *QQuickAbstractAnimation::group() const
     return d->group;
 }
 
-void QQuickAbstractAnimation::setGroup(QQuickAnimationGroup *g)
+void QQuickAbstractAnimation::setGroup(QQuickAnimationGroup *g, int index)
 {
     Q_D(QQuickAbstractAnimation);
     if (d->group == g)
@@ -500,8 +500,12 @@ void QQuickAbstractAnimation::setGroup(QQuickAnimationGroup *g)
 
     d->group = g;
 
-    if (d->group && !d->group->d_func()->animations.contains(this))
-        d->group->d_func()->animations.append(this);
+    if (d->group && !d->group->d_func()->animations.contains(this)) {
+        if (index >= 0)
+            d->group->d_func()->animations.insert(index, this);
+        else
+            d->group->d_func()->animations.append(this);
+    }
 }
 
 /*!
@@ -1170,7 +1174,7 @@ void QQuickPropertyAction::setProperties(const QString &p)
 QQmlListProperty<QObject> QQuickPropertyAction::targets()
 {
     Q_D(QQuickPropertyAction);
-    return QQmlListProperty<QObject>(this, d->targets);
+    return QQmlListProperty<QObject>(this, &(d->targets));
 }
 
 /*!
@@ -1182,7 +1186,7 @@ QQmlListProperty<QObject> QQuickPropertyAction::targets()
 QQmlListProperty<QObject> QQuickPropertyAction::exclude()
 {
     Q_D(QQuickPropertyAction);
-    return QQmlListProperty<QObject>(this, d->exclude);
+    return QQmlListProperty<QObject>(this, &(d->exclude));
 }
 
 /*!
@@ -1722,6 +1726,20 @@ void QQuickAnimationGroupPrivate::append_animation(QQmlListProperty<QQuickAbstra
         a->setGroup(q);
 }
 
+QQuickAbstractAnimation *QQuickAnimationGroupPrivate::at_animation(QQmlListProperty<QQuickAbstractAnimation> *list, int index)
+{
+    if (auto q = qmlobject_cast<QQuickAnimationGroup *>(list->object))
+        return q->d_func()->animations.at(index);
+    return nullptr;
+}
+
+int QQuickAnimationGroupPrivate::count_animation(QQmlListProperty<QQuickAbstractAnimation> *list)
+{
+    if (auto q = qmlobject_cast<QQuickAnimationGroup *>(list->object))
+        return q->d_func()->animations.count();
+    return 0;
+}
+
 void QQuickAnimationGroupPrivate::clear_animation(QQmlListProperty<QQuickAbstractAnimation> *list)
 {
     QQuickAnimationGroup *q = qobject_cast<QQuickAnimationGroup *>(list->object);
@@ -1733,6 +1751,23 @@ void QQuickAnimationGroupPrivate::clear_animation(QQmlListProperty<QQuickAbstrac
     }
 }
 
+void QQuickAnimationGroupPrivate::replace_animation(QQmlListProperty<QQuickAbstractAnimation> *list,
+                                                    int i, QQuickAbstractAnimation *a)
+{
+    if (auto *q = qmlobject_cast<QQuickAnimationGroup *>(list->object)) {
+        if (QQuickAbstractAnimation *anim = q->d_func()->animations.at(i))
+            anim->setGroup(nullptr);
+        if (a)
+            a->setGroup(q, i);
+    }
+}
+
+void QQuickAnimationGroupPrivate::removeLast_animation(QQmlListProperty<QQuickAbstractAnimation> *list)
+{
+    if (auto *q = qobject_cast<QQuickAnimationGroup *>(list->object))
+        q->d_func()->animations.last()->setGroup(nullptr);
+}
+
 QQuickAnimationGroup::~QQuickAnimationGroup()
 {
     Q_D(QQuickAnimationGroup);
@@ -1744,10 +1779,14 @@ QQuickAnimationGroup::~QQuickAnimationGroup()
 QQmlListProperty<QQuickAbstractAnimation> QQuickAnimationGroup::animations()
 {
     Q_D(QQuickAnimationGroup);
-    QQmlListProperty<QQuickAbstractAnimation> list(this, d->animations);
-    list.append = &QQuickAnimationGroupPrivate::append_animation;
-    list.clear = &QQuickAnimationGroupPrivate::clear_animation;
-    return list;
+    return QQmlListProperty<QQuickAbstractAnimation>(
+                this, &(d->animations),
+                &QQuickAnimationGroupPrivate::append_animation,
+                &QQuickAnimationGroupPrivate::count_animation,
+                &QQuickAnimationGroupPrivate::at_animation,
+                &QQuickAnimationGroupPrivate::clear_animation,
+                &QQuickAnimationGroupPrivate::replace_animation,
+                &QQuickAnimationGroupPrivate::removeLast_animation);
 }
 
 /*!
@@ -1927,20 +1966,20 @@ QAbstractAnimationJob* QQuickParallelAnimation::transition(QQuickStateActions &a
 //convert a variant from string type to another animatable type
 void QQuickPropertyAnimationPrivate::convertVariant(QVariant &variant, int type)
 {
-    if (variant.userType() != QVariant::String) {
+    if (variant.userType() != QMetaType::QString) {
         variant.convert(type);
         return;
     }
 
     switch (type) {
-    case QVariant::Rect:
-    case QVariant::RectF:
-    case QVariant::Point:
-    case QVariant::PointF:
-    case QVariant::Size:
-    case QVariant::SizeF:
-    case QVariant::Color:
-    case QVariant::Vector3D:
+    case QMetaType::QRect:
+    case QMetaType::QRectF:
+    case QMetaType::QPoint:
+    case QMetaType::QPointF:
+    case QMetaType::QSize:
+    case QMetaType::QSizeF:
+    case QMetaType::QColor:
+    case QMetaType::QVector3D:
         {
         bool ok = false;
         variant = QQmlStringConverters::variantFromString(variant.toString(), type, &ok);
@@ -2533,7 +2572,7 @@ void QQuickPropertyAnimation::setProperties(const QString &prop)
 QQmlListProperty<QObject> QQuickPropertyAnimation::targets()
 {
     Q_D(QQuickPropertyAnimation);
-    return QQmlListProperty<QObject>(this, d->targets);
+    return QQmlListProperty<QObject>(this, &(d->targets));
 }
 
 /*!
@@ -2544,7 +2583,7 @@ QQmlListProperty<QObject> QQuickPropertyAnimation::targets()
 QQmlListProperty<QObject> QQuickPropertyAnimation::exclude()
 {
     Q_D(QQuickPropertyAnimation);
-    return QQmlListProperty<QObject>(this, d->exclude);
+    return QQmlListProperty<QObject>(this, &(d->exclude));
 }
 
 void QQuickAnimationPropertyUpdater::setValue(qreal v)
diff --git a/src/quick/util/qquickanimation_p.h b/src/quick/util/qquickanimation_p.h
index 45f1635c91..7bad9d50c4 100644
--- a/src/quick/util/qquickanimation_p.h
+++ b/src/quick/util/qquickanimation_p.h
@@ -111,7 +111,7 @@ public:
     void setCurrentTime(int);
 
     QQuickAnimationGroup *group() const;
-    void setGroup(QQuickAnimationGroup *);
+    void setGroup(QQuickAnimationGroup *, int index = -1);
 
     void setDefaultTarget(const QQmlProperty &);
     void setDisableUserControl();
diff --git a/src/quick/util/qquickanimation_p_p.h b/src/quick/util/qquickanimation_p_p.h
index c20ec65c24..8d23242b68 100644
--- a/src/quick/util/qquickanimation_p_p.h
+++ b/src/quick/util/qquickanimation_p_p.h
@@ -256,7 +256,12 @@ public:
     : QQuickAbstractAnimationPrivate() {}
 
     static void append_animation(QQmlListProperty<QQuickAbstractAnimation> *list, QQuickAbstractAnimation *role);
+    static QQuickAbstractAnimation *at_animation(QQmlListProperty<QQuickAbstractAnimation> *list, int index);
+    static int count_animation(QQmlListProperty<QQuickAbstractAnimation> *list);
     static void clear_animation(QQmlListProperty<QQuickAbstractAnimation> *list);
+    static void replace_animation(QQmlListProperty<QQuickAbstractAnimation> *list, int index,
+                                  QQuickAbstractAnimation *role);
+    static void removeLast_animation(QQmlListProperty<QQuickAbstractAnimation> *list);
     QList<QQuickAbstractAnimation *> animations;
 };
 
diff --git a/src/quick/util/qquickfontloader.cpp b/src/quick/util/qquickfontloader.cpp
index 2de9768243..505c70df7c 100644
--- a/src/quick/util/qquickfontloader.cpp
+++ b/src/quick/util/qquickfontloader.cpp
@@ -121,7 +121,7 @@ void QQuickFontObject::replyFinished()
         }
         redirectCount = 0;
 
-        if (!reply->error()) {
+        if (!reply->networkError()) {
             id = QFontDatabase::addApplicationFontFromData(reply->readAll());
             if (id != -1)
                 emit fontDownloaded(QFontDatabase::applicationFontFamilies(id).at(0), QQuickFontLoader::Ready);
diff --git a/src/quick/util/qquickglobal.cpp b/src/quick/util/qquickglobal.cpp
index 527274e6be..bc5b8c4f3e 100644
--- a/src/quick/util/qquickglobal.cpp
+++ b/src/quick/util/qquickglobal.cpp
@@ -719,7 +719,7 @@ public:
     bool typedRead(const QVariant& src, int dstType, void *dst)
     {
         T *dstT = reinterpret_cast<T *>(dst);
-        if (src.type() == static_cast<uint>(dstType)) {
+        if (src.userType() == dstType) {
             *dstT = src.value<T>();
         } else {
             *dstT = T();
diff --git a/src/quick/util/qquickpath.cpp b/src/quick/util/qquickpath.cpp
index 24b22f00c1..c855acc185 100644
--- a/src/quick/util/qquickpath.cpp
+++ b/src/quick/util/qquickpath.cpp
@@ -2415,7 +2415,7 @@ QVariant QQuickPathPolyline::path() const
 
 void QQuickPathPolyline::setPath(const QVariant &path)
 {
-    if (path.type() == QVariant::PolygonF) {
+    if (path.userType() == QMetaType::QPolygonF) {
         setPath(path.value<QPolygonF>());
     } else if (path.canConvert<QVector<QPointF>>()) {
         setPath(path.value<QVector<QPointF>>());
@@ -2431,7 +2431,7 @@ void QQuickPathPolyline::setPath(const QVariant &path)
             pathList.append(v.toPointF());
         setPath(pathList);
     } else {
-        qWarning() << "PathPolyline: path of type" << path.type() << "not supported";
+        qWarning() << "PathPolyline: path of type" << path.userType() << "not supported";
     }
 }
 
@@ -2583,7 +2583,7 @@ void QQuickPathMultiline::setPaths(const QVariant &paths)
         }
         setPaths(pathsList);
     } else {
-        qWarning() << "PathMultiline: paths of type" << paths.type() << "not supported";
+        qWarning() << "PathMultiline: paths of type" << paths.userType() << "not supported";
         setPaths(QVector<QVector<QPointF>>());
     }
 }
diff --git a/src/quick/util/qquickpixmapcache.cpp b/src/quick/util/qquickpixmapcache.cpp
index e1b30f2b2c..d47719389b 100644
--- a/src/quick/util/qquickpixmapcache.cpp
+++ b/src/quick/util/qquickpixmapcache.cpp
@@ -559,7 +559,7 @@ void QQuickPixmapReader::networkRequestDone(QNetworkReply *reply)
         QQuickPixmapReply::ReadError error = QQuickPixmapReply::NoError;
         QString errorString;
         QSize readSize;
-        if (reply->error()) {
+        if (reply->networkError()) {
             error = QQuickPixmapReply::Loading;
             errorString = reply->errorString();
         } else {
diff --git a/src/quick/util/qquickshortcut.cpp b/src/quick/util/qquickshortcut.cpp
index 5d227b4613..8ef204d179 100644
--- a/src/quick/util/qquickshortcut.cpp
+++ b/src/quick/util/qquickshortcut.cpp
@@ -130,7 +130,7 @@ QT_BEGIN_NAMESPACE
 
 static QKeySequence valueToKeySequence(const QVariant &value)
 {
-    if (value.type() == QVariant::Int)
+    if (value.userType() == QMetaType::Int)
         return QKeySequence(static_cast<QKeySequence::StandardKey>(value.toInt()));
     return QKeySequence::fromString(value.toString());
 }