Replace QSequentialIterable with QMetaSequence::Iterable

QSequentialIterable is deprecated.

Task-number: QTBUG-140181
Change-Id: I797c18fa5c319e5c1a0114448d98a38aad33ae04
Reviewed-by: Olivier De Cannière <[email protected]>

11 files changed, 58 insertions, 57 deletions

diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 2478dcb137..59d2d6c7fa 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -82,7 +82,7 @@
 #include <QtCore/qiterable.h>
 #include <QtCore/qloggingcategory.h>
 #include <QtCore/qmetatype.h>
-#include <QtCore/qsequentialiterable.h>
+#include <QtCore/qmetasequence.h>
 #include <QtCore/qtextstream.h>
 #include <QtCore/qtimezone.h>
 
@@ -150,7 +150,7 @@ void createNewIteratorIfNonExisting(void **iterator) {
 
 static QtMetaContainerPrivate::QMetaSequenceInterface emptySequenceInterface()
 {
-    // set up some functions so that non-array QSequentialIterables do not crash
+    // set up some functions so that non-array QMetaSequence::Iterables do not crash
     // but instead appear as an empty sequence
 
     using namespace QtMetaContainerPrivate;
@@ -195,7 +195,7 @@ static QtMetaContainerPrivate::QMetaSequenceInterface sequenceInterface()
     /* Lifetime management notes:
      * valueAtIndexFn and valueAtIteratorFn return a pointer to a JSValue allocated via
      * QMetaType::create Because we set QVariantConstructionFlags::ShouldDeleteVariantData,
-     * QSequentialIterable::at and QSequentialIterable::operator*() will free that memory
+     * QMetaSequence::Iterable::at and QMetaSequence::Iterable::operator*() will free that memory
      */
 
     iface.valueAtIndexFn = [](const void *iterable, qsizetype index, void *dataPtr) -> void {
@@ -295,18 +295,18 @@ static QtMetaContainerPrivate::QMetaSequenceInterface sequenceInterface()
     return iface;
 }
 
-static QSequentialIterable jsvalueToSequence (const QJSValue& value) {
+static QMetaSequence::Iterable jsvalueToSequence (const QJSValue& value) {
     using namespace QtMetaTypePrivate;
     using namespace QtMetaContainerPrivate;
 
 
     if (!value.isArray()) {
         static QMetaSequenceInterface emptySequence = emptySequenceInterface();
-        return QSequentialIterable(QMetaSequence(&emptySequence), nullptr);
+        return QMetaSequence::Iterable(QMetaSequence(&emptySequence), nullptr);
     }
 
     static QMetaSequenceInterface sequence = sequenceInterface();
-    return QSequentialIterable(QMetaSequence(&sequence), &value);
+    return QMetaSequence::Iterable(QMetaSequence(&sequence), &value);
 }
 
 void ExecutionEngine::initializeStaticMembers()
@@ -354,8 +354,8 @@ void ExecutionEngine::initializeStaticMembers()
         QMetaType::registerConverter<QJSValue, QVariantList>(convertJSValueToVariantType<QVariantList>);
     if (!QMetaType::hasRegisteredConverterFunction<QJSValue, QStringList>())
         QMetaType::registerConverter<QJSValue, QStringList>(convertJSValueToVariantType<QStringList>);
-    if (!QMetaType::hasRegisteredConverterFunction<QJSValue, QSequentialIterable>())
-        QMetaType::registerConverter<QJSValue, QSequentialIterable>(jsvalueToSequence);
+    if (!QMetaType::hasRegisteredConverterFunction<QJSValue, QMetaSequence::Iterable>())
+        QMetaType::registerConverter<QJSValue, QMetaSequence::Iterable>(jsvalueToSequence);
 }
 
 /*!
@@ -1976,8 +1976,8 @@ QV4::ReturnedValue ExecutionEngine::fromData(
     if (listType.isSequentialContainer())
         return createSequence(listType.listMetaSequence());
 
-    QSequentialIterable iterable;
-    if (QMetaType::convert(metaType, ptr, QMetaType::fromType<QSequentialIterable>(), &iterable)) {
+    QMetaSequence::Iterable iterable;
+    if (QMetaType::convert(metaType, ptr, QMetaType::fromType<QMetaSequence::Iterable>(), &iterable)) {
 
         // If the resulting iterable is useful for anything, turn it into a QV4::Sequence.
         const QMetaSequence sequence = iterable.metaContainer();
@@ -2544,8 +2544,8 @@ void ExecutionEngine::setExtensionData(int index, Deletable *data)
 template<typename Source>
 bool convertToIterable(QMetaType metaType, void *data, Source *sequence)
 {
-    QSequentialIterable iterable;
-    if (!QMetaType::view(metaType, data, QMetaType::fromType<QSequentialIterable>(), &iterable))
+    QMetaSequence::Iterable iterable;
+    if (!QMetaType::view(metaType, data, QMetaType::fromType<QMetaSequence::Iterable>(), &iterable))
         return false;
 
     // Clear the sequence before appending. There may be stale data in there.
@@ -2555,7 +2555,7 @@ bool convertToIterable(QMetaType metaType, void *data, Source *sequence)
     QV4::Scope scope(sequence->engine());
     QV4::ScopedValue v(scope);
 
-    const QMetaType elementMetaType = iterable.valueMetaType();
+    const QMetaType elementMetaType = iterable.metaContainer().valueMetaType();
     QVariant element;
     void *elementData = nullptr;
     if (elementMetaType == QMetaType::fromType<QVariant>()) {
@@ -2568,7 +2568,7 @@ bool convertToIterable(QMetaType metaType, void *data, Source *sequence)
     for (qsizetype i = 0, end = sequence->getLength(); i < end; ++i) {
         v = sequence->get(i);
         ExecutionEngine::metaTypeFromJS(v, elementMetaType, elementData);
-        iterable.addValue(element, QSequentialIterable::AtEnd);
+        iterable.append(element);
     }
 
     return true;
diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp
index 4a18f18f46..67aa186d06 100644
--- a/src/qml/jsruntime/qv4sequenceobject.cpp
+++ b/src/qml/jsruntime/qv4sequenceobject.cpp
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 // Qt-Security score:significant
 
-#include <QtCore/qsequentialiterable.h>
+#include <QtCore/qmetasequence.h>
 
 #include "qv4sequenceobject_p.h"
 
@@ -911,9 +911,9 @@ ReturnedValue SequencePrototype::fromVariant(QV4::ExecutionEngine *engine, const
     if (qmlType.isSequentialContainer())
         return fromData(engine, type, qmlType.listMetaSequence(), v.constData());
 
-    QSequentialIterable iterable;
+    QMetaSequence::Iterable iterable;
     if (QMetaType::convert(
-            type, v.constData(), QMetaType::fromType<QSequentialIterable>(), &iterable)) {
+            type, v.constData(), QMetaType::fromType<QMetaSequence::Iterable>(), &iterable)) {
         return fromData(engine, type, iterable.metaContainer(), v.constData());
     }
 
@@ -962,18 +962,18 @@ QVariant SequencePrototype::toVariant(const Sequence *object)
 
 bool convertToIterable(QMetaType metaType, void *data, QV4::Object *sequence)
 {
-    QSequentialIterable iterable;
-    if (!QMetaType::view(metaType, data, QMetaType::fromType<QSequentialIterable>(), &iterable))
+    QMetaSequence::Iterable iterable;
+    if (!QMetaType::view(metaType, data, QMetaType::fromType<QMetaSequence::Iterable>(), &iterable))
         return false;
 
-    const QMetaType elementMetaType = iterable.valueMetaType();
+    const QMetaType elementMetaType = iterable.metaContainer().valueMetaType();
     QV4::Scope scope(sequence->engine());
     QV4::ScopedValue v(scope);
     for (qsizetype i = 0, end = sequence->getLength(); i < end; ++i) {
         QVariant element(elementMetaType);
         v = sequence->get(i);
         ExecutionEngine::metaTypeFromJS(v, elementMetaType, element.data());
-        iterable.addValue(element, QSequentialIterable::AtEnd);
+        iterable.append(element);
     }
     return true;
 }
@@ -997,10 +997,11 @@ QVariant SequencePrototype::toVariant(const QV4::Value &array, QMetaType targetT
             type.isSequentialContainer()) {
         // If the QML type declares a custom sequential container, use that.
         meta = type.priv()->extraData.sequentialContainerTypeData;
-    } else if (QSequentialIterable iterable;
-            QMetaType::view(targetType, result.data(), QMetaType::fromType<QSequentialIterable>(),
-                            &iterable)) {
-        // Otherwise try to convert to QSequentialIterable via QMetaType conversion.
+    } else if (QMetaSequence::Iterable iterable;
+            QMetaType::view(
+                       targetType, result.data(),
+                       QMetaType::fromType<QMetaSequence::Iterable>(), &iterable)) {
+        // Otherwise try to convert to QMetaSequence::Iterable via QMetaType conversion.
         meta = iterable.metaContainer();
     }
 
diff --git a/src/qml/qml/qqml.cpp b/src/qml/qml/qqml.cpp
index 4eea815c0d..3dcf4121e1 100644
--- a/src/qml/qml/qqml.cpp
+++ b/src/qml/qml/qqml.cpp
@@ -25,7 +25,7 @@
 #include <QtQml/qqmlprivate.h>
 
 #include <QtCore/qmutex.h>
-#include <QtCore/qsequentialiterable.h>
+#include <QtCore/qmetasequence.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -1249,14 +1249,14 @@ static void iterateVariant(const QVariant &element, std::vector<QVariant> *eleme
         return;
     }
 
-    QSequentialIterable iterable;
+    QMetaSequence::Iterable iterable;
     if (!QMetaType::convert(
                 element.metaType(), element.constData(),
-                QMetaType::fromType<QSequentialIterable>(), &iterable)) {
+                QMetaType::fromType<QMetaSequence::Iterable>(), &iterable)) {
         return;
     }
 
-    switch (iterable.valueMetaType().id()) {
+    switch (iterable.metaContainer().valueMetaType().id()) {
     QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(ADD_CASE)
     QT_FOR_EACH_STATIC_CORE_CLASS(ADD_CASE)
     QT_FOR_EACH_STATIC_GUI_CLASS(ADD_CASE)
diff --git a/src/qml/qml/qqml.h b/src/qml/qml/qqml.h
index a3c9577275..4c7347cf78 100644
--- a/src/qml/qml/qqml.h
+++ b/src/qml/qml/qqml.h
@@ -10,7 +10,7 @@
 
 #include <QtCore/qbytearray.h>
 #include <QtCore/qmetaobject.h>
-#include <QtCore/qmetacontainer.h>
+#include <QtCore/qmetasequence.h>
 #include <QtCore/qversionnumber.h>
 
 #define QML_VERSION     0x020000
diff --git a/src/qml/qml/qqmlprivate.h b/src/qml/qml/qqmlprivate.h
index a12ada16f7..b3182e4c72 100644
--- a/src/qml/qml/qqmlprivate.h
+++ b/src/qml/qml/qqmlprivate.h
@@ -25,7 +25,7 @@
 #include <QtCore/qdatetime.h>
 #include <QtCore/qdebug.h>
 #include <QtCore/qglobal.h>
-#include <QtCore/qmetacontainer.h>
+#include <QtCore/qmetasequence.h>
 #include <QtCore/qmetaobject.h>
 #include <QtCore/qpointer.h>
 #include <QtCore/qurl.h>
diff --git a/src/qml/qml/qqmlproperty.cpp b/src/qml/qml/qqmlproperty.cpp
index 6d7de72a6d..dbd4bf0e64 100644
--- a/src/qml/qml/qqmlproperty.cpp
+++ b/src/qml/qml/qqmlproperty.cpp
@@ -28,7 +28,7 @@
 #include <QtQml/qqmlpropertymap.h>
 
 #include <QtCore/qdebug.h>
-#include <QtCore/qsequentialiterable.h>
+#include <QtCore/qmetasequence.h>
 #include <QtCore/qstringlist.h>
 #include <QtCore/qvector.h>
 
@@ -1482,15 +1482,15 @@ static ConvertAndAssignResult tryConvertAndAssign(
 template<typename Op>
 bool iterateQObjectContainer(QMetaType metaType, const void *data, Op op)
 {
-    QSequentialIterable iterable;
-    if (!QMetaType::convert(metaType, data, QMetaType::fromType<QSequentialIterable>(), &iterable))
+    QMetaSequence::Iterable iterable;
+    if (!QMetaType::convert(metaType, data, QMetaType::fromType<QMetaSequence::Iterable>(), &iterable))
         return false;
 
     const QMetaSequence metaSequence = iterable.metaContainer();
 
     if (!metaSequence.hasConstIterator()
             || !metaSequence.canGetValueAtConstIterator()
-            || !iterable.valueMetaType().flags().testFlag(QMetaType::PointerToQObject)) {
+            || !metaSequence.valueMetaType().flags().testFlag(QMetaType::PointerToQObject)) {
         return false;
     }
 
@@ -1585,14 +1585,14 @@ template<typename DoAppend>
 AssignResult assignMetaContainerToListProperty(
         QQmlListProperty<QObject> *prop, QMetaType metaType, const void *data, DoAppend &&doAppend)
 {
-    QSequentialIterable iterable;
-    if (!QMetaType::convert(metaType, data, QMetaType::fromType<QSequentialIterable>(), &iterable))
+    QMetaSequence::Iterable iterable;
+    if (!QMetaType::convert(metaType, data, QMetaType::fromType<QMetaSequence::Iterable>(), &iterable))
         return AssignResult::TypeMismatch;
 
     const QMetaSequence metaSequence = iterable.metaContainer();
     if (!metaSequence.hasConstIterator()
             || !metaSequence.canGetValueAtConstIterator()
-            || !iterable.valueMetaType().flags().testFlag(QMetaType::PointerToQObject)) {
+            || !metaSequence.valueMetaType().flags().testFlag(QMetaType::PointerToQObject)) {
         return AssignResult::TypeMismatch;
     }
 
@@ -1737,11 +1737,11 @@ static bool assignToListProperty(
         const QMetaType outputElementMetaType = outputSequence.valueMetaType();
         const bool outputIsQVariant = (outputElementMetaType == QMetaType::fromType<QVariant>());
 
-        QSequentialIterable inputIterable;
+        QMetaSequence::Iterable inputIterable;
         QVariant inputList = value;
         if (QMetaType::view(
                     inputList.metaType(), inputList.data(),
-                    QMetaType::fromType<QSequentialIterable>(), &inputIterable)) {
+                    QMetaType::fromType<QMetaSequence::Iterable>(), &inputIterable)) {
 
             const QMetaSequence inputSequence = inputIterable.metaContainer();
             const QMetaType inputElementMetaType = inputSequence.valueMetaType();
@@ -1817,15 +1817,15 @@ QVariant QQmlPropertyPrivate::convertToWriteTargetType(const QVariant &value, QM
     /* Note that we've already handled single-value assignment to QList<QUrl> properties in write,
        before calling this function but the generic code still handles them, which is important for
        other places*/
-    QSequentialIterable iterable;
+    QMetaSequence::Iterable iterable;
     QVariant sequenceVariant = QVariant(targetMetaType);
     if (QMetaType::view(
                 targetMetaType, sequenceVariant.data(),
-                QMetaType::fromType<QSequentialIterable>(),
+                QMetaType::fromType<QMetaSequence::Iterable>(),
                 &iterable)) {
         const QMetaSequence propertyMetaSequence = iterable.metaContainer();
         if (propertyMetaSequence.canAddValueAtEnd()) {
-            const QMetaType elementMetaType = iterable.valueMetaType();
+            const QMetaType elementMetaType = propertyMetaSequence.valueMetaType();
             void *propertyContainer = iterable.mutableIterable();
 
             if (sourceMetaType == elementMetaType) {
diff --git a/src/qml/qml/qqmlvmemetaobject.cpp b/src/qml/qml/qqmlvmemetaobject.cpp
index 62f0b0a07f..622b8b0cb8 100644
--- a/src/qml/qml/qqmlvmemetaobject.cpp
+++ b/src/qml/qml/qqmlvmemetaobject.cpp
@@ -23,7 +23,7 @@
 #include <private/qv4variantassociationobject_p.h>
 #include <private/qv4variantobject_p.h>
 
-#include <QtCore/qsequentialiterable.h>
+#include <QtCore/qmetasequence.h>
 
 #include <climits> // for CHAR_BIT
 
@@ -930,10 +930,10 @@ int QQmlVMEMetaObject::metaCall(QObject *o, QMetaObject::Call c, int _id, void *
                                         type.isSequentialContainer()) {
                                     sequence = QV4::SequencePrototype::fromData(
                                         engine, propType, type.listMetaSequence(), a[0]);
-                                } else if (QSequentialIterable iterable;
+                                } else if (QMetaSequence::Iterable iterable;
                                         QMetaType::convert(
                                                propType, a[0],
-                                               QMetaType::fromType<QSequentialIterable>(),
+                                               QMetaType::fromType<QMetaSequence::Iterable>(),
                                                &iterable)) {
                                     sequence = QV4::SequencePrototype::fromData(
                                         engine, propType, iterable.metaContainer(), a[0]);
diff --git a/src/qmlmodels/qqmllistaccessor.cpp b/src/qmlmodels/qqmllistaccessor.cpp
index aac1b8bfc1..2191a9b792 100644
--- a/src/qmlmodels/qqmllistaccessor.cpp
+++ b/src/qmlmodels/qqmllistaccessor.cpp
@@ -7,7 +7,7 @@
 #include <private/qqmlmetatype_p.h>
 
 #include <QtCore/qdebug.h>
-#include <QtCore/qsequentialiterable.h>
+#include <QtCore/qmetasequence.h>
 #include <QtCore/qstringlist.h>
 #include <QtCore/qurl.h>
 
@@ -117,10 +117,10 @@ void QQmlListAccessor::setList(const QVariant &v)
         return;
     }
 
-    QSequentialIterable iterable;
+    QMetaSequence::Iterable iterable;
     if (QMetaType::convert(
                 variantsType, d.constData(),
-                QMetaType::fromType<QSequentialIterable>(), &iterable)) {
+                QMetaType::fromType<QMetaSequence::Iterable>(), &iterable)) {
         const QMetaSequence sequence = iterable.metaContainer();
 
         if (sequence.hasSize() && sequence.canGetValueAtIndex()) {
diff --git a/src/quick/util/qquickpath.cpp b/src/quick/util/qquickpath.cpp
index 4cff9565d2..bcb15e38d8 100644
--- a/src/quick/util/qquickpath.cpp
+++ b/src/quick/util/qquickpath.cpp
@@ -2921,7 +2921,7 @@ void QQuickPathPolyline::setPath(const QVariant &path)
         QVariantList vl = path.value<QVariantList>();
         // If path is a QJSValue, e.g. coming from a JS array of Qt.point() in QML,
         // then path.value<QVariantList>() is inefficient.
-        // TODO We should be able to iterate over path.value<QSequentialIterable>() eventually
+        // TODO We should be able to iterate over path.value<QMetaSequence::Iterable>() eventually
         for (const QVariant &v : vl)
             pathList.append(v.toPointF());
         setPath(pathList);
diff --git a/tests/auto/qml/qjsmanagedvalue/tst_qjsmanagedvalue.cpp b/tests/auto/qml/qjsmanagedvalue/tst_qjsmanagedvalue.cpp
index 53f7331fc8..8d02f81cf5 100644
--- a/tests/auto/qml/qjsmanagedvalue/tst_qjsmanagedvalue.cpp
+++ b/tests/auto/qml/qjsmanagedvalue/tst_qjsmanagedvalue.cpp
@@ -13,7 +13,7 @@
 #include <QtCore/qvariant.h>
 #include <QtCore/qpoint.h>
 #include <QtCore/qdatastream.h>
-#include <QtCore/qsequentialiterable.h>
+#include <QtCore/qmetasequence.h>
 #include <QtCore/qloggingcategory.h>
 #include <QtCore/qwaitcondition.h>
 #include <QtCore/qthread.h>
@@ -1660,7 +1660,7 @@ void tst_QJSManagedValue::jsvalueArrayToSequenceType()
         array.setProperty(3, QJSValue(std::move(testObject)));
         auto asVariant = QVariant::fromValue(array);
         QVERIFY(asVariant.canConvert<QVariantList>());
-        auto asIterable = asVariant.value<QSequentialIterable>();
+        auto asIterable = asVariant.value<QMetaSequence::Iterable>();
         for (auto it = asIterable.begin(); it != asIterable.end(); ++it) {
             Q_UNUSED(*it);
         }
diff --git a/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp b/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp
index dfaa8772ef..a7a1877e2b 100644
--- a/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp
+++ b/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp
@@ -10,7 +10,7 @@
 #include <QtCore/qbuffer.h>
 #include <QtCore/qdatetime.h>
 #include <QtCore/qmutex.h>
-#include <QtCore/qsequentialiterable.h>
+#include <QtCore/qmetasequence.h>
 #include <QtCore/qthread.h>
 #include <QtCore/qwaitcondition.h>
 #include <QtQml/qqmlengine.h>
@@ -2768,7 +2768,7 @@ void tst_QJSValue::jsvalueArrayToSequenceType()
         array.setProperty(3, testObject);
         auto asVariant = QVariant::fromValue(array);
         QVERIFY(asVariant.canConvert<QVariantList>());
-        auto asIterable = asVariant.value<QSequentialIterable>();
+        auto asIterable = asVariant.value<QMetaSequence::Iterable>();
         for (auto it = asIterable.begin(); it != asIterable.end(); ++it) {
             Q_UNUSED(*it);
         }
@@ -2793,11 +2793,11 @@ void tst_QJSValue::jsvalueArrayToSequenceType()
     QCOMPARE(instanceCount, 0);
 
     QJSValue five(5);
-    QSequentialIterable iterable;
+    QMetaSequence::Iterable iterable;
 
     QVERIFY(QMetaType::convert(
             QMetaType::fromType<QJSValue>(), &five,
-            QMetaType::fromType<QSequentialIterable>(), &iterable));
+            QMetaType::fromType<QMetaSequence::Iterable>(), &iterable));
 
     QCOMPARE_LE(iterable.size(), 0);
 
@@ -2813,7 +2813,7 @@ void tst_QJSValue::jsvalueArrayToSequenceType()
         fiveFive.setProperty(i, 5);
     QVERIFY(QMetaType::convert(
             QMetaType::fromType<QJSValue>(), &fiveFive,
-            QMetaType::fromType<QSequentialIterable>(), &iterable));
+            QMetaType::fromType<QMetaSequence::Iterable>(), &iterable));
 
     QCOMPARE(iterable.size(), 5);