Pass QMetaType by value rather than by ID in more places

This saves us some ping-pong between the IDs and the QMetaTypes, and
avoids possible ambiguities if multiple metatypes are registered for the
same C++ type.

Change-Id: I81cec94a9cd05d69927dc884f65574f0ab2ddc22
Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

33 files changed, 264 insertions, 255 deletions

diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 958a994cc3..fb5f5802f8 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -1513,15 +1513,14 @@ static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::Value &value, QMet
 {
     Q_ASSERT (!value.isEmpty());
     QV4::Scope scope(e);
-    int typeHint = metaType.id();
 
     if (const QV4::VariantObject *v = value.as<QV4::VariantObject>())
         return v->d()->data();
 
-    if (typeHint == QMetaType::Bool)
+    if (metaType == QMetaType::fromType<bool>())
         return QVariant(value.toBoolean());
 
-    if (typeHint == QMetaType::QJsonValue)
+    if (metaType == QMetaType::fromType<QJsonValue>())
         return QVariant::fromValue(QV4::JsonObject::toJsonValue(value));
 
     if (metaType == QMetaType::fromType<QJSValue>())
@@ -1529,7 +1528,7 @@ static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::Value &value, QMet
 
     if (value.as<QV4::Object>()) {
         QV4::ScopedObject object(scope, value);
-        if (typeHint == QMetaType::QJsonObject
+        if (metaType == QMetaType::fromType<QJsonObject>()
                    && !value.as<ArrayObject>() && !value.as<FunctionObject>()) {
             return QVariant::fromValue(QV4::JsonObject::toJsonObject(object));
         } else if (QV4::QObjectWrapper *wrapper = object->as<QV4::QObjectWrapper>()) {
@@ -1551,7 +1550,7 @@ static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::Value &value, QMet
 
     if (value.as<ArrayObject>()) {
         QV4::ScopedArrayObject a(scope, value);
-        if (typeHint == qMetaTypeId<QList<QObject *> >()) {
+        if (metaType == QMetaType::fromType<QList<QObject *>>()) {
             QList<QObject *> list;
             uint length = a->getLength();
             QV4::Scoped<QV4::QObjectWrapper> qobjectWrapper(scope);
@@ -1565,14 +1564,14 @@ static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::Value &value, QMet
             }
 
             return QVariant::fromValue<QList<QObject*> >(list);
-        } else if (typeHint == QMetaType::QJsonArray) {
+        } else if (metaType == QMetaType::fromType<QJsonArray>()) {
             return QVariant::fromValue(QV4::JsonObject::toJsonArray(a));
         }
 
         QVariant retn;
 #if QT_CONFIG(qml_sequence_object)
         bool succeeded = false;
-        retn = QV4::SequencePrototype::toVariant(value, typeHint, &succeeded);
+        retn = QV4::SequencePrototype::toVariant(value, metaType, &succeeded);
         if (succeeded)
             return retn;
 #endif
@@ -1631,7 +1630,7 @@ static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::Value &value, QMet
     if (String *s = value.stringValue()) {
         const QString &str = s->toQString();
         // QChars are stored as a strings
-        if (typeHint == QMetaType::QChar && str.size() == 1)
+        if (metaType == QMetaType::fromType<QChar>() && str.size() == 1)
             return str.at(0);
         return str;
     }
@@ -1642,7 +1641,7 @@ static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::Value &value, QMet
     if (const QV4::DateObject *d = value.as<DateObject>()) {
         auto dt = d->toQDateTime();
         // See ExecutionEngine::metaTypeFromJS()'s handling of QMetaType::Date:
-        if (typeHint == QMetaType::QDate) {
+        if (metaType == QMetaType::fromType<QDate>()) {
             const auto utc = dt.toUTC();
             if (utc.date() != dt.date() && utc.addSecs(-1).date() == dt.date())
                 dt = utc;
@@ -1738,7 +1737,7 @@ static QVariant objectToVariant(QV4::ExecutionEngine *e, const QV4::Object *o, V
   exactly the same as \a metaType and \a ptr.
  */
 QV4::ReturnedValue ExecutionEngine::fromData(
-        const QMetaType &metaType, const void *ptr, const QVariant *variant)
+        QMetaType metaType, const void *ptr, const QVariant *variant)
 {
     const int type = metaType.id();
     if (type < QMetaType::User) {
diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index db6bfcc84b..3120261a94 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -778,8 +778,7 @@ public:
                        int argc, void **args, QMetaType *types);
 
 private:
-    QV4::ReturnedValue fromData(
-            const QMetaType &type, const void *ptr, const QVariant *variant = nullptr);
+    QV4::ReturnedValue fromData(QMetaType type, const void *ptr, const QVariant *variant = nullptr);
 
 #if QT_CONFIG(qml_debug)
     QScopedPointer<QV4::Debugging::Debugger> m_debugger;
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index 20ccb00093..0a4f4658ed 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -134,8 +134,6 @@ static QV4::ReturnedValue loadProperty(QV4::ExecutionEngine *v4, QObject *object
 {
     Q_ASSERT(!property.isFunction());
     QV4::Scope scope(v4);
-    const QMetaType propMetaType = property.propType();
-    const int propType = propMetaType.id();
 
     if (property.isQObject()) {
         QObject *rv = nullptr;
@@ -149,42 +147,54 @@ static QV4::ReturnedValue loadProperty(QV4::ExecutionEngine *v4, QObject *object
             }
         }
         return ret;
+    }
 
-    } else if (property.isQList()) {
+    if (property.isQList())
         return QmlListWrapper::create(v4, object, property.coreIndex(), property.propType());
-    } else if (propType == QMetaType::QReal) {
-        qreal v = 0;
-        property.readProperty(object, &v);
-        return QV4::Encode(v);
-    } else if (propType == QMetaType::Int || property.isEnum()) {
+
+    const QMetaType propMetaType = property.propType();
+    switch (property.isEnum() ? QMetaType::Int : propMetaType.id()) {
+    case QMetaType::Int: {
         int v = 0;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (propType == QMetaType::Bool) {
+    }
+    case QMetaType::Bool: {
         bool v = false;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (propType == QMetaType::QString) {
+    }
+    case QMetaType::QString: {
         QString v;
         property.readProperty(object, &v);
         return v4->newString(v)->asReturnedValue();
-    } else if (propType == QMetaType::UInt) {
+    }
+    case QMetaType::UInt: {
         uint v = 0;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (propType == QMetaType::Float) {
+    }
+    case QMetaType::Float: {
         float v = 0;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (propType == QMetaType::Double) {
+    }
+    case QMetaType::Double: {
         double v = 0;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (propType == qMetaTypeId<QJSValue>()) {
+    }
+    default:
+        break;
+    }
+
+    if (propMetaType == QMetaType::fromType<QJSValue>()) {
         QJSValue v;
         property.readProperty(object, &v);
         return QJSValuePrivate::convertToReturnedValue(v4, v);
-    } else if (property.isQVariant()) {
+    }
+
+    if (property.isQVariant()) {
         QVariant v;
         property.readProperty(object, &v);
 
@@ -194,20 +204,24 @@ static QV4::ReturnedValue loadProperty(QV4::ExecutionEngine *v4, QObject *object
         }
 
         return scope.engine->fromVariant(v);
-    } else if (QQmlMetaType::isValueType(propMetaType)) {
+    }
+
+    if (QQmlMetaType::isValueType(propMetaType)) {
         if (const QMetaObject *valueTypeMetaObject = QQmlMetaType::metaObjectForValueType(propMetaType))
             return QV4::QQmlValueTypeWrapper::create(v4, object, property.coreIndex(), valueTypeMetaObject, propMetaType);
     } else {
 #if QT_CONFIG(qml_sequence_object)
         // see if it's a sequence type
         bool succeeded = false;
-        QV4::ScopedValue retn(scope, QV4::SequencePrototype::newSequence(v4, propType, object, property.coreIndex(), !property.isWritable(), &succeeded));
+        QV4::ScopedValue retn(scope, QV4::SequencePrototype::newSequence(
+                                  v4, propMetaType, object, property.coreIndex(),
+                                  !property.isWritable(), &succeeded));
         if (succeeded)
             return retn->asReturnedValue();
 #endif
     }
 
-    if (propType == QMetaType::UnknownType) {
+    if (!propMetaType.isValid()) {
         QMetaProperty p = object->metaObject()->property(property.coreIndex());
         qWarning("QMetaProperty::read: Unable to handle unregistered datatype '%s' for property "
                  "'%s::%s'", p.typeName(), object->metaObject()->className(), p.name());
@@ -2004,14 +2018,13 @@ bool CallArgument::fromValue(QMetaType metaType, QV4::ExecutionEngine *engine, c
         QQmlEnginePrivate *ep = engine->qmlEngine() ? QQmlEnginePrivate::get(engine->qmlEngine()) : nullptr;
         QVariant v = scope.engine->toVariant(value, metaType);
 
-        const QMetaType callMetaType(callType);
-        if (v.metaType() == callMetaType) {
+        if (v.metaType() == metaType) {
             *qvariantPtr = v;
-        } else if (v.canConvert(callMetaType)) {
+        } else if (v.canConvert(metaType)) {
             *qvariantPtr = v;
-            qvariantPtr->convert(callMetaType);
+            qvariantPtr->convert(metaType);
         } else {
-            QQmlMetaObject mo = ep ? ep->rawMetaObjectForType(callType) : QQmlMetaObject();
+            QQmlMetaObject mo = ep ? ep->rawMetaObjectForType(metaType) : QQmlMetaObject();
             if (!mo.isNull()) {
                 QObject *obj = QQmlMetaType::toQObject(v);
 
diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp
index 0523d740fb..e7063b05a4 100644
--- a/src/qml/jsruntime/qv4sequenceobject.cpp
+++ b/src/qml/jsruntime/qv4sequenceobject.cpp
@@ -605,7 +605,9 @@ ReturnedValue SequencePrototype::method_sort(const FunctionObject *b, const Valu
     return o.asReturnedValue();
 }
 
-ReturnedValue SequencePrototype::newSequence(QV4::ExecutionEngine *engine, int sequenceType, QObject *object, int propertyIndex, bool readOnly, bool *succeeded)
+ReturnedValue SequencePrototype::newSequence(
+        QV4::ExecutionEngine *engine, QMetaType sequenceType, QObject *object,
+        int propertyIndex,  bool readOnly, bool *succeeded)
 {
     QV4::Scope scope(engine);
     // This function is called when the property is a QObject Q_PROPERTY of
@@ -613,9 +615,7 @@ ReturnedValue SequencePrototype::newSequence(QV4::ExecutionEngine *engine, int s
     // (as well as object ptr + property index for updated-read and write-back)
     // and so access/mutate avoids variant conversion.
 
-
-    const QQmlType qmlType = QQmlMetaType::qmlType(
-                sequenceType, QQmlMetaType::TypeIdCategory::MetaType);
+    const QQmlType qmlType = QQmlMetaType::qmlType(sequenceType);
     if (qmlType.isSequentialContainer()) {
         *succeeded = true;
         QV4::ScopedObject obj(scope, engine->memoryManager->allocate<QV4Sequence>(
@@ -633,8 +633,7 @@ ReturnedValue SequencePrototype::fromVariant(
     return fromData(engine, v.metaType(), v.constData(), succeeded);
 }
 
-ReturnedValue SequencePrototype::fromData(
-        ExecutionEngine *engine, const QMetaType &type, const void *data, bool *succeeded)
+ReturnedValue SequencePrototype::fromData(ExecutionEngine *engine, QMetaType type, const void *data, bool *succeeded)
 {
     QV4::Scope scope(engine);
     // This function is called when assigning a sequence value to a normal JS var
@@ -642,8 +641,7 @@ ReturnedValue SequencePrototype::fromData(
     // Access and mutation is extremely fast since it will not need to modify any
     // QObject property.
 
-    const QQmlType qmlType = QQmlMetaType::qmlType(
-                type.id(), QQmlMetaType::TypeIdCategory::MetaType);
+    const QQmlType qmlType = QQmlMetaType::qmlType(type);
     if (qmlType.isSequentialContainer()) {
         *succeeded = true;
         QV4::ScopedObject obj(scope, engine->memoryManager->allocate<QV4Sequence>(qmlType, data));
@@ -660,7 +658,7 @@ QVariant SequencePrototype::toVariant(Object *object)
     return object->as<QV4Sequence>()->toVariant();
 }
 
-QVariant SequencePrototype::toVariant(const QV4::Value &array, int typeHint, bool *succeeded)
+QVariant SequencePrototype::toVariant(const QV4::Value &array, QMetaType typeHint, bool *succeeded)
 {
     *succeeded = true;
 
@@ -671,7 +669,7 @@ QVariant SequencePrototype::toVariant(const QV4::Value &array, int typeHint, boo
     QV4::Scope scope(array.as<Object>()->engine());
     QV4::ScopedArrayObject a(scope, array);
 
-    const QQmlType type = QQmlMetaType::qmlType(typeHint, QQmlMetaType::TypeIdCategory::MetaType);
+    const QQmlType type = QQmlMetaType::qmlType(typeHint);
     if (type.isSequentialContainer()) {
         const QMetaSequence *meta = type.priv()->extraData.ld;
         const QMetaType containerMetaType(type.priv()->typeId);
diff --git a/src/qml/jsruntime/qv4sequenceobject_p.h b/src/qml/jsruntime/qv4sequenceobject_p.h
index 603d33d6d8..d7bc7327c5 100644
--- a/src/qml/jsruntime/qv4sequenceobject_p.h
+++ b/src/qml/jsruntime/qv4sequenceobject_p.h
@@ -79,13 +79,13 @@ struct Q_QML_PRIVATE_EXPORT SequencePrototype : public QV4::Object
     static ReturnedValue method_valueOf(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
     static ReturnedValue method_sort(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
 
-    static ReturnedValue newSequence(QV4::ExecutionEngine *engine, int sequenceTypeId, QObject *object, int propertyIndex, bool readOnly, bool *succeeded);
+    static ReturnedValue newSequence(QV4::ExecutionEngine *engine, QMetaType sequenceType, QObject *object, int propertyIndex, bool readOnly, bool *succeeded);
     static ReturnedValue fromVariant(QV4::ExecutionEngine *engine, const QVariant &v, bool *succeeded);
-    static ReturnedValue fromData(QV4::ExecutionEngine *engine, const QMetaType &type, const void *data, bool *succeeded);
+    static ReturnedValue fromData(QV4::ExecutionEngine *engine, QMetaType type, const void *data, bool *succeeded);
 
     static int metaTypeForSequence(const Object *object);
     static QVariant toVariant(Object *object);
-    static QVariant toVariant(const Value &array, int typeHint, bool *succeeded);
+    static QVariant toVariant(const Value &array, QMetaType typeHint, bool *succeeded);
     static void* getRawContainerPtr(const Object *object, int typeHint);
 };
 
diff --git a/src/qml/qml/qqml.cpp b/src/qml/qml/qqml.cpp
index 70525f98a4..3a0f2b8b3e 100644
--- a/src/qml/qml/qqml.cpp
+++ b/src/qml/qml/qqml.cpp
@@ -806,7 +806,7 @@ static bool initObjectLookup(
         if (!foundMetaObject) {
             if (QQmlEngine *engine = aotContext->qmlEngine()) {
                 foundMetaObject = QQmlEnginePrivate::get(engine)->metaObjectForType(
-                            propType.id()).metaObject();
+                            propType).metaObject();
             }
         }
 
diff --git a/src/qml/qml/qqmlbinding.cpp b/src/qml/qml/qqmlbinding.cpp
index 788d03b8e2..772086c241 100644
--- a/src/qml/qml/qqmlbinding.cpp
+++ b/src/qml/qml/qqmlbinding.cpp
@@ -586,7 +586,7 @@ void QQmlBinding::handleWriteError(const void *result, QMetaType resultType, QMe
         if (QObject *o = *(QObject *const *)result) {
             valueType = o->metaObject()->className();
             QQmlMetaObject propertyMetaObject = QQmlPropertyPrivate::rawMetaObjectForType(
-                        QQmlEnginePrivate::get(engine()), metaType.id());
+                        QQmlEnginePrivate::get(engine()), metaType);
             if (!propertyMetaObject.isNull())
                 propertyType = propertyMetaObject.className();
         }
@@ -781,7 +781,7 @@ class QObjectPointerBinding: public QQmlNonbindingBinding
     QQmlMetaObject targetMetaObject;
 
 public:
-    QObjectPointerBinding(QQmlEnginePrivate *engine, int propertyType)
+    QObjectPointerBinding(QQmlEnginePrivate *engine, QMetaType propertyType)
         : targetMetaObject(QQmlPropertyPrivate::rawMetaObjectForType(engine, propertyType))
     {}
 
@@ -815,7 +815,7 @@ protected:
             QQmlEngine *qmlEngine = engine();
             Q_ASSERT(qmlEngine);
             resultMo = QQmlPropertyPrivate::rawMetaObjectForType(
-                        QQmlEnginePrivate::get(qmlEngine), value.userType());
+                        QQmlEnginePrivate::get(qmlEngine), value.metaType());
             if (resultMo.isNull())
                 return slowWrite(*pd, vtpd, result, type, isUndefined, flags);
             resultObject = *static_cast<QObject *const *>(value.constData());
@@ -857,7 +857,7 @@ protected:
             QQmlEngine *qmlEngine = engine();
             Q_ASSERT(qmlEngine);
             resultMo = QQmlPropertyPrivate::rawMetaObjectForType(
-                        QQmlEnginePrivate::get(qmlEngine), value.userType());
+                        QQmlEnginePrivate::get(qmlEngine), value.metaType());
             if (resultMo.isNull())
                 return slowWrite(*pd, vtpd, result, isUndefined, flags);
             resultObject = *static_cast<QObject *const *>(value.constData());
@@ -898,15 +898,12 @@ QQmlBinding *QQmlBinding::newBinding(QQmlEnginePrivate *engine, const QQmlProper
 QQmlBinding *QQmlBinding::newBinding(QQmlEnginePrivate *engine, QMetaType propertyType)
 {
     if (propertyType.flags() & QMetaType::PointerToQObject)
-        return new QObjectPointerBinding(engine, propertyType.id());
+        return new QObjectPointerBinding(engine, propertyType);
 
-    const int type = propertyType.id();
-
-    if (type == qMetaTypeId<QQmlBinding *>()) {
+    if (propertyType == QMetaType::fromType<QQmlBinding *>())
         return new QQmlBindingBinding;
-    }
 
-    switch (type) {
+    switch (propertyType.id()) {
     case QMetaType::Bool:
         return new GenericBinding<QMetaType::Bool>;
     case QMetaType::Int:
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index 4b90f6a501..dfcf52a8e4 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -1343,7 +1343,7 @@ template<>
 QJSValue QQmlEngine::singletonInstance<QJSValue>(int qmlTypeId)
 {
     Q_D(QQmlEngine);
-    QQmlType type = QQmlMetaType::qmlType(qmlTypeId, QQmlMetaType::TypeIdCategory::QmlType);
+    QQmlType type = QQmlMetaType::qmlTypeById(qmlTypeId);
 
     if (!type.isValid() || !type.isSingleton())
         return QJSValue();
@@ -2062,13 +2062,12 @@ static QQmlPropertyCache *propertyCacheForPotentialInlineComponentType(int t, co
  *
  * Look up by type's baseMetaObject.
  */
-QQmlMetaObject QQmlEnginePrivate::rawMetaObjectForType(int t) const
+QQmlMetaObject QQmlEnginePrivate::rawMetaObjectForType(QMetaType metaType) const
 {
-    if (QQmlPropertyCache *composite = findPropertyCacheInCompositeTypes(t))
+    if (QQmlPropertyCache *composite = findPropertyCacheInCompositeTypes(metaType.id()))
         return QQmlMetaObject(composite);
 
-    QQmlType type = QQmlMetaType::qmlType(t);
-    return QQmlMetaObject(type.baseMetaObject());
+    return QQmlMetaObject(QQmlMetaType::qmlType(metaType).baseMetaObject());
 }
 
 /*!
@@ -2076,13 +2075,12 @@ QQmlMetaObject QQmlEnginePrivate::rawMetaObjectForType(int t) const
  *
  * Look up by type's metaObject.
  */
-QQmlMetaObject QQmlEnginePrivate::metaObjectForType(int t) const
+QQmlMetaObject QQmlEnginePrivate::metaObjectForType(QMetaType metaType) const
 {
-    if (QQmlPropertyCache *composite = findPropertyCacheInCompositeTypes(t))
+    if (QQmlPropertyCache *composite = findPropertyCacheInCompositeTypes(metaType.id()))
         return QQmlMetaObject(composite);
 
-    QQmlType type = QQmlMetaType::qmlType(t);
-    return QQmlMetaObject(type.metaObject());
+    return QQmlMetaObject(QQmlMetaType::qmlType(metaType).metaObject());
 }
 
 /*!
@@ -2090,12 +2088,12 @@ QQmlMetaObject QQmlEnginePrivate::metaObjectForType(int t) const
  *
  * Look up by type's metaObject and version.
  */
-QQmlPropertyCache *QQmlEnginePrivate::propertyCacheForType(int t)
+QQmlPropertyCache *QQmlEnginePrivate::propertyCacheForType(QMetaType metaType)
 {
-    if (QQmlPropertyCache *composite = findPropertyCacheInCompositeTypes(t))
+    if (QQmlPropertyCache *composite = findPropertyCacheInCompositeTypes(metaType.id()))
         return composite;
 
-    QQmlType type = QQmlMetaType::qmlType(t);
+    const QQmlType type = QQmlMetaType::qmlType(metaType);
     return type.isValid() ? cache(type.metaObject(), type.version()) : nullptr;
 }
 
@@ -2106,12 +2104,12 @@ QQmlPropertyCache *QQmlEnginePrivate::propertyCacheForType(int t)
  * TODO: Is this correct? Passing a plain QTypeRevision() rather than QTypeRevision::zero() or
  *       the actual type's version seems strange. The behavior has been in place for a while.
  */
-QQmlPropertyCache *QQmlEnginePrivate::rawPropertyCacheForType(int t)
+QQmlPropertyCache *QQmlEnginePrivate::rawPropertyCacheForType(QMetaType metaType)
 {
-    if (QQmlPropertyCache *composite = findPropertyCacheInCompositeTypes(t))
+    if (QQmlPropertyCache *composite = findPropertyCacheInCompositeTypes(metaType.id()))
         return composite;
 
-    QQmlType type = QQmlMetaType::qmlType(t);
+    const QQmlType type = QQmlMetaType::qmlType(metaType);
     return type.isValid() ? cache(type.baseMetaObject(), QTypeRevision()) : nullptr;
 }
 
@@ -2121,12 +2119,13 @@ QQmlPropertyCache *QQmlEnginePrivate::rawPropertyCacheForType(int t)
  * Look up by QQmlType and version. We only fall back to lookup by metaobject if the type
  * has no revisiononed attributes here. Unspecified versions are interpreted as "any".
  */
-QQmlPropertyCache *QQmlEnginePrivate::rawPropertyCacheForType(int t, QTypeRevision version)
+QQmlPropertyCache *QQmlEnginePrivate::rawPropertyCacheForType(
+        QMetaType metaType, QTypeRevision version)
 {
-    if (QQmlPropertyCache *composite = findPropertyCacheInCompositeTypes(t))
+    if (QQmlPropertyCache *composite = findPropertyCacheInCompositeTypes(metaType.id()))
         return composite;
 
-    QQmlType type = QQmlMetaType::qmlType(t);
+    const QQmlType type = QQmlMetaType::qmlType(metaType);
     if (!type.isValid())
         return nullptr;
 
diff --git a/src/qml/qml/qqmlengine_p.h b/src/qml/qml/qqmlengine_p.h
index 499f9dd492..1e11808ac7 100644
--- a/src/qml/qml/qqmlengine_p.h
+++ b/src/qml/qml/qqmlengine_p.h
@@ -235,11 +235,11 @@ public:
     using QJSEnginePrivate::cache;
 
     // These methods may be called from the loader thread
-    QQmlMetaObject rawMetaObjectForType(int) const;
-    QQmlMetaObject metaObjectForType(int) const;
-    QQmlPropertyCache *propertyCacheForType(int);
-    QQmlPropertyCache *rawPropertyCacheForType(int);
-    QQmlPropertyCache *rawPropertyCacheForType(int, QTypeRevision version);
+    QQmlMetaObject rawMetaObjectForType(QMetaType metaType) const;
+    QQmlMetaObject metaObjectForType(QMetaType metaType) const;
+    QQmlPropertyCache *propertyCacheForType(QMetaType metaType);
+    QQmlPropertyCache *rawPropertyCacheForType(QMetaType metaType);
+    QQmlPropertyCache *rawPropertyCacheForType(QMetaType metaType, QTypeRevision version);
     void registerInternalCompositeType(QV4::ExecutableCompilationUnit *compilationUnit);
     void unregisterInternalCompositeType(QV4::ExecutableCompilationUnit *compilationUnit);
     QV4::ExecutableCompilationUnit *obtainExecutableCompilationUnit(int typeId);
diff --git a/src/qml/qml/qqmlglobal.cpp b/src/qml/qml/qqmlglobal.cpp
index d4473b7020..bd0d8e5e88 100644
--- a/src/qml/qml/qqmlglobal.cpp
+++ b/src/qml/qml/qqmlglobal.cpp
@@ -48,21 +48,20 @@
 
 QT_BEGIN_NAMESPACE
 
-bool QQmlValueTypeProvider::initValueType(int type, QVariant& dst)
+bool QQmlValueTypeProvider::initValueType(QMetaType metaType, QVariant &dst)
 {
-    const QMetaType metaType(type);
     if (!metaType.isValid())
         return false;
-    dst = QVariant(QMetaType(type));
+    dst = QVariant(metaType);
     return true;
 }
 
-bool QQmlValueTypeProvider::createValueType(int type, const QJSValue &s, QVariant &data)
+bool QQmlValueTypeProvider::createValueType(QMetaType metaType, const QJSValue &s, QVariant &data)
 {
-    const QQmlType qmlType = QQmlMetaType::qmlType(type, QQmlMetaType::TypeIdCategory::MetaType);
+    const QQmlType qmlType = QQmlMetaType::qmlType(metaType);
     if (auto valueTypeFunction = qmlType.createValueTypeFunction()) {
         QVariant result = valueTypeFunction(s);
-        if (result.userType() == type) {
+        if (result.metaType() == metaType) {
             data = std::move(result);
             return true;
         }
@@ -71,32 +70,34 @@ bool QQmlValueTypeProvider::createValueType(int type, const QJSValue &s, QVarian
     return false;
 }
 
-bool QQmlValueTypeProvider::equalValueType(int type, const void *lhs, const QVariant& rhs)
+bool QQmlValueTypeProvider::equalValueType(QMetaType metaType, const void *lhs, const QVariant &rhs)
 {
     Q_ASSERT(lhs);
-    return QMetaType(type).equals(lhs, rhs.constData());
+    return metaType.equals(lhs, rhs.constData());
 }
 
-bool QQmlValueTypeProvider::readValueType(const QVariant& src, void *dst, int type)
+bool QQmlValueTypeProvider::readValueType(QMetaType metaType, const QVariant  &src, void *dst)
 {
     Q_ASSERT(dst);
-    const QMetaType dstType(type);
-    if (!dstType.isValid() || (src.metaType() == dstType && dstType.equals(src.constData(), dst)))
+    if (!metaType.isValid()
+            || (src.metaType() == metaType && metaType.equals(src.constData(), dst))) {
         return false;
+    }
 
-    dstType.destruct(dst);
-    dstType.construct(dst, src.metaType() == dstType ? src.constData() : nullptr);
+    metaType.destruct(dst);
+    metaType.construct(dst, src.metaType() == metaType ? src.constData() : nullptr);
     return true;
 }
 
-bool QQmlValueTypeProvider::writeValueType(int type, const void *src, QVariant& dst)
+bool QQmlValueTypeProvider::writeValueType(QMetaType metaType, const void *src, QVariant &dst)
 {
     Q_ASSERT(src);
-    const QMetaType srcType(type);
-    if (!srcType.isValid() || (dst.metaType() == srcType && srcType.equals(src, dst.constData())))
+    if (!metaType.isValid()
+            || (dst.metaType() == metaType && metaType.equals(src, dst.constData()))) {
         return false;
+    }
 
-    dst = QVariant(srcType, src);
+    dst = QVariant(metaType, src);
     return true;
 }
 
diff --git a/src/qml/qml/qqmlglobal_p.h b/src/qml/qml/qqmlglobal_p.h
index d32641c10c..fd4bd0deaa 100644
--- a/src/qml/qml/qqmlglobal_p.h
+++ b/src/qml/qml/qqmlglobal_p.h
@@ -220,11 +220,11 @@ inline void QQml_setParent_noEvent(QObject *object, QObject *parent)
 class Q_QML_PRIVATE_EXPORT QQmlValueTypeProvider
 {
 public:
-    bool initValueType(int, QVariant&);
-    bool createValueType(int, const QJSValue &, QVariant &);
-    bool equalValueType(int, const void *, const QVariant&);
-    bool readValueType(const QVariant&, void *, int);
-    bool writeValueType(int, const void *, QVariant&);
+    bool initValueType(QMetaType, QVariant &);
+    bool createValueType(QMetaType, const QJSValue &, QVariant &);
+    bool equalValueType(QMetaType, const void *, const QVariant &);
+    bool readValueType(QMetaType, const QVariant &, void *);
+    bool writeValueType(QMetaType, const void *, QVariant &);
 };
 
 Q_AUTOTEST_EXPORT QQmlValueTypeProvider *QQml_valueTypeProvider();
diff --git a/src/qml/qml/qqmllist_p.h b/src/qml/qml/qqmllist_p.h
index 8ce3c04abb..7ecb09b51d 100644
--- a/src/qml/qml/qqmllist_p.h
+++ b/src/qml/qml/qqmllist_p.h
@@ -85,7 +85,7 @@ public:
     const QMetaObject *elementType()
     {
         if (m_elementTypeOrEngine.isT2()) {
-            const int listType = QQmlMetaType::listType(propertyType).id();
+            const QMetaType listType = QQmlMetaType::listType(propertyType);
             const QQmlEngine *engine = m_elementTypeOrEngine.asT2();
             const QQmlEnginePrivate *p = engine ? QQmlEnginePrivate::get(engine) : nullptr;
             m_elementTypeOrEngine = p ? p->rawMetaObjectForType(listType).metaObject()
diff --git a/src/qml/qml/qqmlmetatype.cpp b/src/qml/qml/qqmlmetatype.cpp
index e412263825..444a40c7fc 100644
--- a/src/qml/qml/qqmlmetatype.cpp
+++ b/src/qml/qml/qqmlmetatype.cpp
@@ -1059,10 +1059,9 @@ QMetaType QQmlMetaType::listType(QMetaType metaType)
     const auto iface = metaType.iface();
     if (iface->metaObjectFn == &dynamicQmlListMarker)
         return QMetaType(static_cast<const QQmlListMetaTypeInterface *>(iface)->valueType);
-    auto id = metaType.id();
     QQmlMetaTypeDataPtr data;
-    QQmlTypePrivate *type = data->idToType.value(id);
-    if (type && type->listId.id() == id)
+    QQmlTypePrivate *type = data->idToType.value(metaType.id());
+    if (type && type->listId == metaType)
         return type->typeId;
     else
         return QMetaType {};
@@ -1132,26 +1131,17 @@ QMetaMethod QQmlMetaType::defaultMethod(QObject *obj)
 /*!
     See qmlRegisterInterface() for information about when this will return true.
 */
-bool QQmlMetaType::isInterface(int userType)
+bool QQmlMetaType::isInterface(QMetaType type)
 {
     const QQmlMetaTypeDataPtr data;
-    return data->interfaces.contains(userType);
+    return data->interfaces.contains(type.id());
 }
 
-const char *QQmlMetaType::interfaceIId(int userType)
+const char *QQmlMetaType::interfaceIId(QMetaType metaType)
 {
-
-    QQmlTypePrivate *typePrivate = nullptr;
-    {
-        QQmlMetaTypeDataPtr data;
-        typePrivate = data->idToType.value(userType);
-    }
-
-    QQmlType type(typePrivate);
-    if (type.isInterface() && type.typeId().id() == userType)
-        return type.interfaceIId();
-    else
-        return nullptr;
+    const QQmlMetaTypeDataPtr data;
+    const QQmlType type(data->idToType.value(metaType.id()));
+    return (type.isInterface() && type.typeId() == metaType) ? type.interfaceIId() : nullptr;
 }
 
 bool QQmlMetaType::isList(QMetaType type)
@@ -1200,8 +1190,8 @@ QQmlType QQmlMetaType::qmlType(const QHashedStringRef &name, const QHashedString
 }
 
 /*!
-    Returns the type (if any) that corresponds to the \a metaObject.  Returns null if no
-    type is registered.
+    Returns the type (if any) that corresponds to the \a metaObject. Returns an invalid type if no
+    such type is registered.
 */
 QQmlType QQmlMetaType::qmlType(const QMetaObject *metaObject)
 {
@@ -1231,27 +1221,30 @@ QQmlType QQmlMetaType::qmlType(const QMetaObject *metaObject, const QHashedStrin
 }
 
 /*!
-    Returns the type (if any) that corresponds to \a typeId.  Depending on \a category, the
-    \a typeId is interpreted either as QVariant::Type or as QML type id returned by one of the
-    qml type registration functions.  Returns null if no type is registered.
+    Returns the type (if any) that corresponds to \a qmlTypeId.
+    Returns an invalid QQmlType if no such type is registered.
 */
-QQmlType QQmlMetaType::qmlType(int typeId, TypeIdCategory category)
+QQmlType QQmlMetaType::qmlTypeById(int qmlTypeId)
 {
     const QQmlMetaTypeDataPtr data;
-
-    if (category == TypeIdCategory::MetaType) {
-        QQmlTypePrivate *type = data->idToType.value(typeId);
-        if (type && type->typeId.id() == typeId)
-            return QQmlType(type);
-    } else if (category == TypeIdCategory::QmlType) {
-        QQmlType type = data->types.value(typeId);
-        if (type.isValid())
-            return type;
-    }
+    QQmlType type = data->types.value(qmlTypeId);
+    if (type.isValid())
+        return type;
     return QQmlType();
 }
 
 /*!
+    Returns the type (if any) that corresponds to \a metaType.
+    Returns an invalid QQmlType if no such type is registered.
+*/
+QQmlType QQmlMetaType::qmlType(QMetaType metaType)
+{
+    const QQmlMetaTypeDataPtr data;
+    QQmlTypePrivate *type = data->idToType.value(metaType.id());
+    return (type && type->typeId == metaType) ? QQmlType(type) : QQmlType();
+}
+
+/*!
     Returns the type (if any) that corresponds to the given \a url in the set of
     composite types added through file imports.
 
@@ -1491,7 +1484,7 @@ QString QQmlMetaType::prettyTypeName(const QObject *object)
         marker = typeName.indexOf(QLatin1String("_QML_"));
         if (marker != -1) {
             typeName = QStringView{typeName}.left(marker) + QLatin1Char('*');
-            type = QQmlMetaType::qmlType(QMetaType::fromName(typeName.toLatin1()).id());
+            type = QQmlMetaType::qmlType(QMetaType::fromName(typeName.toUtf8()));
             if (type.isValid()) {
                 QString qmlTypeName = type.qmlTypeName();
                 const int lastSlash = qmlTypeName.lastIndexOf(QLatin1Char('/'));
@@ -1580,8 +1573,7 @@ bool QQmlMetaType::isValueType(QMetaType type)
 
 const QMetaObject *QQmlMetaType::metaObjectForValueType(QMetaType metaType)
 {
-    const int t = metaType.id();
-    switch (t) {
+    switch (metaType.id()) {
     case QMetaType::QPoint:
         return &QQmlPointValueType::staticMetaObject;
     case QMetaType::QPointF:
@@ -1616,7 +1608,7 @@ const QMetaObject *QQmlMetaType::metaObjectForValueType(QMetaType metaType)
     // call QObject pointers value types. Explicitly registered types also override
     // the implicit use of gadgets.
     if (!(metaType.flags() & QMetaType::PointerToQObject)) {
-        const QQmlType qmlType = QQmlMetaType::qmlType(t, QQmlMetaType::TypeIdCategory::MetaType);
+        const QQmlType qmlType = QQmlMetaType::qmlType(metaType);
 
         // Prefer the extension meta object.
         // Extensions allow registration of non-gadget value types.
@@ -1636,16 +1628,15 @@ const QMetaObject *QQmlMetaType::metaObjectForValueType(QMetaType metaType)
 
 QQmlValueType *QQmlMetaType::valueType(QMetaType type)
 {
-    const int idx = type.id();
     QQmlMetaTypeDataPtr data;
 
-    const auto it = data->metaTypeToValueType.constFind(idx);
+    const auto it = data->metaTypeToValueType.constFind(type.id());
     if (it != data->metaTypeToValueType.constEnd())
         return *it;
 
     if (const QMetaObject *mo = metaObjectForValueType(type))
-        return *data->metaTypeToValueType.insert(idx, new QQmlValueType(idx, mo));
-    return *data->metaTypeToValueType.insert(idx, nullptr);
+        return *data->metaTypeToValueType.insert(type.id(), new QQmlValueType(type, mo));
+    return *data->metaTypeToValueType.insert(type.id(), nullptr);
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlmetatype_p.h b/src/qml/qml/qqmlmetatype_p.h
index 7ee16f9dc9..4ea1938051 100644
--- a/src/qml/qml/qqmlmetatype_p.h
+++ b/src/qml/qml/qqmlmetatype_p.h
@@ -164,16 +164,13 @@ public:
     static QList<QQmlType> qmlSingletonTypes();
     static QList<QQmlType> qmlAllTypes();
 
-    enum class TypeIdCategory {
-        MetaType,
-        QmlType
-    };
-
     static QQmlType qmlType(const QString &qualifiedName, QTypeRevision version);
     static QQmlType qmlType(const QHashedStringRef &name, const QHashedStringRef &module, QTypeRevision version);
     static QQmlType qmlType(const QMetaObject *);
     static QQmlType qmlType(const QMetaObject *metaObject, const QHashedStringRef &module, QTypeRevision version);
-    static QQmlType qmlType(int typeId, TypeIdCategory category = TypeIdCategory::MetaType);
+    static QQmlType qmlTypeById(int qmlTypeId);
+
+    static QQmlType qmlType(QMetaType metaType);
     static QQmlType qmlType(const QUrl &unNormalizedUrl, bool includeNonFileImports = false);
 
     static QQmlPropertyCache *propertyCache(const QMetaObject *metaObject,
@@ -192,8 +189,8 @@ public:
     static QMetaType listType(QMetaType type);
     static QQmlAttachedPropertiesFunc attachedPropertiesFunc(QQmlEnginePrivate *,
                                                              const QMetaObject *);
-    static bool isInterface(int);
-    static const char *interfaceIId(int);
+    static bool isInterface(QMetaType type);
+    static const char *interfaceIId(QMetaType type);
     static bool isList(QMetaType type);
 
     static QTypeRevision latestModuleVersion(const QString &uri);
diff --git a/src/qml/qml/qqmlobjectcreator.cpp b/src/qml/qml/qqmlobjectcreator.cpp
index c0cc917499..c74732d9f0 100644
--- a/src/qml/qml/qqmlobjectcreator.cpp
+++ b/src/qml/qml/qqmlobjectcreator.cpp
@@ -349,11 +349,11 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     QQmlPropertyData::WriteFlags propertyWriteFlags = QQmlPropertyData::BypassInterceptor | QQmlPropertyData::RemoveBindingOnAliasWrite;
     QV4::Scope scope(v4);
 
-    int propertyType = property->propType().id();
+    QMetaType propertyType = property->propType();
 
     if (property->isEnum()) {
         if (binding->flags & QV4::CompiledData::Binding::IsResolvedEnum) {
-            propertyType = QMetaType::Int;
+            propertyType = QMetaType::fromType<int>();
         } else {
             // ### This should be resolved earlier at compile time and the binding value should be changed accordingly.
             QVariant value = compilationUnit->bindingValueAsString(binding);
@@ -386,7 +386,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         }
     }
 
-    switch (propertyType) {
+    switch (propertyType.id()) {
     case QMetaType::QVariant: {
         if (binding->type == QV4::CompiledData::Binding::Type_Number) {
             double n = compilationUnit->bindingValueAsNumber(binding);
@@ -488,7 +488,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     case QMetaType::QColor: {
         QVariant data;
         if (QQml_valueTypeProvider()->createValueType(
-                    QMetaType::QColor, compilationUnit->bindingValueAsString(binding), data)) {
+                    propertyType, compilationUnit->bindingValueAsString(binding), data)) {
             property->writeProperty(_qobject, data.data(), propertyWriteFlags);
         }
     }
@@ -579,37 +579,37 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     }
     default: {
         // generate single literal value assignment to a list property if required
-        if (propertyType == qMetaTypeId<QList<qreal> >()) {
+        if (propertyType == QMetaType::fromType<QList<qreal>>()) {
             assertType(QV4::CompiledData::Binding::Type_Number);
             QList<qreal> value;
             value.append(compilationUnit->bindingValueAsNumber(binding));
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
-        } else if (propertyType == qMetaTypeId<QList<int> >()) {
+        } else if (propertyType == QMetaType::fromType<QList<int>>()) {
             assertType(QV4::CompiledData::Binding::Type_Number);
             double n = compilationUnit->bindingValueAsNumber(binding);
             QList<int> value;
             value.append(int(n));
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
-        } else if (propertyType == qMetaTypeId<QList<bool> >()) {
+        } else if (propertyType == QMetaType::fromType<QList<bool>>()) {
             assertType(QV4::CompiledData::Binding::Type_Boolean);
             QList<bool> value;
             value.append(binding->valueAsBoolean());
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
-        } else if (propertyType == qMetaTypeId<QList<QUrl> >()) {
+        } else if (propertyType == QMetaType::fromType<QList<QUrl>>()) {
             assertType(QV4::CompiledData::Binding::Type_String);
             QList<QUrl> value { QUrl(compilationUnit->bindingValueAsString(binding)) };
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
-        } else if (propertyType == qMetaTypeId<QList<QString> >()) {
+        } else if (propertyType == QMetaType::fromType<QList<QString>>()) {
             assertOrNull(binding->evaluatesToString());
             QList<QString> value;
             value.append(compilationUnit->bindingValueAsString(binding));
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
-        } else if (propertyType == qMetaTypeId<QJSValue>()) {
+        } else if (propertyType == QMetaType::fromType<QJSValue>()) {
             QJSValue value;
             if (binding->type == QV4::CompiledData::Binding::Type_Boolean) {
                 value = QJSValue(binding->valueAsBoolean());
@@ -1063,7 +1063,7 @@ bool QQmlObjectCreator::setPropertyBinding(const QQmlPropertyData *bindingProper
         int propertyWriteStatus = -1;
         void *argv[] = { nullptr, nullptr, &propertyWriteStatus, &propertyWriteFlags };
 
-        if (const char *iid = QQmlMetaType::interfaceIId(bindingProperty->propType().id())) {
+        if (const char *iid = QQmlMetaType::interfaceIId(bindingProperty->propType())) {
             void *ptr = createdSubObject->qt_metacast(iid);
             if (ptr) {
                 argv[0] = &ptr;
@@ -1100,7 +1100,7 @@ bool QQmlObjectCreator::setPropertyBinding(const QQmlPropertyData *bindingProper
 
             QMetaType listItemType = QQmlMetaType::listType(bindingProperty->propType());
             if (listItemType.isValid()) {
-                const char *iid = QQmlMetaType::interfaceIId(listItemType.id());
+                const char *iid = QQmlMetaType::interfaceIId(listItemType);
                 if (iid)
                     itemToAdd = createdSubObject->qt_metacast(iid);
             }
diff --git a/src/qml/qml/qqmlproperty.cpp b/src/qml/qml/qqmlproperty.cpp
index b24b57a0e4..d8e2c58e36 100644
--- a/src/qml/qml/qqmlproperty.cpp
+++ b/src/qml/qml/qqmlproperty.cpp
@@ -1251,8 +1251,7 @@ bool QQmlPropertyPrivate::write(
         const QQmlRefPointer<QQmlContextData> &context, QQmlPropertyData::WriteFlags flags)
 {
     const QMetaType propertyMetaType = property.propType();
-    const int propertyType = propertyMetaType.id();
-    const int variantType = value.userType();
+    const QMetaType variantMetaType = value.metaType();
 
     // we need to prevent new-style bindings from being  removed
     QUntypedPropertyBinding untypedBinding;
@@ -1276,7 +1275,7 @@ bool QQmlPropertyPrivate::write(
         QMetaProperty prop = object->metaObject()->property(property.coreIndex());
         QVariant v = value;
         // Enum values come through the script engine as doubles
-        if (variantType == QMetaType::Double) {
+        if (variantMetaType == QMetaType::fromType<double>()) {
             double integral;
             double fractional = std::modf(value.toDouble(), &integral);
             if (qFuzzyIsNull(fractional))
@@ -1286,25 +1285,28 @@ bool QQmlPropertyPrivate::write(
     }
 
     QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(context);
-    const bool isUrl = propertyType == QMetaType::QUrl; // handled separately
+    const bool isUrl = propertyMetaType == QMetaType::fromType<QUrl>(); // handled separately
 
     // The cases below are in approximate order of likelyhood:
-    if (propertyType == variantType && !isUrl && propertyType != qMetaTypeId<QList<QUrl>>() && !property.isQList()) {
+    if (propertyMetaType == variantMetaType && !isUrl
+            && propertyMetaType != QMetaType::fromType<QList<QUrl>>() && !property.isQList()) {
         return property.writeProperty(object, const_cast<void *>(value.constData()), flags);
     } else if (property.isQObject()) {
         QVariant val = value;
-        int varType = variantType;
-        if (variantType == QMetaType::Nullptr) {
+        QMetaType varType;
+        if (variantMetaType == QMetaType::fromType<std::nullptr_t>()) {
             // This reflects the fact that you can assign a nullptr to a QObject pointer
             // Without the change to QObjectStar, rawMetaObjectForType would not give us a QQmlMetaObject
-            varType = QMetaType::QObjectStar;
-            val = QVariant(QMetaType::fromType<QObject *>(), nullptr);
+            varType = QMetaType::fromType<QObject*>();
+            val = QVariant(varType, nullptr);
+        } else {
+            varType = variantMetaType;
         }
         QQmlMetaObject valMo = rawMetaObjectForType(enginePriv, varType);
         if (valMo.isNull())
             return false;
         QObject *o = *static_cast<QObject *const *>(val.constData());
-        QQmlMetaObject propMo = rawMetaObjectForType(enginePriv, propertyType);
+        QQmlMetaObject propMo = rawMetaObjectForType(enginePriv, propertyMetaType);
 
         if (o)
             valMo = o;
@@ -1320,10 +1322,10 @@ bool QQmlPropertyPrivate::write(
             return false;
         }
     } else if (value.canConvert(propertyMetaType)
-               && !isUrl && variantType != QMetaType::QString
-               && propertyType != qMetaTypeId<QList<QUrl>>() && !property.isQList()) {
+               && !isUrl && variantMetaType != QMetaType::fromType<QString>()
+               && propertyMetaType != QMetaType::fromType<QList<QUrl>>() && !property.isQList()) {
         // common cases:
-        switch (propertyType) {
+        switch (propertyMetaType.id()) {
         case QMetaType::Bool: {
             bool b = value.toBool();
             return property.writeProperty(object, &b, flags);
@@ -1350,30 +1352,30 @@ bool QQmlPropertyPrivate::write(
             return property.writeProperty(object, const_cast<void *>(v.constData()), flags);
         }
         }
-    } else if (propertyType == qMetaTypeId<QVariant>()) {
+    } else if (propertyMetaType == QMetaType::fromType<QVariant>()) {
         return property.writeProperty(object, const_cast<QVariant *>(&value), flags);
     } else if (isUrl) {
         QUrl u;
-        if (variantType == QMetaType::QUrl)
+        if (variantMetaType == QMetaType::fromType<QUrl>())
             u = value.toUrl();
-        else if (variantType == QMetaType::QByteArray)
+        else if (variantMetaType == QMetaType::fromType<QByteArray>())
             u = QUrl(QString::fromUtf8(value.toByteArray()));
-        else if (variantType == QMetaType::QString)
+        else if (variantMetaType == QMetaType::fromType<QString>())
             u = QUrl(value.toString());
         else
             return false;
 
         return property.writeProperty(object, &u, flags);
-    } else if (propertyType == qMetaTypeId<QList<QUrl>>()) {
+    } else if (propertyMetaType == QMetaType::fromType<QList<QUrl>>()) {
         QList<QUrl> urlSeq = urlSequence(value).value<QList<QUrl>>();
         return property.writeProperty(object, &urlSeq, flags);
     } else if (property.isQList()) {
         QQmlMetaObject listType;
 
         if (enginePriv) {
-            listType = enginePriv->rawMetaObjectForType(QQmlMetaType::listType(propertyMetaType).id());
+            listType = enginePriv->rawMetaObjectForType(QQmlMetaType::listType(propertyMetaType));
         } else {
-            QQmlType type = QQmlMetaType::qmlType(QQmlMetaType::listType(propertyMetaType).id());
+            const QQmlType type = QQmlMetaType::qmlType(QQmlMetaType::listType(propertyMetaType));
             if (!type.isValid())
                 return false;
             listType = type.baseMetaObject();
@@ -1389,7 +1391,7 @@ bool QQmlPropertyPrivate::write(
 
         prop.clear(&prop);
 
-        if (variantType == qMetaTypeId<QQmlListReference>()) {
+        if (variantMetaType == QMetaType::fromType<QQmlListReference>()) {
             QQmlListReference qdlr = value.value<QQmlListReference>();
 
             for (qsizetype ii = 0; ii < qdlr.count(); ++ii) {
@@ -1398,7 +1400,7 @@ bool QQmlPropertyPrivate::write(
                     o = nullptr;
                 prop.append(&prop, o);
             }
-        } else if (variantType == qMetaTypeId<QList<QObject *> >()) {
+        } else if (variantMetaType == QMetaType::fromType<QList<QObject *>>()) {
             const QList<QObject *> &list = qvariant_cast<QList<QObject *> >(value);
 
             for (qsizetype ii = 0; ii < list.count(); ++ii) {
@@ -1414,12 +1416,12 @@ bool QQmlPropertyPrivate::write(
             prop.append(&prop, o);
         }
     } else {
-        Q_ASSERT(variantType != propertyType);
+        Q_ASSERT(variantMetaType != propertyMetaType);
 
         bool ok = false;
         QVariant v;
-        if (variantType == QMetaType::QString)
-            v = QQmlStringConverters::variantFromString(value.toString(), propertyType, &ok);
+        if (variantMetaType == QMetaType::fromType<QString>())
+            v = QQmlStringConverters::variantFromString(value.toString(), propertyMetaType, &ok);
 
         if (!ok) {
             v = value;
@@ -1432,28 +1434,33 @@ bool QQmlPropertyPrivate::write(
             // 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 == QMetaType::Int && propertyType == qMetaTypeId<QList<int> >()) {
+            if (variantMetaType == QMetaType::fromType<int>()
+                    && propertyMetaType == QMetaType::fromType<QList<int>>()) {
                 QList<int> list;
                 list << value.toInt();
                 v = QVariant::fromValue<QList<int> >(list);
                 ok = true;
-            } else if ((variantType == QMetaType::Double || variantType == QMetaType::Int)
-                       && (propertyType == qMetaTypeId<QList<qreal> >())) {
+            } else if ((variantMetaType == QMetaType::fromType<double>()
+                        || variantMetaType == QMetaType::fromType<int>())
+                       && (propertyMetaType == QMetaType::fromType<QList<qreal>>())) {
                 QList<qreal> list;
                 list << value.toReal();
                 v = QVariant::fromValue<QList<qreal> >(list);
                 ok = true;
-            } else if (variantType == QMetaType::Bool && propertyType == qMetaTypeId<QList<bool> >()) {
+            } else if (variantMetaType == QMetaType::fromType<bool>()
+                       && propertyMetaType == QMetaType::fromType<QList<bool>>()) {
                 QList<bool> list;
                 list << value.toBool();
                 v = QVariant::fromValue<QList<bool> >(list);
                 ok = true;
-            } else if (variantType == QMetaType::QString && propertyType == qMetaTypeId<QList<QString> >()) {
+            } else if (variantMetaType == QMetaType::fromType<QString>()
+                       && propertyMetaType == QMetaType::fromType<QList<QString>>()) {
                 QList<QString> list;
                 list << value.toString();
                 v = QVariant::fromValue<QList<QString> >(list);
                 ok = true;
-            } else if (variantType == QMetaType::QString && propertyType == qMetaTypeId<QStringList>()) {
+            } else if (variantMetaType == QMetaType::fromType<QString>()
+                       && propertyMetaType == QMetaType::fromType<QStringList>()) {
                 QStringList list;
                 list << value.toString();
                 v = QVariant::fromValue<QStringList>(list);
@@ -1461,11 +1468,11 @@ bool QQmlPropertyPrivate::write(
             }
         }
 
-        if (!ok && QQmlMetaType::isInterface(propertyType)) {
+        if (!ok && QQmlMetaType::isInterface(propertyMetaType)) {
             auto valueAsQObject = qvariant_cast<QObject *>(value);
 
             if (void *interface = valueAsQObject
-                        ? valueAsQObject->qt_metacast(QQmlMetaType::interfaceIId(propertyType))
+                        ? valueAsQObject->qt_metacast(QQmlMetaType::interfaceIId(propertyMetaType))
                         : nullptr;
                 interface) {
                 // this case can occur when object has an interface type
@@ -1484,14 +1491,16 @@ bool QQmlPropertyPrivate::write(
     return true;
 }
 
-QQmlMetaObject QQmlPropertyPrivate::rawMetaObjectForType(QQmlEnginePrivate *engine, int userType)
+QQmlMetaObject QQmlPropertyPrivate::rawMetaObjectForType(
+            QQmlEnginePrivate *engine, QMetaType metaType)
 {
-    QMetaType metaType(userType);
-    if ((metaType.flags() & QMetaType::PointerToQObject) && metaType.metaObject())
-        return metaType.metaObject();
+    if (metaType.flags() & QMetaType::PointerToQObject) {
+        if (const QMetaObject *metaObject = metaType.metaObject())
+            return metaObject;
+    }
     if (engine)
-        return engine->rawMetaObjectForType(userType);
-    QQmlType type = QQmlMetaType::qmlType(userType);
+        return engine->rawMetaObjectForType(metaType);
+    const QQmlType type = QQmlMetaType::qmlType(metaType);
     if (type.isValid())
         return QQmlMetaObject(type.baseMetaObject());
     return QQmlMetaObject();
diff --git a/src/qml/qml/qqmlproperty_p.h b/src/qml/qml/qqmlproperty_p.h
index c54d066152..46bd54c701 100644
--- a/src/qml/qml/qqmlproperty_p.h
+++ b/src/qml/qml/qqmlproperty_p.h
@@ -102,7 +102,7 @@ public:
     QVariant readValueProperty();
     bool writeValueProperty(const QVariant &, QQmlPropertyData::WriteFlags);
 
-    static QQmlMetaObject rawMetaObjectForType(QQmlEnginePrivate *, int);
+    static QQmlMetaObject rawMetaObjectForType(QQmlEnginePrivate *, QMetaType metaType);
     static bool writeEnumProperty(const QMetaProperty &prop, int idx, QObject *object,
                                   const QVariant &value, int flags);
     static bool writeValueProperty(QObject *,
diff --git a/src/qml/qml/qqmlpropertybinding.cpp b/src/qml/qml/qqmlpropertybinding.cpp
index b1ad3f1767..c8cf0c4d13 100644
--- a/src/qml/qml/qqmlpropertybinding.cpp
+++ b/src/qml/qml/qqmlpropertybinding.cpp
@@ -448,12 +448,12 @@ void QQmlPropertyBinding::bindingErrorCallback(QPropertyBindingPrivate *that)
 
 QUntypedPropertyBinding QQmlTranslationPropertyBinding::create(const QQmlPropertyData *pd, const QQmlRefPointer<QV4::ExecutableCompilationUnit> &compilationUnit, const QV4::CompiledData::Binding *binding)
 {
-    auto translationBinding = [compilationUnit, binding](const QMetaType &metaType, void *dataPtr) -> bool {
+    auto translationBinding = [compilationUnit, binding](QMetaType metaType, void *dataPtr) -> bool {
         // Create a dependency to the uiLanguage
         QJSEnginePrivate::get(compilationUnit->engine)->uiLanguage.value();
 
         QVariant resultVariant(compilationUnit->bindingValueAsString(binding));
-        if (metaType.id() != QMetaType::QString)
+        if (metaType != QMetaType::fromType<QString>())
             resultVariant.convert(metaType);
 
         const bool hasChanged = !metaType.equals(resultVariant.constData(), dataPtr);
diff --git a/src/qml/qml/qqmlpropertycachecreator.cpp b/src/qml/qml/qqmlpropertycachecreator.cpp
index ff607add09..8bd66177a9 100644
--- a/src/qml/qml/qqmlpropertycachecreator.cpp
+++ b/src/qml/qml/qqmlpropertycachecreator.cpp
@@ -130,7 +130,7 @@ QQmlRefPointer<QQmlPropertyCache> QQmlBindingInstantiationContext::instantiating
         if (instantiatingProperty->isQObject()) {
             // rawPropertyCacheForType assumes a given unspecified version means "any version".
             // There is another overload that takes no version, which we shall not use here.
-            return enginePrivate->rawPropertyCacheForType(instantiatingProperty->propType().id(),
+            return enginePrivate->rawPropertyCacheForType(instantiatingProperty->propType(),
                                                           instantiatingProperty->typeVersion());
         } else if (const QMetaObject *vtmo = QQmlMetaType::metaObjectForValueType(instantiatingProperty->propType())) {
             return enginePrivate->cache(vtmo, instantiatingProperty->typeVersion());
diff --git a/src/qml/qml/qqmlpropertycachecreator_p.h b/src/qml/qml/qqmlpropertycachecreator_p.h
index 0a5e642c9f..55dd6d2728 100644
--- a/src/qml/qml/qqmlpropertycachecreator_p.h
+++ b/src/qml/qml/qqmlpropertycachecreator_p.h
@@ -919,7 +919,7 @@ inline QQmlError QQmlPropertyCacheAliasCreator<ObjectContainer>::propertyDataFor
         if (!QQmlMetaType::isValueType(targetProperty->propType()) && valueTypeIndex != -1) {
             // deep alias property
             *type = targetProperty->propType();
-            targetCache = enginePriv->propertyCacheForType(type->id());
+            targetCache = enginePriv->propertyCacheForType(*type);
             Q_ASSERT(targetCache);
             targetProperty = targetCache->property(valueTypeIndex);
 
diff --git a/src/qml/qml/qqmlpropertyvalidator.cpp b/src/qml/qml/qqmlpropertyvalidator.cpp
index f1826b2f1c..72e0275a53 100644
--- a/src/qml/qml/qqmlpropertyvalidator.cpp
+++ b/src/qml/qml/qqmlpropertyvalidator.cpp
@@ -49,9 +49,9 @@
 
 QT_BEGIN_NAMESPACE
 
-static bool isPrimitiveType(int typeId)
+static bool isPrimitiveType(QMetaType metaType)
 {
-    switch (typeId) {
+    switch (metaType.id()) {
 #define HANDLE_PRIMITIVE(Type, id, T) \
     case QMetaType::Type:
 QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(HANDLE_PRIMITIVE);
@@ -309,21 +309,21 @@ QVector<QQmlError> QQmlPropertyValidator::validateObject(
                         return recordError(binding->location, tr("Invalid grouped property access"));
                     }
                 } else {
-                    const int typeId = pd->propType().id();
-                    if (isPrimitiveType(typeId)) {
+                    const QMetaType type = pd->propType();
+                    if (isPrimitiveType(type)) {
                         return recordError(
                                     binding->location,
                                     tr("Invalid grouped property access: Property \"%1\" with primitive type \"%2\".")
                                         .arg(name)
-                                        .arg(QString::fromLatin1(QMetaType(typeId).name()))
+                                        .arg(QString::fromUtf8(type.name()))
                                     );
                     }
 
-                    if (!enginePrivate->propertyCacheForType(typeId)) {
+                    if (!enginePrivate->propertyCacheForType(type)) {
                         return recordError(binding->location,
                                            tr("Invalid grouped property access: Property \"%1\" with type \"%2\", which is not a value type")
                                            .arg(name)
-                                           .arg(QString::fromLatin1(QMetaType(typeId).name()))
+                                           .arg(QString::fromUtf8(type.name()))
                                           );
                     }
                 }
@@ -586,7 +586,7 @@ QQmlError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache *prope
         };
         QVariant result;
         if (!QQml_valueTypeProvider()->createValueType(
-                    property->propType().id(),
+                    property->propType(),
                     compilationUnit->bindingValueAsString(binding), result)) {
             return warnOrError(tr("Invalid property assignment: %1 expected")
                                .arg(typeName()));
@@ -647,7 +647,7 @@ QQmlError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache *prope
     Returns true if from can be assigned to a (QObject) property of type
     to.
 */
-bool QQmlPropertyValidator::canCoerce(int to, QQmlPropertyCache *fromMo) const
+bool QQmlPropertyValidator::canCoerce(QMetaType to, QQmlPropertyCache *fromMo) const
 {
     QQmlPropertyCache *toMo = enginePrivate->rawPropertyCacheForType(to);
 
@@ -657,7 +657,7 @@ bool QQmlPropertyValidator::canCoerce(int to, QQmlPropertyCache *fromMo) const
         // only occurs after the whole file has been validated
         // Therefore we need to check the ICs here
         for (const auto& icDatum : compilationUnit->inlineComponentData) {
-            if (icDatum.typeIds.id.id() == to) {
+            if (icDatum.typeIds.id == to) {
                 toMo = compilationUnit->propertyCaches.at(icDatum.objectIndex);
                 break;
             }
@@ -718,7 +718,7 @@ QQmlError QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *propert
         return noError;
     }
 
-    const int propType = property->propType().id();
+    const QMetaType propType = property->propType();
     const auto rhsType = [&]() {
         return stringAt(compilationUnit->objectAt(binding->value.objectIndex)
                         ->inheritedTypeNameIndex);
@@ -728,11 +728,12 @@ QQmlError QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *propert
         // Can only check at instantiation time if the created sub-object successfully casts to the
         // target interface.
         return noError;
-    } else if (propType == QMetaType::QVariant || propType == qMetaTypeId<QJSValue>()) {
+    } else if (propType == QMetaType::fromType<QVariant>()
+               || propType == QMetaType::fromType<QJSValue>()) {
         // We can convert everything to QVariant :)
         return noError;
     } else if (property->isQList()) {
-        const int listType = QQmlMetaType::listType(property->propType()).id();
+        const QMetaType listType = QQmlMetaType::listType(property->propType());
         if (!QQmlMetaType::isInterface(listType)) {
             QQmlPropertyCache *source = propertyCaches.at(binding->value.objectIndex);
             if (!canCoerce(listType, source)) {
@@ -748,7 +749,7 @@ QQmlError QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *propert
                                                       .arg(rhsType())
                                                       .arg(propertyName)
                                                       .arg(typeName));
-    } else if (propType == qMetaTypeId<QQmlScriptString>()) {
+    } else if (propType == QMetaType::fromType<QQmlScriptString>()) {
         return qQmlCompileError(binding->valueLocation, tr("Invalid property assignment: script expected"));
     } else if (QQmlMetaType::isValueType(property->propType())) {
         return qQmlCompileError(binding->location, tr("Cannot assign value of type \"%1\" to property \"%2\", expecting an object")
diff --git a/src/qml/qml/qqmlpropertyvalidator_p.h b/src/qml/qml/qqmlpropertyvalidator_p.h
index 281472981c..0b830dd107 100644
--- a/src/qml/qml/qqmlpropertyvalidator_p.h
+++ b/src/qml/qml/qqmlpropertyvalidator_p.h
@@ -79,7 +79,7 @@ private:
             QQmlPropertyData *property, const QString &propertyName,
             const QV4::CompiledData::Binding *binding) const;
 
-    bool canCoerce(int to, QQmlPropertyCache *fromMo) const;
+    bool canCoerce(QMetaType to, QQmlPropertyCache *fromMo) const;
 
     Q_REQUIRED_RESULT QVector<QQmlError> recordError(
             const QV4::CompiledData::Location &location, const QString &description) const;
diff --git a/src/qml/qml/qqmlstringconverters.cpp b/src/qml/qml/qqmlstringconverters.cpp
index 9c2e715a6a..d46f38aba1 100644
--- a/src/qml/qml/qqmlstringconverters.cpp
+++ b/src/qml/qml/qqmlstringconverters.cpp
@@ -48,9 +48,9 @@
 
 QT_BEGIN_NAMESPACE
 
-QVariant QQmlStringConverters::variantFromString(const QString &s, int preferredType, bool *ok)
+QVariant QQmlStringConverters::variantFromString(const QString &s, QMetaType preferredType, bool *ok)
 {
-    switch (preferredType) {
+    switch (preferredType.id()) {
     case QMetaType::Int:
         return QVariant(int(qRound(s.toDouble(ok))));
     case QMetaType::UInt:
diff --git a/src/qml/qml/qqmlstringconverters_p.h b/src/qml/qml/qqmlstringconverters_p.h
index 52c602c18e..5944241570 100644
--- a/src/qml/qml/qqmlstringconverters_p.h
+++ b/src/qml/qml/qqmlstringconverters_p.h
@@ -66,7 +66,7 @@ class QByteArray;
 
 namespace QQmlStringConverters
 {
-    Q_QML_PRIVATE_EXPORT QVariant variantFromString(const QString &, int preferredType, bool *ok = nullptr);
+    Q_QML_PRIVATE_EXPORT QVariant variantFromString(const QString &, QMetaType preferredType, bool *ok = nullptr);
 
     Q_QML_PRIVATE_EXPORT QVariant colorFromString(const QString &, bool *ok = nullptr);
     Q_QML_PRIVATE_EXPORT unsigned rgbaFromString(const QString &, bool *ok = nullptr);
diff --git a/src/qml/qml/qqmltypecompiler.cpp b/src/qml/qml/qqmltypecompiler.cpp
index 7ca85d3f7f..e8384d19cb 100644
--- a/src/qml/qml/qqmltypecompiler.cpp
+++ b/src/qml/qml/qqmltypecompiler.cpp
@@ -807,8 +807,8 @@ void QQmlComponentAndAliasResolver::findAndRegisterImplicitComponents(const QmlI
         // Otherwise, make sure we look up by metaobject.
         // TODO: Is this correct?
         QQmlPropertyCache *pc = pd->typeVersion().hasMinorVersion()
-                ? enginePrivate->rawPropertyCacheForType(pd->propType().id(), pd->typeVersion())
-                : enginePrivate->rawPropertyCacheForType(pd->propType().id());
+                ? enginePrivate->rawPropertyCacheForType(pd->propType(), pd->typeVersion())
+                : enginePrivate->rawPropertyCacheForType(pd->propType());
         const QMetaObject *mo = pc ? pc->firstCppMetaObject() : nullptr;
         while (mo) {
             if (mo == &QQmlComponent::staticMetaObject)
diff --git a/src/qml/qml/qqmltypedata.cpp b/src/qml/qml/qqmltypedata.cpp
index ab2d83e57a..a4416d1073 100644
--- a/src/qml/qml/qqmltypedata.cpp
+++ b/src/qml/qml/qqmltypedata.cpp
@@ -936,11 +936,11 @@ QQmlError QQmlTypeData::buildTypeResolutionCaches(
                 if (qmlType.isValid()) {
                     // this is required for inline components in singletons
                     auto type = qmlType.lookupInlineComponentById(qmlType.inlineComponentId()).typeId();
-                    auto typeID = type.isValid() ? type.id() : -1;
-                    auto exUnit = engine->obtainExecutableCompilationUnit(typeID);
+                    auto exUnit = engine->obtainExecutableCompilationUnit(
+                                type.isValid() ? type.id() : -1);
                     if (exUnit) {
                         ref->setCompilationUnit(exUnit);
-                        ref->setTypePropertyCache(engine->propertyCacheForType(typeID));
+                        ref->setTypePropertyCache(engine->propertyCacheForType(type));
                     }
                 }
             } else {
diff --git a/src/qml/qml/qqmltypewrapper.cpp b/src/qml/qml/qqmltypewrapper.cpp
index c4d2d82a50..1930c15e0d 100644
--- a/src/qml/qml/qqmltypewrapper.cpp
+++ b/src/qml/qml/qqmltypewrapper.cpp
@@ -412,9 +412,9 @@ ReturnedValue QQmlTypeWrapper::virtualInstanceOf(const Object *typeObject, const
 
         QQmlRefPointer<QQmlTypeData> td = qenginepriv->typeLoader.getType(typeWrapper->d()->type().sourceUrl());
         ExecutableCompilationUnit *cu = td->compilationUnit();
-        myQmlType = qenginepriv->metaObjectForType(cu->typeIds.id.id());
+        myQmlType = qenginepriv->metaObjectForType(cu->typeIds.id);
     } else {
-        myQmlType = qenginepriv->metaObjectForType(myTypeId.id());
+        myQmlType = qenginepriv->metaObjectForType(myTypeId);
     }
 
     const QMetaObject *theirType = wrapperObject->metaObject();
diff --git a/src/qml/qml/qqmlvaluetype.cpp b/src/qml/qml/qqmlvaluetype.cpp
index d03cf04fa6..4b9653d8e9 100644
--- a/src/qml/qml/qqmlvaluetype.cpp
+++ b/src/qml/qml/qqmlvaluetype.cpp
@@ -47,8 +47,8 @@
 
 QT_BEGIN_NAMESPACE
 
-QQmlValueType::QQmlValueType(int typeId, const QMetaObject *gadgetMetaObject)
-    : metaType(typeId)
+QQmlValueType::QQmlValueType(QMetaType type, const QMetaObject *gadgetMetaObject)
+    : metaType(type)
 {
     QMetaObjectBuilder builder(gadgetMetaObject);
     dynamicMetaObject = builder.toMetaObject();
diff --git a/src/qml/qml/qqmlvaluetype_p.h b/src/qml/qml/qqmlvaluetype_p.h
index 09dd458a9d..c006fc7532 100644
--- a/src/qml/qml/qqmlvaluetype_p.h
+++ b/src/qml/qml/qqmlvaluetype_p.h
@@ -71,7 +71,7 @@ class Q_QML_PRIVATE_EXPORT QQmlValueType : public QAbstractDynamicMetaObject
 {
 public:
     QQmlValueType() : metaType(QMetaType::UnknownType) {}
-    QQmlValueType(int userType, const QMetaObject *metaObject);
+    QQmlValueType(QMetaType type, const QMetaObject *metaObject);
     ~QQmlValueType();
 
     void *create() const { return metaType.create(); }
diff --git a/src/qml/qml/qqmlvmemetaobject.cpp b/src/qml/qml/qqmlvmemetaobject.cpp
index e7248b038a..f7c9fbbbfb 100644
--- a/src/qml/qml/qqmlvmemetaobject.cpp
+++ b/src/qml/qml/qqmlvmemetaobject.cpp
@@ -250,7 +250,7 @@ void QQmlVMEMetaObjectEndpoint::tryConnect()
             if (pd && valueTypeIndex != -1 && !QQmlMetaType::valueType(pd->propType())) {
                 // deep alias
                 QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(metaObject->compilationUnit->engine->qmlEngine());
-                auto const *newPropertyCache = enginePriv->propertyCacheForType(pd->propType().id());
+                auto const *newPropertyCache = enginePriv->propertyCacheForType(pd->propType());
                 void *argv[1] = { &target };
                 QMetaObject::metacall(target, QMetaObject::ReadProperty, coreIndex, argv);
                 Q_ASSERT(newPropertyCache);
@@ -708,7 +708,8 @@ int QQmlVMEMetaObject::metaCall(QObject *o, QMetaObject::Call c, int _id, void *
                         ? nullptr
                         : QQmlEnginePrivate::get(ctxt->engine());
 
-                const int fallbackMetaType = QQmlPropertyCacheCreatorBase::metaTypeForPropertyType(t).id();
+                const QMetaType fallbackMetaType
+                        = QQmlPropertyCacheCreatorBase::metaTypeForPropertyType(t);
 
                 if (c == QMetaObject::ReadProperty) {
                     switch (t) {
@@ -750,12 +751,13 @@ int QQmlVMEMetaObject::metaCall(QObject *o, QMetaObject::Call c, int _id, void *
                     case QV4::CompiledData::BuiltinType::Vector4D:
                     case QV4::CompiledData::BuiltinType::Matrix4x4:
                     case QV4::CompiledData::BuiltinType::Quaternion:
-                        Q_ASSERT(fallbackMetaType != QMetaType::UnknownType);
+                        Q_ASSERT(fallbackMetaType.isValid());
                         if (QV4::MemberData *md = propertyAndMethodStorageAsMemberData()) {
                             QVariant propertyAsVariant;
                             if (const QV4::VariantObject *v = (md->data() + id)->as<QV4::VariantObject>())
                                 propertyAsVariant = v->d()->data();
-                            QQml_valueTypeProvider()->readValueType(propertyAsVariant, a[0], fallbackMetaType);
+                            QQml_valueTypeProvider()->readValueType(
+                                        fallbackMetaType, propertyAsVariant, a[0]);
                         }
                         break;
                     case QV4::CompiledData::BuiltinType::Var:
@@ -855,7 +857,7 @@ int QQmlVMEMetaObject::metaCall(QObject *o, QMetaObject::Call c, int _id, void *
                     case QV4::CompiledData::BuiltinType::Vector4D:
                     case QV4::CompiledData::BuiltinType::Matrix4x4:
                     case QV4::CompiledData::BuiltinType::Quaternion:
-                        Q_ASSERT(fallbackMetaType != QMetaType::UnknownType);
+                        Q_ASSERT(fallbackMetaType.isValid());
                         if (QV4::MemberData *md = propertyAndMethodStorageAsMemberData()) {
                             const QV4::VariantObject *v = (md->data() + id)->as<QV4::VariantObject>();
                             if (!v) {
diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
index f15c3aa201..388b6153fd 100644
--- a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
+++ b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
@@ -294,8 +294,10 @@ QVariant QtObject::font(const QJSValue &fontSpecifier) const
 
     {
         QVariant v;
-        if (QQml_valueTypeProvider()->createValueType(QMetaType::QFont, fontSpecifier, v))
+        if (QQml_valueTypeProvider()->createValueType(
+                    QMetaType(QMetaType::QFont), fontSpecifier, v)) {
             return v;
+        }
     }
 
     v4Engine()->throwError(QStringLiteral("Qt.font(): Invalid argument: "
@@ -323,7 +325,7 @@ void addParameters(QJSEngine *e, QJSValue &result, int i, T parameter, Others...
 }
 
 template<typename ...T>
-static QVariant createValueType(QJSEngine *e, QMetaType::Type type, T... parameters)
+static QVariant createValueType(QJSEngine *e, QMetaType type, T... parameters)
 {
     if (!e)
         return QVariant();
@@ -341,7 +343,7 @@ static QVariant createValueType(QJSEngine *e, QMetaType::Type type, T... paramet
 */
 QVariant QtObject::vector2d(double x, double y) const
 {
-    return createValueType(jsEngine(), QMetaType::QVector2D, x, y);
+    return createValueType(jsEngine(), QMetaType(QMetaType::QVector2D), x, y);
 }
 
 /*!
@@ -351,7 +353,7 @@ QVariant QtObject::vector2d(double x, double y) const
 */
 QVariant QtObject::vector3d(double x, double y, double z) const
 {
-    return createValueType(jsEngine(), QMetaType::QVector3D, x, y, z);
+    return createValueType(jsEngine(), QMetaType(QMetaType::QVector3D), x, y, z);
 }
 
 /*!
@@ -361,7 +363,7 @@ QVariant QtObject::vector3d(double x, double y, double z) const
 */
 QVariant QtObject::vector4d(double x, double y, double z, double w) const
 {
-    return createValueType(jsEngine(), QMetaType::QVector4D, x, y, z, w);
+    return createValueType(jsEngine(), QMetaType(QMetaType::QVector4D), x, y, z, w);
 }
 
 /*!
@@ -371,7 +373,7 @@ QVariant QtObject::vector4d(double x, double y, double z, double w) const
 */
 QVariant QtObject::quaternion(double scalar, double x, double y, double z) const
 {
-    return createValueType(jsEngine(), QMetaType::QQuaternion, scalar, x, y, z);
+    return createValueType(jsEngine(), QMetaType(QMetaType::QQuaternion), scalar, x, y, z);
 }
 
 /*!
@@ -398,7 +400,8 @@ QVariant QtObject::quaternion(double scalar, double x, double y, double z) const
 QVariant QtObject::matrix4x4() const
 {
     QVariant variant;
-    QQml_valueTypeProvider()->createValueType(QMetaType::QMatrix4x4, QJSValue(), variant);
+    QQml_valueTypeProvider()->createValueType(
+                QMetaType(QMetaType::QMatrix4x4), QJSValue(), variant);
     return variant;
 }
 
@@ -406,7 +409,7 @@ QVariant QtObject::matrix4x4(const QJSValue &value) const
 {
     if (value.isObject()) {
         QVariant v;
-        if (QQml_valueTypeProvider()->createValueType(QMetaType::QMatrix4x4, value, v))
+        if (QQml_valueTypeProvider()->createValueType(QMetaType(QMetaType::QMatrix4x4), value, v))
             return v;
     }
 
@@ -420,7 +423,7 @@ QVariant QtObject::matrix4x4(double m11, double m12, double m13, double m14,
                              double m31, double m32, double m33, double m34,
                              double m41, double m42, double m43, double m44) const
 {
-    return createValueType(jsEngine(), QMetaType::QMatrix4x4,
+    return createValueType(jsEngine(), QMetaType(QMetaType::QMatrix4x4),
                            m11, m12, m13, m14, m21, m22, m23, m24,
                            m31, m32, m33, m34, m41, m42, m43, m44);
 }
diff --git a/src/qmlworkerscript/qv4serialize.cpp b/src/qmlworkerscript/qv4serialize.cpp
index c7e03f36ef..39adaa715b 100644
--- a/src/qmlworkerscript/qv4serialize.cpp
+++ b/src/qmlworkerscript/qv4serialize.cpp
@@ -435,7 +435,7 @@ ReturnedValue Serialize::deserialize(const char *&data, ExecutionEngine *engine)
             array->arrayPut(ii, value);
         }
         array->setArrayLengthUnchecked(seqLength);
-        QVariant seqVariant = QV4::SequencePrototype::toVariant(array, sequenceType, &succeeded);
+        QVariant seqVariant = QV4::SequencePrototype::toVariant(array, QMetaType(sequenceType), &succeeded);
         return QV4::SequencePrototype::fromVariant(engine, seqVariant, &succeeded);
     }
 #endif
diff --git a/src/quick/util/qquickanimation.cpp b/src/quick/util/qquickanimation.cpp
index 28cea4b93d..d8ac42f9e6 100644
--- a/src/quick/util/qquickanimation.cpp
+++ b/src/quick/util/qquickanimation.cpp
@@ -1978,7 +1978,7 @@ void QQuickPropertyAnimationPrivate::convertVariant(QVariant &variant, QMetaType
     case QMetaType::QVector3D:
         {
         bool ok = false;
-        variant = QQmlStringConverters::variantFromString(variant.toString(), type.id(), &ok);
+        variant = QQmlStringConverters::variantFromString(variant.toString(), type, &ok);
         }
         break;
     default: