Use QTypeRevision for all versions and revisions

In many places we carry major and minor versions or revisions that are
loosely coupled to minor versions. As the Qt minor version resets now,
we need to handle these things more systematically. In particular, we
need to add a "major" part to revisions.

QTypeRevision can express the current major/minor pairs more efficiently
and can also be used to add a major version to revisions. This change
does not change the semantics, yet, but only replaces the types.

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

9 files changed, 107 insertions, 93 deletions

diff --git a/tools/qmlcachegen/generateloader.cpp b/tools/qmlcachegen/generateloader.cpp
index 71286137eb..a8ec527299 100644
--- a/tools/qmlcachegen/generateloader.cpp
+++ b/tools/qmlcachegen/generateloader.cpp
@@ -155,7 +155,7 @@ bool generateLoader(const QStringList &compiledFiles, const QString &outputFileN
         }
 
         stream << "    QQmlPrivate::RegisterQmlUnitCacheHook registration;\n";
-        stream << "    registration.version = 0;\n";
+        stream << "    registration.structVersion = 0;\n";
         stream << "    registration.lookupCachedQmlUnit = &lookupCachedUnit;\n";
         stream << "    QQmlPrivate::qmlregister(QQmlPrivate::QmlUnitCacheHookRegistration, &registration);\n";
 
diff --git a/tools/qmlformat/dumpastvisitor.cpp b/tools/qmlformat/dumpastvisitor.cpp
index 75d9fa8a4f..af0e0aeff0 100644
--- a/tools/qmlformat/dumpastvisitor.cpp
+++ b/tools/qmlformat/dumpastvisitor.cpp
@@ -1221,8 +1221,8 @@ bool DumpAstVisitor::visit(UiImport *node) {
         result += parseUiQualifiedId(node->importUri);
 
     if (node->version) {
-        result += " " + QString::number(node->version->majorVersion) + "."
-                + QString::number(node->version->minorVersion);
+        result += " " + QString::number(node->version->version.majorVersion()) + "."
+                + QString::number(node->version->version.minorVersion());
     }
 
     if (node->asToken.isValid()) {
diff --git a/tools/qmlimportscanner/main.cpp b/tools/qmlimportscanner/main.cpp
index b563d7df95..1059f12b54 100644
--- a/tools/qmlimportscanner/main.cpp
+++ b/tools/qmlimportscanner/main.cpp
@@ -123,7 +123,11 @@ QVariantList findImportsInAst(QQmlJS::AST::UiHeaderItemList *headerItemList, con
             if (!name.isEmpty())
                 import[nameLiteral()] = name;
             import[typeLiteral()] = moduleLiteral();
-            auto versionString = importNode->version ? QString::number(importNode->version->majorVersion) + QLatin1Char('.') + QString::number(importNode->version->minorVersion) : QString();
+            auto versionString = importNode->version
+                    ? QString::number(importNode->version->version.majorVersion())
+                      + QLatin1Char('.')
+                      + QString::number(importNode->version->version.minorVersion())
+                    : QString();
             import[versionLiteral()] = versionString;
         }
 
diff --git a/tools/qmllint/componentversion.cpp b/tools/qmllint/componentversion.cpp
index e5047b8302..95403ec15f 100644
--- a/tools/qmllint/componentversion.cpp
+++ b/tools/qmllint/componentversion.cpp
@@ -41,21 +41,21 @@ ComponentVersion::ComponentVersion(const QString &versionString)
     const int maybeMinor = versionString.midRef(dotIdx + 1).toInt(&ok);
     if (!ok)
         return;
-    m_major = maybeMajor;
-    m_minor = maybeMinor;
+    m_version = QTypeRevision::fromVersion(maybeMajor, maybeMinor);
 }
 
 bool operator<(const ComponentVersion &lhs, const ComponentVersion &rhs)
 {
-    return lhs.majorVersion() < rhs.majorVersion()
-            || (lhs.majorVersion() == rhs.majorVersion() && lhs.minorVersion() < rhs.minorVersion());
+    return lhs.version().majorVersion() < rhs.version().majorVersion()
+            || (lhs.version().majorVersion() == rhs.version().majorVersion()
+                && lhs.version().minorVersion() < rhs.version().minorVersion());
 }
 
 bool operator<=(const ComponentVersion &lhs, const ComponentVersion &rhs)
 {
-    return lhs.majorVersion() < rhs.majorVersion()
-            || (lhs.majorVersion() == rhs.majorVersion()
-                && lhs.minorVersion() <= rhs.minorVersion());
+    return lhs.version().majorVersion() < rhs.version().majorVersion()
+            || (lhs.version().majorVersion() == rhs.version().majorVersion()
+                && lhs.version().minorVersion() <= rhs.version().minorVersion());
 }
 
 bool operator>(const ComponentVersion &lhs, const ComponentVersion &rhs)
@@ -70,8 +70,8 @@ bool operator>=(const ComponentVersion &lhs, const ComponentVersion &rhs)
 
 bool operator==(const ComponentVersion &lhs, const ComponentVersion &rhs)
 {
-    return lhs.majorVersion() == rhs.majorVersion()
-            && lhs.minorVersion() == rhs.minorVersion();
+    return lhs.version().majorVersion() == rhs.version().majorVersion()
+            && lhs.version().minorVersion() == rhs.version().minorVersion();
 }
 
 bool operator!=(const ComponentVersion &lhs, const ComponentVersion &rhs)
diff --git a/tools/qmllint/componentversion.h b/tools/qmllint/componentversion.h
index 9c4604b9a3..bbb039fc40 100644
--- a/tools/qmllint/componentversion.h
+++ b/tools/qmllint/componentversion.h
@@ -40,24 +40,20 @@
 // We mean it.
 
 #include <QtCore/qglobal.h>
+#include <QtCore/qversionnumber.h>
 
 class ComponentVersion
 {
 public:
-    static const int NoVersion = -1;
-
     ComponentVersion() = default;
-    ComponentVersion(int major, int minor) : m_major(major), m_minor(minor) {}
+    ComponentVersion(QTypeRevision version) : m_version(version) {}
     explicit ComponentVersion(const QString &versionString);
 
-    int majorVersion() const { return m_major; }
-    int minorVersion() const { return m_minor; }
-
-    bool isValid() const { return m_major >= 0 && m_minor >= 0; }
+    QTypeRevision version() const { return m_version; }
+    bool isValid() const { return m_version.hasMajorVersion() && m_version.hasMinorVersion(); }
 
 private:
-    int m_major = NoVersion;
-    int m_minor = NoVersion;
+    QTypeRevision m_version;
 };
 
 bool operator<(const ComponentVersion &lhs, const ComponentVersion &rhs);
diff --git a/tools/qmllint/findunqualified.cpp b/tools/qmllint/findunqualified.cpp
index 807110c3c1..187471125a 100644
--- a/tools/qmllint/findunqualified.cpp
+++ b/tools/qmllint/findunqualified.cpp
@@ -92,8 +92,7 @@ void FindUnqualifiedIDVisitor::parseHeaders(QQmlJS::AST::UiHeaderItemList *heade
                 if (import->asToken.isValid()) {
                     prefix += import->importId + QLatin1Char('.');
                 }
-                importHelper(path, prefix, import->version->majorVersion,
-                             import->version->minorVersion);
+                importHelper(path, prefix, import->version->version);
             }
         }
         header = header->next;
@@ -119,7 +118,7 @@ ScopeTree *FindUnqualifiedIDVisitor::parseProgram(QQmlJS::AST::Program *program,
 
 enum ImportVersion { FullyVersioned, PartiallyVersioned, Unversioned, BasePath };
 
-QStringList completeImportPaths(const QString &uri, const QString &basePath, int vmaj, int vmin)
+QStringList completeImportPaths(const QString &uri, const QString &basePath, QTypeRevision version)
 {
     static const QLatin1Char Slash('/');
     static const QLatin1Char Backslash('\\');
@@ -130,15 +129,16 @@ QStringList completeImportPaths(const QString &uri, const QString &basePath, int
     // fully & partially versioned parts + 1 unversioned for each base path
     qmlDirPathsPaths.reserve(2 * parts.count() + 1);
 
-    auto versionString = [](int vmaj, int vmin, ImportVersion version)
+    auto versionString = [](QTypeRevision version, ImportVersion mode)
     {
-        if (version == FullyVersioned) {
+        if (mode == FullyVersioned) {
             // extension with fully encoded version number (eg. MyModule.3.2)
-            return QString::fromLatin1(".%1.%2").arg(vmaj).arg(vmin);
+            return QString::fromLatin1(".%1.%2").arg(version.majorVersion())
+                    .arg(version.minorVersion());
         }
-        if (version == PartiallyVersioned) {
+        if (mode == PartiallyVersioned) {
             // extension with encoded version major (eg. MyModule.3)
-            return QString::fromLatin1(".%1").arg(vmaj);
+            return QString::fromLatin1(".%1").arg(version.majorVersion());
         }
         // else extension without version number (eg. MyModule)
         return QString();
@@ -153,24 +153,24 @@ QStringList completeImportPaths(const QString &uri, const QString &basePath, int
         return str;
     };
 
-    const ImportVersion initial = (vmin >= 0)
+    const ImportVersion initial = (version.hasMinorVersion())
             ? FullyVersioned
-            : (vmaj >= 0 ? PartiallyVersioned : Unversioned);
-    for (int version = initial; version <= BasePath; ++version) {
-        const QString ver = versionString(vmaj, vmin, static_cast<ImportVersion>(version));
+            : (version.hasMajorVersion() ? PartiallyVersioned : Unversioned);
+    for (int mode = initial; mode <= BasePath; ++mode) {
+        const QString ver = versionString(version, ImportVersion(mode));
 
         QString dir = basePath;
         if (!dir.endsWith(Slash) && !dir.endsWith(Backslash))
             dir += Slash;
 
-        if (version == BasePath) {
+        if (mode == BasePath) {
             qmlDirPathsPaths += dir;
         } else {
             // append to the end
             qmlDirPathsPaths += dir + joinStringRefs(parts, Slash) + ver;
         }
 
-        if (version < Unversioned) {
+        if (mode < Unversioned) {
             // insert in the middle
             for (int index = parts.count() - 2; index >= 0; --index) {
                 qmlDirPathsPaths += dir + joinStringRefs(parts.mid(0, index + 1), Slash)
@@ -222,7 +222,7 @@ FindUnqualifiedIDVisitor::Import FindUnqualifiedIDVisitor::readQmldir(const QStr
 
         (*mo)->addExport(
                     it.key(), reader.typeNamespace(),
-                    ComponentVersion(it->majorVersion, it->minorVersion));
+                    ComponentVersion(it->version));
     }
     for (auto it = qmlComponents.begin(), end = qmlComponents.end(); it != end; ++it)
         result.objects.insert( it.key(), ScopeTree::ConstPtr(it.value()));
@@ -240,11 +240,11 @@ void FindUnqualifiedIDVisitor::processImport(const QString &prefix, const FindUn
         auto const &id = split.at(0);
         if (split.length() > 1) {
             const auto version = split.at(1).split('.');
-            importHelper(id, QString(),
-                         version.at(0).toInt(),
-                         version.length() > 1 ? version.at(1).toInt() : -1);
+            importHelper(id, QString(), QTypeRevision::fromVersion(
+                             version.at(0).toInt(),
+                             version.length() > 1 ? version.at(1).toInt() : -1));
         } else {
-            importHelper(id, QString(), -1, -1);
+            importHelper(id, QString(), QTypeRevision());
         }
 
 
@@ -267,7 +267,7 @@ void FindUnqualifiedIDVisitor::processImport(const QString &prefix, const FindUn
 }
 
 void FindUnqualifiedIDVisitor::importHelper(const QString &module, const QString &prefix,
-                                            int major, int minor)
+                                            QTypeRevision version)
 {
     const QString id = QString(module).replace(QLatin1Char('/'), QLatin1Char('.'));
     QPair<QString, QString> importId { id, prefix };
@@ -276,7 +276,7 @@ void FindUnqualifiedIDVisitor::importHelper(const QString &module, const QString
     m_alreadySeenImports.insert(importId);
 
     for (const QString &qmltypeDir : m_qmltypeDirs) {
-        auto qmltypesPaths = completeImportPaths(id, qmltypeDir, major, minor);
+        auto qmltypesPaths = completeImportPaths(id, qmltypeDir, version);
 
         for (auto const &qmltypesPath : qmltypesPaths) {
             if (QFile::exists(qmltypesPath + SlashQmldir)) {
@@ -764,7 +764,7 @@ bool FindUnqualifiedIDVisitor::visit(QQmlJS::AST::UiImport *import)
         }
         path.chop(1);
 
-        importHelper(path, prefix, import->version->majorVersion, import->version->minorVersion);
+        importHelper(path, prefix, import->version->version);
     }
     return true;
 }
diff --git a/tools/qmllint/findunqualified.h b/tools/qmllint/findunqualified.h
index 6668b53b08..1c351e4fd9 100644
--- a/tools/qmllint/findunqualified.h
+++ b/tools/qmllint/findunqualified.h
@@ -91,7 +91,7 @@ private:
     void enterEnvironment(ScopeType type, const QString &name);
     void leaveEnvironment();
     void importHelper(const QString &module, const QString &prefix = QString(),
-                      int major = -1, int minor = -1);
+                      QTypeRevision version = QTypeRevision());
 
     void readQmltypes(const QString &filename, Import &result);
     Import readQmldir(const QString &dirname);
diff --git a/tools/qmllint/typedescriptionreader.cpp b/tools/qmllint/typedescriptionreader.cpp
index 3dc87ffc8d..8734f349d5 100644
--- a/tools/qmllint/typedescriptionreader.cpp
+++ b/tools/qmllint/typedescriptionreader.cpp
@@ -102,7 +102,7 @@ void TypeDescriptionReader::readDocument(UiProgram *ast)
         return;
     }
 
-    if (import->version->majorVersion != 1) {
+    if (import->version->version.majorVersion() != 1) {
         addError(import->version->firstSourceLocation(),
                  tr("Major version different from 1 not supported."));
         return;
diff --git a/tools/qmlplugindump/main.cpp b/tools/qmlplugindump/main.cpp
index 947b5dff27..3efa4dc605 100644
--- a/tools/qmlplugindump/main.cpp
+++ b/tools/qmlplugindump/main.cpp
@@ -103,15 +103,15 @@ static QString enquote(const QString &string)
 struct QmlVersionInfo
 {
     QString pluginImportUri;
-    int majorVersion;
-    int minorVersion;
+    QTypeRevision version;
     bool strict;
 };
 
 static bool matchingImportUri(const QQmlType &ty, const QmlVersionInfo& versionInfo) {
     if (versionInfo.strict) {
         return (versionInfo.pluginImportUri == ty.module()
-                && (ty.majorVersion() == versionInfo.majorVersion || ty.majorVersion() == -1))
+                && (ty.version().majorVersion() == versionInfo.version.majorVersion()
+                    || !ty.version().hasMajorVersion()))
                 || ty.module().isEmpty();
     }
     return ty.module().isEmpty()
@@ -335,23 +335,23 @@ QSet<const QMetaObject *> collectReachableMetaObjects(QQmlEngine *engine,
 }
 
 class KnownAttributes {
-    QHash<QByteArray, int> m_properties;
-    QHash<QByteArray, QHash<int, int> > m_methods;
+    QHash<QByteArray, QTypeRevision> m_properties;
+    QHash<QByteArray, QHash<int, QTypeRevision> > m_methods;
 public:
-    bool knownMethod(const QByteArray &name, int nArgs, int revision)
+    bool knownMethod(const QByteArray &name, int nArgs, QTypeRevision revision)
     {
         if (m_methods.contains(name)) {
-            QHash<int, int> overloads = m_methods.value(name);
-            if (overloads.contains(nArgs) && overloads.value(nArgs) <= revision)
+            QHash<int, QTypeRevision> overloads = m_methods.value(name);
+            if (overloads.contains(nArgs) && overloads.value(nArgs).toEncodedVersion<quint16>() <= revision.toEncodedVersion<quint16>())
                 return true;
         }
         m_methods[name][nArgs] = revision;
         return false;
     }
 
-    bool knownProperty(const QByteArray &name, int revision)
+    bool knownProperty(const QByteArray &name, QTypeRevision revision)
     {
-        if (m_properties.contains(name) && m_properties.value(name) <= revision)
+        if (m_properties.contains(name) && m_properties.value(name).toEncodedVersion<quint16>() <= revision.toEncodedVersion<quint16>())
             return true;
         m_properties[name] = revision;
         return false;
@@ -375,13 +375,14 @@ public:
     {
         const QString module = type.module().isEmpty() ? versionInfo.pluginImportUri
                                                        : type.module();
-        const int majorVersion = type.majorVersion() >= 0 ? type.majorVersion()
-                                                          : versionInfo.majorVersion;
-        const int minorVersion = type.minorVersion() >= 0 ? type.minorVersion()
-                                                          : versionInfo.minorVersion;
+        QTypeRevision version = QTypeRevision::fromVersion(
+                    type.version().hasMajorVersion() ? type.version().majorVersion()
+                                                     : versionInfo.version.majorVersion(),
+                    type.version().hasMinorVersion() ? type.version().minorVersion()
+                                                     : versionInfo.version.minorVersion());
 
         const QString versionedElement = type.elementName()
-                + QString::fromLatin1(" %1.%2").arg(majorVersion).arg(minorVersion);
+                + QString::fromLatin1(" %1.%2").arg(version.majorVersion()).arg(version.minorVersion());
 
         return enquote((module == relocatableModuleUri)
                        ? versionedElement
@@ -390,7 +391,7 @@ public:
 
     void writeMetaContent(const QMetaObject *meta, KnownAttributes *knownAttributes = nullptr)
     {
-        QSet<QString> implicitSignals = dumpMetaProperties(meta, 0, knownAttributes);
+        QSet<QString> implicitSignals = dumpMetaProperties(meta, QTypeRevision::zero(), knownAttributes);
 
         if (meta == &QObject::staticMetaObject) {
             // for QObject, hide deleteLater() and onDestroyed
@@ -405,17 +406,17 @@ public:
             }
 
             // and add toString(), destroy() and destroy(int)
-            if (!knownAttributes || !knownAttributes->knownMethod(QByteArray("toString"), 0, 0)) {
+            if (!knownAttributes || !knownAttributes->knownMethod(QByteArray("toString"), 0, QTypeRevision::zero())) {
                 qml->writeStartObject(QLatin1String("Method"));
                 qml->writeScriptBinding(QLatin1String("name"), enquote(QLatin1String("toString")));
                 qml->writeEndObject();
             }
-            if (!knownAttributes || !knownAttributes->knownMethod(QByteArray("destroy"), 0, 0)) {
+            if (!knownAttributes || !knownAttributes->knownMethod(QByteArray("destroy"), 0, QTypeRevision::zero())) {
                 qml->writeStartObject(QLatin1String("Method"));
                 qml->writeScriptBinding(QLatin1String("name"), enquote(QLatin1String("destroy")));
                 qml->writeEndObject();
             }
-            if (!knownAttributes || !knownAttributes->knownMethod(QByteArray("destroy"), 1, 0)) {
+            if (!knownAttributes || !knownAttributes->knownMethod(QByteArray("destroy"), 1, QTypeRevision::zero())) {
                 qml->writeStartObject(QLatin1String("Method"));
                 qml->writeScriptBinding(QLatin1String("name"), enquote(QLatin1String("destroy")));
                 qml->writeStartObject(QLatin1String("Parameter"));
@@ -498,7 +499,12 @@ public:
         qml->writeScriptBinding(QLatin1String("name"), exportString);
 
         qml->writeArrayBinding(QLatin1String("exports"), QStringList() << exportString);
-        qml->writeArrayBinding(QLatin1String("exportMetaObjectRevisions"), QStringList() << QString::number(compositeType.minorVersion()));
+
+        // TODO: shouldn't this be metaObjectRevision().value<quint16>()
+        //       rather than version().minorVersion()
+        qml->writeArrayBinding(QLatin1String("exportMetaObjectRevisions"), QStringList()
+                               << QString::number(compositeType.version().minorVersion()));
+
         qml->writeBooleanBinding(QLatin1String("isComposite"), true);
 
         if (compositeType.isSingleton()) {
@@ -537,10 +543,10 @@ public:
 
     struct QmlTypeInfo {
         QmlTypeInfo() {}
-        QmlTypeInfo(const QString &exportString, int revision, const QMetaObject *extendedObject, QByteArray attachedTypeId)
+        QmlTypeInfo(const QString &exportString, QTypeRevision revision, const QMetaObject *extendedObject, QByteArray attachedTypeId)
             : exportString(exportString), revision(revision), extendedObject(extendedObject), attachedTypeId(attachedTypeId) {}
         QString exportString;
-        int revision = 0;
+        QTypeRevision revision = QTypeRevision::zero();
         const QMetaObject *extendedObject = nullptr;
         QByteArray attachedTypeId;
     };
@@ -563,11 +569,11 @@ public:
                 if (attachedType != meta)
                     attachedTypeId = convertToId(attachedType);
             }
-            const QString exportString = getExportString(type, { QString(), -1, -1, false });
-            int metaObjectRevision = type.metaObjectRevision();
+            const QString exportString = getExportString(type, { QString(), QTypeRevision(), false });
+            QTypeRevision metaObjectRevision = type.metaObjectRevision();
             if (extendedObject) {
                 // emulate custom metaobjectrevision out of import
-                metaObjectRevision = type.majorVersion() * 100 + type.minorVersion();
+                metaObjectRevision = type.version();
             }
 
             QmlTypeInfo info = { exportString, metaObjectRevision, extendedObject, attachedTypeId };
@@ -576,7 +582,7 @@ public:
 
         // sort to ensure stable output
         std::sort(typeInfo.begin(), typeInfo.end(), [](const QmlTypeInfo &i1, const QmlTypeInfo &i2) {
-            return i1.revision < i2.revision;
+            return i1.revision.toEncodedVersion<quint16>() < i2.revision.toEncodedVersion<quint16>();
         });
 
         // determine default property
@@ -600,7 +606,7 @@ public:
         if (!typeInfo.isEmpty()) {
             QMap<QString, QString> exports; // sort exports
             for (const QmlTypeInfo &iter : typeInfo)
-                exports.insert(iter.exportString, QString::number(iter.revision));
+                exports.insert(iter.exportString, QString::number(iter.revision.toEncodedVersion<quint16>()));
 
             QStringList exportStrings = exports.keys();
             QStringList metaObjectRevisions = exports.values();
@@ -681,22 +687,27 @@ private:
             qml->writeScriptBinding(QLatin1String("isPointer"), QLatin1String("true"));
     }
 
-    void dump(const QMetaProperty &prop, int metaRevision = -1, KnownAttributes *knownAttributes = nullptr)
+    void dump(const QMetaProperty &prop, QTypeRevision metaRevision = QTypeRevision(),
+              KnownAttributes *knownAttributes = nullptr)
     {
-        int revision = metaRevision ? metaRevision : prop.revision();
+        // TODO: should that not be metaRevision.isValid() rather than comparing to zero()?
+        QTypeRevision revision = (metaRevision == QTypeRevision::zero())
+                ? QTypeRevision::fromEncodedVersion(prop.revision())
+                : metaRevision;
         QByteArray propName = prop.name();
         if (knownAttributes && knownAttributes->knownProperty(propName, revision))
             return;
         qml->writeStartObject("Property");
         qml->writeScriptBinding(QLatin1String("name"), enquote(QString::fromUtf8(prop.name())));
-        if (revision)
-            qml->writeScriptBinding(QLatin1String("revision"), QString::number(revision));
+        if (revision != QTypeRevision::zero())
+            qml->writeScriptBinding(QLatin1String("revision"), QString::number(revision.toEncodedVersion<quint16>()));
         writeTypeProperties(prop.typeName(), prop.isWritable());
 
         qml->writeEndObject();
     }
 
-    QSet<QString> dumpMetaProperties(const QMetaObject *meta, int metaRevision = -1, KnownAttributes *knownAttributes = nullptr)
+    QSet<QString> dumpMetaProperties(const QMetaObject *meta, QTypeRevision metaRevision = QTypeRevision(),
+                                     KnownAttributes *knownAttributes = nullptr)
     {
         QSet<QString> implicitSignals;
         for (int index = meta->propertyOffset(); index < meta->propertyCount(); ++index) {
@@ -704,7 +715,7 @@ private:
             dump(property, metaRevision, knownAttributes);
             if (knownAttributes)
                 knownAttributes->knownMethod(QByteArray(property.name()).append("Changed"),
-                                             0, property.revision());
+                                             0, QTypeRevision::fromEncodedVersion(property.revision()));
             implicitSignals.insert(QString("%1Changed").arg(QString::fromUtf8(property.name())));
         }
         return implicitSignals;
@@ -732,7 +743,7 @@ private:
             return;
         }
 
-        int revision = meth.revision();
+        QTypeRevision revision = QTypeRevision::fromEncodedVersion(meth.revision());
         if (knownAttributes && knownAttributes->knownMethod(name, meth.parameterNames().size(), revision))
             return;
         if (meth.methodType() == QMetaMethod::Signal)
@@ -742,8 +753,8 @@ private:
 
         qml->writeScriptBinding(QLatin1String("name"), enquote(name));
 
-        if (revision)
-            qml->writeScriptBinding(QLatin1String("revision"), QString::number(revision));
+        if (revision != QTypeRevision::zero())
+            qml->writeScriptBinding(QLatin1String("revision"), QString::number(revision.toEncodedVersion<quint16>()));
 
         if (typeName != QLatin1String("void"))
             qml->writeScriptBinding(QLatin1String("type"), enquote(typeName));
@@ -1001,9 +1012,9 @@ static bool operator<(const QQmlType &a, const QQmlType &b)
 {
     return a.qmlTypeName() < b.qmlTypeName()
             || (a.qmlTypeName() == b.qmlTypeName()
-                && ((a.majorVersion() < b.majorVersion())
-                    || (a.majorVersion() == b.majorVersion()
-                        && a.minorVersion() < b.minorVersion())));
+                && ((a.version().majorVersion() < b.version().majorVersion())
+                    || (a.version().majorVersion() == b.version().majorVersion()
+                        && a.version().minorVersion() < b.version().minorVersion())));
 }
 QT_END_NAMESPACE
 
@@ -1243,11 +1254,13 @@ int main(int argc, char *argv[])
     // composite types we want to dump information of
     QMap<QString, QList<QQmlType>> compositeTypes;
 
-    int majorVersion = qtQmlMajorVersion, minorVersion = qtQmlMinorVersion;
+    QTypeRevision version = QTypeRevision::fromVersion(qtQmlMajorVersion, qtQmlMinorVersion);
     QmlVersionInfo info;
     if (action == Builtins) {
         QMap<QString, QList<QQmlType>> defaultCompositeTypes;
-        QSet<const QMetaObject *> builtins = collectReachableMetaObjects(&engine, uncreatableMetas, singletonMetas, defaultCompositeTypes, {QLatin1String("Qt"), majorVersion, minorVersion, strict});
+        QSet<const QMetaObject *> builtins = collectReachableMetaObjects(
+                    &engine, uncreatableMetas, singletonMetas, defaultCompositeTypes,
+                    {QLatin1String("Qt"), version, strict});
         Q_ASSERT(builtins.size() == 1);
         metas.insert(*builtins.begin());
     } else {
@@ -1256,12 +1269,13 @@ int main(int argc, char *argv[])
         if (!ok)
             qCritical("Invalid version number");
         else {
-            majorVersion = versionSplitted.at(0).toInt(&ok);
+            const int majorVersion = versionSplitted.at(0).toInt(&ok);
             if (!ok)
                 qCritical("Invalid major version");
-            minorVersion = versionSplitted.at(1).toInt(&ok);
+            const int minorVersion = versionSplitted.at(1).toInt(&ok);
             if (!ok)
                 qCritical("Invalid minor version");
+            version = QTypeRevision::fromVersion(majorVersion, minorVersion);
         }
         QList<QQmlType> defaultTypes = QQmlMetaType::qmlTypes();
         // find a valid QtQuick import
@@ -1273,9 +1287,9 @@ int main(int argc, char *argv[])
         } else {
             QString module = qtObjectType.qmlTypeName();
             module = module.mid(0, module.lastIndexOf(QLatin1Char('/')));
-            importCode = QString("import %1 %2.%3").arg(module,
-                                                        QString::number(qtObjectType.majorVersion()),
-                                                        QString::number(qtObjectType.minorVersion())).toUtf8();
+            importCode = QString("import %1 %2.%3").arg(
+                        module, QString::number(qtObjectType.version().majorVersion()),
+                        QString::number(qtObjectType.version().minorVersion())).toUtf8();
         }
         // avoid importing dependencies?
         for (const QString &moduleToImport : qAsConst(dependencies)) {
@@ -1307,7 +1321,7 @@ int main(int argc, char *argv[])
                 return EXIT_IMPORTERROR;
             }
         }
-        info = {pluginImportUri, majorVersion, minorVersion, strict};
+        info = {pluginImportUri, version, strict};
         QSet<const QMetaObject *> candidates = collectReachableMetaObjects(&engine, uncreatableMetas, singletonMetas, compositeTypes, info, defaultTypes);
 
         for (auto it = compositeTypes.begin(), end = compositeTypes.end(); it != end; ++it) {