QtQml: Remove QQmlTypeLoader from QQmlImport

The type loader belongs to the engine and we must not store it in
engine-independent data structures. We do want the import cache to be
stored in the type registry, though (in a separate change).

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

21 files changed, 210 insertions, 147 deletions

diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index 25484f2773..f0d9ecf143 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -109,6 +109,7 @@ class QQmlError;
 class QJSEngine;
 class QQmlEngine;
 class QQmlContextData;
+class QQmlTypeLoader;
 
 namespace QV4 {
 namespace Debugging {
@@ -173,6 +174,14 @@ public:
     QQmlEngine *qmlEngine() const { return m_qmlEngine; }
     QJSEngine *publicEngine;
 
+    template<typename TypeLoader = QQmlTypeLoader>
+    TypeLoader *typeLoader()
+    {
+        if (m_qmlEngine)
+            return TypeLoader::get(m_qmlEngine);
+        return nullptr;
+    }
+
     enum JSObjects {
         RootContext,
         ScriptContext,
diff --git a/src/qml/jsruntime/qv4function.cpp b/src/qml/jsruntime/qv4function.cpp
index ced169407a..7283565489 100644
--- a/src/qml/jsruntime/qv4function.cpp
+++ b/src/qml/jsruntime/qv4function.cpp
@@ -136,6 +136,8 @@ Function::Function(ExecutionEngine *engine, ExecutableCompilationUnit *unit,
 
     JSTypedFunction *synthesized = new JSTypedFunction;
 
+    QQmlTypeLoader *typeLoader = engine->typeLoader();
+
     auto findQmlType = [&](const CompiledData::ParameterType &param) {
         const quint32 type = param.typeNameIndexOrCommonType();
         if (param.indexIsCommonType()) {
@@ -146,8 +148,11 @@ Function::Function(ExecutionEngine *engine, ExecutableCompilationUnit *unit,
         if (type == 0)
             return QQmlType();
 
-        const QQmlType qmltype = unit->typeNameCache->query<QQmlImport::AllowRecursion>(
-                                                            unit->stringAt(type)).type;
+        const QQmlType qmltype = typeLoader
+                ? unit->typeNameCache->query<QQmlImport::AllowRecursion>(
+                                             unit->stringAt(type), typeLoader).type
+                : QQmlType();
+
         if (!qmltype.isValid() || qmltype.typeId().isValid())
             return qmltype;
 
diff --git a/src/qml/jsruntime/qv4qmlcontext.cpp b/src/qml/jsruntime/qv4qmlcontext.cpp
index 7b4e5e7387..708339013f 100644
--- a/src/qml/jsruntime/qv4qmlcontext.cpp
+++ b/src/qml/jsruntime/qv4qmlcontext.cpp
@@ -197,9 +197,11 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r
             return result->asReturnedValue();
     }
 
+    QQmlEnginePrivate *ep = QQmlEnginePrivate::get(v4->qmlEngine());
     if (context->imports() && (name->startsWithUpper() || context->valueTypesAreAddressable())) {
         // Search for attached properties, enums and imported scripts
-        QQmlTypeNameCache::Result r = context->imports()->query<QQmlImport::AllowRecursion>(name);
+        QQmlTypeNameCache::Result r = context->imports()->query<QQmlImport::AllowRecursion>(
+                name, QQmlTypeLoader::get(ep));
 
         if (r.isValid()) {
             if (hasProperty)
@@ -258,7 +260,6 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r
         // Fall through
     }
 
-    QQmlEnginePrivate *ep = QQmlEnginePrivate::get(v4->qmlEngine());
     Lookup * const originalLookup = lookup;
 
     decltype(lookup->qmlContextPropertyGetter) contextGetterFunction = QQmlContextWrapper::lookupContextObjectProperty;
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index 5ca64be73b..769f9abd7e 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -421,24 +421,29 @@ static OptionalReturnedValue getPropertyFromImports(
     if (!qmlContext || !qmlContext->imports())
         return OptionalReturnedValue();
 
-    QQmlTypeNameCache::Result r = qmlContext->imports()->query(name);
-
     if (hasProperty)
         *hasProperty = true;
 
-    if (!r.isValid())
-        return OptionalReturnedValue();
+    if (QQmlTypeLoader *typeLoader = v4->typeLoader()) {
+        QQmlTypeNameCache::Result r = qmlContext->imports()->query(name, typeLoader);
+
+        if (!r.isValid())
+            return OptionalReturnedValue();
 
-    if (r.scriptIndex != -1) {
-        return OptionalReturnedValue(Encode::undefined());
-    } else if (r.type.isValid()) {
-        return OptionalReturnedValue(QQmlTypeWrapper::create(v4, qobj,r.type, Heap::QQmlTypeWrapper::ExcludeEnums));
-    } else if (r.importNamespace) {
-        return OptionalReturnedValue(QQmlTypeWrapper::create(
-                                         v4, qobj, qmlContext->imports(), r.importNamespace,
-                                         Heap::QQmlTypeWrapper::ExcludeEnums));
+        if (r.scriptIndex != -1) {
+            return OptionalReturnedValue(Encode::undefined());
+        } else if (r.type.isValid()) {
+            return OptionalReturnedValue(
+                    QQmlTypeWrapper::create(v4, qobj,r.type, Heap::QQmlTypeWrapper::ExcludeEnums));
+        } else if (r.importNamespace) {
+            return OptionalReturnedValue(QQmlTypeWrapper::create(
+                    v4, qobj, qmlContext->imports(), r.importNamespace,
+                    Heap::QQmlTypeWrapper::ExcludeEnums));
+        }
+        Q_UNREACHABLE_RETURN(OptionalReturnedValue());
+    } else {
+        return OptionalReturnedValue();
     }
-    Q_UNREACHABLE_RETURN(OptionalReturnedValue());
 }
 
 ReturnedValue QObjectWrapper::getQmlProperty(
diff --git a/src/qml/qml/qqml.cpp b/src/qml/qml/qqml.cpp
index 6533deebf5..46e83d532e 100644
--- a/src/qml/qml/qqml.cpp
+++ b/src/qml/qml/qqml.cpp
@@ -1982,8 +1982,12 @@ static void initTypeWrapperLookup(
     if (importNamespace != AOTCompiledContext::InvalidStringId) {
         QV4::Scope scope(context->engine->handle());
         QV4::ScopedString import(scope, context->compilationUnit->runtimeStrings[importNamespace]);
+
+        QQmlTypeLoader *typeLoader = scope.engine->typeLoader();
+        Q_ASSERT(typeLoader);
         if (const QQmlImportRef *importRef
-                = context->qmlContext->imports()->query(import).importNamespace) {
+                = context->qmlContext->imports()->query(import, typeLoader).importNamespace) {
+
             QV4::Scoped<QV4::QQmlTypeWrapper> wrapper(
                         scope, QV4::QQmlTypeWrapper::create(
                             scope.engine, nullptr, context->qmlContext->imports(), importRef));
@@ -2042,12 +2046,16 @@ void AOTCompiledContext::initLoadAttachedLookup(
     QV4::ScopedString name(scope, compilationUnit->runtimeStrings[l->nameIndex]);
 
     QQmlType type;
+    QQmlTypeLoader *typeLoader = scope.engine->typeLoader();
+    Q_ASSERT(typeLoader);
     if (importNamespace != InvalidStringId) {
         QV4::ScopedString import(scope, compilationUnit->runtimeStrings[importNamespace]);
-        if (const QQmlImportRef *importRef = qmlContext->imports()->query(import).importNamespace)
-            type = qmlContext->imports()->query(name, importRef).type;
+        if (const QQmlImportRef *importRef
+                = qmlContext->imports()->query(import, typeLoader).importNamespace) {
+            type = qmlContext->imports()->query(name, importRef, typeLoader).type;
+        }
     } else {
-        type = qmlContext->imports()->query<QQmlImport::AllowRecursion>(name).type;
+        type = qmlContext->imports()->query<QQmlImport::AllowRecursion>(name, typeLoader).type;
     }
 
     if (!type.isValid()) {
diff --git a/src/qml/qml/qqmlcontext.cpp b/src/qml/qml/qqmlcontext.cpp
index ad73d708fc..cf6736deb9 100644
--- a/src/qml/qml/qqmlcontext.cpp
+++ b/src/qml/qml/qqmlcontext.cpp
@@ -453,7 +453,7 @@ QJSValue QQmlContext::importedScript(const QString &name) const
 {
     Q_D(const QQmlContext);
 
-    QQmlTypeNameCache::Result r = d->m_data->imports()->query(name);
+    QQmlTypeNameCache::Result r = d->m_data->imports()->query(name, QQmlTypeLoader::get(engine()));
     QV4::Scope scope(engine()->handle());
     QV4::ScopedObject scripts(scope, d->m_data->importedScripts().valueRef());
     return scripts ? QJSValuePrivate::fromReturnedValue(scripts->get(r.scriptIndex))
diff --git a/src/qml/qml/qqmlcustomparser.cpp b/src/qml/qml/qqmlcustomparser.cpp
index d3f43cb8c4..bd632d25a6 100644
--- a/src/qml/qml/qqmlcustomparser.cpp
+++ b/src/qml/qml/qqmlcustomparser.cpp
@@ -103,10 +103,13 @@ int QQmlCustomParser::evaluateEnum(const QString &script, bool *ok) const
     const QString scope = script.left(dot);
 
     if (scope != QLatin1String("Qt")) {
-        if (imports.isNull())
+        if (!engine || imports.isNull())
             return -1;
         QQmlType type;
 
+        QQmlTypeLoader *typeLoader = QQmlTypeLoader::get(engine);
+        Q_ASSERT(typeLoader);
+
         if (imports.isT1()) {
             QQmlImportNamespace *ns = nullptr;
 
@@ -115,7 +118,7 @@ int QQmlCustomParser::evaluateEnum(const QString &script, bool *ok) const
             bool recursionDetected = false;
 
             if (!imports.asT1()->resolveType(
-                        scope, &type, nullptr, &ns, nullptr,
+                        typeLoader, scope, &type, nullptr, &ns, nullptr,
                         QQmlType::AnyRegistrationType, &recursionDetected)) {
                 return -1;
             }
@@ -123,7 +126,7 @@ int QQmlCustomParser::evaluateEnum(const QString &script, bool *ok) const
             if (!type.isValid() && ns != nullptr) {
                 dot = nextDot(dot);
                 if (dot == -1 || !imports.asT1()->resolveType(
-                            script.left(dot), &type, nullptr, nullptr, nullptr,
+                            typeLoader, script.left(dot), &type, nullptr, nullptr, nullptr,
                             QQmlType::AnyRegistrationType, &recursionDetected)) {
                     return -1;
                 }
@@ -131,13 +134,15 @@ int QQmlCustomParser::evaluateEnum(const QString &script, bool *ok) const
         } else {
             // Allow recursion so that we can find enums from the same document.
             const QQmlTypeNameCache::Result result
-                    = imports.asT2()->query<QQmlImport::AllowRecursion>(scope);
+                    = imports.asT2()->query<QQmlImport::AllowRecursion>(scope, typeLoader);
             if (result.isValid()) {
                 type = result.type;
             } else if (result.importNamespace) {
                 dot = nextDot(dot);
-                if (dot != -1)
-                    type = imports.asT2()->query<QQmlImport::AllowRecursion>(script.left(dot)).type;
+                if (dot != -1) {
+                    type = imports.asT2()->query<QQmlImport::AllowRecursion>(
+                                                 script.left(dot), typeLoader).type;
+                }
             }
         }
 
@@ -196,10 +201,10 @@ int QQmlCustomParser::evaluateEnum(const QString &script, bool *ok) const
 */
 const QMetaObject *QQmlCustomParser::resolveType(const QString& name) const
 {
-    if (!imports.isT1())
+    if (!engine || !imports.isT1())
         return nullptr;
     QQmlType qmltype;
-    if (!imports.asT1()->resolveType(name, &qmltype, nullptr, nullptr, nullptr))
+    if (!imports.asT1()->resolveType(QQmlTypeLoader::get(engine), name, &qmltype, nullptr, nullptr))
         return nullptr;
     return qmltype.metaObject();
 }
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index d2a4aaf5a7..a5f6d4d531 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -2134,9 +2134,8 @@ LoadHelper::ResolveTypeResult LoadHelper::resolveType(QAnyStringView typeName)
     QTypeRevision versionReturn;
     QList<QQmlError> errors;
     QQmlImportNamespace *ns_return = nullptr;
-    m_importCache->resolveType(typeName.toString(), &type, &versionReturn,
-                               &ns_return,
-                               &errors);
+    m_importCache->resolveType(
+            typeLoader(), typeName.toString(), &type, &versionReturn, &ns_return, &errors);
     return {ResolveTypeResult::ModuleFound, type};
 }
 
diff --git a/src/qml/qml/qqmlimport.cpp b/src/qml/qml/qqmlimport.cpp
index 69657d1fda..4720923e15 100644
--- a/src/qml/qml/qqmlimport.cpp
+++ b/src/qml/qml/qqmlimport.cpp
@@ -450,8 +450,8 @@ QString QQmlImports::versionString(QTypeRevision version, ImportVersion versionM
   \sa addFileImport(), addLibraryImport
 */
 bool QQmlImports::resolveType(
-        const QHashedStringRef &type, QQmlType *type_return, QTypeRevision *version_return,
-        QQmlImportNamespace **ns_return, QList<QQmlError> *errors,
+        QQmlTypeLoader *typeLoader,  const QHashedStringRef &type, QQmlType *type_return,
+        QTypeRevision *version_return, QQmlImportNamespace **ns_return, QList<QQmlError> *errors,
         QQmlType::RegistrationType registrationType, bool *typeRecursionDetected) const
 {
     QQmlImportNamespace *ns = findQualifiedNamespace(type);
@@ -461,7 +461,7 @@ bool QQmlImports::resolveType(
         return true;
     }
     if (type_return) {
-        if (resolveType(type, version_return, type_return, errors, registrationType,
+        if (resolveType(typeLoader, type, version_return, type_return, errors, registrationType,
                         typeRecursionDetected)) {
             if (lcQmlImport().isDebugEnabled()) {
 #define RESOLVE_TYPE_DEBUG qCDebug(lcQmlImport) \
@@ -706,16 +706,16 @@ bool QQmlImportInstance::resolveType(QQmlTypeLoader *typeLoader, const QHashedSt
 }
 
 bool QQmlImports::resolveType(
-        const QHashedStringRef &type, QTypeRevision *version_return, QQmlType *type_return,
-        QList<QQmlError> *errors, QQmlType::RegistrationType registrationType,
-        bool *typeRecursionDetected) const
+        QQmlTypeLoader *typeLoader, const QHashedStringRef &type, QTypeRevision *version_return,
+        QQmlType *type_return, QList<QQmlError> *errors,
+        QQmlType::RegistrationType registrationType, bool *typeRecursionDetected) const
 {
     const QVector<QHashedStringRef> splitName = type.split(Dot);
     auto resolveTypeInNamespace = [&](
             QHashedStringRef unqualifiedtype, QQmlImportNamespace *nameSpace,
             QList<QQmlError> *errors) -> bool {
         if (nameSpace->resolveType(
-                    m_typeLoader, unqualifiedtype,  version_return, type_return, &m_base, errors,
+                    typeLoader, unqualifiedtype,  version_return, type_return, &m_base, errors,
                     registrationType, typeRecursionDetected))
             return true;
         if (nameSpace->imports.size() == 1
@@ -901,7 +901,7 @@ QQmlImportNamespace *QQmlImports::findQualifiedNamespace(const QHashedStringRef
 Import an extension defined by a qmldir file.
 */
 QTypeRevision QQmlImports::importExtension(
-        const QString &uri, QTypeRevision version, QQmlImportDatabase *database,
+        QQmlTypeLoader *typeLoader, const QString &uri, QTypeRevision version,
         const QQmlTypeLoaderQmldirContent *qmldir, QList<QQmlError> *errors)
 {
     Q_ASSERT(qmldir->hasContent());
@@ -924,17 +924,19 @@ QTypeRevision QQmlImports::importExtension(
     if (qmldir->plugins().isEmpty())
         return validVersion(version);
 
-    QQmlPluginImporter importer(uri, version, database, qmldir, m_typeLoader, errors);
+    QQmlPluginImporter importer(
+            uri, version, typeLoader->importDatabase(), qmldir, typeLoader, errors);
     return importer.importPlugins();
 }
 
-bool QQmlImports::getQmldirContent(const QString &qmldirIdentifier, const QString &uri,
-                                          QQmlTypeLoaderQmldirContent *qmldir, QList<QQmlError> *errors)
+bool QQmlImports::getQmldirContent(
+        QQmlTypeLoader *typeLoader, const QString &qmldirIdentifier, const QString &uri,
+        QQmlTypeLoaderQmldirContent *qmldir, QList<QQmlError> *errors)
 {
     Q_ASSERT(errors);
     Q_ASSERT(qmldir);
 
-    *qmldir = m_typeLoader->qmldirContent(qmldirIdentifier);
+    *qmldir = typeLoader->qmldirContent(qmldirIdentifier);
     if ((*qmldir).hasContent()) {
         // Ensure that parsing was successful
         if ((*qmldir).hasError()) {
@@ -1142,11 +1144,11 @@ QQmlImportInstance *QQmlImports::addImportToNamespace(
 }
 
 QTypeRevision QQmlImports::addLibraryImport(
-        QQmlImportDatabase *database, const QString &uri, const QString &prefix,
+        QQmlTypeLoader *typeLoader, const QString &uri, const QString &prefix,
         QTypeRevision version, const QString &qmldirIdentifier, const QString &qmldirUrl,
         ImportFlags flags, quint16 precedence, QList<QQmlError> *errors)
 {
-    Q_ASSERT(database);
+    Q_ASSERT(typeLoader);
     Q_ASSERT(errors);
 
     qCDebug(lcQmlImport)
@@ -1166,11 +1168,11 @@ QTypeRevision QQmlImports::addLibraryImport(
         QQmlTypeLoaderQmldirContent qmldir;
 
         if (!qmldirIdentifier.isEmpty()) {
-            if (!getQmldirContent(qmldirIdentifier, uri, &qmldir, errors))
+            if (!getQmldirContent(typeLoader, qmldirIdentifier, uri, &qmldir, errors))
                 return QTypeRevision();
 
             if (qmldir.hasContent()) {
-                version = importExtension(uri, version, database, &qmldir, errors);
+                version = importExtension(typeLoader, uri, version, &qmldir, errors);
                 if (!version.isValid())
                     return QTypeRevision();
 
@@ -1226,11 +1228,11 @@ QTypeRevision QQmlImports::addLibraryImport(
   In case of failure, the \a errors array will filled appropriately.
 */
 QTypeRevision QQmlImports::addFileImport(
-        QQmlImportDatabase *database, const QString &uri, const QString &prefix,
-        QTypeRevision version, ImportFlags flags, quint16 precedence,
-        QString *localQmldir, QList<QQmlError> *errors)
+        QQmlTypeLoader *typeLoader, const QString &uri, const QString &prefix,
+        QTypeRevision version, ImportFlags flags, quint16 precedence, QString *localQmldir,
+        QList<QQmlError> *errors)
 {
-    Q_ASSERT(database);
+    Q_ASSERT(typeLoader);
     Q_ASSERT(errors);
 
     qCDebug(lcQmlImport)
@@ -1260,7 +1262,7 @@ QTypeRevision QQmlImports::addFileImport(
     QString qmldirUrl = resolveLocalUrl(m_base, importUri + (importUri.endsWith(Slash)
                                                            ? String_qmldir
                                                            : Slash_qmldir));
-    qmldirUrl = m_typeLoader->engine()->interceptUrl(
+    qmldirUrl = typeLoader->engine()->interceptUrl(
                 QUrl(qmldirUrl), QQmlAbstractUrlInterceptor::QmldirFile).toString();
     QString qmldirIdentifier;
 
@@ -1270,7 +1272,7 @@ QTypeRevision QQmlImports::addFileImport(
         Q_ASSERT(!localFileOrQrc.isEmpty());
 
         const QString dir = localFileOrQrc.left(localFileOrQrc.lastIndexOf(Slash) + 1);
-        if (!m_typeLoader->directoryExists(dir)) {
+        if (!typeLoader->directoryExists(dir)) {
             if (precedence < QQmlImportInstance::Implicit) {
                 QQmlError error;
                 error.setDescription(QQmlImportDatabase::tr("\"%1\": no such directory").arg(uri));
@@ -1282,11 +1284,11 @@ QTypeRevision QQmlImports::addFileImport(
 
         // Transforms the (possible relative) uri into our best guess relative to the
         // import paths.
-        importUri = resolvedUri(dir, database);
+        importUri = resolvedUri(dir, typeLoader->importDatabase());
         if (importUri.endsWith(Slash))
             importUri.chop(1);
 
-        if (!m_typeLoader->absoluteFilePath(localFileOrQrc).isEmpty()) {
+        if (!typeLoader->absoluteFilePath(localFileOrQrc).isEmpty()) {
             qmldirIdentifier = localFileOrQrc;
             if (localQmldir)
                 *localQmldir = qmldirIdentifier;
@@ -1335,7 +1337,7 @@ QTypeRevision QQmlImports::addFileImport(
 
     if (!(flags & QQmlImports::ImportIncomplete) && !qmldirIdentifier.isEmpty()) {
         QQmlTypeLoaderQmldirContent qmldir;
-        if (!getQmldirContent(qmldirIdentifier, importUri, &qmldir, errors))
+        if (!getQmldirContent(typeLoader, qmldirIdentifier, importUri, &qmldir, errors))
             return QTypeRevision();
 
         if (qmldir.hasContent()) {
@@ -1349,7 +1351,7 @@ QTypeRevision QQmlImports::addFileImport(
                         errors, precedence);
             Q_ASSERT(inserted);
 
-            version = importExtension(importUri, version, database, &qmldir, errors);
+            version = importExtension(typeLoader, importUri, version, &qmldir, errors);
             if (!version.isValid())
                 return QTypeRevision();
 
@@ -1368,10 +1370,10 @@ QTypeRevision QQmlImports::addFileImport(
 }
 
 QTypeRevision QQmlImports::updateQmldirContent(
-        QQmlImportDatabase *database, const QString &uri, const QString &prefix,
+        QQmlTypeLoader *typeLoader, const QString &uri, const QString &prefix,
         const QString &qmldirIdentifier, const QString &qmldirUrl, QList<QQmlError> *errors)
 {
-    Q_ASSERT(database);
+    Q_ASSERT(typeLoader);
     Q_ASSERT(errors);
 
     qDebug(lcQmlImport)
@@ -1383,12 +1385,12 @@ QTypeRevision QQmlImports::updateQmldirContent(
 
     if (QQmlImportInstance *import = nameSpace->findImport(uri)) {
         QQmlTypeLoaderQmldirContent qmldir;
-        if (!getQmldirContent(qmldirIdentifier, uri, &qmldir, errors))
+        if (!getQmldirContent(typeLoader, qmldirIdentifier, uri, &qmldir, errors))
             return QTypeRevision();
 
         if (qmldir.hasContent()) {
             QTypeRevision version = importExtension(
-                        uri, import->version, database, &qmldir, errors);
+                    typeLoader, uri, import->version, &qmldir, errors);
             if (!version.isValid())
                 return QTypeRevision();
 
@@ -1420,7 +1422,7 @@ QTypeRevision QQmlImports::updateQmldirContent(
 }
 
 /*!
-  \fn QQmlImports::addImplicitImport(QQmlImportDatabase *importDb, QString *localQmldir, QList<QQmlError> *errors)
+  \fn QQmlImports::addImplicitImport(QQmlTypeLoader *typeLoader, QString *localQmldir, QList<QQmlError> *errors)
   \internal
 
   Adds an implicit "." file import.  This is equivalent to calling addFileImport(), but error
diff --git a/src/qml/qml/qqmlimport_p.h b/src/qml/qml/qqmlimport_p.h
index f827d69b02..4466c1c324 100644
--- a/src/qml/qml/qqmlimport_p.h
+++ b/src/qml/qml/qqmlimport_p.h
@@ -127,7 +127,7 @@ public:
     };
     Q_DECLARE_FLAGS(ImportFlags, ImportFlag)
 
-    QQmlImports(QQmlTypeLoader *loader) : m_typeLoader(loader) {}
+    QQmlImports() = default;
     ~QQmlImports()
     {
         while (QQmlImportNamespace *ns = m_qualifiedSets.takeFirst())
@@ -138,13 +138,14 @@ public:
     QUrl baseUrl() const { return m_baseUrl; }
 
     bool resolveType(
-            const QHashedStringRef &type, QQmlType *type_return, QTypeRevision *version_return,
-            QQmlImportNamespace **ns_return, QList<QQmlError> *errors = nullptr,
+            QQmlTypeLoader *typeLoader, const QHashedStringRef &type, QQmlType *type_return,
+            QTypeRevision *version_return, QQmlImportNamespace **ns_return,
+            QList<QQmlError> *errors = nullptr,
             QQmlType::RegistrationType registrationType = QQmlType::AnyRegistrationType,
             bool *typeRecursionDetected = nullptr) const;
 
     QTypeRevision addImplicitImport(
-            QQmlImportDatabase *importDb, QString *localQmldir, QList<QQmlError> *errors)
+            QQmlTypeLoader *typeLoader, QString *localQmldir, QList<QQmlError> *errors)
     {
         Q_ASSERT(errors);
         qCDebug(lcQmlImport) << "addImplicitImport:" << qPrintable(baseUrl().toString());
@@ -152,25 +153,25 @@ public:
         const ImportFlags flags =
                 ImportFlags(!isLocal(baseUrl()) ? ImportIncomplete : ImportNoFlag);
         return addFileImport(
-                    importDb, QLatin1String("."), QString(), QTypeRevision(),
-                    flags, QQmlImportInstance::Implicit, localQmldir, errors);
+                typeLoader, QLatin1String("."), QString(), QTypeRevision(), flags,
+                QQmlImportInstance::Implicit, localQmldir, errors);
     }
 
     bool addInlineComponentImport(
             QQmlImportInstance  *const importInstance, const QString &name, const QUrl importUrl);
 
     QTypeRevision addFileImport(
-            QQmlImportDatabase *importDb, const QString &uri, const QString &prefix,
+            QQmlTypeLoader *typeLoader, const QString &uri, const QString &prefix,
             QTypeRevision version, ImportFlags flags, quint16 precedence, QString *localQmldir,
             QList<QQmlError> *errors);
 
     QTypeRevision addLibraryImport(
-            QQmlImportDatabase *importDb, const QString &uri, const QString &prefix,
+            QQmlTypeLoader *typeLoader, const QString &uri, const QString &prefix,
             QTypeRevision version, const QString &qmldirIdentifier, const QString &qmldirUrl,
             ImportFlags flags, quint16 precedence, QList<QQmlError> *errors);
 
     QTypeRevision updateQmldirContent(
-            QQmlImportDatabase *importDb, const QString &uri, const QString &prefix,
+            QQmlTypeLoader *typeLoader, const QString &uri, const QString &prefix,
             const QString &qmldirIdentifier, const QString &qmldirUrl, QList<QQmlError> *errors);
 
     void populateCache(QQmlTypeNameCache *cache) const;
@@ -220,8 +221,9 @@ private:
     QQmlImportNamespace *importNamespace(const QString &prefix);
 
     bool resolveType(
-            const QHashedStringRef &type, QTypeRevision *version_return, QQmlType *type_return,
-            QList<QQmlError> *errors, QQmlType::RegistrationType registrationType,
+            QQmlTypeLoader *typeLoader, const QHashedStringRef &type, QTypeRevision *version_return,
+            QQmlType *type_return, QList<QQmlError> *errors,
+            QQmlType::RegistrationType registrationType,
             bool *typeRecursionDetected = nullptr) const;
 
     QQmlImportNamespace *findQualifiedNamespace(const QHashedStringRef &) const;
@@ -231,12 +233,12 @@ private:
             QTypeRevision version, QList<QQmlError> *errors);
 
     QTypeRevision importExtension(
-            const QString &uri, QTypeRevision version, QQmlImportDatabase *database,
+            QQmlTypeLoader *typeLoader, const QString &uri, QTypeRevision version,
             const QQmlTypeLoaderQmldirContent *qmldir, QList<QQmlError> *errors);
 
     bool getQmldirContent(
-            const QString &qmldirIdentifier, const QString &uri, QQmlTypeLoaderQmldirContent *qmldir,
-            QList<QQmlError> *errors);
+            QQmlTypeLoader *typeLoader,  const QString &qmldirIdentifier, const QString &uri,
+            QQmlTypeLoaderQmldirContent *qmldir, QList<QQmlError> *errors);
 
     QString resolvedUri(const QString &dir_arg, QQmlImportDatabase *database);
 
@@ -256,8 +258,6 @@ private:
 
     // storage of data related to imports with a namespace
     QFieldList<QQmlImportNamespace, &QQmlImportNamespace::nextNamespace> m_qualifiedSets;
-
-    QQmlTypeLoader *m_typeLoader = nullptr;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QQmlImports::ImportFlags)
diff --git a/src/qml/qml/qqmlobjectcreator.cpp b/src/qml/qml/qqmlobjectcreator.cpp
index 206a4ecc44..e2aaa330c7 100644
--- a/src/qml/qml/qqmlobjectcreator.cpp
+++ b/src/qml/qml/qqmlobjectcreator.cpp
@@ -788,16 +788,17 @@ bool QQmlObjectCreator::setPropertyBinding(const QQmlPropertyData *bindingProper
         QV4::ResolvedTypeReference *tr = resolvedType(binding->propertyNameIndex);
         Q_ASSERT(tr);
         QQmlType attachedType = tr->type();
+        QQmlEnginePrivate *enginePrivate = QQmlEnginePrivate::get(engine);
         if (!attachedType.isValid()) {
             QQmlTypeNameCache::Result res = context->imports()->query(
-                        stringAt(binding->propertyNameIndex));
+                    stringAt(binding->propertyNameIndex), QQmlTypeLoader::get(enginePrivate));
             if (res.isValid())
                 attachedType = res.type;
             else
                 return false;
         }
         QObject *qmlObject = qmlAttachedPropertiesObject(
-                _qobject, attachedType.attachedPropertiesFunction(QQmlEnginePrivate::get(engine)));
+                _qobject, attachedType.attachedPropertiesFunction(enginePrivate));
         if (!qmlObject) {
             recordError(binding->location,
                         QStringLiteral("Could not create attached properties object '%1'")
diff --git a/src/qml/qml/qqmlproperty.cpp b/src/qml/qml/qqmlproperty.cpp
index bed1d951c4..bdeb478a9b 100644
--- a/src/qml/qml/qqmlproperty.cpp
+++ b/src/qml/qml/qqmlproperty.cpp
@@ -247,10 +247,11 @@ void QQmlPropertyPrivate::initProperty(QObject *obj, const QString &name,
             // Types must begin with an uppercase letter (see checkRegistration()
             // in qqmlmetatype.cpp for the enforcement of this).
             if (typeNameCache && !pathName.isEmpty() && pathName.at(0).isUpper()) {
-                QQmlTypeNameCache::Result r = typeNameCache->query(pathName);
+                QQmlEnginePrivate *enginePrivate = QQmlEnginePrivate::get(engine);
+                QQmlTypeLoader *typeLoader = QQmlTypeLoader::get(enginePrivate);
+                QQmlTypeNameCache::Result r = typeNameCache->query(pathName, typeLoader);
                 if (r.isValid()) {
                     if (r.type.isValid()) {
-                        QQmlEnginePrivate *enginePrivate = QQmlEnginePrivate::get(engine);
                         QQmlAttachedPropertiesFunc func = r.type.attachedPropertiesFunction(enginePrivate);
                         if (!func) return; // Not an attachable type
 
@@ -262,12 +263,11 @@ void QQmlPropertyPrivate::initProperty(QObject *obj, const QString &name,
 
                         // TODO: Do we really _not_ want to query the namespaced types here?
                         r = typeNameCache->query<QQmlTypeNameCache::QueryNamespaced::No>(
-                                    path.at(ii), r.importNamespace);
+                                    path.at(ii), r.importNamespace, typeLoader);
 
                         if (!r.type.isValid())
                             return; // Invalid type in namespace
 
-                        QQmlEnginePrivate *enginePrivate = QQmlEnginePrivate::get(engine);
                         QQmlAttachedPropertiesFunc func = r.type.attachedPropertiesFunction(enginePrivate);
                         if (!func)
                             return; // Not an attachable type
diff --git a/src/qml/qml/qqmlpropertycachecreator_p.h b/src/qml/qml/qqmlpropertycachecreator_p.h
index 90fbe29832..b84d589b39 100644
--- a/src/qml/qml/qqmlpropertycachecreator_p.h
+++ b/src/qml/qml/qqmlpropertycachecreator_p.h
@@ -364,8 +364,9 @@ inline QQmlPropertyCache::ConstPtr QQmlPropertyCacheCreator<ObjectContainer>::pr
             Q_ASSERT(typeRef);
             QQmlType qmltype = typeRef->type();
             if (!qmltype.isValid()) {
-                imports->resolveType(stringAt(binding->propertyNameIndex),
-                                     &qmltype, nullptr, nullptr, nullptr);
+                imports->resolveType(
+                        QQmlTypeLoader::get(enginePrivate), stringAt(binding->propertyNameIndex),
+                        &qmltype, nullptr, nullptr);
             }
 
             const QMetaObject *attachedMo = qmltype.attachedPropertiesType(enginePrivate);
@@ -666,8 +667,9 @@ inline QQmlError QQmlPropertyCacheCreator<ObjectContainer>::createMetaObject(
             QQmlType qmltype;
             bool selfReference = false;
             if (!imports->resolveType(
-                    stringAt(p->commonTypeOrTypeNameIndex()), &qmltype, nullptr, nullptr,
-                    nullptr, QQmlType::AnyRegistrationType, &selfReference)) {
+                        QQmlTypeLoader::get(enginePrivate),
+                        stringAt(p->commonTypeOrTypeNameIndex()), &qmltype, nullptr, nullptr,
+                        nullptr, QQmlType::AnyRegistrationType, &selfReference)) {
                 return qQmlCompileError(p->location, QQmlPropertyCacheCreatorBase::tr("Invalid property type"));
             }
 
@@ -749,8 +751,9 @@ inline QMetaType QQmlPropertyCacheCreator<ObjectContainer>::metaTypeForParameter
         *customTypeName = typeName;
     QQmlType qmltype;
     bool selfReference = false;
-    if (!imports->resolveType(typeName, &qmltype, nullptr, nullptr, nullptr,
-                              QQmlType::AnyRegistrationType, &selfReference))
+    if (!imports->resolveType(
+                &enginePrivate->typeLoader, typeName, &qmltype, nullptr, nullptr, nullptr,
+                QQmlType::AnyRegistrationType, &selfReference))
         return QMetaType();
 
     if (!qmltype.isComposite()) {
diff --git a/src/qml/qml/qqmlpropertyvalidator.cpp b/src/qml/qml/qqmlpropertyvalidator.cpp
index aecce2da30..05b31829a7 100644
--- a/src/qml/qml/qqmlpropertyvalidator.cpp
+++ b/src/qml/qml/qqmlpropertyvalidator.cpp
@@ -201,7 +201,8 @@ QVector<QQmlError> QQmlPropertyValidator::validateObject(
             QQmlType type;
             QQmlImportNamespace *typeNamespace = nullptr;
             imports->resolveType(
-                        stringAt(binding->propertyNameIndex), &type, nullptr, &typeNamespace);
+                    QQmlTypeLoader::get(enginePrivate), stringAt(binding->propertyNameIndex),
+                    &type, nullptr, &typeNamespace);
             if (typeNamespace)
                 return recordError(binding->location, tr("Invalid use of namespace"));
             return recordError(binding->location, tr("Invalid attached object assignment"));
diff --git a/src/qml/qml/qqmltypecompiler.cpp b/src/qml/qml/qqmltypecompiler.cpp
index 12663b608b..243a9ee412 100644
--- a/src/qml/qml/qqmltypecompiler.cpp
+++ b/src/qml/qml/qqmltypecompiler.cpp
@@ -307,8 +307,11 @@ bool SignalHandlerResolver::resolveSignalHandlerExpressions(
             const QmlIR::Object *attachedObj = qmlObjects.at(binding->value.objectIndex);
             auto *typeRef = resolvedType(binding->propertyNameIndex);
             QQmlType type = typeRef ? typeRef->type() : QQmlType();
-            if (!type.isValid())
-                imports->resolveType(bindingPropertyName, &type, nullptr, nullptr, nullptr);
+            if (!type.isValid()) {
+                imports->resolveType(
+                        QQmlTypeLoader::get(enginePrivate), bindingPropertyName, &type, nullptr,
+                        nullptr);
+            }
 
             const QMetaObject *attachedType = type.attachedPropertiesType(enginePrivate);
             if (!attachedType)
@@ -542,7 +545,8 @@ bool QQmlEnumTypeResolver::tryQualifiedEnumAssignment(
         return true;
     }
     QQmlType type;
-    imports->resolveType(typeName, &type, nullptr, nullptr, nullptr);
+    imports->resolveType(
+            QQmlTypeLoader::get(compiler->enginePrivate()), typeName, &type, nullptr, nullptr);
 
     if (!type.isValid() && !isQtObject)
         return true;
@@ -604,7 +608,8 @@ int QQmlEnumTypeResolver::evaluateEnum(const QString &scope, QStringView enumNam
 
     if (scope != QLatin1String("Qt")) {
         QQmlType type;
-        imports->resolveType(scope, &type, nullptr, nullptr, nullptr);
+        imports->resolveType(
+                QQmlTypeLoader::get(compiler->enginePrivate()), scope, &type, nullptr, nullptr);
         if (!type.isValid())
             return -1;
         if (!enumName.isEmpty())
diff --git a/src/qml/qml/qqmltypedata.cpp b/src/qml/qml/qqmltypedata.cpp
index 597683f77b..9be9f323e4 100644
--- a/src/qml/qml/qqmltypedata.cpp
+++ b/src/qml/qml/qqmltypedata.cpp
@@ -588,13 +588,12 @@ bool QQmlTypeData::loadImplicitImport()
 
     m_importCache->setBaseUrl(finalUrl(), finalUrlString());
 
-    QQmlImportDatabase *importDatabase = typeLoader()->importDatabase();
     // For local urls, add an implicit import "." as most overridden lookup.
     // This will also trigger the loading of the qmldir and the import of any native
     // types from available plugins.
     QList<QQmlError> implicitImportErrors;
     QString localQmldir;
-    m_importCache->addImplicitImport(importDatabase, &localQmldir, &implicitImportErrors);
+    m_importCache->addImplicitImport(typeLoader(), &localQmldir, &implicitImportErrors);
 
     // When loading with QQmlImports::ImportImplicit, the imports are _appended_ to the namespace
     // in the order they are loaded. Therefore, the addImplicitImport above gets the highest
@@ -1039,17 +1038,17 @@ bool QQmlTypeData::resolveType(const QString &typeName, QTypeRevision &version,
     QQmlImportNamespace *typeNamespace = nullptr;
     QList<QQmlError> errors;
 
-    bool typeFound = m_importCache->resolveType(typeName, &ref.type, &version,
-                                                &typeNamespace, &errors, registrationType,
-                                                typeRecursionDetected);
+    bool typeFound = m_importCache->resolveType(
+            typeLoader(), typeName, &ref.type, &version, &typeNamespace, &errors, registrationType,
+            typeRecursionDetected);
     if (!typeNamespace && !typeFound && !m_implicitImportLoaded) {
         // Lazy loading of implicit import
         if (loadImplicitImport()) {
             // Try again to find the type
             errors.clear();
-            typeFound = m_importCache->resolveType(typeName, &ref.type, &version,
-                                                   &typeNamespace, &errors, registrationType,
-                                                   typeRecursionDetected);
+            typeFound = m_importCache->resolveType(
+                    typeLoader(), typeName, &ref.type, &version, &typeNamespace, &errors,
+                    registrationType, typeRecursionDetected);
         } else {
             return false; //loadImplicitImport() hit an error, and called setError already
         }
diff --git a/src/qml/qml/qqmltypeloader.cpp b/src/qml/qml/qqmltypeloader.cpp
index 2561943df4..0abe3db316 100644
--- a/src/qml/qml/qqmltypeloader.cpp
+++ b/src/qml/qml/qqmltypeloader.cpp
@@ -455,7 +455,7 @@ QQmlTypeLoader::Blob::PendingImport::PendingImport(
 
 QQmlTypeLoader::Blob::Blob(const QUrl &url, QQmlDataBlob::Type type, QQmlTypeLoader *loader)
   : QQmlDataBlob(url, type, loader)
-  , m_importCache(new QQmlImports(loader), QQmlRefPointer<QQmlImports>::Adopt)
+  , m_importCache(new QQmlImports(), QQmlRefPointer<QQmlImports>::Adopt)
 {
 }
 
@@ -530,8 +530,7 @@ bool QQmlTypeLoader::Blob::updateQmldir(const QQmlRefPointer<QQmlQmldirData> &da
     typeLoader()->setQmldirContent(qmldirIdentifier, data->content());
 
     const QTypeRevision version = m_importCache->updateQmldirContent(
-                typeLoader()->importDatabase(), import->uri, import->qualifier, qmldirIdentifier,
-                qmldirUrl, errors);
+            typeLoader(), import->uri, import->qualifier, qmldirIdentifier, qmldirUrl, errors);
     if (!version.isValid())
         return false;
 
@@ -567,7 +566,6 @@ bool QQmlTypeLoader::Blob::addScriptImport(const QQmlTypeLoader::Blob::PendingIm
 
 bool QQmlTypeLoader::Blob::addFileImport(const QQmlTypeLoader::Blob::PendingImportPtr &import, QList<QQmlError> *errors)
 {
-    QQmlImportDatabase *importDatabase = typeLoader()->importDatabase();
     QQmlImports::ImportFlags flags;
 
     QUrl importUrl(import->uri);
@@ -581,8 +579,8 @@ bool QQmlTypeLoader::Blob::addFileImport(const QQmlTypeLoader::Blob::PendingImpo
     }
 
     const QTypeRevision version = m_importCache->addFileImport(
-                importDatabase, import->uri, import->qualifier, import->version, flags,
-                import->precedence, nullptr, errors);
+            typeLoader(), import->uri, import->qualifier, import->version, flags,
+            import->precedence, nullptr, errors);
     if (!version.isValid())
         return false;
 
@@ -619,9 +617,8 @@ bool QQmlTypeLoader::Blob::addLibraryImport(const QQmlTypeLoader::Blob::PendingI
                 [&](const QString &qmldirFilePath, const QString &qmldirUrl) {
         // This is a local library import
         const QTypeRevision actualVersion = m_importCache->addLibraryImport(
-                    importDatabase, import->uri, import->qualifier,
-                    import->version, qmldirFilePath, qmldirUrl, import->flags, import->precedence,
-                    errors);
+                typeLoader(), import->uri, import->qualifier, import->version, qmldirFilePath,
+                qmldirUrl, import->flags, import->precedence, errors);
         if (!actualVersion.isValid())
             return false;
 
@@ -679,8 +676,8 @@ bool QQmlTypeLoader::Blob::addLibraryImport(const QQmlTypeLoader::Blob::PendingI
             || QQmlMetaType::latestModuleVersion(import->uri).isValid())) {
 
         if (!m_importCache->addLibraryImport(
-                    importDatabase, import->uri, import->qualifier, import->version,
-                    QString(), QString(), import->flags, import->precedence, errors).isValid()) {
+                    typeLoader(), import->uri, import->qualifier, import->version, QString(),
+                    QString(), import->flags, import->precedence, errors).isValid()) {
             return false;
         }
     } else {
@@ -699,9 +696,9 @@ bool QQmlTypeLoader::Blob::addLibraryImport(const QQmlTypeLoader::Blob::PendingI
         if (!remotePathList.isEmpty()) {
             // Add this library and request the possible locations for it
             const QTypeRevision version = m_importCache->addLibraryImport(
-                        importDatabase, import->uri, import->qualifier, import->version,
-                        QString(), QString(), import->flags | QQmlImports::ImportIncomplete,
-                        import->precedence, errors);
+                    typeLoader(), import->uri, import->qualifier, import->version, QString(),
+                    QString(), import->flags | QQmlImports::ImportIncomplete, import->precedence,
+                    errors);
 
             if (!version.isValid())
                 return false;
diff --git a/src/qml/qml/qqmltypeloader_p.h b/src/qml/qml/qqmltypeloader_p.h
index 7f6e43bcfb..7f0b593534 100644
--- a/src/qml/qml/qqmltypeloader_p.h
+++ b/src/qml/qml/qqmltypeloader_p.h
@@ -122,6 +122,23 @@ public:
     QQmlTypeLoader(QQmlEngine *);
     ~QQmlTypeLoader();
 
+    template<
+            typename Engine,
+            typename EnginePrivate = QQmlEnginePrivate,
+            typename = std::enable_if_t<std::is_same_v<Engine, QQmlEngine>>>
+    static QQmlTypeLoader *get(Engine *engine)
+    {
+        return get(EnginePrivate::get(engine));
+    }
+
+    template<
+            typename Engine,
+            typename = std::enable_if_t<std::is_same_v<Engine, QQmlEnginePrivate>>>
+    static QQmlTypeLoader *get(Engine *engine)
+    {
+        return &engine->typeLoader;
+    }
+
     QQmlImportDatabase *importDatabase() const;
     ChecksumCache *checksumCache() { return &m_checksumCache; }
     const ChecksumCache *checksumCache() const { return &m_checksumCache; }
diff --git a/src/qml/qml/qqmltypenamecache_p.h b/src/qml/qml/qqmltypenamecache_p.h
index 552db9f98c..7563e3225a 100644
--- a/src/qml/qml/qqmltypenamecache_p.h
+++ b/src/qml/qml/qqmltypenamecache_p.h
@@ -74,27 +74,29 @@ public:
     // Restrict the types allowed for key. We don't want QV4::ScopedString, for  example.
 
     template<QQmlImport::RecursionRestriction recursionRestriction = QQmlImport::PreventRecursion>
-    Result query(const QHashedStringRef &key) const
+    Result query(const QHashedStringRef &key, QQmlTypeLoader *typeLoader) const
     {
-        return doQuery<const QHashedStringRef &, recursionRestriction>(key);
+        return doQuery<const QHashedStringRef &, recursionRestriction>(key, typeLoader);
     }
 
     template<QueryNamespaced queryNamespaced = QueryNamespaced::Yes>
-    Result query(const QHashedStringRef &key, const QQmlImportRef *importNamespace) const
+    Result query(const QHashedStringRef &key, const QQmlImportRef *importNamespace,
+                 QQmlTypeLoader *typeLoader) const
     {
-        return doQuery<const QHashedStringRef &, queryNamespaced>(key, importNamespace);
+        return doQuery<const QHashedStringRef &, queryNamespaced>(key, importNamespace, typeLoader);
     }
 
     template<QQmlImport::RecursionRestriction recursionRestriction = QQmlImport::PreventRecursion>
-    Result query(const QV4::String *key) const
+    Result query(const QV4::String *key, QQmlTypeLoader *typeLoader) const
     {
-        return doQuery<const QV4::String *, recursionRestriction>(key);
+        return doQuery<const QV4::String *, recursionRestriction>(key, typeLoader);
     }
 
     template<QueryNamespaced queryNamespaced = QueryNamespaced::Yes>
-    Result query(const QV4::String *key, const QQmlImportRef *importNamespace) const
+    Result query(const QV4::String *key, const QQmlImportRef *importNamespace,
+                 QQmlTypeLoader *typeLoader) const
     {
-        return doQuery<const QV4::String *, queryNamespaced>(key, importNamespace);
+        return doQuery<const QV4::String *, queryNamespaced>(key, importNamespace, typeLoader);
     }
 
 private:
@@ -122,7 +124,7 @@ private:
     static QString toQString(const QV4::String *key) { return key->toQStringNoThrow(); }
 
     template<typename Key, QQmlImport::RecursionRestriction recursionRestriction>
-    Result doQuery(Key name) const
+    Result doQuery(Key name, QQmlTypeLoader *typeLoader) const
     {
         Result result = doQuery(m_namedImports, name);
 
@@ -141,9 +143,9 @@ private:
             QQmlType t;
             bool typeRecursionDetected = false;
             const bool typeFound = m_imports->resolveType(
-                        toHashedStringRef(name), &t, nullptr, &typeNamespace, &errors,
-                        QQmlType::AnyRegistrationType,
-                        recursionRestriction == QQmlImport::AllowRecursion
+                    typeLoader, toHashedStringRef(name), &t, nullptr, &typeNamespace, &errors,
+                    QQmlType::AnyRegistrationType,
+                    recursionRestriction == QQmlImport::AllowRecursion
                             ? &typeRecursionDetected
                             : nullptr);
             if (typeFound)
@@ -155,7 +157,7 @@ private:
     }
 
     template<typename Key, QueryNamespaced queryNamespaced>
-    Result doQuery(Key name, const QQmlImportRef *importNamespace) const
+    Result doQuery(Key name, const QQmlImportRef *importNamespace, QQmlTypeLoader *typeLoader) const
     {
         Q_ASSERT(importNamespace && importNamespace->scriptIndex == -1);
 
@@ -183,7 +185,7 @@ private:
             QList<QQmlError> errors;
             QQmlType t;
             bool typeFound = m_imports->resolveType(
-                        qualifiedTypeName, &t, nullptr, &typeNamespace, &errors);
+                        typeLoader, qualifiedTypeName, &t, nullptr, &typeNamespace, &errors);
             if (typeFound)
                 return Result(t);
         }
diff --git a/src/qml/qml/qqmltypewrapper.cpp b/src/qml/qml/qqmltypewrapper.cpp
index e48efbda3f..c76a7a93c6 100644
--- a/src/qml/qml/qqmltypewrapper.cpp
+++ b/src/qml/qml/qqmltypewrapper.cpp
@@ -192,14 +192,15 @@ ReturnedValue QQmlTypeWrapper::virtualGet(const Managed *m, PropertyKey id, cons
     QObject *object = w->d()->object;
     QQmlType type = w->d()->type();
 
+    QQmlEnginePrivate *enginePrivate = QQmlEnginePrivate::get(v4->qmlEngine());
     if (type.isValid()) {
 
         // singleton types are handled differently to other types.
         if (type.isSingleton()) {
-            QQmlEnginePrivate *e = QQmlEnginePrivate::get(v4->qmlEngine());
+
             QJSValue scriptSingleton;
             if (type.isQObjectSingleton() || type.isCompositeSingleton()) {
-                if (QObject *qobjectSingleton = e->singletonInstance<QObject*>(type)) {
+                if (QObject *qobjectSingleton = enginePrivate->singletonInstance<QObject*>(type)) {
                     // check for enum value
                     const bool includeEnums = w->d()->mode == Heap::QQmlTypeWrapper::IncludeEnums;
                     if (includeEnums && name->startsWithUpper()) {
@@ -208,7 +209,7 @@ ReturnedValue QQmlTypeWrapper::virtualGet(const Managed *m, PropertyKey id, cons
                         if (ok)
                             return QV4::Value::fromInt32(value).asReturnedValue();
 
-                        value = type.scopedEnumIndex(QQmlEnginePrivate::get(v4->qmlEngine()), name, &ok);
+                        value = type.scopedEnumIndex(enginePrivate, name, &ok);
                         if (ok) {
                             Scoped<QQmlScopedEnumWrapper> enumWrapper(scope, v4->memoryManager->allocate<QQmlScopedEnumWrapper>());
                             enumWrapper->d()->typePrivate = type.priv();
@@ -229,7 +230,7 @@ ReturnedValue QQmlTypeWrapper::virtualGet(const Managed *m, PropertyKey id, cons
                     return result;
                 }
             } else if (type.isQJSValueSingleton()) {
-                QJSValue scriptSingleton = e->singletonInstance<QJSValue>(type);
+                QJSValue scriptSingleton = enginePrivate->singletonInstance<QJSValue>(type);
                 if (!scriptSingleton.isUndefined()) {
                     // NOTE: if used in a binding, changes will not trigger re-evaluation since non-NOTIFYable.
                     QV4::ScopedObject o(scope, QJSValuePrivate::asReturnedValue(&scriptSingleton));
@@ -244,11 +245,11 @@ ReturnedValue QQmlTypeWrapper::virtualGet(const Managed *m, PropertyKey id, cons
 
             if (name->startsWithUpper()) {
                 bool ok = false;
-                int value = type.enumValue(QQmlEnginePrivate::get(v4->qmlEngine()), name, &ok);
+                int value = type.enumValue(enginePrivate, name, &ok);
                 if (ok)
                     return QV4::Value::fromInt32(value).asReturnedValue();
 
-                value = type.scopedEnumIndex(QQmlEnginePrivate::get(v4->qmlEngine()), name, &ok);
+                value = type.scopedEnumIndex(enginePrivate, name, &ok);
                 if (ok) {
                     Scoped<QQmlScopedEnumWrapper> enumWrapper(scope, v4->memoryManager->allocate<QQmlScopedEnumWrapper>());
                     enumWrapper->d()->typePrivate = type.priv();
@@ -278,7 +279,8 @@ ReturnedValue QQmlTypeWrapper::virtualGet(const Managed *m, PropertyKey id, cons
 
     } else if (w->d()->typeNamespace) {
         Q_ASSERT(w->d()->importNamespace);
-        QQmlTypeNameCache::Result r = w->d()->typeNamespace->query(name, w->d()->importNamespace);
+        QQmlTypeNameCache::Result r = w->d()->typeNamespace->query(
+                name, w->d()->importNamespace, QQmlTypeLoader::get(enginePrivate));
 
         if (r.isValid()) {
             if (r.type.isValid()) {
diff --git a/src/qml/types/qqmlbind.cpp b/src/qml/types/qqmlbind.cpp
index cb2da29c10..1386c3ae39 100644
--- a/src/qml/types/qqmlbind.cpp
+++ b/src/qml/types/qqmlbind.cpp
@@ -780,14 +780,16 @@ void QQmlBindPrivate::decodeBinding(
             Q_ASSERT(typeReference);
             QQmlType attachedType = typeReference->type();
             if (!attachedType.isValid()) {
-                const QQmlTypeNameCache::Result result
-                        = deferredData->context->imports()->query(propertySuffix);
-                if (!result.isValid()) {
-                    qmlWarning(q).nospace()
-                            << "Unknown name " << propertySuffix << ". The binding is ignored.";
-                    return;
+                if (QQmlTypeLoader *typeLoader = compilationUnit->engine->typeLoader()) {
+                    const QQmlTypeNameCache::Result result
+                            = deferredData->context->imports()->query(propertySuffix, typeLoader);
+                    if (!result.isValid()) {
+                        qmlWarning(q).nospace()
+                                << "Unknown name " << propertySuffix << ". The binding is ignored.";
+                        return;
+                    }
+                    attachedType = result.type;
                 }
-                attachedType = result.type;
             }
 
             QQmlContext *context = qmlContext(q);