Convert more builtin functions to the new calling convention

Change-Id: I053215261e1186aff25f29e0967219ef667f7678
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

15 files changed, 424 insertions, 451 deletions

diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index 77dbb18b50..7260e71fab 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -826,40 +826,39 @@ struct QObjectSlotDispatcher : public QtPrivate::QSlotObjectBase
 
 } // namespace QV4
 
-ReturnedValue QObjectWrapper::method_connect(CallContext *ctx)
+void QObjectWrapper::method_connect(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    if (ctx->argc() == 0)
-        V4THROW_ERROR("Function.prototype.connect: no arguments given");
+    if (callData->argc == 0)
+        THROW_GENERIC_ERROR("Function.prototype.connect: no arguments given");
 
-    QPair<QObject *, int> signalInfo = extractQtSignal(ctx->thisObject());
+    QPair<QObject *, int> signalInfo = extractQtSignal(callData->thisObject);
     QObject *signalObject = signalInfo.first;
     int signalIndex = signalInfo.second; // in method range, not signal range!
 
     if (signalIndex < 0)
-        V4THROW_ERROR("Function.prototype.connect: this object is not a signal");
+        THROW_GENERIC_ERROR("Function.prototype.connect: this object is not a signal");
 
     if (!signalObject)
-        V4THROW_ERROR("Function.prototype.connect: cannot connect to deleted QObject");
+        THROW_GENERIC_ERROR("Function.prototype.connect: cannot connect to deleted QObject");
 
     if (signalObject->metaObject()->method(signalIndex).methodType() != QMetaMethod::Signal)
-        V4THROW_ERROR("Function.prototype.connect: this object is not a signal");
+        THROW_GENERIC_ERROR("Function.prototype.connect: this object is not a signal");
 
-    QV4::Scope scope(ctx);
     QV4::ScopedFunctionObject f(scope);
     QV4::ScopedValue thisObject (scope, QV4::Encode::undefined());
 
-    if (ctx->argc() == 1) {
-        f = ctx->args()[0];
-    } else if (ctx->argc() >= 2) {
-        thisObject = ctx->args()[0];
-        f = ctx->args()[1];
+    if (callData->argc == 1) {
+        f = callData->args[0];
+    } else if (callData->argc >= 2) {
+        thisObject = callData->args[0];
+        f = callData->args[1];
     }
 
     if (!f)
-        V4THROW_ERROR("Function.prototype.connect: target is not a function");
+        THROW_GENERIC_ERROR("Function.prototype.connect: target is not a function");
 
     if (!thisObject->isUndefined() && !thisObject->isObject())
-        V4THROW_ERROR("Function.prototype.connect: target this is not an object");
+        THROW_GENERIC_ERROR("Function.prototype.connect: target this is not an object");
 
     QV4::QObjectSlotDispatcher *slot = new QV4::QObjectSlotDispatcher;
     slot->signalIndex = signalIndex;
@@ -874,49 +873,47 @@ ReturnedValue QObjectWrapper::method_connect(CallContext *ctx)
     }
     QObjectPrivate::connect(signalObject, signalIndex, slot, Qt::AutoConnection);
 
-    return Encode::undefined();
+    RETURN_UNDEFINED();
 }
 
-ReturnedValue QObjectWrapper::method_disconnect(CallContext *ctx)
+void QObjectWrapper::method_disconnect(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    if (ctx->argc() == 0)
-        V4THROW_ERROR("Function.prototype.disconnect: no arguments given");
-
-    QV4::Scope scope(ctx);
+    if (callData->argc == 0)
+        THROW_GENERIC_ERROR("Function.prototype.disconnect: no arguments given");
 
-    QPair<QObject *, int> signalInfo = extractQtSignal(ctx->thisObject());
+    QPair<QObject *, int> signalInfo = extractQtSignal(callData->thisObject);
     QObject *signalObject = signalInfo.first;
     int signalIndex = signalInfo.second;
 
     if (signalIndex == -1)
-        V4THROW_ERROR("Function.prototype.disconnect: this object is not a signal");
+        THROW_GENERIC_ERROR("Function.prototype.disconnect: this object is not a signal");
 
     if (!signalObject)
-        V4THROW_ERROR("Function.prototype.disconnect: cannot disconnect from deleted QObject");
+        THROW_GENERIC_ERROR("Function.prototype.disconnect: cannot disconnect from deleted QObject");
 
     if (signalIndex < 0 || signalObject->metaObject()->method(signalIndex).methodType() != QMetaMethod::Signal)
-        V4THROW_ERROR("Function.prototype.disconnect: this object is not a signal");
+        THROW_GENERIC_ERROR("Function.prototype.disconnect: this object is not a signal");
 
     QV4::ScopedFunctionObject functionValue(scope);
     QV4::ScopedValue functionThisValue(scope, QV4::Encode::undefined());
 
-    if (ctx->argc() == 1) {
-        functionValue = ctx->args()[0];
-    } else if (ctx->argc() >= 2) {
-        functionThisValue = ctx->args()[0];
-        functionValue = ctx->args()[1];
+    if (callData->argc == 1) {
+        functionValue = callData->args[0];
+    } else if (callData->argc >= 2) {
+        functionThisValue = callData->args[0];
+        functionValue = callData->args[1];
     }
 
     if (!functionValue)
-        V4THROW_ERROR("Function.prototype.disconnect: target is not a function");
+        THROW_GENERIC_ERROR("Function.prototype.disconnect: target is not a function");
 
     if (!functionThisValue->isUndefined() && !functionThisValue->isObject())
-        V4THROW_ERROR("Function.prototype.disconnect: target this is not an object");
+        THROW_GENERIC_ERROR("Function.prototype.disconnect: target this is not an object");
 
     QPair<QObject *, int> functionData = QObjectMethod::extractQtMethod(functionValue);
 
     void *a[] = {
-        ctx->d()->engine,
+        scope.engine,
         functionValue.ptr,
         functionThisValue.ptr,
         functionData.first,
@@ -925,7 +922,7 @@ ReturnedValue QObjectWrapper::method_disconnect(CallContext *ctx)
 
     QObjectPrivate::disconnect(signalObject, signalIndex, reinterpret_cast<void**>(&a));
 
-    return Encode::undefined();
+    RETURN_UNDEFINED();
 }
 
 static void markChildQObjectsRecursively(QObject *parent, QV4::ExecutionEngine *e)
diff --git a/src/qml/jsruntime/qv4qobjectwrapper_p.h b/src/qml/jsruntime/qv4qobjectwrapper_p.h
index c7c4f4dd77..b09e06cec5 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper_p.h
+++ b/src/qml/jsruntime/qv4qobjectwrapper_p.h
@@ -197,8 +197,8 @@ protected:
     static void advanceIterator(Managed *m, ObjectIterator *it, Value *name, uint *index, Property *p, PropertyAttributes *attributes);
     static void markObjects(Heap::Base *that, QV4::ExecutionEngine *e);
 
-    static ReturnedValue method_connect(CallContext *ctx);
-    static ReturnedValue method_disconnect(CallContext *ctx);
+    static void method_connect(const BuiltinFunction *, Scope &scope, CallData *callData);
+    static void method_disconnect(const BuiltinFunction *, Scope &scope, CallData *callData);
 
 private:
     Q_NEVER_INLINE static ReturnedValue wrap_slowPath(ExecutionEngine *engine, QObject *object);
diff --git a/src/qml/jsruntime/qv4scopedvalue_p.h b/src/qml/jsruntime/qv4scopedvalue_p.h
index 6cdc6200e7..6775028272 100644
--- a/src/qml/jsruntime/qv4scopedvalue_p.h
+++ b/src/qml/jsruntime/qv4scopedvalue_p.h
@@ -94,6 +94,12 @@ struct ScopedValue;
         return; \
     } while (false)
 
+#define THROW_GENERIC_ERROR(str) \
+    do { \
+        scope.result = scope.engine->throwError(QString::fromUtf8(str)); \
+        return; \
+    } while (false)
+
 struct Scope {
     inline Scope(ExecutionContext *ctx)
         : engine(ctx->d()->engine)
diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp
index 58da7b9f68..8ce10e326d 100644
--- a/src/qml/jsruntime/qv4sequenceobject.cpp
+++ b/src/qml/jsruntime/qv4sequenceobject.cpp
@@ -404,28 +404,28 @@ public:
 
     struct CompareFunctor
     {
-        CompareFunctor(QV4::ExecutionContext *ctx, const QV4::Value &compareFn)
-            : m_ctx(ctx), m_compareFn(&compareFn)
+        CompareFunctor(QV4::ExecutionEngine *v4, const QV4::Value &compareFn)
+            : m_v4(v4), m_compareFn(&compareFn)
         {}
 
         bool operator()(typename Container::value_type lhs, typename Container::value_type rhs)
         {
-            QV4::Scope scope(m_ctx);
+            QV4::Scope scope(m_v4);
             ScopedObject compare(scope, m_compareFn);
             ScopedCallData callData(scope, 2);
-            callData->args[0] = convertElementToValue(this->m_ctx->d()->engine, lhs);
-            callData->args[1] = convertElementToValue(this->m_ctx->d()->engine, rhs);
-            callData->thisObject = this->m_ctx->d()->engine->globalObject;
+            callData->args[0] = convertElementToValue(m_v4, lhs);
+            callData->args[1] = convertElementToValue(m_v4, rhs);
+            callData->thisObject = m_v4->globalObject;
             compare->call(scope, callData);
             return scope.result.toNumber() < 0;
         }
 
     private:
-        QV4::ExecutionContext *m_ctx;
+        QV4::ExecutionEngine *m_v4;
         const QV4::Value *m_compareFn;
     };
 
-    void sort(QV4::CallContext *ctx)
+    void sort(const BuiltinFunction *, Scope &scope, CallData *callData)
     {
         if (d()->isReference) {
             if (!d()->object)
@@ -433,9 +433,8 @@ public:
             loadReference();
         }
 
-        QV4::Scope scope(ctx);
-        if (ctx->argc() == 1 && ctx->args()[0].as<FunctionObject>()) {
-            CompareFunctor cf(ctx, ctx->args()[0]);
+        if (callData->argc == 1 && callData->args[0].as<FunctionObject>()) {
+            CompareFunctor cf(scope.engine, callData->args[0]);
             std::sort(d()->container->begin(), d()->container->end(), cf);
         } else {
             DefaultCompareFunctor cf;
@@ -446,45 +445,43 @@ public:
             storeReference();
     }
 
-    static QV4::ReturnedValue method_get_length(QV4::CallContext *ctx)
+    static void method_get_length(const BuiltinFunction *, Scope &scope, CallData *callData)
     {
-        QV4::Scope scope(ctx);
-        QV4::Scoped<QQmlSequence<Container> > This(scope, ctx->thisObject().as<QQmlSequence<Container> >());
+        QV4::Scoped<QQmlSequence<Container> > This(scope, callData->thisObject.as<QQmlSequence<Container> >());
         if (!This)
-            return ctx->engine()->throwTypeError();
+            THROW_TYPE_ERROR();
 
         if (This->d()->isReference) {
             if (!This->d()->object)
-                return QV4::Encode(0);
+                RETURN_RESULT(Encode(0));
             This->loadReference();
         }
-        return QV4::Encode(This->d()->container->count());
+        RETURN_RESULT(Encode(This->d()->container->count()));
     }
 
-    static QV4::ReturnedValue method_set_length(QV4::CallContext* ctx)
+    static void method_set_length(const BuiltinFunction *, Scope &scope, CallData *callData)
     {
-        QV4::Scope scope(ctx);
-        QV4::Scoped<QQmlSequence<Container> > This(scope, ctx->thisObject().as<QQmlSequence<Container> >());
+        QV4::Scoped<QQmlSequence<Container> > This(scope, callData->thisObject.as<QQmlSequence<Container> >());
         if (!This)
-            return ctx->engine()->throwTypeError();
+            THROW_TYPE_ERROR();
 
-        quint32 newLength = ctx->args()[0].toUInt32();
+        quint32 newLength = callData->args[0].toUInt32();
         /* Qt containers have int (rather than uint) allowable indexes. */
         if (newLength > INT_MAX) {
             generateWarning(scope.engine, QLatin1String("Index out of range during length set"));
-            return QV4::Encode::undefined();
+            RETURN_UNDEFINED();
         }
         /* Read the sequence from the QObject property if we're a reference */
         if (This->d()->isReference) {
             if (!This->d()->object)
-                return QV4::Encode::undefined();
+                RETURN_UNDEFINED();
             This->loadReference();
         }
         /* Determine whether we need to modify the sequence */
         qint32 newCount = static_cast<qint32>(newLength);
         qint32 count = This->d()->container->count();
         if (newCount == count) {
-            return QV4::Encode::undefined();
+            RETURN_UNDEFINED();
         } else if (newCount > count) {
             /* according to ECMA262r3 we need to insert */
             /* undefined values increasing length to newLength. */
@@ -506,7 +503,7 @@ public:
             /* write back.  already checked that object is non-null, so skip that check here. */
             This->storeReference();
         }
-        return QV4::Encode::undefined();
+        RETURN_UNDEFINED();
     }
 
     QVariant toVariant() const
@@ -625,26 +622,25 @@ void SequencePrototype::init()
 }
 #undef REGISTER_QML_SEQUENCE_METATYPE
 
-QV4::ReturnedValue SequencePrototype::method_sort(QV4::CallContext *ctx)
+void SequencePrototype::method_sort(const BuiltinFunction *b, Scope &scope, CallData *callData)
 {
-    QV4::Scope scope(ctx);
-    QV4::ScopedObject o(scope, ctx->thisObject());
+    QV4::ScopedObject o(scope, callData->thisObject);
     if (!o || !o->isListType())
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
-    if (ctx->argc() >= 2)
-        return o.asReturnedValue();
+    if (callData->argc >= 2)
+        RETURN_RESULT(o);
 
 #define CALL_SORT(SequenceElementType, SequenceElementTypeName, SequenceType, DefaultValue) \
         if (QQml##SequenceElementTypeName##List *s = o->as<QQml##SequenceElementTypeName##List>()) { \
-            s->sort(ctx); \
+            s->sort(b, scope, callData); \
         } else
 
         FOREACH_QML_SEQUENCE_TYPE(CALL_SORT)
 
 #undef CALL_SORT
         {}
-    return o.asReturnedValue();
+    RETURN_RESULT(o);
 }
 
 #define IS_SEQUENCE(unused1, unused2, SequenceType, unused3) \
diff --git a/src/qml/jsruntime/qv4sequenceobject_p.h b/src/qml/jsruntime/qv4sequenceobject_p.h
index c0416ad639..6f96b9f760 100644
--- a/src/qml/jsruntime/qv4sequenceobject_p.h
+++ b/src/qml/jsruntime/qv4sequenceobject_p.h
@@ -67,12 +67,12 @@ struct SequencePrototype : public QV4::Object
 {
     void init();
 
-    static ReturnedValue method_valueOf(QV4::CallContext *ctx)
+    static void method_valueOf(const BuiltinFunction *, Scope &scope, CallData *callData)
     {
-        return ctx->thisObject().toString(ctx->engine())->asReturnedValue();
+        scope.result = callData->thisObject.toString(scope.engine);
     }
 
-    static ReturnedValue method_sort(QV4::CallContext *ctx);
+    static void method_sort(const BuiltinFunction *, Scope &scope, CallData *callData);
 
     static bool isSequenceType(int sequenceTypeId);
     static ReturnedValue newSequence(QV4::ExecutionEngine *engine, int sequenceTypeId, QObject *object, int propertyIndex, bool *succeeded);
diff --git a/src/qml/jsruntime/qv4variantobject.cpp b/src/qml/jsruntime/qv4variantobject.cpp
index 455a7ccb65..5cab4c5386 100644
--- a/src/qml/jsruntime/qv4variantobject.cpp
+++ b/src/qml/jsruntime/qv4variantobject.cpp
@@ -113,67 +113,68 @@ void VariantPrototype::init()
     defineDefaultProperty(engine()->id_toString(), method_toString, 0);
 }
 
-QV4::ReturnedValue VariantPrototype::method_preserve(CallContext *ctx)
+void VariantPrototype::method_preserve(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<VariantObject> o(scope, ctx->thisObject().as<QV4::VariantObject>());
+    Scoped<VariantObject> o(scope, callData->thisObject.as<QV4::VariantObject>());
     if (o && o->d()->isScarce())
         o->d()->addVmePropertyReference();
-    return Encode::undefined();
+    RETURN_UNDEFINED();
 }
 
-QV4::ReturnedValue VariantPrototype::method_destroy(CallContext *ctx)
+void VariantPrototype::method_destroy(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<VariantObject> o(scope, ctx->thisObject().as<QV4::VariantObject>());
+    Scoped<VariantObject> o(scope, callData->thisObject.as<QV4::VariantObject>());
     if (o) {
         if (o->d()->isScarce())
             o->d()->addVmePropertyReference();
         o->d()->data() = QVariant();
     }
-    return Encode::undefined();
+    RETURN_UNDEFINED();
 }
 
-QV4::ReturnedValue VariantPrototype::method_toString(CallContext *ctx)
+void VariantPrototype::method_toString(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<VariantObject> o(scope, ctx->thisObject().as<QV4::VariantObject>());
+    Scoped<VariantObject> o(scope, callData->thisObject.as<QV4::VariantObject>());
     if (!o)
-        return Encode::undefined();
+        RETURN_UNDEFINED();
     QString result = o->d()->data().toString();
     if (result.isEmpty() && !o->d()->data().canConvert(QVariant::String)) {
         result = QLatin1String("QVariant(")
                  + QLatin1String(o->d()->data().typeName())
                  + QLatin1Char(')');
     }
-    return Encode(ctx->d()->engine->newString(result));
+    scope.result = scope.engine->newString(result);
 }
 
-QV4::ReturnedValue VariantPrototype::method_valueOf(CallContext *ctx)
+void VariantPrototype::method_valueOf(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<VariantObject> o(scope, ctx->thisObject().as<QV4::VariantObject>());
+    Scoped<VariantObject> o(scope, callData->thisObject.as<QV4::VariantObject>());
     if (o) {
         QVariant v = o->d()->data();
         switch (v.type()) {
         case QVariant::Invalid:
-            return Encode::undefined();
+            scope.result = Encode::undefined();
+            return;
         case QVariant::String:
-            return Encode(ctx->d()->engine->newString(v.toString()));
+            scope.result = scope.engine->newString(v.toString());
+            return;
         case QVariant::Int:
-            return Encode(v.toInt());
+            scope.result = Encode(v.toInt());
+            return;
         case QVariant::Double:
         case QVariant::UInt:
-            return Encode(v.toDouble());
+            scope.result = Encode(v.toDouble());
+            return;
         case QVariant::Bool:
-            return Encode(v.toBool());
+            scope.result = Encode(v.toBool());
+            return;
         default:
             if (QMetaType::typeFlags(v.userType()) & QMetaType::IsEnumeration)
-                return Encode(v.toInt());
+                RETURN_RESULT(Encode(v.toInt()));
             break;
         }
     }
-    return ctx->thisObject().asReturnedValue();
+    scope.result = callData->thisObject;
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/jsruntime/qv4variantobject_p.h b/src/qml/jsruntime/qv4variantobject_p.h
index 9a04069c12..ef51b6632d 100644
--- a/src/qml/jsruntime/qv4variantobject_p.h
+++ b/src/qml/jsruntime/qv4variantobject_p.h
@@ -107,10 +107,10 @@ struct VariantPrototype : VariantObject
 public:
     void init();
 
-    static ReturnedValue method_preserve(CallContext *ctx);
-    static ReturnedValue method_destroy(CallContext *ctx);
-    static ReturnedValue method_toString(CallContext *ctx);
-    static ReturnedValue method_valueOf(CallContext *ctx);
+    static void method_preserve(const BuiltinFunction *, Scope &scope, CallData *callData);
+    static void method_destroy(const BuiltinFunction *, Scope &scope, CallData *callData);
+    static void method_toString(const BuiltinFunction *, Scope &scope, CallData *callData);
+    static void method_valueOf(const BuiltinFunction *, Scope &scope, CallData *callData);
 };
 
 }
diff --git a/src/qml/qml/qqmlcomponent.cpp b/src/qml/qml/qqmlcomponent.cpp
index 50ed58e63d..a04f47e6a4 100644
--- a/src/qml/qml/qqmlcomponent.cpp
+++ b/src/qml/qml/qqmlcomponent.cpp
@@ -1063,11 +1063,11 @@ struct QmlIncubatorObject : public QV4::Object
     V4_OBJECT2(QmlIncubatorObject, Object)
     V4_NEEDS_DESTROY
 
-    static QV4::ReturnedValue method_get_statusChanged(QV4::CallContext *ctx);
-    static QV4::ReturnedValue method_set_statusChanged(QV4::CallContext *ctx);
-    static QV4::ReturnedValue method_get_status(QV4::CallContext *ctx);
-    static QV4::ReturnedValue method_get_object(QV4::CallContext *ctx);
-    static QV4::ReturnedValue method_forceCompletion(QV4::CallContext *ctx);
+    static void method_get_statusChanged(const BuiltinFunction *, Scope &scope, CallData *callData);
+    static void method_set_statusChanged(const BuiltinFunction *, Scope &scope, CallData *callData);
+    static void method_get_status(const BuiltinFunction *, Scope &scope, CallData *callData);
+    static void method_get_object(const BuiltinFunction *, Scope &scope, CallData *callData);
+    static void method_forceCompletion(const BuiltinFunction *, Scope &scope, CallData *callData);
 
     static void markObjects(QV4::Heap::Base *that, QV4::ExecutionEngine *e);
 
@@ -1415,58 +1415,53 @@ QQmlComponentExtension::QQmlComponentExtension(QV4::ExecutionEngine *v4)
     incubationProto.set(v4, proto);
 }
 
-QV4::ReturnedValue QV4::QmlIncubatorObject::method_get_object(QV4::CallContext *ctx)
+void QV4::QmlIncubatorObject::method_get_object(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    QV4::Scope scope(ctx);
-    QV4::Scoped<QmlIncubatorObject> o(scope, ctx->thisObject().as<QmlIncubatorObject>());
+    QV4::Scoped<QmlIncubatorObject> o(scope, callData->thisObject.as<QmlIncubatorObject>());
     if (!o)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
-    return QV4::QObjectWrapper::wrap(ctx->d()->engine, o->d()->incubator->object());
+    scope.result = QV4::QObjectWrapper::wrap(scope.engine, o->d()->incubator->object());
 }
 
-QV4::ReturnedValue QV4::QmlIncubatorObject::method_forceCompletion(QV4::CallContext *ctx)
+void QV4::QmlIncubatorObject::method_forceCompletion(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    QV4::Scope scope(ctx);
-    QV4::Scoped<QmlIncubatorObject> o(scope, ctx->thisObject().as<QmlIncubatorObject>());
+    QV4::Scoped<QmlIncubatorObject> o(scope, callData->thisObject.as<QmlIncubatorObject>());
     if (!o)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
     o->d()->incubator->forceCompletion();
 
-    return QV4::Encode::undefined();
+    RETURN_UNDEFINED();
 }
 
-QV4::ReturnedValue QV4::QmlIncubatorObject::method_get_status(QV4::CallContext *ctx)
+void QV4::QmlIncubatorObject::method_get_status(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    QV4::Scope scope(ctx);
-    QV4::Scoped<QmlIncubatorObject> o(scope, ctx->thisObject().as<QmlIncubatorObject>());
+    QV4::Scoped<QmlIncubatorObject> o(scope, callData->thisObject.as<QmlIncubatorObject>());
     if (!o)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
-    return QV4::Encode(o->d()->incubator->status());
+    scope.result = QV4::Encode(o->d()->incubator->status());
 }
 
-QV4::ReturnedValue QV4::QmlIncubatorObject::method_get_statusChanged(QV4::CallContext *ctx)
+void QV4::QmlIncubatorObject::method_get_statusChanged(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    QV4::Scope scope(ctx);
-    QV4::Scoped<QmlIncubatorObject> o(scope, ctx->thisObject().as<QmlIncubatorObject>());
+    QV4::Scoped<QmlIncubatorObject> o(scope, callData->thisObject.as<QmlIncubatorObject>());
     if (!o)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
-    return o->d()->statusChanged.asReturnedValue();
+    scope.result = o->d()->statusChanged;
 }
 
-QV4::ReturnedValue QV4::QmlIncubatorObject::method_set_statusChanged(QV4::CallContext *ctx)
+void QV4::QmlIncubatorObject::method_set_statusChanged(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    QV4::Scope scope(ctx);
-    QV4::Scoped<QmlIncubatorObject> o(scope, ctx->thisObject().as<QmlIncubatorObject>());
-    if (!o || ctx->argc() < 1)
-        return ctx->engine()->throwTypeError();
+    QV4::Scoped<QmlIncubatorObject> o(scope, callData->thisObject.as<QmlIncubatorObject>());
+    if (!o || callData->argc < 1)
+        THROW_TYPE_ERROR();
 
+    o->d()->statusChanged = callData->args[0];
 
-    o->d()->statusChanged = ctx->args()[0];
-    return QV4::Encode::undefined();
+    RETURN_UNDEFINED();
 }
 
 QQmlComponentExtension::~QQmlComponentExtension()
diff --git a/src/qml/qml/qqmlvaluetypewrapper.cpp b/src/qml/qml/qqmlvaluetypewrapper.cpp
index 6ce52bb9e5..44b612e7d2 100644
--- a/src/qml/qml/qqmlvaluetypewrapper.cpp
+++ b/src/qml/qml/qqmlvaluetypewrapper.cpp
@@ -312,18 +312,18 @@ bool QQmlValueTypeWrapper::write(QObject *target, int propertyIndex) const
     return true;
 }
 
-ReturnedValue QQmlValueTypeWrapper::method_toString(CallContext *ctx)
+void QQmlValueTypeWrapper::method_toString(const BuiltinFunction *, Scope &scope, CallData *callData)
 {
-    Object *o = ctx->thisObject().as<Object>();
+    Object *o = callData->thisObject.as<Object>();
     if (!o)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
     QQmlValueTypeWrapper *w = o->as<QQmlValueTypeWrapper>();
     if (!w)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
     if (QQmlValueTypeReference *ref = w->as<QQmlValueTypeReference>())
         if (!ref->readReferenceValue())
-            return Encode::undefined();
+            RETURN_UNDEFINED();
 
     QString result;
     // Prepare a buffer to pass to QMetaType::convert()
@@ -346,7 +346,7 @@ ReturnedValue QQmlValueTypeWrapper::method_toString(CallContext *ctx)
         }
         result += QLatin1Char(')');
     }
-    return Encode(ctx->engine()->newString(result));
+    scope.result = scope.engine->newString(result);
 }
 
 ReturnedValue QQmlValueTypeWrapper::get(const Managed *m, String *name, bool *hasProperty)
diff --git a/src/qml/qml/qqmlvaluetypewrapper_p.h b/src/qml/qml/qqmlvaluetypewrapper_p.h
index fec54df770..87f9116056 100644
--- a/src/qml/qml/qqmlvaluetypewrapper_p.h
+++ b/src/qml/qml/qqmlvaluetypewrapper_p.h
@@ -111,7 +111,7 @@ public:
     static PropertyAttributes query(const Managed *, String *name);
     static void advanceIterator(Managed *m, ObjectIterator *it, Value *name, uint *index, Property *p, PropertyAttributes *attributes);
 
-    static QV4::ReturnedValue method_toString(CallContext *ctx);
+    static void method_toString(const BuiltinFunction *, Scope &scope, CallData *callData);
 
     static void initProto(ExecutionEngine *v4);
 };
diff --git a/src/qml/qml/qqmlxmlhttprequest.cpp b/src/qml/qml/qqmlxmlhttprequest.cpp
index 22c3c49c58..d0d9f080da 100644
--- a/src/qml/qml/qqmlxmlhttprequest.cpp
+++ b/src/qml/qml/qqmlxmlhttprequest.cpp
@@ -71,10 +71,12 @@ using namespace QV4;
 
 #if QT_CONFIG(xmlstreamreader) && QT_CONFIG(qml_network)
 
-#define V4THROW_REFERENCE(string) { \
-        ScopedObject error(scope, ctx->engine()->newReferenceErrorObject(QStringLiteral(string))); \
-        return ctx->engine()->throwError(error); \
-    }
+#define V4THROW_REFERENCE(string) \
+    do { \
+        ScopedObject error(scope, scope.engine->newReferenceErrorObject(QStringLiteral(string))); \
+        scope.result = scope.engine->throwError(error); \
+        return; \
+    } while (false)
 
 QT_BEGIN_NAMESPACE
 
@@ -274,25 +276,25 @@ public:
     static void initClass(ExecutionEngine *engine);
 
     // JS API
-    static ReturnedValue method_get_nodeName(CallContext *ctx);
-    static ReturnedValue method_get_nodeValue(CallContext *ctx);
-    static ReturnedValue method_get_nodeType(CallContext *ctx);
-    static ReturnedValue method_get_namespaceUri(CallContext *ctx);
-
-    static ReturnedValue method_get_parentNode(CallContext *ctx);
-    static ReturnedValue method_get_childNodes(CallContext *ctx);
-    static ReturnedValue method_get_firstChild(CallContext *ctx);
-    static ReturnedValue method_get_lastChild(CallContext *ctx);
-    static ReturnedValue method_get_previousSibling(CallContext *ctx);
-    static ReturnedValue method_get_nextSibling(CallContext *ctx);
-    static ReturnedValue method_get_attributes(CallContext *ctx);
-
-    //static ReturnedValue ownerDocument(CallContext *ctx);
-    //static ReturnedValue namespaceURI(CallContext *ctx);
-    //static ReturnedValue prefix(CallContext *ctx);
-    //static ReturnedValue localName(CallContext *ctx);
-    //static ReturnedValue baseURI(CallContext *ctx);
-    //static ReturnedValue textContent(CallContext *ctx);
+    static void method_get_nodeName(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_nodeValue(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_nodeType(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_namespaceUri(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+
+    static void method_get_parentNode(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_childNodes(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_firstChild(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_lastChild(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_previousSibling(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_nextSibling(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_attributes(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+
+    //static void ownerDocument(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    //static void namespaceURI(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    //static void prefix(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    //static void localName(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    //static void baseURI(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    //static void textContent(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
 
     static ReturnedValue getProto(ExecutionEngine *v4);
 
@@ -353,12 +355,12 @@ class Attr : public Node
 {
 public:
     // JS API
-    static ReturnedValue method_name(CallContext *ctx);
-//    static ReturnedValue specified(CallContext *);
-    static ReturnedValue method_value(CallContext *ctx);
-    static ReturnedValue method_ownerElement(CallContext *ctx);
-//    static ReturnedValue schemaTypeInfo(CallContext *);
-//    static ReturnedValue isId(CallContext *c);
+    static void method_name(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+//    static void specified(CallContext *);
+    static void method_value(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_ownerElement(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+//    static void schemaTypeInfo(CallContext *);
+//    static void isId(CallContext *c);
 
     // C++ API
     static ReturnedValue prototype(ExecutionEngine *);
@@ -368,7 +370,7 @@ class CharacterData : public Node
 {
 public:
     // JS API
-    static ReturnedValue method_length(CallContext *ctx);
+    static void method_length(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
 
     // C++ API
     static ReturnedValue prototype(ExecutionEngine *v4);
@@ -378,8 +380,8 @@ class Text : public CharacterData
 {
 public:
     // JS API
-    static ReturnedValue method_isElementContentWhitespace(CallContext *ctx);
-    static ReturnedValue method_wholeText(CallContext *ctx);
+    static void method_isElementContentWhitespace(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_wholeText(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
 
     // C++ API
     static ReturnedValue prototype(ExecutionEngine *);
@@ -396,10 +398,10 @@ class Document : public Node
 {
 public:
     // JS API
-    static ReturnedValue method_xmlVersion(CallContext *ctx);
-    static ReturnedValue method_xmlEncoding(CallContext *ctx);
-    static ReturnedValue method_xmlStandalone(CallContext *ctx);
-    static ReturnedValue method_documentElement(CallContext *ctx);
+    static void method_xmlVersion(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_xmlEncoding(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_xmlStandalone(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_documentElement(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
 
     // C++ API
     static ReturnedValue prototype(ExecutionEngine *);
@@ -418,12 +420,11 @@ void NodeImpl::release()
     document->release();
 }
 
-ReturnedValue NodePrototype::method_get_nodeName(CallContext *ctx)
+void NodePrototype::method_get_nodeName(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
     QString name;
     switch (r->d()->d->type) {
@@ -440,15 +441,14 @@ ReturnedValue NodePrototype::method_get_nodeName(CallContext *ctx)
         name = r->d()->d->name;
         break;
     }
-    return Encode(ctx->d()->engine->newString(name));
+    scope.result = Encode(scope.engine->newString(name));
 }
 
-ReturnedValue NodePrototype::method_get_nodeValue(CallContext *ctx)
+void NodePrototype::method_get_nodeValue(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
     if (r->d()->d->type == NodeImpl::Document ||
         r->d()->d->type == NodeImpl::DocumentFragment ||
@@ -457,135 +457,128 @@ ReturnedValue NodePrototype::method_get_nodeValue(CallContext *ctx)
         r->d()->d->type == NodeImpl::Entity ||
         r->d()->d->type == NodeImpl::EntityReference ||
         r->d()->d->type == NodeImpl::Notation)
-        return Encode::null();
+        RETURN_RESULT(Encode::null());
 
-    return Encode(ctx->d()->engine->newString(r->d()->d->data));
+    scope.result = Encode(scope.engine->newString(r->d()->d->data));
 }
 
-ReturnedValue NodePrototype::method_get_nodeType(CallContext *ctx)
+void NodePrototype::method_get_nodeType(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
-    return Encode(r->d()->d->type);
+    scope.result = Encode(r->d()->d->type);
 }
 
-ReturnedValue NodePrototype::method_get_namespaceUri(CallContext *ctx)
+void NodePrototype::method_get_namespaceUri(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
-    return Encode(ctx->d()->engine->newString(r->d()->d->namespaceUri));
+    scope.result = Encode(scope.engine->newString(r->d()->d->namespaceUri));
 }
 
-ReturnedValue NodePrototype::method_get_parentNode(CallContext *ctx)
+void NodePrototype::method_get_parentNode(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
     if (r->d()->d->parent)
-        return Node::create(scope.engine, r->d()->d->parent);
+        scope.result = Node::create(scope.engine, r->d()->d->parent);
     else
-        return Encode::null();
+        scope.result = Encode::null();
 }
 
-ReturnedValue NodePrototype::method_get_childNodes(CallContext *ctx)
+void NodePrototype::method_get_childNodes(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
-    return NodeList::create(scope.engine, r->d()->d);
+    scope.result = NodeList::create(scope.engine, r->d()->d);
 }
 
-ReturnedValue NodePrototype::method_get_firstChild(CallContext *ctx)
+void NodePrototype::method_get_firstChild(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
     if (r->d()->d->children.isEmpty())
-        return Encode::null();
+        scope.result = Encode::null();
     else
-        return Node::create(scope.engine, r->d()->d->children.constFirst());
+        scope.result = Node::create(scope.engine, r->d()->d->children.constFirst());
 }
 
-ReturnedValue NodePrototype::method_get_lastChild(CallContext *ctx)
+void NodePrototype::method_get_lastChild(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
     if (r->d()->d->children.isEmpty())
-        return Encode::null();
+        scope.result = Encode::null();
     else
-        return Node::create(scope.engine, r->d()->d->children.constLast());
+        scope.result = Node::create(scope.engine, r->d()->d->children.constLast());
 }
 
-ReturnedValue NodePrototype::method_get_previousSibling(CallContext *ctx)
+void NodePrototype::method_get_previousSibling(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
     if (!r->d()->d->parent)
-        return Encode::null();
+        RETURN_RESULT(Encode::null());
 
     for (int ii = 0; ii < r->d()->d->parent->children.count(); ++ii) {
         if (r->d()->d->parent->children.at(ii) == r->d()->d) {
             if (ii == 0)
-                return Encode::null();
+                scope.result = Encode::null();
             else
-                return Node::create(scope.engine, r->d()->d->parent->children.at(ii - 1));
+                scope.result = Node::create(scope.engine, r->d()->d->parent->children.at(ii - 1));
+            return;
         }
     }
 
-    return Encode::null();
+    scope.result = Encode::null();
 }
 
-ReturnedValue NodePrototype::method_get_nextSibling(CallContext *ctx)
+void NodePrototype::method_get_nextSibling(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
     if (!r->d()->d->parent)
-        return Encode::null();
+        RETURN_RESULT(Encode::null());
 
     for (int ii = 0; ii < r->d()->d->parent->children.count(); ++ii) {
         if (r->d()->d->parent->children.at(ii) == r->d()->d) {
             if ((ii + 1) == r->d()->d->parent->children.count())
-                return Encode::null();
+                scope.result = Encode::null();
             else
-                return Node::create(scope.engine, r->d()->d->parent->children.at(ii + 1));
+                scope.result = Node::create(scope.engine, r->d()->d->parent->children.at(ii + 1));
+            return;
         }
     }
 
-    return Encode::null();
+    scope.result = Encode::null();
 }
 
-ReturnedValue NodePrototype::method_get_attributes(CallContext *ctx)
+void NodePrototype::method_get_attributes(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return ctx->engine()->throwTypeError();
+        THROW_TYPE_ERROR();
 
     if (r->d()->d->type != NodeImpl::Element)
-        return Encode::null();
+        scope.result = Encode::null();
     else
-        return NamedNodeMap::create(scope.engine, r->d()->d, r->d()->d->attributes);
+        scope.result = NamedNodeMap::create(scope.engine, r->d()->d, r->d()->d->attributes);
 }
 
 ReturnedValue NodePrototype::getProto(ExecutionEngine *v4)
@@ -666,44 +659,40 @@ ReturnedValue Attr::prototype(ExecutionEngine *engine)
     return d->attrPrototype.value();
 }
 
-ReturnedValue Attr::method_name(CallContext *ctx)
+void Attr::method_name(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return Encode::undefined();
+        RETURN_UNDEFINED();
 
-    return QV4::Encode(scope.engine->newString(r->d()->d->name));
+    scope.result = scope.engine->newString(r->d()->d->name);
 }
 
-ReturnedValue Attr::method_value(CallContext *ctx)
+void Attr::method_value(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return Encode::undefined();
+        RETURN_UNDEFINED();
 
-    return QV4::Encode(scope.engine->newString(r->d()->d->data));
+    scope.result = scope.engine->newString(r->d()->d->data);
 }
 
-ReturnedValue Attr::method_ownerElement(CallContext *ctx)
+void Attr::method_ownerElement(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return Encode::undefined();
+        RETURN_UNDEFINED();
 
-    return Node::create(scope.engine, r->d()->d->parent);
+    scope.result = Node::create(scope.engine, r->d()->d->parent);
 }
 
-ReturnedValue CharacterData::method_length(CallContext *ctx)
+void CharacterData::method_length(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return Encode::undefined();
+        RETURN_UNDEFINED();
 
-    return Encode(r->d()->d->data.length());
+    scope.result = Encode(r->d()->d->data.length());
 }
 
 ReturnedValue CharacterData::prototype(ExecutionEngine *v4)
@@ -722,23 +711,22 @@ ReturnedValue CharacterData::prototype(ExecutionEngine *v4)
     return d->characterDataPrototype.value();
 }
 
-ReturnedValue Text::method_isElementContentWhitespace(CallContext *ctx)
+void Text::method_isElementContentWhitespace(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
-    if (!r) return Encode::undefined();
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
+    if (!r)
+        RETURN_UNDEFINED();
 
-    return Encode(QStringRef(&r->d()->d->data).trimmed().isEmpty());
+    scope.result = Encode(QStringRef(&r->d()->d->data).trimmed().isEmpty());
 }
 
-ReturnedValue Text::method_wholeText(CallContext *ctx)
+void Text::method_wholeText(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r)
-        return Encode::undefined();
+        RETURN_UNDEFINED();
 
-    return QV4::Encode(scope.engine->newString(r->d()->d->data));
+    scope.result = scope.engine->newString(r->d()->d->data);
 }
 
 ReturnedValue Text::prototype(ExecutionEngine *v4)
@@ -964,44 +952,40 @@ ReturnedValue NodeList::create(ExecutionEngine *v4, NodeImpl *data)
     return (v4->memoryManager->allocObject<NodeList>(data))->asReturnedValue();
 }
 
-ReturnedValue Document::method_documentElement(CallContext *ctx)
+void Document::method_documentElement(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r || r->d()->d->type != NodeImpl::Document)
-        return Encode::undefined();
+        RETURN_UNDEFINED();
 
-    return Node::create(scope.engine, static_cast<DocumentImpl *>(r->d()->d)->root);
+    scope.result = Node::create(scope.engine, static_cast<DocumentImpl *>(r->d()->d)->root);
 }
 
-ReturnedValue Document::method_xmlStandalone(CallContext *ctx)
+void Document::method_xmlStandalone(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r || r->d()->d->type != NodeImpl::Document)
-        return Encode::undefined();
+        RETURN_UNDEFINED();
 
-    return Encode(static_cast<DocumentImpl *>(r->d()->d)->isStandalone);
+    scope.result = Encode(static_cast<DocumentImpl *>(r->d()->d)->isStandalone);
 }
 
-ReturnedValue Document::method_xmlVersion(CallContext *ctx)
+void Document::method_xmlVersion(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r || r->d()->d->type != NodeImpl::Document)
-        return Encode::undefined();
+        RETURN_UNDEFINED();
 
-    return QV4::Encode(scope.engine->newString(static_cast<DocumentImpl *>(r->d()->d)->version));
+    scope.result = scope.engine->newString(static_cast<DocumentImpl *>(r->d()->d)->version);
 }
 
-ReturnedValue Document::method_xmlEncoding(CallContext *ctx)
+void Document::method_xmlEncoding(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<Node> r(scope, ctx->thisObject().as<Node>());
+    Scoped<Node> r(scope, callData->thisObject.as<Node>());
     if (!r || r->d()->d->type != NodeImpl::Document)
-        return Encode::undefined();
+        RETURN_UNDEFINED();
 
-    return QV4::Encode(scope.engine->newString(static_cast<DocumentImpl *>(r->d()->d)->encoding));
+    scope.result = scope.engine->newString(static_cast<DocumentImpl *>(r->d()->d)->encoding);
 }
 
 class QQmlXMLHttpRequest : public QObject
@@ -1657,21 +1641,21 @@ struct QQmlXMLHttpRequestCtor : public FunctionObject
 
     void setupProto();
 
-    static ReturnedValue method_open(CallContext *ctx);
-    static ReturnedValue method_setRequestHeader(CallContext *ctx);
-    static ReturnedValue method_send(CallContext *ctx);
-    static ReturnedValue method_abort(CallContext *ctx);
-    static ReturnedValue method_getResponseHeader(CallContext *ctx);
-    static ReturnedValue method_getAllResponseHeaders(CallContext *ctx);
-
-    static ReturnedValue method_get_readyState(CallContext *ctx);
-    static ReturnedValue method_get_status(CallContext *ctx);
-    static ReturnedValue method_get_statusText(CallContext *ctx);
-    static ReturnedValue method_get_responseText(CallContext *ctx);
-    static ReturnedValue method_get_responseXML(CallContext *ctx);
-    static ReturnedValue method_get_response(CallContext *ctx);
-    static ReturnedValue method_get_responseType(CallContext *ctx);
-    static ReturnedValue method_set_responseType(CallContext *ctx);
+    static void method_open(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_setRequestHeader(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_send(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_abort(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_getResponseHeader(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_getAllResponseHeaders(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+
+    static void method_get_readyState(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_status(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_statusText(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_responseText(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_responseXML(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_response(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_get_responseType(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void method_set_responseType(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
 };
 
 }
@@ -1733,19 +1717,18 @@ void QQmlXMLHttpRequestCtor::setupProto()
 
 
 // XMLHttpRequest methods
-ReturnedValue QQmlXMLHttpRequestCtor::method_open(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_open(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
-    if (ctx->argc() < 2 || ctx->argc() > 5)
-        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
+    if (callData->argc < 2 || callData->argc > 5)
+        THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
 
     // Argument 0 - Method
-    QString method = ctx->args()[0].toQStringNoThrow().toUpper();
+    QString method = callData->args[0].toQStringNoThrow().toUpper();
     if (method != QLatin1String("GET") &&
         method != QLatin1String("PUT") &&
         method != QLatin1String("HEAD") &&
@@ -1754,26 +1737,26 @@ ReturnedValue QQmlXMLHttpRequestCtor::method_open(CallContext *ctx)
         method != QLatin1String("OPTIONS") &&
         method != QLatin1String("PROPFIND") &&
         method != QLatin1String("PATCH"))
-        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Unsupported HTTP method type");
+        THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Unsupported HTTP method type");
 
     // Argument 1 - URL
-    QUrl url = QUrl(ctx->args()[1].toQStringNoThrow());
+    QUrl url = QUrl(callData->args[1].toQStringNoThrow());
 
     if (url.isRelative())
         url = scope.engine->callingQmlContext()->resolvedUrl(url);
 
     bool async = true;
     // Argument 2 - async (optional)
-    if (ctx->argc() > 2) {
-        async = ctx->args()[2].booleanValue();
+    if (callData->argc > 2) {
+        async = callData->args[2].booleanValue();
     }
 
     // Argument 3/4 - user/pass (optional)
     QString username, password;
-    if (ctx->argc() > 3)
-        username = ctx->args()[3].toQStringNoThrow();
-    if (ctx->argc() > 4)
-        password = ctx->args()[4].toQStringNoThrow();
+    if (callData->argc > 3)
+        username = callData->args[3].toQStringNoThrow();
+    if (callData->argc > 4)
+        password = callData->args[4].toQStringNoThrow();
 
     // Clear the fragment (if any)
     url.setFragment(QString());
@@ -1782,25 +1765,24 @@ ReturnedValue QQmlXMLHttpRequestCtor::method_open(CallContext *ctx)
     if (!username.isNull()) url.setUserName(username);
     if (!password.isNull()) url.setPassword(password);
 
-    return r->open(w, scope.engine->callingQmlContext(), method, url, async ? QQmlXMLHttpRequest::AsynchronousLoad : QQmlXMLHttpRequest::SynchronousLoad);
+    scope.result = r->open(w, scope.engine->callingQmlContext(), method, url, async ? QQmlXMLHttpRequest::AsynchronousLoad : QQmlXMLHttpRequest::SynchronousLoad);
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_setRequestHeader(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_setRequestHeader(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
-    if (ctx->argc() != 2)
-        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
+    if (callData->argc != 2)
+        THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
 
     if (r->readyState() != QQmlXMLHttpRequest::Opened || r->sendFlag())
-        V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
+        THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
-    QString name = ctx->args()[0].toQStringNoThrow();
-    QString value = ctx->args()[1].toQStringNoThrow();
+    QString name = callData->args[0].toQStringNoThrow();
+    QString value = callData->args[1].toQStringNoThrow();
 
     // ### Check that name and value are well formed
 
@@ -1825,148 +1807,139 @@ ReturnedValue QQmlXMLHttpRequestCtor::method_setRequestHeader(CallContext *ctx)
         nameUpper == QLatin1String("VIA") ||
         nameUpper.startsWith(QLatin1String("PROXY-")) ||
         nameUpper.startsWith(QLatin1String("SEC-")))
-        return Encode::undefined();
+        RETURN_UNDEFINED();
 
     r->addHeader(name, value);
 
-    return Encode::undefined();
+    RETURN_UNDEFINED();
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_send(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_send(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
     if (r->readyState() != QQmlXMLHttpRequest::Opened ||
         r->sendFlag())
-        V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
+        THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
     QByteArray data;
-    if (ctx->argc() > 0)
-        data = ctx->args()[0].toQStringNoThrow().toUtf8();
+    if (callData->argc > 0)
+        data = callData->args[0].toQStringNoThrow().toUtf8();
 
-    return r->send(w, scope.engine->callingQmlContext(), data);
+    scope.result = r->send(w, scope.engine->callingQmlContext(), data);
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_abort(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_abort(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
-    return r->abort(w, scope.engine->callingQmlContext());
+    scope.result = r->abort(w, scope.engine->callingQmlContext());
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_getResponseHeader(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_getResponseHeader(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
-    if (ctx->argc() != 1)
-        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
+    if (callData->argc != 1)
+        THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
 
     if (r->readyState() != QQmlXMLHttpRequest::Loading &&
         r->readyState() != QQmlXMLHttpRequest::Done &&
         r->readyState() != QQmlXMLHttpRequest::HeadersReceived)
-        V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
+        THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
-    return QV4::Encode(scope.engine->newString(r->header(ctx->args()[0].toQStringNoThrow())));
+    scope.result = scope.engine->newString(r->header(callData->args[0].toQStringNoThrow()));
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_getAllResponseHeaders(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_getAllResponseHeaders(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
-    if (ctx->argc() != 0)
-        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
+    if (callData->argc != 0)
+        THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
 
     if (r->readyState() != QQmlXMLHttpRequest::Loading &&
         r->readyState() != QQmlXMLHttpRequest::Done &&
         r->readyState() != QQmlXMLHttpRequest::HeadersReceived)
-        V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
+        THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
-    return QV4::Encode(scope.engine->newString(r->headers()));
+    scope.result = scope.engine->newString(r->headers());
 }
 
 // XMLHttpRequest properties
-ReturnedValue QQmlXMLHttpRequestCtor::method_get_readyState(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_get_readyState(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
-    return Encode(r->readyState());
+    scope.result = Encode(r->readyState());
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_get_status(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_get_status(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
     if (r->readyState() == QQmlXMLHttpRequest::Unsent ||
         r->readyState() == QQmlXMLHttpRequest::Opened)
-        V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
+        THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
     if (r->errorFlag())
-        return Encode(0);
+        scope.result = Encode(0);
     else
-        return Encode(r->replyStatus());
+        scope.result = Encode(r->replyStatus());
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_get_statusText(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_get_statusText(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
     if (r->readyState() == QQmlXMLHttpRequest::Unsent ||
         r->readyState() == QQmlXMLHttpRequest::Opened)
-        V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
+        THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
     if (r->errorFlag())
-        return QV4::Encode(scope.engine->newString(QString()));
+        scope.result = scope.engine->newString(QString());
     else
-        return QV4::Encode(scope.engine->newString(r->replyStatusText()));
+        scope.result = scope.engine->newString(r->replyStatusText());
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_get_responseText(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_get_responseText(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
     if (r->readyState() != QQmlXMLHttpRequest::Loading &&
         r->readyState() != QQmlXMLHttpRequest::Done)
-        return QV4::Encode(scope.engine->newString(QString()));
+        scope.result = scope.engine->newString(QString());
     else
-        return QV4::Encode(scope.engine->newString(r->responseBody()));
+        scope.result = scope.engine->newString(r->responseBody());
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_get_responseXML(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_get_responseXML(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
@@ -1974,66 +1947,63 @@ ReturnedValue QQmlXMLHttpRequestCtor::method_get_responseXML(CallContext *ctx)
     if (!r->receivedXml() ||
         (r->readyState() != QQmlXMLHttpRequest::Loading &&
          r->readyState() != QQmlXMLHttpRequest::Done)) {
-        return Encode::null();
+        scope.result = Encode::null();
     } else {
         if (r->responseType().isEmpty())
             r->setResponseType(QLatin1String("document"));
-        return r->xmlResponseBody(scope.engine);
+        scope.result = r->xmlResponseBody(scope.engine);
     }
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_get_response(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_get_response(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
     if (r->readyState() != QQmlXMLHttpRequest::Loading &&
             r->readyState() != QQmlXMLHttpRequest::Done)
-        return QV4::Encode(scope.engine->newString(QString()));
+        RETURN_RESULT(scope.engine->newString(QString()));
 
     const QString& responseType = r->responseType();
     if (responseType.compare(QLatin1String("text"), Qt::CaseInsensitive) == 0 || responseType.isEmpty()) {
-        return QV4::Encode(scope.engine->newString(r->responseBody()));
+        RETURN_RESULT(scope.engine->newString(r->responseBody()));
     } else if (responseType.compare(QLatin1String("arraybuffer"), Qt::CaseInsensitive) == 0) {
-        return QV4::Encode(scope.engine->newArrayBuffer(r->rawResponseBody()));
+        RETURN_RESULT(scope.engine->newArrayBuffer(r->rawResponseBody()));
     } else if (responseType.compare(QLatin1String("json"), Qt::CaseInsensitive) == 0) {
-        return r->jsonResponseBody(scope.engine);
+        RETURN_RESULT(r->jsonResponseBody(scope.engine));
     } else if (responseType.compare(QLatin1String("document"), Qt::CaseInsensitive) == 0) {
-        return r->xmlResponseBody(scope.engine);
+        RETURN_RESULT(r->xmlResponseBody(scope.engine));
     } else {
-        return QV4::Encode(scope.engine->newString(QString()));
+        RETURN_RESULT(scope.engine->newString(QString()));
     }
 }
 
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_get_responseType(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_get_responseType(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
-    return QV4::Encode(scope.engine->newString(r->responseType()));
+    scope.result = scope.engine->newString(r->responseType());
 }
 
-ReturnedValue QQmlXMLHttpRequestCtor::method_set_responseType(CallContext *ctx)
+void QQmlXMLHttpRequestCtor::method_set_responseType(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    Scope scope(ctx);
-    Scoped<QQmlXMLHttpRequestWrapper> w(scope, ctx->thisObject().as<QQmlXMLHttpRequestWrapper>());
+    Scoped<QQmlXMLHttpRequestWrapper> w(scope, callData->thisObject.as<QQmlXMLHttpRequestWrapper>());
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->d()->request;
 
-    if (ctx->argc() < 1)
-        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
+    if (callData->argc < 1)
+        THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
 
     // Argument 0 - response type
-    r->setResponseType(ctx->args()[0].toQStringNoThrow());
+    r->setResponseType(callData->args[0].toQStringNoThrow());
 
-    return Encode::undefined();
+    scope.result = Encode::undefined();
 }
 
 void qt_rem_qmlxmlhttprequest(ExecutionEngine * /* engine */, void *d)
diff --git a/src/qml/qml/v8/qv4domerrors_p.h b/src/qml/qml/v8/qv4domerrors_p.h
index faa9dd8bc7..d2225ec591 100644
--- a/src/qml/qml/v8/qv4domerrors_p.h
+++ b/src/qml/qml/v8/qv4domerrors_p.h
@@ -81,6 +81,14 @@ QT_BEGIN_NAMESPACE
     return ctx->engine()->throwError(ex); \
 }
 
+#define THROW_DOM(error, string) { \
+    QV4::ScopedValue v(scope, scope.engine->newString(QStringLiteral(string))); \
+    QV4::ScopedObject ex(scope, scope.engine->newErrorObject(v)); \
+    ex->put(QV4::ScopedString(scope, scope.engine->newIdentifier(QStringLiteral("code"))), QV4::ScopedValue(scope, QV4::Primitive::fromInt32(error))); \
+    scope.result = scope.engine->throwError(ex); \
+    return; \
+}
+
 namespace QV4 {
 struct ExecutionEngine;
 }
diff --git a/src/qml/types/qqmldelegatemodel.cpp b/src/qml/types/qqmldelegatemodel.cpp
index c0d75cae33..a5878dcffd 100644
--- a/src/qml/types/qqmldelegatemodel.cpp
+++ b/src/qml/types/qqmldelegatemodel.cpp
@@ -1795,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) {
@@ -1820,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 &)
@@ -3234,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);
     }
 };
 
diff --git a/src/qml/types/qqmldelegatemodel_p_p.h b/src/qml/types/qqmldelegatemodel_p_p.h
index 4c2841b8ba..cb4a1f79ba 100644
--- a/src/qml/types/qqmldelegatemodel_p_p.h
+++ b/src/qml/types/qqmldelegatemodel_p_p.h
@@ -131,9 +131,9 @@ public:
     virtual void setValue(const QString &role, const QVariant &value) { Q_UNUSED(role); Q_UNUSED(value); }
     virtual bool resolveIndex(const QQmlAdaptorModel &, int) { return false; }
 
-    static QV4::ReturnedValue get_model(QV4::CallContext *ctx);
-    static QV4::ReturnedValue get_groups(QV4::CallContext *ctx);
-    static QV4::ReturnedValue set_groups(QV4::CallContext *ctx);
+    static void get_model(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void get_groups(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
+    static void set_groups(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
     static QV4::ReturnedValue get_member(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &);
     static QV4::ReturnedValue set_member(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &arg);
     static QV4::ReturnedValue get_index(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &arg);
diff --git a/src/qml/types/qquickworkerscript.cpp b/src/qml/types/qquickworkerscript.cpp
index 5f716da17a..f35e17c34d 100644
--- a/src/qml/types/qquickworkerscript.cpp
+++ b/src/qml/types/qquickworkerscript.cpp
@@ -185,7 +185,7 @@ public:
 
     int m_nextId;
 
-    static QV4::ReturnedValue method_sendMessage(QV4::CallContext *ctx);
+    static void method_sendMessage(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData);
 
 signals:
     void stopThread();
@@ -292,14 +292,13 @@ QQuickWorkerScriptEnginePrivate::QQuickWorkerScriptEnginePrivate(QQmlEngine *eng
 {
 }
 
-QV4::ReturnedValue QQuickWorkerScriptEnginePrivate::method_sendMessage(QV4::CallContext *ctx)
+void QQuickWorkerScriptEnginePrivate::method_sendMessage(const QV4::BuiltinFunction *, QV4::Scope &scope, QV4::CallData *callData)
 {
-    WorkerEngine *engine = (WorkerEngine*)ctx->engine()->v8Engine;
+    WorkerEngine *engine = (WorkerEngine*)scope.engine->v8Engine;
 
-    int id = ctx->argc() > 1 ? ctx->args()[1].toInt32() : 0;
+    int id = callData->argc > 1 ? callData->args[1].toInt32() : 0;
 
-    QV4::Scope scope(ctx);
-    QV4::ScopedValue v(scope, ctx->argument(2));
+    QV4::ScopedValue v(scope, callData->argument(2));
     QByteArray data = QV4::Serialize::serialize(v, scope.engine);
 
     QMutexLocker locker(&engine->p->m_lock);
@@ -307,7 +306,7 @@ QV4::ReturnedValue QQuickWorkerScriptEnginePrivate::method_sendMessage(QV4::Call
     if (script && script->owner)
         QCoreApplication::postEvent(script->owner, new WorkerDataEvent(0, data));
 
-    return QV4::Encode::undefined();
+    scope.result = QV4::Encode::undefined();
 }
 
 QV4::ReturnedValue QQuickWorkerScriptEnginePrivate::getWorker(WorkerScript *script)