QML engine: Use QMetaType instead of metatype-id in propertydata

We don't want to convert back and forth between QMetaTypes and ids. This
change is the first step towards using QMetaType directly everywhere.
By reordering the members of QQmlPropertyData to avoid a gap caused by
alignment, we can replace the typeid int with a QMetaType without
requiring more space.
There are still a few places left using metatype ids, notably the value
type logic.

Task-number: QTBUG-82931
Change-Id: Ic38f38d10c71ed20655877976c9cb5ee3cbe2d77
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>

18 files changed, 193 insertions, 186 deletions

diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index a4f676ef66..22c4863bde 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -132,42 +132,43 @@ static QV4::ReturnedValue loadProperty(QV4::ExecutionEngine *v4, QObject *object
 {
     Q_ASSERT(!property.isFunction());
     QV4::Scope scope(v4);
+    const int propType = property.propType().id();
 
     if (property.isQObject()) {
         QObject *rv = nullptr;
         property.readProperty(object, &rv);
         return QV4::QObjectWrapper::wrap(v4, rv);
     } else if (property.isQList()) {
-        return QmlListWrapper::create(v4, object, property.coreIndex(), property.propType());
-    } else if (property.propType() == QMetaType::QReal) {
+        return QmlListWrapper::create(v4, object, property.coreIndex(), property.propType().id());
+    } else if (propType == QMetaType::QReal) {
         qreal v = 0;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (property.propType() == QMetaType::Int || property.isEnum()) {
+    } else if (propType == QMetaType::Int || property.isEnum()) {
         int v = 0;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (property.propType() == QMetaType::Bool) {
+    } else if (propType == QMetaType::Bool) {
         bool v = false;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (property.propType() == QMetaType::QString) {
+    } else if (propType == QMetaType::QString) {
         QString v;
         property.readProperty(object, &v);
         return v4->newString(v)->asReturnedValue();
-    } else if (property.propType() == QMetaType::UInt) {
+    } else if (propType == QMetaType::UInt) {
         uint v = 0;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (property.propType() == QMetaType::Float) {
+    } else if (propType == QMetaType::Float) {
         float v = 0;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (property.propType() == QMetaType::Double) {
+    } else if (propType == QMetaType::Double) {
         double v = 0;
         property.readProperty(object, &v);
         return QV4::Encode(v);
-    } else if (property.propType() == qMetaTypeId<QJSValue>()) {
+    } else if (propType == qMetaTypeId<QJSValue>()) {
         QJSValue v;
         property.readProperty(object, &v);
         return QJSValuePrivate::convertToReturnedValue(v4, v);
@@ -181,26 +182,26 @@ static QV4::ReturnedValue loadProperty(QV4::ExecutionEngine *v4, QObject *object
         }
 
         return scope.engine->fromVariant(v);
-    } else if (QQmlValueTypeFactory::isValueType(property.propType())) {
-        if (const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(property.propType()))
-            return QV4::QQmlValueTypeWrapper::create(v4, object, property.coreIndex(), valueTypeMetaObject, property.propType());
+    } else if (QQmlValueTypeFactory::isValueType(propType)) {
+        if (const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(propType))
+            return QV4::QQmlValueTypeWrapper::create(v4, object, property.coreIndex(), valueTypeMetaObject, propType);
     } 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, property.propType(), object, property.coreIndex(), !property.isWritable(), &succeeded));
+        QV4::ScopedValue retn(scope, QV4::SequencePrototype::newSequence(v4, propType, object, property.coreIndex(), !property.isWritable(), &succeeded));
         if (succeeded)
             return retn->asReturnedValue();
 #endif
     }
 
-    if (property.propType() == QMetaType::UnknownType) {
+    if (propType == QMetaType::UnknownType) {
         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());
         return QV4::Encode::undefined();
     } else {
-        QVariant v(QMetaType(property.propType()), (void *)nullptr);
+        QVariant v(property.propType(), (void *)nullptr);
         property.readProperty(object, v.data());
         return scope.engine->fromVariant(v);
     }
@@ -461,7 +462,7 @@ void QObjectWrapper::setProperty(ExecutionEngine *engine, QObject *object, QQmlP
     QV4::ScopedFunctionObject f(scope, value);
     if (f) {
         if (!f->isBinding()) {
-            if (!property->isVarProperty() && property->propType() != qMetaTypeId<QJSValue>()) {
+            if (!property->isVarProperty() && property->propType().id() != qMetaTypeId<QJSValue>()) {
                 // assigning a JS function to a non var or QJSValue property or is not allowed.
                 QString error = QLatin1String("Cannot assign JavaScript function to ");
                 if (!QMetaType(property->propType()).name())
@@ -520,42 +521,43 @@ void QObjectWrapper::setProperty(ExecutionEngine *engine, QObject *object, QQmlP
     void *argv[] = { &o, 0, &status, &flags }; \
     QMetaObject::metacall(object, QMetaObject::WriteProperty, property->coreIndex(), argv);
 
+    const int propType = property->propType().id();
     if (value.isNull() && property->isQObject()) {
         PROPERTY_STORE(QObject*, nullptr);
     } else if (value.isUndefined() && property->isResettable()) {
         void *a[] = { nullptr };
         QMetaObject::metacall(object, QMetaObject::ResetProperty, property->coreIndex(), a);
-    } else if (value.isUndefined() && property->propType() == qMetaTypeId<QVariant>()) {
+    } else if (value.isUndefined() && propType == qMetaTypeId<QVariant>()) {
         PROPERTY_STORE(QVariant, QVariant());
-    } else if (value.isUndefined() && property->propType() == QMetaType::QJsonValue) {
+    } else if (value.isUndefined() && propType == QMetaType::QJsonValue) {
         PROPERTY_STORE(QJsonValue, QJsonValue(QJsonValue::Undefined));
-    } else if (!newBinding && property->propType() == qMetaTypeId<QJSValue>()) {
+    } else if (!newBinding && propType == qMetaTypeId<QJSValue>()) {
         PROPERTY_STORE(QJSValue, QJSValuePrivate::fromReturnedValue(value.asReturnedValue()));
-    } else if (value.isUndefined() && property->propType() != qMetaTypeId<QQmlScriptString>()) {
+    } else if (value.isUndefined() && propType != qMetaTypeId<QQmlScriptString>()) {
         QString error = QLatin1String("Cannot assign [undefined] to ");
-        if (!QMetaType(property->propType()).name())
+        if (!property->propType().name())
             error += QLatin1String("[unknown property type]");
         else
-            error += QLatin1String(QMetaType(property->propType()).name());
+            error += QLatin1String(property->propType().name());
         scope.engine->throwError(error);
         return;
     } else if (value.as<FunctionObject>()) {
         // this is handled by the binding creation above
-    } else if (property->propType() == QMetaType::Int && value.isNumber()) {
+    } else if (property->propType().id() == QMetaType::Int && value.isNumber()) {
         PROPERTY_STORE(int, value.asDouble());
-    } else if (property->propType() == QMetaType::QReal && value.isNumber()) {
+    } else if (propType == QMetaType::QReal && value.isNumber()) {
         PROPERTY_STORE(qreal, qreal(value.asDouble()));
-    } else if (property->propType() == QMetaType::Float && value.isNumber()) {
+    } else if (propType == QMetaType::Float && value.isNumber()) {
         PROPERTY_STORE(float, float(value.asDouble()));
-    } else if (property->propType() == QMetaType::Double && value.isNumber()) {
+    } else if (propType == QMetaType::Double && value.isNumber()) {
         PROPERTY_STORE(double, double(value.asDouble()));
-    } else if (property->propType() == QMetaType::QString && value.isString()) {
+    } else if (propType == QMetaType::QString && value.isString()) {
         PROPERTY_STORE(QString, value.toQStringNoThrow());
     } else if (property->isVarProperty()) {
         QQmlVMEMetaObject *vmemo = QQmlVMEMetaObject::get(object);
         Q_ASSERT(vmemo);
         vmemo->setVMEProperty(property->coreIndex(), value);
-    } else if (property->propType() == qMetaTypeId<QQmlScriptString>() && (value.isUndefined() || value.isPrimitive())) {
+    } else if (propType == qMetaTypeId<QQmlScriptString>() && (value.isUndefined() || value.isPrimitive())) {
         QQmlScriptString ss(value.toQStringNoThrow(), nullptr /* context */, object);
         if (value.isNumber()) {
             ss.d->numberValue = value.toNumber();
@@ -570,7 +572,7 @@ void QObjectWrapper::setProperty(ExecutionEngine *engine, QObject *object, QQmlP
         if (property->isQList())
             v = scope.engine->toVariant(value, qMetaTypeId<QList<QObject *> >());
         else
-            v = scope.engine->toVariant(value, property->propType());
+            v = scope.engine->toVariant(value, propType);
 
         QQmlRefPointer<QQmlContextData> callingQmlContext = scope.engine->callingQmlContext();
         if (!QQmlPropertyPrivate::write(object, *property, v, callingQmlContext)) {
diff --git a/src/qml/qml/qqmlbinding.cpp b/src/qml/qml/qqmlbinding.cpp
index 6378c60a5c..0101607b4f 100644
--- a/src/qml/qml/qqmlbinding.cpp
+++ b/src/qml/qml/qqmlbinding.cpp
@@ -292,7 +292,7 @@ protected:
 
         int propertyType = StaticPropType; // If the binding is specialized to a type, the if and switch below will be constant-folded.
         if (propertyType == QMetaType::UnknownType)
-            propertyType = pd->propType();
+            propertyType = pd->propType().id();
 
         if (Q_LIKELY(!isUndefined && !vpd.isValid())) {
             switch (propertyType) {
@@ -322,7 +322,7 @@ protected:
                 break;
             default:
                 if (const QV4::QQmlValueTypeWrapper *vtw = result.as<const QV4::QQmlValueTypeWrapper>()) {
-                    if (vtw->d()->valueType()->metaType.id() == pd->propType()) {
+                    if (vtw->d()->valueType()->metaType == pd->propType()) {
                         return vtw->write(m_target.data(), pd->coreIndex());
                     }
                 }
@@ -372,7 +372,7 @@ public:
         QQmlPropertyData vpd;
         getPropertyData(&pd, &vpd);
         Q_ASSERT(pd);
-        if (pd->propType() == QMetaType::QString) {
+        if (pd->propType().id() == QMetaType::QString) {
             doStore(result, pd, flags);
         } else {
             QV4::ScopedString value(scope, scope.engine->newString(result));
@@ -413,7 +413,7 @@ Q_NEVER_INLINE bool QQmlBinding::slowWrite(const QQmlPropertyData &core,
     QQmlEngine *qmlEngine = engine();
     QV4::ExecutionEngine *v4engine = qmlEngine->handle();
 
-    int type = valueTypeData.isValid() ? valueTypeData.propType() : core.propType();
+    const int type = valueTypeData.isValid() ? valueTypeData.propType().id() : core.propType().id();
 
     QQmlJavaScriptExpression::DeleteWatcher watcher(this);
 
@@ -425,7 +425,7 @@ Q_NEVER_INLINE bool QQmlBinding::slowWrite(const QQmlPropertyData &core,
         value = v4engine->toVariant(result, qMetaTypeId<QList<QObject *> >());
     } else if (result.isNull() && core.isQObject()) {
         value = QVariant::fromValue((QObject *)nullptr);
-    } else if (core.propType() == qMetaTypeId<QList<QUrl> >()) {
+    } else if (core.propType().id() == qMetaTypeId<QList<QUrl> >()) {
         value = QQmlPropertyPrivate::urlSequence(v4engine->toVariant(result, qMetaTypeId<QList<QUrl>>()));
     } else if (!isVarProperty && type != qMetaTypeId<QJSValue>()) {
         value = v4engine->toVariant(result, type);
@@ -630,11 +630,11 @@ void QQmlBinding::getPropertyData(QQmlPropertyData **propertyData, QQmlPropertyD
     Q_ASSERT(*propertyData);
 
     if (Q_UNLIKELY(m_targetIndex.hasValueTypeIndex() && valueTypeData)) {
-        const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType((*propertyData)->propType());
+        const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType((*propertyData)->propType().id());
         Q_ASSERT(valueTypeMetaObject);
         QMetaProperty vtProp = valueTypeMetaObject->property(m_targetIndex.valueTypeIndex());
         valueTypeData->setFlags(QQmlPropertyData::flagsForProperty(vtProp));
-        valueTypeData->setPropType(vtProp.userType());
+        valueTypeData->setPropType(vtProp.metaType());
         valueTypeData->setCoreIndex(m_targetIndex.valueTypeIndex());
     }
 }
@@ -736,9 +736,9 @@ protected:
 QQmlBinding *QQmlBinding::newBinding(QQmlEnginePrivate *engine, const QQmlPropertyData *property)
 {
     if (property && property->isQObject())
-        return new QObjectPointerBinding(engine, property->propType());
+        return new QObjectPointerBinding(engine, property->propType().id());
 
-    const int type = property ? property->propType() : QMetaType::UnknownType;
+    const int type = property ? property->propType().id() : QMetaType::UnknownType;
 
     if (type == qMetaTypeId<QQmlBinding *>()) {
         return new QQmlBindingBinding;
diff --git a/src/qml/qml/qqmllist.cpp b/src/qml/qml/qqmllist.cpp
index 51499f816d..3b5b1fbc60 100644
--- a/src/qml/qml/qqmllist.cpp
+++ b/src/qml/qml/qqmllist.cpp
@@ -141,13 +141,13 @@ QQmlListReference::QQmlListReference(QObject *object, const char *property, QQml
 
     QQmlEnginePrivate *p = engine?QQmlEnginePrivate::get(engine):nullptr;
 
-    int listType = p?p->listType(data->propType()):QQmlMetaType::listType(data->propType());
+    int listType = p?p->listType(data->propType().id()):QQmlMetaType::listType(data->propType().id());
     if (listType == -1) return;
 
     d = new QQmlListReferencePrivate;
     d->object = object;
     d->elementType = p ? p->rawMetaObjectForType(listType) : QQmlMetaType::qmlType(listType).baseMetaObject();
-    d->propertyType = data->propType();
+    d->propertyType = data->propType().id();
 
     void *args[] = { &d->property, nullptr };
     QMetaObject::metacall(object, QMetaObject::ReadProperty, data->coreIndex(), args);
diff --git a/src/qml/qml/qqmlmetaobject.cpp b/src/qml/qml/qqmlmetaobject.cpp
index 84a906b4f9..89c08f3841 100644
--- a/src/qml/qml/qqmlmetaobject.cpp
+++ b/src/qml/qml/qqmlmetaobject.cpp
@@ -139,32 +139,32 @@ int QQmlMetaObject::methodReturnType(const QQmlPropertyData &data, QByteArray *u
 {
     Q_ASSERT(_m && data.coreIndex() >= 0);
 
-    int type = data.propType();
+    QMetaType type = data.propType();
 
     const char *propTypeName = nullptr;
 
-    if (type == QMetaType::UnknownType) {
+    if (!type.isValid()) {
         // Find the return type name from the method info
         QMetaMethod m = _m->method(data.coreIndex());
 
-        type = m.returnType();
+        type = m.returnMetaType();
         propTypeName = m.typeName();
     }
 
-    if (QMetaType(type).sizeOf() <= qsizetype(sizeof(int))) {
-        if (QMetaType(type).flags() & QMetaType::IsEnumeration)
+    if (type.sizeOf() <= qsizetype(sizeof(int))) {
+        if (type.flags() & QMetaType::IsEnumeration)
             return QMetaType::Int;
 
         if (isNamedEnumerator(_m, propTypeName))
             return QMetaType::Int;
 
-        if (type == QMetaType::UnknownType) {
+        if (!type.isValid()) {
             if (unknownTypeError)
                 *unknownTypeError = propTypeName;
         }
     } // else we know that it's a known type, as sizeOf(UnknownType) == 0
 
-    return type;
+    return type.id();
 }
 
 int *QQmlMetaObject::methodParameterTypes(int index, ArgTypeStorage *argStorage,
diff --git a/src/qml/qml/qqmlobjectcreator.cpp b/src/qml/qml/qqmlobjectcreator.cpp
index 43c639ce8d..21e845ccdb 100644
--- a/src/qml/qml/qqmlobjectcreator.cpp
+++ b/src/qml/qml/qqmlobjectcreator.cpp
@@ -346,7 +346,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     QQmlPropertyData::WriteFlags propertyWriteFlags = QQmlPropertyData::BypassInterceptor | QQmlPropertyData::RemoveBindingOnAliasWrite;
     QV4::Scope scope(v4);
 
-    int propertyType = property->propType();
+    int propertyType = property->propType().id();
 
     if (property->isEnum()) {
         if (binding->flags & QV4::CompiledData::Binding::IsResolvedEnum) {
@@ -576,37 +576,37 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     }
     default: {
         // generate single literal value assignment to a list property if required
-        if (property->propType() == qMetaTypeId<QList<qreal> >()) {
+        if (propertyType == qMetaTypeId<QList<qreal> >()) {
             assertType(QV4::CompiledData::Binding::Type_Number);
             QList<qreal> value;
             value.append(compilationUnit->bindingValueAsNumber(binding));
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
-        } else if (property->propType() == qMetaTypeId<QList<int> >()) {
+        } else if (propertyType == qMetaTypeId<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 (property->propType() == qMetaTypeId<QList<bool> >()) {
+        } else if (propertyType == qMetaTypeId<QList<bool> >()) {
             assertType(QV4::CompiledData::Binding::Type_Boolean);
             QList<bool> value;
             value.append(binding->valueAsBoolean());
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
-        } else if (property->propType() == qMetaTypeId<QList<QUrl> >()) {
+        } else if (propertyType == qMetaTypeId<QList<QUrl> >()) {
             assertType(QV4::CompiledData::Binding::Type_String);
             QList<QUrl> value { QUrl(compilationUnit->bindingValueAsString(binding)) };
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
-        } else if (property->propType() == qMetaTypeId<QList<QString> >()) {
+        } else if (propertyType == qMetaTypeId<QList<QString> >()) {
             assertOrNull(binding->evaluatesToString());
             QList<QString> value;
             value.append(compilationUnit->bindingValueAsString(binding));
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
-        } else if (property->propType() == qMetaTypeId<QJSValue>()) {
+        } else if (propertyType == qMetaTypeId<QJSValue>()) {
             QJSValue value;
             if (binding->type == QV4::CompiledData::Binding::Type_Boolean) {
                 value = QJSValue(binding->valueAsBoolean());
@@ -627,12 +627,12 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
 
         // otherwise, try a custom type assignment
         QString stringValue = compilationUnit->bindingValueAsString(binding);
-        QQmlMetaType::StringConverter converter = QQmlMetaType::customStringConverter(property->propType());
+        QQmlMetaType::StringConverter converter = QQmlMetaType::customStringConverter(property->propType().id());
         Q_ASSERT(converter);
         QVariant value = (*converter)(stringValue);
 
         QMetaProperty metaProperty = _qobject->metaObject()->property(property->coreIndex());
-        if (value.isNull() || metaProperty.userType() != property->propType()) {
+        if (value.isNull() || metaProperty.metaType() != property->propType()) {
             recordError(binding->location, tr("Cannot assign value %1 to property %2").arg(stringValue).arg(QString::fromUtf8(metaProperty.name())));
             break;
         }
@@ -664,7 +664,7 @@ void QQmlObjectCreator::setupBindings(bool applyDeferredBindings)
     if (_compiledObject->idNameIndex) {
         const QQmlPropertyData *idProperty = propertyData.last();
         Q_ASSERT(!idProperty || !idProperty->isValid() || idProperty->name(_qobject) == QLatin1String("id"));
-        if (idProperty && idProperty->isValid() && idProperty->isWritable() && idProperty->propType() == QMetaType::QString) {
+        if (idProperty && idProperty->isValid() && idProperty->isWritable() && idProperty->propType().id() == QMetaType::QString) {
             QV4::CompiledData::Binding idBinding;
             idBinding.propertyNameIndex = 0; // Not used
             idBinding.flags = 0;
@@ -806,7 +806,7 @@ bool QQmlObjectCreator::setPropertyBinding(const QQmlPropertyData *bindingProper
     }
 
     // ### resolve this at compile time
-    if (bindingProperty && bindingProperty->propType() == qMetaTypeId<QQmlScriptString>()) {
+    if (bindingProperty && bindingProperty->propType() == QMetaType::fromType<QQmlScriptString>()) {
         QQmlScriptString ss(compilationUnit->bindingValueAsScriptString(binding),
                             context->asQQmlContext(), _scopeObject);
         ss.d.data()->bindingId = binding->type == QV4::CompiledData::Binding::Type_Script ? binding->value.compiledScriptIndex : (quint32)QQmlBinding::Invalid;
@@ -843,8 +843,8 @@ bool QQmlObjectCreator::setPropertyBinding(const QQmlPropertyData *bindingProper
             const QQmlPropertyData *valueTypeProperty = nullptr;
             QObject *bindingTarget = _bindingTarget;
 
-            if (QQmlValueTypeFactory::isValueType(bindingProperty->propType())) {
-                valueType = QQmlGadgetPtrWrapper::instance(engine, bindingProperty->propType());
+            if (QQmlValueTypeFactory::isValueType(bindingProperty->propType().id())) {
+                valueType = QQmlGadgetPtrWrapper::instance(engine, bindingProperty->propType().id());
                 if (!valueType) {
                     recordError(binding->location, tr("Cannot set properties on %1 as it is null").arg(stringAt(binding->propertyNameIndex)));
                     return false;
@@ -1066,7 +1066,7 @@ bool QQmlObjectCreator::setPropertyBinding(const QQmlPropertyData *bindingProper
         int propertyWriteStatus = -1;
         void *argv[] = { nullptr, nullptr, &propertyWriteStatus, &propertyWriteFlags };
 
-        if (const char *iid = QQmlMetaType::interfaceIId(bindingProperty->propType())) {
+        if (const char *iid = QQmlMetaType::interfaceIId(bindingProperty->propType().id())) {
             void *ptr = createdSubObject->qt_metacast(iid);
             if (ptr) {
                 argv[0] = &ptr;
@@ -1075,7 +1075,7 @@ bool QQmlObjectCreator::setPropertyBinding(const QQmlPropertyData *bindingProper
                 recordError(binding->location, tr("Cannot assign object to interface property"));
                 return false;
             }
-        } else if (bindingProperty->propType() == QMetaType::QVariant) {
+        } else if (bindingProperty->propType() == QMetaType::fromType<QVariant>()) {
             if (bindingProperty->isVarProperty()) {
                 QV4::Scope scope(v4);
                 QV4::ScopedValue wrappedObject(scope, QV4::QObjectWrapper::wrap(engine->handle(), createdSubObject));
@@ -1085,7 +1085,7 @@ bool QQmlObjectCreator::setPropertyBinding(const QQmlPropertyData *bindingProper
                 argv[0] = &value;
                 QMetaObject::metacall(_qobject, QMetaObject::WriteProperty, bindingProperty->coreIndex(), argv);
             }
-        } else if (bindingProperty->propType() == qMetaTypeId<QJSValue>()) {
+        } else if (bindingProperty->propType() == QMetaType::fromType<QJSValue>()) {
             QV4::Scope scope(v4);
             QV4::ScopedValue wrappedObject(scope, QV4::QObjectWrapper::wrap(engine->handle(), createdSubObject));
             if (bindingProperty->isVarProperty()) {
@@ -1102,7 +1102,7 @@ bool QQmlObjectCreator::setPropertyBinding(const QQmlPropertyData *bindingProper
             void *itemToAdd = createdSubObject;
 
             const char *iid = nullptr;
-            int listItemType = QQmlEnginePrivate::get(engine)->listType(bindingProperty->propType());
+            int listItemType = QQmlEnginePrivate::get(engine)->listType(bindingProperty->propType().id());
             if (listItemType != -1)
                 iid = QQmlMetaType::interfaceIId(listItemType);
             if (iid)
diff --git a/src/qml/qml/qqmlproperty.cpp b/src/qml/qml/qqmlproperty.cpp
index 68127f8686..d05b9c52fe 100644
--- a/src/qml/qml/qqmlproperty.cpp
+++ b/src/qml/qml/qqmlproperty.cpp
@@ -316,9 +316,9 @@ void QQmlPropertyPrivate::initProperty(QObject *obj, const QString &name)
             if (property->isFunction())
                 return; // Not an object property
 
-            if (ii == (path.count() - 2) && QQmlValueTypeFactory::isValueType(property->propType())) {
+            if (ii == (path.count() - 2) && QQmlValueTypeFactory::isValueType(property->propType().id())) {
                 // We're now at a value type property
-                const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(property->propType());
+                const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(property->propType().id());
                 if (!valueTypeMetaObject) return; // Not a value type
 
                 int idx = valueTypeMetaObject->indexOfProperty(path.last().toUtf8().constData());
@@ -331,7 +331,7 @@ void QQmlPropertyPrivate::initProperty(QObject *obj, const QString &name)
                 object = currentObject;
                 core = *property;
                 valueTypeData.setFlags(QQmlPropertyData::flagsForProperty(vtProp));
-                valueTypeData.setPropType(vtProp.userType());
+                valueTypeData.setPropType(vtProp.metaType());
                 valueTypeData.setCoreIndex(idx);
 
                 return;
@@ -502,7 +502,7 @@ const char *QQmlProperty::propertyTypeName() const
     if (!d)
         return nullptr;
     if (d->isValueType()) {
-        const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(d->core.propType());
+        const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(d->core.propType().id());
         Q_ASSERT(valueTypeMetaObject);
         return valueTypeMetaObject->property(d->valueTypeData.coreIndex()).typeName();
     } else if (d->object && type() & Property && d->core.isValid()) {
@@ -545,9 +545,9 @@ int QQmlPropertyPrivate::propertyType() const
 {
     uint type = this->type();
     if (isValueType()) {
-        return valueTypeData.propType();
+        return valueTypeData.propType().id();
     } else if (type & QQmlProperty::Property) {
-        return core.propType();
+        return core.propType().id();
     } else {
         return QMetaType::UnknownType;
     }
@@ -676,7 +676,7 @@ QString QQmlProperty::name() const
         // ###
         if (!d->object) {
         } else if (d->isValueType()) {
-            const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(d->core.propType());
+            const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(d->core.propType().id());
             Q_ASSERT(valueTypeMetaObject);
 
             const char *vtName = valueTypeMetaObject->property(d->valueTypeData.coreIndex()).name();
@@ -1057,9 +1057,9 @@ QVariant QQmlPropertyPrivate::readValueProperty()
     };
 
     if (isValueType()) {
-        if (QQmlGadgetPtrWrapper *wrapper = QQmlGadgetPtrWrapper::instance(engine, core.propType()))
+        if (QQmlGadgetPtrWrapper *wrapper = QQmlGadgetPtrWrapper::instance(engine, core.propType().id()))
             return doRead(wrapper);
-        if (QQmlValueType *valueType = QQmlValueTypeFactory::valueType(core.propType())) {
+        if (QQmlValueType *valueType = QQmlValueTypeFactory::valueType(core.propType().id())) {
             QQmlGadgetPtrWrapper wrapper(valueType, nullptr);
             return doRead(&wrapper);
         }
@@ -1068,7 +1068,7 @@ QVariant QQmlPropertyPrivate::readValueProperty()
 
         QQmlListProperty<QObject> prop;
         core.readProperty(object, &prop);
-        return QVariant::fromValue(QQmlListReferencePrivate::init(prop, core.propType(), engine));
+        return QVariant::fromValue(QQmlListReferencePrivate::init(prop, core.propType().id(), engine));
 
     } else if (core.isQObject()) {
 
@@ -1078,20 +1078,20 @@ QVariant QQmlPropertyPrivate::readValueProperty()
 
     } else {
 
-        if (!core.propType()) // Unregistered type
+        if (!core.propType().isValid()) // Unregistered type
             return object->metaObject()->property(core.coreIndex()).read(object);
 
         QVariant value;
         int status = -1;
         void *args[] = { nullptr, &value, &status };
-        if (core.propType() == QMetaType::QVariant) {
+        if (core.propType() == QMetaType::fromType<QVariant>()) {
             args[0] = &value;
         } else {
-            value = QVariant(QMetaType(core.propType()), (void*)nullptr);
+            value = QVariant(core.propType(), (void*)nullptr);
             args[0] = value.data();
         }
         core.readPropertyWithArgs(object, args);
-        if (core.propType() != QMetaType::QVariant && args[0] != value.data())
+        if (core.propType() != QMetaType::fromType<QVariant>() && args[0] != value.data())
             return QVariant(QMetaType(core.propType()), args[0]);
 
         return value;
@@ -1195,11 +1195,11 @@ QQmlPropertyPrivate::writeValueProperty(QObject *object,
         };
 
         QQmlGadgetPtrWrapper *wrapper = context
-                ? QQmlGadgetPtrWrapper::instance(context->engine(), core.propType())
+                ? QQmlGadgetPtrWrapper::instance(context->engine(), core.propType().id())
                 : nullptr;
         if (wrapper) {
             doWrite(wrapper);
-        } else if (QQmlValueType *valueType = QQmlValueTypeFactory::valueType(core.propType())) {
+        } else if (QQmlValueType *valueType = QQmlValueTypeFactory::valueType(core.propType().id())) {
             QQmlGadgetPtrWrapper wrapper(valueType, nullptr);
             doWrite(&wrapper);
         }
@@ -1215,7 +1215,8 @@ bool QQmlPropertyPrivate::write(
         QObject *object, const QQmlPropertyData &property, const QVariant &value,
         const QQmlRefPointer<QQmlContextData> &context, QQmlPropertyData::WriteFlags flags)
 {
-    const int propertyType = property.propType();
+    const QMetaType propertyMetaType = property.propType();
+    const int propertyType = propertyMetaType.id();
     const int variantType = value.userType();
 
     if (property.isEnum()) {
@@ -1265,7 +1266,7 @@ bool QQmlPropertyPrivate::write(
         } else {
             return false;
         }
-    } else if (value.canConvert(QMetaType(propertyType))
+    } else if (value.canConvert(propertyMetaType)
                && !isUrl && variantType != QMetaType::QString
                && propertyType != qMetaTypeId<QList<QUrl>>() && !property.isQList()) {
         // common cases:
@@ -1292,7 +1293,7 @@ bool QQmlPropertyPrivate::write(
         }
         default: { // "fallback":
             QVariant v = value;
-            v.convert(QMetaType(propertyType));
+            v.convert(propertyMetaType);
             return property.writeProperty(object, const_cast<void *>(v.constData()), flags);
         }
         }
@@ -1317,9 +1318,9 @@ bool QQmlPropertyPrivate::write(
         QQmlMetaObject listType;
 
         if (enginePriv) {
-            listType = enginePriv->rawMetaObjectForType(enginePriv->listType(property.propType()));
+            listType = enginePriv->rawMetaObjectForType(enginePriv->listType(propertyType));
         } else {
-            QQmlType type = QQmlMetaType::qmlType(QQmlMetaType::listType(property.propType()));
+            QQmlType type = QQmlMetaType::qmlType(QQmlMetaType::listType(propertyType));
             if (!type.isValid())
                 return false;
             listType = type.baseMetaObject();
@@ -1369,7 +1370,7 @@ bool QQmlPropertyPrivate::write(
 
         if (!ok) {
             v = value;
-            if (v.convert(QMetaType(propertyType))) {
+            if (v.convert(propertyMetaType)) {
                 ok = true;
             } else if (static_cast<uint>(propertyType) >= QMetaType::User &&
                        variantType == QMetaType::QString) {
diff --git a/src/qml/qml/qqmlpropertybinding.cpp b/src/qml/qml/qqmlpropertybinding.cpp
index e950de5d48..77f72d9723 100644
--- a/src/qml/qml/qqmlpropertybinding.cpp
+++ b/src/qml/qml/qqmlpropertybinding.cpp
@@ -46,7 +46,7 @@ QUntypedPropertyBinding QQmlPropertyBinding::create(const QQmlPropertyData *pd,
                                                     QObject *obj, const QQmlRefPointer<QQmlContextData> &ctxt,
                                                     QV4::ExecutionContext *scope)
 {
-    if (auto aotFunction = function->aotFunction; aotFunction && aotFunction->returnType.id() == pd->propType()) {
+    if (auto aotFunction = function->aotFunction; aotFunction && aotFunction->returnType == pd->propType()) {
         return QUntypedPropertyBinding(aotFunction->returnType,
             [
                 aotFunction,
diff --git a/src/qml/qml/qqmlpropertycache.cpp b/src/qml/qml/qqmlpropertycache.cpp
index 060437441d..18c27710c7 100644
--- a/src/qml/qml/qqmlpropertycache.cpp
+++ b/src/qml/qml/qqmlpropertycache.cpp
@@ -138,7 +138,7 @@ void QQmlPropertyData::load(const QMetaProperty &p)
 {
     populate(this, p);
     QMetaType type = p.metaType();
-    setPropType(type.id());
+    setPropType(type);
     flagsForPropertyType(type, m_flags);
 }
 
@@ -147,14 +147,14 @@ void QQmlPropertyData::load(const QMetaMethod &m)
     setCoreIndex(m.methodIndex());
     setArguments(nullptr);
 
-    setPropType(m.returnType());
+    setPropType(m.returnMetaType());
 
     m_flags.type = Flags::FunctionType;
     if (m.methodType() == QMetaMethod::Signal) {
         m_flags.setIsSignal(true);
     } else if (m.methodType() == QMetaMethod::Constructor) {
         m_flags.setIsConstructor(true);
-        setPropType(QMetaType::QObjectStar);
+        setPropType(QMetaType::fromType<QObject *>());
     }
 
     const int paramCount = m.parameterCount();
@@ -261,7 +261,7 @@ QQmlPropertyCache *QQmlPropertyCache::copyAndReserve(int propertyCount, int meth
     This is different from QMetaMethod::methodIndex().
 */
 void QQmlPropertyCache::appendProperty(const QString &name, QQmlPropertyData::Flags flags,
-                                       int coreIndex, int propType, QTypeRevision version,
+                                       int coreIndex, QMetaType propType, QTypeRevision version,
                                        int notifyIndex)
 {
     QQmlPropertyData data;
@@ -286,7 +286,7 @@ void QQmlPropertyCache::appendSignal(const QString &name, QQmlPropertyData::Flag
                                      const QList<QByteArray> &names)
 {
     QQmlPropertyData data;
-    data.setPropType(QMetaType::UnknownType);
+    data.setPropType(QMetaType());
     data.setCoreIndex(coreIndex);
     data.setFlags(flags);
     data.setArguments(nullptr);
@@ -326,7 +326,7 @@ void QQmlPropertyCache::appendMethod(const QString &name, QQmlPropertyData::Flag
     int argumentCount = names.count();
 
     QQmlPropertyData data;
-    data.setPropType(returnType);
+    data.setPropType(QMetaType(returnType));
     data.setCoreIndex(coreIndex);
 
     QQmlPropertyCacheMethodArguments *args = createArgumentsObject(argumentCount, names);
@@ -1091,8 +1091,8 @@ void QQmlPropertyCache::toMetaObjectBuilder(QMetaObjectBuilder &builder)
         QQmlPropertyData *data = methods.at(ii).second;
 
         QByteArray returnType;
-        if (data->propType() != 0)
-            returnType = QMetaType(data->propType()).name();
+        if (data->propType().isValid())
+            returnType = data->propType().name();
 
         QByteArray signature;
         // '+=' reserves extra capacity. Follow-up appending will be probably free.
diff --git a/src/qml/qml/qqmlpropertycache_p.h b/src/qml/qml/qqmlpropertycache_p.h
index 503ee7aa5d..b265d339e8 100644
--- a/src/qml/qml/qqmlpropertycache_p.h
+++ b/src/qml/qml/qqmlpropertycache_p.h
@@ -151,7 +151,7 @@ public:
     QQmlPropertyCache *copyAndReserve(int propertyCount,
                                       int methodCount, int signalCount, int enumCount);
     void appendProperty(const QString &, QQmlPropertyData::Flags flags, int coreIndex,
-                        int propType, QTypeRevision revision, int notifyIndex);
+                        QMetaType propType, QTypeRevision revision, int notifyIndex);
     void appendSignal(const QString &, QQmlPropertyData::Flags, int coreIndex,
                       const int *types = nullptr, const QList<QByteArray> &names = QList<QByteArray>());
     void appendMethod(const QString &, QQmlPropertyData::Flags flags, int coreIndex, int returnType,
diff --git a/src/qml/qml/qqmlpropertycachecreator.cpp b/src/qml/qml/qqmlpropertycachecreator.cpp
index 144d7e59b4..dcefa33166 100644
--- a/src/qml/qml/qqmlpropertycachecreator.cpp
+++ b/src/qml/qml/qqmlpropertycachecreator.cpp
@@ -46,31 +46,32 @@ QT_BEGIN_NAMESPACE
 QAtomicInt QQmlPropertyCacheCreatorBase::classIndexCounter(0);
 
 
-int QQmlPropertyCacheCreatorBase::metaTypeForPropertyType(QV4::CompiledData::BuiltinType type)
+QMetaType QQmlPropertyCacheCreatorBase::metaTypeForPropertyType(QV4::CompiledData::BuiltinType type)
 {
+    // TODO: we cannot depend on GUI types in declarative, so we'll have to do the id lookup
     switch (type) {
-    case QV4::CompiledData::BuiltinType::Var: return QMetaType::QVariant;
-    case QV4::CompiledData::BuiltinType::Int: return QMetaType::Int;
-    case QV4::CompiledData::BuiltinType::Bool: return QMetaType::Bool;
-    case QV4::CompiledData::BuiltinType::Real: return QMetaType::Double;
-    case QV4::CompiledData::BuiltinType::String: return QMetaType::QString;
-    case QV4::CompiledData::BuiltinType::Url: return QMetaType::QUrl;
-    case QV4::CompiledData::BuiltinType::Color: return QMetaType::QColor;
-    case QV4::CompiledData::BuiltinType::Font: return QMetaType::QFont;
-    case QV4::CompiledData::BuiltinType::Time: return QMetaType::QTime;
-    case QV4::CompiledData::BuiltinType::Date: return QMetaType::QDate;
-    case QV4::CompiledData::BuiltinType::DateTime: return QMetaType::QDateTime;
-    case QV4::CompiledData::BuiltinType::Rect: return QMetaType::QRectF;
-    case QV4::CompiledData::BuiltinType::Point: return QMetaType::QPointF;
-    case QV4::CompiledData::BuiltinType::Size: return QMetaType::QSizeF;
-    case QV4::CompiledData::BuiltinType::Vector2D: return QMetaType::QVector2D;
-    case QV4::CompiledData::BuiltinType::Vector3D: return QMetaType::QVector3D;
-    case QV4::CompiledData::BuiltinType::Vector4D: return QMetaType::QVector4D;
-    case QV4::CompiledData::BuiltinType::Matrix4x4: return QMetaType::QMatrix4x4;
-    case QV4::CompiledData::BuiltinType::Quaternion: return QMetaType::QQuaternion;
+    case QV4::CompiledData::BuiltinType::Var: return QMetaType::fromType<QVariant>();
+    case QV4::CompiledData::BuiltinType::Int: return QMetaType::fromType<int>();
+    case QV4::CompiledData::BuiltinType::Bool: return QMetaType::fromType<bool>();
+    case QV4::CompiledData::BuiltinType::Real: return QMetaType::fromType<qreal>();
+    case QV4::CompiledData::BuiltinType::String: return QMetaType::fromType<QString>();
+    case QV4::CompiledData::BuiltinType::Url: return QMetaType::fromType<QUrl>();
+    case QV4::CompiledData::BuiltinType::Color: return QMetaType(QMetaType::QColor);
+    case QV4::CompiledData::BuiltinType::Font: return QMetaType(QMetaType::QFont);
+    case QV4::CompiledData::BuiltinType::Time: return QMetaType::fromType<QTime>();
+    case QV4::CompiledData::BuiltinType::Date: return QMetaType::fromType<QDate>();
+    case QV4::CompiledData::BuiltinType::DateTime: return QMetaType::fromType<QDateTime>();
+    case QV4::CompiledData::BuiltinType::Rect: return QMetaType::fromType<QRectF>();
+    case QV4::CompiledData::BuiltinType::Point: return QMetaType::fromType<QPointF>();
+    case QV4::CompiledData::BuiltinType::Size: return QMetaType::fromType<QSizeF>();
+    case QV4::CompiledData::BuiltinType::Vector2D: return QMetaType(QMetaType::QVector2D);
+    case QV4::CompiledData::BuiltinType::Vector3D: return QMetaType(QMetaType::QVector3D);
+    case QV4::CompiledData::BuiltinType::Vector4D: return QMetaType(QMetaType::QVector4D);
+    case QV4::CompiledData::BuiltinType::Matrix4x4: return QMetaType(QMetaType::QMatrix4x4);
+    case QV4::CompiledData::BuiltinType::Quaternion: return QMetaType(QMetaType::QQuaternion);
     case QV4::CompiledData::BuiltinType::InvalidBuiltin: break;
     };
-    return QMetaType::UnknownType;
+    return QMetaType {};
 }
 
 QByteArray QQmlPropertyCacheCreatorBase::createClassNameTypeByUrl(const QUrl &url)
@@ -120,9 +121,9 @@ 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(),
+            return enginePrivate->rawPropertyCacheForType(instantiatingProperty->propType().id(),
                                                           instantiatingProperty->typeVersion());
-        } else if (const QMetaObject *vtmo = QQmlValueTypeFactory::metaObjectForMetaType(instantiatingProperty->propType())) {
+        } else if (const QMetaObject *vtmo = QQmlValueTypeFactory::metaObjectForMetaType(instantiatingProperty->propType().id())) {
             return enginePrivate->cache(vtmo, instantiatingProperty->typeVersion());
         }
     }
diff --git a/src/qml/qml/qqmlpropertycachecreator_p.h b/src/qml/qml/qqmlpropertycachecreator_p.h
index 21551db5c4..fc100fe08e 100644
--- a/src/qml/qml/qqmlpropertycachecreator_p.h
+++ b/src/qml/qml/qqmlpropertycachecreator_p.h
@@ -101,7 +101,7 @@ struct QQmlPropertyCacheCreatorBase
 public:
     static QAtomicInt classIndexCounter;
 
-    static int metaTypeForPropertyType(QV4::CompiledData::BuiltinType type);
+    static QMetaType metaTypeForPropertyType(QV4::CompiledData::BuiltinType type);
 
     static QByteArray createClassNameTypeByUrl(const QUrl &url);
 };
@@ -237,7 +237,7 @@ inline QQmlError QQmlPropertyCacheCreator<ObjectContainer>::buildMetaObjectRecur
                 // group properties and value type group properties. For the former the base type is derived from
                 // the property that references us, for the latter we only need a meta-object on the referencing object
                 // because interceptors can't go to the shared value type instances.
-                if (context.instantiatingProperty && QQmlValueTypeFactory::isValueType(context.instantiatingProperty->propType())) {
+                if (context.instantiatingProperty && QQmlValueTypeFactory::isValueType(context.instantiatingProperty->propType().id())) {
                     if (!propertyCaches->needsVMEMetaObject(context.referencingObjectIndex)) {
                         const CompiledObject *obj = objectContainer->objectAt(context.referencingObjectIndex);
                         auto *typeRef = objectContainer->resolvedType(obj->inheritedTypeNameIndex);
@@ -532,7 +532,7 @@ inline QQmlError QQmlPropertyCacheCreator<ObjectContainer>::createMetaObject(int
     p = obj->propertiesBegin();
     pend = obj->propertiesEnd();
     for ( ; p != pend; ++p, ++propertyIdx) {
-        int propertyType = 0;
+        QMetaType propertyType;
         QTypeRevision propertyTypeVersion = QTypeRevision::zero();
         QQmlPropertyData::Flags propertyFlags;
 
@@ -582,15 +582,15 @@ inline QQmlError QQmlPropertyCacheCreator<ObjectContainer>::createMetaObject(int
                 }
 
                 if (p->isList) {
-                    propertyType = typeIds.listId.id();
+                    propertyType = typeIds.listId;
                 } else {
-                    propertyType = typeIds.id.id();
+                    propertyType = typeIds.id;
                 }
             } else {
                 if (p->isList) {
-                    propertyType = qmltype.qListTypeId().id();
+                    propertyType = qmltype.qListTypeId();
                 } else {
-                    propertyType = qmltype.typeId().id();
+                    propertyType = qmltype.typeId();
                     propertyTypeVersion = qmltype.version();
                 }
             }
@@ -624,7 +624,7 @@ inline int QQmlPropertyCacheCreator<ObjectContainer>::metaTypeForParameter(const
 {
     if (param.indexIsBuiltinType) {
         // built-in type
-        return metaTypeForPropertyType(static_cast<QV4::CompiledData::BuiltinType>(int(param.typeNameIndexOrBuiltinType)));
+        return metaTypeForPropertyType(static_cast<QV4::CompiledData::BuiltinType>(int(param.typeNameIndexOrBuiltinType))).id();
     }
 
     // lazily resolved type
@@ -666,7 +666,7 @@ public:
 
 private:
     void appendAliasPropertiesInMetaObjectsWithinComponent(const CompiledObject &component, int firstObjectIndex, QQmlEnginePrivate *enginePriv);
-    QQmlError propertyDataForAlias(const CompiledObject &component, const QV4::CompiledData::Alias &alias, int *type, QTypeRevision *version, QQmlPropertyData::Flags *propertyFlags, QQmlEnginePrivate *enginePriv);
+    QQmlError propertyDataForAlias(const CompiledObject &component, const QV4::CompiledData::Alias &alias, QMetaType *type, QTypeRevision *version, QQmlPropertyData::Flags *propertyFlags, QQmlEnginePrivate *enginePriv);
 
     void collectObjectsWithAliasesRecursively(int objectIndex, QVector<int> *objectsWithAliases) const;
 
@@ -778,11 +778,11 @@ inline void QQmlPropertyCacheAliasCreator<ObjectContainer>::collectObjectsWithAl
 
 template <typename ObjectContainer>
 inline QQmlError QQmlPropertyCacheAliasCreator<ObjectContainer>::propertyDataForAlias(
-        const CompiledObject &component, const QV4::CompiledData::Alias &alias, int *type,
+        const CompiledObject &component, const QV4::CompiledData::Alias &alias, QMetaType *type,
         QTypeRevision *version, QQmlPropertyData::Flags *propertyFlags,
         QQmlEnginePrivate *enginePriv)
 {
-    *type = 0;
+    *type = QMetaType();
     bool writable = false;
     bool resettable = false;
     bool bindable = false;
@@ -833,9 +833,9 @@ inline QQmlError QQmlPropertyCacheAliasCreator<ObjectContainer>::propertyDataFor
 
         const auto referencedType = typeRef->type();
         if (referencedType.isValid())
-            *type = referencedType.typeId().id();
+            *type = referencedType.typeId();
         else
-            *type = typeRef->compilationUnit()->typeIds.id.id();
+            *type = typeRef->compilationUnit()->typeIds.id;
 
         *version = typeRef->version();
 
@@ -851,10 +851,10 @@ inline QQmlError QQmlPropertyCacheAliasCreator<ObjectContainer>::propertyDataFor
         Q_ASSERT(targetProperty);
 
         // for deep aliases, valueTypeIndex is always set
-        if (!QQmlValueTypeFactory::isValueType(targetProperty->propType()) && valueTypeIndex != -1) {
+        if (!QQmlValueTypeFactory::isValueType(targetProperty->propType().id()) && valueTypeIndex != -1) {
             // deep alias property
             *type = targetProperty->propType();
-            targetCache = enginePriv->propertyCacheForType(*type);
+            targetCache = enginePriv->propertyCacheForType(type->id());
             Q_ASSERT(targetCache);
             targetProperty = targetCache->property(valueTypeIndex);
 
@@ -874,12 +874,12 @@ inline QQmlError QQmlPropertyCacheAliasCreator<ObjectContainer>::propertyDataFor
             if (valueTypeIndex != -1) {
                 const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(*type);
                 if (valueTypeMetaObject->property(valueTypeIndex).isEnumType())
-                    *type = QMetaType::Int;
+                    *type = QMetaType::fromType<int>();
                 else
-                    *type = valueTypeMetaObject->property(valueTypeIndex).userType();
+                    *type = valueTypeMetaObject->property(valueTypeIndex).metaType();
             } else {
                 if (targetProperty->isEnum()) {
-                    *type = QMetaType::Int;
+                    *type = QMetaType::fromType<int>();
                 } else {
                     // Copy type flags
                     propertyFlags->copyPropertyTypeFlags(targetProperty->flags());
@@ -917,7 +917,7 @@ inline QQmlError QQmlPropertyCacheAliasCreator<ObjectContainer>::appendAliasesTo
     for ( ; alias != end; ++alias, ++aliasIndex) {
         Q_ASSERT(alias->flags & QV4::CompiledData::Alias::Resolved);
 
-        int type = 0;
+        QMetaType type;
         QTypeRevision version = QTypeRevision::zero();
         QQmlPropertyData::Flags propertyFlags;
         QQmlError error = propertyDataForAlias(component, *alias, &type, &version,
diff --git a/src/qml/qml/qqmlpropertydata_p.h b/src/qml/qml/qqmlpropertydata_p.h
index d239b461e1..4decbf6e21 100644
--- a/src/qml/qml/qqmlpropertydata_p.h
+++ b/src/qml/qml/qqmlpropertydata_p.h
@@ -259,8 +259,8 @@ public:
     bool hasOverride() const { return overrideIndex() >= 0; }
     bool hasRevision() const { return revision() != QTypeRevision::zero(); }
 
-    int propType() const { return m_propType; }
-    void setPropType(int pt)
+    QMetaType propType() const { return m_propType; }
+    void setPropType(QMetaType pt)
     {
         m_propType = pt;
     }
@@ -397,7 +397,6 @@ private:
     void lazyLoad(const QMetaMethod &);
 
     Flags m_flags;
-    int m_propType = 0;
     qint16 m_coreIndex = -1;
 
     // The notify index is in the range returned by QObjectPrivate::signalIndex().
@@ -410,6 +409,8 @@ private:
     QTypeRevision m_revision = QTypeRevision::zero();
     QTypeRevision m_typeVersion = QTypeRevision::zero();
 
+    QMetaType m_propType = {};
+
     QQmlPropertyCacheMethodArguments *m_arguments = nullptr;
     StaticMetaCallFunction m_staticMetaCallFunction = nullptr;
 };
diff --git a/src/qml/qml/qqmlpropertyvalidator.cpp b/src/qml/qml/qqmlpropertyvalidator.cpp
index 3cc7cc843a..c1d0977f31 100644
--- a/src/qml/qml/qqmlpropertyvalidator.cpp
+++ b/src/qml/qml/qqmlpropertyvalidator.cpp
@@ -229,7 +229,7 @@ QVector<QQmlError> QQmlPropertyValidator::validateObject(
         if (binding->type >= QV4::CompiledData::Binding::Type_Object && (pd || binding->isAttachedProperty())) {
             const bool populatingValueTypeGroupProperty
                     = pd
-                      && QQmlValueTypeFactory::metaObjectForMetaType(pd->propType())
+                      && QQmlValueTypeFactory::metaObjectForMetaType(pd->propType().id())
                       && !(binding->flags & QV4::CompiledData::Binding::IsOnAssignment);
             const QVector<QQmlError> subObjectValidatorErrors
                     = validateObject(binding->value.objectIndex, binding,
@@ -267,7 +267,7 @@ QVector<QQmlError> QQmlPropertyValidator::validateObject(
 
             if (!pd->isQList() && (binding->flags & QV4::CompiledData::Binding::IsListItem)) {
                 QString error;
-                if (pd->propType() == qMetaTypeId<QQmlScriptString>())
+                if (pd->propType() == QMetaType::fromType<QQmlScriptString>())
                     error = tr( "Cannot assign multiple values to a script property");
                 else
                     error = tr( "Cannot assign multiple values to a singular property");
@@ -282,7 +282,7 @@ QVector<QQmlError> QQmlPropertyValidator::validateObject(
                 if (loc < (*assignedGroupProperty)->valueLocation)
                     loc = (*assignedGroupProperty)->valueLocation;
 
-                if (pd && QQmlValueTypeFactory::isValueType(pd->propType()))
+                if (pd && QQmlValueTypeFactory::isValueType(pd->propType().id()))
                     return recordError(loc, tr("Property has already been assigned a value"));
                 return recordError(loc, tr("Cannot assign a value directly to a grouped property"));
             }
@@ -296,8 +296,8 @@ QVector<QQmlError> QQmlPropertyValidator::validateObject(
                 if (bindingError.isValid())
                     return recordError(bindingError);
             } else if (binding->isGroupProperty()) {
-                if (QQmlValueTypeFactory::isValueType(pd->propType())) {
-                    if (QQmlValueTypeFactory::metaObjectForMetaType(pd->propType())) {
+                if (QQmlValueTypeFactory::isValueType(pd->propType().id())) {
+                    if (QQmlValueTypeFactory::metaObjectForMetaType(pd->propType().id())) {
                         if (!pd->isWritable()) {
                             return recordError(binding->location, tr("Invalid property assignment: \"%1\" is a read-only property").arg(name));
                         }
@@ -305,7 +305,7 @@ QVector<QQmlError> QQmlPropertyValidator::validateObject(
                         return recordError(binding->location, tr("Invalid grouped property access"));
                     }
                 } else {
-                    const int typeId = pd->propType();
+                    const int typeId = pd->propType().id();
                     if (isPrimitiveType(typeId)) {
                         return recordError(
                                     binding->location,
@@ -412,7 +412,7 @@ QQmlError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache *prope
         return  binding->type == QV4::CompiledData::Binding::Type_String;
     };
 
-    switch (property->propType()) {
+    switch (property->propType().id()) {
     case QMetaType::QVariant:
     break;
     case QMetaType::QString: {
@@ -572,7 +572,7 @@ QQmlError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache *prope
     case QMetaType::QVector4D:
     case QMetaType::QQuaternion: {
         auto typeName = [&]() {
-            switch (property->propType()) {
+            switch (property->propType().id()) {
             case QMetaType::QVector2D: return QStringLiteral("2D vector");
             case QMetaType::QVector3D: return QStringLiteral("3D vector");
             case QMetaType::QVector4D: return QStringLiteral("4D vector");
@@ -582,7 +582,7 @@ QQmlError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache *prope
         };
         QVariant result;
         if (!QQml_valueTypeProvider()->createValueType(
-                    property->propType(),
+                    property->propType().id(),
                     compilationUnit->bindingValueAsString(binding), result)) {
             return warnOrError(tr("Invalid property assignment: %1 expected")
                                .arg(typeName()));
@@ -593,12 +593,12 @@ QQmlError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache *prope
         return warnOrError(tr("Invalid property assignment: regular expression expected; use /pattern/ syntax"));
     default: {
         // generate single literal value assignment to a list property if required
-        if (property->propType() == qMetaTypeId<QList<qreal> >()) {
+        if (property->propType() == QMetaType::fromType<QList<qreal> >()) {
             if (binding->type != QV4::CompiledData::Binding::Type_Number) {
                 return warnOrError(tr("Invalid property assignment: number or array of numbers expected"));
             }
             break;
-        } else if (property->propType() == qMetaTypeId<QList<int> >()) {
+        } else if (property->propType() == QMetaType::fromType<QList<int> >()) {
             bool ok = (binding->type == QV4::CompiledData::Binding::Type_Number);
             if (ok) {
                 double n = compilationUnit->bindingValueAsNumber(binding);
@@ -608,24 +608,24 @@ QQmlError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache *prope
             if (!ok)
                 return warnOrError(tr("Invalid property assignment: int or array of ints expected"));
             break;
-        } else if (property->propType() == qMetaTypeId<QList<bool> >()) {
+        } else if (property->propType() == QMetaType::fromType<QList<bool> >()) {
             if (binding->type != QV4::CompiledData::Binding::Type_Boolean) {
                 return warnOrError(tr("Invalid property assignment: bool or array of bools expected"));
             }
             break;
-        } else if (property->propType() == qMetaTypeId<QList<QUrl> >()) {
+        } else if (property->propType() == QMetaType::fromType<QList<QUrl> >()) {
             if (binding->type != QV4::CompiledData::Binding::Type_String) {
                 return warnOrError(tr("Invalid property assignment: url or array of urls expected"));
             }
             break;
-        } else if (property->propType() == qMetaTypeId<QList<QString> >()) {
+        } else if (property->propType() == QMetaType::fromType<QList<QString> >()) {
             if (!binding->evaluatesToString()) {
                 return warnOrError(tr("Invalid property assignment: string or array of strings expected"));
             }
             break;
-        } else if (property->propType() == qMetaTypeId<QJSValue>()) {
+        } else if (property->propType() == QMetaType::fromType<QJSValue>()) {
             break;
-        } else if (property->propType() == qMetaTypeId<QQmlScriptString>()) {
+        } else if (property->propType() == QMetaType::fromType<QQmlScriptString>()) {
             break;
         } else if (property->isQObject()
                    && binding->type == QV4::CompiledData::Binding::Type_Null) {
@@ -633,7 +633,7 @@ QQmlError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache *prope
         }
 
         // otherwise, try a custom type assignment
-        QQmlMetaType::StringConverter converter = QQmlMetaType::customStringConverter(property->propType());
+        QQmlMetaType::StringConverter converter = QQmlMetaType::customStringConverter(property->propType().id());
         if (!converter) {
             return warnOrError(tr("Invalid property assignment: unsupported type \"%1\"").arg(QString::fromLatin1(QMetaType(property->propType()).name())));
         }
@@ -705,7 +705,7 @@ QQmlError QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *propert
         return noError;
     }
 
-    const int propType = property->propType();
+    const int propType = property->propType().id();
     const auto rhsType = [&]() {
         return stringAt(compilationUnit->objectAt(binding->value.objectIndex)
                         ->inheritedTypeNameIndex);
@@ -759,11 +759,11 @@ QQmlError QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *propert
 
             if (!isAssignable) {
                 return qQmlCompileError(binding->valueLocation, tr("Cannot assign object of type \"%1\" to property of type \"%2\" as the former is neither the same as the latter nor a sub-class of it.")
-                        .arg(rhsType()).arg(QLatin1String(QMetaType(propType).name())));
+                        .arg(rhsType()).arg(QLatin1String(property->propType().name())));
             }
         } else {
             return qQmlCompileError(binding->valueLocation, tr("Cannot assign to property of unknown type \"%1\".")
-                        .arg(QLatin1String(QMetaType(propType).name())));
+                        .arg(QLatin1String(property->propType().name())));
         }
 
     }
diff --git a/src/qml/qml/qqmltypecompiler.cpp b/src/qml/qml/qqmltypecompiler.cpp
index a5660e2d53..b39aa174a3 100644
--- a/src/qml/qml/qqmltypecompiler.cpp
+++ b/src/qml/qml/qqmltypecompiler.cpp
@@ -542,7 +542,7 @@ bool QQmlEnumTypeResolver::resolveEnumBindings()
             if (!pd)
                 continue;
 
-            if (!pd->isEnum() && pd->propType() != QMetaType::Int)
+            if (!pd->isEnum() && pd->propType().id() != QMetaType::Int)
                 continue;
 
             if (!tryQualifiedEnumAssignment(obj, propertyCache, pd, binding))
@@ -564,7 +564,7 @@ bool QQmlEnumTypeResolver::assignEnumToBinding(QmlIR::Binding *binding, QStringV
 
 bool QQmlEnumTypeResolver::tryQualifiedEnumAssignment(const QmlIR::Object *obj, const QQmlPropertyCache *propertyCache, const QQmlPropertyData *prop, QmlIR::Binding *binding)
 {
-    bool isIntProp = (prop->propType() == QMetaType::Int) && !prop->isEnum();
+    bool isIntProp = (prop->propType().id() == QMetaType::Int) && !prop->isEnum();
     if (!prop->isEnum() && !isIntProp)
         return true;
 
@@ -763,7 +763,7 @@ QQmlScriptStringScanner::QQmlScriptStringScanner(QQmlTypeCompiler *typeCompiler)
 
 void QQmlScriptStringScanner::scan()
 {
-    const int scriptStringMetaType = qMetaTypeId<QQmlScriptString>();
+    const QMetaType scriptStringMetaType = QMetaType::fromType<QQmlScriptString>();
     for (int i = 0; i < qmlObjects.count(); ++i) {
         QQmlPropertyCache *propertyCache = propertyCaches->at(i);
         if (!propertyCache)
@@ -854,8 +854,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(), pd->typeVersion())
-                : enginePrivate->rawPropertyCacheForType(pd->propType());
+                ? enginePrivate->rawPropertyCacheForType(pd->propType().id(), pd->typeVersion())
+                : enginePrivate->rawPropertyCacheForType(pd->propType().id());
         const QMetaObject *mo = pc ? pc->firstCppMetaObject() : nullptr;
         while (mo) {
             if (mo == &QQmlComponent::staticMetaObject)
@@ -1184,7 +1184,7 @@ QQmlComponentAndAliasResolver::resolveAliasesInObject(int objectIndex,
             propIdx = QQmlPropertyIndex(targetProperty->coreIndex());
 
             if (!subProperty.isEmpty()) {
-                const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(targetProperty->propType());
+                const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(targetProperty->propType().id());
                 if (!valueTypeMetaObject) {
                     // could be a deep alias
                     bool isDeepAlias = subProperty.at(0).isLower();
diff --git a/src/qml/qml/qqmlvaluetype_p.h b/src/qml/qml/qqmlvaluetype_p.h
index aaef422627..4abf324121 100644
--- a/src/qml/qml/qqmlvaluetype_p.h
+++ b/src/qml/qml/qqmlvaluetype_p.h
@@ -121,7 +121,9 @@ class Q_QML_PRIVATE_EXPORT QQmlValueTypeFactory
 {
 public:
     static bool isValueType(int idx);
+    static QQmlValueType *valueType(QMetaType metaType) {return valueType(metaType.id());};
     static QQmlValueType *valueType(int idx);
+    static const QMetaObject *metaObjectForMetaType(QMetaType type) {return metaObjectForMetaType(type.id());};
     static const QMetaObject *metaObjectForMetaType(int type);
 };
 
diff --git a/src/qml/qml/qqmlvaluetypewrapper.cpp b/src/qml/qml/qqmlvaluetypewrapper.cpp
index aeee32bc7b..18e2d06492 100644
--- a/src/qml/qml/qqmlvaluetypewrapper.cpp
+++ b/src/qml/qml/qqmlvaluetypewrapper.cpp
@@ -449,15 +449,15 @@ Q_ALWAYS_INLINE static ReturnedValue getGadgetProperty(ExecutionEngine *engine,
     QQmlMetaObject::resolveGadgetMethodOrPropertyIndex(QMetaObject::ReadProperty, &metaObject, &index);
 
     // These four types are the most common used by the value type wrappers
-    VALUE_TYPE_LOAD(QMetaType::QReal, qreal, qreal);
-    VALUE_TYPE_LOAD(QMetaType::Int || property->isEnum(), int, int);
-    VALUE_TYPE_LOAD(QMetaType::Int, int, int);
-    VALUE_TYPE_LOAD(QMetaType::QString, QString, engine->newString);
-    VALUE_TYPE_LOAD(QMetaType::Bool, bool, bool);
+    VALUE_TYPE_LOAD(QMetaType::fromType<qreal>(), qreal, qreal);
+    VALUE_TYPE_LOAD(QMetaType::fromType<int>() || property->isEnum(), int, int);
+    VALUE_TYPE_LOAD(QMetaType::fromType<int>(), int, int);
+    VALUE_TYPE_LOAD(QMetaType::fromType<QString>(), QString, engine->newString);
+    VALUE_TYPE_LOAD(QMetaType::fromType<bool>(), bool, bool);
 
     QVariant v;
     void *args[] = { nullptr, nullptr };
-    if (property->propType() == QMetaType::QVariant) {
+    if (property->propType() == QMetaType::fromType<QVariant>()) {
         args[0] = &v;
     } else {
         v = QVariant(QMetaType(property->propType()), static_cast<void *>(nullptr));
@@ -578,7 +578,7 @@ bool QQmlValueTypeWrapper::virtualPut(Managed *m, PropertyKey id, const Value &v
     Scoped<QQmlValueTypeWrapper> r(scope, static_cast<QQmlValueTypeWrapper *>(m));
     Scoped<QQmlValueTypeReference> reference(scope, m->d());
 
-    int writeBackPropertyType = -1;
+    QMetaType writeBackPropertyType;
 
     if (reference) {
         QMetaProperty writebackProperty = reference->d()->object->metaObject()->property(reference->d()->property);
@@ -586,7 +586,7 @@ bool QQmlValueTypeWrapper::virtualPut(Managed *m, PropertyKey id, const Value &v
         if (!writebackProperty.isWritable() || !reference->readReferenceValue())
             return false;
 
-        writeBackPropertyType = writebackProperty.userType();
+        writeBackPropertyType = writebackProperty.metaType();
     }
 
     ScopedString name(scope, id.asStringOrSymbol());
@@ -660,7 +660,7 @@ bool QQmlValueTypeWrapper::virtualPut(Managed *m, PropertyKey id, const Value &v
 
 
     if (reference) {
-        if (writeBackPropertyType == QMetaType::QVariant) {
+        if (writeBackPropertyType == QMetaType::fromType<QVariant>()) {
             QVariant variantReferenceValue = r->d()->toVariant();
 
             int flags = 0;
diff --git a/src/qml/qml/qqmlvmemetaobject.cpp b/src/qml/qml/qqmlvmemetaobject.cpp
index 2379f393aa..2ae9707c22 100644
--- a/src/qml/qml/qqmlvmemetaobject.cpp
+++ b/src/qml/qml/qqmlvmemetaobject.cpp
@@ -250,7 +250,7 @@ void QQmlVMEMetaObjectEndpoint::tryConnect()
             if (pd && valueTypeIndex != -1 && !QQmlValueTypeFactory::valueType(pd->propType())) {
                 // deep alias
                 QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(metaObject->compilationUnit->engine->qmlEngine());
-                auto const *newPropertyCache = enginePriv->propertyCacheForType(pd->propType());
+                auto const *newPropertyCache = enginePriv->propertyCacheForType(pd->propType().id());
                 void *argv[1] = { &target };
                 QMetaObject::metacall(target, QMetaObject::ReadProperty, coreIndex, argv);
                 Q_ASSERT(newPropertyCache);
@@ -321,7 +321,7 @@ bool QQmlInterceptorMetaObject::intercept(QMetaObject::Call c, int id, void **a)
 
             const int valueIndex = vi->m_propertyIndex.valueTypeIndex();
             const QQmlData *data = QQmlData::get(object);
-            const int type = data->propertyCache->property(id)->propType();
+            const int type = data->propertyCache->property(id)->propType().id();
 
             if (type != QMetaType::UnknownType) {
                 if (valueIndex != -1) {
@@ -700,7 +700,7 @@ int QQmlVMEMetaObject::metaCall(QObject *o, QMetaObject::Call c, int _id, void *
                         ? nullptr
                         : QQmlEnginePrivate::get(ctxt->engine());
 
-                const int fallbackMetaType = QQmlPropertyCacheCreatorBase::metaTypeForPropertyType(t);
+                const int fallbackMetaType = QQmlPropertyCacheCreatorBase::metaTypeForPropertyType(t).id();
 
                 if (c == QMetaObject::ReadProperty) {
                     switch (t) {
@@ -930,7 +930,7 @@ int QQmlVMEMetaObject::metaCall(QObject *o, QMetaObject::Call c, int _id, void *
                     const QQmlPropertyData *pd = targetDData->propertyCache->property(coreIndex);
                     // Value type property or deep alias
                     QQmlGadgetPtrWrapper *valueType = QQmlGadgetPtrWrapper::instance(
-                                ctxt->engine(), pd->propType());
+                                ctxt->engine(), pd->propType().id());
                     if (valueType) {
                         valueType->read(target, coreIndex);
                         int rv = QMetaObject::metacall(valueType, c, valueTypePropertyIndex, a);
@@ -1007,24 +1007,24 @@ int QQmlVMEMetaObject::metaCall(QObject *o, QMetaObject::Call c, int _id, void *
                     jsCallData->args[ii] = scope.engine->metaTypeToJS(arguments->arguments[ii + 1], a[ii + 1]);
                 }
 
-                const int returnType = methodData->propType();
+                const QMetaType returnType = methodData->propType();
                 QV4::ScopedValue result(scope, function->call(jsCallData));
                 if (scope.hasException()) {
                     QQmlError error = scope.engine->catchExceptionAsQmlError();
                     if (error.isValid())
                         ep->warning(error);
                     if (a[0]) {
-                        QMetaType(returnType).destruct(a[0]);
-                        QMetaType(returnType).construct(a[0], nullptr);
+                        returnType.destruct(a[0]);
+                        returnType.construct(a[0], nullptr);
                     }
                 } else {
                     if (a[0]) {
                         // When the return type is QVariant, JS objects are to be returned as QJSValue wrapped in
                         // QVariant.
-                        if (returnType == QMetaType::QVariant)
+                        if (returnType == QMetaType::fromType<QVariant>())
                             *(QVariant *)a[0] = scope.engine->toVariant(result, 0);
                         else
-                            scope.engine->metaTypeFromJS(result, returnType, a[0]);
+                            scope.engine->metaTypeFromJS(result, returnType.id(), a[0]);
                     }
                 }
 
diff --git a/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp b/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
index c0286bd195..9f4cdb770e 100644
--- a/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
+++ b/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
@@ -4796,7 +4796,7 @@ void tst_qqmllanguage::preservePropertyCacheOnGroupObjects()
     QVERIFY(subCache);
     QQmlPropertyData *pd = subCache->property(QStringLiteral("newProperty"), /*object*/nullptr, /*context*/nullptr);
     QVERIFY(pd);
-    QCOMPARE(pd->propType(), qMetaTypeId<int>());
+    QCOMPARE(pd->propType(), QMetaType::fromType<int>());
 }
 
 void tst_qqmllanguage::propertyCacheInSync()