1 files changed, 75 insertions, 72 deletions

diff --git a/src/qml/types/qqmldelegatemodel.cpp b/src/qml/types/qqmldelegatemodel.cpp
index be10b270ae..a5878dcffd 100644
--- a/src/qml/types/qqmldelegatemodel.cpp
+++ b/src/qml/types/qqmldelegatemodel.cpp
@@ -264,7 +264,7 @@ QQmlDelegateModel::~QQmlDelegateModel()
 {
     Q_D(QQmlDelegateModel);
 
-    foreach (QQmlDelegateModelItem *cacheItem, d->m_cache) {
+    for (QQmlDelegateModelItem *cacheItem : qAsConst(d->m_cache)) {
         if (cacheItem->object) {
             delete cacheItem->object;
 
@@ -310,7 +310,7 @@ void QQmlDelegateModel::componentComplete()
             --d->m_groupCount;
             --i;
         } else if (name.at(0).isUpper()) {
-            qmlInfo(d->m_groups[i]) << QQmlDelegateModelGroup::tr("Group names must start with a lower case letter");
+            qmlWarning(d->m_groups[i]) << QQmlDelegateModelGroup::tr("Group names must start with a lower case letter");
             d->m_groups[i] = d->m_groups[d->m_groupCount - 1];
             --d->m_groupCount;
             --i;
@@ -404,7 +404,7 @@ void QQmlDelegateModel::setDelegate(QQmlComponent *delegate)
 {
     Q_D(QQmlDelegateModel);
     if (d->m_transaction) {
-        qmlInfo(this) << tr("The delegate of a DelegateModel cannot be changed within onUpdated.");
+        qmlWarning(this) << tr("The delegate of a DelegateModel cannot be changed within onUpdated.");
         return;
     }
     bool wasValid = d->m_delegate != 0;
@@ -610,7 +610,7 @@ void QQmlDelegateModelPrivate::group_append(
     if (d->m_complete)
         return;
     if (d->m_groupCount == Compositor::MaximumGroupCount) {
-        qmlInfo(d->q_func()) << QQmlDelegateModel::tr("The maximum number of supported DelegateModelGroups is 8");
+        qmlWarning(d->q_func()) << QQmlDelegateModel::tr("The maximum number of supported DelegateModelGroups is 8");
         return;
     }
     d->m_groups[d->m_groupCount] = group;
@@ -719,7 +719,7 @@ void QQmlDelegateModel::setFilterGroup(const QString &group)
     Q_D(QQmlDelegateModel);
 
     if (d->m_transaction) {
-        qmlInfo(this) << tr("The group of a DelegateModel cannot be changed within onChanged");
+        qmlWarning(this) << tr("The group of a DelegateModel cannot be changed within onChanged");
         return;
     }
 
@@ -764,7 +764,8 @@ void QQmlDelegateModelPrivate::updateFilterGroup()
             emit q->countChanged();
 
         if (m_parts) {
-            foreach (QQmlPartsModel *model, m_parts->models)
+            auto partsCopy = m_parts->models; // deliberate; this may alter m_parts
+            for (QQmlPartsModel *model : qAsConst(partsCopy))
                 model->updateFilterGroup(m_compositorGroup, changeSet);
         }
     }
@@ -889,7 +890,7 @@ void QQmlDelegateModelPrivate::incubatorStatusChanged(QQDMIncubationTask *incuba
             emitCreatedItem(incubationTask, cacheItem->object);
         cacheItem->releaseObject();
     } else if (status == QQmlIncubator::Error) {
-        qmlInfo(q, m_delegate->errors()) << "Error creating delegate";
+        qmlWarning(q, m_delegate->errors()) << "Error creating delegate";
     }
 
     if (!cacheItem->isObjectReferenced()) {
@@ -1472,7 +1473,8 @@ void QQmlDelegateModelPrivate::emitChanges()
     for (int i = 1; i < m_groupCount; ++i)
         QQmlDelegateModelGroupPrivate::get(m_groups[i])->emitModelUpdated(reset);
 
-    foreach (QQmlDelegateModelItem *cacheItem, m_cache) {
+    auto cacheCopy = m_cache; // deliberate; emitChanges may alter m_cache
+    for (QQmlDelegateModelItem *cacheItem : qAsConst(cacheCopy)) {
         if (cacheItem->attached)
             cacheItem->attached->emitChanges();
     }
@@ -1793,24 +1795,26 @@ int QQmlDelegateModelItemMetaType::parseGroups(const QV4::Value &groups) const
     return groupFlags;
 }
 
-QV4::ReturnedValue QQmlDelegateModelItem::get_model(QV4::CallContext *ctx)
+void QQmlDelegateModelItem::get_model(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    QV4::Scope scope(ctx);
-    QV4::Scoped<QQmlDelegateModelItemObject> o(scope, ctx->thisObject().as<QQmlDelegateModelItemObject>());
-    if (!o)
-        return ctx->engine()->throwTypeError(QStringLiteral("Not a valid VisualData object"));
+    QV4::Scoped<QQmlDelegateModelItemObject> o(scope, callData->thisObject.as<QQmlDelegateModelItemObject>());
+    if (!o) {
+        scope.result = scope.engine->throwTypeError(QStringLiteral("Not a valid VisualData object"));
+        return;
+    }
     if (!o->d()->item->metaType->model)
-        return QV4::Encode::undefined();
+        RETURN_UNDEFINED();
 
-    return o->d()->item->get();
+    scope.result = o->d()->item->get();
 }
 
-QV4::ReturnedValue QQmlDelegateModelItem::get_groups(QV4::CallContext *ctx)
+void QQmlDelegateModelItem::get_groups(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    QV4::Scope scope(ctx);
-    QV4::Scoped<QQmlDelegateModelItemObject> o(scope, ctx->thisObject().as<QQmlDelegateModelItemObject>());
-    if (!o)
-        return ctx->engine()->throwTypeError(QStringLiteral("Not a valid VisualData object"));
+    QV4::Scoped<QQmlDelegateModelItemObject> o(scope, callData->thisObject.as<QQmlDelegateModelItemObject>());
+    if (!o) {
+        scope.result = scope.engine->throwTypeError(QStringLiteral("Not a valid VisualData object"));
+        return;
+    }
 
     QStringList groups;
     for (int i = 1; i < o->d()->item->metaType->groupCount; ++i) {
@@ -1818,27 +1822,29 @@ QV4::ReturnedValue QQmlDelegateModelItem::get_groups(QV4::CallContext *ctx)
             groups.append(o->d()->item->metaType->groupNames.at(i - 1));
     }
 
-    return scope.engine->fromVariant(groups);
+    scope.result = scope.engine->fromVariant(groups);
 }
 
-QV4::ReturnedValue QQmlDelegateModelItem::set_groups(QV4::CallContext *ctx)
+void QQmlDelegateModelItem::set_groups(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    QV4::Scope scope(ctx);
-    QV4::Scoped<QQmlDelegateModelItemObject> o(scope, ctx->thisObject().as<QQmlDelegateModelItemObject>());
-    if (!o)
-        return ctx->engine()->throwTypeError(QStringLiteral("Not a valid VisualData object"));
-    if (!ctx->argc())
-        return ctx->engine()->throwTypeError();
+    QV4::Scoped<QQmlDelegateModelItemObject> o(scope, callData->thisObject.as<QQmlDelegateModelItemObject>());
+    if (!o) {
+        scope.result = scope.engine->throwTypeError(QStringLiteral("Not a valid VisualData object"));
+        return;
+    }
+
+    if (!callData->argc)
+        THROW_TYPE_ERROR();
 
     if (!o->d()->item->metaType->model)
-        return QV4::Encode::undefined();
+        RETURN_UNDEFINED();
     QQmlDelegateModelPrivate *model = QQmlDelegateModelPrivate::get(o->d()->item->metaType->model);
 
-    const int groupFlags = model->m_cacheMetaType->parseGroups(ctx->args()[0]);
+    const int groupFlags = model->m_cacheMetaType->parseGroups(callData->args[0]);
     const int cacheIndex = model->m_cache.indexOf(o->d()->item);
     Compositor::iterator it = model->m_compositor.find(Compositor::Cache, cacheIndex);
     model->setGroups(it, 1, Compositor::Cache, groupFlags);
-    return QV4::Encode::undefined();
+    scope.result = QV4::Encode::undefined();
 }
 
 QV4::ReturnedValue QQmlDelegateModelItem::get_member(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &)
@@ -2459,7 +2465,7 @@ QQmlV4Handle QQmlDelegateModelGroup::get(int index)
     if (!model->m_context || !model->m_context->isValid()) {
         return QQmlV4Handle(QV4::Encode::undefined());
     } else if (index < 0 || index >= model->m_compositor.count(d->group)) {
-        qmlInfo(this) << tr("get: index out of range");
+        qmlWarning(this) << tr("get: index out of range");
         return QQmlV4Handle(QV4::Encode::undefined());
     }
 
@@ -2552,7 +2558,7 @@ void QQmlDelegateModelGroup::insert(QQmlV4Function *args)
     QV4::ScopedValue v(scope, (*args)[i]);
     if (d->parseIndex(v, &index, &group)) {
         if (index < 0 || index > model->m_compositor.count(group)) {
-            qmlInfo(this) << tr("insert: index out of range");
+            qmlWarning(this) << tr("insert: index out of range");
             return;
         }
         if (++i == args->length())
@@ -2637,7 +2643,7 @@ void QQmlDelegateModelGroup::create(QQmlV4Function *args)
         }
     }
     if (index < 0 || index >= model->m_compositor.count(group)) {
-        qmlInfo(this) << tr("create: index out of range");
+        qmlWarning(this) << tr("create: index out of range");
         return;
     }
 
@@ -2690,22 +2696,22 @@ void QQmlDelegateModelGroup::resolve(QQmlV4Function *args)
     QV4::ScopedValue v(scope, (*args)[0]);
     if (d->parseIndex(v, &from, &fromGroup)) {
         if (from < 0 || from >= model->m_compositor.count(fromGroup)) {
-            qmlInfo(this) << tr("resolve: from index out of range");
+            qmlWarning(this) << tr("resolve: from index out of range");
             return;
         }
     } else {
-        qmlInfo(this) << tr("resolve: from index invalid");
+        qmlWarning(this) << tr("resolve: from index invalid");
         return;
     }
 
     v = (*args)[1];
     if (d->parseIndex(v, &to, &toGroup)) {
         if (to < 0 || to >= model->m_compositor.count(toGroup)) {
-            qmlInfo(this) << tr("resolve: to index out of range");
+            qmlWarning(this) << tr("resolve: to index out of range");
             return;
         }
     } else {
-        qmlInfo(this) << tr("resolve: to index invalid");
+        qmlWarning(this) << tr("resolve: to index invalid");
         return;
     }
 
@@ -2713,11 +2719,11 @@ void QQmlDelegateModelGroup::resolve(QQmlV4Function *args)
     Compositor::iterator toIt = model->m_compositor.find(toGroup, to);
 
     if (!fromIt->isUnresolved()) {
-        qmlInfo(this) << tr("resolve: from is not an unresolved item");
+        qmlWarning(this) << tr("resolve: from is not an unresolved item");
         return;
     }
     if (!toIt->list) {
-        qmlInfo(this) << tr("resolve: to is not a model item");
+        qmlWarning(this) << tr("resolve: to is not a model item");
         return;
     }
 
@@ -2787,7 +2793,7 @@ void QQmlDelegateModelGroup::remove(QQmlV4Function *args)
     QV4::Scope scope(args->v4engine());
     QV4::ScopedValue v(scope, (*args)[0]);
     if (!d->parseIndex(v, &index, &group)) {
-        qmlInfo(this) << tr("remove: invalid index");
+        qmlWarning(this) << tr("remove: invalid index");
         return;
     }
 
@@ -2799,11 +2805,11 @@ void QQmlDelegateModelGroup::remove(QQmlV4Function *args)
 
     QQmlDelegateModelPrivate *model = QQmlDelegateModelPrivate::get(d->model);
     if (index < 0 || index >= model->m_compositor.count(group)) {
-        qmlInfo(this) << tr("remove: index out of range");
+        qmlWarning(this) << tr("remove: index out of range");
     } else if (count != 0) {
         Compositor::iterator it = model->m_compositor.find(group, index);
         if (count < 0 || count > model->m_compositor.count(d->group) - it.index[d->group]) {
-            qmlInfo(this) << tr("remove: invalid count");
+            qmlWarning(this) << tr("remove: invalid count");
         } else {
             model->removeGroups(it, count, d->group, 1 << d->group);
         }
@@ -2858,11 +2864,11 @@ void QQmlDelegateModelGroup::addGroups(QQmlV4Function *args)
 
     QQmlDelegateModelPrivate *model = QQmlDelegateModelPrivate::get(d->model);
     if (index < 0 || index >= model->m_compositor.count(group)) {
-        qmlInfo(this) << tr("addGroups: index out of range");
+        qmlWarning(this) << tr("addGroups: index out of range");
     } else if (count != 0) {
         Compositor::iterator it = model->m_compositor.find(group, index);
         if (count < 0 || count > model->m_compositor.count(d->group) - it.index[d->group]) {
-            qmlInfo(this) << tr("addGroups: invalid count");
+            qmlWarning(this) << tr("addGroups: invalid count");
         } else {
             model->addGroups(it, count, d->group, groups);
         }
@@ -2888,11 +2894,11 @@ void QQmlDelegateModelGroup::removeGroups(QQmlV4Function *args)
 
     QQmlDelegateModelPrivate *model = QQmlDelegateModelPrivate::get(d->model);
     if (index < 0 || index >= model->m_compositor.count(group)) {
-        qmlInfo(this) << tr("removeGroups: index out of range");
+        qmlWarning(this) << tr("removeGroups: index out of range");
     } else if (count != 0) {
         Compositor::iterator it = model->m_compositor.find(group, index);
         if (count < 0 || count > model->m_compositor.count(d->group) - it.index[d->group]) {
-            qmlInfo(this) << tr("removeGroups: invalid count");
+            qmlWarning(this) << tr("removeGroups: invalid count");
         } else {
             model->removeGroups(it, count, d->group, groups);
         }
@@ -2918,11 +2924,11 @@ void QQmlDelegateModelGroup::setGroups(QQmlV4Function *args)
 
     QQmlDelegateModelPrivate *model = QQmlDelegateModelPrivate::get(d->model);
     if (index < 0 || index >= model->m_compositor.count(group)) {
-        qmlInfo(this) << tr("setGroups: index out of range");
+        qmlWarning(this) << tr("setGroups: index out of range");
     } else if (count != 0) {
         Compositor::iterator it = model->m_compositor.find(group, index);
         if (count < 0 || count > model->m_compositor.count(d->group) - it.index[d->group]) {
-            qmlInfo(this) << tr("setGroups: invalid count");
+            qmlWarning(this) << tr("setGroups: invalid count");
         } else {
             model->setGroups(it, count, d->group, groups);
         }
@@ -2957,13 +2963,13 @@ void QQmlDelegateModelGroup::move(QQmlV4Function *args)
     QV4::Scope scope(args->v4engine());
     QV4::ScopedValue v(scope, (*args)[0]);
     if (!d->parseIndex(v, &from, &fromGroup)) {
-        qmlInfo(this) << tr("move: invalid from index");
+        qmlWarning(this) << tr("move: invalid from index");
         return;
     }
 
     v = (*args)[1];
     if (!d->parseIndex(v, &to, &toGroup)) {
-        qmlInfo(this) << tr("move: invalid to index");
+        qmlWarning(this) << tr("move: invalid to index");
         return;
     }
 
@@ -2976,11 +2982,11 @@ void QQmlDelegateModelGroup::move(QQmlV4Function *args)
     QQmlDelegateModelPrivate *model = QQmlDelegateModelPrivate::get(d->model);
 
     if (count < 0) {
-        qmlInfo(this) << tr("move: invalid count");
+        qmlWarning(this) << tr("move: invalid count");
     } else if (from < 0 || from + count > model->m_compositor.count(fromGroup)) {
-        qmlInfo(this) << tr("move: from index out of range");
+        qmlWarning(this) << tr("move: from index out of range");
     } else if (!model->m_compositor.verifyMoveTo(fromGroup, from, toGroup, to, count, d->group)) {
-        qmlInfo(this) << tr("move: to index out of range");
+        qmlWarning(this) << tr("move: to index out of range");
     } else if (count > 0) {
         QVector<Compositor::Remove> removes;
         QVector<Compositor::Insert> inserts;
@@ -3038,7 +3044,7 @@ QString QQmlPartsModel::filterGroup() const
 void QQmlPartsModel::setFilterGroup(const QString &group)
 {
     if (QQmlDelegateModelPrivate::get(m_model)->m_transaction) {
-        qmlInfo(this) << tr("The group of a DelegateModel cannot be changed within onChanged");
+        qmlWarning(this) << tr("The group of a DelegateModel cannot be changed within onChanged");
         return;
     }
 
@@ -3151,7 +3157,7 @@ QObject *QQmlPartsModel::object(int index, bool asynchronous)
     model->release(object);
     if (!model->m_delegateValidated) {
         if (object)
-            qmlInfo(model->m_delegate) << tr("Delegate component must be Package type.");
+            qmlWarning(model->m_delegate) << tr("Delegate component must be Package type.");
         model->m_delegateValidated = true;
     }
 
@@ -3232,28 +3238,25 @@ struct QQmlDelegateModelGroupChange : QV4::Object
         return e->memoryManager->allocObject<QQmlDelegateModelGroupChange>();
     }
 
-    static QV4::ReturnedValue method_get_index(QV4::CallContext *ctx) {
-        QV4::Scope scope(ctx);
-        QV4::Scoped<QQmlDelegateModelGroupChange> that(scope, ctx->thisObject().as<QQmlDelegateModelGroupChange>());
+    static void method_get_index(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData) {
+        QV4::Scoped<QQmlDelegateModelGroupChange> that(scope, callData->thisObject.as<QQmlDelegateModelGroupChange>());
         if (!that)
-            return ctx->engine()->throwTypeError();
-        return QV4::Encode(that->d()->change.index);
+            THROW_TYPE_ERROR();
+        scope.result = QV4::Encode(that->d()->change.index);
     }
-    static QV4::ReturnedValue method_get_count(QV4::CallContext *ctx) {
-        QV4::Scope scope(ctx);
-        QV4::Scoped<QQmlDelegateModelGroupChange> that(scope, ctx->thisObject().as<QQmlDelegateModelGroupChange>());
+    static void method_get_count(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData) {
+        QV4::Scoped<QQmlDelegateModelGroupChange> that(scope, callData->thisObject.as<QQmlDelegateModelGroupChange>());
         if (!that)
-            return ctx->engine()->throwTypeError();
-        return QV4::Encode(that->d()->change.count);
+            THROW_TYPE_ERROR();
+        scope.result = QV4::Encode(that->d()->change.count);
     }
-    static QV4::ReturnedValue method_get_moveId(QV4::CallContext *ctx) {
-        QV4::Scope scope(ctx);
-        QV4::Scoped<QQmlDelegateModelGroupChange> that(scope, ctx->thisObject().as<QQmlDelegateModelGroupChange>());
+    static void method_get_moveId(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData) {
+        QV4::Scoped<QQmlDelegateModelGroupChange> that(scope, callData->thisObject.as<QQmlDelegateModelGroupChange>());
         if (!that)
-            return ctx->engine()->throwTypeError();
+            THROW_TYPE_ERROR();
         if (that->d()->change.moveId < 0)
-            return QV4::Encode::undefined();
-        return QV4::Encode(that->d()->change.moveId);
+            RETURN_UNDEFINED();
+        scope.result = QV4::Encode(that->d()->change.moveId);
     }
 };