QML: Use QQmlType as container for composite types (inline or not)

This gives us a unified interface to all kinds of QML types at run time
and reduces the effort of finding corresponding type attributes.

QQmlType is much larger than CompositeMetaTypeIds. Most composite types,
however, are initially referenced by URL, and we call typeForUrl anyway.
typeForUrl already creates a mostly functional QQmlType; we only need to
add the dynamic metatypes. The same type can be retrieved later and
associated with the actual CU using the compositeTypes hash. That way,
we don't need any extra type. We do, however, incur the cost of creating
the QMetaTypePrivate instances when first referencing a type. This could
be optimized, like many things in this area, by using thread safe lazy
initialization.

Now some QQmlTypes implicitly depend on the CUs they were created for.
This creates problems if the CUs are removed but the types still
persist. Such a situation can arise if you create and delete engines. In
order to avoid it, we:

1. Make the compositeTypes hold a strong reference to the CUs
2. When unlinking, avoid dropping the property caches (as those are used
   to hold the metaobjects)

Now, however we got a cyclic reference between the CU and its
QQmlType(s). To resolve this, we clear the QQmlTypes on unlinking.
Finally, to avoid deletion recursion when clearing the last CUs on
destruction of the QQmlMetaTypeData, we move the compilation units out
of the way first.

All of this still doesn't work if multiple CUs hold the same QQmlType,
since compositeTypes can only hold one CU per type and that may be the
one that gets removed first. Therefore, we cannot allow such a situation
to happen and have to create a new QQmlType if it arises. It can only
arise if you have multiple engines loading the same QML components,
which should be fairly rare.

For inline components, we apply a similar trick: You can either find an
inline component by Url, and receive any type that matches, no matter
what CU it belongs to. Or you can request an inline component type that
belongs to a specific CU. It turns out we don't have to store the
containing type of an IC at all. Also, we slightly change the naming of
internal components' "class names" since we want to use the inline
components' element names for them.

Change-Id: I0ef89bd4b0a02cc927aed2525e72f6bff56df626
Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>

1 files changed, 22 insertions, 25 deletions

diff --git a/src/qml/qml/qqmlpropertycachecreator_p.h b/src/qml/qml/qqmlpropertycachecreator_p.h
index 568e5cac0f..f7d27d113b 100644
--- a/src/qml/qml/qqmlpropertycachecreator_p.h
+++ b/src/qml/qml/qqmlpropertycachecreator_p.h
@@ -69,9 +69,10 @@ public:
     static QMetaType metaTypeForPropertyType(QV4::CompiledData::CommonType type);
     static QMetaType listTypeForPropertyType(QV4::CompiledData::CommonType type);
 
+    static bool canCreateClassNameTypeByUrl(const QUrl &url);
     static QByteArray createClassNameTypeByUrl(const QUrl &url);
 
-    static QByteArray createClassNameForInlineComponent(const QUrl &baseUrl, int icId);
+    static QByteArray createClassNameForInlineComponent(const QUrl &baseUrl, const QString &name);
 
     struct IncrementalResult {
         // valid if and only if an error occurred
@@ -157,7 +158,7 @@ inline QQmlPropertyCacheCreator<ObjectContainer>::QQmlPropertyCacheCreator(QQmlP
     , typeClassName(typeClassName)
     , currentRoot(-1)
 {
-    propertyCaches->resize(objectContainer->objectCount());
+    propertyCaches->resetAndResize(objectContainer->objectCount());
 
     using namespace icutils;
 
@@ -626,35 +627,29 @@ inline QQmlError QQmlPropertyCacheCreator<ObjectContainer>::createMetaObject(
             // inline components are not necessarily valid yet
             Q_ASSERT(qmltype.isValid() || qmltype.isInlineComponentType());
             if (qmltype.isComposite() || qmltype.isInlineComponentType()) {
-                CompositeMetaTypeIds typeIds;
+                QQmlType compositeType;
                 if (qmltype.isInlineComponentType()) {
                     const QString icName = qmltype.elementName();
-                    auto containingType = qmltype.containingType();
-                    if (containingType.isValid()) {
-                        const QQmlType icType
-                            = QQmlMetaType::inlineComponentType(containingType, icName);
-                        typeIds = {icType.typeId(), icType.qListTypeId()};
-                    } else {
-                        typeIds = {};
-                    }
-                    if (!typeIds.isValid()) // type has not been registered yet, we must be in containing type
-                        typeIds = objectContainer->typeIdsForComponent(icName);
-                    Q_ASSERT(typeIds.isValid());
+                    compositeType = QQmlMetaType::inlineComponentTypeForUrl(
+                            qmltype.sourceUrl(), icName);
+                    if (!compositeType.isValid()) // type has not been registered yet, we must be in containing type
+                        compositeType = objectContainer->qmlTypeForComponent(icName);
+                    Q_ASSERT(compositeType.isValid());
                 } else if (selfReference) {
-                     typeIds = objectContainer->typeIdsForComponent();
+                     compositeType = objectContainer->qmlTypeForComponent();
                 } else {
                     QQmlRefPointer<QQmlTypeData> tdata = enginePrivate->typeLoader.getType(qmltype.sourceUrl());
                     Q_ASSERT(tdata);
                     Q_ASSERT(tdata->isComplete());
 
                     auto compilationUnit = tdata->compilationUnit();
-                    typeIds = compilationUnit->typeIdsForComponent();
+                    compositeType = compilationUnit->qmlTypeForComponent();
                 }
 
                 if (p->isList()) {
-                    propertyType = typeIds.listId;
+                    propertyType = compositeType.qListTypeId();
                 } else {
-                    propertyType = typeIds.id;
+                    propertyType = compositeType.typeId();
                 }
             } else {
                 if (p->isList())
@@ -714,16 +709,16 @@ inline QMetaType QQmlPropertyCacheCreator<ObjectContainer>::metaTypeForParameter
     if (!qmltype.isComposite()) {
         const QMetaType typeId = param.isList() ? qmltype.qListTypeId() : qmltype.typeId();
         if (!typeId.isValid() && qmltype.isInlineComponentType()) {
-            const auto typeIds = objectContainer->typeIdsForComponent(qmltype.elementName());
-            return param.isList() ? typeIds.listId : typeIds.id;
+            const QQmlType qmlType = objectContainer->qmlTypeForComponent(qmltype.elementName());
+            return param.isList() ? qmlType.qListTypeId() : qmlType.typeId();
         } else {
             return typeId;
         }
     }
 
     if (selfReference) {
-        const auto typeIds = objectContainer->typeIdsForComponent();
-        return param.isList() ? typeIds.listId : typeIds.id;
+        const QQmlType qmlType = objectContainer->qmlTypeForComponent();
+        return param.isList() ? qmlType.qListTypeId() : qmlType.typeId();
     }
 
     QQmlRefPointer<QQmlTypeData> tdata = enginePrivate->typeLoader.getType(qmltype.sourceUrl());
@@ -732,7 +727,9 @@ inline QMetaType QQmlPropertyCacheCreator<ObjectContainer>::metaTypeForParameter
 
     auto compilationUnit = tdata->compilationUnit();
 
-    return param.isList() ? compilationUnit->typeIds.listId : compilationUnit->typeIds.id;
+    return param.isList()
+               ? compilationUnit->qmlType.qListTypeId()
+               : compilationUnit->qmlType.typeId();
 }
 
 template <typename ObjectContainer>
@@ -825,11 +822,11 @@ inline QQmlError QQmlPropertyCacheAliasCreator<ObjectContainer>::propertyDataFor
         if (referencedType.isValid()) {
             *type = referencedType.typeId();
             if (!type->isValid() && referencedType.isInlineComponentType()) {
-                *type = objectContainer->typeIdsForComponent(referencedType.elementName()).id;
+                *type = objectContainer->qmlTypeForComponent(referencedType.elementName()).typeId();
                 Q_ASSERT(type->isValid());
             }
         } else {
-            *type = typeRef->compilationUnit()->typeIds.id;
+            *type = typeRef->compilationUnit()->qmlType.typeId();
         }
 
         *version = typeRef->version();