Enable resolution of composite types in QQmlTypeNameCache

We didn't have resolution of composite types previously, which is a
prerequisite to do more exciting things with QML types in JavaScript
(such as instanceof).

By deferring the resolution to QQmlImports, we can avoid the need to
fill the cache with types that may not be needed, while still finding
types which are requested.

In the future, we could consider removing the "special" handling for composite
singletons as they should be found through QQmlImports now. If we do
that, we may still want to cache the QUrl for the types, to avoid using
QQmlImports too often directly, as it is a little slow itself.

This change doesn't regress tst_compilation.

Task-number: QTBUG-24799
Change-Id: I9ba2e4829ca49008fd180fb488c586475cf90674
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

1 files changed, 56 insertions, 1 deletions

diff --git a/src/qml/qml/qqmltypenamecache.cpp b/src/qml/qml/qqmltypenamecache.cpp
index c2098bc9a1..b5b14d1ae8 100644
--- a/src/qml/qml/qqmltypenamecache.cpp
+++ b/src/qml/qml/qqmltypenamecache.cpp
@@ -43,7 +43,8 @@
 
 QT_BEGIN_NAMESPACE
 
-QQmlTypeNameCache::QQmlTypeNameCache()
+QQmlTypeNameCache::QQmlTypeNameCache(const QQmlImports &importCache)
+    : m_imports(importCache)
 {
 }
 
@@ -70,6 +71,7 @@ void QQmlTypeNameCache::add(const QHashedString &name, int importedScriptIndex,
 {
     Import import;
     import.scriptIndex = importedScriptIndex;
+    import.m_qualifier = name;
 
     if (nameSpace.length() != 0) {
         Import *i = m_namedImports.value(nameSpace);
@@ -94,6 +96,18 @@ QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QHashedStringRef &name)
     if (!result.isValid())
         result = query(m_anonymousCompositeSingletons, name);
 
+    if (!result.isValid()) {
+        // Look up anonymous types from the imports of this document
+        QQmlImportNamespace *typeNamespace = 0;
+        QList<QQmlError> errors;
+        QQmlType *t = 0;
+        bool typeFound = m_imports.resolveType(name, &t, 0, 0, &typeNamespace, &errors);
+        if (typeFound) {
+            return Result(t);
+        }
+
+    }
+
     return result;
 }
 
@@ -109,6 +123,20 @@ QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QHashedStringRef &name,
     if (!result.isValid())
         result = query(i->compositeSingletons, name);
 
+    if (!result.isValid()) {
+        // Look up types from the imports of this document
+        // ### it would be nice if QQmlImports allowed us to resolve a namespace
+        // first, and then types on it.
+        QString qualifiedTypeName = i->m_qualifier + "." + name.toString();
+        QQmlImportNamespace *typeNamespace = 0;
+        QList<QQmlError> errors;
+        QQmlType *t = 0;
+        bool typeFound = m_imports.resolveType(qualifiedTypeName, &t, 0, 0, &typeNamespace, &errors);
+        if (typeFound) {
+            return Result(t);
+        }
+    }
+
     return result;
 }
 
@@ -122,6 +150,19 @@ QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QV4::String *name) cons
     if (!result.isValid())
         result = query(m_anonymousCompositeSingletons, name);
 
+    if (!result.isValid()) {
+        // Look up anonymous types from the imports of this document
+        QString typeName = name->toQStringNoThrow();
+        QQmlImportNamespace *typeNamespace = 0;
+        QList<QQmlError> errors;
+        QQmlType *t = 0;
+        bool typeFound = m_imports.resolveType(typeName, &t, 0, 0, &typeNamespace, &errors);
+        if (typeFound) {
+            return Result(t);
+        }
+
+    }
+
     return result;
 }
 
@@ -143,6 +184,20 @@ QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QV4::String *name, cons
     if (!r.isValid())
         r = query(i->compositeSingletons, name);
 
+    if (!r.isValid()) {
+        // Look up types from the imports of this document
+        // ### it would be nice if QQmlImports allowed us to resolve a namespace
+        // first, and then types on it.
+        QString qualifiedTypeName = i->m_qualifier + "." + name->toQStringNoThrow();
+        QQmlImportNamespace *typeNamespace = 0;
+        QList<QQmlError> errors;
+        QQmlType *t = 0;
+        bool typeFound = m_imports.resolveType(qualifiedTypeName, &t, 0, 0, &typeNamespace, &errors);
+        if (typeFound) {
+            return Result(t);
+        }
+    }
+
     return r;
 }