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>

1 files changed, 93 insertions, 20 deletions

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