QQmlMetaType: Remove qmlLists member

Instead of using a hashmap which maps a QML lists metatype to its list element's metatype, we can just store a pointer in the list metatype to the element metatype. Moreover, listType now returns a metatype. This is a preparation for converting enginePriv->rawMetaObjectForType(typeId) to metaType.metaObject() calls once we can actually retrieve the metaobject from QML metatypes. The QML metatype interface classes are moved into a header, so that Qt for Python can use the same classes. This does not affect types registered from C++, as those use a different mechanism. Task-number: QTBUG-88766 Task-number: QTBUG-82931 Task-number: QTBUG-87134 Change-Id: I330c2bbe4ac92072a333c001750f7504b56df478 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
author: Fabian Kosmale <fabian.kosmale@qt.io> 2021-03-05 13:20:05 +0100
committer: Fabian Kosmale <fabian.kosmale@qt.io> 2021-03-19 21:03:34 +0100
commit: 2afb055609dedb79f232b32f704cce33ffd5778d (patch)
tree: f278287299f374bc6390b034dcac984dad4b673e /src
parent: 0c066168bbbd230abe875727b2000d6828b03f23 (diff)
14 files changed, 121 insertions, 99 deletions
diff --git a/src/plugins/qmltooling/qmldbg_debugger/qqmlenginedebugservice.cpp b/src/plugins/qmltooling/qmldbg_debugger/qqmlenginedebugservice.cpp
index 962245fa4c..812c48b72e 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qqmlenginedebugservice.cpp
+++ b/src/plugins/qmltooling/qmldbg_debugger/qqmlenginedebugservice.cpp
@@ -198,7 +198,7 @@ QQmlEngineDebugServiceImpl::propertyData(QObject *obj, int propIdx)
 
     if (prop.metaType().flags().testFlag(QMetaType::PointerToQObject))  {
         rv.type = QQmlObjectProperty::Object;
-    } else if (QQmlMetaType::isList(prop.userType())) {
+    } else if (QQmlMetaType::isList(prop.metaType())) {
         rv.type = QQmlObjectProperty::List;
     } else if (prop.userType() == QMetaType::QVariant) {
         rv.type = QQmlObjectProperty::Variant;
diff --git a/src/qml/jsruntime/qv4qmlcontext.cpp b/src/qml/jsruntime/qv4qmlcontext.cpp
index 5581ea9a53..18d611f2c3 100644
--- a/src/qml/jsruntime/qv4qmlcontext.cpp
+++ b/src/qml/jsruntime/qv4qmlcontext.cpp
@@ -126,7 +126,7 @@ static OptionalReturnedValue searchContextProperties(
         QQmlListProperty<QObject> prop(context->asQQmlContext(), (void*) qintptr(propertyIdx),
                                        QQmlContextPrivate::context_count,
                                        QQmlContextPrivate::context_at);
-        return OptionalReturnedValue(QmlListWrapper::create(v4, prop, qMetaTypeId<QQmlListProperty<QObject> >()));
+        return OptionalReturnedValue(QmlListWrapper::create(v4, prop, QMetaType::fromType<QQmlListProperty<QObject> >()));
     }
     return OptionalReturnedValue(v4->fromVariant(cp->propertyValue(propertyIdx)));
 }
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index c43a4bfe25..25d92596c9 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -151,7 +151,7 @@ static QV4::ReturnedValue loadProperty(QV4::ExecutionEngine *v4, QObject *object
         return ret;
 
     } else if (property.isQList()) {
-        return QmlListWrapper::create(v4, object, property.coreIndex(), property.propType().id());
+        return QmlListWrapper::create(v4, object, property.coreIndex(), property.propType());
     } else if (propType == QMetaType::QReal) {
         qreal v = 0;
         property.readProperty(object, &v);
diff --git a/src/qml/qml/qqmllist.cpp b/src/qml/qml/qqmllist.cpp
index 0aecc51e85..3d15eba4ca 100644
--- a/src/qml/qml/qqmllist.cpp
+++ b/src/qml/qml/qqmllist.cpp
@@ -59,7 +59,7 @@ QQmlListReferencePrivate::QQmlListReferencePrivate()
 {
 }
 
-QQmlListReference QQmlListReferencePrivate::init(const QQmlListProperty<QObject> &prop, int propType, QQmlEngine *engine)
+QQmlListReference QQmlListReferencePrivate::init(const QQmlListProperty<QObject> &prop, QMetaType propType, QQmlEngine *engine)
 {
     QQmlListReference rv;
 
@@ -145,7 +145,7 @@ QQmlListReference::QQmlListReference(const QVariant &variant, QQmlEngine *engine
         return;
 
     d = new QQmlListReferencePrivate;
-    d->propertyType = t.id();
+    d->propertyType = t;
     d->setEngine(engine);
 
     d->property.~QQmlListProperty();
@@ -177,7 +177,7 @@ QQmlListReference::QQmlListReference(QObject *object, const char *property, QQml
 
     d = new QQmlListReferencePrivate;
     d->object = object;
-    d->propertyType = data->propType().id();
+    d->propertyType = data->propType();
     d->setEngine(engine);
 
     void *args[] = { &d->property, nullptr };
diff --git a/src/qml/qml/qqmllist_p.h b/src/qml/qml/qqmllist_p.h
index 022bed977e..8ce3c04abb 100644
--- a/src/qml/qml/qqmllist_p.h
+++ b/src/qml/qml/qqmllist_p.h
@@ -63,11 +63,11 @@ class QQmlListReferencePrivate
 public:
     QQmlListReferencePrivate();
 
-    static QQmlListReference init(const QQmlListProperty<QObject> &, int, QQmlEngine *);
+    static QQmlListReference init(const QQmlListProperty<QObject> &, QMetaType, QQmlEngine *);
 
     QPointer<QObject> object;
     QQmlListProperty<QObject> property;
-    int propertyType;
+    QMetaType propertyType;
 
     void addref();
     void release();
@@ -85,7 +85,7 @@ public:
     const QMetaObject *elementType()
     {
         if (m_elementTypeOrEngine.isT2()) {
-            const int listType = QQmlMetaType::listType(propertyType);
+            const int listType = QQmlMetaType::listType(propertyType).id();
             const QQmlEngine *engine = m_elementTypeOrEngine.asT2();
             const QQmlEnginePrivate *p = engine ? QQmlEnginePrivate::get(engine) : nullptr;
             m_elementTypeOrEngine = p ? p->rawMetaObjectForType(listType).metaObject()
diff --git a/src/qml/qml/qqmllistwrapper.cpp b/src/qml/qml/qqmllistwrapper.cpp
index e5c1cb04a9..f69bc50259 100644
--- a/src/qml/qml/qqmllistwrapper.cpp
+++ b/src/qml/qml/qqmllistwrapper.cpp
@@ -66,7 +66,7 @@ void Heap::QmlListWrapper::destroy()
     Object::destroy();
 }
 
-ReturnedValue QmlListWrapper::create(ExecutionEngine *engine, QObject *object, int propId, int propType)
+ReturnedValue QmlListWrapper::create(ExecutionEngine *engine, QObject *object, int propId, QMetaType propType)
 {
     if (!object || propId == -1)
         return Encode::null();
@@ -75,20 +75,20 @@ ReturnedValue QmlListWrapper::create(ExecutionEngine *engine, QObject *object, i
 
     Scoped<QmlListWrapper> r(scope, engine->memoryManager->allocate<QmlListWrapper>());
     r->d()->object = object;
-    r->d()->propertyType = propType;
+    r->d()->propertyType = propType.iface();
     void *args[] = { &r->d()->property(), nullptr };
     QMetaObject::metacall(object, QMetaObject::ReadProperty, propId, args);
     return r.asReturnedValue();
 }
 
-ReturnedValue QmlListWrapper::create(ExecutionEngine *engine, const QQmlListProperty<QObject> &prop, int propType)
+ReturnedValue QmlListWrapper::create(ExecutionEngine *engine, const QQmlListProperty<QObject> &prop, QMetaType propType)
 {
     Scope scope(engine);
 
     Scoped<QmlListWrapper> r(scope, engine->memoryManager->allocate<QmlListWrapper>());
     r->d()->object = prop.object;
     r->d()->property() = prop;
-    r->d()->propertyType = propType;
+    r->d()->propertyType = propType.iface();
     return r.asReturnedValue();
 }
 
@@ -97,7 +97,7 @@ QVariant QmlListWrapper::toVariant() const
     if (!d()->object)
         return QVariant();
 
-    return QVariant::fromValue(QQmlListReferencePrivate::init(d()->property(), d()->propertyType, engine()->qmlEngine()));
+    return QVariant::fromValue(QQmlListReferencePrivate::init(d()->property(), QMetaType(d()->propertyType), engine()->qmlEngine()));
 }
 
 
diff --git a/src/qml/qml/qqmllistwrapper_p.h b/src/qml/qml/qqmllistwrapper_p.h
index 26a5023e6b..0e53b73bb8 100644
--- a/src/qml/qml/qqmllistwrapper_p.h
+++ b/src/qml/qml/qqmllistwrapper_p.h
@@ -74,7 +74,8 @@ struct QmlListWrapper : Object {
         return *reinterpret_cast<QQmlListProperty<QObject>*>(propertyData);
     }
 
-    int propertyType;
+    // interface instead of QMetaType to keep class a POD
+    const QtPrivate::QMetaTypeInterface *propertyType;
 
 private:
     void *propertyData[sizeof(QQmlListProperty<QObject>)/sizeof(void*)];
@@ -88,8 +89,8 @@ struct Q_QML_EXPORT QmlListWrapper : Object
     V4_NEEDS_DESTROY
     V4_PROTOTYPE(propertyListPrototype)
 
-    static ReturnedValue create(ExecutionEngine *engine, QObject *object, int propId, int propType);
-    static ReturnedValue create(ExecutionEngine *engine, const QQmlListProperty<QObject> &prop, int propType);
+    static ReturnedValue create(ExecutionEngine *engine, QObject *object, int propId, QMetaType propType);
+    static ReturnedValue create(ExecutionEngine *engine, const QQmlListProperty<QObject> &prop, QMetaType propType);
 
     QVariant toVariant() const;
 
diff --git a/src/qml/qml/qqmlmetatype.cpp b/src/qml/qml/qqmlmetatype.cpp
index 71abce89b1..a37dde064f 100644
--- a/src/qml/qml/qqmlmetatype.cpp
+++ b/src/qml/qml/qqmlmetatype.cpp
@@ -325,17 +325,6 @@ bool QQmlMetaType::qmlRegisterModuleTypes(const QString &uri)
     return data->registerModuleTypes(uri);
 }
 
-/*!
-   \internal
-    Method is only used to in tst_qqmlenginecleanup.cpp to test whether all
-    types have been removed from qmlLists after shutdown of QQmlEngine
- */
-int QQmlMetaType::qmlRegisteredListTypeCount()
-{
-    QQmlMetaTypeDataPtr data;
-    return data->qmlLists.count();
-}
-
 void QQmlMetaType::clearTypeRegistrations()
 {
     //Only cleans global static, assumed no running engine
@@ -583,51 +572,13 @@ QQmlType QQmlMetaType::registerCompositeType(const QQmlPrivate::RegisterComposit
     return QQmlType(priv);
 }
 
-
-
-struct QQmlMetaTypeInterface : QtPrivate::QMetaTypeInterface
-{
-    const QByteArray name;
-    template <typename T>
-    QQmlMetaTypeInterface(const QByteArray &name, T *)
-        : QMetaTypeInterface {
-            /*.revision=*/ 0,
-            /*.alignment=*/ alignof(T),
-            /*.size=*/ sizeof(T),
-            /*.flags=*/ QtPrivate::QMetaTypeTypeFlags<T>::Flags,
-            /*.typeId=*/ 0,
-            /*.metaObject=*/ nullptr,//QtPrivate::MetaObjectForType<T>::value(),
-            /*.name=*/ name.constData(),
-            /*.defaultCtr=*/ [](const QMetaTypeInterface *, void *addr) { new (addr) T(); },
-            /*.copyCtr=*/ [](const QMetaTypeInterface *, void *addr, const void *other) {
-                    new (addr) T(*reinterpret_cast<const T *>(other));
-                },
-            /*.moveCtr=*/ [](const QMetaTypeInterface *, void *addr, void *other) {
-                    new (addr) T(std::move(*reinterpret_cast<T *>(other)));
-                },
-            /*.dtor=*/ [](const QMetaTypeInterface *, void *addr) {
-                reinterpret_cast<T *>(addr)->~T();
-            },
-            /*.equals*/ nullptr,
-            /*.lessThan*/ nullptr,
-            /*.debugStream=*/ nullptr,
-            /*.dataStreamOut=*/ nullptr,
-            /*.dataStreamIn=*/ nullptr,
-            /*.legacyRegisterOp=*/ nullptr
-        }
-        , name(name) { }
-};
-
 CompositeMetaTypeIds QQmlMetaType::registerInternalCompositeType(const QByteArray &className)
 {
     QByteArray ptr = className + '*';
     QByteArray lst = "QQmlListProperty<" + className + '>';
 
     QMetaType ptr_type(new QQmlMetaTypeInterface(ptr, (QObject **)nullptr));
-    QMetaType lst_type(new QQmlMetaTypeInterface(lst, (QQmlListProperty<QObject> *)nullptr));
-
-    QQmlMetaTypeDataPtr data;
-    data->qmlLists.insert(lst_type.id(), ptr_type.id());
+    QMetaType lst_type(new QQmlListMetaTypeInterface(lst, (QQmlListProperty<QObject> *)nullptr, ptr_type.iface()));
 
     return {ptr_type, lst_type};
 }
@@ -644,11 +595,10 @@ void QQmlMetaType::unregisterInternalCompositeType(const CompositeMetaTypeIds &t
     if (QQmlValueType *vt = data->metaTypeToValueType.take(listMetaType.id()))
         delete vt;
 
-    data->qmlLists.remove(listMetaType.id());
     QMetaType::unregisterMetaType(metaType);
     QMetaType::unregisterMetaType(listMetaType);
     delete static_cast<const QQmlMetaTypeInterface *>(metaType.iface());
-    delete static_cast<const QQmlMetaTypeInterface *>(listMetaType.iface());
+    delete static_cast<const QQmlListMetaTypeInterface *>(listMetaType.iface());
 }
 
 int QQmlMetaType::registerUnitCacheHook(
@@ -1102,17 +1052,20 @@ QObject *QQmlMetaType::toQObject(const QVariant &v, bool *ok)
 /*
     Returns the item type for a list of type \a id.
  */
-int QQmlMetaType::listType(int id)
-{
+QMetaType QQmlMetaType::listType(QMetaType metaType)
+{
+    if (!isList(metaType))
+        return QMetaType {};
+    const auto iface = metaType.iface();
+    if (iface->metaObjectFn == &dynamicQmlListMarker)
+        return QMetaType(static_cast<const QQmlListMetaTypeInterface *>(iface)->valueType);
+    auto id = metaType.id();
     QQmlMetaTypeDataPtr data;
-    QHash<int, int>::ConstIterator iter = data->qmlLists.constFind(id);
-    if (iter != data->qmlLists.cend())
-        return *iter;
     QQmlTypePrivate *type = data->idToType.value(id);
     if (type && type->listId.id() == id)
-        return type->typeId.id();
+        return type->typeId;
     else
-        return 0;
+        return QMetaType {};
 }
 
 QQmlAttachedPropertiesFunc QQmlMetaType::attachedPropertiesFunc(QQmlEnginePrivate *engine,
@@ -1201,15 +1154,12 @@ const char *QQmlMetaType::interfaceIId(int userType)
         return nullptr;
 }
 
-bool QQmlMetaType::isList(int userType)
+bool QQmlMetaType::isList(QMetaType type)
 {
-    QMetaType type(userType);
     if (type.flags().testFlag(QMetaType::IsQmlList))
         return true;
-    QQmlMetaTypeDataPtr data;
-    if (data->qmlLists.contains(userType))
-        return true;
-    return false;
+    else
+        return false;
 }
 
 /*!
diff --git a/src/qml/qml/qqmlmetatype_p.h b/src/qml/qml/qqmlmetatype_p.h
index d1735902f5..ac16ce9c2a 100644
--- a/src/qml/qml/qqmlmetatype_p.h
+++ b/src/qml/qml/qqmlmetatype_p.h
@@ -189,12 +189,12 @@ public:
 
     static QObject *toQObject(const QVariant &, bool *ok = nullptr);
 
-    static int listType(int);
+    static QMetaType listType(QMetaType type);
     static QQmlAttachedPropertiesFunc attachedPropertiesFunc(QQmlEnginePrivate *,
                                                              const QMetaObject *);
     static bool isInterface(int);
     static const char *interfaceIId(int);
-    static bool isList(int);
+    static bool isList(QMetaType type);
 
     typedef QVariant (*StringConverter)(const QString &);
     static void registerCustomStringConverter(int, StringConverter);
@@ -257,8 +257,6 @@ public:
 
     static bool qmlRegisterModuleTypes(const QString &uri);
 
-    static int qmlRegisteredListTypeCount();
-
     static bool isValueType(QMetaType type);
     static QQmlValueType *valueType(QMetaType metaType);
     static const QMetaObject *metaObjectForMetaType(QMetaType type);
@@ -266,6 +264,81 @@ public:
 
 Q_DECLARE_TYPEINFO(QQmlMetaType, Q_RELOCATABLE_TYPE);
 
+// used in QQmlListMetaType to tag the metatpye
+inline const QMetaObject *dynamicQmlListMarker(const QtPrivate::QMetaTypeInterface *) {
+    return nullptr;
+};
+
+// metatype interface for composite QML types
+struct QQmlMetaTypeInterface : QtPrivate::QMetaTypeInterface
+{
+    const QByteArray name;
+    template <typename T>
+    QQmlMetaTypeInterface(const QByteArray &name, T *)
+        : QMetaTypeInterface {
+            /*.revision=*/ 0,
+            /*.alignment=*/ alignof(T),
+            /*.size=*/ sizeof(T),
+            /*.flags=*/ QtPrivate::QMetaTypeTypeFlags<T>::Flags,
+            /*.typeId=*/ 0,
+            /*.metaObject=*/ nullptr,//QtPrivate::MetaObjectForType<T>::value(),
+            /*.name=*/ name.constData(),
+            /*.defaultCtr=*/ [](const QMetaTypeInterface *, void *addr) { new (addr) T(); },
+            /*.copyCtr=*/ [](const QMetaTypeInterface *, void *addr, const void *other) {
+                    new (addr) T(*reinterpret_cast<const T *>(other));
+                },
+            /*.moveCtr=*/ [](const QMetaTypeInterface *, void *addr, void *other) {
+                    new (addr) T(std::move(*reinterpret_cast<T *>(other)));
+                },
+            /*.dtor=*/ [](const QMetaTypeInterface *, void *addr) {
+                reinterpret_cast<T *>(addr)->~T();
+            },
+            /*.equals*/ nullptr,
+            /*.lessThan*/ nullptr,
+            /*.debugStream=*/ nullptr,
+            /*.dataStreamOut=*/ nullptr,
+            /*.dataStreamIn=*/ nullptr,
+            /*.legacyRegisterOp=*/ nullptr
+        }
+        , name(name) { }
+};
+
+// metatype for qml list types
+struct QQmlListMetaTypeInterface : QtPrivate::QMetaTypeInterface
+{
+    const QByteArray name;
+    // if this interface is for list<type>; valueType stores the interface for type
+    const QtPrivate::QMetaTypeInterface *valueType;
+    template<typename T>
+    QQmlListMetaTypeInterface(const QByteArray &name, T *, const QtPrivate::QMetaTypeInterface * valueType)
+        : QMetaTypeInterface {
+            /*.revision=*/ 0,
+            /*.alignment=*/ alignof(T),
+            /*.size=*/ sizeof(T),
+            /*.flags=*/ QtPrivate::QMetaTypeTypeFlags<T>::Flags,
+            /*.typeId=*/ 0,
+            /*.metaObjectFn=*/ &dynamicQmlListMarker,
+            /*.name=*/ name.constData(),
+            /*.defaultCtr=*/ [](const QMetaTypeInterface *, void *addr) { new (addr) T(); },
+            /*.copyCtr=*/ [](const QMetaTypeInterface *, void *addr, const void *other) {
+                    new (addr) T(*reinterpret_cast<const T *>(other));
+                },
+            /*.moveCtr=*/ [](const QMetaTypeInterface *, void *addr, void *other) {
+                    new (addr) T(std::move(*reinterpret_cast<T *>(other)));
+                },
+            /*.dtor=*/ [](const QMetaTypeInterface *, void *addr) {
+                reinterpret_cast<T *>(addr)->~T();
+            },
+            /*.equals*/ nullptr,
+            /*.lessThan*/ nullptr,
+            /*.debugStream=*/ nullptr,
+            /*.dataStreamOut=*/ nullptr,
+            /*.dataStreamIn=*/ nullptr,
+            /*.legacyRegisterOp=*/ nullptr
+        }
+        , name(name), valueType(valueType) { }
+};
+
 QT_END_NAMESPACE
 
 #endif // QQMLMETATYPE_P_H
diff --git a/src/qml/qml/qqmlmetatypedata_p.h b/src/qml/qml/qqmlmetatypedata_p.h
index 9719ec1bb4..c4608a7997 100644
--- a/src/qml/qml/qqmlmetatypedata_p.h
+++ b/src/qml/qml/qqmlmetatypedata_p.h
@@ -131,8 +131,6 @@ struct QQmlMetaTypeData
     QList<QQmlPrivate::AutoParentFunction> parentFunctions;
     QVector<QQmlPrivate::QmlUnitCacheLookupFunction> lookupCachedQmlUnit;
 
-    QHash<int, int> qmlLists;
-
     QHash<const QMetaObject *, QQmlPropertyCache *> propertyCaches;
 
     QQmlPropertyCache *propertyCacheForVersion(int index, QTypeRevision version) const;
diff --git a/src/qml/qml/qqmlobjectcreator.cpp b/src/qml/qml/qqmlobjectcreator.cpp
index 10b1304b67..058888bcd0 100644
--- a/src/qml/qml/qqmlobjectcreator.cpp
+++ b/src/qml/qml/qqmlobjectcreator.cpp
@@ -1106,12 +1106,12 @@ bool QQmlObjectCreator::setPropertyBinding(const QQmlPropertyData *bindingProper
 
             void *itemToAdd = createdSubObject;
 
-            const char *iid = nullptr;
-            int listItemType = QQmlMetaType::listType(bindingProperty->propType().id());
-            if (listItemType != -1)
-                iid = QQmlMetaType::interfaceIId(listItemType);
-            if (iid)
-                itemToAdd = createdSubObject->qt_metacast(iid);
+            QMetaType listItemType = QQmlMetaType::listType(bindingProperty->propType());
+            if (listItemType.isValid()) {
+                const char *iid = QQmlMetaType::interfaceIId(listItemType.id());
+                if (iid)
+                    itemToAdd = createdSubObject->qt_metacast(iid);
+            }
 
             if (_currentList.append)
                 _currentList.append(&_currentList, itemToAdd);
diff --git a/src/qml/qml/qqmlproperty.cpp b/src/qml/qml/qqmlproperty.cpp
index af5d916c68..28aef9c1fd 100644
--- a/src/qml/qml/qqmlproperty.cpp
+++ b/src/qml/qml/qqmlproperty.cpp
@@ -1102,7 +1102,7 @@ QVariant QQmlPropertyPrivate::readValueProperty()
 
         QQmlListProperty<QObject> prop;
         core.readProperty(object, &prop);
-        return QVariant::fromValue(QQmlListReferencePrivate::init(prop, core.propType().id(), engine));
+        return QVariant::fromValue(QQmlListReferencePrivate::init(prop, core.propType(), engine));
 
     } else if (core.isQObject()) {
 
@@ -1352,9 +1352,9 @@ bool QQmlPropertyPrivate::write(
         QQmlMetaObject listType;
 
         if (enginePriv) {
-            listType = enginePriv->rawMetaObjectForType(QQmlMetaType::listType(propertyType));
+            listType = enginePriv->rawMetaObjectForType(QQmlMetaType::listType(propertyMetaType).id());
         } else {
-            QQmlType type = QQmlMetaType::qmlType(QQmlMetaType::listType(propertyType));
+            QQmlType type = QQmlMetaType::qmlType(QQmlMetaType::listType(propertyMetaType).id());
             if (!type.isValid())
                 return false;
             listType = type.baseMetaObject();
diff --git a/src/qml/qml/qqmlpropertyvalidator.cpp b/src/qml/qml/qqmlpropertyvalidator.cpp
index 7aeef30d9d..c1a8694a59 100644
--- a/src/qml/qml/qqmlpropertyvalidator.cpp
+++ b/src/qml/qml/qqmlpropertyvalidator.cpp
@@ -734,7 +734,7 @@ QQmlError QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *propert
         // We can convert everything to QVariant :)
         return noError;
     } else if (property->isQList()) {
-        const int listType = QQmlMetaType::listType(propType);
+        const int listType = QQmlMetaType::listType(property->propType()).id();
         if (!QQmlMetaType::isInterface(listType)) {
             QQmlPropertyCache *source = propertyCaches.at(binding->value.objectIndex);
             if (!canCoerce(listType, source)) {
diff --git a/src/quick/designer/qquickdesignersupportitems.cpp b/src/quick/designer/qquickdesignersupportitems.cpp
index 987e8fd922..862b57f2b7 100644
--- a/src/quick/designer/qquickdesignersupportitems.cpp
+++ b/src/quick/designer/qquickdesignersupportitems.cpp
@@ -125,7 +125,7 @@ static void allSubObjects(QObject *object, QObjectList &objectList)
 
         // search recursive in property object lists
         if (metaProperty.isReadable()
-                && QQmlMetaType::isList(metaProperty.userType())) {
+                && QQmlMetaType::isList(metaProperty.metaType())) {
             QQmlListReference list(object, metaProperty.name());
             if (list.canCount() && list.canAt()) {
                 for (qsizetype i = 0; i < list.count(); i++) {
author	Fabian Kosmale <fabian.kosmale@qt.io>	2021-03-05 13:20:05 +0100
committer	Fabian Kosmale <fabian.kosmale@qt.io>	2021-03-19 21:03:34 +0100
commit	2afb055609dedb79f232b32f704cce33ffd5778d (patch)
tree	f278287299f374bc6390b034dcac984dad4b673e /src
parent	0c066168bbbd230abe875727b2000d6828b03f23 (diff)