QQmlType: Re-organize QQmlTypePrivate to reduce memory usage

The iid is only used for interfaces, and re-ordering the members saves
some padding. Also, avoid extra indirection where possible. QUrl is only
one pointer to begin with, just like QMetaSequence. We can store them
directly in the union. Finally, rename the extraData members so that we
can easily recognize them.

Change-Id: Ia9c524ea65f8137b264a7dfd9459369c90ce1670
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

5 files changed, 143 insertions, 147 deletions

diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp
index dc894fb670..13388108c4 100644
--- a/src/qml/jsruntime/qv4sequenceobject.cpp
+++ b/src/qml/jsruntime/qv4sequenceobject.cpp
@@ -694,7 +694,7 @@ QVariant SequencePrototype::toVariant(const QV4::Value &array, QMetaType typeHin
     const QQmlType type = QQmlMetaType::qmlListType(typeHint);
     if (type.isSequentialContainer()) {
         const QQmlTypePrivate *priv = type.priv();
-        const QMetaSequence *meta = priv->extraData.ld;
+        const QMetaSequence *meta = &priv->extraData.sequentialContainerTypeData;
         const QMetaType containerMetaType(priv->listId);
         QVariant result(containerMetaType);
         qint64 length = a->getLength();
diff --git a/src/qml/qml/qqmlmetatype.cpp b/src/qml/qml/qqmlmetatype.cpp
index d969fb9ff0..462027682e 100644
--- a/src/qml/qml/qqmlmetatype.cpp
+++ b/src/qml/qml/qqmlmetatype.cpp
@@ -61,7 +61,7 @@ static QQmlTypePrivate *createQQmlType(QQmlMetaTypeData *data,
                                        const QQmlPrivate::RegisterInterface &type)
 {
     auto *d = new QQmlTypePrivate(QQmlType::InterfaceType);
-    d->iid = type.iid;
+    d->extraData.interfaceTypeData = type.iid;
     d->typeId = type.typeId;
     d->listId = type.listId;
     d->isSetup.storeRelease(true);
@@ -86,14 +86,14 @@ static QQmlTypePrivate *createQQmlType(QQmlMetaTypeData *data, const QString &el
         d->revision = type.revision;
     }
 
-    d->extraData.sd->singletonInstanceInfo = new QQmlType::SingletonInstanceInfo;
-    d->extraData.sd->singletonInstanceInfo->scriptCallback = type.scriptApi;
-    d->extraData.sd->singletonInstanceInfo->qobjectCallback = type.qObjectApi;
-    d->extraData.sd->singletonInstanceInfo->typeName = QString::fromUtf8(type.typeName);
-    d->extraData.sd->singletonInstanceInfo->instanceMetaObject
+    d->extraData.singletonTypeData->singletonInstanceInfo = new QQmlType::SingletonInstanceInfo;
+    d->extraData.singletonTypeData->singletonInstanceInfo->scriptCallback = type.scriptApi;
+    d->extraData.singletonTypeData->singletonInstanceInfo->qobjectCallback = type.qObjectApi;
+    d->extraData.singletonTypeData->singletonInstanceInfo->typeName = QString::fromUtf8(type.typeName);
+    d->extraData.singletonTypeData->singletonInstanceInfo->instanceMetaObject
             = type.qObjectApi ? type.instanceMetaObject : nullptr;
-    d->extraData.sd->extFunc = type.extensionObjectCreate;
-    d->extraData.sd->extMetaObject = type.extensionMetaObject;
+    d->extraData.singletonTypeData->extFunc = type.extensionObjectCreate;
+    d->extraData.singletonTypeData->extMetaObject = type.extensionMetaObject;
 
     return d;
 }
@@ -109,44 +109,44 @@ static QQmlTypePrivate *createQQmlType(QQmlMetaTypeData *data, const QString &el
     d->revision = type.revision;
     d->typeId = type.typeId;
     d->listId = type.listId;
-    d->extraData.cd->allocationSize = type.objectSize;
-    d->extraData.cd->userdata = type.userdata;
-    d->extraData.cd->newFunc = type.create;
-    d->extraData.cd->noCreationReason = type.noCreationReason;
-    d->extraData.cd->createValueTypeFunc = type.createValueType;
+    d->extraData.cppTypeData->allocationSize = type.objectSize;
+    d->extraData.cppTypeData->userdata = type.userdata;
+    d->extraData.cppTypeData->newFunc = type.create;
+    d->extraData.cppTypeData->noCreationReason = type.noCreationReason;
+    d->extraData.cppTypeData->createValueTypeFunc = type.createValueType;
     d->baseMetaObject = type.metaObject;
-    d->extraData.cd->attachedPropertiesFunc = type.attachedPropertiesFunction;
-    d->extraData.cd->attachedPropertiesType = type.attachedPropertiesMetaObject;
-    d->extraData.cd->parserStatusCast = type.parserStatusCast;
-    d->extraData.cd->propertyValueSourceCast = type.valueSourceCast;
-    d->extraData.cd->propertyValueInterceptorCast = type.valueInterceptorCast;
-    d->extraData.cd->finalizerCast = type.has(QQmlPrivate::RegisterType::FinalizerCast)
+    d->extraData.cppTypeData->attachedPropertiesFunc = type.attachedPropertiesFunction;
+    d->extraData.cppTypeData->attachedPropertiesType = type.attachedPropertiesMetaObject;
+    d->extraData.cppTypeData->parserStatusCast = type.parserStatusCast;
+    d->extraData.cppTypeData->propertyValueSourceCast = type.valueSourceCast;
+    d->extraData.cppTypeData->propertyValueInterceptorCast = type.valueInterceptorCast;
+    d->extraData.cppTypeData->finalizerCast = type.has(QQmlPrivate::RegisterType::FinalizerCast)
             ? type.finalizerCast
             : -1;
-    d->extraData.cd->extFunc = type.extensionObjectCreate;
-    d->extraData.cd->customParser = reinterpret_cast<QQmlCustomParser *>(type.customParser);
-    d->extraData.cd->registerEnumClassesUnscoped = true;
-    d->extraData.cd->registerEnumsFromRelatedTypes = true;
-    d->extraData.cd->constructValueType = type.has(QQmlPrivate::RegisterType::CreationMethod)
+    d->extraData.cppTypeData->extFunc = type.extensionObjectCreate;
+    d->extraData.cppTypeData->customParser = reinterpret_cast<QQmlCustomParser *>(type.customParser);
+    d->extraData.cppTypeData->registerEnumClassesUnscoped = true;
+    d->extraData.cppTypeData->registerEnumsFromRelatedTypes = true;
+    d->extraData.cppTypeData->constructValueType = type.has(QQmlPrivate::RegisterType::CreationMethod)
             && type.creationMethod != QQmlPrivate::ValueTypeCreationMethod::None;
-    d->extraData.cd->populateValueType = type.has(QQmlPrivate::RegisterType::CreationMethod)
+    d->extraData.cppTypeData->populateValueType = type.has(QQmlPrivate::RegisterType::CreationMethod)
             && type.creationMethod == QQmlPrivate::ValueTypeCreationMethod::Structured;
 
     if (type.extensionMetaObject)
-        d->extraData.cd->extMetaObject = type.extensionMetaObject;
+        d->extraData.cppTypeData->extMetaObject = type.extensionMetaObject;
 
     // Check if the user wants only scoped enum classes
     if (d->baseMetaObject) {
         auto indexOfUnscoped = d->baseMetaObject->indexOfClassInfo("RegisterEnumClassesUnscoped");
         if (indexOfUnscoped != -1
                 && qstrcmp(d->baseMetaObject->classInfo(indexOfUnscoped).value(), "false") == 0) {
-            d->extraData.cd->registerEnumClassesUnscoped = false;
+            d->extraData.cppTypeData->registerEnumClassesUnscoped = false;
         }
 
         auto indexOfRelated = d->baseMetaObject->indexOfClassInfo("RegisterEnumsFromRelatedTypes");
         if (indexOfRelated != -1
                 && qstrcmp(d->baseMetaObject->classInfo(indexOfRelated).value(), "false") == 0) {
-            d->extraData.cd->registerEnumsFromRelatedTypes = false;
+            d->extraData.cppTypeData->registerEnumsFromRelatedTypes = false;
         }
     }
 
@@ -178,7 +178,7 @@ static QQmlTypePrivate *createQQmlType(QQmlMetaTypeData *data, const QString &el
     d->version = type.version;
 
     const QUrl normalized = QQmlTypeLoader::normalize(type.url);
-    d->extraData.fd->url = normalized;
+    d->extraData.compositeTypeData = normalized;
     addQQmlMetaTypeInterfaces(
         d, QQmlPropertyCacheCreatorBase::createClassNameTypeByUrl(normalized));
     return d;
@@ -194,9 +194,9 @@ static QQmlTypePrivate *createQQmlType(QQmlMetaTypeData *data, const QString &el
     d->version = type.version;
 
     const QUrl normalized = QQmlTypeLoader::normalize(type.url);
-    d->extraData.sd->singletonInstanceInfo = new QQmlType::SingletonInstanceInfo;
-    d->extraData.sd->singletonInstanceInfo->url = normalized;
-    d->extraData.sd->singletonInstanceInfo->typeName = QString::fromUtf8(type.typeName);
+    d->extraData.singletonTypeData->singletonInstanceInfo = new QQmlType::SingletonInstanceInfo;
+    d->extraData.singletonTypeData->singletonInstanceInfo->url = normalized;
+    d->extraData.singletonTypeData->singletonInstanceInfo->typeName = QString::fromUtf8(type.typeName);
     addQQmlMetaTypeInterfaces(
         d, QQmlPropertyCacheCreatorBase::createClassNameTypeByUrl(normalized));
     return d;
@@ -630,11 +630,11 @@ static QQmlType createTypeForUrl(
         priv->version = version;
 
         if (mode == QQmlMetaType::Singleton) {
-            priv->extraData.sd->singletonInstanceInfo = new QQmlType::SingletonInstanceInfo;
-            priv->extraData.sd->singletonInstanceInfo->url = url;
-            priv->extraData.sd->singletonInstanceInfo->typeName = typeName;
+            priv->extraData.singletonTypeData->singletonInstanceInfo = new QQmlType::SingletonInstanceInfo;
+            priv->extraData.singletonTypeData->singletonInstanceInfo->url = url;
+            priv->extraData.singletonTypeData->singletonInstanceInfo->typeName = typeName;
         } else {
-            priv->extraData.fd->url = url;
+            priv->extraData.compositeTypeData = url;
         }
 
         data->registerType(priv);
@@ -690,7 +690,7 @@ static QQmlType doRegisterInlineComponentType(QQmlMetaTypeData *data, const QUrl
     QQmlTypePrivate *priv = new QQmlTypePrivate(QQmlType::InlineComponentType);
     priv->setName(QString(), url.fragment());
 
-    priv->extraData.id->url = url;
+    priv->extraData.inlineComponentTypeData = url;
 
     const QByteArray className
             = QQmlPropertyCacheCreatorBase::createClassNameForInlineComponent(url, url.fragment());
@@ -774,7 +774,7 @@ QQmlType QQmlMetaType::registerSequentialContainer(
     priv->revision = container.revision;
     priv->typeId = container.metaSequence.valueMetaType();
     priv->listId = container.typeId;
-    *priv->extraData.ld = container.metaSequence;
+    priv->extraData.sequentialContainerTypeData = container.metaSequence;
 
     addTypeToData(priv, data);
 
@@ -1785,11 +1785,11 @@ QList<QQmlProxyMetaObject::ProxyData> QQmlMetaType::proxyData(const QMetaObject
         QQmlTypePrivate *t = data->metaObjectToType.value(mo);
         if (t) {
             if (t->regType == QQmlType::CppType) {
-                createProxyMetaObject(t, t->baseMetaObject, t->extraData.cd->extMetaObject,
-                                      t->extraData.cd->extFunc);
+                createProxyMetaObject(t, t->baseMetaObject, t->extraData.cppTypeData->extMetaObject,
+                                      t->extraData.cppTypeData->extFunc);
             } else if (t->regType == QQmlType::SingletonType) {
-                createProxyMetaObject(t, t->baseMetaObject, t->extraData.sd->extMetaObject,
-                                      t->extraData.sd->extFunc);
+                createProxyMetaObject(t, t->baseMetaObject, t->extraData.singletonTypeData->extMetaObject,
+                                      t->extraData.singletonTypeData->extFunc);
             }
         }
         mo = mo->d.superdata;
diff --git a/src/qml/qml/qqmltype.cpp b/src/qml/qml/qqmltype.cpp
index ece6454705..491bb2086f 100644
--- a/src/qml/qml/qqmltype.cpp
+++ b/src/qml/qml/qqmltype.cpp
@@ -17,46 +17,51 @@
 QT_BEGIN_NAMESPACE
 
 QQmlTypePrivate::QQmlTypePrivate(QQmlType::RegistrationType type)
-    : regType(type), iid(nullptr), revision(QTypeRevision::zero()),
-    containsRevisionedAttributes(false), baseMetaObject(nullptr),
-    index(-1), isSetup(false), isEnumFromCacheSetup(false), isEnumFromBaseSetup(false)
+    : regType(type)
+    , revision(QTypeRevision::zero())
+    , baseMetaObject(nullptr)
+    , index(-1)
+    , containsRevisionedAttributes(false)
+    , isSetup(false)
+    , isEnumFromCacheSetup(false)
+    , isEnumFromBaseSetup(false)
 {
     switch (type) {
     case QQmlType::CppType:
-        extraData.cd = new QQmlCppTypeData;
-        extraData.cd->allocationSize = 0;
-        extraData.cd->newFunc = nullptr;
-        extraData.cd->createValueTypeFunc = nullptr;
-        extraData.cd->parserStatusCast = -1;
-        extraData.cd->extFunc = nullptr;
-        extraData.cd->extMetaObject = nullptr;
-        extraData.cd->customParser = nullptr;
-        extraData.cd->attachedPropertiesFunc = nullptr;
-        extraData.cd->attachedPropertiesType = nullptr;
-        extraData.cd->propertyValueSourceCast = -1;
-        extraData.cd->propertyValueInterceptorCast = -1;
-        extraData.cd->finalizerCast = -1;
-        extraData.cd->registerEnumClassesUnscoped = true;
-        extraData.cd->registerEnumsFromRelatedTypes = true;
+        extraData.cppTypeData = new QQmlCppTypeData;
+        extraData.cppTypeData->allocationSize = 0;
+        extraData.cppTypeData->newFunc = nullptr;
+        extraData.cppTypeData->createValueTypeFunc = nullptr;
+        extraData.cppTypeData->parserStatusCast = -1;
+        extraData.cppTypeData->extFunc = nullptr;
+        extraData.cppTypeData->extMetaObject = nullptr;
+        extraData.cppTypeData->customParser = nullptr;
+        extraData.cppTypeData->attachedPropertiesFunc = nullptr;
+        extraData.cppTypeData->attachedPropertiesType = nullptr;
+        extraData.cppTypeData->propertyValueSourceCast = -1;
+        extraData.cppTypeData->propertyValueInterceptorCast = -1;
+        extraData.cppTypeData->finalizerCast = -1;
+        extraData.cppTypeData->registerEnumClassesUnscoped = true;
+        extraData.cppTypeData->registerEnumsFromRelatedTypes = true;
         break;
     case QQmlType::SingletonType:
     case QQmlType::CompositeSingletonType:
-        extraData.sd = new QQmlSingletonTypeData;
-        extraData.sd->singletonInstanceInfo = nullptr;
-        extraData.sd->extFunc = nullptr;
-        extraData.sd->extMetaObject = nullptr;
+        extraData.singletonTypeData = new QQmlSingletonTypeData;
+        extraData.singletonTypeData->singletonInstanceInfo = nullptr;
+        extraData.singletonTypeData->extFunc = nullptr;
+        extraData.singletonTypeData->extMetaObject = nullptr;
         break;
     case QQmlType::InterfaceType:
-        extraData.cd = nullptr;
+        extraData.interfaceTypeData = nullptr;
         break;
     case QQmlType::CompositeType:
-        extraData.fd = new QQmlCompositeTypeData;
+        new (&extraData.compositeTypeData) QUrl();
         break;
     case QQmlType::InlineComponentType:
-        extraData.id = new QQmlInlineTypeData;
+        new (&extraData.inlineComponentTypeData) QUrl();
         break;
     case QQmlType::SequentialContainerType:
-        extraData.ld = new QQmlSequenceTypeData;
+        new (&extraData.sequentialContainerTypeData) QMetaSequence();
         break;
     default: qFatal("QQmlTypePrivate Internal Error.");
     }
@@ -75,22 +80,22 @@ QQmlTypePrivate::~QQmlTypePrivate()
 
     switch (regType) {
     case QQmlType::CppType:
-        delete extraData.cd->customParser;
-        delete extraData.cd;
+        delete extraData.cppTypeData->customParser;
+        delete extraData.cppTypeData;
         break;
     case QQmlType::SingletonType:
     case QQmlType::CompositeSingletonType:
-        delete extraData.sd->singletonInstanceInfo;
-        delete extraData.sd;
+        delete extraData.singletonTypeData->singletonInstanceInfo;
+        delete extraData.singletonTypeData;
         break;
     case QQmlType::CompositeType:
-        delete extraData.fd;
+        extraData.compositeTypeData.~QUrl();
         break;
     case QQmlType::InlineComponentType:
-        delete  extraData.id;
+        extraData.inlineComponentTypeData.~QUrl();
         break;
     case QQmlType::SequentialContainerType:
-        delete extraData.ld;
+        extraData.sequentialContainerTypeData.~QMetaSequence();
         break;
     default: //Also InterfaceType, because it has no extra data
         break;
@@ -205,9 +210,9 @@ void QQmlTypePrivate::init() const
     };
 
     if (regType == QQmlType::SingletonType)
-        setupExtendedMetaObject(extraData.sd->extMetaObject, extraData.sd->extFunc);
+        setupExtendedMetaObject(extraData.singletonTypeData->extMetaObject, extraData.singletonTypeData->extFunc);
     else if (regType == QQmlType::CppType)
-        setupExtendedMetaObject(extraData.cd->extMetaObject, extraData.cd->extFunc);
+        setupExtendedMetaObject(extraData.cppTypeData->extMetaObject, extraData.cppTypeData->extFunc);
 
     metaObjects.append(QQmlMetaType::proxyData(
             mo, baseMetaObject, metaObjects.isEmpty() ? nullptr
@@ -275,7 +280,7 @@ void QQmlTypePrivate::initEnums(QQmlEnginePrivate *engine) const
 void QQmlTypePrivate::insertEnums(const QMetaObject *metaObject) const
 {
     // Add any enum values defined by 'related' classes
-    if (regType != QQmlType::CppType || extraData.cd->registerEnumsFromRelatedTypes) {
+    if (regType != QQmlType::CppType || extraData.cppTypeData->registerEnumsFromRelatedTypes) {
         if (const auto *related = metaObject->d.relatedMetaObjects) {
             while (const QMetaObject *relatedMetaObject = *related) {
                 insertEnums(relatedMetaObject);
@@ -307,7 +312,7 @@ void QQmlTypePrivate::insertEnums(const QMetaObject *metaObject) const
         for (int jj = 0; jj < e.keyCount(); ++jj) {
             const QString key = QString::fromUtf8(e.key(jj));
             const int value = e.value(jj);
-            if (!isScoped || (regType == QQmlType::CppType && extraData.cd->registerEnumClassesUnscoped)) {
+            if (!isScoped || (regType == QQmlType::CppType && extraData.cppTypeData->registerEnumClassesUnscoped)) {
                 if (localEnums.contains(key)) {
                     auto existingEntry = enums.find(key);
                     if (existingEntry != enums.end() && existingEntry.value() != value) {
@@ -420,7 +425,7 @@ QByteArray QQmlType::typeName() const
 {
     if (d) {
         if (d->regType == SingletonType || d->regType == CompositeSingletonType)
-            return d->extraData.sd->singletonInstanceInfo->typeName.toUtf8();
+            return d->extraData.singletonTypeData->singletonInstanceInfo->typeName.toUtf8();
         else if (d->baseMetaObject)
             return d->baseMetaObject->className();
     }
@@ -472,11 +477,11 @@ QObject *QQmlType::create(void **memory, size_t additionalMemory) const
 
     d->init();
 
-    QObject *rv = (QObject *)operator new(d->extraData.cd->allocationSize + additionalMemory);
-    d->extraData.cd->newFunc(rv, d->extraData.cd->userdata);
+    QObject *rv = (QObject *)operator new(d->extraData.cppTypeData->allocationSize + additionalMemory);
+    d->extraData.cppTypeData->newFunc(rv, d->extraData.cppTypeData->userdata);
 
     createProxy(rv);
-    *memory = ((char *)rv) + d->extraData.cd->allocationSize;
+    *memory = ((char *)rv) + d->extraData.cppTypeData->allocationSize;
     return rv;
 }
 
@@ -504,7 +509,7 @@ QQmlType::SingletonInstanceInfo *QQmlType::singletonInstanceInfo() const
         return nullptr;
     if (d->regType != SingletonType && d->regType != CompositeSingletonType)
         return nullptr;
-    return d->extraData.sd->singletonInstanceInfo;
+    return d->extraData.singletonTypeData->singletonInstanceInfo;
 }
 
 QQmlCustomParser *QQmlType::customParser() const
@@ -513,47 +518,47 @@ QQmlCustomParser *QQmlType::customParser() const
         return nullptr;
     if (d->regType != CppType)
         return nullptr;
-    return d->extraData.cd->customParser;
+    return d->extraData.cppTypeData->customParser;
 }
 
 QQmlType::CreateValueTypeFunc QQmlType::createValueTypeFunction() const
 {
     if (!d || d->regType != CppType)
         return nullptr;
-    return d->extraData.cd->createValueTypeFunc;
+    return d->extraData.cppTypeData->createValueTypeFunc;
 }
 
 bool QQmlType::canConstructValueType() const
 {
     if (!d || d->regType != CppType)
         return false;
-    return d->extraData.cd->constructValueType;
+    return d->extraData.cppTypeData->constructValueType;
 }
 
 bool QQmlType::canPopulateValueType() const
 {
     if (!d || d->regType != CppType)
         return false;
-    return d->extraData.cd->populateValueType;
+    return d->extraData.cppTypeData->populateValueType;
 }
 
 QQmlType::CreateFunc QQmlType::createFunction() const
 {
     if (!d || d->regType != CppType)
         return nullptr;
-    return d->extraData.cd->newFunc;
+    return d->extraData.cppTypeData->newFunc;
 }
 
 QString QQmlType::noCreationReason() const
 {
     if (!d || d->regType != CppType)
         return QString();
-    return d->extraData.cd->noCreationReason;
+    return d->extraData.cppTypeData->noCreationReason;
 }
 
 bool QQmlType::isCreatable() const
 {
-    return d && d->regType == CppType && d->extraData.cd->newFunc;
+    return d && d->regType == CppType && d->extraData.cppTypeData->newFunc;
 }
 
 QQmlType::ExtensionFunc QQmlType::extensionFunction() const
@@ -563,9 +568,9 @@ QQmlType::ExtensionFunc QQmlType::extensionFunction() const
 
     switch (d->regType) {
     case CppType:
-        return d->extraData.cd->extFunc;
+        return d->extraData.cppTypeData->extFunc;
     case SingletonType:
-        return d->extraData.sd->extFunc;
+        return d->extraData.singletonTypeData->extFunc;
     default:
         return nullptr;
     }
@@ -578,9 +583,9 @@ const QMetaObject *QQmlType::extensionMetaObject() const
 
     switch (d->regType) {
     case CppType:
-        return d->extraData.cd->extMetaObject;
+        return d->extraData.cppTypeData->extMetaObject;
     case SingletonType:
-        return d->extraData.sd->extMetaObject;
+        return d->extraData.singletonTypeData->extMetaObject;
     default:
         return nullptr;
     }
@@ -621,12 +626,12 @@ bool QQmlType::isCompositeSingleton() const
 
 bool QQmlType::isQObjectSingleton() const
 {
-    return d && d->regType == SingletonType && d->extraData.sd->singletonInstanceInfo->qobjectCallback;
+    return d && d->regType == SingletonType && d->extraData.singletonTypeData->singletonInstanceInfo->qobjectCallback;
 }
 
 bool QQmlType::isQJSValueSingleton() const
 {
-    return d && d->regType == SingletonType && d->extraData.sd->singletonInstanceInfo->scriptCallback;
+    return d && d->regType == SingletonType && d->extraData.singletonTypeData->singletonInstanceInfo->scriptCallback;
 }
 
 bool QQmlType::isSequentialContainer() const
@@ -646,7 +651,7 @@ QMetaType QQmlType::qListTypeId() const
 
 QMetaSequence QQmlType::listMetaSequence() const
 {
-    return isSequentialContainer() ? *d->extraData.ld : QMetaSequence();
+    return isSequentialContainer() ? d->extraData.sequentialContainerTypeData : QMetaSequence();
 }
 
 const QMetaObject *QQmlType::metaObject() const
@@ -684,14 +689,14 @@ QTypeRevision QQmlType::metaObjectRevision() const
 QQmlAttachedPropertiesFunc QQmlType::attachedPropertiesFunction(QQmlEnginePrivate *engine) const
 {
     if (const QQmlTypePrivate *base = d ? d->attachedPropertiesBase(engine) : nullptr)
-        return base->extraData.cd->attachedPropertiesFunc;
+        return base->extraData.cppTypeData->attachedPropertiesFunc;
     return nullptr;
 }
 
 const QMetaObject *QQmlType::attachedPropertiesType(QQmlEnginePrivate *engine) const
 {
     if (const QQmlTypePrivate *base = d ? d->attachedPropertiesBase(engine) : nullptr)
-        return base->extraData.cd->attachedPropertiesType;
+        return base->extraData.cppTypeData->attachedPropertiesType;
     return nullptr;
 }
 
@@ -699,35 +704,35 @@ int QQmlType::parserStatusCast() const
 {
     if (!d || d->regType != CppType)
         return -1;
-    return d->extraData.cd->parserStatusCast;
+    return d->extraData.cppTypeData->parserStatusCast;
 }
 
 int QQmlType::propertyValueSourceCast() const
 {
     if (!d || d->regType != CppType)
         return -1;
-    return d->extraData.cd->propertyValueSourceCast;
+    return d->extraData.cppTypeData->propertyValueSourceCast;
 }
 
 int QQmlType::propertyValueInterceptorCast() const
 {
     if (!d || d->regType != CppType)
         return -1;
-    return d->extraData.cd->propertyValueInterceptorCast;
+    return d->extraData.cppTypeData->propertyValueInterceptorCast;
 }
 
 int QQmlType::finalizerCast() const
 {
     if (!d || d->regType != CppType)
         return -1;
-    return d->extraData.cd->finalizerCast;
+    return d->extraData.cppTypeData->finalizerCast;
 }
 
 const char *QQmlType::interfaceIId() const
 {
     if (!d || d->regType != InterfaceType)
         return nullptr;
-    return d->iid;
+    return d->extraData.interfaceTypeData;
 }
 
 int QQmlType::index() const
diff --git a/src/qml/qml/qqmltype_p_p.h b/src/qml/qml/qqmltype_p_p.h
index 73567b5a22..c15a9d42ca 100644
--- a/src/qml/qml/qqmltype_p_p.h
+++ b/src/qml/qml/qqmltype_p_p.h
@@ -41,11 +41,11 @@ public:
     {
         switch (regType) {
         case QQmlType::CompositeType:
-            return extraData.fd->url;
+            return extraData.compositeTypeData;
         case QQmlType::CompositeSingletonType:
-            return extraData.sd->singletonInstanceInfo->url;
+            return extraData.singletonTypeData->singletonInstanceInfo->url;
         case QQmlType::InlineComponentType:
-            return extraData.id->url;
+            return extraData.inlineComponentTypeData;
         default:
             return QUrl();
         }
@@ -55,7 +55,7 @@ public:
     {
         for (const QQmlTypePrivate *d = this; d; d = d->resolveCompositeBaseType(engine).d.data()) {
             if (d->regType == QQmlType::CppType)
-                return d->extraData.cd->attachedPropertiesType ? d : nullptr;
+                return d->extraData.cppTypeData->attachedPropertiesType ? d : nullptr;
 
             if (d->regType != QQmlType::CompositeType)
                 return nullptr;
@@ -71,8 +71,6 @@ public:
     QQmlType resolveCompositeBaseType(QQmlEnginePrivate *engine) const;
     QQmlPropertyCache::ConstPtr compositePropertyCache(QQmlEnginePrivate *engine) const;
 
-    QQmlType::RegistrationType regType;
-
     struct QQmlCppTypeData
     {
         int allocationSize;
@@ -102,38 +100,31 @@ public:
         const QMetaObject *extMetaObject;
     };
 
-    struct QQmlCompositeTypeData
-    {
-        QUrl url;
-    };
-
-    struct QQmlInlineTypeData
-    {
-        QUrl url;
-    };
-
-    using QQmlSequenceTypeData = QMetaSequence;
-
     union extraData {
-        QQmlCppTypeData* cd;
-        QQmlSingletonTypeData* sd;
-        QQmlCompositeTypeData* fd;
-        QQmlInlineTypeData* id;
-        QQmlSequenceTypeData* ld;
+        extraData() {}  // QQmlTypePrivate() does the actual construction.
+        ~extraData() {} // ~QQmlTypePrivate() does the actual destruction.
+
+        QQmlCppTypeData *cppTypeData;
+        QQmlSingletonTypeData *singletonTypeData;
+        QUrl compositeTypeData;
+        QUrl inlineComponentTypeData;
+        QMetaSequence sequentialContainerTypeData;
+        const char *interfaceTypeData;
     } extraData;
+    static_assert(sizeof(extraData) == sizeof(void *));
 
-    const char *iid;
     QHashedString module;
     QString name;
     QString elementName;
     QMetaType typeId;
     QMetaType listId;
+    QQmlType::RegistrationType regType;
     QTypeRevision version;
     QTypeRevision revision;
-    mutable bool containsRevisionedAttributes;
     const QMetaObject *baseMetaObject;
 
     int index;
+    mutable bool containsRevisionedAttributes;
     mutable QAtomicInteger<bool> isSetup;
     mutable QAtomicInteger<bool> isEnumFromCacheSetup;
     mutable QAtomicInteger<bool> isEnumFromBaseSetup;
diff --git a/src/qml/qmltc/qqmltcobjectcreationhelper.cpp b/src/qml/qmltc/qqmltcobjectcreationhelper.cpp
index db8517ca70..693277f0f1 100644
--- a/src/qml/qmltc/qqmltcobjectcreationhelper.cpp
+++ b/src/qml/qmltc/qqmltcobjectcreationhelper.cpp
@@ -26,23 +26,23 @@ void qmltcCreateDynamicMetaObject(QObject *object, const QmltcTypeData &data)
 
     // initialize QQmlType::QQmlCppTypeData
     Q_ASSERT(data.regType == QQmlType::CppType);
-    qmlTypePrivate->extraData.cd->allocationSize = data.allocationSize;
-    qmlTypePrivate->extraData.cd->newFunc = nullptr;
-    qmlTypePrivate->extraData.cd->userdata = nullptr;
-    qmlTypePrivate->extraData.cd->noCreationReason =
+    qmlTypePrivate->extraData.cppTypeData->allocationSize = data.allocationSize;
+    qmlTypePrivate->extraData.cppTypeData->newFunc = nullptr;
+    qmlTypePrivate->extraData.cppTypeData->userdata = nullptr;
+    qmlTypePrivate->extraData.cppTypeData->noCreationReason =
             QStringLiteral("Qmltc-compiled type is not creatable via QQmlType");
-    qmlTypePrivate->extraData.cd->createValueTypeFunc = nullptr;
-    qmlTypePrivate->extraData.cd->parserStatusCast = -1;
-    qmlTypePrivate->extraData.cd->extFunc = nullptr;
-    qmlTypePrivate->extraData.cd->extMetaObject = nullptr;
-    qmlTypePrivate->extraData.cd->customParser = nullptr;
-    qmlTypePrivate->extraData.cd->attachedPropertiesFunc = nullptr;
-    qmlTypePrivate->extraData.cd->attachedPropertiesType = nullptr;
-    qmlTypePrivate->extraData.cd->propertyValueSourceCast = -1;
-    qmlTypePrivate->extraData.cd->propertyValueInterceptorCast = -1;
-    qmlTypePrivate->extraData.cd->finalizerCast = -1;
-    qmlTypePrivate->extraData.cd->registerEnumClassesUnscoped = false;
-    qmlTypePrivate->extraData.cd->registerEnumsFromRelatedTypes = false;
+    qmlTypePrivate->extraData.cppTypeData->createValueTypeFunc = nullptr;
+    qmlTypePrivate->extraData.cppTypeData->parserStatusCast = -1;
+    qmlTypePrivate->extraData.cppTypeData->extFunc = nullptr;
+    qmlTypePrivate->extraData.cppTypeData->extMetaObject = nullptr;
+    qmlTypePrivate->extraData.cppTypeData->customParser = nullptr;
+    qmlTypePrivate->extraData.cppTypeData->attachedPropertiesFunc = nullptr;
+    qmlTypePrivate->extraData.cppTypeData->attachedPropertiesType = nullptr;
+    qmlTypePrivate->extraData.cppTypeData->propertyValueSourceCast = -1;
+    qmlTypePrivate->extraData.cppTypeData->propertyValueInterceptorCast = -1;
+    qmlTypePrivate->extraData.cppTypeData->finalizerCast = -1;
+    qmlTypePrivate->extraData.cppTypeData->registerEnumClassesUnscoped = false;
+    qmlTypePrivate->extraData.cppTypeData->registerEnumsFromRelatedTypes = false;
 
     qmlTypePrivate->baseMetaObject = data.metaObject;
     qmlTypePrivate->init();