Unify QQmlJSImportVisitor and FindWarningsVisitor

They are both pretty much doing the same thing, except that the import
visitor is not as thorough. We need the full analysis in QtQmlCompiler,
so we successively move the code over.

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

5 files changed, 199 insertions, 106 deletions

diff --git a/src/qmlcompiler/qqmljsimportvisitor.cpp b/src/qmlcompiler/qqmljsimportvisitor.cpp
index 0cb5632d40..ac21c7715e 100644
--- a/src/qmlcompiler/qqmljsimportvisitor.cpp
+++ b/src/qmlcompiler/qqmljsimportvisitor.cpp
@@ -28,21 +28,46 @@
 
 #include "qqmljsimportvisitor_p.h"
 
+#include <QtCore/qfileinfo.h>
+#include <QtCore/qdir.h>
+
 QT_BEGIN_NAMESPACE
 
 using namespace QQmlJS::AST;
 
-QQmlJSScope::Ptr QQmlJSImportVisitor::result(const QString &scopeName) const
+QQmlJSImportVisitor::QQmlJSImportVisitor(
+        QQmlJSImporter *importer, const QString &implicitImportDirectory,
+        const QStringList &qmltypesFiles)
+    : m_implicitImportDirectory(implicitImportDirectory)
+    , m_qmltypesFiles(qmltypesFiles)
+    , m_currentScope(QQmlJSScope::create(QQmlJSScope::JSFunctionScope))
+    , m_importer(importer)
+{
+    m_globalScope = m_currentScope;
+}
+
+void QQmlJSImportVisitor::enterEnvironment(QQmlJSScope::ScopeType type, const QString &name)
+{
+    m_currentScope = QQmlJSScope::create(type, m_currentScope);
+    m_currentScope->setBaseTypeName(name);
+    m_currentScope->setIsComposite(true);
+}
+
+void QQmlJSImportVisitor::leaveEnvironment()
+{
+    m_currentScope = m_currentScope->parentScope();
+}
+
+QQmlJSScope::Ptr QQmlJSImportVisitor::result() const
 {
     QQmlJSScope::Ptr result = QQmlJSScope::create();
     result->setIsComposite(true);
-    result->setInternalName(scopeName);
-    result->setBaseTypeName(m_rootObject->baseTypeName());
-    const auto properties = m_rootObject->properties();
+    result->setBaseTypeName(m_qmlRootScope->baseTypeName());
+    const auto properties = m_qmlRootScope->properties();
     for (auto property : properties) {
         if (property.isAlias()) {
-            const auto it = m_objects.find(property.typeName());
-            if (it != m_objects.end())
+            const auto it = m_scopesById.find(property.typeName());
+            if (it != m_scopesById.end())
                 property.setType(QQmlJSScope::ConstPtr(*it));
             result->addProperty(property);
         } else {
@@ -50,34 +75,47 @@ QQmlJSScope::Ptr QQmlJSImportVisitor::result(const QString &scopeName) const
         }
     }
 
-    for (const auto &method : m_rootObject->methods())
+    for (const auto &method : m_qmlRootScope->methods())
         result->addMethod(method);
 
-    for (const auto &enumerator : m_rootObject->enums())
+    for (const auto &enumerator : m_qmlRootScope->enums())
         result->addEnum(enumerator);
 
+    result->resolveTypes(m_rootScopeImports);
     return result;
 }
 
+bool QQmlJSImportVisitor::visit(QQmlJS::AST::UiProgram *)
+{
+    m_rootScopeImports = m_importer->importBuiltins();
+
+    if (!m_qmltypesFiles.isEmpty())
+        m_rootScopeImports.insert(m_importer->importQmltypes(m_qmltypesFiles));
+
+    m_rootScopeImports.insert(m_importer->importDirectory(m_implicitImportDirectory));
+
+    m_errors.append(m_importer->takeWarnings());
+    return true;
+}
+
 bool QQmlJSImportVisitor::visit(UiObjectDefinition *definition)
 {
-    QQmlJSScope::Ptr scope = QQmlJSScope::create();
     QString superType;
     for (auto segment = definition->qualifiedTypeNameId; segment; segment = segment->next) {
         if (!superType.isEmpty())
             superType.append(u'.');
         superType.append(segment->name.toString());
     }
-    scope->setBaseTypeName(superType);
-    if (!m_rootObject)
-        m_rootObject = scope;
-    m_currentObjects.append(scope);
+    enterEnvironment(QQmlJSScope::QMLScope, superType);
+    if (!m_qmlRootScope)
+        m_qmlRootScope = m_currentScope;
+
     return true;
 }
 
 void QQmlJSImportVisitor::endVisit(UiObjectDefinition *)
 {
-    m_currentObjects.pop_back();
+    leaveEnvironment();
 }
 
 bool QQmlJSImportVisitor::visit(UiPublicMember *publicMember)
@@ -92,7 +130,7 @@ bool QQmlJSImportVisitor::visit(UiPublicMember *publicMember)
             method.addParameter(param->name.toString(), param->type->name.toString());
             param = param->next;
         }
-        currentObject()->addMethod(method);
+        m_currentScope->addMethod(method);
         break;
     }
     case UiPublicMember::Property: {
@@ -112,48 +150,81 @@ bool QQmlJSImportVisitor::visit(UiPublicMember *publicMember)
             isAlias,
             0
         };
-        currentObject()->addProperty(prop);
+        m_currentScope->addProperty(prop);
         break;
     }
     }
     return true;
 }
 
-bool QQmlJSImportVisitor::visit(UiSourceElement *sourceElement)
+void QQmlJSImportVisitor::visitFunctionExpressionHelper(QQmlJS::AST::FunctionExpression *fexpr)
 {
-    if (FunctionExpression *fexpr = sourceElement->sourceElement->asFunctionDefinition()) {
-        QQmlJSMetaMethod method;
-        method.setMethodName(fexpr->name.toString());
-        method.setMethodType(QQmlJSMetaMethod::Method);
-        FormalParameterList *parameters = fexpr->formals;
-        while (parameters) {
-            method.addParameter(parameters->element->bindingIdentifier.toString(), QString());
-            parameters = parameters->next;
+    using namespace QQmlJS::AST;
+    auto name = fexpr->name.toString();
+    if (!name.isEmpty()) {
+        if (m_currentScope->scopeType() == QQmlJSScope::QMLScope) {
+            QQmlJSMetaMethod method(name, QStringLiteral("void"));
+            method.setMethodType(QQmlJSMetaMethod::Method);
+            FormalParameterList *parameters = fexpr->formals;
+            while (parameters) {
+                method.addParameter(parameters->element->bindingIdentifier.toString(), QString());
+                parameters = parameters->next;
+            }
+            m_currentScope->addMethod(method);
+        } else {
+            m_currentScope->insertJSIdentifier(
+                        name, {
+                            QQmlJSScope::JavaScriptIdentifier::LexicalScoped,
+                            fexpr->firstSourceLocation()
+                        });
         }
-        currentObject()->addMethod(method);
-    } else if (ClassExpression *clexpr = sourceElement->sourceElement->asClassDefinition()) {
-        QQmlJSMetaProperty prop { clexpr->name.toString(), QString(), false, false, false, false, 1 };
-        currentObject()->addProperty(prop);
-    } else if (cast<VariableStatement *>(sourceElement->sourceElement)) {
-        // nothing to do
+        enterEnvironment(QQmlJSScope::JSFunctionScope, name);
     } else {
-        const auto loc = sourceElement->firstSourceLocation();
-        m_errors.append({
-                            QStringLiteral("unsupportedd sourceElement %1")
-                                    .arg(sourceElement->sourceElement->kind),
-                            QtWarningMsg,
-                            loc
-                        });
+        enterEnvironment(QQmlJSScope::JSFunctionScope, QStringLiteral("<anon>"));
     }
+}
+
+bool QQmlJSImportVisitor::visit(QQmlJS::AST::FunctionExpression *fexpr)
+{
+    visitFunctionExpressionHelper(fexpr);
+    return true;
+}
+
+void QQmlJSImportVisitor::endVisit(QQmlJS::AST::FunctionExpression *)
+{
+    leaveEnvironment();
+}
+
+bool QQmlJSImportVisitor::visit(QQmlJS::AST::FunctionDeclaration *fdecl)
+{
+    visitFunctionExpressionHelper(fdecl);
+    return true;
+}
+
+void QQmlJSImportVisitor::endVisit(QQmlJS::AST::FunctionDeclaration *)
+{
+    leaveEnvironment();
+}
+
+bool QQmlJSImportVisitor::visit(QQmlJS::AST::ClassExpression *ast)
+{
+    QQmlJSMetaProperty prop { ast->name.toString(), QString(), false, false, false, false, 1 };
+    m_currentScope->addProperty(prop);
+    enterEnvironment(QQmlJSScope::JSFunctionScope, ast->name.toString());
     return true;
 }
 
+void QQmlJSImportVisitor::endVisit(QQmlJS::AST::ClassExpression *)
+{
+    leaveEnvironment();
+}
+
 bool QQmlJSImportVisitor::visit(UiScriptBinding *scriptBinding)
 {
     if (scriptBinding->qualifiedId->name == QLatin1String("id")) {
         const auto *statement = cast<ExpressionStatement *>(scriptBinding->statement);
         const auto *idExprension = cast<IdentifierExpression *>(statement->expression);
-        m_objects.insert(idExprension->name.toString(), currentObject());
+        m_scopesById.insert(idExprension->name.toString(), m_currentScope);
     }
     return true;
 }
@@ -163,7 +234,51 @@ bool QQmlJSImportVisitor::visit(QQmlJS::AST::UiEnumDeclaration *uied)
     QQmlJSMetaEnum qmlEnum(uied->name.toString());
     for (const auto *member = uied->members; member; member = member->next)
         qmlEnum.addKey(member->member.toString());
-    currentObject()->addEnum(qmlEnum);
+    m_currentScope->addEnum(qmlEnum);
+    return true;
+}
+
+bool QQmlJSImportVisitor::visit(QQmlJS::AST::UiImport *import)
+{
+    // construct path
+    QString prefix = QLatin1String("");
+    if (import->asToken.isValid()) {
+        prefix += import->importId;
+    }
+    auto filename = import->fileName.toString();
+    if (!filename.isEmpty()) {
+        const QFileInfo file(filename);
+        const QFileInfo path(file.isRelative() ? QDir(m_implicitImportDirectory).filePath(filename)
+                                               : filename);
+        if (path.isDir()) {
+            m_rootScopeImports.insert(m_importer->importDirectory(path.canonicalFilePath(), prefix));
+        } else if (path.isFile()) {
+            const auto scope = m_importer->importFile(path.canonicalFilePath());
+            m_rootScopeImports.insert(prefix.isEmpty() ? scope->internalName() : prefix, scope);
+        }
+
+    }
+
+    QString path {};
+    if (!import->importId.isEmpty()) {
+        // TODO: do not put imported ids into the same space as qml IDs
+        const QString importId = import->importId.toString();
+        m_scopesById.insert(importId, m_rootScopeImports.value(importId));
+    }
+    auto uri = import->importUri;
+    while (uri) {
+        path.append(uri->name);
+        path.append(u'/');
+        uri = uri->next;
+    }
+    path.chop(1);
+
+    const auto imported = m_importer->importModule(
+                path, prefix, import->version ? import->version->version : QTypeRevision());
+
+    m_rootScopeImports.insert(imported);
+
+    m_errors.append(m_importer->takeWarnings());
     return true;
 }
 
diff --git a/src/qmlcompiler/qqmljsimportvisitor_p.h b/src/qmlcompiler/qqmljsimportvisitor_p.h
index 8f0d937968..1d50881441 100644
--- a/src/qmlcompiler/qqmljsimportvisitor_p.h
+++ b/src/qmlcompiler/qqmljsimportvisitor_p.h
@@ -43,31 +43,51 @@
 
 #include <private/qqmljsast_p.h>
 #include <private/qqmljsdiagnosticmessage_p.h>
+#include <private/qqmljsimporter_p.h>
 
 QT_BEGIN_NAMESPACE
 
 class QQmlJSImportVisitor : public QQmlJS::AST::Visitor
 {
 public:
-    QQmlJSScope::Ptr result(const QString &scopeName) const;
+    QQmlJSImportVisitor(QQmlJSImporter *importer, const QString &implicitImportDirectory,
+                        const QStringList &qmltypesFiles = QStringList());
+
+    QQmlJSScope::Ptr result() const;
     QList<QQmlJS::DiagnosticMessage> errors() const { return m_errors; }
 
-private:
+protected:
+    bool visit(QQmlJS::AST::UiProgram *) override;
     bool visit(QQmlJS::AST::UiObjectDefinition *) override;
     void endVisit(QQmlJS::AST::UiObjectDefinition *) override;
     bool visit(QQmlJS::AST::UiPublicMember *) override;
-    bool visit(QQmlJS::AST::UiSourceElement *) override;
     bool visit(QQmlJS::AST::UiScriptBinding *) override;
     bool visit(QQmlJS::AST::UiEnumDeclaration *uied) override;
+    bool visit(QQmlJS::AST::FunctionExpression *fexpr) override;
+    void endVisit(QQmlJS::AST::FunctionExpression *) override;
+    bool visit(QQmlJS::AST::FunctionDeclaration *fdecl) override;
+    void endVisit(QQmlJS::AST::FunctionDeclaration *) override;
+    bool visit(QQmlJS::AST::ClassExpression *ast) override;
+    void endVisit(QQmlJS::AST::ClassExpression *) override;
+    bool visit(QQmlJS::AST::UiImport *import) override;
     void throwRecursionDepthError() override;
 
-    QQmlJSScope::Ptr currentObject() const { return m_currentObjects.back(); }
-
-    QVector<QQmlJSScope::Ptr> m_currentObjects;
-    QQmlJSScope::ConstPtr m_rootObject;
-    QHash<QString, QQmlJSScope::Ptr> m_objects;
+    QString m_implicitImportDirectory;
+    QStringList m_qmltypesFiles;
+    QQmlJSScope::Ptr m_currentScope;
+    QQmlJSScope::ConstPtr m_qmlRootScope;
+    QQmlJSScope::ConstPtr m_globalScope;
+    QHash<QString, QQmlJSScope::ConstPtr> m_scopesById;
+    QHash<QString, QQmlJSScope::ConstPtr> m_rootScopeImports;
+    QQmlJSImporter *m_importer;
 
     QList<QQmlJS::DiagnosticMessage> m_errors;
+
+    void enterEnvironment(QQmlJSScope::ScopeType type, const QString &name);
+    void leaveEnvironment();
+
+private:
+    void visitFunctionExpressionHelper(QQmlJS::AST::FunctionExpression *fexpr);
 };
 
 QT_END_NAMESPACE
diff --git a/src/qmlcompiler/qqmljsscope.cpp b/src/qmlcompiler/qqmljsscope.cpp
index e515431758..ed434c17e7 100644
--- a/src/qmlcompiler/qqmljsscope.cpp
+++ b/src/qmlcompiler/qqmljsscope.cpp
@@ -44,13 +44,8 @@ QQmlJSScope::QQmlJSScope(ScopeType type, const QQmlJSScope::Ptr &parentScope)
 QQmlJSScope::Ptr QQmlJSScope::create(ScopeType type, const QQmlJSScope::Ptr &parentScope)
 {
     QSharedPointer<QQmlJSScope> childScope(new QQmlJSScope{type, parentScope});
-    if (parentScope) {
-        Q_ASSERT(type != QQmlJSScope::QMLScope
-                || !parentScope->m_parentScope
-                || parentScope->parentScope()->m_scopeType == QQmlJSScope::QMLScope
-                || parentScope->parentScope()->m_internalName == QLatin1String("global"));
+    if (parentScope)
         parentScope->m_childScopes.push_back(childScope);
-    }
     return childScope;
 }
 
@@ -188,19 +183,10 @@ bool QQmlJSScope::Export::isValid() const
 
 QQmlJSScope QDeferredFactory<QQmlJSScope>::create() const
 {
-    QQmlJSTypeReader typeReader(m_filePath);
+    QQmlJSTypeReader typeReader(m_importer, m_filePath);
     QQmlJSScope::Ptr result = typeReader();
-
     m_importer->m_warnings.append(typeReader.errors());
-
-    QQmlJSImporter::AvailableTypes types;
-    types.qmlNames.insert(m_importer->importDirectory(QFileInfo(m_filePath).canonicalPath()));
-
-    const auto imports = typeReader.imports();
-    for (const auto &import : imports)
-        m_importer->importHelper(import.module, &types, import.prefix, import.version);
-
-    result->resolveTypes(types.qmlNames);
+    result->setInternalName(QFileInfo(m_filePath).baseName());
     return std::move(*result);
 }
 
diff --git a/src/qmlcompiler/qqmljstypereader.cpp b/src/qmlcompiler/qqmljstypereader.cpp
index 0e12c8de95..578b0378c3 100644
--- a/src/qmlcompiler/qqmljstypereader.cpp
+++ b/src/qmlcompiler/qqmljstypereader.cpp
@@ -40,34 +40,6 @@
 
 QT_BEGIN_NAMESPACE
 
-static QList<QQmlJSTypeReader::Import> parseHeaders(QQmlJS::AST::UiHeaderItemList *header)
-{
-    using namespace QQmlJS::AST;
-    QList<QQmlJSTypeReader::Import> imports;
-
-    for (; header; header = header->next) {
-        auto import = cast<UiImport *>(header->headerItem);
-        if (!import)
-            continue;
-
-        QString path;
-        auto uri = import->importUri;
-        while (uri) {
-            path.append(uri->name);
-            path.append(u'.');
-            uri = uri->next;
-        }
-        path.chop(1);
-        imports.append({
-                path,
-                import->version ? import->version->version : QTypeRevision(),
-                import->asToken.isValid() ? import->importId.toString() : QString()
-        });
-    }
-
-    return imports;
-}
-
 static QQmlJSScope::Ptr parseProgram(QQmlJS::AST::Program *program, const QString &name)
 {
     using namespace QQmlJS::AST;
@@ -126,11 +98,11 @@ QQmlJSScope::Ptr QQmlJSTypeReader::operator()()
 
     if (!isJavaScript) {
         QQmlJS::AST::UiProgram *program = parser.ast();
-        m_imports = parseHeaders(program->headers);
-        QQmlJSImportVisitor membersVisitor;
-        program->members->accept(&membersVisitor);
+        QQmlJSImportVisitor membersVisitor(m_importer, QFileInfo(m_file).canonicalPath(),
+                                           m_qmltypesFiles);
+        program->accept(&membersVisitor);
         m_errors = membersVisitor.errors();
-        return membersVisitor.result(scopeName);
+        return membersVisitor.result();
     }
 
     // TODO: Anything special to do with ES modules here?
diff --git a/src/qmlcompiler/qqmljstypereader_p.h b/src/qmlcompiler/qqmljstypereader_p.h
index 4a6c2c2cd0..4e9d26c08c 100644
--- a/src/qmlcompiler/qqmljstypereader_p.h
+++ b/src/qmlcompiler/qqmljstypereader_p.h
@@ -40,6 +40,7 @@
 // We mean it.
 
 #include "qqmljsscope_p.h"
+#include "qqmljsimporter_p.h"
 
 #include <QtQml/private/qqmljsastfwd_p.h>
 #include <QtQml/private/qqmljsdiagnosticmessage_p.h>
@@ -52,21 +53,20 @@ QT_BEGIN_NAMESPACE
 class QQmlJSTypeReader
 {
 public:
-    struct Import {
-        QString module;
-        QTypeRevision version;
-        QString prefix;
-    };
-
-    QQmlJSTypeReader(const QString &file) : m_file(file) {}
+    QQmlJSTypeReader(QQmlJSImporter *importer, const QString &file,
+                     const QStringList &qmltypesFiles = QStringList())
+        : m_importer(importer)
+        , m_file(file)
+        , m_qmltypesFiles(qmltypesFiles)
+    {}
 
     QQmlJSScope::Ptr operator()();
-    QList<Import> imports() const { return m_imports; }
     QList<QQmlJS::DiagnosticMessage> errors() const { return m_errors; }
 
 private:
+    QQmlJSImporter *m_importer;
     QString m_file;
-    QList<Import> m_imports;
+    QStringList m_qmltypesFiles;
     QList<QQmlJS::DiagnosticMessage> m_errors;
 };