Specify parameters of type registration in class declarations

Using this technique we can automatically register all necessary
revisions and minor versions of a type, using the metaobject system.
This greatly reduces the potential for mistakes and resulting
incompatibilities between versions of imports.

We assume that for each type we need to register all revisions of its
super types and its attached type, and that the revisions match. That
is, if you import version X of type A, you will also get version X of
its attached type and of any super types. As we previously didn't take
these dependencies into account when manually registering the types, a
number of extra revisions are now registered for some types.

Potentially, we can now generate the qmltypes files at compile time,
using moc.

Change-Id: I7abb8a5c39f5e63ad1a0cb41a783f2c91909491b
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

12 files changed, 676 insertions, 90 deletions

diff --git a/src/qml/qml/qqml.cpp b/src/qml/qml/qqml.cpp
index 8a50b51b5d..a3ca48d6d9 100644
--- a/src/qml/qml/qqml.cpp
+++ b/src/qml/qml/qqml.cpp
@@ -96,33 +96,188 @@ QObject *QQmlPrivate::RegisterSingletonFunctor::operator()(QQmlEngine *qeng, QJS
     return m_object;
 };
 
+static QVector<int> availableRevisions(const QMetaObject *metaObject)
+{
+    QVector<int> revisions;
+    if (!metaObject)
+        return revisions;
+    const int propertyOffset = metaObject->propertyOffset();
+    const int propertyCount = metaObject->propertyCount();
+    for (int propertyIndex = propertyOffset, propertyEnd = propertyOffset + propertyCount;
+         propertyIndex < propertyEnd; ++propertyIndex) {
+        const QMetaProperty property = metaObject->property(propertyIndex);
+        if (int revision = property.revision())
+            revisions.append(revision);
+    }
+    const int methodOffset = metaObject->methodOffset();
+    const int methodCount = metaObject->methodCount();
+    for (int methodIndex = methodOffset, methodEnd = methodOffset + methodCount;
+         methodIndex < methodEnd; ++methodIndex) {
+        const QMetaMethod method = metaObject->method(methodIndex);
+        if (int revision = method.revision())
+            revisions.append(revision);
+    }
+
+    // Need to also check parent meta objects, as their revisions are inherited.
+    if (const QMetaObject *superMeta = metaObject->superClass())
+        revisions += availableRevisions(superMeta);
+
+    return revisions;
+}
+
 /*
 This method is "over generalized" to allow us to (potentially) register more types of things in
 the future without adding exported symbols.
 */
 int QQmlPrivate::qmlregister(RegistrationType type, void *data)
 {
-    if (type == AutoParentRegistration) {
+    QQmlType dtype;
+    switch (type) {
+    case AutoParentRegistration:
         return QQmlMetaType::registerAutoParentFunction(
                 *reinterpret_cast<RegisterAutoParent *>(data));
-    } else if (type == QmlUnitCacheHookRegistration) {
+    case QmlUnitCacheHookRegistration:
         return QQmlMetaType::registerUnitCacheHook(
                 *reinterpret_cast<RegisterQmlUnitCacheHook *>(data));
+    case TypeAndRevisionsRegistration: {
+        const RegisterTypeAndRevisions &type = *reinterpret_cast<RegisterTypeAndRevisions *>(data);
+        const char *elementName = classElementName(type.classInfoMetaObject);
+        const bool creatable = (elementName != nullptr)
+                && boolClassInfo(type.classInfoMetaObject, "QML.Creatable", true);
+
+        const QString noCreateReason = creatable
+                ? QString()
+                : QString::fromUtf8(classInfo(type.classInfoMetaObject, "QML.UncreatableReason"));
+        RegisterType revisionRegistration = {
+            1,
+            type.typeId,
+            type.listId,
+            creatable ? type.objectSize : 0,
+            nullptr,
+            noCreateReason,
+            type.uri,
+            type.versionMajor,
+            -1,
+            nullptr,
+            type.metaObject,
+            type.attachedPropertiesFunction,
+            type.attachedPropertiesMetaObject,
+            type.parserStatusCast,
+            type.valueSourceCast,
+            type.valueInterceptorCast,
+            type.extensionObjectCreate,
+            type.extensionMetaObject,
+            nullptr,
+            -1
+        };
+
+        const int added = intClassInfo(type.classInfoMetaObject, "QML.AddedInMinorVersion", 0);
+        const int removed = intClassInfo(type.classInfoMetaObject, "QML.RemovedInMinorVersion", -1);
+
+        auto revisions = availableRevisions(type.metaObject);
+        revisions.append(qMax(added, 0));
+        if (type.attachedPropertiesMetaObject)
+            revisions += availableRevisions(type.attachedPropertiesMetaObject);
+
+        std::sort(revisions.begin(), revisions.end());
+        const auto it = std::unique(revisions.begin(), revisions.end());
+        revisions.erase(it, revisions.end());
+
+        const bool typeWasRemoved = removed >= added;
+        for (int revision : revisions) {
+            if (revision < added)
+                continue;
+
+            // When removed, we still add revisions, but anonymous ones
+            if (typeWasRemoved && revision >= removed) {
+                revisionRegistration.elementName = nullptr;
+                revisionRegistration.create = nullptr;
+            } else {
+                revisionRegistration.elementName = elementName;
+                revisionRegistration.create = creatable ? type.create : nullptr;
+            }
+
+            // Equivalent of qmlRegisterRevision<T, revision>(...)
+            revisionRegistration.versionMinor = revision;
+            revisionRegistration.revision = revision;
+            revisionRegistration.customParser = type.customParserFactory();
+
+            qmlregister(TypeRegistration, &revisionRegistration);
+        }
+        break;
     }
+    case SingletonAndRevisionsRegistration: {
+        const RegisterSingletonTypeAndRevisions &type
+                = *reinterpret_cast<RegisterSingletonTypeAndRevisions *>(data);
+        const char *elementName = classElementName(type.classInfoMetaObject);
+        RegisterSingletonType revisionRegistration = {
+            QmlCurrentSingletonTypeRegistrationVersion,
+            type.uri,
+            type.versionMajor,
+            -1,
+            elementName,
 
-    QQmlType dtype;
-    if (type == TypeRegistration)
+            type.scriptApi,
+            nullptr,
+            type.instanceMetaObject,
+            type.typeId,
+            -1,
+
+            type.generalizedQobjectApi
+        };
+
+        const int added = intClassInfo(type.classInfoMetaObject, "QML.AddedInMinorVersion", 0);
+        const int removed = intClassInfo(type.classInfoMetaObject, "QML.RemovedInMinorVersion", -1);
+
+        auto revisions = availableRevisions(type.instanceMetaObject);
+        revisions.append(qMax(added, 0));
+
+        std::sort(revisions.begin(), revisions.end());
+        const auto it = std::unique(revisions.begin(), revisions.end());
+        revisions.erase(it, revisions.end());
+
+        const bool typeWasRemoved = removed >= added;
+        for (int revision : qAsConst(revisions)) {
+            if (revision < added)
+                continue;
+
+            // When removed, we still add revisions, but anonymous ones
+            if (typeWasRemoved && revision >= removed) {
+                revisionRegistration.typeName = nullptr;
+                revisionRegistration.scriptApi = nullptr;
+                revisionRegistration.generalizedQobjectApi = nullptr;
+            } else {
+                revisionRegistration.typeName = elementName;
+                revisionRegistration.scriptApi = type.scriptApi;
+                revisionRegistration.generalizedQobjectApi = type.generalizedQobjectApi;
+            }
+
+            // Equivalent of qmlRegisterRevision<T, revision>(...)
+            revisionRegistration.versionMinor = revision;
+            revisionRegistration.revision = revision;
+
+            qmlregister(SingletonRegistration, &revisionRegistration);
+        }
+        break;
+    }
+    case TypeRegistration:
         dtype = QQmlMetaType::registerType(*reinterpret_cast<RegisterType *>(data));
-    else if (type == InterfaceRegistration)
+        break;
+    case InterfaceRegistration:
         dtype = QQmlMetaType::registerInterface(*reinterpret_cast<RegisterInterface *>(data));
-    else if (type == SingletonRegistration)
+        break;
+    case SingletonRegistration:
         dtype = QQmlMetaType::registerSingletonType(*reinterpret_cast<RegisterSingletonType *>(data));
-    else if (type == CompositeRegistration)
+        break;
+    case CompositeRegistration:
         dtype = QQmlMetaType::registerCompositeType(*reinterpret_cast<RegisterCompositeType *>(data));
-    else if (type == CompositeSingletonRegistration)
+        break;
+    case CompositeSingletonRegistration:
         dtype = QQmlMetaType::registerCompositeSingletonType(*reinterpret_cast<RegisterCompositeSingletonType *>(data));
-    else
+        break;
+    default:
         return -1;
+    }
 
     if (!dtype.isValid())
         return -1;
@@ -148,6 +303,14 @@ void QQmlPrivate::qmlunregister(RegistrationType type, quintptr data)
     case CompositeSingletonRegistration:
         QQmlMetaType::unregisterType(data);
         break;
+    case TypeAndRevisionsRegistration:
+    case SingletonAndRevisionsRegistration:
+        // Currently unnecessary. We'd need a special data structure to hold
+        // URI + majorVersion and then we'd iterate the minor versions, look up the
+        // associated QQmlType objects by uri/elementName/major/minor and qmlunregister
+        // each of them.
+        Q_UNREACHABLE();
+        break;
     }
 }
 
diff --git a/src/qml/qml/qqml.h b/src/qml/qml/qqml.h
index 6295345fa4..effa05180d 100644
--- a/src/qml/qml/qqml.h
+++ b/src/qml/qml/qqml.h
@@ -41,9 +41,6 @@
 #define QQML_H
 
 #include <QtQml/qqmlprivate.h>
-#include <QtQml/qqmlparserstatus.h>
-#include <QtQml/qqmlpropertyvaluesource.h>
-#include <QtQml/qqmllist.h>
 
 #include <QtCore/qbytearray.h>
 #include <QtCore/qmetaobject.h>
@@ -51,6 +48,12 @@
 #define QML_VERSION     0x020000
 #define QML_VERSION_STR "2.0"
 
+#define QML_PRIVATE_NAMESPACE \
+    QT_PREPEND_NAMESPACE(QQmlPrivate)
+
+#define QML_REGISTER_TYPES_AND_REVISIONS \
+    QT_PREPEND_NAMESPACE(qmlRegisterTypesAndRevisions)
+
 #define QML_DECLARE_TYPE(TYPE) \
     Q_DECLARE_METATYPE(TYPE *) \
     Q_DECLARE_METATYPE(QQmlListProperty<TYPE>)
@@ -64,6 +67,52 @@
 #define QML_DECLARE_INTERFACE_HASMETATYPE(INTERFACE) \
     QML_DECLARE_TYPE_HASMETATYPE(INTERFACE)
 
+#define QML_ELEMENT \
+    Q_CLASSINFO("QML.Element", "auto")
+
+#define QML_ANONYMOUS \
+    Q_CLASSINFO("QML.Element", "anonymous")
+
+#define QML_NAMED_ELEMENT(NAME) \
+    Q_CLASSINFO("QML.Element", #NAME)
+
+#define QML_UNCREATABLE(REASON) \
+    Q_CLASSINFO("QML.Creatable", "false") \
+    Q_CLASSINFO("QML.UncreatableReason", REASON)
+
+#define QML_SINGLETON \
+    Q_CLASSINFO("QML.Singleton", "true") \
+    enum class QmlIsSingleton {yes = true}; \
+    template<typename, typename> friend struct QML_PRIVATE_NAMESPACE::QmlSingleton; \
+    template<typename T, typename... Args> \
+    friend void QML_REGISTER_TYPES_AND_REVISIONS(const char *uri, int versionMajor);
+
+#define QML_ADDED_IN_MINOR_VERSION(VERSION) \
+    Q_CLASSINFO("QML.AddedInMinorVersion", #VERSION)
+
+#define QML_REMOVED_IN_MINOR_VERSION(VERSION) \
+    Q_CLASSINFO("QML.RemovedInMinorVersion", #VERSION)
+
+#define QML_ATTACHED(ATTACHED_TYPE) \
+    Q_CLASSINFO("QML.Attached", #ATTACHED_TYPE) \
+    using QmlAttachedType = ATTACHED_TYPE; \
+    template<class, class, bool> friend struct QML_PRIVATE_NAMESPACE::QmlAttached; \
+    template<class> friend struct QML_PRIVATE_NAMESPACE::QmlAttachedAccessor;
+
+#define QML_EXTENDED(EXTENDED_TYPE) \
+    Q_CLASSINFO("QML.Extended", #EXTENDED_TYPE) \
+    using QmlExtendedType = EXTENDED_TYPE; \
+    template<class, class> friend struct QML_PRIVATE_NAMESPACE::QmlExtended; \
+    template<typename T, typename... Args> \
+    friend void QML_REGISTER_TYPES_AND_REVISIONS(const char *uri, int versionMajor);
+
+#define QML_FOREIGN(FOREIGN_TYPE) \
+    Q_CLASSINFO("QML.Foreign", #FOREIGN_TYPE) \
+    using QmlForeignType = FOREIGN_TYPE; \
+    template<class, class> friend struct QML_PRIVATE_NAMESPACE::QmlResolved; \
+    template<typename T, typename... Args> \
+    friend void QML_REGISTER_TYPES_AND_REVISIONS(const char *uri, int versionMajor);
+
 enum { /* TYPEINFO flags */
     QML_HAS_ATTACHED_PROPERTIES = 0x01
 };
@@ -82,25 +131,11 @@ QT_END_NAMESPACE
 
 QT_BEGIN_NAMESPACE
 
-
-class QQmlPropertyValueInterceptor;
-
-#define QML_GETTYPENAMES \
-    const char *className = T::staticMetaObject.className(); \
-    const int nameLen = int(strlen(className)); \
-    QVarLengthArray<char,48> pointerName(nameLen+2); \
-    memcpy(pointerName.data(), className, size_t(nameLen)); \
-    pointerName[nameLen] = '*'; \
-    pointerName[nameLen+1] = '\0'; \
-    const int listLen = int(strlen("QQmlListProperty<")); \
-    QVarLengthArray<char,64> listName(listLen + nameLen + 2); \
-    memcpy(listName.data(), "QQmlListProperty<", size_t(listLen)); \
-    memcpy(listName.data()+listLen, className, size_t(nameLen)); \
-    listName[listLen+nameLen] = '>'; \
-    listName[listLen+nameLen+1] = '\0';
-
 void Q_QML_EXPORT qmlClearTypeRegistrations();
 
+template<class T>
+QQmlCustomParser *qmlCreateCustomParser();
+
 template<typename T>
 int qmlRegisterAnonymousType(const char *uri, int versionMajor)
 {
@@ -720,6 +755,44 @@ inline int qmlRegisterType(const QUrl &url, const char *uri, int versionMajor, i
     return QQmlPrivate::qmlregister(QQmlPrivate::CompositeRegistration, &type);
 }
 
+template<class T, class Resolved, class Extended, bool Singleton>
+struct QmlTypeAndRevisionsRegistration;
+
+template<class T, class Resolved, class Extended>
+struct QmlTypeAndRevisionsRegistration<T, Resolved, Extended, false> {
+    static void registerTypeAndRevisions(const char *uri, int versionMajor)
+    {
+        QQmlPrivate::qmlRegisterTypeAndRevisions<Resolved, Extended>(
+                    uri, versionMajor, &T::staticMetaObject);
+    }
+};
+
+template<class T, class Resolved>
+struct QmlTypeAndRevisionsRegistration<T, Resolved, void, true> {
+    static void registerTypeAndRevisions(const char *uri, int versionMajor)
+    {
+        QQmlPrivate::qmlRegisterSingletonAndRevisions<Resolved>(
+                    uri, versionMajor, &T::staticMetaObject);
+    }
+};
+
+template<typename T = void, typename... Args>
+void qmlRegisterTypesAndRevisions(const char *uri, int versionMajor);
+
+template<typename T, typename... Args>
+void qmlRegisterTypesAndRevisions(const char *uri, int versionMajor)
+{
+    QmlTypeAndRevisionsRegistration<
+            T, typename QQmlPrivate::QmlResolved<T>::Type,
+            typename QQmlPrivate::QmlExtended<T>::Type,
+            QQmlPrivate::QmlSingleton<T>::Value>
+            ::registerTypeAndRevisions(uri, versionMajor);
+    qmlRegisterTypesAndRevisions<Args...>(uri, versionMajor);
+}
+
+template<>
+inline void qmlRegisterTypesAndRevisions<>(const char *, int) {}
+
 int Q_QML_EXPORT qmlTypeId(const char *uri, int versionMajor, int versionMinor, const char *qmlName);
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlcomponent.h b/src/qml/qml/qqmlcomponent.h
index f259c99b08..cb5d5a787c 100644
--- a/src/qml/qml/qqmlcomponent.h
+++ b/src/qml/qml/qqmlcomponent.h
@@ -70,6 +70,9 @@ class Q_QML_EXPORT QQmlComponent : public QObject
     Q_PROPERTY(qreal progress READ progress NOTIFY progressChanged)
     Q_PROPERTY(Status status READ status NOTIFY statusChanged)
     Q_PROPERTY(QUrl url READ url CONSTANT)
+    QML_NAMED_ELEMENT(Component)
+    QML_ATTACHED(QQmlComponentAttached)
+    Q_CLASSINFO("QML.Builtin", "QML")
 
 public:
     enum CompilationMode { PreferSynchronous, Asynchronous };
@@ -136,9 +139,29 @@ private:
     friend class QQmlObjectCreator;
 };
 
-QT_END_NAMESPACE
 
+// Don't do this at home.
+namespace QQmlPrivate {
+
+// Generally you cannot use QQmlComponentAttached as attached properties object in derived classes.
+// It is private.
+template<class T>
+struct OverridableAttachedType<T, QQmlComponentAttached>
+{
+    using Type = void;
+};
+
+// QQmlComponent itself is allowed to use QQmlComponentAttached, though.
+template<>
+struct OverridableAttachedType<QQmlComponent, QQmlComponentAttached>
+{
+    using Type = QQmlComponentAttached;
+};
+
+} // namespace QQmlPrivate
+
+
+QT_END_NAMESPACE
 QML_DECLARE_TYPE(QQmlComponent)
-QML_DECLARE_TYPEINFO(QQmlComponent, QML_HAS_ATTACHED_PROPERTIES)
 
 #endif // QQMLCOMPONENT_H
diff --git a/src/qml/qml/qqmlcomponentattached_p.h b/src/qml/qml/qqmlcomponentattached_p.h
index e3bca18857..8ecd9da17d 100644
--- a/src/qml/qml/qqmlcomponentattached_p.h
+++ b/src/qml/qml/qqmlcomponentattached_p.h
@@ -61,6 +61,11 @@ QT_BEGIN_NAMESPACE
 class Q_QML_PRIVATE_EXPORT QQmlComponentAttached : public QObject
 {
     Q_OBJECT
+
+    // Used as attached object for QQmlComponent. We want qqmlcomponentattached_p.h to be #include'd
+    // when registering QQmlComponent, but we cannot #include it from qqmlcomponent.h. Therefore we
+    // force an anonymous type registration here.
+    QML_ANONYMOUS
 public:
     QQmlComponentAttached(QObject *parent = nullptr);
     ~QQmlComponentAttached();
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index 0fd07ea209..af44d737a2 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -201,33 +201,26 @@ void QQmlEnginePrivate::defineModule()
 {
     const char uri[] = "QtQml";
 
-    qmlRegisterType<QQmlComponent>(uri, 2, 0, "Component");
-    qmlRegisterType<QObject>(uri, 2, 0, "QtObject");
-    qmlRegisterType<QQmlBind>(uri, 2, 0, "Binding");
-    qmlRegisterType<QQmlBind, 8>(uri, 2, 8, "Binding"); // Only available in >= 2.8
-    qmlRegisterType<QQmlBind, 14>(uri, 2, 14, "Binding");
-
-    // TODO: We won't need Connections to be a custom type anymore once we can drop the
-    //       automatic signal handler inference from undeclared properties.
-    qmlRegisterCustomType<QQmlConnections>(uri, 2, 0, "Connections", new QQmlConnectionsParser);
-    qmlRegisterCustomType<QQmlConnections, 3>(uri, 2, 3, "Connections", new QQmlConnectionsParser); // Only available in QtQml >= 2.3
-
+    qmlRegisterTypesAndRevisions<
+            QObjectForeign,
 #if QT_CONFIG(qml_animation)
-    qmlRegisterType<QQmlTimer>(uri, 2, 0, "Timer");
+            QQmlTimer,
 #endif
-
-    qmlRegisterType<QQmlLoggingCategory>(uri, 2, 8, "LoggingCategory"); // Only available in >= 2.8
-    qmlRegisterType<QQmlLoggingCategory, 12>(uri, 2, 12, "LoggingCategory"); // Only available in >= 2.12
-
 #if QT_CONFIG(qml_locale)
-    qmlRegisterUncreatableType<QQmlLocale>(uri, 2, 2, "Locale", QQmlEngine::tr("Locale cannot be instantiated. Use Qt.locale()"));
+            QQmlLocale,
 #endif
+            QQmlComponent,
+            QQmlBind,
+            QQmlConnections,
+            QQmlLoggingCategory
+    >(uri, 2);
 }
 
 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 void QQmlEnginePrivate::registerQuickTypes()
 {
     // Don't add anything here. These are only for backwards compatibility.
+    // Also, don't use qmlRegisterTypesAndRevisions as that will auto-add future revisions.
 
     const char uri[] = "QtQuick";
 
@@ -236,13 +229,17 @@ void QQmlEnginePrivate::registerQuickTypes()
     qmlRegisterType<QQmlBind>(uri, 2, 0, "Binding");
     qmlRegisterType<QQmlBind, 8>(uri, 2, 8, "Binding");
     qmlRegisterCustomType<QQmlConnections>(uri, 2, 0, "Connections", new QQmlConnectionsParser);
+
+    // Connections revision 3 was added in QtQml 2.3, but only in QtQuick 2.7.
     qmlRegisterCustomType<QQmlConnections, 3>(uri, 2, 7, "Connections", new QQmlConnectionsParser);
+
 #if QT_CONFIG(qml_animation)
     qmlRegisterType<QQmlTimer>(uri, 2, 0,"Timer");
 #endif
     qmlRegisterType<QQmlLoggingCategory>(uri, 2, 8, "LoggingCategory");
     qmlRegisterType<QQmlLoggingCategory, 12>(uri, 2, 12, "LoggingCategory");
 #if QT_CONFIG(qml_locale)
+    // Locale was added in QtQuick 2.0 and in QtQml 2.2
     qmlRegisterUncreatableType<QQmlLocale>(uri, 2, 0, "Locale", QQmlEngine::tr("Locale cannot be instantiated. Use Qt.locale()"));
 #endif
 }
diff --git a/src/qml/qml/qqmlengine_p.h b/src/qml/qml/qqmlengine_p.h
index 385ae02ce5..5b1b676c89 100644
--- a/src/qml/qml/qqmlengine_p.h
+++ b/src/qml/qml/qqmlengine_p.h
@@ -101,6 +101,13 @@ class QQmlProfiler;
 class QQmlPropertyCapture;
 class QQmlMetaObject;
 
+struct QObjectForeign {
+    Q_GADGET
+    QML_FOREIGN(QObject)
+    QML_NAMED_ELEMENT(QtObject)
+    Q_CLASSINFO("QML.Root", "QML")
+};
+
 // This needs to be declared here so that the pool for it can live in QQmlEnginePrivate.
 // The inline method definitions are in qqmljavascriptexpression_p.h
 class QQmlJavaScriptExpressionGuard : public QQmlNotifierEndpoint
diff --git a/src/qml/qml/qqmllocale_p.h b/src/qml/qml/qqmllocale_p.h
index 859c36e11b..10e0dfcc38 100644
--- a/src/qml/qml/qqmllocale_p.h
+++ b/src/qml/qml/qqmllocale_p.h
@@ -94,6 +94,9 @@ private:
 class Q_QML_PRIVATE_EXPORT QQmlLocale
 {
     Q_GADGET
+    QML_NAMED_ELEMENT(Locale)
+    QML_UNCREATABLE("Locale cannot be instantiated. Use Qt.locale().")
+    QML_ADDED_IN_MINOR_VERSION(2)
 
 public:
     ~QQmlLocale();
diff --git a/src/qml/qml/qqmlloggingcategory_p.h b/src/qml/qml/qqmlloggingcategory_p.h
index ee5d9af2e7..c7377528b4 100644
--- a/src/qml/qml/qqmlloggingcategory_p.h
+++ b/src/qml/qml/qqmlloggingcategory_p.h
@@ -56,6 +56,7 @@
 #include <QtCore/qloggingcategory.h>
 
 #include <QtQml/qqmlparserstatus.h>
+#include <QtQml/qqml.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -66,6 +67,8 @@ class QQmlLoggingCategory : public QObject, public QQmlParserStatus
 
     Q_PROPERTY(QString name READ name WRITE setName)
     Q_PROPERTY(DefaultLogLevel defaultLogLevel READ defaultLogLevel WRITE setDefaultLogLevel REVISION 12)
+    QML_NAMED_ELEMENT(LoggingCategory)
+    QML_ADDED_IN_MINOR_VERSION(8)
 
 public:
     enum DefaultLogLevel {
diff --git a/src/qml/qml/qqmlmetatype.cpp b/src/qml/qml/qqmlmetatype.cpp
index c2674b402a..268d58a856 100644
--- a/src/qml/qml/qqmlmetatype.cpp
+++ b/src/qml/qml/qqmlmetatype.cpp
@@ -154,7 +154,7 @@ static QQmlTypePrivate *createQQmlType(QQmlMetaTypeData *data, const QString &el
     d->extraData.cd->propertyValueSourceCast = type.valueSourceCast;
     d->extraData.cd->propertyValueInterceptorCast = type.valueInterceptorCast;
     d->extraData.cd->extFunc = type.extensionObjectCreate;
-    d->extraData.cd->customParser = type.customParser;
+    d->extraData.cd->customParser = reinterpret_cast<QQmlCustomParser *>(type.customParser);
     d->extraData.cd->registerEnumClassesUnscoped = true;
 
     if (type.extensionMetaObject)
diff --git a/src/qml/qml/qqmlprivate.h b/src/qml/qml/qqmlprivate.h
index e6dd5e0b16..8111178320 100644
--- a/src/qml/qml/qqmlprivate.h
+++ b/src/qml/qml/qqmlprivate.h
@@ -52,17 +52,42 @@
 //
 
 #include <functional>
+#include <type_traits>
 
 #include <QtQml/qtqmlglobal.h>
+#include <QtQml/qqmlparserstatus.h>
+#include <QtQml/qqmllist.h>
+#include <QtQml/qqmlpropertyvaluesource.h>
 
 #include <QtCore/qglobal.h>
 #include <QtCore/qvariant.h>
 #include <QtCore/qurl.h>
 
+#include <QtCore/qmetaobject.h>
+#include <QtCore/qdebug.h>
+
+#define QML_GETTYPENAMES \
+    const char *className = T::staticMetaObject.className(); \
+    const int nameLen = int(strlen(className)); \
+    QVarLengthArray<char,48> pointerName(nameLen+2); \
+    memcpy(pointerName.data(), className, size_t(nameLen)); \
+    pointerName[nameLen] = '*'; \
+    pointerName[nameLen+1] = '\0'; \
+    const int listLen = int(strlen("QQmlListProperty<")); \
+    QVarLengthArray<char,64> listName(listLen + nameLen + 2); \
+    memcpy(listName.data(), "QQmlListProperty<", size_t(listLen)); \
+    memcpy(listName.data()+listLen, className, size_t(nameLen)); \
+    listName[listLen+nameLen] = '>'; \
+    listName[listLen+nameLen+1] = '\0';
+
 QT_BEGIN_NAMESPACE
 
+class QQmlPropertyValueInterceptor;
+
 namespace QQmlPrivate {
 struct CachedQmlUnit;
+template<typename A>
+using QQmlAttachedPropertiesFunc = A *(*)(QObject *);
 }
 
 namespace QV4 {
@@ -77,7 +102,7 @@ struct Document;
 typedef void (*IRLoaderFunction)(Document *, const QQmlPrivate::CachedQmlUnit *);
 }
 
-typedef QObject *(*QQmlAttachedPropertiesFunc)(QObject *);
+using QQmlAttachedPropertiesFunc = QQmlPrivate::QQmlAttachedPropertiesFunc<QObject>;
 
 inline uint qHash(QQmlAttachedPropertiesFunc func, uint seed = 0)
 {
@@ -98,6 +123,13 @@ class QJSValue;
 class QJSEngine;
 class QQmlEngine;
 class QQmlCustomParser;
+
+template<class T>
+QQmlCustomParser *qmlCreateCustomParser()
+{
+    return nullptr;
+}
+
 namespace QQmlPrivate
 {
     void Q_QML_EXPORT qdeclarativeelement_destructor(QObject *);
@@ -123,11 +155,62 @@ namespace QQmlPrivate
     };
 
     template<typename T>
+    constexpr bool isConstructible()
+    {
+        return std::is_default_constructible<T>::value && std::is_base_of<QObject, T>::value;
+    }
+
+    template<typename T>
     void createInto(void *memory) { new (memory) QQmlElement<T>; }
 
     template<typename T>
+    QObject *createSingletonInstance(QQmlEngine *, QJSEngine *) { return new T; }
+
+    template<typename T>
     QObject *createParent(QObject *p) { return new T(p); }
 
+    using CreateIntoFunction = void (*)(void *);
+    using CreateSingletonFunction = QObject *(*)(QQmlEngine *, QJSEngine *);
+    using CreateParentFunction = QObject *(*)(QObject *);
+
+    template<typename T, bool Constructible = isConstructible<T>()>
+    struct Constructors;
+
+    template<typename T>
+    struct Constructors<T, true>
+    {
+        static constexpr CreateIntoFunction createInto
+                = QQmlPrivate::createInto<T>;
+        static constexpr CreateSingletonFunction createSingletonInstance
+                = QQmlPrivate::createSingletonInstance<T>;
+    };
+
+    template<typename T>
+    struct Constructors<T, false>
+    {
+        static constexpr CreateIntoFunction createInto = nullptr;
+        static constexpr CreateSingletonFunction createSingletonInstance = nullptr;
+    };
+
+    template<typename T, bool IsVoid = std::is_void<T>::value>
+    struct ExtendedType;
+
+    // void means "not an extended type"
+    template<typename T>
+    struct ExtendedType<T, true>
+    {
+        static constexpr const CreateParentFunction createParent = nullptr;
+        static constexpr const QMetaObject *staticMetaObject = nullptr;
+    };
+
+    // If it's not void, we actually want an error if the ctor or the metaobject is missing.
+    template<typename T>
+    struct ExtendedType<T, false>
+    {
+        static constexpr const CreateParentFunction createParent = QQmlPrivate::createParent<T>;
+        static constexpr const QMetaObject *staticMetaObject = &T::staticMetaObject;
+    };
+
     template<class From, class To, int N>
     struct StaticCastSelectorClass
     {
@@ -155,66 +238,103 @@ namespace QQmlPrivate
         }
     };
 
-    template <typename T>
-    struct has_attachedPropertiesMember
+    template<typename...>
+    using QmlVoidT = void;
+
+    // You can prevent subclasses from using the same attached type by specialzing this.
+    // This is reserved for internal types, though.
+    template<class T, class A>
+    struct OverridableAttachedType
     {
-        static bool const value = QQmlTypeInfo<T>::hasAttachedProperties;
+        using Type = A;
     };
 
-    template <typename T, bool hasMember>
-    class has_attachedPropertiesMethod
+    template<class T, class = QmlVoidT<>, bool OldStyle = QQmlTypeInfo<T>::hasAttachedProperties>
+    struct QmlAttached
     {
-    public:
-        typedef int yes_type;
-        typedef char no_type;
-
-        template<typename ReturnType>
-        static yes_type checkType(ReturnType *(*)(QObject *));
-        static no_type checkType(...);
-
-        static bool const value = sizeof(checkType(&T::qmlAttachedProperties)) == sizeof(yes_type);
+        using Type = void;
+        using Func = QQmlAttachedPropertiesFunc<QObject>;
+        static const QMetaObject *staticMetaObject() { return nullptr; }
+        static Func attachedPropertiesFunc() { return nullptr; }
     };
 
-    template <typename T>
-    class has_attachedPropertiesMethod<T, false>
+    // Defined inline via QML_ATTACHED
+    template<class T>
+    struct QmlAttached<T, QmlVoidT<typename OverridableAttachedType<T, typename T::QmlAttachedType>::Type>, false>
     {
-    public:
-        static bool const value = false;
+        // Normal attached properties
+        template <typename Parent, typename Attached>
+        struct Properties
+        {
+            using Func = QQmlAttachedPropertiesFunc<Attached>;
+            static const QMetaObject *staticMetaObject() { return &Attached::staticMetaObject; }
+            static Func attachedPropertiesFunc() { return Parent::qmlAttachedProperties; }
+        };
+
+        // Disabled via OverridableAttachedType
+        template<typename Parent>
+        struct Properties<Parent, void>
+        {
+            using Func = QQmlAttachedPropertiesFunc<QObject>;
+            static const QMetaObject *staticMetaObject() { return nullptr; };
+            static Func attachedPropertiesFunc() { return nullptr; };
+        };
+
+        using Type = typename OverridableAttachedType<T, typename T::QmlAttachedType>::Type;
+        using Func = typename Properties<T, Type>::Func;
+
+        static const QMetaObject *staticMetaObject()
+        {
+            return Properties<T, Type>::staticMetaObject();
+        }
+
+        static Func attachedPropertiesFunc()
+        {
+            return Properties<T, Type>::attachedPropertiesFunc();
+        }
     };
 
-    template<typename T, int N>
-    class AttachedPropertySelector
+    // Separately defined via QQmlTypeInfo
+    template<class T>
+    struct QmlAttached<T, QmlVoidT<decltype(T::qmlAttachedProperties)>, true>
     {
-    public:
-        static inline QQmlAttachedPropertiesFunc func() { return nullptr; }
-        static inline const QMetaObject *metaObject() { return nullptr; }
+        using Type = typename std::remove_pointer<decltype(T::qmlAttachedProperties(nullptr))>::type;
+        using Func = QQmlAttachedPropertiesFunc<Type>;
+
+        static const QMetaObject *staticMetaObject() { return &Type::staticMetaObject; }
+        static Func attachedPropertiesFunc() { return T::qmlAttachedProperties; }
     };
-    template<typename T>
-    class AttachedPropertySelector<T, 1>
+
+    // This is necessary because both the type containing a default template parameter and the type
+    // instantiating the template need to have access to the default template parameter type. In
+    // this case that's T::QmlAttachedType. The QML_FOREIGN macro needs to befriend specific other
+    // types. Therefore we need some kind of "accessor". Because of compiler bugs in gcc and clang,
+    // we cannot befriend attachedPropertiesFunc() directly. Wrapping the actual access into another
+    // struct "fixes" that. For convenience we still want the free standing functions in addition.
+    template<class T>
+    struct QmlAttachedAccessor
     {
-        template<typename ReturnType>
-        static inline const QMetaObject *attachedPropertiesMetaObject(ReturnType *(*)(QObject *)) {
-            return &ReturnType::staticMetaObject;
-        }
-    public:
-        static inline QQmlAttachedPropertiesFunc func() {
-            return QQmlAttachedPropertiesFunc(&T::qmlAttachedProperties);
+        static QQmlAttachedPropertiesFunc<QObject> attachedPropertiesFunc()
+        {
+            return QQmlAttachedPropertiesFunc<QObject>(QmlAttached<T>::attachedPropertiesFunc());
         }
-        static inline const QMetaObject *metaObject() {
-            return attachedPropertiesMetaObject(&T::qmlAttachedProperties);
+
+        static const QMetaObject *staticMetaObject()
+        {
+            return QmlAttached<T>::staticMetaObject();
         }
     };
 
     template<typename T>
-    inline QQmlAttachedPropertiesFunc attachedPropertiesFunc()
+    inline QQmlAttachedPropertiesFunc<QObject> attachedPropertiesFunc()
     {
-        return AttachedPropertySelector<T, has_attachedPropertiesMethod<T, has_attachedPropertiesMember<T>::value>::value>::func();
+        return QmlAttachedAccessor<T>::attachedPropertiesFunc();
     }
 
     template<typename T>
     inline const QMetaObject *attachedPropertiesMetaObject()
     {
-        return AttachedPropertySelector<T, has_attachedPropertiesMethod<T, has_attachedPropertiesMember<T>::value>::value>::metaObject();
+        return QmlAttachedAccessor<T>::staticMetaObject();
     }
 
     enum AutoParentResult { Parented, IncompatibleObject, IncompatibleParent };
@@ -235,7 +355,7 @@ namespace QQmlPrivate
         const char *elementName;
         const QMetaObject *metaObject;
 
-        QQmlAttachedPropertiesFunc attachedPropertiesFunction;
+        QQmlAttachedPropertiesFunc<QObject> attachedPropertiesFunction;
         const QMetaObject *attachedPropertiesMetaObject;
 
         int parserStatusCast;
@@ -246,10 +366,38 @@ namespace QQmlPrivate
         const QMetaObject *extensionMetaObject;
 
         QQmlCustomParser *customParser;
+
         int revision;
         // If this is extended ensure "version" is bumped!!!
     };
 
+    struct RegisterTypeAndRevisions {
+        int version;
+
+        int typeId;
+        int listId;
+        int objectSize;
+        void (*create)(void *);
+
+        const char *uri;
+        int versionMajor;
+
+        const QMetaObject *metaObject;
+        const QMetaObject *classInfoMetaObject;
+
+        QQmlAttachedPropertiesFunc<QObject> attachedPropertiesFunction;
+        const QMetaObject *attachedPropertiesMetaObject;
+
+        int parserStatusCast;
+        int valueSourceCast;
+        int valueInterceptorCast;
+
+        QObject *(*extensionObjectCreate)(QObject *);
+        const QMetaObject *extensionMetaObject;
+
+        QQmlCustomParser *(*customParserFactory)();
+    };
+
     struct RegisterInterface {
         int version;
 
@@ -282,6 +430,19 @@ namespace QQmlPrivate
         // If this is extended ensure "version" is bumped!!!
     };
 
+    struct RegisterSingletonTypeAndRevisions {
+        int version;
+        const char *uri;
+        int versionMajor;
+
+        QJSValue (*scriptApi)(QQmlEngine *, QJSEngine *);
+        const QMetaObject *instanceMetaObject;
+        const QMetaObject *classInfoMetaObject;
+
+        int typeId;
+        std::function<QObject*(QQmlEngine *, QJSEngine *)> generalizedQobjectApi; // new in version 3
+    };
+
     struct RegisterCompositeType {
         QUrl url;
         const char *uri;
@@ -317,7 +478,9 @@ namespace QQmlPrivate
         SingletonRegistration  = 3,
         CompositeRegistration  = 4,
         CompositeSingletonRegistration = 5,
-        QmlUnitCacheHookRegistration = 6
+        QmlUnitCacheHookRegistration = 6,
+        TypeAndRevisionsRegistration = 7,
+        SingletonAndRevisionsRegistration = 8
     };
 
     int Q_QML_EXPORT qmlregister(RegistrationType, void *);
@@ -329,7 +492,151 @@ namespace QQmlPrivate
         QObject *m_object;
         bool alreadyCalled = false;
     };
-}
+
+    static int indexOfOwnClassInfo(const QMetaObject *metaObject, const char *key)
+    {
+        if (!metaObject || !key)
+            return -1;
+
+        const int offset = metaObject->classInfoOffset();
+        for (int i = metaObject->classInfoCount() + offset - 1; i >= offset; --i)
+            if (qstrcmp(key, metaObject->classInfo(i).name()) == 0) {
+                return i;
+        }
+        return -1;
+    }
+
+    inline const char *classInfo(const QMetaObject *metaObject, const char *key)
+    {
+        return metaObject->classInfo(indexOfOwnClassInfo(metaObject, key)).value();
+    }
+
+    inline int intClassInfo(const QMetaObject *metaObject, const char *key, int defaultValue = 0)
+    {
+        const int index = indexOfOwnClassInfo(metaObject, key);
+        return (index == -1) ? defaultValue
+                             : QByteArray(metaObject->classInfo(index).value()).toInt();
+    }
+
+    inline bool boolClassInfo(const QMetaObject *metaObject, const char *key,
+                              bool defaultValue = false)
+    {
+        const int index = indexOfOwnClassInfo(metaObject, key);
+        return (index == -1) ? defaultValue
+                             : (QByteArray(metaObject->classInfo(index).value()) == "true");
+    }
+
+    inline const char *classElementName(const QMetaObject *metaObject)
+    {
+        const char *elementName = classInfo(metaObject, "QML.Element");
+        if (qstrcmp(elementName, "auto") == 0)
+            return metaObject->className();
+        if (qstrcmp(elementName, "anonymous") == 0)
+            return nullptr;
+
+        if (!elementName || elementName[0] < 'A' || elementName[0] > 'Z') {
+            qWarning() << "Missing or unusable QML.Element class info \"" << elementName << "\""
+                       << "for" << metaObject->className();
+        }
+
+        return elementName;
+    }
+
+    template<class T, class = QmlVoidT<>>
+    struct QmlExtended
+    {
+        using Type = void;
+    };
+
+    template<class T>
+    struct QmlExtended<T, QmlVoidT<typename T::QmlExtendedType>>
+    {
+        using Type = typename T::QmlExtendedType;
+    };
+
+    template<class T, class = QmlVoidT<>>
+    struct QmlResolved
+    {
+        using Type = T;
+    };
+
+    template<class T>
+    struct QmlResolved<T, QmlVoidT<typename T::QmlForeignType>>
+    {
+        using Type = typename T::QmlForeignType;
+    };
+
+    template<class T, class = QmlVoidT<>>
+    struct QmlSingleton
+    {
+        static constexpr bool Value = false;
+    };
+
+    template<class T>
+    struct QmlSingleton<T, QmlVoidT<typename T::QmlIsSingleton>>
+    {
+        static constexpr bool Value = bool(T::QmlIsSingleton::yes);
+    };
+
+    template<typename T>
+    void qmlRegisterSingletonAndRevisions(const char *uri, int versionMajor,
+                                          const QMetaObject *classInfoMetaObject)
+    {
+        QML_GETTYPENAMES
+
+        RegisterSingletonTypeAndRevisions api = {
+            0,
+
+            uri,
+            versionMajor,
+
+            nullptr,
+
+            &T::staticMetaObject,
+            classInfoMetaObject,
+
+            qRegisterNormalizedMetaType<T *>(pointerName.constData()),
+            Constructors<T>::createSingletonInstance
+        };
+
+        qmlregister(SingletonAndRevisionsRegistration, &api);
+    }
+
+    template<typename T, typename E>
+    void qmlRegisterTypeAndRevisions(const char *uri, int versionMajor,
+                                     const QMetaObject *classInfoMetaObject)
+    {
+        QML_GETTYPENAMES
+
+        RegisterTypeAndRevisions type = {
+            0,
+            qRegisterNormalizedMetaType<T *>(pointerName.constData()),
+            qRegisterNormalizedMetaType<QQmlListProperty<T> >(listName.constData()),
+            int(sizeof(T)),
+            Constructors<T>::createInto,
+
+            uri,
+            versionMajor,
+
+            &T::staticMetaObject,
+            classInfoMetaObject,
+
+            attachedPropertiesFunc<T>(),
+            attachedPropertiesMetaObject<T>(),
+
+            StaticCastSelector<T, QQmlParserStatus>::cast(),
+            StaticCastSelector<T, QQmlPropertyValueSource>::cast(),
+            StaticCastSelector<T, QQmlPropertyValueInterceptor>::cast(),
+
+            ExtendedType<E>::createParent,
+            ExtendedType<E>::staticMetaObject,
+
+            &qmlCreateCustomParser<T>
+        };
+
+        qmlregister(TypeAndRevisionsRegistration, &type);
+    }
+} // namespace QQmlPrivate
 
 QT_END_NAMESPACE
 
diff --git a/src/qml/qml/qqmltypenotavailable_p.h b/src/qml/qml/qqmltypenotavailable_p.h
index 33630bf507..8db5876b10 100644
--- a/src/qml/qml/qqmltypenotavailable_p.h
+++ b/src/qml/qml/qqmltypenotavailable_p.h
@@ -58,6 +58,9 @@ QT_BEGIN_NAMESPACE
 
 class QQmlTypeNotAvailable : public QObject {
     Q_OBJECT
+    QML_NAMED_ELEMENT(TypeNotAvailable)
+    QML_UNCREATABLE("Type not available.")
+
 public:
     QQmlTypeNotAvailable();
 };
diff --git a/src/qml/qml/qqmlvaluetype_p.h b/src/qml/qml/qqmlvaluetype_p.h
index cf53b8cb4a..9c008859da 100644
--- a/src/qml/qml/qqmlvaluetype_p.h
+++ b/src/qml/qml/qqmlvaluetype_p.h
@@ -215,6 +215,8 @@ struct QQmlEasingValueType
 {
     QEasingCurve v;
     Q_GADGET
+    QML_NAMED_ELEMENT(Easing)
+    QML_UNCREATABLE("Use the Type enum.")
 
     Q_PROPERTY(QQmlEasingValueType::Type type READ type WRITE setType FINAL)
     Q_PROPERTY(qreal amplitude READ amplitude WRITE setAmplitude FINAL)