Convert more methods to return a Returned<>

Change-Id: If294c9c4f574824c308b63a11da1337226180105
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

14 files changed, 117 insertions, 100 deletions

diff --git a/src/qml/jsruntime/qv4arrayobject.cpp b/src/qml/jsruntime/qv4arrayobject.cpp
index 5508372265..1f09b97d5c 100644
--- a/src/qml/jsruntime/qv4arrayobject.cpp
+++ b/src/qml/jsruntime/qv4arrayobject.cpp
@@ -57,7 +57,8 @@ ArrayCtor::ArrayCtor(ExecutionContext *scope)
 ReturnedValue ArrayCtor::construct(Managed *m, CallData *callData)
 {
     ExecutionEngine *v4 = m->engine();
-    ArrayObject *a = v4->newArrayObject();
+    Scope scope(v4);
+    Scoped<ArrayObject> a(scope, v4->newArrayObject());
     uint len;
     if (callData->argc == 1 && callData->args[0].isNumber()) {
         bool ok;
@@ -77,7 +78,7 @@ ReturnedValue ArrayCtor::construct(Managed *m, CallData *callData)
     }
     a->setArrayLengthUnchecked(len);
 
-    return Value::fromObject(a).asReturnedValue();
+    return a.asReturnedValue();
 }
 
 ReturnedValue ArrayCtor::call(Managed *that, CallData *callData)
@@ -156,7 +157,8 @@ ReturnedValue ArrayPrototype::method_toLocaleString(SimpleCallContext *ctx)
 
 ReturnedValue ArrayPrototype::method_concat(SimpleCallContext *ctx)
 {
-    ArrayObject *result = ctx->engine->newArrayObject();
+    Scope scope(ctx);
+    Scoped<ArrayObject> result(scope, ctx->engine->newArrayObject());
 
     if (ArrayObject *instance = ctx->thisObject.asArrayObject()) {
         result->copyArrayData(instance);
@@ -178,10 +180,10 @@ ReturnedValue ArrayPrototype::method_concat(SimpleCallContext *ctx)
             result->arrayConcat(elt);
 
         else
-            result->arraySet(getLength(ctx, result), arg);
+            result->arraySet(getLength(ctx, result.getPointer()), arg);
     }
 
-    return Value::fromObject(result).asReturnedValue();
+    return result.asReturnedValue();
 }
 
 ReturnedValue ArrayPrototype::method_join(SimpleCallContext *ctx)
@@ -404,7 +406,7 @@ ReturnedValue ArrayPrototype::method_slice(SimpleCallContext *ctx)
     Scope scope(ctx);
     Object *o = ctx->thisObject.toObject(ctx);
 
-    ArrayObject *result = ctx->engine->newArrayObject();
+    Scoped<ArrayObject> result(scope, ctx->engine->newArrayObject());
     uint len = ArrayPrototype::getLength(ctx, o);
     double s = ctx->argument(0).toInteger();
     uint start;
@@ -435,7 +437,7 @@ ReturnedValue ArrayPrototype::method_slice(SimpleCallContext *ctx)
         }
         ++n;
     }
-    return Value::fromObject(result).asReturnedValue();
+    return result.asReturnedValue();
 }
 
 ReturnedValue ArrayPrototype::method_sort(SimpleCallContext *ctx)
@@ -455,7 +457,7 @@ ReturnedValue ArrayPrototype::method_splice(SimpleCallContext *ctx)
     Object *instance = ctx->thisObject.toObject(ctx);
     uint len = getLength(ctx, instance);
 
-    ArrayObject *newArray = ctx->engine->newArrayObject();
+    Scoped<ArrayObject> newArray(scope, ctx->engine->newArrayObject());
 
     double rs = ctx->argument(0).toInteger();
     uint start;
@@ -508,7 +510,7 @@ ReturnedValue ArrayPrototype::method_splice(SimpleCallContext *ctx)
     ctx->strictMode = true;
     instance->put(ctx->engine->id_length, Value::fromDouble(len - deleteCount + itemCount));
 
-    return Value::fromObject(newArray).asReturnedValue();
+    return newArray.asReturnedValue();
 }
 
 ReturnedValue ArrayPrototype::method_unshift(SimpleCallContext *ctx)
@@ -750,7 +752,7 @@ ReturnedValue ArrayPrototype::method_map(SimpleCallContext *ctx)
 
     Value thisArg = ctx->argument(1);
 
-    ArrayObject *a = ctx->engine->newArrayObject();
+    Scoped<ArrayObject> a(scope, ctx->engine->newArrayObject());
     a->arrayReserve(len);
     a->setArrayLengthUnchecked(len);
 
@@ -771,7 +773,7 @@ ReturnedValue ArrayPrototype::method_map(SimpleCallContext *ctx)
         mapped = callback->call(callData);
         a->arraySet(k, mapped);
     }
-    return Value::fromObject(a).asReturnedValue();
+    return a.asReturnedValue();
 }
 
 ReturnedValue ArrayPrototype::method_filter(SimpleCallContext *ctx)
@@ -787,7 +789,7 @@ ReturnedValue ArrayPrototype::method_filter(SimpleCallContext *ctx)
 
     Value thisArg = ctx->argument(1);
 
-    ArrayObject *a = ctx->engine->newArrayObject();
+    Scoped<ArrayObject> a(scope, ctx->engine->newArrayObject());
     a->arrayReserve(len);
 
     ScopedValue selected(scope);
@@ -812,7 +814,7 @@ ReturnedValue ArrayPrototype::method_filter(SimpleCallContext *ctx)
             ++to;
         }
     }
-    return Value::fromObject(a).asReturnedValue();
+    return a.asReturnedValue();
 }
 
 ReturnedValue ArrayPrototype::method_reduce(SimpleCallContext *ctx)
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 0187099f62..1a084905ae 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -393,7 +393,7 @@ Returned<Object> *ExecutionEngine::newBooleanObject(const Value &value)
     return object->asReturned<Object>();
 }
 
-ArrayObject *ExecutionEngine::newArrayObject(int count)
+Returned<ArrayObject> *ExecutionEngine::newArrayObject(int count)
 {
     ArrayObject *object = new (memoryManager) ArrayObject(this);
 
@@ -402,19 +402,19 @@ ArrayObject *ExecutionEngine::newArrayObject(int count)
             object->arrayReserve(count);
         object->setArrayLengthUnchecked(count);
     }
-    return object;
+    return object->asReturned<ArrayObject>();
 }
 
-ArrayObject *ExecutionEngine::newArrayObject(const QStringList &list)
+Returned<ArrayObject> *ExecutionEngine::newArrayObject(const QStringList &list)
 {
     ArrayObject *object = new (memoryManager) ArrayObject(this, list);
-    return object;
+    return object->asReturned<ArrayObject>();
 }
 
-ArrayObject *ExecutionEngine::newArrayObject(InternalClass *ic)
+Returned<ArrayObject> *ExecutionEngine::newArrayObject(InternalClass *ic)
 {
     ArrayObject *object = new (memoryManager) ArrayObject(ic);
-    return object;
+    return object->asReturned<ArrayObject>();
 }
 
 
@@ -474,43 +474,50 @@ Returned<Object> *ExecutionEngine::newSyntaxErrorObject(const QString &message,
 }
 
 
-Object *ExecutionEngine::newReferenceErrorObject(const QString &message)
+Returned<Object> *ExecutionEngine::newReferenceErrorObject(const QString &message)
 {
-    return new (memoryManager) ReferenceErrorObject(this, message);
+    Object *o = new (memoryManager) ReferenceErrorObject(this, message);
+    return o->asReturned<Object>();
 }
 
-Object *ExecutionEngine::newReferenceErrorObject(const QString &message, const QString &fileName, int lineNumber, int columnNumber)
+Returned<Object> *ExecutionEngine::newReferenceErrorObject(const QString &message, const QString &fileName, int lineNumber, int columnNumber)
 {
-    return new (memoryManager) ReferenceErrorObject(this, message, fileName, lineNumber, columnNumber);
+    Object *o = new (memoryManager) ReferenceErrorObject(this, message, fileName, lineNumber, columnNumber);
+    return o->asReturned<Object>();
 }
 
 
-Object *ExecutionEngine::newTypeErrorObject(const QString &message)
+Returned<Object> *ExecutionEngine::newTypeErrorObject(const QString &message)
 {
-    return new (memoryManager) TypeErrorObject(this, message);
+    Object *o = new (memoryManager) TypeErrorObject(this, message);
+    return o->asReturned<Object>();
 }
 
-Object *ExecutionEngine::newRangeErrorObject(const QString &message)
+Returned<Object> *ExecutionEngine::newRangeErrorObject(const QString &message)
 {
-    return new (memoryManager) RangeErrorObject(this, message);
+    Object *o = new (memoryManager) RangeErrorObject(this, message);
+    return o->asReturned<Object>();
 }
 
-Object *ExecutionEngine::newURIErrorObject(Value message)
+Returned<Object> *ExecutionEngine::newURIErrorObject(Value message)
 {
-    return new (memoryManager) URIErrorObject(this, message);
+    Object *o = new (memoryManager) URIErrorObject(this, message);
+    return o->asReturned<Object>();
 }
 
-Object *ExecutionEngine::newVariantObject(const QVariant &v)
+Returned<Object> *ExecutionEngine::newVariantObject(const QVariant &v)
 {
-    return new (memoryManager) VariantObject(this, v);
+    Object *o = new (memoryManager) VariantObject(this, v);
+    return o->asReturned<Object>();
 }
 
-Object *ExecutionEngine::newForEachIteratorObject(ExecutionContext *ctx, Object *o)
+Returned<Object> *ExecutionEngine::newForEachIteratorObject(ExecutionContext *ctx, Object *o)
 {
-    return new (memoryManager) ForEachIteratorObject(ctx, o);
+    Object *obj = new (memoryManager) ForEachIteratorObject(ctx, o);
+    return obj->asReturned<Object>();
 }
 
-Object *ExecutionEngine::qmlContextObject() const
+Returned<Object> *ExecutionEngine::qmlContextObject() const
 {
     ExecutionContext *ctx = current;
 
@@ -527,7 +534,7 @@ Object *ExecutionEngine::qmlContextObject() const
     if (ctx->type != ExecutionContext::Type_QmlContext)
         return 0;
 
-    return static_cast<CallContext *>(ctx)->activation;
+    return static_cast<CallContext *>(ctx)->activation->asReturned<Object>();
 }
 
 namespace {
diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index 5ef7d08a4a..297f756033 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -274,9 +274,9 @@ struct Q_QML_EXPORT ExecutionEngine
     Returned<Object> *newNumberObject(const Value &value);
     Returned<Object> *newBooleanObject(const Value &value);
 
-    ArrayObject *newArrayObject(int count = 0);
-    ArrayObject *newArrayObject(const QStringList &list);
-    ArrayObject *newArrayObject(InternalClass *ic);
+    Returned<ArrayObject> *newArrayObject(int count = 0);
+    Returned<ArrayObject> *newArrayObject(const QStringList &list);
+    Returned<ArrayObject> *newArrayObject(InternalClass *ic);
 
     Returned<DateObject> *newDateObject(const Value &value);
     Returned<DateObject> *newDateObject(const QDateTime &dt);
@@ -288,17 +288,17 @@ struct Q_QML_EXPORT ExecutionEngine
     Returned<Object> *newErrorObject(const Value &value);
     Returned<Object> *newSyntaxErrorObject(const QString &message, const QString &fileName, int line, int column);
     Returned<Object> *newSyntaxErrorObject(const QString &message);
-    Object *newReferenceErrorObject(const QString &message);
-    Object *newReferenceErrorObject(const QString &message, const QString &fileName, int lineNumber, int columnNumber);
-    Object *newTypeErrorObject(const QString &message);
-    Object *newRangeErrorObject(const QString &message);
-    Object *newURIErrorObject(Value message);
+    Returned<Object> *newReferenceErrorObject(const QString &message);
+    Returned<Object> *newReferenceErrorObject(const QString &message, const QString &fileName, int lineNumber, int columnNumber);
+    Returned<Object> *newTypeErrorObject(const QString &message);
+    Returned<Object> *newRangeErrorObject(const QString &message);
+    Returned<Object> *newURIErrorObject(Value message);
 
-    Object *newVariantObject(const QVariant &v);
+    Returned<Object> *newVariantObject(const QVariant &v);
 
-    Object *newForEachIteratorObject(ExecutionContext *ctx, Object *o);
+    Returned<Object> *newForEachIteratorObject(ExecutionContext *ctx, Object *o);
 
-    Object *qmlContextObject() const;
+    Returned<Object> *qmlContextObject() const;
 
     struct StackFrame {
         QString source;
diff --git a/src/qml/jsruntime/qv4include.cpp b/src/qml/jsruntime/qv4include.cpp
index ac9a50c3a1..740bb406f3 100644
--- a/src/qml/jsruntime/qv4include.cpp
+++ b/src/qml/jsruntime/qv4include.cpp
@@ -196,11 +196,11 @@ QV4::ReturnedValue QV4Include::method_include(QV4::SimpleCallContext *ctx)
     QString localFile = QQmlFile::urlToLocalFileOrQrc(url);
 
     QV4::ScopedValue result(scope);
+    QV4::Scoped<QV4::Object> qmlcontextobject(scope, v4->qmlContextObject());
 
     if (localFile.isEmpty()) {
-
         QV4Include *i = new QV4Include(url, engine, context,
-                                       QV4::Value::fromObject(v4->qmlContextObject()),
+                                       qmlcontextobject.asValue(),
                                        callbackFunction);
         result = i->result();
 
@@ -213,8 +213,7 @@ QV4::ReturnedValue QV4Include::method_include(QV4::SimpleCallContext *ctx)
             QString code = QString::fromUtf8(data);
             QQmlScript::Parser::extractPragmas(code);
 
-            QV4::Scoped<QV4::Object> qmlglobal(scope, QV4::Value::fromObject(v4->qmlContextObject()));
-            QV4::Script script(v4, qmlglobal.getPointer(), code, url.toString());
+            QV4::Script script(v4, qmlcontextobject.getPointer(), code, url.toString());
 
             QV4::ExecutionContext *ctx = v4->current;
             try {
diff --git a/src/qml/jsruntime/qv4jsonobject.cpp b/src/qml/jsruntime/qv4jsonobject.cpp
index a42cfd4873..2bb755b537 100644
--- a/src/qml/jsruntime/qv4jsonobject.cpp
+++ b/src/qml/jsruntime/qv4jsonobject.cpp
@@ -77,8 +77,8 @@ private:
     inline bool eatSpace();
     inline QChar nextToken();
 
-    Value parseObject();
-    Value parseArray();
+    ReturnedValue parseObject();
+    ReturnedValue parseArray();
     bool parseMember(Object *o);
     bool parseString(QString *string);
     bool parseValue(Value *val);
@@ -224,42 +224,42 @@ Value JsonParser::parse(QJsonParseError *error)
     end-object
 */
 
-Value JsonParser::parseObject()
+ReturnedValue JsonParser::parseObject()
 {
     if (++nestingLevel > nestingLimit) {
         lastError = QJsonParseError::DeepNesting;
-        return Value::undefinedValue();
+        return Encode::undefined();
     }
 
     BEGIN << "parseObject pos=" << json;
+    Scope scope(context);
 
-    Object *o = context->engine->newObject();
-    Value objectVal = Value::fromObject(o);
+    Scoped<Object> o(scope, context->engine->newObject());
 
     QChar token = nextToken();
     while (token == Quote) {
-        if (!parseMember(o))
-            return Value::undefinedValue();
+        if (!parseMember(o.getPointer()))
+            return Encode::undefined();
         token = nextToken();
         if (token != ValueSeparator)
             break;
         token = nextToken();
         if (token == EndObject) {
             lastError = QJsonParseError::MissingObject;
-            return Value::undefinedValue();
+            return Encode::undefined();
         }
     }
 
     DEBUG << "end token=" << token;
     if (token != EndObject) {
         lastError = QJsonParseError::UnterminatedObject;
-        return Value::undefinedValue();
+        return Encode::undefined();
     }
 
     END;
 
     --nestingLevel;
-    return objectVal;
+    return o.asReturnedValue();
 }
 
 /*
@@ -291,19 +291,20 @@ bool JsonParser::parseMember(Object *o)
 /*
     array = begin-array [ value *( value-separator value ) ] end-array
 */
-Value JsonParser::parseArray()
+ReturnedValue JsonParser::parseArray()
 {
+    Scope scope(context);
     BEGIN << "parseArray";
-    ArrayObject *array = context->engine->newArrayObject();
+    Scoped<ArrayObject> array(scope, context->engine->newArrayObject());
 
     if (++nestingLevel > nestingLimit) {
         lastError = QJsonParseError::DeepNesting;
-        return Value::undefinedValue();
+        return Encode::undefined();
     }
 
     if (!eatSpace()) {
         lastError = QJsonParseError::UnterminatedArray;
-        return Value::undefinedValue();
+        return Encode::undefined();
     }
     if (*json == EndArray) {
         nextToken();
@@ -312,7 +313,7 @@ Value JsonParser::parseArray()
         while (1) {
             Value val;
             if (!parseValue(&val))
-                return Value::undefinedValue();
+                return Encode::undefined();
             array->arraySet(index, val);
             QChar token = nextToken();
             if (token == EndArray)
@@ -322,7 +323,7 @@ Value JsonParser::parseArray()
                     lastError = QJsonParseError::UnterminatedArray;
                 else
                     lastError = QJsonParseError::MissingValueSeparator;
-                return Value::undefinedValue();
+                return Encode::undefined();
             }
             ++index;
         }
@@ -332,7 +333,7 @@ Value JsonParser::parseArray()
     END;
 
     --nestingLevel;
-    return Value::fromObject(array);
+    return array.asReturnedValue();
 }
 
 /*
@@ -401,7 +402,7 @@ bool JsonParser::parseValue(Value *val)
         return true;
     }
     case BeginArray: {
-        *val = parseArray();
+        *val = Value::fromReturnedValue(parseArray());
         if (val->isUndefined())
             return false;
         DEBUG << "value: array";
@@ -409,7 +410,7 @@ bool JsonParser::parseValue(Value *val)
         return true;
     }
     case BeginObject: {
-        *val = parseObject();
+        *val = Value::fromReturnedValue(parseObject());
         if (val->isUndefined())
             return false;
         DEBUG << "value: object";
@@ -1020,14 +1021,15 @@ QJsonObject JsonObject::toJsonObject(QV4::Object *o, V4ObjectSet &visitedObjects
 
 QV4::ReturnedValue JsonObject::fromJsonArray(ExecutionEngine *engine, const QJsonArray &array)
 {
+    Scope scope(engine);
     int size = array.size();
-    ArrayObject *a = engine->newArrayObject();
+    Scoped<ArrayObject> a(scope, engine->newArrayObject());
     a->arrayReserve(size);
     a->arrayDataLen = size;
     for (int i = 0; i < size; i++)
         a->arrayData[i].value = Value::fromReturnedValue(fromJsonValue(engine, array.at(i)));
     a->setArrayLengthUnchecked(size);
-    return Value::fromObject(a).asReturnedValue();
+    return a.asReturnedValue();
 }
 
 QJsonArray JsonObject::toJsonArray(ArrayObject *a, V4ObjectSet &visitedObjects)
diff --git a/src/qml/jsruntime/qv4object.cpp b/src/qml/jsruntime/qv4object.cpp
index 7b372a4e17..6496a0354a 100644
--- a/src/qml/jsruntime/qv4object.cpp
+++ b/src/qml/jsruntime/qv4object.cpp
@@ -1424,6 +1424,8 @@ void Object::markArrayObjects() const
     }
 }
 
+DEFINE_MANAGED_VTABLE(ArrayObject);
+
 ArrayObject::ArrayObject(ExecutionEngine *engine, const QStringList &list)
     : Object(engine->arrayClass)
 {
diff --git a/src/qml/jsruntime/qv4object_p.h b/src/qml/jsruntime/qv4object_p.h
index b7b08c2b34..765ec18728 100644
--- a/src/qml/jsruntime/qv4object_p.h
+++ b/src/qml/jsruntime/qv4object_p.h
@@ -375,6 +375,7 @@ protected:
 };
 
 struct ArrayObject: Object {
+    Q_MANAGED
     enum {
         LengthPropertyIndex = 0
     };
diff --git a/src/qml/jsruntime/qv4objectproto.cpp b/src/qml/jsruntime/qv4objectproto.cpp
index fe041f0bd7..073d588e56 100644
--- a/src/qml/jsruntime/qv4objectproto.cpp
+++ b/src/qml/jsruntime/qv4objectproto.cpp
@@ -355,7 +355,7 @@ ReturnedValue ObjectPrototype::method_keys(SimpleCallContext *ctx)
     Scope scope(ctx);
     Object *o = ctx->argument(0).objectValue();
 
-    ArrayObject *a = ctx->engine->newArrayObject();
+    Scoped<ArrayObject> a(scope, ctx->engine->newArrayObject());
 
     ObjectIterator it(o, ObjectIterator::EnumerableOnly);
     ScopedValue name(scope);
@@ -366,7 +366,7 @@ ReturnedValue ObjectPrototype::method_keys(SimpleCallContext *ctx)
         a->push_back(name);
     }
 
-    return Value::fromObject(a).asReturnedValue();
+    return a.asReturnedValue();
 }
 
 ReturnedValue ObjectPrototype::method_toString(SimpleCallContext *ctx)
@@ -608,10 +608,10 @@ ReturnedValue ObjectPrototype::fromPropertyDescriptor(ExecutionContext *ctx, con
 ArrayObject *ObjectPrototype::getOwnPropertyNames(ExecutionEngine *v4, const Value &o)
 {
     Scope scope(v4);
-    ArrayObject *array = v4->newArrayObject();
+    Scoped<ArrayObject> array(scope, v4->newArrayObject());
     Object *O = o.asObject();
     if (!O)
-        return array;
+        return array.getPointer();
 
     ObjectIterator it(O, ObjectIterator::NoFlags);
     ScopedValue name(scope);
@@ -621,5 +621,5 @@ ArrayObject *ObjectPrototype::getOwnPropertyNames(ExecutionEngine *v4, const Val
             break;
         array->push_back(name);
     }
-    return array;
+    return array.getPointer();
 }
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index abff3ac93d..d774014073 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -323,8 +323,9 @@ ReturnedValue QObjectWrapper::getQmlProperty(ExecutionContext *ctx, QQmlContextD
             Q_ASSERT(vmemo);
             return vmemo->vmeMethod(result->coreIndex);
         } else if (result->isV4Function()) {
+            QV4::Scoped<QV4::Object> qmlcontextobject(scope, ctx->engine->qmlContextObject());
             return QV4::QObjectMethod::create(ctx->engine->rootContext, m_object, result->coreIndex,
-                                              QV4::Value::fromObject(ctx->engine->qmlContextObject())).asReturnedValue();
+                                              qmlcontextobject.asValue()).asReturnedValue();
         } else if (result->isSignalHandler()) {
             QV4::QmlSignalHandler *handler = new (ctx->engine->memoryManager) QV4::QmlSignalHandler(ctx->engine, m_object, result->coreIndex);
 
@@ -1603,13 +1604,13 @@ QV4::ReturnedValue CallArgument::toValue(QV8Engine *engine)
         // XXX Can this be made more by using Array as a prototype and implementing
         // directly against QList<QObject*>?
         QList<QObject *> &list = *qlistPtr;
-        QV4::ArrayObject *array = v4->newArrayObject();
+        QV4::Scoped<ArrayObject> array(scope, v4->newArrayObject());
         array->arrayReserve(list.count());
         array->arrayDataLen = list.count();
         for (int ii = 0; ii < list.count(); ++ii)
             array->arrayData[ii].value = Value::fromReturnedValue(QV4::QObjectWrapper::wrap(v4, list.at(ii)));
         array->setArrayLengthUnchecked(list.count());
-        return QV4::Value::fromObject(array).asReturnedValue();
+        return array.asReturnedValue();
     } else if (type == qMetaTypeId<QQmlV4Handle>()) {
         return handlePtr->toValue().asReturnedValue();
     } else if (type == QMetaType::QJsonArray) {
diff --git a/src/qml/jsruntime/qv4regexpobject.cpp b/src/qml/jsruntime/qv4regexpobject.cpp
index 38ebf8d9e6..60a5026772 100644
--- a/src/qml/jsruntime/qv4regexpobject.cpp
+++ b/src/qml/jsruntime/qv4regexpobject.cpp
@@ -321,7 +321,7 @@ ReturnedValue RegExpPrototype::method_exec(SimpleCallContext *ctx)
     }
 
     // fill in result data
-    ArrayObject *array = ctx->engine->newArrayObject(ctx->engine->regExpExecArrayClass);
+    Scoped<ArrayObject> array(scope, ctx->engine->newArrayObject(ctx->engine->regExpExecArrayClass));
     int len = r->value->captureCount();
     array->arrayReserve(len);
     for (int i = 0; i < len; ++i) {
@@ -338,7 +338,7 @@ ReturnedValue RegExpPrototype::method_exec(SimpleCallContext *ctx)
     if (r->global)
         r->lastIndexProperty(ctx)->value = Value::fromInt32(matchOffsets[1]);
 
-    return Value::fromObject(array).asReturnedValue();
+    return array.asReturnedValue();
 }
 
 ReturnedValue RegExpPrototype::method_test(SimpleCallContext *ctx)
diff --git a/src/qml/jsruntime/qv4runtime.cpp b/src/qml/jsruntime/qv4runtime.cpp
index d98087b6a4..f2c655f5fe 100644
--- a/src/qml/jsruntime/qv4runtime.cpp
+++ b/src/qml/jsruntime/qv4runtime.cpp
@@ -735,11 +735,12 @@ void __qmljs_set_element(ExecutionContext *ctx, const ValueRef object, const Val
 
 ReturnedValue __qmljs_foreach_iterator_object(ExecutionContext *ctx, const ValueRef in)
 {
-    Object *o = 0;
+    Scope scope(ctx);
+    Scoped<Object> o(scope, (Object *)0);
     if (!in->isNullOrUndefined())
-        o = in->toObject(ctx);
-    Object *it = ctx->engine->newForEachIteratorObject(ctx, o);
-    return Value::fromObject(it).asReturnedValue();
+        o = in;
+    Scoped<Object> it(scope, ctx->engine->newForEachIteratorObject(ctx, o.getPointer()));
+    return it.asReturnedValue();
 }
 
 ReturnedValue __qmljs_foreach_next_property_name(const ValueRef foreach_iterator)
@@ -1161,7 +1162,8 @@ void __qmljs_builtin_define_property(ExecutionContext *ctx, const ValueRef objec
 
 ReturnedValue __qmljs_builtin_define_array(ExecutionContext *ctx, Value *values, uint length)
 {
-    ArrayObject *a = ctx->engine->newArrayObject();
+    Scope scope(ctx);
+    Scoped<ArrayObject> a(scope, ctx->engine->newArrayObject());
 
     // ### FIXME: We need to allocate the array data to avoid crashes other places
     // This should rather be done when required
@@ -1181,7 +1183,7 @@ ReturnedValue __qmljs_builtin_define_array(ExecutionContext *ctx, Value *values,
         }
         a->setArrayLengthUnchecked(length);
     }
-    return Value::fromObject(a).asReturnedValue();
+    return a.asReturnedValue();
 }
 
 void __qmljs_builtin_define_getter_setter(ExecutionContext *ctx, const ValueRef object, String *name, const ValueRef getter, const ValueRef setter)
diff --git a/src/qml/jsruntime/qv4scopedvalue_p.h b/src/qml/jsruntime/qv4scopedvalue_p.h
index 4bbd3303ee..5fe870c21d 100644
--- a/src/qml/jsruntime/qv4scopedvalue_p.h
+++ b/src/qml/jsruntime/qv4scopedvalue_p.h
@@ -197,6 +197,7 @@ struct Scoped
 #endif
     }
 
+    // ### GC FIX casting below to be safe
     Scoped(const Scope &scope, const Value &v)
     {
         ptr = scope.engine->jsStackTop++;
diff --git a/src/qml/jsruntime/qv4serialize.cpp b/src/qml/jsruntime/qv4serialize.cpp
index f76f76b6d2..41481ac1b8 100644
--- a/src/qml/jsruntime/qv4serialize.cpp
+++ b/src/qml/jsruntime/qv4serialize.cpp
@@ -317,13 +317,13 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
     case WorkerArray:
     {
         quint32 size = headersize(header);
-        QV4::ArrayObject *a = v4->newArrayObject();
+        Scoped<ArrayObject> a(scope, v4->newArrayObject());
         ScopedValue v(scope);
         for (quint32 ii = 0; ii < size; ++ii) {
             v = deserialize(data, engine);
             a->putIndexed(ii, v);
         }
-        return QV4::Value::fromObject(a).asReturnedValue();
+        return a.asReturnedValue();
     }
     case WorkerObject:
     {
@@ -377,7 +377,7 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
         quint32 seqLength = length - 1;
         value = deserialize(data, engine);
         int sequenceType = value->integerValue();
-        QV4::ArrayObject *array = v4->newArrayObject();
+        Scoped<ArrayObject> array(scope, v4->newArrayObject());
         array->arrayReserve(seqLength);
         array->arrayDataLen = seqLength;
         for (quint32 ii = 0; ii < seqLength; ++ii) {
@@ -385,7 +385,7 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
             array->arrayData[ii].value = value;
         }
         array->setArrayLengthUnchecked(seqLength);
-        QVariant seqVariant = QV4::SequencePrototype::toVariant(QV4::Value::fromObject(array), sequenceType, &succeeded);
+        QVariant seqVariant = QV4::SequencePrototype::toVariant(array.asValue(), sequenceType, &succeeded);
         return QV4::SequencePrototype::fromVariant(v4, seqVariant, &succeeded);
     }
     }
diff --git a/src/qml/jsruntime/qv4stringobject.cpp b/src/qml/jsruntime/qv4stringobject.cpp
index 2223432ec9..811c5b26b9 100644
--- a/src/qml/jsruntime/qv4stringobject.cpp
+++ b/src/qml/jsruntime/qv4stringobject.cpp
@@ -379,7 +379,7 @@ ReturnedValue StringPrototype::method_match(SimpleCallContext *context)
 
     String *lastIndex = context->engine->newString(QStringLiteral("lastIndex"));
     rx->put(lastIndex, Value::fromInt32(0));
-    ArrayObject *a = context->engine->newArrayObject();
+    Scoped<ArrayObject> a(scope, context->engine->newArrayObject());
 
     double previousLastIndex = 0;
     uint n = 0;
@@ -406,7 +406,7 @@ ReturnedValue StringPrototype::method_match(SimpleCallContext *context)
     if (!n)
         return Encode::null();
 
-    return Value::fromObject(a).asReturnedValue();
+    return a.asReturnedValue();
 
 }
 
@@ -618,6 +618,7 @@ ReturnedValue StringPrototype::method_slice(SimpleCallContext *ctx)
 
 ReturnedValue StringPrototype::method_split(SimpleCallContext *ctx)
 {
+    Scope scope(ctx);
     QString text;
     if (StringObject *thisObject = ctx->thisObject.asStringObject())
         text = thisObject->value.stringValue()->toQString();
@@ -627,13 +628,12 @@ ReturnedValue StringPrototype::method_split(SimpleCallContext *ctx)
     Value separatorValue = ctx->argumentCount > 0 ? ctx->argument(0) : Value::undefinedValue();
     Value limitValue = ctx->argumentCount > 1 ? ctx->argument(1) : Value::undefinedValue();
 
-    ArrayObject* array = ctx->engine->newArrayObject();
-    Value result = Value::fromObject(array);
+    Scoped<ArrayObject> array(scope, ctx->engine->newArrayObject());
 
     if (separatorValue.isUndefined()) {
         if (limitValue.isUndefined()) {
             array->push_back(Value::fromString(ctx, text));
-            return result.asReturnedValue();
+            return array.asReturnedValue();
         }
         return Value::fromString(ctx, text.left(limitValue.toInteger())).asReturnedValue();
     }
@@ -641,7 +641,7 @@ ReturnedValue StringPrototype::method_split(SimpleCallContext *ctx)
     uint limit = limitValue.isUndefined() ? UINT_MAX : limitValue.toUInt32();
 
     if (limit == 0)
-        return result.asReturnedValue();
+        return array.asReturnedValue();
 
     if (RegExpObject* re = separatorValue.as<RegExpObject>()) {
         if (re->value->pattern().isEmpty()) {
@@ -679,7 +679,7 @@ ReturnedValue StringPrototype::method_split(SimpleCallContext *ctx)
         if (separator.isEmpty()) {
             for (uint i = 0; i < qMin(limit, uint(text.length())); ++i)
                 array->push_back(Value::fromString(ctx, text.mid(i, 1)));
-            return result.asReturnedValue();
+            return array.asReturnedValue();
         }
 
         int start = 0;
@@ -693,7 +693,7 @@ ReturnedValue StringPrototype::method_split(SimpleCallContext *ctx)
         if (array->arrayLength() < limit && start != -1)
             array->push_back(Value::fromString(ctx, text.mid(start)));
     }
-    return result.asReturnedValue();
+    return array.asReturnedValue();
 }
 
 ReturnedValue StringPrototype::method_substr(SimpleCallContext *context)