1 files changed, 46 insertions, 9 deletions

diff --git a/tools/qmltc/main.cpp b/tools/qmltc/main.cpp
index 6ef0afe105..1899f4087e 100644
--- a/tools/qmltc/main.cpp
+++ b/tools/qmltc/main.cpp
@@ -9,6 +9,7 @@
 
 #include <private/qqmljscompiler_p.h>
 #include <private/qqmljsresourcefilemapper_p.h>
+#include <private/qqmljsutils_p.h>
 
 #include <QtCore/qcoreapplication.h>
 #include <QtCore/qurl.h>
@@ -24,6 +25,8 @@
 #include <QtQml/private/qqmljsastvisitor_p.h>
 #include <QtQml/private/qqmljsast_p.h>
 #include <QtQml/private/qqmljsdiagnosticmessage_p.h>
+#include <QtQmlCompiler/qqmlsa.h>
+#include <QtQmlCompiler/private/qqmljsliteralbindingcheck_p.h>
 
 #include <cstdlib> // EXIT_SUCCESS, EXIT_FAILURE
 
@@ -31,8 +34,8 @@ using namespace Qt::StringLiterals;
 
 void setupLogger(QQmlJSLogger &logger) // prepare logger to work with compiler
 {
-    for (const QQmlJSLogger::Category &category : logger.categories()) {
-        if (category == qmlUnusedImports)
+    for (const QQmlJS::LoggerCategory &category : logger.categories()) {
+        if (category.id() == qmlUnusedImports)
             continue;
         logger.setCategoryLevel(category.id(), QtCriticalMsg);
         logger.setCategoryIgnored(category.id(), false);
@@ -99,6 +102,25 @@ int main(int argc, char **argv)
         QCoreApplication::translate("main", "namespace")
     };
     parser.addOption(namespaceOption);
+    QCommandLineOption moduleOption{
+        u"module"_s,
+        QCoreApplication::translate("main",
+                                    "Name of the QML module that this QML code belongs to."),
+        QCoreApplication::translate("main", "module")
+    };
+    parser.addOption(moduleOption);
+    QCommandLineOption exportOption{ u"export"_s,
+                                     QCoreApplication::translate(
+                                             "main", "Export macro used in the generated C++ code"),
+                                     QCoreApplication::translate("main", "export") };
+    parser.addOption(exportOption);
+    QCommandLineOption exportIncludeOption{
+        u"exportInclude"_s,
+        QCoreApplication::translate(
+                "main", "Header defining the export macro to be used in the generated C++ code"),
+        QCoreApplication::translate("main", "exportInclude")
+    };
+    parser.addOption(exportIncludeOption);
 
     parser.process(app);
 
@@ -153,7 +175,7 @@ int main(int argc, char **argv)
     if (!parser.isSet(bareOption))
         importPaths.append(QLibraryInfo::path(QLibraryInfo::QmlImportsPath));
 
-    QStringList qmldirFiles = parser.values(qmldirOption);
+    QStringList qmldirFiles = QQmlJSUtils::cleanPaths(parser.values(qmldirOption));
 
     QString outputCppFile;
     if (!parser.isSet(outputCppOption)) {
@@ -224,6 +246,8 @@ int main(int argc, char **argv)
     info.outputHFile = parser.value(outputHOption);
     info.resourcePath = firstQml(paths);
     info.outputNamespace = parser.value(namespaceOption);
+    info.exportMacro = parser.value(exportOption);
+    info.exportInclude = parser.value(exportIncludeOption);
 
     if (info.outputCppFile.isEmpty()) {
         fprintf(stderr, "An output C++ file is required. Pass one using --impl");
@@ -236,24 +260,37 @@ int main(int argc, char **argv)
 
     QQmlJSImporter importer { importPaths, &mapper };
     importer.setMetaDataMapper(&metaDataMapper);
-    auto createQmltcVisitor = [](const QQmlJSScope::Ptr &root, QQmlJSImporter *importer,
-                                 QQmlJSLogger *logger, const QString &implicitImportDirectory,
-                                 const QStringList &qmldirFiles) -> QQmlJSImportVisitor * {
-        return new QmltcVisitor(root, importer, logger, implicitImportDirectory, qmldirFiles);
+    auto qmltcVisitor = [](QQmlJS::AST::Node *rootNode, QQmlJSImporter *self,
+                                 const QQmlJSImporter::ImportVisitorPrerequisites &p) {
+        QmltcVisitor v(p.m_target, self, p.m_logger, p.m_implicitImportDirectory, p.m_qmldirFiles);
+        QQmlJS::AST::Node::accept(rootNode, &v);
     };
-    importer.setImportVisitorCreator(createQmltcVisitor);
+    importer.setImportVisitor(qmltcVisitor);
 
     QQmlJSLogger logger;
     logger.setFileName(url);
     logger.setCode(sourceCode);
     setupLogger(logger);
 
-    QmltcVisitor visitor(QQmlJSScope::create(), &importer, &logger,
+    auto currentScope = QQmlJSScope::create();
+    if (parser.isSet(moduleOption))
+        currentScope->setOwnModuleName(parser.value(moduleOption));
+
+    QmltcVisitor visitor(currentScope, &importer, &logger,
                          QQmlJSImportVisitor::implicitImportDirectory(url, &mapper), qmldirFiles);
     visitor.setMode(QmltcVisitor::Compile);
     QmltcTypeResolver typeResolver { &importer };
     typeResolver.init(&visitor, qmlParser.rootNode());
 
+    using PassManagerPtr =
+            std::unique_ptr<QQmlSA::PassManager,
+                            decltype(&QQmlSA::PassManagerPrivate::deletePassManager)>;
+    PassManagerPtr passMan(QQmlSA::PassManagerPrivate::createPassManager(&visitor, &typeResolver),
+                           &QQmlSA::PassManagerPrivate::deletePassManager);
+    passMan->registerPropertyPass(std::make_unique<QQmlJSLiteralBindingCheck>(passMan.get()),
+                                  QString(), QString(), QString());
+    passMan->analyze(QQmlJSScope::createQQmlSAElement(visitor.result()));
+
     if (logger.hasErrors())
         return EXIT_FAILURE;