QQmlEngine: Remove methods that merely forward to QQmlMetaType

There is no reason to drag an engine around for those.

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

19 files changed, 43 insertions, 80 deletions

diff --git a/src/qml/jsapi/qjsengine_p.h b/src/qml/jsapi/qjsengine_p.h
index 6d6cd9b97b..acb36f4902 100644
--- a/src/qml/jsapi/qjsengine_p.h
+++ b/src/qml/jsapi/qjsengine_p.h
@@ -86,8 +86,6 @@ public:
 
     // These methods may be called from the QML loader thread
     inline QQmlRefPointer<QQmlPropertyCache> cache(QObject *obj, QTypeRevision version = QTypeRevision());
-    inline QQmlRefPointer<QQmlPropertyCache> cache(
-            const QMetaObject *obj, QTypeRevision version = QTypeRevision());
 };
 
 /*!
@@ -114,24 +112,6 @@ QQmlRefPointer<QQmlPropertyCache> QJSEnginePrivate::cache(QObject *obj, QTypeRev
     return QQmlMetaType::propertyCache(mo, version);
 }
 
-/*!
-Returns a QQmlPropertyCache for \a metaObject.
-
-As the cache is persisted for the life of the engine, \a metaObject must be
-a static "compile time" meta-object, or a meta-object that is otherwise known to
-exist for the lifetime of the QQmlEngine.
-
-The returned cache is not referenced, so if it is to be stored, call addref().
-*/
-QQmlRefPointer<QQmlPropertyCache> QJSEnginePrivate::cache(
-        const QMetaObject *metaObject, QTypeRevision version)
-{
-    Q_ASSERT(metaObject);
-
-    return QQmlMetaType::propertyCache(metaObject, version);
-}
-
-
 QT_END_NAMESPACE
 
 #endif // QJSENGINE_P_H
diff --git a/src/qml/jsruntime/qv4executablecompilationunit.cpp b/src/qml/jsruntime/qv4executablecompilationunit.cpp
index 5884640287..cfded3f858 100644
--- a/src/qml/jsruntime/qv4executablecompilationunit.cpp
+++ b/src/qml/jsruntime/qv4executablecompilationunit.cpp
@@ -856,7 +856,7 @@ bool ExecutableCompilationUnit::saveToDisk(const QUrl &unitUrl, QString *errorSt
     This function creates a temporary key vector and sorts it to guarantuee a stable
     hash. This is used to calculate a check-sum on dependent meta-objects.
  */
-bool ResolvedTypeReferenceMap::addToHash(QCryptographicHash *hash, QQmlEngine *engine) const
+bool ResolvedTypeReferenceMap::addToHash(QCryptographicHash *hash) const
 {
     std::vector<int> keys (count());
     int i = 0;
@@ -866,7 +866,7 @@ bool ResolvedTypeReferenceMap::addToHash(QCryptographicHash *hash, QQmlEngine *e
     }
     std::sort(keys.begin(), keys.end());
     for (int key: keys) {
-        if (!this->operator[](key)->addToHash(hash, engine))
+        if (!this->operator[](key)->addToHash(hash))
             return false;
     }
 
diff --git a/src/qml/jsruntime/qv4executablecompilationunit_p.h b/src/qml/jsruntime/qv4executablecompilationunit_p.h
index 962517f6f4..6798829898 100644
--- a/src/qml/jsruntime/qv4executablecompilationunit_p.h
+++ b/src/qml/jsruntime/qv4executablecompilationunit_p.h
@@ -94,7 +94,7 @@ class ResolvedTypeReference;
 // map from name index
 struct ResolvedTypeReferenceMap: public QHash<int, ResolvedTypeReference*>
 {
-    bool addToHash(QCryptographicHash *hash, QQmlEngine *engine) const;
+    bool addToHash(QCryptographicHash *hash) const;
 };
 
 class Q_QML_PRIVATE_EXPORT ExecutableCompilationUnit final: public CompiledData::CompilationUnit,
diff --git a/src/qml/jsruntime/qv4resolvedtypereference.cpp b/src/qml/jsruntime/qv4resolvedtypereference.cpp
index d81f512391..d390de7349 100644
--- a/src/qml/jsruntime/qv4resolvedtypereference.cpp
+++ b/src/qml/jsruntime/qv4resolvedtypereference.cpp
@@ -83,12 +83,12 @@ QQmlRefPointer<QQmlPropertyCache> ResolvedTypeReference::propertyCache() const
 /*!
 Returns the property cache, creating one if it doesn't already exist.  The cache is not referenced.
 */
-QQmlRefPointer<QQmlPropertyCache> ResolvedTypeReference::createPropertyCache(QQmlEngine *engine)
+QQmlRefPointer<QQmlPropertyCache> ResolvedTypeReference::createPropertyCache()
 {
     if (m_typePropertyCache) {
         return m_typePropertyCache;
     } else if (m_type.isValid()) {
-        m_typePropertyCache = QQmlEnginePrivate::get(engine)->cache(m_type.metaObject(), m_version);
+        m_typePropertyCache = QQmlMetaType::propertyCache(m_type.metaObject(), m_version);
         return m_typePropertyCache;
     } else {
         Q_ASSERT(m_compilationUnit);
@@ -96,11 +96,11 @@ QQmlRefPointer<QQmlPropertyCache> ResolvedTypeReference::createPropertyCache(QQm
     }
 }
 
-bool ResolvedTypeReference::addToHash(QCryptographicHash *hash, QQmlEngine *engine)
+bool ResolvedTypeReference::addToHash(QCryptographicHash *hash)
 {
     if (m_type.isValid() && !m_type.isInlineComponentType()) {
         bool ok = false;
-        hash->addData(createPropertyCache(engine)->checksum(&ok));
+        hash->addData(createPropertyCache()->checksum(&ok));
         return ok;
     }
     if (!m_compilationUnit)
diff --git a/src/qml/jsruntime/qv4resolvedtypereference_p.h b/src/qml/jsruntime/qv4resolvedtypereference_p.h
index 7e8bedad62..61e683ce17 100644
--- a/src/qml/jsruntime/qv4resolvedtypereference_p.h
+++ b/src/qml/jsruntime/qv4resolvedtypereference_p.h
@@ -74,8 +74,8 @@ public:
     }
 
     QQmlRefPointer<QQmlPropertyCache> propertyCache() const;
-    QQmlRefPointer<QQmlPropertyCache> createPropertyCache(QQmlEngine *);
-    bool addToHash(QCryptographicHash *hash, QQmlEngine *engine);
+    QQmlRefPointer<QQmlPropertyCache> createPropertyCache();
+    bool addToHash(QCryptographicHash *hash);
 
     void doDynamicTypeCheck();
 
diff --git a/src/qml/qml/qqmlbinding.cpp b/src/qml/qml/qqmlbinding.cpp
index 5733abcad0..2ed251c796 100644
--- a/src/qml/qml/qqmlbinding.cpp
+++ b/src/qml/qml/qqmlbinding.cpp
@@ -728,7 +728,7 @@ bool QQmlBinding::setTarget(QObject *object, int coreIndex, bool coreIsAlias, in
 
     QQmlData *data = QQmlData::get(m_target.data(), true);
     if (!data->propertyCache)
-        data->propertyCache = QQmlEnginePrivate::get(engine())->cache(m_target->metaObject());
+        data->propertyCache = QQmlMetaType::propertyCache(m_target->metaObject());
 
     return true;
 }
@@ -741,7 +741,7 @@ void QQmlBinding::getPropertyData(QQmlPropertyData **propertyData, QQmlPropertyD
     Q_ASSERT(data);
 
     if (Q_UNLIKELY(!data->propertyCache))
-        data->propertyCache = QQmlEnginePrivate::get(engine())->cache(m_target->metaObject());
+        data->propertyCache = QQmlMetaType::propertyCache(m_target->metaObject());
 
     *propertyData = data->propertyCache->property(m_targetIndex.coreIndex());
     Q_ASSERT(*propertyData);
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index 324e871254..6b5e2cf53a 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -1732,7 +1732,7 @@ QQmlRefPointer<QQmlPropertyCache> QQmlEnginePrivate::propertyCacheForType(QMetaT
 
     const QQmlType type = QQmlMetaType::qmlType(metaType);
     return type.isValid()
-            ? cache(type.metaObject(), type.version())
+            ? QQmlMetaType::propertyCache(type.metaObject(), type.version())
             : QQmlRefPointer<QQmlPropertyCache>();
 }
 
@@ -1750,7 +1750,7 @@ QQmlRefPointer<QQmlPropertyCache> QQmlEnginePrivate::rawPropertyCacheForType(QMe
 
     const QQmlType type = QQmlMetaType::qmlType(metaType);
     return type.isValid()
-            ? cache(type.baseMetaObject(), QTypeRevision())
+            ? QQmlMetaType::propertyCache(type.baseMetaObject(), QTypeRevision())
             : QQmlRefPointer<QQmlPropertyCache>();
 }
 
@@ -1774,7 +1774,7 @@ QQmlRefPointer<QQmlPropertyCache> QQmlEnginePrivate::rawPropertyCacheForType(
         return QQmlMetaType::propertyCache(type, version);
 
     if (const QMetaObject *metaObject = type.metaObject())
-        return cache(metaObject, version);
+        return QQmlMetaType::propertyCache(metaObject, version);
 
     return QQmlRefPointer<QQmlPropertyCache>();
 }
diff --git a/src/qml/qml/qqmlengine_p.h b/src/qml/qml/qqmlengine_p.h
index 81494103c1..e9e4aeda4b 100644
--- a/src/qml/qml/qqmlengine_p.h
+++ b/src/qml/qml/qqmlengine_p.h
@@ -208,8 +208,6 @@ public:
     // These methods may be called from any thread
     QString offlineStorageDatabaseDirectory() const;
 
-    // These methods may be called from the loader thread
-    inline QQmlRefPointer<QQmlPropertyCache> cache(const QQmlType &, QTypeRevision version);
     using QJSEnginePrivate::cache;
 
     // These methods may be called from the loader thread
@@ -362,19 +360,6 @@ inline void QQmlEnginePrivate::dereferenceScarceResources()
     }
 }
 
-/*!
-Returns a QQmlPropertyCache for \a type with \a minorVersion.
-
-The returned cache is not referenced, so if it is to be stored, call addref().
-*/
-QQmlRefPointer<QQmlPropertyCache> QQmlEnginePrivate::cache(
-        const QQmlType &type, QTypeRevision version)
-{
-    Q_ASSERT(type.isValid());
-    Q_ASSERT(type.containsRevisionedAttributes());
-    return QQmlMetaType::propertyCache(type, version);
-}
-
 QV4::ExecutionEngine *QQmlEnginePrivate::getV4Engine(QQmlEngine *e)
 {
     Q_ASSERT(e);
diff --git a/src/qml/qml/qqmlpropertybinding.cpp b/src/qml/qml/qqmlpropertybinding.cpp
index 7243615e3e..876e5e01af 100644
--- a/src/qml/qml/qqmlpropertybinding.cpp
+++ b/src/qml/qml/qqmlpropertybinding.cpp
@@ -179,7 +179,7 @@ void QQmlPropertyBindingJS::expressionChanged()
         const auto ctxt = context();
         QQmlEngine *engine = ctxt ? ctxt->engine() : nullptr;
         if (engine)
-            err.setDescription(asBinding()->createBindingLoopErrorDescription(QQmlEnginePrivate::get(engine)));
+            err.setDescription(asBinding()->createBindingLoopErrorDescription());
         else
             err.setDescription(QString::fromLatin1("Binding loop detected"));
         err.setObject(asBinding()->target());
@@ -230,7 +230,7 @@ void QQmlPropertyBinding::handleUndefinedAssignment(QQmlEnginePrivate *ep, void
     QQmlData *data = QQmlData::get(target(), false);
     Q_ASSERT(data);
     if (Q_UNLIKELY(!data->propertyCache))
-        data->propertyCache = ep->cache(target()->metaObject());
+        data->propertyCache = QQmlMetaType::propertyCache(target()->metaObject());
 
     propertyData = data->propertyCache->property(targetIndex().coreIndex());
     Q_ASSERT(propertyData);
@@ -293,14 +293,14 @@ void QQmlPropertyBinding::handleUndefinedAssignment(QQmlEnginePrivate *ep, void
     }
 }
 
-QString QQmlPropertyBinding::createBindingLoopErrorDescription(QJSEnginePrivate *ep)
+QString QQmlPropertyBinding::createBindingLoopErrorDescription()
 {
     QQmlPropertyData *propertyData = nullptr;
     QQmlPropertyData valueTypeData;
     QQmlData *data = QQmlData::get(target(), false);
     Q_ASSERT(data);
     if (Q_UNLIKELY(!data->propertyCache))
-        data->propertyCache = ep->cache(target()->metaObject());
+        data->propertyCache = QQmlMetaType::propertyCache(target()->metaObject());
 
     propertyData = data->propertyCache->property(targetIndex().coreIndex());
     Q_ASSERT(propertyData);
@@ -316,7 +316,6 @@ void QQmlPropertyBinding::bindingErrorCallback(QPropertyBindingPrivate *that)
     auto engine = qmlEngine(target);
     if (!engine)
         return;
-    auto ep = QQmlEnginePrivate::get(engine);
 
     auto error = This->bindingError();
     QQmlError qmlError;
@@ -326,11 +325,11 @@ void QQmlPropertyBinding::bindingErrorCallback(QPropertyBindingPrivate *that)
     qmlError.setUrl(QUrl {location.sourceFile});
     auto description = error.description();
     if (error.type() == QPropertyBindingError::BindingLoop) {
-        description = This->createBindingLoopErrorDescription(ep);
+        description = This->createBindingLoopErrorDescription();
     }
     qmlError.setDescription(description);
     qmlError.setObject(target);
-    ep->warning(qmlError);
+    QQmlEnginePrivate::get(engine)->warning(qmlError);
 }
 
 QUntypedPropertyBinding QQmlTranslationPropertyBinding::create(const QQmlPropertyData *pd, const QQmlRefPointer<QV4::ExecutableCompilationUnit> &compilationUnit, const QV4::CompiledData::Binding *binding)
diff --git a/src/qml/qml/qqmlpropertybinding_p.h b/src/qml/qml/qqmlpropertybinding_p.h
index d06891fab3..b6c7aa8cec 100644
--- a/src/qml/qml/qqmlpropertybinding_p.h
+++ b/src/qml/qml/qqmlpropertybinding_p.h
@@ -170,7 +170,7 @@ private:
 
     Q_NEVER_INLINE void handleUndefinedAssignment(QQmlEnginePrivate *ep, void *dataPtr);
 
-    QString createBindingLoopErrorDescription(QJSEnginePrivate *ep);
+    QString createBindingLoopErrorDescription();
 
     struct TargetData {
         enum BoundFunction : bool {
diff --git a/src/qml/qml/qqmlpropertycachecreator.cpp b/src/qml/qml/qqmlpropertycachecreator.cpp
index 6d3b8ca030..c1a0da0295 100644
--- a/src/qml/qml/qqmlpropertycachecreator.cpp
+++ b/src/qml/qml/qqmlpropertycachecreator.cpp
@@ -136,7 +136,7 @@ QQmlRefPointer<QQmlPropertyCache> QQmlBindingInstantiationContext::instantiating
             return enginePrivate->rawPropertyCacheForType(instantiatingProperty->propType(),
                                                           instantiatingProperty->typeVersion());
         } else if (const QMetaObject *vtmo = QQmlMetaType::metaObjectForValueType(instantiatingProperty->propType())) {
-            return enginePrivate->cache(vtmo, instantiatingProperty->typeVersion());
+            return QQmlMetaType::propertyCache(vtmo, instantiatingProperty->typeVersion());
         }
     }
     return QQmlRefPointer<QQmlPropertyCache>();
diff --git a/src/qml/qml/qqmlpropertycachecreator_p.h b/src/qml/qml/qqmlpropertycachecreator_p.h
index fc30b88889..635819cfff 100644
--- a/src/qml/qml/qqmlpropertycachecreator_p.h
+++ b/src/qml/qml/qqmlpropertycachecreator_p.h
@@ -308,7 +308,7 @@ inline QQmlError QQmlPropertyCacheCreator<ObjectContainer>::buildMetaObjectRecur
                         const CompiledObject *obj = objectContainer->objectAt(context.referencingObjectIndex);
                         auto *typeRef = objectContainer->resolvedType(obj->inheritedTypeNameIndex);
                         Q_ASSERT(typeRef);
-                        QQmlRefPointer<QQmlPropertyCache> baseTypeCache = typeRef->createPropertyCache(QQmlEnginePrivate::get(enginePrivate));
+                        QQmlRefPointer<QQmlPropertyCache> baseTypeCache = typeRef->createPropertyCache();
                         QQmlError error = createMetaObject(context.referencingObjectIndex, obj, baseTypeCache);
                         if (error.isValid())
                             return error;
@@ -403,7 +403,7 @@ inline QQmlRefPointer<QQmlPropertyCache> QQmlPropertyCacheCreator<ObjectContaine
             }
         }
 
-        return typeRef->createPropertyCache(QQmlEnginePrivate::get(enginePrivate));
+        return typeRef->createPropertyCache();
     } else if (const QV4::CompiledData::Binding *binding = context.instantiatingBinding) {
         if (binding->isAttachedProperty()) {
             auto *typeRef = objectContainer->resolvedType(
@@ -420,7 +420,7 @@ inline QQmlRefPointer<QQmlPropertyCache> QQmlPropertyCacheCreator<ObjectContaine
                 *error = qQmlCompileError(binding->location, QQmlPropertyCacheCreatorBase::tr("Non-existent attached object"));
                 return nullptr;
             }
-            return enginePrivate->cache(attachedMo);
+            return QQmlMetaType::propertyCache(attachedMo);
         } else if (binding->isGroupProperty()) {
             const auto *obj = objectContainer->objectAt(binding->value.objectIndex);
             if (!stringAt(obj->inheritedTypeNameIndex).isEmpty())
diff --git a/src/qml/qml/qqmlpropertyvalidator.cpp b/src/qml/qml/qqmlpropertyvalidator.cpp
index daaec2e3aa..91a5d8ec41 100644
--- a/src/qml/qml/qqmlpropertyvalidator.cpp
+++ b/src/qml/qml/qqmlpropertyvalidator.cpp
@@ -710,7 +710,7 @@ QQmlError QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *propert
 
         const QV4::CompiledData::Object *targetObject = compilationUnit->objectAt(binding->value.objectIndex);
         if (auto *typeRef = resolvedType(targetObject->inheritedTypeNameIndex)) {
-            QQmlRefPointer<QQmlPropertyCache> cache = typeRef->createPropertyCache(QQmlEnginePrivate::get(enginePrivate));
+            QQmlRefPointer<QQmlPropertyCache> cache = typeRef->createPropertyCache();
             const QMetaObject *mo = cache->firstCppMetaObject();
             QQmlType qmlType;
             while (mo && !qmlType.isValid()) {
diff --git a/src/qml/qml/qqmltypecompiler.cpp b/src/qml/qml/qqmltypecompiler.cpp
index 6c4e65aa57..604afb5d5e 100644
--- a/src/qml/qml/qqmltypecompiler.cpp
+++ b/src/qml/qml/qqmltypecompiler.cpp
@@ -350,7 +350,7 @@ bool SignalHandlerResolver::resolveSignalHandlerExpressions(
             const QMetaObject *attachedType = type.attachedPropertiesType(enginePrivate);
             if (!attachedType)
                 COMPILE_EXCEPTION(binding, tr("Non-existent attached object"));
-            QQmlRefPointer<QQmlPropertyCache> cache = compiler->enginePrivate()->cache(attachedType);
+            QQmlRefPointer<QQmlPropertyCache> cache = QQmlMetaType::propertyCache(attachedType);
             if (!resolveSignalHandlerExpressions(attachedObj, bindingPropertyName, cache.data()))
                 return false;
             continue;
@@ -856,7 +856,7 @@ void QQmlComponentAndAliasResolver::findAndRegisterImplicitComponents(
         const int componentIndex = qmlObjects->count() - 1;
         // Keep property caches symmetric
         QQmlRefPointer<QQmlPropertyCache> componentCache
-                = enginePrivate->cache(&QQmlComponent::staticMetaObject);
+                = QQmlMetaType::propertyCache(&QQmlComponent::staticMetaObject);
         propertyCaches.append(componentCache);
 
         QmlIR::Binding *syntheticBinding = pool->New<QmlIR::Binding>();
diff --git a/src/qml/qml/qqmltypedata.cpp b/src/qml/qml/qqmltypedata.cpp
index 6698b6d78e..542862aad5 100644
--- a/src/qml/qml/qqmltypedata.cpp
+++ b/src/qml/qml/qqmltypedata.cpp
@@ -252,14 +252,15 @@ void QQmlTypeData::createTypeAndPropertyCaches(
     pendingGroupPropertyBindings.resolveMissingPropertyCaches(engine, &m_compiledData->propertyCaches);
 }
 
-static bool addTypeReferenceChecksumsToHash(const QList<QQmlTypeData::TypeReference> &typeRefs, QCryptographicHash *hash, QQmlEngine *engine)
+static bool addTypeReferenceChecksumsToHash(
+        const QList<QQmlTypeData::TypeReference> &typeRefs, QCryptographicHash *hash)
 {
     for (const auto &typeRef: typeRefs) {
         if (typeRef.typeData) {
             const auto unit = typeRef.typeData->compilationUnit()->unitData();
             hash->addData(unit->md5Checksum, sizeof(unit->md5Checksum));
         } else if (typeRef.type.isValid()) {
-            const auto propertyCache = QQmlEnginePrivate::get(engine)->cache(typeRef.type.metaObject());
+            const auto propertyCache = QQmlMetaType::propertyCache(typeRef.type.metaObject());
             bool ok = false;
             hash->addData(propertyCache->checksum(&ok));
             if (!ok)
@@ -417,12 +418,10 @@ void QQmlTypeData::done()
         }
     }
 
-    QQmlEngine *const engine = typeLoader()->engine();
-
-    const auto dependencyHasher = [engine, &resolvedTypeCache, this]() {
+    const auto dependencyHasher = [&resolvedTypeCache, this]() {
         QCryptographicHash hash(QCryptographicHash::Md5);
-        return (resolvedTypeCache.addToHash(&hash, engine)
-                && ::addTypeReferenceChecksumsToHash(m_compositeSingletons, &hash, engine))
+        return (resolvedTypeCache.addToHash(&hash)
+                && ::addTypeReferenceChecksumsToHash(m_compositeSingletons, &hash))
                 ? hash.result()
                 : QByteArray();
     };
@@ -451,7 +450,7 @@ void QQmlTypeData::done()
         return;
 
     {
-        QQmlEnginePrivate *const enginePrivate = QQmlEnginePrivate::get(engine);
+        QQmlEnginePrivate *const enginePrivate = QQmlEnginePrivate::get(typeLoader()->engine());
         m_compiledData->inlineComponentData = m_inlineComponentData;
         {
             // Sanity check property bindings
@@ -954,7 +953,7 @@ QQmlError QQmlTypeData::buildTypeResolutionCaches(
             }
 
             if (qmlType.containsRevisionedAttributes())
-                ref->setTypePropertyCache(engine->cache(qmlType, resolvedType->version));
+                ref->setTypePropertyCache(QQmlMetaType::propertyCache(qmlType, resolvedType->version));
         }
         ref->setVersion(resolvedType->version);
         ref->doDynamicTypeCheck();
diff --git a/src/quick/designer/qqmldesignermetaobject.cpp b/src/quick/designer/qqmldesignermetaobject.cpp
index 90fdbddabf..f7be623030 100644
--- a/src/quick/designer/qqmldesignermetaobject.cpp
+++ b/src/quick/designer/qqmldesignermetaobject.cpp
@@ -107,7 +107,7 @@ QQmlDesignerMetaObject* QQmlDesignerMetaObject::getNodeInstanceMetaObject(QObjec
     return mo;
 }
 
-void QQmlDesignerMetaObject::init(QObject *object, QQmlEngine *engine)
+void QQmlDesignerMetaObject::init(QObject *object)
 {
     //Creating QQmlOpenMetaObjectType
     m_openMetaObject = std::make_unique<QQmlOpenMetaObject>(object, metaObjectParent());
@@ -118,7 +118,7 @@ void QQmlDesignerMetaObject::init(QObject *object, QQmlEngine *engine)
     QObjectPrivate *op = QObjectPrivate::get(object);
     op->metaObject = this;
 
-    cache = QQmlEnginePrivate::get(engine)->cache(metaObject);
+    cache = QQmlMetaType::propertyCache(metaObject);
 
     nodeInstanceMetaObjectList.insert(this, true);
 }
@@ -128,7 +128,7 @@ QQmlDesignerMetaObject::QQmlDesignerMetaObject(QObject *object, QQmlEngine *engi
       m_context(engine->contextForObject(object)),
       m_data(new MetaPropertyData)
 {
-    init(object, engine);
+    init(object);
 
     QQmlData *ddata = QQmlData::get(object, false);
     //Assign cache to object
diff --git a/src/quick/designer/qqmldesignermetaobject_p.h b/src/quick/designer/qqmldesignermetaobject_p.h
index 08979b1492..454ed61d2e 100644
--- a/src/quick/designer/qqmldesignermetaobject_p.h
+++ b/src/quick/designer/qqmldesignermetaobject_p.h
@@ -96,7 +96,7 @@ protected:
 
 private:
     QQmlDesignerMetaObject(QObject *object, QQmlEngine *engine);
-    void init(QObject *, QQmlEngine *engine);
+    void init(QObject *);
     QQmlOpenMetaObjectType *type() const { return m_openMetaObject->type(); }
 
     QPointer<QQmlContext> m_context;
diff --git a/src/quick/designer/qquickdesignersupportproperties.cpp b/src/quick/designer/qquickdesignersupportproperties.cpp
index 9239f388a8..6027f7c35c 100644
--- a/src/quick/designer/qquickdesignersupportproperties.cpp
+++ b/src/quick/designer/qquickdesignersupportproperties.cpp
@@ -121,9 +121,9 @@ QObject *QQuickDesignerSupportProperties::readQObjectProperty(const QMetaPropert
     return QQmlMetaType::toQObject(metaProperty.read(object));
 }
 
-void QQuickDesignerSupportProperties::getPropertyCache(QObject *object, QQmlEngine *engine)
+void QQuickDesignerSupportProperties::getPropertyCache(QObject *object)
 {
-    QQmlEnginePrivate::get(engine)->cache(object->metaObject());
+    QQmlMetaType::propertyCache(object->metaObject());
 }
 
 static QQuickDesignerSupport::PropertyNameList propertyNameListForWritableProperties(QObject *object,
diff --git a/src/quick/designer/qquickdesignersupportproperties_p.h b/src/quick/designer/qquickdesignersupportproperties_p.h
index 5970eca9f1..6e9faddad1 100644
--- a/src/quick/designer/qquickdesignersupportproperties_p.h
+++ b/src/quick/designer/qquickdesignersupportproperties_p.h
@@ -88,7 +88,7 @@ public:
     static bool isPropertyQObject(const QMetaProperty &metaProperty);
     static QObject *readQObjectProperty(const QMetaProperty &metaProperty, QObject *object);
 
-    static void getPropertyCache(QObject *object, QQmlEngine *engine);
+    static void getPropertyCache(QObject *object);
     static bool isPropertyBlackListed(const QQuickDesignerSupport::PropertyName &propertyName);
     static QQuickDesignerSupport::PropertyNameList propertyNameListForWritableProperties(QObject *object);
     static QQuickDesignerSupport::PropertyNameList allPropertyNames(QObject *object,