Remove base-class dependency of QQmlPropertyCacheCreator

By not depending on QQmlCompilePass the code will be re-usable also
outside of the type compiler in the future.

Change-Id: I55c637886cf557d6d130c4f9325d6b0790cb2806
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

4 files changed, 31 insertions, 39 deletions

diff --git a/src/qml/compiler/qqmlpropertycachecreator.cpp b/src/qml/compiler/qqmlpropertycachecreator.cpp
index bd5bb3620d..c6cd29a317 100644
--- a/src/qml/compiler/qqmlpropertycachecreator.cpp
+++ b/src/qml/compiler/qqmlpropertycachecreator.cpp
@@ -68,12 +68,11 @@ QQmlPropertyCacheCreator::InstantiationContext::InstantiationContext(int referen
     }
 }
 
-QQmlPropertyCacheCreator::QQmlPropertyCacheCreator(QQmlTypeCompiler *typeCompiler, QQmlPropertyCacheVector *propertyCaches)
-    : QQmlCompilePass(typeCompiler)
-    , enginePrivate(typeCompiler->enginePrivate())
-    , qmlObjects(*typeCompiler->qmlObjects())
-    , imports(typeCompiler->imports())
-    , resolvedTypes(typeCompiler->resolvedTypes())
+QQmlPropertyCacheCreator::QQmlPropertyCacheCreator(QQmlPropertyCacheVector *propertyCaches, QQmlEnginePrivate *enginePrivate, const QQmlTypeCompiler *compiler, const QQmlImports *imports)
+    : enginePrivate(enginePrivate)
+    , compiler(compiler)
+    , qmlObjects(*compiler->qmlObjects())
+    , imports(imports)
     , propertyCaches(propertyCaches)
 {
     propertyCaches->resize(qmlObjects.count());
@@ -104,7 +103,7 @@ QQmlCompileError QQmlPropertyCacheCreator::buildMetaObjectRecursively(int object
                 if (context.instantiatingProperty && QQmlValueTypeFactory::isValueType(context.instantiatingProperty->propType)) {
                     if (!propertyCaches->needsVMEMetaObject(context.referencingObjectIndex)) {
                         const QmlIR::Object *obj = qmlObjects.at(context.referencingObjectIndex);
-                        auto *typeRef = resolvedTypes->value(obj->inheritedTypeNameIndex);
+                        auto *typeRef = compiler->resolvedTypes.value(obj->inheritedTypeNameIndex);
                         Q_ASSERT(typeRef);
                         QQmlPropertyCache *baseTypeCache = typeRef->createPropertyCache(QQmlEnginePrivate::get(enginePrivate));
                         QQmlCompileError error = createMetaObject(context.referencingObjectIndex, obj, baseTypeCache);
@@ -161,7 +160,7 @@ QQmlPropertyCache *QQmlPropertyCacheCreator::propertyCacheForObject(const QmlIR:
             return enginePrivate->cache(vtmo);
         }
     } else if (obj->inheritedTypeNameIndex != 0) {
-        auto *typeRef = resolvedTypes->value(obj->inheritedTypeNameIndex);
+        auto *typeRef = compiler->resolvedTypes.value(obj->inheritedTypeNameIndex);
         Q_ASSERT(typeRef);
 
         if (typeRef->isFullyDynamicType) {
@@ -181,7 +180,7 @@ QQmlPropertyCache *QQmlPropertyCacheCreator::propertyCacheForObject(const QmlIR:
 
         return typeRef->createPropertyCache(QQmlEnginePrivate::get(enginePrivate));
     } else if (context.instantiatingBinding && context.instantiatingBinding->isAttachedProperty()) {
-        auto *typeRef = resolvedTypes->value(context.instantiatingBinding->propertyNameIndex);
+        auto *typeRef = compiler->resolvedTypes.value(context.instantiatingBinding->propertyNameIndex);
         Q_ASSERT(typeRef);
         QQmlType *qmltype = typeRef->type;
         if (!qmltype) {
@@ -250,7 +249,7 @@ QQmlCompileError QQmlPropertyCacheCreator::createMetaObject(int objectIndex, con
     QByteArray newClassName;
 
     if (objectIndex == compiler->rootObjectIndex()) {
-        QString path = compiler->url().path();
+        const QString path = compiler->url().path();
         int lastSlash = path.lastIndexOf(QLatin1Char('/'));
         if (lastSlash > -1) {
             const QStringRef nameBase = path.midRef(lastSlash + 1, path.length() - lastSlash - 5);
diff --git a/src/qml/compiler/qqmlpropertycachecreator_p.h b/src/qml/compiler/qqmlpropertycachecreator_p.h
index 8dd4b2bc0f..6d575c6a99 100644
--- a/src/qml/compiler/qqmlpropertycachecreator_p.h
+++ b/src/qml/compiler/qqmlpropertycachecreator_p.h
@@ -54,11 +54,11 @@
 
 QT_BEGIN_NAMESPACE
 
-class QQmlPropertyCacheCreator : public QQmlCompilePass
+class QQmlPropertyCacheCreator
 {
     Q_DECLARE_TR_FUNCTIONS(QQmlPropertyCacheCreator)
 public:
-    QQmlPropertyCacheCreator(QQmlTypeCompiler *typeCompiler, QQmlPropertyCacheVector *propertyCaches);
+    QQmlPropertyCacheCreator(QQmlPropertyCacheVector *propertyCaches, QQmlEnginePrivate *enginePrivate, const QQmlTypeCompiler *compiler, const QQmlImports *imports);
     ~QQmlPropertyCacheCreator();
 
     QQmlCompileError buildMetaObjects();
@@ -76,11 +76,12 @@ protected:
     QQmlPropertyCache *propertyCacheForObject(const QmlIR::Object *obj, const InstantiationContext &context, QQmlCompileError *error) const;
     QQmlCompileError createMetaObject(int objectIndex, const QmlIR::Object *obj, QQmlPropertyCache *baseTypeCache);
 
+    QString stringAt(int index) const { return compiler->stringAt(index); }
 
-    QQmlEnginePrivate *enginePrivate;
+    QQmlEnginePrivate * const enginePrivate;
+    const QQmlTypeCompiler *compiler;
     const QVector<QmlIR::Object*> &qmlObjects;
-    const QQmlImports *imports;
-    QHash<int, QV4::CompiledData::CompilationUnit::ResolvedTypeReference*> *resolvedTypes;
+    const QQmlImports * const imports;
     QQmlPropertyCacheVector *propertyCaches;
 };
 
diff --git a/src/qml/compiler/qqmltypecompiler.cpp b/src/qml/compiler/qqmltypecompiler.cpp
index f2a8538b4c..e6a71c6e15 100644
--- a/src/qml/compiler/qqmltypecompiler.cpp
+++ b/src/qml/compiler/qqmltypecompiler.cpp
@@ -77,8 +77,8 @@ QV4::CompiledData::CompilationUnit *QQmlTypeCompiler::compile()
 
     typeData->imports().populateCache(importCache.data());
 
-    const QHash<int, QQmlTypeData::TypeReference> &resolvedTypes = typeData->resolvedTypeRefs();
-    for (QHash<int, QQmlTypeData::TypeReference>::ConstIterator resolvedType = resolvedTypes.constBegin(), end = resolvedTypes.constEnd();
+    const QHash<int, QQmlTypeData::TypeReference> &resolvedTypeRefs = typeData->resolvedTypeRefs();
+    for (QHash<int, QQmlTypeData::TypeReference>::ConstIterator resolvedType = resolvedTypeRefs.constBegin(), end = resolvedTypeRefs.constEnd();
          resolvedType != end; ++resolvedType) {
         QScopedPointer<QV4::CompiledData::CompilationUnit::ResolvedTypeReference> ref(new QV4::CompiledData::CompilationUnit::ResolvedTypeReference);
         QQmlType *qmlType = resolvedType->type;
@@ -109,12 +109,12 @@ QV4::CompiledData::CompilationUnit *QQmlTypeCompiler::compile()
         ref->majorVersion = resolvedType->majorVersion;
         ref->minorVersion = resolvedType->minorVersion;
         ref->doDynamicTypeCheck();
-        m_resolvedTypes.insert(resolvedType.key(), ref.take());
+        resolvedTypes.insert(resolvedType.key(), ref.take());
     }
 
     // Build property caches and VME meta object data
 
-    for (auto it = m_resolvedTypes.constBegin(), end = m_resolvedTypes.constEnd();
+    for (auto it = resolvedTypes.constBegin(), end = resolvedTypes.constEnd();
          it != end; ++it) {
         QQmlCustomParser *customParser = (*it)->type ? (*it)->type->customParser() : 0;
         if (customParser)
@@ -122,7 +122,7 @@ QV4::CompiledData::CompilationUnit *QQmlTypeCompiler::compile()
     }
 
     {
-        QQmlPropertyCacheCreator propertyCacheBuilder(this, &m_propertyCaches);
+        QQmlPropertyCacheCreator propertyCacheBuilder(&m_propertyCaches, engine, this, imports());
         QQmlCompileError error = propertyCacheBuilder.buildMetaObjects();
         if (error.isSet()) {
             recordError(error);
@@ -231,7 +231,7 @@ QV4::CompiledData::CompilationUnit *QQmlTypeCompiler::compile()
     compilationUnit = document->javaScriptCompilationUnit;
     compilationUnit->importCache = importCache;
     compilationUnit->dependentScripts = dependentScripts;
-    compilationUnit->resolvedTypes = m_resolvedTypes;
+    compilationUnit->resolvedTypes = resolvedTypes;
     compilationUnit->propertyCaches = std::move(m_propertyCaches);
     Q_ASSERT(compilationUnit->propertyCaches.count() == static_cast<int>(compilationUnit->data->nObjects));
 
@@ -240,7 +240,7 @@ QV4::CompiledData::CompilationUnit *QQmlTypeCompiler::compile()
         engine->registerInternalCompositeType(compilationUnit);
     else {
         const QV4::CompiledData::Object *obj = qmlUnit->objectAt(qmlUnit->indexOfRootObject);
-        auto *typeRef = m_resolvedTypes.value(obj->inheritedTypeNameIndex);
+        auto *typeRef = resolvedTypes.value(obj->inheritedTypeNameIndex);
         Q_ASSERT(typeRef);
         if (typeRef->compilationUnit) {
             compilationUnit->metaTypeId = typeRef->compilationUnit->metaTypeId;
@@ -263,7 +263,7 @@ QV4::CompiledData::CompilationUnit *QQmlTypeCompiler::compile()
     for (quint32 i = 0; i < qmlUnit->nObjects; ++i) {
         const QV4::CompiledData::Object *obj = qmlUnit->objectAt(i);
         bindingCount += obj->nBindings;
-        if (auto *typeRef = m_resolvedTypes.value(obj->inheritedTypeNameIndex)) {
+        if (auto *typeRef = resolvedTypes.value(obj->inheritedTypeNameIndex)) {
             if (QQmlType *qmlType = typeRef->type) {
                 if (qmlType->parserStatusCast() != -1)
                     ++parserStatusCount;
@@ -333,12 +333,7 @@ const QQmlImports *QQmlTypeCompiler::imports() const
     return &typeData->imports();
 }
 
-QHash<int, QV4::CompiledData::CompilationUnit::ResolvedTypeReference*> *QQmlTypeCompiler::resolvedTypes()
-{
-    return &m_resolvedTypes;
-}
-
-QVector<QmlIR::Object *> *QQmlTypeCompiler::qmlObjects()
+QVector<QmlIR::Object *> *QQmlTypeCompiler::qmlObjects() const
 {
     return &document->objects;
 }
@@ -402,7 +397,7 @@ SignalHandlerConverter::SignalHandlerConverter(QQmlTypeCompiler *typeCompiler)
     , qmlObjects(*typeCompiler->qmlObjects())
     , imports(typeCompiler->imports())
     , customParsers(typeCompiler->customParserCache())
-    , resolvedTypes(*typeCompiler->resolvedTypes())
+    , resolvedTypes(typeCompiler->resolvedTypes)
     , illegalNames(QV8Engine::get(QQmlEnginePrivate::get(typeCompiler->enginePrivate()))->illegalNames())
     , propertyCaches(typeCompiler->propertyCaches())
 {
@@ -613,7 +608,7 @@ QQmlEnumTypeResolver::QQmlEnumTypeResolver(QQmlTypeCompiler *typeCompiler)
     , qmlObjects(*typeCompiler->qmlObjects())
     , propertyCaches(typeCompiler->propertyCaches())
     , imports(typeCompiler->imports())
-    , resolvedTypes(typeCompiler->resolvedTypes())
+    , resolvedTypes(&typeCompiler->resolvedTypes)
 {
 }
 
@@ -872,7 +867,7 @@ QQmlComponentAndAliasResolver::QQmlComponentAndAliasResolver(QQmlTypeCompiler *t
     , qmlObjects(typeCompiler->qmlObjects())
     , indexOfRootObject(typeCompiler->rootObjectIndex())
     , _componentIndex(-1)
-    , resolvedTypes(typeCompiler->resolvedTypes())
+    , resolvedTypes(&typeCompiler->resolvedTypes)
     , propertyCaches(std::move(typeCompiler->takePropertyCaches()))
 {
 }
@@ -1342,7 +1337,7 @@ QQmlPropertyValidator::QQmlPropertyValidator(QQmlTypeCompiler *typeCompiler, con
     : QQmlCompilePass(typeCompiler)
     , enginePrivate(typeCompiler->enginePrivate())
     , qmlUnit(typeCompiler->qmlUnit())
-    , resolvedTypes(*typeCompiler->resolvedTypes())
+    , resolvedTypes(typeCompiler->resolvedTypes)
     , customParsers(typeCompiler->customParserCache())
     , propertyCaches(propertyCaches)
 {
@@ -2004,7 +1999,7 @@ bool QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *property, co
 
 QQmlJSCodeGenerator::QQmlJSCodeGenerator(QQmlTypeCompiler *typeCompiler, QmlIR::JSCodeGen *v4CodeGen)
     : QQmlCompilePass(typeCompiler)
-    , resolvedTypes(*typeCompiler->resolvedTypes())
+    , resolvedTypes(typeCompiler->resolvedTypes)
     , customParsers(typeCompiler->customParserCache())
     , qmlObjects(*typeCompiler->qmlObjects())
     , propertyCaches(typeCompiler->propertyCaches())
diff --git a/src/qml/compiler/qqmltypecompiler_p.h b/src/qml/compiler/qqmltypecompiler_p.h
index 29712e73e7..71d2d2337e 100644
--- a/src/qml/compiler/qqmltypecompiler_p.h
+++ b/src/qml/compiler/qqmltypecompiler_p.h
@@ -95,6 +95,7 @@ public:
     QString stringAt(int idx) const;
     QmlIR::PoolList<QmlIR::Function>::Iterator objectFunctionsBegin(const QmlIR::Object *object) const { return object->functionsBegin(); }
     QmlIR::PoolList<QmlIR::Function>::Iterator objectFunctionsEnd(const QmlIR::Object *object) const { return object->functionsEnd(); }
+    QHash<int, QV4::CompiledData::CompilationUnit::ResolvedTypeReference*> resolvedTypes;
     // ---
 
     QV4::CompiledData::CompilationUnit *compile();
@@ -113,8 +114,7 @@ public:
     QUrl url() const { return typeData->finalUrl(); }
     QQmlEnginePrivate *enginePrivate() const { return engine; }
     const QQmlImports *imports() const;
-    QHash<int, QV4::CompiledData::CompilationUnit::ResolvedTypeReference *> *resolvedTypes();
-    QVector<QmlIR::Object *> *qmlObjects();
+    QVector<QmlIR::Object *> *qmlObjects() const;
     int rootObjectIndex() const;
     void setPropertyCaches(QQmlPropertyCacheVector &&caches);
     const QQmlPropertyCacheVector *propertyCaches() const;
@@ -138,7 +138,6 @@ private:
     QmlIR::Document *document;
     // index is string index of type name (use obj->inheritedTypeNameIndex)
     QHash<int, QQmlCustomParser*> customParsers;
-    QHash<int, QV4::CompiledData::CompilationUnit::ResolvedTypeReference*> m_resolvedTypes;
 
     // index in first hash is component index, vector inside contains object indices of objects with id property
     QVector<quint32> m_componentRoots;
@@ -147,8 +146,6 @@ private:
 
 struct QQmlCompilePass
 {
-    virtual ~QQmlCompilePass() {}
-
     QQmlCompilePass(QQmlTypeCompiler *typeCompiler);
 
     QString stringAt(int idx) const { return compiler->stringAt(idx); }