Add support for semi-automatic QML type registrations

We can use the new moc JSON output to collect all meta-objects at build
time and, for those that include QML element registration meta-data,
generate code that automatically registers these types with QML. This
eliminates the need to call qmlRegisterType manually.

For now this generates free-standing functions (per module) that need to
be called manually. This is intended as an intermediate step.

Task-number: QTBUG-68796
Change-Id: Ib414eef9757344feee488ebc7388f957b975347f
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

29 files changed, 1458 insertions, 81 deletions

diff --git a/src/qml/qml/qml.pri b/src/qml/qml/qml.pri
index 2e9c6f3de6..a16f3d4167 100644
--- a/src/qml/qml/qml.pri
+++ b/src/qml/qml/qml.pri
@@ -3,6 +3,7 @@ SOURCES += \
     $$PWD/qqmldatablob.cpp \
     $$PWD/qqmldirdata.cpp \
     $$PWD/qqmlerror.cpp \
+    $$PWD/qqmlmoduleregistration.cpp \
     $$PWD/qqmlopenmetaobject.cpp \
     $$PWD/qqmlscriptblob.cpp \
     $$PWD/qqmlscriptdata.cpp \
@@ -71,6 +72,7 @@ HEADERS += \
     $$PWD/qqmldatablob_p.h \
     $$PWD/qqmldirdata_p.h \
     $$PWD/qqmlglobal_p.h \
+    $$PWD/qqmlmoduleregistration.h \
     $$PWD/qqmlopenmetaobject_p.h \
     $$PWD/qqmlscriptblob_p.h \
     $$PWD/qqmlscriptdata_p.h \
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index af44d737a2..7edb8b3110 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -2262,7 +2262,7 @@ void QQmlEngine::setPluginPathList(const QStringList &paths)
 
   On failure and if non-null, the \a errors list will have any errors which occurred prepended to it.
 
-  The plugin has to be a Qt plugin which implements the QQmlExtensionPlugin interface.
+  The plugin has to be a Qt plugin which implements the QQmlEngineExtensionPlugin interface.
 */
 bool QQmlEngine::importPlugin(const QString &filePath, const QString &uri, QList<QQmlError> *errors)
 {
diff --git a/src/qml/qml/qqmlextensioninterface.h b/src/qml/qml/qqmlextensioninterface.h
index d2eb79c5c9..1490bc512e 100644
--- a/src/qml/qml/qqmlextensioninterface.h
+++ b/src/qml/qml/qqmlextensioninterface.h
@@ -62,8 +62,14 @@ public:
     virtual void initializeEngine(QQmlEngine *engine, const char *uri) = 0;
 };
 
-#define QQmlTypesExtensionInterface_iid "org.qt-project.Qt.QQmlTypesExtensionInterface"
+class Q_QML_EXPORT QQmlEngineExtensionInterface
+{
+public:
+    virtual ~QQmlEngineExtensionInterface() = default;
+    virtual void initializeEngine(QQmlEngine *engine, const char *uri) = 0;
+};
 
+#define QQmlTypesExtensionInterface_iid "org.qt-project.Qt.QQmlTypesExtensionInterface"
 Q_DECLARE_INTERFACE(QQmlTypesExtensionInterface, "org.qt-project.Qt.QQmlTypesExtensionInterface/1.0")
 
 // NOTE: When changing this to a new version and deciding to add backup code to
@@ -73,6 +79,9 @@ Q_DECLARE_INTERFACE(QQmlTypesExtensionInterface, "org.qt-project.Qt.QQmlTypesExt
 
 Q_DECLARE_INTERFACE(QQmlExtensionInterface, QQmlExtensionInterface_iid)
 
+#define QQmlEngineExtensionInterface_iid "org.qt-project.Qt.QQmlEngineExtensionInterface"
+Q_DECLARE_INTERFACE(QQmlEngineExtensionInterface, QQmlEngineExtensionInterface_iid)
+
 QT_END_NAMESPACE
 
 #endif // QQMLEXTENSIONINTERFACE_H
diff --git a/src/qml/qml/qqmlextensionplugin.cpp b/src/qml/qml/qqmlextensionplugin.cpp
index c1c971f0a9..26364661a8 100644
--- a/src/qml/qml/qqmlextensionplugin.cpp
+++ b/src/qml/qml/qqmlextensionplugin.cpp
@@ -43,10 +43,11 @@
 QT_BEGIN_NAMESPACE
 
 /*!
-    \since 5.0
+    \since 5.14
     \inmodule QtQml
-    \class QQmlExtensionPlugin
-    \brief The QQmlExtensionPlugin class provides an abstract base for custom QML extension plugins.
+    \class QQmlEngineExtensionPlugin
+    \brief The QQmlEngineExtensionPlugin class provides an abstract base for custom QML extension
+           plugins.
 
     \ingroup plugins
 
@@ -60,6 +61,7 @@ QT_BEGIN_NAMESPACE
 
 /*!
     \fn void QQmlExtensionPlugin::registerTypes(const char *uri)
+    \internal
 
     Registers the QML types in the given \a uri. Subclasses should implement
     this to call qmlRegisterType() for all types which are provided by the extension
@@ -70,26 +72,39 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
+    \internal
+*/
+QQmlExtensionPlugin::QQmlExtensionPlugin(QObject *parent)
+    : QObject(*(new QQmlExtensionPluginPrivate), parent)
+{
+}
+
+/*!
     Constructs a QML extension plugin with the given \a parent.
 
     Note that this constructor is invoked automatically by the
     Q_PLUGIN_METADATA() macro, so there is no need for calling it
     explicitly.
-*/
-QQmlExtensionPlugin::QQmlExtensionPlugin(QObject *parent)
-    : QObject(*(new QQmlExtensionPluginPrivate), parent)
+ */
+QQmlEngineExtensionPlugin::QQmlEngineExtensionPlugin(QObject *parent)
+    : QObject(parent)
 {
 }
 
+
 /*!
   \internal
  */
-QQmlExtensionPlugin::~QQmlExtensionPlugin()
-{
-}
+QQmlExtensionPlugin::~QQmlExtensionPlugin() = default;
+
+/*!
+  \internal
+ */
+QQmlEngineExtensionPlugin::~QQmlEngineExtensionPlugin() = default;
 
 /*!
     \since 5.1
+    \internal
     \brief Returns the URL of the directory from which the extension is loaded.
 
     This is useful when the plugin also needs to load QML files or other
@@ -102,14 +117,23 @@ QUrl QQmlExtensionPlugin::baseUrl() const
 }
 
 /*!
-    \fn void QQmlExtensionPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
+    \internal
+*/
+
+void QQmlExtensionPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
+{
+    Q_UNUSED(engine);
+    Q_UNUSED(uri);
+}
+
+/*!
+    \fn void QQmlEngineExtensionPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
 
     Initializes the extension from the \a uri using the \a engine. Here an application
     plugin might, for example, expose some data or objects to QML,
     as context properties on the engine's root context.
-*/
-
-void QQmlExtensionPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
+ */
+void QQmlEngineExtensionPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
 {
     Q_UNUSED(engine);
     Q_UNUSED(uri);
@@ -127,6 +151,12 @@ void QQmlExtensionPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
   \inmodule QtQml
 */
 
+/*!
+  \class QQmlEngineExtensionInterface
+  \internal
+  \inmodule QtQml
+*/
+
 QT_END_NAMESPACE
 
 #include "moc_qqmlextensionplugin.cpp"
diff --git a/src/qml/qml/qqmlextensionplugin.h b/src/qml/qml/qqmlextensionplugin.h
index 55e9b89dae..ef7ff422cd 100644
--- a/src/qml/qml/qqmlextensionplugin.h
+++ b/src/qml/qml/qqmlextensionplugin.h
@@ -70,6 +70,19 @@ private:
     Q_DISABLE_COPY(QQmlExtensionPlugin)
 };
 
+class Q_QML_EXPORT QQmlEngineExtensionPlugin
+        : public QObject
+        , public QQmlEngineExtensionInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY_MOVE(QQmlEngineExtensionPlugin)
+    Q_INTERFACES(QQmlEngineExtensionInterface)
+public:
+    explicit QQmlEngineExtensionPlugin(QObject *parent = nullptr);
+    ~QQmlEngineExtensionPlugin() override;
+    void initializeEngine(QQmlEngine *engine, const char *uri) override;
+};
+
 QT_END_NAMESPACE
 
 #endif // QQMLEXTENSIONPLUGIN_H
diff --git a/src/qml/qml/qqmlimport.cpp b/src/qml/qml/qqmlimport.cpp
index d69c2ac903..79e3585202 100644
--- a/src/qml/qml/qqmlimport.cpp
+++ b/src/qml/qml/qqmlimport.cpp
@@ -990,7 +990,9 @@ static QVector<QStaticPlugin> makePlugins()
     const auto staticPlugins = QPluginLoader::staticPlugins();
     for (const QStaticPlugin &plugin : staticPlugins) {
         const QString iid = plugin.metaData().value(QLatin1String("IID")).toString();
-        if (iid == QLatin1String(QQmlExtensionInterface_iid) || iid == QLatin1String(QQmlExtensionInterface_iid_old)) {
+        if (iid == QLatin1String(QQmlEngineExtensionInterface_iid)
+                || iid == QLatin1String(QQmlExtensionInterface_iid)
+                || iid == QLatin1String(QQmlExtensionInterface_iid_old)) {
             plugins.append(plugin);
         }
     }
@@ -1008,7 +1010,9 @@ bool QQmlImportsPrivate::populatePluginPairVector(QVector<StaticPluginPair> &res
     static const QVector<QStaticPlugin> plugins = makePlugins();
     for (const QStaticPlugin &plugin : plugins) {
         // Since a module can list more than one plugin, we keep iterating even after we found a match.
-        if (QQmlExtensionPlugin *instance = qobject_cast<QQmlExtensionPlugin *>(plugin.instance())) {
+        QObject *instance = plugin.instance();
+        if (qobject_cast<QQmlEngineExtensionPlugin *>(instance)
+                || qobject_cast<QQmlExtensionPlugin *>(instance)) {
             const QJsonArray metaTagsUriList = plugin.metaData().value(QLatin1String("uri")).toArray();
             if (metaTagsUriList.isEmpty()) {
                 if (errors) {
@@ -2055,17 +2059,8 @@ bool QQmlImportDatabase::importStaticPlugin(QObject *instance, const QString &ba
         // other QML loader threads and thus not process the initializeEngine call).
     }
 
-    // The plugin's per-engine initialization does not need lock protection, as this function is
-    // only called from the engine specific loader thread and importDynamicPlugin as well as
-    // importStaticPlugin are the only places of access.
-    if (!initializedPlugins.contains(uniquePluginID)) {
-        initializedPlugins.insert(uniquePluginID);
-
-        if (QQmlExtensionInterface *eiface = qobject_cast<QQmlExtensionInterface *>(instance)) {
-            QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
-            ep->typeLoader.initializeEngine(eiface, uri.toUtf8().constData());
-        }
-    }
+    if (!initializedPlugins.contains(uniquePluginID))
+        finalizePlugin(instance, uniquePluginID, uri);
 
     return true;
 }
@@ -2140,18 +2135,8 @@ bool QQmlImportDatabase::importDynamicPlugin(const QString &filePath, const QStr
     // other QML loader threads and thus not process the initializeEngine call).
     }
 
-
-    if (!engineInitialized) {
-        // The plugin's per-engine initialization does not need lock protection, as this function is
-        // only called from the engine specific loader thread and importDynamicPlugin as well as
-        // importStaticPlugin are the only places of access.
-        initializedPlugins.insert(absoluteFilePath);
-
-        if (QQmlExtensionInterface *eiface = qobject_cast<QQmlExtensionInterface *>(instance)) {
-            QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
-            ep->typeLoader.initializeEngine(eiface, uri.toUtf8().constData());
-        }
-    }
+    if (!engineInitialized)
+        finalizePlugin(instance, absoluteFilePath, uri);
 
     return true;
 }
@@ -2174,4 +2159,20 @@ void QQmlImportDatabase::clearDirCache()
     qmldirCache.clear();
 }
 
+void QQmlImportDatabase::finalizePlugin(QObject *instance, const QString &path, const QString &uri)
+{
+    // The plugin's per-engine initialization does not need lock protection, as this function is
+    // only called from the engine specific loader thread and importDynamicPlugin as well as
+    // importStaticPlugin are the only places of access.
+
+    initializedPlugins.insert(path);
+    if (auto *extensionIface = qobject_cast<QQmlExtensionInterface *>(instance)) {
+        QQmlEnginePrivate::get(engine)->typeLoader.initializeEngine(
+                    extensionIface, uri.toUtf8().constData());
+    } else if (auto *engineIface = qobject_cast<QQmlEngineExtensionInterface *>(instance)) {
+        QQmlEnginePrivate::get(engine)->typeLoader.initializeEngine(
+                    engineIface, uri.toUtf8().constData());
+    }
+}
+
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlimport_p.h b/src/qml/qml/qqmlimport_p.h
index e24b3c447c..7f781d2eb7 100644
--- a/src/qml/qml/qqmlimport_p.h
+++ b/src/qml/qml/qqmlimport_p.h
@@ -236,6 +236,7 @@ private:
     bool importStaticPlugin(QObject *instance, const QString &basePath, const QString &uri,
                           const QString &typeNamespace, int vmaj, QList<QQmlError> *errors);
     void clearDirCache();
+    void finalizePlugin(QObject *instance, const QString &path, const QString &uri);
 
     struct QmldirCache {
         int versionMajor;
diff --git a/src/qml/qml/qqmlmetatype.cpp b/src/qml/qml/qqmlmetatype.cpp
index 1a5affb0ad..c21247bb95 100644
--- a/src/qml/qml/qqmlmetatype.cpp
+++ b/src/qml/qml/qqmlmetatype.cpp
@@ -267,6 +267,23 @@ void QQmlMetaType::clone(QMetaObjectBuilder &builder, const QMetaObject *mo,
     }
 }
 
+void QQmlMetaType::qmlInsertModuleRegistration(const QString &uri, int majorVersion,
+                                               void (*registerFunction)())
+{
+    const QQmlMetaTypeData::VersionedUri versionedUri(uri, majorVersion);
+    QQmlMetaTypeDataPtr data;
+    if (data->moduleTypeRegistrationFunctions.contains(versionedUri))
+        qFatal("Canot add multiple registrations for %s %d", qPrintable(uri), majorVersion);
+    else
+        data->moduleTypeRegistrationFunctions.insert(versionedUri, registerFunction);
+}
+
+void QQmlMetaType::qmlRegisterModuleTypes(const QString &uri, int majorVersion)
+{
+    QQmlMetaTypeDataPtr data;
+    data->registerModuleTypes(QQmlMetaTypeData::VersionedUri(uri, majorVersion));
+}
+
 void QQmlMetaType::clearTypeRegistrations()
 {
     //Only cleans global static, assumed no running engine
@@ -633,17 +650,6 @@ bool QQmlMetaType::registerPluginTypes(QObject *instance, const QString &basePat
                                        const QString &uri, const QString &typeNamespace, int vmaj,
                                        QList<QQmlError> *errors)
 {
-    QQmlTypesExtensionInterface *iface = qobject_cast<QQmlTypesExtensionInterface *>(instance);
-    if (!iface) {
-        if (errors) {
-            QQmlError error;
-            error.setDescription(QStringLiteral("Module loaded for URI '%1' does not implement "
-                                                "QQmlTypesExtensionInterface").arg(typeNamespace));
-            errors->prepend(error);
-        }
-        return false;
-    }
-
     if (!typeNamespace.isEmpty() && typeNamespace != uri) {
         // This is an 'identified' module
         // The namespace for type registrations must match the URI for locating the module
@@ -681,26 +687,42 @@ bool QQmlMetaType::registerPluginTypes(QObject *instance, const QString &basePat
                                    "it cannot be protected from external registrations.").arg(uri));
         }
 
-        if (auto *plugin = qobject_cast<QQmlExtensionPlugin *>(instance)) {
-        // basepath should point to the directory of the module, not the plugin file itself:
-        QQmlExtensionPluginPrivate::get(plugin)->baseUrl
-                = QQmlImports::urlFromLocalFileOrQrcOrUrl(basePath);
+        if (!qobject_cast<QQmlEngineExtensionInterface *>(instance)) {
+            QQmlTypesExtensionInterface *iface = qobject_cast<QQmlTypesExtensionInterface *>(instance);
+            if (!iface) {
+                if (errors) {
+                    QQmlError error;
+                    // Also does not implement QQmlTypesExtensionInterface, but we want to discourage that.
+                    error.setDescription(QStringLiteral("Module loaded for URI '%1' does not implement "
+                                                        "QQmlEngineExtensionInterface").arg(typeNamespace));
+                    errors->prepend(error);
+                }
+                return false;
+            }
+
+            if (auto *plugin = qobject_cast<QQmlExtensionPlugin *>(instance)) {
+                // basepath should point to the directory of the module, not the plugin file itself:
+                QQmlExtensionPluginPrivate::get(plugin)->baseUrl
+                        = QQmlImports::urlFromLocalFileOrQrcOrUrl(basePath);
+            }
+
+            const QByteArray bytes = uri.toUtf8();
+            const char *moduleId = bytes.constData();
+            iface->registerTypes(moduleId);
         }
 
-        const QByteArray bytes = uri.toUtf8();
-        const char *moduleId = bytes.constData();
-        iface->registerTypes(moduleId);
-    }
+        data->registerModuleTypes(QQmlMetaTypeData::VersionedUri(uri, vmaj));
 
-    if (!failures.isEmpty()) {
-        if (errors) {
-            for (const QString &failure : qAsConst(failures)) {
-                QQmlError error;
-                error.setDescription(failure);
-                errors->prepend(error);
+        if (!failures.isEmpty()) {
+            if (errors) {
+                for (const QString &failure : qAsConst(failures)) {
+                    QQmlError error;
+                    error.setDescription(failure);
+                    errors->prepend(error);
+                }
             }
+            return false;
         }
-        return false;
     }
 
     return true;
diff --git a/src/qml/qml/qqmlmetatype_p.h b/src/qml/qml/qqmlmetatype_p.h
index 35d5386e1f..13ba4d809b 100644
--- a/src/qml/qml/qqmlmetatype_p.h
+++ b/src/qml/qml/qqmlmetatype_p.h
@@ -188,6 +188,10 @@ public:
 
     static void clone(QMetaObjectBuilder &builder, const QMetaObject *mo,
                       const QMetaObject *ignoreStart, const QMetaObject *ignoreEnd);
+
+    static void qmlInsertModuleRegistration(const QString &uri, int majorVersion,
+                                            void (*registerFunction)());
+    static void qmlRegisterModuleTypes(const QString &uri, int majorVersion);
 };
 
 Q_DECLARE_TYPEINFO(QQmlMetaType, Q_MOVABLE_TYPE);
diff --git a/src/qml/qml/qqmlmetatypedata.cpp b/src/qml/qml/qqmlmetatypedata.cpp
index 775bc8bdb4..c2150225c3 100644
--- a/src/qml/qml/qqmlmetatypedata.cpp
+++ b/src/qml/qml/qqmlmetatypedata.cpp
@@ -78,6 +78,13 @@ void QQmlMetaTypeData::registerType(QQmlTypePrivate *priv)
     priv->release();
 }
 
+void QQmlMetaTypeData::registerModuleTypes(const QQmlMetaTypeData::VersionedUri &versionedUri)
+{
+    auto function = moduleTypeRegistrationFunctions.constFind(versionedUri);
+    if (function != moduleTypeRegistrationFunctions.constEnd())
+        (*function)();
+}
+
 QQmlPropertyCache *QQmlMetaTypeData::propertyCacheForMinorVersion(int index, int minorVersion) const
 {
     return (index < typePropertyCaches.length())
diff --git a/src/qml/qml/qqmlmetatypedata_p.h b/src/qml/qml/qqmlmetatypedata_p.h
index ea796ee7c6..755a51a16e 100644
--- a/src/qml/qml/qqmlmetatypedata_p.h
+++ b/src/qml/qml/qqmlmetatypedata_p.h
@@ -96,9 +96,13 @@ struct QQmlMetaTypeData
         QHashedString uri;
         int majorVersion;
     };
+
     typedef QHash<VersionedUri, QQmlTypeModule *> TypeModules;
     TypeModules uriToModule;
 
+    QHash<VersionedUri, void (*)()> moduleTypeRegistrationFunctions;
+    void registerModuleTypes(const VersionedUri &versionedUri);
+
     QBitArray objects;
     QBitArray interfaces;
     QBitArray lists;
diff --git a/src/qml/qml/qqmlmoduleregistration.cpp b/src/qml/qml/qqmlmoduleregistration.cpp
new file mode 100644
index 0000000000..bb82ec1d95
--- /dev/null
+++ b/src/qml/qml/qqmlmoduleregistration.cpp
@@ -0,0 +1,54 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtQml/private/qqmlmetatype_p.h>
+#include <QtQml/qqmlmoduleregistration.h>
+#include <QtCore/qglobalstatic.h>
+
+QT_BEGIN_NAMESPACE
+
+QQmlModuleRegistration::QQmlModuleRegistration(
+        const char *uri, int majorVersion,
+        void (*registerFunction)())
+{
+    QQmlMetaType::qmlInsertModuleRegistration(QString::fromUtf8(uri), majorVersion,
+                                              registerFunction);
+}
+
+QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlmoduleregistration.h b/src/qml/qml/qqmlmoduleregistration.h
new file mode 100644
index 0000000000..8924724b48
--- /dev/null
+++ b/src/qml/qml/qqmlmoduleregistration.h
@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQMLMODULEREGISTRATION_H
+#define QQMLMODULEREGISTRATION_H
+
+#include <QtQml/qtqmlglobal.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QML_EXPORT QQmlModuleRegistration
+{
+    Q_DISABLE_COPY_MOVE(QQmlModuleRegistration)
+
+public:
+    QQmlModuleRegistration(const char *uri, int majorVersion, void (*registerFunction)());
+    ~QQmlModuleRegistration() = default;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQMLMODULEREGISTRATION_H
diff --git a/src/qml/qml/qqmltypeloader.cpp b/src/qml/qml/qqmltypeloader.cpp
index c62f760ee3..54f94d6a11 100644
--- a/src/qml/qml/qqmltypeloader.cpp
+++ b/src/qml/qml/qqmltypeloader.cpp
@@ -395,19 +395,29 @@ QQmlEngine *QQmlTypeLoader::engine() const
 Call the initializeEngine() method on \a iface.  Used by QQmlImportDatabase to ensure it
 gets called in the correct thread.
 */
-void QQmlTypeLoader::initializeEngine(QQmlExtensionInterface *iface,
-                                              const char *uri)
+template<class Interface>
+void doInitializeEngine(Interface *iface, QQmlTypeLoaderThread *thread, QQmlEngine *engine,
+                      const char *uri)
 {
-    Q_ASSERT(m_thread->isThisThread() || engine()->thread() == QThread::currentThread());
+    Q_ASSERT(thread->isThisThread() || engine->thread() == QThread::currentThread());
 
-    if (m_thread->isThisThread()) {
-        m_thread->initializeEngine(iface, uri);
+    if (thread->isThisThread()) {
+        thread->initializeEngine(iface, uri);
     } else {
-        Q_ASSERT(engine()->thread() == QThread::currentThread());
-        iface->initializeEngine(engine(), uri);
+        Q_ASSERT(engine->thread() == QThread::currentThread());
+        iface->initializeEngine(engine, uri);
     }
 }
 
+void QQmlTypeLoader::initializeEngine(QQmlEngineExtensionInterface *iface, const char *uri)
+{
+    doInitializeEngine(iface, m_thread, engine(), uri);
+}
+
+void QQmlTypeLoader::initializeEngine(QQmlExtensionInterface *iface, const char *uri)
+{
+    doInitializeEngine(iface, m_thread, engine(), uri);
+}
 
 void QQmlTypeLoader::setData(QQmlDataBlob *blob, const QByteArray &data)
 {
diff --git a/src/qml/qml/qqmltypeloader_p.h b/src/qml/qml/qqmltypeloader_p.h
index 612d6777ed..d45f0e095c 100644
--- a/src/qml/qml/qqmltypeloader_p.h
+++ b/src/qml/qml/qqmltypeloader_p.h
@@ -68,6 +68,7 @@ QT_BEGIN_NAMESPACE
 class QQmlScriptBlob;
 class QQmlQmldirData;
 class QQmlTypeData;
+class QQmlEngineExtensionInterface;
 class QQmlExtensionInterface;
 class QQmlProfiler;
 class QQmlTypeLoaderThread;
@@ -172,6 +173,7 @@ public:
     void loadWithCachedUnit(QQmlDataBlob *blob, const QV4::CompiledData::Unit *unit, Mode mode = PreferSynchronous);
 
     QQmlEngine *engine() const;
+    void initializeEngine(QQmlEngineExtensionInterface *, const char *);
     void initializeEngine(QQmlExtensionInterface *, const char *);
     void invalidate();
 
diff --git a/src/qml/qml/qqmltypeloaderthread.cpp b/src/qml/qml/qqmltypeloaderthread.cpp
index 0e1cecd1e5..618bb09039 100644
--- a/src/qml/qml/qqmltypeloaderthread.cpp
+++ b/src/qml/qml/qqmltypeloaderthread.cpp
@@ -138,7 +138,13 @@ void QQmlTypeLoaderThread::callDownloadProgressChanged(QQmlDataBlob *b, qreal p)
 void QQmlTypeLoaderThread::initializeEngine(QQmlExtensionInterface *iface,
                                             const char *uri)
 {
-    callMethodInMain(&This::initializeEngineMain, iface, uri);
+    callMethodInMain(&This::initializeExtensionMain, iface, uri);
+}
+
+void QQmlTypeLoaderThread::initializeEngine(QQmlEngineExtensionInterface *iface,
+                                            const char *uri)
+{
+    callMethodInMain(&This::initializeEngineExtensionMain, iface, uri);
 }
 
 void QQmlTypeLoaderThread::shutdownThread()
@@ -188,7 +194,14 @@ void QQmlTypeLoaderThread::callDownloadProgressChangedMain(QQmlDataBlob *b, qrea
     b->release();
 }
 
-void QQmlTypeLoaderThread::initializeEngineMain(QQmlExtensionInterface *iface,
+void QQmlTypeLoaderThread::initializeExtensionMain(QQmlExtensionInterface *iface,
+                                                const char *uri)
+{
+    Q_ASSERT(m_loader->engine()->thread() == QThread::currentThread());
+    iface->initializeEngine(m_loader->engine(), uri);
+}
+
+void QQmlTypeLoaderThread::initializeEngineExtensionMain(QQmlEngineExtensionInterface *iface,
                                                 const char *uri)
 {
     Q_ASSERT(m_loader->engine()->thread() == QThread::currentThread());
diff --git a/src/qml/qml/qqmltypeloaderthread_p.h b/src/qml/qml/qqmltypeloaderthread_p.h
index 67e47e86de..9fb441e6e2 100644
--- a/src/qml/qml/qqmltypeloaderthread_p.h
+++ b/src/qml/qml/qqmltypeloaderthread_p.h
@@ -65,6 +65,7 @@ QT_BEGIN_NAMESPACE
 
 class QQmlDataBlob;
 class QQmlTypeLoader;
+class QQmlEngineExtensionInterface;
 class QQmlExtensionInterface;
 
 class QQmlTypeLoaderThread : public QQmlThread
@@ -86,6 +87,7 @@ public:
     void callCompleted(QQmlDataBlob *b);
     void callDownloadProgressChanged(QQmlDataBlob *b, qreal p);
     void initializeEngine(QQmlExtensionInterface *, const char *);
+    void initializeEngine(QQmlEngineExtensionInterface *, const char *);
 
 protected:
     void shutdownThread() override;
@@ -96,7 +98,8 @@ private:
     void loadWithCachedUnitThread(QQmlDataBlob *b, const QV4::CompiledData::Unit *unit);
     void callCompletedMain(QQmlDataBlob *b);
     void callDownloadProgressChangedMain(QQmlDataBlob *b, qreal p);
-    void initializeEngineMain(QQmlExtensionInterface *iface, const char *uri);
+    void initializeExtensionMain(QQmlExtensionInterface *iface, const char *uri);
+    void initializeEngineExtensionMain(QQmlEngineExtensionInterface *iface, const char *uri);
 
     QQmlTypeLoader *m_loader;
 #if QT_CONFIG(qml_network)
diff --git a/src/quick/util/qquickimageprovider.cpp b/src/quick/util/qquickimageprovider.cpp
index ebcca77f17..c081d45268 100644
--- a/src/quick/util/qquickimageprovider.cpp
+++ b/src/quick/util/qquickimageprovider.cpp
@@ -291,7 +291,7 @@ void QQuickImageResponse::cancel()
     \image imageprovider.png
 
     See the \l {imageprovider}{Image Provider Example} for the complete implementation.
-    Note that the example registers the provider via a \l{QQmlExtensionPlugin}{plugin}
+    Note that the example registers the provider via a \l{QQmlEngineExtensionPlugin}{plugin}
     instead of registering it in the application \c main() function as shown above.
 
 
diff --git a/tools/qmlplugindump/qmlplugindump.pro b/tools/qmlplugindump/qmlplugindump.pro
index 62b08e9334..e374ae45f4 100644
--- a/tools/qmlplugindump/qmlplugindump.pro
+++ b/tools/qmlplugindump/qmlplugindump.pro
@@ -5,14 +5,16 @@ CONFIG += no_import_scan
 
 QTPLUGIN.platforms = qminimal
 
+INCLUDEPATH += ../shared
+
 SOURCES += \
     main.cpp \
-    qmlstreamwriter.cpp \
-    qmltypereader.cpp
+    qmltypereader.cpp \
+    ../shared/qmlstreamwriter.cpp
 
 HEADERS += \
-    qmlstreamwriter.h \
-    qmltypereader.h
+    qmltypereader.h \
+    ../shared/qmlstreamwriter.h
 
 macx {
     # Prevent qmlplugindump from popping up in the dock when launched.
diff --git a/tools/qmltyperegistrar/qmltyperegistrar.cpp b/tools/qmltyperegistrar/qmltyperegistrar.cpp
new file mode 100644
index 0000000000..2cf309ff0d
--- /dev/null
+++ b/tools/qmltyperegistrar/qmltyperegistrar.cpp
@@ -0,0 +1,404 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmltypescreator.h"
+
+#include <QCoreApplication>
+#include <QCommandLineParser>
+#include <QtDebug>
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QJsonValue>
+#include <QJsonObject>
+#include <QFile>
+#include <QScopedPointer>
+#include <QSaveFile>
+#include <QQueue>
+
+#include <cstdlib>
+
+struct ScopedPointerFileCloser
+{
+    static inline void cleanup(FILE *handle) { if (handle) fclose(handle); }
+};
+
+static bool acceptClassForQmlTypeRegistration(const QJsonObject &classDef)
+{
+    const QJsonArray classInfos = classDef[QLatin1String("classInfos")].toArray();
+    for (const QJsonValue &info: classInfos) {
+        if (info[QLatin1String("name")].toString().startsWith(QLatin1String("QML.")))
+            return true;
+    }
+    return false;
+}
+
+static QVector<QJsonObject> foreignRelatedTypes(const QVector<QJsonObject> &types,
+                                                const QVector<QJsonObject> &foreignTypes)
+{
+    const QLatin1String classInfosKey("classInfos");
+    const QLatin1String nameKey("name");
+    const QLatin1String qualifiedClassNameKey("qualifiedClassName");
+    const QLatin1String qmlNamePrefix("QML.");
+    const QLatin1String qmlForeignName("QML.Foreign");
+    const QLatin1String qmlAttachedName("QML.Attached");
+    const QLatin1String valueKey("value");
+    const QLatin1String superClassesKey("superClasses");
+    const QLatin1String accessKey("access");
+    const QLatin1String publicAccess("public");
+
+    QSet<QString> processedRelatedNames;
+    QQueue<QJsonObject> typeQueue;
+    typeQueue.append(types.toList());
+    QVector<QJsonObject> relatedTypes;
+
+    // First mark all classes registered from this module as already processed.
+    for (const QJsonObject &type : types) {
+        processedRelatedNames.insert(type.value(qualifiedClassNameKey).toString());
+        const auto classInfos = type.value(classInfosKey).toArray();
+        for (const QJsonValue &classInfo : classInfos) {
+            const QJsonObject obj = classInfo.toObject();
+            if (obj.value(nameKey).toString() == qmlForeignName) {
+                processedRelatedNames.insert(obj.value(valueKey).toString());
+                break;
+            }
+        }
+    }
+
+    // Then mark all classes registered from other modules as already processed.
+    // We don't want to generate them again for this module.
+    for (const QJsonObject &foreignType : foreignTypes) {
+        const auto classInfos = foreignType.value(classInfosKey).toArray();
+        bool seenQmlPrefix = false;
+        for (const QJsonValue &classInfo : classInfos) {
+            const QJsonObject obj = classInfo.toObject();
+            const QString name = obj.value(nameKey).toString();
+            if (!seenQmlPrefix && name.startsWith(qmlNamePrefix)) {
+                processedRelatedNames.insert(foreignType.value(qualifiedClassNameKey).toString());
+                seenQmlPrefix = true;
+            }
+            if (name == qmlForeignName) {
+                processedRelatedNames.insert(obj.value(valueKey).toString());
+                break;
+            }
+        }
+    }
+
+    auto addType = [&](const QString &typeName) {
+        if (processedRelatedNames.contains(typeName))
+            return;
+        processedRelatedNames.insert(typeName);
+        if (const QJsonObject *other = QmlTypesClassDescription::findType(foreignTypes, typeName)) {
+            relatedTypes.append(*other);
+            typeQueue.enqueue(*other);
+        }
+    };
+
+    // Then recursively iterate the super types and attached types, marking the
+    // ones we are interested in as related.
+    while (!typeQueue.isEmpty()) {
+        const QJsonObject classDef = typeQueue.dequeue();
+
+        const auto classInfos = classDef.value(classInfosKey).toArray();
+        for (const QJsonValue &classInfo : classInfos) {
+            const QJsonObject obj = classInfo.toObject();
+            if (obj.value(nameKey).toString() == qmlAttachedName) {
+                addType(obj.value(valueKey).toString());
+            } else if (obj.value(nameKey).toString() == qmlForeignName) {
+                const QString foreignClassName = obj.value(valueKey).toString();
+                if (const QJsonObject *other = QmlTypesClassDescription::findType(
+                            foreignTypes, foreignClassName)) {
+                    const auto otherSupers = other->value(superClassesKey).toArray();
+                    if (!otherSupers.isEmpty()) {
+                        const QJsonObject otherSuperObject = otherSupers.first().toObject();
+                        if (otherSuperObject.value(accessKey).toString() == publicAccess)
+                            addType(otherSuperObject.value(nameKey).toString());
+                    }
+
+                    const auto otherClassInfos = other->value(classInfosKey).toArray();
+                    for (const QJsonValue &otherClassInfo : otherClassInfos) {
+                        const QJsonObject obj = otherClassInfo.toObject();
+                        if (obj.value(nameKey).toString() == qmlAttachedName) {
+                            addType(obj.value(valueKey).toString());
+                            break;
+                        }
+                        // No, you cannot chain QML_FOREIGN declarations. Sorry.
+                    }
+                    break;
+                }
+            }
+        }
+
+        const auto supers = classDef.value(superClassesKey).toArray();
+        if (!supers.isEmpty()) {
+            const QJsonObject superObject = supers.first().toObject();
+            if (superObject.value(accessKey).toString() == publicAccess)
+                addType(superObject.value(nameKey).toString());
+        }
+    }
+
+    return relatedTypes;
+}
+
+int main(int argc, char **argv)
+{
+    // Produce reliably the same output for the same input by disabling QHash's random seeding.
+    qSetGlobalQHashSeed(0);
+
+    QCoreApplication app(argc, argv);
+    QCoreApplication::setApplicationName(QStringLiteral("qmltyperegistrar"));
+    QCoreApplication::setApplicationVersion(QLatin1String(QT_VERSION_STR));
+
+    QCommandLineParser parser;
+    parser.addHelpOption();
+    parser.addVersionOption();
+
+    QCommandLineOption outputOption(QStringLiteral("o"));
+    outputOption.setDescription(QStringLiteral("Write output to specified file."));
+    outputOption.setValueName(QStringLiteral("file"));
+    outputOption.setFlags(QCommandLineOption::ShortOptionStyle);
+    parser.addOption(outputOption);
+
+    QCommandLineOption privateIncludesOption(
+            QStringLiteral("private-includes"),
+            QStringLiteral("Include headers ending in \"_p.h\" using \"#include <private/foo_p.h>\""
+                           "rather than \"#include <foo_p.h>\"."));
+    parser.addOption(privateIncludesOption);
+
+    QCommandLineOption importNameOption(QStringLiteral("import-name"));
+    importNameOption.setDescription(QStringLiteral("Name of the module to use with QML type registrations."));
+    importNameOption.setValueName(QStringLiteral("QML module name"));
+    parser.addOption(importNameOption);
+
+    QCommandLineOption majorVersionOption(QStringLiteral("major-version"));
+    majorVersionOption.setDescription(QStringLiteral("Major version to use for type registrations."));
+    majorVersionOption.setValueName(QStringLiteral("major version"));
+    parser.addOption(majorVersionOption);
+
+    QCommandLineOption pluginTypesOption(QStringLiteral("generate-plugintypes"));
+    pluginTypesOption.setDescription(QStringLiteral("Generate plugins.qmltypes into specified directory."));
+    pluginTypesOption.setValueName(QStringLiteral("qmltypes target Directory"));
+    parser.addOption(pluginTypesOption);
+
+    QCommandLineOption foreignTypesOption(QStringLiteral("foreign-types"));
+    foreignTypesOption.setDescription(QStringLiteral("Consider foreign types when generating plugins.qmltypes."));
+    foreignTypesOption.setValueName(QStringLiteral("Comma separated list of other modules to consult for types."));
+    parser.addOption(foreignTypesOption);
+
+    QCommandLineOption dependenciesOption(QStringLiteral("dependencies"));
+    dependenciesOption.setDescription(QStringLiteral("Dependencies to be stated in plugins.qmltypes"));
+    dependenciesOption.setValueName(QStringLiteral("name of JSON file with dependencies"));
+    parser.addOption(dependenciesOption);
+
+    parser.addPositionalArgument(QStringLiteral("[MOC generated json file]"),
+                                 QStringLiteral("MOC generated json output"));
+
+    parser.process(app);
+
+    FILE *output = stdout;
+    QScopedPointer<FILE, ScopedPointerFileCloser> outputFile;
+
+    if (parser.isSet(outputOption)) {
+        QString outputName = parser.value(outputOption);
+#if defined(_MSC_VER)
+        if (_wfopen_s(&output, reinterpret_cast<const wchar_t *>(outputName.utf16()), L"w") != 0) {
+#else
+        output = fopen(QFile::encodeName(outputName).constData(), "w"); // create output file
+        if (!output) {
+#endif
+            fprintf(stderr, "Error: Cannot open %s for writing\n", qPrintable(outputName));
+            return EXIT_FAILURE;
+        }
+        outputFile.reset(output);
+    }
+
+    fprintf(output,
+            "/****************************************************************************\n"
+            "** Generated QML type registration code\n**\n");
+    fprintf(output,
+            "** WARNING! All changes made in this file will be lost!\n"
+            "*****************************************************************************/\n\n");
+    fprintf(output,
+            "#include <QtQml/qqmlengine.h>\n");
+
+    QStringList includes;
+    QVector<QJsonObject> types;
+    QVector<QJsonObject> foreignTypes;
+
+    const QString module = parser.value(importNameOption);
+    const QStringList files = parser.positionalArguments();
+    for (const QString &source: files) {
+        QJsonDocument metaObjects;
+        {
+            QFile f(source);
+            if (!f.open(QIODevice::ReadOnly)) {
+                fprintf(stderr, "Error opening %s for reading\n", qPrintable(source));
+                return EXIT_FAILURE;
+            }
+            QJsonParseError error = {0, QJsonParseError::NoError};
+            metaObjects = QJsonDocument::fromJson(f.readAll(), &error);
+            if (error.error != QJsonParseError::NoError) {
+                fprintf(stderr, "Error parsing %s\n", qPrintable(source));
+                return EXIT_FAILURE;
+            }
+        }
+
+        auto processMetaObject = [&](const QJsonObject &metaObject) {
+            const QJsonArray classes = metaObject[QLatin1String("classes")].toArray();
+            for (const auto &cls : classes) {
+                QJsonObject classDef = cls.toObject();
+                if (acceptClassForQmlTypeRegistration(classDef)) {
+                    const QString include = metaObject[QLatin1String("inputFile")].toString();
+                    const bool declaredInHeader = include.endsWith(QLatin1String(".h"));
+                    if (declaredInHeader) {
+                        includes.append(include);
+                        classDef.insert(QLatin1String("registerable"), true);
+                    } else {
+                        fprintf(stderr, "Cannot generate QML type registration for class %s "
+                                        "because it is not declared in a header.",
+                                qPrintable(classDef.value(QLatin1String("qualifiedClassName"))
+                                           .toString()));
+                    }
+                    types.append(classDef);
+                } else {
+                    foreignTypes.append(classDef);
+                }
+            }
+        };
+
+        if (metaObjects.isArray()) {
+            const QJsonArray metaObjectsArray = metaObjects.array();
+            for (const auto &metaObject : metaObjectsArray) {
+                if (!metaObject.isObject()) {
+                    fprintf(stderr, "Error parsing %s: JSON is not an object\n",
+                            qPrintable(source));
+                    return EXIT_FAILURE;
+                }
+
+                processMetaObject(metaObject.toObject());
+            }
+        } else if (metaObjects.isObject()) {
+            processMetaObject(metaObjects.object());
+        } else {
+            fprintf(stderr, "Error parsing %s: JSON is not an object or an array\n",
+                    qPrintable(source));
+            return EXIT_FAILURE;
+        }
+    }
+
+    const QLatin1String qualifiedClassNameKey("qualifiedClassName");
+    auto sortTypes = [&](QVector<QJsonObject> &types) {
+        std::sort(types.begin(), types.end(), [&](const QJsonObject &a, const QJsonObject &b) {
+            return a.value(qualifiedClassNameKey).toString() <
+                    b.value(qualifiedClassNameKey).toString();
+        });
+    };
+
+    sortTypes(types);
+
+    fprintf(output, "\n#include <QtQml/qqmlmoduleregistration.h>");
+    const bool privateIncludes = parser.isSet(privateIncludesOption);
+    for (const QString &include : qAsConst(includes)) {
+        if (privateIncludes && include.endsWith(QLatin1String("_p.h")))
+            fprintf(output, "\n#include <private/%s>", qPrintable(include));
+        else
+            fprintf(output, "\n#include <%s>", qPrintable(include));
+    }
+
+    fprintf(output, "\n\n");
+
+    QString moduleAsSymbol = module;
+    moduleAsSymbol.replace(QLatin1Char('.'), QLatin1Char('_'));
+
+    const QString functionName = QStringLiteral("qml_register_types_") + moduleAsSymbol;
+
+    fprintf(output, "void %s()\n{\n", qPrintable(functionName));
+    const auto majorVersion = parser.value(majorVersionOption);
+
+    for (const QJsonObject &classDef : qAsConst(types)) {
+        if (!classDef.value(QLatin1String("registerable")).toBool())
+            continue;
+
+        const QString className = classDef[QLatin1String("qualifiedClassName")].toString();
+        fprintf(output, "\n    qmlRegisterTypesAndRevisions<%s>(\"%s\", %s);", qPrintable(className),
+                qPrintable(module), qPrintable(majorVersion));
+    }
+
+    fprintf(output, "\n    qmlRegisterModule(\"%s\", %s, QT_VERSION_MINOR);",
+            qPrintable(module), qPrintable(majorVersion));
+    fprintf(output, "\n}\n");
+    fprintf(output, "static const QQmlModuleRegistration registration(\"%s\", %s, %s);\n",
+            qPrintable(module), qPrintable(majorVersion), qPrintable(functionName));
+
+    if (!parser.isSet(pluginTypesOption))
+        return EXIT_SUCCESS;
+
+    if (parser.isSet(foreignTypesOption)) {
+        const QStringList foreignTypesFiles = parser.value(foreignTypesOption)
+                .split(QLatin1Char(','));
+        for (const QString &types : foreignTypesFiles) {
+            QFile typesFile(types);
+            if (!typesFile.open(QIODevice::ReadOnly)) {
+                fprintf(stderr, "Cannot open foreign types file %s\n", qPrintable(types));
+                continue;
+            }
+
+            QJsonParseError error = {0, QJsonParseError::NoError};
+            QJsonDocument foreignMetaObjects = QJsonDocument::fromJson(typesFile.readAll(), &error);
+            if (error.error != QJsonParseError::NoError) {
+                fprintf(stderr, "Error parsing %s\n", qPrintable(types));
+                continue;
+            }
+
+            const QJsonArray foreignObjectsArray = foreignMetaObjects.array();
+            for (const auto &metaObject : foreignObjectsArray) {
+                if (!metaObject.isObject()) {
+                    fprintf(stderr, "Error parsing %s: JSON is not an object\n",
+                            qPrintable(types));
+                    continue;
+                }
+
+                const QJsonArray classes = metaObject[QLatin1String("classes")].toArray();
+                for (const auto &cls : classes)
+                    foreignTypes.append(cls.toObject());
+            }
+        }
+    }
+
+    sortTypes(foreignTypes);
+    types += foreignRelatedTypes(types, foreignTypes);
+    sortTypes(types);
+
+    QmlTypesCreator creator;
+    creator.setOwnTypes(std::move(types));
+    creator.setForeignTypes(std::move(foreignTypes));
+    creator.setModule(module);
+    creator.setMajorVersion(parser.value(majorVersionOption).toInt());
+
+    creator.generate(parser.value(pluginTypesOption), parser.value(dependenciesOption));
+    return EXIT_SUCCESS;
+}
diff --git a/tools/qmltyperegistrar/qmltyperegistrar.pro b/tools/qmltyperegistrar/qmltyperegistrar.pro
new file mode 100644
index 0000000000..802526d964
--- /dev/null
+++ b/tools/qmltyperegistrar/qmltyperegistrar.pro
@@ -0,0 +1,26 @@
+option(host_build)
+
+QT       = core-private
+DEFINES += QT_NO_CAST_TO_ASCII QT_NO_CAST_FROM_ASCII
+
+QMAKE_TARGET_DESCRIPTION = QML Types Registrar
+
+INCLUDEPATH += ../shared
+
+SOURCES += \
+    qmltyperegistrar.cpp \
+    ../shared/qmlstreamwriter.cpp \
+    qmltypesclassdescription.cpp \
+    qmltypescreator.cpp
+
+HEADERS += \
+    ../shared/qmlstreamwriter.h \
+    qmltypesclassdescription.h \
+    qmltypescreator.h
+
+build_integration.files = qmltypes.prf
+build_integration.path = $$[QT_HOST_DATA]/mkspecs/features
+prefix_build: INSTALLS += build_integration
+else: COPIES += build_integration
+
+load(qt_tool)
diff --git a/tools/qmltyperegistrar/qmltypes.prf b/tools/qmltyperegistrar/qmltypes.prf
new file mode 100644
index 0000000000..495cc1b0cd
--- /dev/null
+++ b/tools/qmltyperegistrar/qmltypes.prf
@@ -0,0 +1,66 @@
+CONFIG += metatypes
+
+qtPrepareTool(QML_TYPEREGISTRAR, qmltyperegistrar)
+
+# from moc.prf
+isEmpty(QML_IMPORT_MAJOR_VERSION):!isEmpty(IMPORT_VERSION): \
+    QML_IMPORT_MAJOR_VERSION = $$section(IMPORT_VERSION, ., 0, 0)
+isEmpty(QML_IMPORT_NAME):!isEmpty(TARGETPATH) {
+    QML_IMPORT_NAME = $$replace(TARGETPATH, "/", ".")
+    QML_IMPORT_NAME = $$replace(QML_IMPORT_NAME, .$${QML_IMPORT_MAJOR_VERSION}$, '')
+}
+
+isEmpty(QMLTYPES_FILENAME) {
+    plugin: QMLTYPES_FILENAME = $$OUT_PWD/plugins.qmltypes
+    else: QMLTYPES_FILENAME = $$OUT_PWD/$${TEMPLATE}.qmltypes
+}
+
+qt_module_deps = $$replace(QT, -private$, '')
+qt_module_deps += $$replace(QT_PRIVATE, -private$, '')
+qt_module_deps = $$replace(qt_module_deps, _private$, '')
+all_qt_module_deps = $$resolve_depends(qt_module_deps, "QT.", ".depends" ".run_depends")
+foreign_types =
+for(dep, all_qt_module_deps): \
+    foreign_types += $$[QT_INSTALL_LIBS]/metatypes/$$lower($$eval(QT.$${dep}.module))_metatypes.json
+
+QML_TYPEREGISTRAR_FLAGS = \
+    --generate-plugintypes=$$QMLTYPES_FILENAME \
+    --import-name=$$QML_IMPORT_NAME \
+    --major-version=$$QML_IMPORT_MAJOR_VERSION \
+    --foreign-types=$$join(foreign_types, ',')
+
+DEPENDENCIESFILE = $$_PRO_FILE_PWD_/dependencies.json
+exists($$DEPENDENCIESFILE): QML_TYPEREGISTRAR_FLAGS += --dependencies=$$DEPENDENCIESFILE
+
+!isEmpty(MODULE_PRIVATE_INCLUDES): QML_TYPEREGISTRAR_FLAGS += --private-includes
+
+METATYPES_JSON = $$lower($$basename(TARGET))_metatypes.json
+
+TYPEREGISTRATIONS = $$lower($$basename(TARGET))_qmltyperegistrations$${first(QMAKE_EXT_CPP)}
+
+qmltyperegistrar_compiler.CONFIG += combine
+qmltyperegistrar_compiler.commands = \
+    $$QML_TYPEREGISTRAR $$QML_TYPEREGISTRAR_FLAGS -o ${QMAKE_FILE_OUT} ${QMAKE_FILE_IN}
+qmltyperegistrar_compiler.input = METATYPES_JSON
+qmltyperegistrar_compiler.output = $$TYPEREGISTRATIONS
+qmltyperegistrar_compiler.variable_out = SOURCES
+qmltyperegistrar_compiler.name = Automatic QML type registration
+qmltyperegistrar_compiler.dependency_type = TYPE_C
+
+qmltyperegistrar_qmltypes.input = METATYPES_JSON
+qmltyperegistrar_qmltypes.depends = $$TYPEREGISTRATIONS
+qmltyperegistrar_qmltypes.output = $$QMLTYPES_FILENAME
+qmltyperegistrar_qmltypes.CONFIG = no_link
+qmltyperegistrar_qmltypes.commands = $$escape_expand(\\n)  # force creation of rule
+
+install_qmltypes {
+    isEmpty(QMLTYPES_INSTALL_DIR): \
+        QMLTYPES_INSTALL_DIR = $$[QT_INSTALL_QML]/$$TARGETPATH
+    do_install.files = $$QMLTYPES_FILENAME
+    do_install.path = $$QMLTYPES_INSTALL_DIR
+    do_install.CONFIG += no_link
+    prefix_build: INSTALLS += do_install
+    else: COPIES += do_install
+}
+
+QMAKE_EXTRA_COMPILERS += qmltyperegistrar_compiler qmltyperegistrar_qmltypes
diff --git a/tools/qmltyperegistrar/qmltypesclassdescription.cpp b/tools/qmltyperegistrar/qmltypesclassdescription.cpp
new file mode 100644
index 0000000000..8189bcd52e
--- /dev/null
+++ b/tools/qmltyperegistrar/qmltypesclassdescription.cpp
@@ -0,0 +1,161 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmltypesclassdescription.h"
+
+#include <QtCore/qjsonarray.h>
+
+static void collectExtraVersions(const QJsonObject *component, const QString &key,
+                                 QList<int> &extraVersions)
+{
+    const QJsonArray &items = component->value(key).toArray();
+    for (const QJsonValue &item : items) {
+        const QJsonObject obj = item.toObject();
+        const auto revision = obj.find(QLatin1String("revision"));
+        if (revision != obj.end()) {
+            const int extraVersion = revision.value().toInt();
+            if (!extraVersions.contains(extraVersion))
+                extraVersions.append(extraVersion);
+        }
+    }
+}
+
+const QJsonObject *QmlTypesClassDescription::findType(const QVector<QJsonObject> &types,
+                                                      const QString &name)
+{
+    static const QLatin1String qualifiedClassNameKey("qualifiedClassName");
+    auto it = std::lower_bound(types.begin(), types.end(), name,
+                               [&](const QJsonObject &type, const QString &typeName) {
+        return type.value(qualifiedClassNameKey).toString() < typeName;
+    });
+
+    return (it != types.end() && it->value(qualifiedClassNameKey) == name) ? &(*it) : nullptr;
+}
+
+void QmlTypesClassDescription::collect(const QJsonObject *classDef,
+                                           const QVector<QJsonObject> &types,
+                                           const QVector<QJsonObject> &foreign,
+                                           bool topLevel)
+{
+    const auto classInfos = classDef->value(QLatin1String("classInfos")).toArray();
+    for (const QJsonValue &classInfo : classInfos) {
+        const QJsonObject obj = classInfo.toObject();
+        const QString name = obj[QLatin1String("name")].toString();
+        const QString value = obj[QLatin1String("value")].toString();
+
+        if (name == QLatin1String("DefaultProperty")) {
+            if (defaultProp.isEmpty())
+                defaultProp = value;
+        } else if (name == QLatin1String("QML.AddedInMinorVersion")) {
+            if (topLevel) {
+                addedInRevision = value.toInt();
+                revisions.append(value.toInt());
+            } else if (!elementName.isEmpty()) {
+                revisions.append(value.toInt());
+            }
+        }
+
+        if (!topLevel)
+            continue;
+
+        // These only apply to the original class
+        if (name == QLatin1String("QML.Element")) {
+            if (value == QLatin1String("auto"))
+                elementName = classDef->value(QLatin1String("className")).toString();
+            else if (value != QLatin1String("anonymous"))
+                elementName = value;
+        } else if (name == QLatin1String("QML.RemovedInMinorVersion")) {
+            removedInRevision = value.toInt();
+        } else if (name == QLatin1String("QML.Creatable")) {
+            isCreatable = (value != QLatin1String("false"));
+        } else if (name == QLatin1String("QML.Attached")) {
+            attachedType = value;
+            if (const QJsonObject *other = findType(types, attachedType))
+                collect(other, types, foreign, false);
+            else if (const QJsonObject *other = findType(foreign, attachedType))
+                collect(other, types, foreign, false);
+        } else if (name == QLatin1String("QML.Singleton")) {
+            if (value == QLatin1String("true"))
+                isSingleton = true;
+        } else if (name == QLatin1String("QML.Foreign")) {
+            if (const QJsonObject *other = findType(foreign, value)) {
+                classDef = other;
+                if (defaultProp.isEmpty()) {
+                    // Foreign type can have a default property
+                    const auto classInfos = classDef->value(QLatin1String("classInfos")).toArray();
+                    for (const QJsonValue &classInfo : classInfos) {
+                        QJsonObject obj = classInfo.toObject();
+                        if (obj[QLatin1String("name")].toString() == QLatin1String("DefaultProperty")) {
+                            defaultProp = obj[QLatin1String("value")].toString();
+                            break;
+                        }
+                    }
+                }
+            }
+        } else if (name == QLatin1String("QML.Root")) {
+            isRootClass = true;
+            isBuiltin = true;
+        } else if (name == QLatin1String("QML.Builtin")) {
+            isBuiltin = true;
+        }
+    }
+
+    if (!elementName.isEmpty()) {
+        collectExtraVersions(classDef, QString::fromLatin1("properties"), revisions);
+        collectExtraVersions(classDef, QString::fromLatin1("slots"), revisions);
+        collectExtraVersions(classDef, QString::fromLatin1("methods"), revisions);
+        collectExtraVersions(classDef, QString::fromLatin1("signals"), revisions);
+    }
+
+    const auto supers = classDef->value(QLatin1String("superClasses")).toArray();
+    if (!supers.isEmpty()) {
+        const QJsonObject superObject = supers.first().toObject();
+        if (superObject[QLatin1String("access")].toString() == QLatin1String("public")) {
+            const QString superName = superObject[QLatin1String("name")].toString();
+            if (topLevel && superClass.isEmpty())
+                superClass = superName;
+
+            if (const QJsonObject *other = findType(types, superName))
+                collect(other, types, foreign, false);
+            else if (const QJsonObject *other = findType(foreign, superName))
+                collect(other, types, foreign, false);
+        }
+    }
+
+    if (addedInRevision == -1) {
+        revisions.append(0);
+        addedInRevision = 0;
+    }
+
+    std::sort(revisions.begin(), revisions.end(),
+              [](int a, int b) { return QByteArray::number(a) < QByteArray::number(b); });
+    const auto end = std::unique(revisions.begin(), revisions.end());
+    revisions.erase(end, revisions.end());
+
+    resolvedClass = classDef;
+}
diff --git a/tools/qmltyperegistrar/qmltypesclassdescription.h b/tools/qmltyperegistrar/qmltypesclassdescription.h
new file mode 100644
index 0000000000..8f3a6ea124
--- /dev/null
+++ b/tools/qmltyperegistrar/qmltypesclassdescription.h
@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMLTYPESCLASSDESCRIPTION_H
+#define QMLTYPESCLASSDESCRIPTION_H
+
+#include <QtCore/qstring.h>
+#include <QtCore/qjsonobject.h>
+#include <QtCore/qvector.h>
+#include <QtCore/qset.h>
+
+struct QmlTypesClassDescription
+{
+    const QJsonObject *resolvedClass = nullptr;
+    QString elementName;
+    QString defaultProp;
+    QString superClass;
+    QString attachedType;
+    QList<int> revisions;
+    int addedInRevision = -1;
+    int removedInRevision = -1;
+    bool isCreatable = true;
+    bool isSingleton = false;
+    bool isRootClass = false;
+    bool isBuiltin = false;
+
+    void collect(const QJsonObject *classDef, const QVector<QJsonObject> &types,
+                 const QVector<QJsonObject> &foreign, bool topLevel);
+
+    static const QJsonObject *findType(const QVector<QJsonObject> &types, const QString &name);
+};
+
+#endif // QMLTYPESCLASSDESCRIPTION_H
diff --git a/tools/qmltyperegistrar/qmltypescreator.cpp b/tools/qmltyperegistrar/qmltypescreator.cpp
new file mode 100644
index 0000000000..7bac6a87d8
--- /dev/null
+++ b/tools/qmltyperegistrar/qmltypescreator.cpp
@@ -0,0 +1,357 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmltypescreator.h"
+#include "qmlstreamwriter.h"
+#include "qmltypesclassdescription.h"
+
+#include <QtCore/qset.h>
+#include <QtCore/qjsonarray.h>
+#include <QtCore/qsavefile.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qjsondocument.h>
+
+static QString enquote(const QString &string)
+{
+    QString s = string;
+    return QString::fromLatin1("\"%1\"").arg(s.replace(QLatin1Char('\\'), QLatin1String("\\\\"))
+                                         .replace(QLatin1Char('"'),QLatin1String("\\\"")));
+}
+
+void QmlTypesCreator::writeClassProperties(const QmlTypesClassDescription &collector)
+{
+    m_qml.writeScriptBinding(
+                QLatin1String("name"),
+                enquote(collector.resolvedClass->value(
+                            QLatin1String("qualifiedClassName")).toString()));
+
+    if (!collector.defaultProp.isEmpty())
+        m_qml.writeScriptBinding(QLatin1String("defaultProperty"), enquote(collector.defaultProp));
+
+    if (!collector.superClass.isEmpty())
+        m_qml.writeScriptBinding(QLatin1String("prototype"), enquote(collector.superClass));
+
+    if (collector.elementName.isEmpty())
+        return;
+
+    QStringList exports;
+    QStringList metaObjects;
+
+    for (auto it = collector.revisions.begin(), end = collector.revisions.end(); it != end; ++it) {
+        const int revision = *it;
+        if (revision < collector.addedInRevision)
+            continue;
+        if (collector.removedInRevision > collector.addedInRevision
+                && revision >= collector.removedInRevision) {
+            break;
+        }
+
+        if (collector.isBuiltin) {
+            exports.append(enquote(QString::fromLatin1("QML/%1 1.0").arg(collector.elementName)));
+            metaObjects.append(QLatin1String("0"));
+        }
+
+        exports.append(enquote(QString::fromLatin1("%1/%2 %3.%4")
+                                           .arg(m_module).arg(collector.elementName)
+                                           .arg(m_majorVersion).arg(revision)));
+        metaObjects.append(QString::number(revision));
+    }
+
+    m_qml.writeArrayBinding(QLatin1String("exports"), exports);
+
+    if (!collector.isCreatable || collector.isSingleton)
+        m_qml.writeScriptBinding(QLatin1String("isCreatable"), QLatin1String("false"));
+
+    if (collector.isSingleton)
+        m_qml.writeScriptBinding(QLatin1String("isSingleton"), QLatin1String("true"));
+
+    m_qml.writeArrayBinding(QLatin1String("exportMetaObjectRevisions"), metaObjects);
+
+    if (!collector.attachedType.isEmpty())
+        m_qml.writeScriptBinding(QLatin1String("attachedType"), enquote(collector.attachedType));
+}
+
+void QmlTypesCreator::writeType(const QJsonObject &property, const QString &key, bool isReadonly,
+                                bool parsePointer)
+{
+    auto it = property.find(key);
+    if (it == property.end())
+        return;
+
+    QString type = (*it).toString();
+    if (type.isEmpty() || type == QLatin1String("void"))
+        return;
+
+    const QLatin1String typeKey("type");
+
+    bool isList = false;
+    bool isPointer = false;
+
+    if (type == QLatin1String("QString")) {
+        type = QLatin1String("string");
+    } else if (type == QLatin1String("qreal")) {
+        type = QLatin1String("double");
+    } else if (type == QLatin1String("qint32")) {
+        type = QLatin1String("int");
+    } else if (type == QLatin1String("quint32")) {
+        type = QLatin1String("uint");
+    } else if (type == QLatin1String("qint64")) {
+        type = QLatin1String("qlonglong");
+    } else if (type == QLatin1String("quint64")) {
+        type = QLatin1String("qulonglong");
+    } else {
+
+        const QLatin1String listProperty("QQmlListProperty<");
+        if (type.startsWith(listProperty)) {
+            isList = true;
+            const int listPropertySize = listProperty.size();
+            type = type.mid(listPropertySize, type.size() - listPropertySize - 1);
+        }
+
+        if (parsePointer && type.endsWith(QLatin1Char('*'))) {
+            isPointer = true;
+            type = type.left(type.size() - 1);
+        }
+    }
+
+    m_qml.writeScriptBinding(typeKey, enquote(type));
+    const QLatin1String trueString("true");
+    if (isList)
+        m_qml.writeScriptBinding(QLatin1String("isList"), trueString);
+    if (isReadonly)
+        m_qml.writeScriptBinding(QLatin1String("isReadonly"), trueString);
+    if (isPointer)
+        m_qml.writeScriptBinding(QLatin1String("isPointer"), trueString);
+}
+
+void QmlTypesCreator::writeProperties(const QJsonArray &properties, QSet<QString> &notifySignals)
+{
+    for (const QJsonValue &property : properties) {
+        const QJsonObject obj = property.toObject();
+        const QString name = obj[QLatin1String("name")].toString();
+        m_qml.writeStartObject(QLatin1String("Property"));
+        m_qml.writeScriptBinding(QLatin1String("name"), enquote(name));
+        const auto it = obj.find(QLatin1String("revision"));
+        if (it != obj.end())
+            m_qml.writeScriptBinding(QLatin1String("revision"), QString::number(it.value().toInt()));
+        writeType(obj, QLatin1String("type"), !obj.contains(QLatin1String("write")), true);
+        m_qml.writeEndObject();
+
+        const QString notify = obj[QLatin1String("notify")].toString();
+        if (notify == name + QLatin1String("Changed"))
+            notifySignals.insert(notify);
+    }
+}
+
+void QmlTypesCreator::writeMethods(const QJsonArray &methods, const QString &type,
+                                   const QSet<QString> &notifySignals)
+{
+    for (const QJsonValue &method : methods) {
+        const QJsonObject obj = method.toObject();
+        if (obj[QLatin1String("access")].toString() != QLatin1String("public"))
+            continue;
+        const QString name = obj[QLatin1String("name")].toString();
+        const QJsonArray arguments = method[QLatin1String("arguments")].toArray();
+        const auto revision = obj.find(QLatin1String("revision"));
+        if (notifySignals.contains(name) && arguments.isEmpty() && revision == obj.end())
+            continue;
+        m_qml.writeStartObject(type);
+        m_qml.writeScriptBinding(QLatin1String("name"), enquote(name));
+        if (revision != obj.end())
+            m_qml.writeScriptBinding(QLatin1String("revision"), QString::number(revision.value().toInt()));
+        writeType(obj, QLatin1String("returnType"), false, false);
+        for (const QJsonValue &argument : arguments) {
+            const QJsonObject obj = argument.toObject();
+            m_qml.writeStartObject(QLatin1String("Parameter"));
+            const QString name = obj[QLatin1String("name")].toString();
+            if (!name.isEmpty())
+                m_qml.writeScriptBinding(QLatin1String("name"), enquote(name));
+            writeType(obj, QLatin1String("type"), false, true);
+            m_qml.writeEndObject();
+        }
+        m_qml.writeEndObject();
+    }
+}
+
+void QmlTypesCreator::writeEnums(const QJsonArray &enums)
+{
+    for (const auto &item : enums) {
+        const QJsonObject obj = item.toObject();
+        const QJsonArray values = obj.value(QLatin1String("values")).toArray();
+        QStringList valueList;
+
+        for (const QJsonValue &value : values)
+            valueList.append(enquote(value.toString()));
+
+        m_qml.writeStartObject(QLatin1String("Enum"));
+        m_qml.writeScriptBinding(QLatin1String("name"),
+                               enquote(obj.value(QLatin1String("name")).toString()));
+        m_qml.writeArrayBinding(QLatin1String("values"), valueList);
+        m_qml.writeEndObject();
+    }
+}
+
+void QmlTypesCreator::writeComponents()
+{
+    const QLatin1String nameKey("name");
+    const QLatin1String signalsKey("signals");
+    const QLatin1String enumsKey("enums");
+    const QLatin1String propertiesKey("properties");
+    const QLatin1String slotsKey("slots");
+    const QLatin1String methodsKey("methods");
+    const QLatin1String accessKey("access");
+    const QLatin1String typeKey("type");
+    const QLatin1String argumentsKey("arguments");
+
+    const QLatin1String destroyedName("destroyed");
+    const QLatin1String deleteLaterName("deleteLater");
+    const QLatin1String toStringName("toString");
+    const QLatin1String destroyName("destroy");
+    const QLatin1String delayName("delay");
+
+    const QLatin1String signalElement("Signal");
+    const QLatin1String componentElement("Component");
+    const QLatin1String methodElement("Method");
+
+    const QLatin1String publicAccess("public");
+    const QLatin1String intType("int");
+
+    for (const QJsonObject &component : m_ownTypes) {
+        m_qml.writeStartObject(componentElement);
+
+        QmlTypesClassDescription collector;
+        collector.collect(&component, m_ownTypes, m_foreignTypes, true);
+
+        writeClassProperties(collector);
+
+        const QJsonObject *classDef = collector.resolvedClass;
+        writeEnums(classDef->value(enumsKey).toArray());
+
+        QSet<QString> notifySignals;
+        writeProperties(classDef->value(propertiesKey).toArray(), notifySignals);
+
+        if (collector.isRootClass) {
+
+            // Hide destroyed() signals
+            QJsonArray componentSignals = classDef->value(signalsKey).toArray();
+            for (auto it = componentSignals.begin(); it != componentSignals.end();) {
+                if (it->toObject().value(nameKey).toString() == destroyedName)
+                    it = componentSignals.erase(it);
+                else
+                    ++it;
+            }
+            writeMethods(componentSignals, signalElement, notifySignals);
+
+            // Hide deleteLater() methods
+            QJsonArray componentMethods = classDef->value(methodsKey).toArray()
+                    + classDef->value(slotsKey).toArray();
+            for (auto it = componentMethods.begin(); it != componentMethods.end();) {
+                if (it->toObject().value(nameKey).toString() == deleteLaterName)
+                    it = componentMethods.erase(it);
+                else
+                    ++it;
+            }
+
+            // Add toString()
+            QJsonObject toStringMethod;
+            toStringMethod.insert(nameKey, toStringName);
+            toStringMethod.insert(accessKey, publicAccess);
+            componentMethods.append(toStringMethod);
+
+            // Add destroy()
+            QJsonObject destroyMethod;
+            destroyMethod.insert(nameKey, destroyName);
+            destroyMethod.insert(accessKey, publicAccess);
+            componentMethods.append(destroyMethod);
+
+            // Add destroy(int)
+            QJsonObject destroyMethodWithArgument;
+            destroyMethodWithArgument.insert(nameKey, destroyName);
+            destroyMethodWithArgument.insert(accessKey, publicAccess);
+            QJsonObject delayArgument;
+            delayArgument.insert(nameKey, delayName);
+            delayArgument.insert(typeKey, intType);
+            QJsonArray destroyArguments;
+            destroyArguments.append(delayArgument);
+            destroyMethodWithArgument.insert(argumentsKey, destroyArguments);
+            componentMethods.append(destroyMethodWithArgument);
+
+            writeMethods(componentMethods, methodElement);
+        } else {
+            writeMethods(classDef->value(signalsKey).toArray(), signalElement, notifySignals);
+            writeMethods(classDef->value(slotsKey).toArray(), methodElement);
+            writeMethods(classDef->value(methodsKey).toArray(), methodElement);
+        }
+        m_qml.writeEndObject();
+    }
+}
+
+void QmlTypesCreator::generate(const QString &outFileName, const QString &dependenciesFileName)
+{
+    m_qml.writeStartDocument();
+    m_qml.writeLibraryImport(QLatin1String("QtQuick.tooling"), 1, 2);
+    m_qml.write(QString::fromLatin1(
+            "\n// This file describes the plugin-supplied types contained in the library."
+            "\n// It is used for QML tooling purposes only."
+            "\n//"
+            "\n// This file was auto-generated by qmltyperegistrar.\n\n"));
+    m_qml.writeStartObject(QLatin1String("Module"));
+
+    QStringList dependencies;
+    if (!dependenciesFileName.isEmpty()) {
+        QFile file(dependenciesFileName);
+        if (!file.open(QIODevice::ReadOnly)) {
+            fprintf(stderr, "Failed to open %s\n", qPrintable(dependenciesFileName));
+        } else {
+            QJsonParseError error { -1, QJsonParseError::NoError };
+            QJsonDocument doc = QJsonDocument::fromJson(file.readAll(), &error);
+            if (error.error != QJsonParseError::NoError) {
+                fprintf(stderr, "Failed to parse %s\n", qPrintable(dependenciesFileName));
+            } else {
+                const QJsonArray array = doc.array();
+                for (const QJsonValue &value : array)
+                    dependencies.append(enquote(value.toString()));
+            }
+        }
+    } else {
+        // Default dependency is QtQuick 2.0
+        dependencies.append(enquote(QLatin1String("QtQuick 2.0")));
+    }
+
+    m_qml.writeArrayBinding(QLatin1String("dependencies"), dependencies);
+
+    writeComponents();
+
+    m_qml.writeEndObject();
+
+    QSaveFile file(outFileName);
+    file.open(QIODevice::WriteOnly);
+    file.write(m_output);
+    file.commit();
+}
+
diff --git a/tools/qmltyperegistrar/qmltypescreator.h b/tools/qmltyperegistrar/qmltypescreator.h
new file mode 100644
index 0000000000..9207a64b7e
--- /dev/null
+++ b/tools/qmltyperegistrar/qmltypescreator.h
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMLTYPESCREATOR_H
+#define QMLTYPESCREATOR_H
+
+#include "qmlstreamwriter.h"
+#include "qmltypesclassdescription.h"
+
+#include <QtCore/qstring.h>
+#include <QtCore/qset.h>
+
+class QmlTypesCreator
+{
+public:
+    QmlTypesCreator() : m_qml(&m_output) {}
+
+    void generate(const QString &outFileName, const QString &dependenciesFileName);
+
+    void setOwnTypes(QVector<QJsonObject> ownTypes) { m_ownTypes = std::move(ownTypes); }
+    void setForeignTypes(QVector<QJsonObject> foreignTypes) { m_foreignTypes = std::move(foreignTypes); }
+    void setModule(QString module) { m_module = std::move(module); }
+    void setMajorVersion(int majorVersion) { m_majorVersion = majorVersion; }
+
+private:
+    void writeClassProperties(const QmlTypesClassDescription &collector);
+    void writeType(const QJsonObject &property, const QString &key, bool isReadonly,
+                   bool parsePointer);
+    void writeProperties(const QJsonArray &properties, QSet<QString> &notifySignals);
+    void writeMethods(const QJsonArray &methods, const QString &type,
+                      const QSet<QString> &notifySignals = QSet<QString>());
+    void writeEnums(const QJsonArray &enums);
+    void writeComponents();
+
+    QByteArray m_output;
+    QmlStreamWriter m_qml;
+    QVector<QJsonObject> m_ownTypes;
+    QVector<QJsonObject> m_foreignTypes;
+    QString m_module;
+    int m_majorVersion = 0;
+};
+
+#endif // QMLTYPESCREATOR_H
diff --git a/tools/qmlplugindump/qmlstreamwriter.cpp b/tools/shared/qmlstreamwriter.cpp
index b0fbc4e443..b0fbc4e443 100644
--- a/tools/qmlplugindump/qmlstreamwriter.cpp
+++ b/tools/shared/qmlstreamwriter.cpp
diff --git a/tools/qmlplugindump/qmlstreamwriter.h b/tools/shared/qmlstreamwriter.h
index cb642159ea..cb642159ea 100644
--- a/tools/qmlplugindump/qmlstreamwriter.h
+++ b/tools/shared/qmlstreamwriter.h
diff --git a/tools/tools.pro b/tools/tools.pro
index 25ed760903..69b79e8816 100644
--- a/tools/tools.pro
+++ b/tools/tools.pro
@@ -10,6 +10,8 @@ qtConfig(qml-devtools) {
     qtConfig(commandlineparser):qtConfig(xmlstreamwriter): SUBDIRS += qmlcachegen
 }
 
+qtConfig(commandlineparser): SUBDIRS += qmltyperegistrar
+
 qtConfig(thread):!android|android_app:!wasm:!rtems {
     SUBDIRS += \
         qml