Change signature for call/callAsConstructor

Change-Id: I159b57acc7a2133ef1ad545aa84e792c63449a57
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

35 files changed, 268 insertions, 250 deletions

diff --git a/src/qml/jsruntime/qv4argumentsobject.cpp b/src/qml/jsruntime/qv4argumentsobject.cpp
index b7ac9616b1..5833e39561 100644
--- a/src/qml/jsruntime/qv4argumentsobject.cpp
+++ b/src/qml/jsruntime/qv4argumentsobject.cpp
@@ -207,12 +207,12 @@ PropertyAttributes ArgumentsObject::queryIndexed(const Managed *m, uint index)
 
 DEFINE_OBJECT_VTABLE(ArgumentsGetterFunction);
 
-ReturnedValue ArgumentsGetterFunction::call(const Managed *getter, CallData *callData)
+ReturnedValue ArgumentsGetterFunction::call(const FunctionObject *getter, const Value *thisObject, const Value *, int)
 {
-    ExecutionEngine *v4 = static_cast<const ArgumentsGetterFunction *>(getter)->engine();
+    ExecutionEngine *v4 = getter->engine();
     Scope scope(v4);
-    Scoped<ArgumentsGetterFunction> g(scope, static_cast<const ArgumentsGetterFunction *>(getter));
-    Scoped<ArgumentsObject> o(scope, callData->thisObject.as<ArgumentsObject>());
+    const ArgumentsGetterFunction *g = static_cast<const ArgumentsGetterFunction *>(getter);
+    Scoped<ArgumentsObject> o(scope, thisObject->as<ArgumentsObject>());
     if (!o)
         return v4->throwTypeError();
 
@@ -222,17 +222,17 @@ ReturnedValue ArgumentsGetterFunction::call(const Managed *getter, CallData *cal
 
 DEFINE_OBJECT_VTABLE(ArgumentsSetterFunction);
 
-ReturnedValue ArgumentsSetterFunction::call(const Managed *setter, CallData *callData)
+ReturnedValue ArgumentsSetterFunction::call(const FunctionObject *setter, const Value *thisObject, const Value *argv, int argc)
 {
-    ExecutionEngine *v4 = static_cast<const ArgumentsSetterFunction *>(setter)->engine();
+    ExecutionEngine *v4 = setter->engine();
     Scope scope(v4);
-    Scoped<ArgumentsSetterFunction> s(scope, static_cast<const ArgumentsSetterFunction *>(setter));
-    Scoped<ArgumentsObject> o(scope, callData->thisObject.as<ArgumentsObject>());
+    const ArgumentsSetterFunction *s = static_cast<const ArgumentsSetterFunction *>(setter);
+    Scoped<ArgumentsObject> o(scope, thisObject->as<ArgumentsObject>());
     if (!o)
         return v4->throwTypeError();
 
     Q_ASSERT(s->index() < static_cast<unsigned>(o->context()->argc()));
-    o->context()->setArg(s->index(), (callData->argc() ? callData->args[0] : Primitive::undefinedValue()));
+    o->context()->setArg(s->index(), argc ? argv[0] : Primitive::undefinedValue());
     return Encode::undefined();
 }
 
diff --git a/src/qml/jsruntime/qv4argumentsobject_p.h b/src/qml/jsruntime/qv4argumentsobject_p.h
index da88a44fee..cd270e8b47 100644
--- a/src/qml/jsruntime/qv4argumentsobject_p.h
+++ b/src/qml/jsruntime/qv4argumentsobject_p.h
@@ -98,7 +98,7 @@ struct ArgumentsGetterFunction: FunctionObject
     V4_OBJECT2(ArgumentsGetterFunction, FunctionObject)
 
     uint index() const { return d()->index; }
-    static ReturnedValue call(const Managed *that, CallData *d);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 inline void
@@ -113,7 +113,7 @@ struct ArgumentsSetterFunction: FunctionObject
     V4_OBJECT2(ArgumentsSetterFunction, FunctionObject)
 
     uint index() const { return d()->index; }
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 inline void
diff --git a/src/qml/jsruntime/qv4arraybuffer.cpp b/src/qml/jsruntime/qv4arraybuffer.cpp
index 7a8e1c67b5..3f06ce8bd5 100644
--- a/src/qml/jsruntime/qv4arraybuffer.cpp
+++ b/src/qml/jsruntime/qv4arraybuffer.cpp
@@ -52,12 +52,12 @@ void Heap::ArrayBufferCtor::init(QV4::ExecutionContext *scope)
     Heap::FunctionObject::init(scope, QStringLiteral("ArrayBuffer"));
 }
 
-ReturnedValue ArrayBufferCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue ArrayBufferCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    ExecutionEngine *v4 = m->engine();
+    ExecutionEngine *v4 = f->engine();
     Scope scope(v4);
 
-    ScopedValue l(scope, callData->argument(0));
+    ScopedValue l(scope, argc ? argv[0] : Primitive::undefinedValue());
     double dl = l->toInteger();
     if (v4->hasException)
         return Encode::undefined();
@@ -73,9 +73,9 @@ ReturnedValue ArrayBufferCtor::callAsConstructor(const Managed *m, CallData *cal
 }
 
 
-ReturnedValue ArrayBufferCtor::call(const Managed *that, CallData *callData)
+ReturnedValue ArrayBufferCtor::call(const FunctionObject *f, const Value *, const Value *argv, int argc)
 {
-    return callAsConstructor(that, callData);
+    return callAsConstructor(f, argv, argc);
 }
 
 ReturnedValue ArrayBufferCtor::method_isView(const BuiltinFunction *, CallData *callData)
diff --git a/src/qml/jsruntime/qv4arraybuffer_p.h b/src/qml/jsruntime/qv4arraybuffer_p.h
index 06c65fb01d..e144faa47f 100644
--- a/src/qml/jsruntime/qv4arraybuffer_p.h
+++ b/src/qml/jsruntime/qv4arraybuffer_p.h
@@ -78,8 +78,8 @@ struct ArrayBufferCtor: FunctionObject
 {
     V4_OBJECT2(ArrayBufferCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *m, CallData *callData);
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 
     static ReturnedValue method_isView(const BuiltinFunction *, CallData *callData);
 
diff --git a/src/qml/jsruntime/qv4arrayobject.cpp b/src/qml/jsruntime/qv4arrayobject.cpp
index a0dd26ce6c..dede423b73 100644
--- a/src/qml/jsruntime/qv4arrayobject.cpp
+++ b/src/qml/jsruntime/qv4arrayobject.cpp
@@ -55,34 +55,34 @@ void Heap::ArrayCtor::init(QV4::ExecutionContext *scope)
     Heap::FunctionObject::init(scope, QStringLiteral("Array"));
 }
 
-ReturnedValue ArrayCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue ArrayCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    ExecutionEngine *v4 = static_cast<const ArrayCtor *>(m)->engine();
+    ExecutionEngine *v4 = static_cast<const ArrayCtor *>(f)->engine();
     Scope scope(v4);
     ScopedArrayObject a(scope, v4->newArrayObject());
     uint len;
-    if (callData->argc() == 1 && callData->args[0].isNumber()) {
+    if (argc == 1 && argv[0].isNumber()) {
         bool ok;
-        len = callData->args[0].asArrayLength(&ok);
+        len = argv[0].asArrayLength(&ok);
 
         if (!ok)
-            return v4->throwRangeError(callData->args[0]);
+            return v4->throwRangeError(argv[0]);
 
         if (len < 0x1000)
             a->arrayReserve(len);
     } else {
-        len = callData->argc();
+        len = argc;
         a->arrayReserve(len);
-        a->arrayPut(0, callData->args, len);
+        a->arrayPut(0, argv, len);
     }
     a->setArrayLengthUnchecked(len);
 
     return a.asReturnedValue();
 }
 
-ReturnedValue ArrayCtor::call(const Managed *that, CallData *callData)
+ReturnedValue ArrayCtor::call(const FunctionObject *f, const Value *, const Value *argv, int argc)
 {
-    return callAsConstructor(that, callData);
+    return callAsConstructor(f, argv, argc);
 }
 
 void ArrayPrototype::init(ExecutionEngine *engine, Object *ctor)
diff --git a/src/qml/jsruntime/qv4arrayobject_p.h b/src/qml/jsruntime/qv4arrayobject_p.h
index f434d05628..db12811cd7 100644
--- a/src/qml/jsruntime/qv4arrayobject_p.h
+++ b/src/qml/jsruntime/qv4arrayobject_p.h
@@ -70,8 +70,8 @@ struct ArrayCtor: FunctionObject
 {
     V4_OBJECT2(ArrayCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *m, CallData *callData);
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct ArrayPrototype: ArrayObject
diff --git a/src/qml/jsruntime/qv4booleanobject.cpp b/src/qml/jsruntime/qv4booleanobject.cpp
index 247f36784b..2d89366e74 100644
--- a/src/qml/jsruntime/qv4booleanobject.cpp
+++ b/src/qml/jsruntime/qv4booleanobject.cpp
@@ -50,15 +50,15 @@ void Heap::BooleanCtor::init(QV4::ExecutionContext *scope)
     Heap::FunctionObject::init(scope, QStringLiteral("Boolean"));
 }
 
-ReturnedValue BooleanCtor::callAsConstructor(const Managed *that, CallData *callData)
+ReturnedValue BooleanCtor::callAsConstructor(const FunctionObject *that, const Value *argv, int argc)
 {
-    bool n = callData->argc() ? callData->args[0].toBoolean() : false;
+    bool n = argc ? argv[0].toBoolean() : false;
     return Encode(that->engine()->newBooleanObject(n));
 }
 
-ReturnedValue BooleanCtor::call(const Managed *, CallData *callData)
+ReturnedValue BooleanCtor::call(const FunctionObject *, const Value *, const Value *argv, int argc)
 {
-    bool value = callData->argc() ? callData->args[0].toBoolean() : 0;
+    bool value = argc ? argv[0].toBoolean() : 0;
     return Encode(value);
 }
 
diff --git a/src/qml/jsruntime/qv4booleanobject_p.h b/src/qml/jsruntime/qv4booleanobject_p.h
index fbdba8d6e4..7a686e0d53 100644
--- a/src/qml/jsruntime/qv4booleanobject_p.h
+++ b/src/qml/jsruntime/qv4booleanobject_p.h
@@ -70,8 +70,8 @@ struct BooleanCtor: FunctionObject
 {
     V4_OBJECT2(BooleanCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *callData);
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct BooleanPrototype: BooleanObject
diff --git a/src/qml/jsruntime/qv4dataview.cpp b/src/qml/jsruntime/qv4dataview.cpp
index db5b41603e..815f6ed991 100644
--- a/src/qml/jsruntime/qv4dataview.cpp
+++ b/src/qml/jsruntime/qv4dataview.cpp
@@ -54,17 +54,17 @@ void Heap::DataViewCtor::init(QV4::ExecutionContext *scope)
     Heap::FunctionObject::init(scope, QStringLiteral("DataView"));
 }
 
-ReturnedValue DataViewCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue DataViewCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    Scope scope(m->engine());
-    Scoped<ArrayBuffer> buffer(scope, callData->argument(0));
+    Scope scope(f->engine());
+    Scoped<ArrayBuffer> buffer(scope, argc ? argv[0] : Primitive::undefinedValue());
     if (!buffer)
         return scope.engine->throwTypeError();
 
-    double bo = callData->argc() > 1 ? callData->args[1].toNumber() : 0;
+    double bo = argc > 1 ? argv[1].toNumber() : 0;
     uint byteOffset = (uint)bo;
     uint bufferLength = buffer->d()->data->size;
-    double bl = callData->argc() < 3 || callData->args[2].isUndefined() ? (bufferLength - bo) : callData->args[2].toNumber();
+    double bl = argc < 3 || argv[2].isUndefined() ? (bufferLength - bo) : argv[2].toNumber();
     uint byteLength = (uint)bl;
     if (bo != byteOffset || bl != byteLength || byteOffset + byteLength > bufferLength)
         return scope.engine->throwRangeError(QStringLiteral("DataView: constructor arguments out of range"));
@@ -76,9 +76,9 @@ ReturnedValue DataViewCtor::callAsConstructor(const Managed *m, CallData *callDa
     return a.asReturnedValue();
 }
 
-ReturnedValue DataViewCtor::call(const Managed *that, CallData *callData)
+ReturnedValue DataViewCtor::call(const FunctionObject *f, const Value *, const Value *argv, int argc)
 {
-    return callAsConstructor(that, callData);
+    return callAsConstructor(f, argv, argc);
 }
 
 void DataViewPrototype::init(ExecutionEngine *engine, Object *ctor)
diff --git a/src/qml/jsruntime/qv4dataview_p.h b/src/qml/jsruntime/qv4dataview_p.h
index 56a4c35621..30fc7e993b 100644
--- a/src/qml/jsruntime/qv4dataview_p.h
+++ b/src/qml/jsruntime/qv4dataview_p.h
@@ -79,8 +79,8 @@ struct DataViewCtor: FunctionObject
 {
     V4_OBJECT2(DataViewCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *m, CallData *callData);
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct DataView : Object
diff --git a/src/qml/jsruntime/qv4dateobject.cpp b/src/qml/jsruntime/qv4dateobject.cpp
index b41fffa399..8b6325badd 100644
--- a/src/qml/jsruntime/qv4dateobject.cpp
+++ b/src/qml/jsruntime/qv4dateobject.cpp
@@ -678,16 +678,16 @@ void Heap::DateCtor::init(QV4::ExecutionContext *scope)
     Heap::FunctionObject::init(scope, QStringLiteral("Date"));
 }
 
-ReturnedValue DateCtor::callAsConstructor(const Managed *that, CallData *callData)
+ReturnedValue DateCtor::callAsConstructor(const FunctionObject *that, const Value *argv, int argc)
 {
     double t = 0;
 
-    if (callData->argc() == 0)
+    if (argc == 0)
         t = currentTime();
 
-    else if (callData->argc() == 1) {
+    else if (argc == 1) {
         Scope scope(that->engine());
-        ScopedValue arg(scope, callData->args[0]);
+        ScopedValue arg(scope, argv[0]);
         if (DateObject *d = arg->as<DateObject>()) {
             t = d->date();
         } else {
@@ -701,13 +701,13 @@ ReturnedValue DateCtor::callAsConstructor(const Managed *that, CallData *callDat
     }
 
     else { // d.argc > 1
-        double year  = callData->args[0].toNumber();
-        double month = callData->args[1].toNumber();
-        double day  = callData->argc() >= 3 ? callData->args[2].toNumber() : 1;
-        double hours = callData->argc() >= 4 ? callData->args[3].toNumber() : 0;
-        double mins = callData->argc() >= 5 ? callData->args[4].toNumber() : 0;
-        double secs = callData->argc() >= 6 ? callData->args[5].toNumber() : 0;
-        double ms    = callData->argc() >= 7 ? callData->args[6].toNumber() : 0;
+        double year  = argv[0].toNumber();
+        double month = argv[1].toNumber();
+        double day  = argc >= 3 ? argv[2].toNumber() : 1;
+        double hours = argc >= 4 ? argv[3].toNumber() : 0;
+        double mins = argc >= 5 ? argv[4].toNumber() : 0;
+        double secs = argc >= 6 ? argv[5].toNumber() : 0;
+        double ms    = argc >= 7 ? argv[6].toNumber() : 0;
         if (year >= 0 && year <= 99)
             year += 1900;
         t = MakeDate(MakeDay(year, month, day), MakeTime(hours, mins, secs, ms));
@@ -717,7 +717,7 @@ ReturnedValue DateCtor::callAsConstructor(const Managed *that, CallData *callDat
     return Encode(that->engine()->newDateObject(Primitive::fromDouble(t)));
 }
 
-ReturnedValue DateCtor::call(const Managed *m, CallData *)
+ReturnedValue DateCtor::call(const FunctionObject *m, const Value *, const Value *, int)
 {
     double t = currentTime();
     return m->engine()->newString(ToString(t))->asReturnedValue();
diff --git a/src/qml/jsruntime/qv4dateobject_p.h b/src/qml/jsruntime/qv4dateobject_p.h
index dd0a64086c..776822d312 100644
--- a/src/qml/jsruntime/qv4dateobject_p.h
+++ b/src/qml/jsruntime/qv4dateobject_p.h
@@ -108,8 +108,8 @@ struct DateCtor: FunctionObject
 {
     V4_OBJECT2(DateCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *callData);
-    static ReturnedValue call(const Managed *that, CallData *);
+    static ReturnedValue callAsConstructor(const FunctionObject *, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int);
 };
 
 struct DatePrototype: Object
diff --git a/src/qml/jsruntime/qv4errorobject.cpp b/src/qml/jsruntime/qv4errorobject.cpp
index 91251ced57..01c59dbcbe 100644
--- a/src/qml/jsruntime/qv4errorobject.cpp
+++ b/src/qml/jsruntime/qv4errorobject.cpp
@@ -233,15 +233,15 @@ void Heap::ErrorCtor::init(QV4::ExecutionContext *scope, const QString &name)
     Heap::FunctionObject::init(scope, name);
 }
 
-ReturnedValue ErrorCtor::callAsConstructor(const Managed *that, CallData *callData)
+ReturnedValue ErrorCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    Value v = Value::fromReturnedValue(callData->argument(0));
-    return ErrorObject::create<ErrorObject>(that->engine(), v)->asReturnedValue();
+    Value v = argc ? *argv : Primitive::undefinedValue();
+    return ErrorObject::create<ErrorObject>(f->engine(), v)->asReturnedValue();
 }
 
-ReturnedValue ErrorCtor::call(const Managed *that, CallData *callData)
+ReturnedValue ErrorCtor::call(const FunctionObject *f, const Value *, const Value *argv, int argc)
 {
-    return static_cast<const FunctionObject *>(that)->callAsConstructor(callData->args, callData->argc());
+    return f->callAsConstructor(argv, argc);
 }
 
 void Heap::EvalErrorCtor::init(QV4::ExecutionContext *scope)
@@ -249,9 +249,10 @@ void Heap::EvalErrorCtor::init(QV4::ExecutionContext *scope)
     Heap::ErrorCtor::init(scope, QStringLiteral("EvalError"));
 }
 
-ReturnedValue EvalErrorCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue EvalErrorCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    return ErrorObject::create<EvalErrorObject>(m->engine(), callData->args[0])->asReturnedValue();
+    Value v = argc ? *argv : Primitive::undefinedValue();
+    return ErrorObject::create<EvalErrorObject>(f->engine(), v)->asReturnedValue();
 }
 
 void Heap::RangeErrorCtor::init(QV4::ExecutionContext *scope)
@@ -259,9 +260,10 @@ void Heap::RangeErrorCtor::init(QV4::ExecutionContext *scope)
     Heap::ErrorCtor::init(scope, QStringLiteral("RangeError"));
 }
 
-ReturnedValue RangeErrorCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue RangeErrorCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    return ErrorObject::create<RangeErrorObject>(m->engine(), callData->args[0])->asReturnedValue();
+    Value v = argc ? *argv : Primitive::undefinedValue();
+    return ErrorObject::create<RangeErrorObject>(f->engine(), v)->asReturnedValue();
 }
 
 void Heap::ReferenceErrorCtor::init(QV4::ExecutionContext *scope)
@@ -269,9 +271,10 @@ void Heap::ReferenceErrorCtor::init(QV4::ExecutionContext *scope)
     Heap::ErrorCtor::init(scope, QStringLiteral("ReferenceError"));
 }
 
-ReturnedValue ReferenceErrorCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue ReferenceErrorCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    return ErrorObject::create<ReferenceErrorObject>(m->engine(), callData->args[0])->asReturnedValue();
+    Value v = argc ? *argv : Primitive::undefinedValue();
+    return ErrorObject::create<ReferenceErrorObject>(f->engine(), v)->asReturnedValue();
 }
 
 void Heap::SyntaxErrorCtor::init(QV4::ExecutionContext *scope)
@@ -279,9 +282,10 @@ void Heap::SyntaxErrorCtor::init(QV4::ExecutionContext *scope)
     Heap::ErrorCtor::init(scope, QStringLiteral("SyntaxError"));
 }
 
-ReturnedValue SyntaxErrorCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue SyntaxErrorCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    return ErrorObject::create<SyntaxErrorObject>(m->engine(), callData->args[0])->asReturnedValue();
+    Value v = argc ? *argv : Primitive::undefinedValue();
+    return ErrorObject::create<SyntaxErrorObject>(f->engine(), v)->asReturnedValue();
 }
 
 void Heap::TypeErrorCtor::init(QV4::ExecutionContext *scope)
@@ -289,9 +293,10 @@ void Heap::TypeErrorCtor::init(QV4::ExecutionContext *scope)
     Heap::ErrorCtor::init(scope, QStringLiteral("TypeError"));
 }
 
-ReturnedValue TypeErrorCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue TypeErrorCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    return ErrorObject::create<TypeErrorObject>(m->engine(), callData->args[0])->asReturnedValue();
+    Value v = argc ? *argv : Primitive::undefinedValue();
+    return ErrorObject::create<TypeErrorObject>(f->engine(), v)->asReturnedValue();
 }
 
 void Heap::URIErrorCtor::init(QV4::ExecutionContext *scope)
@@ -299,9 +304,10 @@ void Heap::URIErrorCtor::init(QV4::ExecutionContext *scope)
     Heap::ErrorCtor::init(scope, QStringLiteral("URIError"));
 }
 
-ReturnedValue URIErrorCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue URIErrorCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    return ErrorObject::create<URIErrorObject>(m->engine(), callData->args[0])->asReturnedValue();
+    Value v = argc ? *argv : Primitive::undefinedValue();
+    return ErrorObject::create<URIErrorObject>(f->engine(), v)->asReturnedValue();
 }
 
 void ErrorPrototype::init(ExecutionEngine *engine, Object *ctor, Object *obj, Heap::ErrorObject::ErrorType t)
diff --git a/src/qml/jsruntime/qv4errorobject_p.h b/src/qml/jsruntime/qv4errorobject_p.h
index 4190b68866..9942ee1ad6 100644
--- a/src/qml/jsruntime/qv4errorobject_p.h
+++ b/src/qml/jsruntime/qv4errorobject_p.h
@@ -229,50 +229,50 @@ struct ErrorCtor: FunctionObject
 {
     V4_OBJECT2(ErrorCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *callData);
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct EvalErrorCtor: ErrorCtor
 {
     V4_OBJECT2(EvalErrorCtor, ErrorCtor)
 
-    static ReturnedValue callAsConstructor(const Managed *m, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
 };
 
 struct RangeErrorCtor: ErrorCtor
 {
     V4_OBJECT2(RangeErrorCtor, ErrorCtor)
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
 };
 
 struct ReferenceErrorCtor: ErrorCtor
 {
     V4_OBJECT2(ReferenceErrorCtor, ErrorCtor)
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
 };
 
 struct SyntaxErrorCtor: ErrorCtor
 {
     V4_OBJECT2(SyntaxErrorCtor, ErrorCtor)
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
 };
 
 struct TypeErrorCtor: ErrorCtor
 {
     V4_OBJECT2(TypeErrorCtor, ErrorCtor)
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
 };
 
 struct URIErrorCtor: ErrorCtor
 {
     V4_OBJECT2(URIErrorCtor, ErrorCtor)
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
 };
 
 
diff --git a/src/qml/jsruntime/qv4functionobject.cpp b/src/qml/jsruntime/qv4functionobject.cpp
index 5b639e01d7..30ece800f6 100644
--- a/src/qml/jsruntime/qv4functionobject.cpp
+++ b/src/qml/jsruntime/qv4functionobject.cpp
@@ -72,15 +72,11 @@ Q_STATIC_ASSERT((Heap::FunctionObject::markTable & Heap::Object::markTable) == H
 
 static ReturnedValue jsCallWrapper(const QV4::FunctionObject *f, const Value *thisObject, const Value *argv, int argc)
 {
-    Scope scope(f->engine());
-    JSCallData callData(scope, argc, argv, thisObject);
-    return f->vtable()->call(f, callData.callData(f));
+    return f->vtable()->call(f, thisObject, argv, argc);
 }
 ReturnedValue jsConstructWrapper(const QV4::FunctionObject *f, const Value *argv, int argc)
 {
-    Scope scope(f->engine());
-    JSCallData callData(scope, argc, argv);
-    return f->vtable()->callAsConstructor(f, callData.callData(f));
+    return f->vtable()->callAsConstructor(f, argv, argc);
 }
 
 
@@ -164,12 +160,12 @@ ReturnedValue FunctionObject::name() const
     return get(scope()->internalClass->engine->id_name());
 }
 
-ReturnedValue FunctionObject::callAsConstructor(const Managed *that, CallData *)
+ReturnedValue FunctionObject::callAsConstructor(const FunctionObject *f, const Value *, int)
 {
-    return that->engine()->throwTypeError();
+    return f->engine()->throwTypeError();
 }
 
-ReturnedValue FunctionObject::call(const Managed *, CallData *)
+ReturnedValue FunctionObject::call(const FunctionObject *, const Value *, const Value *, int)
 {
     return Encode::undefined();
 }
@@ -202,20 +198,19 @@ void Heap::FunctionCtor::init(QV4::ExecutionContext *scope)
 }
 
 // 15.3.2
-ReturnedValue FunctionCtor::callAsConstructor(const Managed *that, CallData *callData)
+ReturnedValue FunctionCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    Scope scope(that->engine());
-    Scoped<FunctionCtor> f(scope, static_cast<const FunctionCtor *>(that));
+    Scope scope(f->engine());
 
     QString arguments;
     QString body;
-    if (callData->argc() > 0) {
-        for (int i = 0, ei = callData->argc() - 1; i < ei; ++i) {
+    if (argc > 0) {
+        for (int i = 0, ei = argc - 1; i < ei; ++i) {
             if (i)
                 arguments += QLatin1String(", ");
-            arguments += callData->args[i].toQString();
+            arguments += argv[i].toQString();
         }
-        body = callData->args[callData->argc() - 1].toQString();
+        body = argv[argc - 1].toQString();
     }
     if (scope.engine->hasException)
         return Encode::undefined();
@@ -250,9 +245,9 @@ ReturnedValue FunctionCtor::callAsConstructor(const Managed *that, CallData *cal
 }
 
 // 15.3.1: This is equivalent to new Function(...)
-ReturnedValue FunctionCtor::call(const Managed *that, CallData *callData)
+ReturnedValue FunctionCtor::call(const FunctionObject *f, const Value *, const Value *argv, int argc)
 {
-    return callAsConstructor(that, callData);
+    return callAsConstructor(f, argv, argc);
 }
 
 DEFINE_OBJECT_VTABLE(FunctionPrototype);
@@ -377,35 +372,41 @@ ReturnedValue FunctionPrototype::method_bind(const BuiltinFunction *b, CallData
 
 DEFINE_OBJECT_VTABLE(ScriptFunction);
 
-ReturnedValue ScriptFunction::callAsConstructor(const Managed *that, CallData *callData)
+ReturnedValue ScriptFunction::callAsConstructor(const FunctionObject *fo, const Value *argv, int argc)
 {
-    ExecutionEngine *v4 = that->engine();
-    const ScriptFunction *f = static_cast<const ScriptFunction *>(that);
+    ExecutionEngine *v4 = fo->engine();
+    const ScriptFunction *f = static_cast<const ScriptFunction *>(fo);
 
+    Scope scope(v4);
+    JSCallData callData(scope, argc, argv);
+    CallData *cData = callData.callData(f);
     InternalClass *ic = f->classForConstructor();
-    callData->context = f->scope();
-    callData->thisObject = v4->memoryManager->allocObject<Object>(ic);
+    cData->context = f->scope();
+    cData->thisObject = v4->memoryManager->allocObject<Object>(ic);
 
     QV4::Function *v4Function = f->function();
     Q_ASSERT(v4Function);
 
-    ReturnedValue result = v4Function->call(callData);
+    ReturnedValue result = v4Function->call(cData);
 
     if (Q_UNLIKELY(v4->hasException))
         return Encode::undefined();
     else if (!Value::fromReturnedValue(result).isObject())
-        return callData->thisObject.asReturnedValue();
+        return cData->thisObject.asReturnedValue();
     return result;
 }
 
-ReturnedValue ScriptFunction::call(const Managed *that, CallData *callData)
+ReturnedValue ScriptFunction::call(const FunctionObject *fo, const Value *thisObject, const Value *argv, int argc)
 {
-    const ScriptFunction *f = static_cast<const ScriptFunction *>(that);
+    const ScriptFunction *f = static_cast<const ScriptFunction *>(fo);
+    Scope scope(f->engine());
+    JSCallData callData(scope, argc, argv, thisObject);
+    CallData *cData = callData.callData(f);
+    cData->context = f->scope();
+
     QV4::Function *v4Function = f->function();
     Q_ASSERT(v4Function);
-
-    callData->context = f->scope();
-    return v4Function->call(callData);
+    return v4Function->call(cData);
 }
 
 void Heap::ScriptFunction::init(QV4::ExecutionContext *scope, Function *function)
@@ -458,15 +459,17 @@ void Heap::BuiltinFunction::init(QV4::ExecutionContext *scope, QV4::String *name
     this->code = code;
 }
 
-ReturnedValue BuiltinFunction::callAsConstructor(const Managed *f, CallData *)
+ReturnedValue BuiltinFunction::callAsConstructor(const QV4::FunctionObject *f, const Value *, int)
 {
     return f->engine()->throwTypeError();
 }
 
-ReturnedValue BuiltinFunction::call(const Managed *that, CallData *callData)
+ReturnedValue BuiltinFunction::call(const FunctionObject *fo, const Value *thisObject, const Value *argv, int argc)
 {
-    const BuiltinFunction *f = static_cast<const BuiltinFunction *>(that);
-    return f->d()->code(f, callData);
+    const BuiltinFunction *f = static_cast<const BuiltinFunction *>(fo);
+    Scope scope(f->engine());
+    JSCallData callData(scope, argc, argv, thisObject);
+    return f->d()->code(f, callData.callData());
 }
 
 DEFINE_OBJECT_VTABLE(IndexedBuiltinFunction);
@@ -499,38 +502,43 @@ void Heap::BoundFunction::init(QV4::ExecutionContext *scope, QV4::FunctionObject
     f->insertMember(s.engine->id_caller(), pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
 }
 
-ReturnedValue BoundFunction::call(const Managed *that, CallData *callData)
+ReturnedValue BoundFunction::call(const FunctionObject *fo, const Value *, const Value *argv, int argc)
 {
-    const BoundFunction *f = static_cast<const BoundFunction *>(that);
-    Heap::MemberData *boundArgs = f->boundArgs();
+    const BoundFunction *f = static_cast<const BoundFunction *>(fo);
+    Scope scope(f->engine());
 
-    int nBoundArgs = boundArgs ? boundArgs->values.size : 0;
-    if (nBoundArgs) {
-        memmove(&callData->args + nBoundArgs, &callData->args, callData->argc()*sizeof(Value));
-        memcpy(callData->args, boundArgs->values.data(), nBoundArgs*sizeof(Value));
-        callData->setArgc(callData->argc() + nBoundArgs);
-        f->engine()->jsStackTop += nBoundArgs;
-    }
+    if (scope.hasException())
+        return Encode::undefined();
 
-    callData->thisObject = f->boundThis();
-    callData->function = f->target();
-    return static_cast<FunctionObject &>(callData->function).call(&callData->thisObject, callData->args, callData->argc());
+    Scoped<MemberData> boundArgs(scope, f->boundArgs());
+    ScopedFunctionObject target(scope, f->target());
+    JSCallData jsCallData(scope, (boundArgs ? boundArgs->size() : 0) + argc);
+    *jsCallData->thisObject = f->boundThis();
+    Value *argp = jsCallData->args;
+    if (boundArgs) {
+        memcpy(argp, boundArgs->data(), boundArgs->size()*sizeof(Value));
+        argp += boundArgs->size();
+    }
+    memcpy(argp, argv, argc*sizeof(Value));
+    return target->call(jsCallData);
 }
 
-ReturnedValue BoundFunction::callAsConstructor(const Managed *that, CallData *callData)
+ReturnedValue BoundFunction::callAsConstructor(const FunctionObject *fo, const Value *argv, int argc)
 {
-    const BoundFunction *f = static_cast<const BoundFunction *>(that);
-    Heap::MemberData *boundArgs = f->boundArgs();
+    const BoundFunction *f = static_cast<const BoundFunction *>(fo);
+    Scope scope(f->engine());
 
-    int nBoundArgs = boundArgs ? boundArgs->values.size : 0;
-    if (nBoundArgs) {
-        memmove(callData->args + nBoundArgs, callData->args, callData->argc()*sizeof(Value));
-        memcpy(callData->args, boundArgs->values.data(), nBoundArgs*sizeof(Value));
-        callData->setArgc(callData->argc() + nBoundArgs);
-        f->engine()->jsStackTop += nBoundArgs;
-    }
+    if (scope.hasException())
+        return Encode::undefined();
 
-    callData->thisObject = f->boundThis();
-    callData->function = f->target();
-    return static_cast<FunctionObject &>(callData->function).callAsConstructor(callData->args, callData->argc());
+    Scoped<MemberData> boundArgs(scope, f->boundArgs());
+    ScopedFunctionObject target(scope, f->target());
+    JSCallData jsCallData(scope, (boundArgs ? boundArgs->size() : 0) + argc);
+    Value *argp = jsCallData->args;
+    if (boundArgs) {
+        memcpy(argp, boundArgs->data(), boundArgs->size()*sizeof(Value));
+        argp += boundArgs->size();
+    }
+    memcpy(argp, argv, argc*sizeof(Value));
+    return target->callAsConstructor(jsCallData);
 }
diff --git a/src/qml/jsruntime/qv4functionobject_p.h b/src/qml/jsruntime/qv4functionobject_p.h
index 6a65a7c1ce..3fd0fbeec8 100644
--- a/src/qml/jsruntime/qv4functionobject_p.h
+++ b/src/qml/jsruntime/qv4functionobject_p.h
@@ -164,8 +164,8 @@ struct Q_QML_EXPORT FunctionObject: Object {
     ReturnedValue call(const Value *thisObject, const Value *argv, int argc) const {
         return d()->jsCall(this, thisObject, argv, argc);
     }
-    static ReturnedValue callAsConstructor(const Managed *that, CallData *);
-    static ReturnedValue call(const Managed *that, CallData *d);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 
     static Heap::FunctionObject *createScriptFunction(ExecutionContext *scope, Function *function);
 
@@ -186,8 +186,8 @@ struct FunctionCtor: FunctionObject
 {
     V4_OBJECT2(FunctionCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *that, CallData *callData);
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct FunctionPrototype: FunctionObject
@@ -211,8 +211,8 @@ struct Q_QML_EXPORT BuiltinFunction : FunctionObject {
         return scope->engine()->memoryManager->allocObject<BuiltinFunction>(scope, name, code);
     }
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *);
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct IndexedBuiltinFunction: BuiltinFunction
@@ -233,8 +233,8 @@ struct ScriptFunction : FunctionObject {
     V4_OBJECT2(ScriptFunction, FunctionObject)
     V4_INTERNALCLASS(ScriptFunction)
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *callData);
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 
     InternalClass *classForConstructor() const;
 };
@@ -252,8 +252,8 @@ struct BoundFunction: FunctionObject {
     Value boundThis() const { return d()->boundThis; }
     Heap::MemberData *boundArgs() const { return d()->boundArgs; }
 
-    static ReturnedValue callAsConstructor(const Managed *, CallData *d);
-    static ReturnedValue call(const Managed *that, CallData *dd);
+    static ReturnedValue callAsConstructor(const FunctionObject *, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4globalobject.cpp b/src/qml/jsruntime/qv4globalobject.cpp
index f962aa29bc..a015461c47 100644
--- a/src/qml/jsruntime/qv4globalobject.cpp
+++ b/src/qml/jsruntime/qv4globalobject.cpp
@@ -338,9 +338,9 @@ void Heap::EvalFunction::init(QV4::ExecutionContext *scope)
     f->defineReadonlyProperty(s.engine->id_length(), Primitive::fromInt32(1));
 }
 
-ReturnedValue EvalFunction::evalCall(CallData *callData, bool directCall) const
+ReturnedValue EvalFunction::evalCall(const Value *, const Value *argv, int argc, bool directCall) const
 {
-    if (callData->argc() < 1)
+    if (argc < 1)
         return Encode::undefined();
 
     ExecutionEngine *v4 = engine();
@@ -354,9 +354,9 @@ ReturnedValue EvalFunction::evalCall(CallData *callData, bool directCall) const
         ctx = v4->rootContext();
     }
 
-    String *scode = callData->args[0].stringValue();
+    String *scode = argv[0].stringValue();
     if (!scode)
-        return callData->args[0].asReturnedValue();
+        return argv[0].asReturnedValue();
 
     const QString code = scode->toQString();
     bool inheritContext = !ctx->d()->v4Function->isStrict();
@@ -396,10 +396,10 @@ ReturnedValue EvalFunction::evalCall(CallData *callData, bool directCall) const
 }
 
 
-ReturnedValue EvalFunction::call(const Managed *that, CallData *callData)
+ReturnedValue EvalFunction::call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc)
 {
     // indirect call
-    return static_cast<const EvalFunction *>(that)->evalCall(callData, false);
+    return static_cast<const EvalFunction *>(f)->evalCall(thisObject, argv, argc, false);
 }
 
 
diff --git a/src/qml/jsruntime/qv4globalobject_p.h b/src/qml/jsruntime/qv4globalobject_p.h
index 5489a9fbb0..af72d3af2f 100644
--- a/src/qml/jsruntime/qv4globalobject_p.h
+++ b/src/qml/jsruntime/qv4globalobject_p.h
@@ -69,9 +69,9 @@ struct Q_QML_EXPORT EvalFunction : FunctionObject
 {
     V4_OBJECT2(EvalFunction, FunctionObject)
 
-    ReturnedValue evalCall(CallData *callData, bool directCall) const;
+    ReturnedValue evalCall(const Value *thisObject, const Value *argv, int argc, bool directCall) const;
 
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct GlobalFunctions
diff --git a/src/qml/jsruntime/qv4numberobject.cpp b/src/qml/jsruntime/qv4numberobject.cpp
index f248109273..2ac4409805 100644
--- a/src/qml/jsruntime/qv4numberobject.cpp
+++ b/src/qml/jsruntime/qv4numberobject.cpp
@@ -78,15 +78,15 @@ void Heap::NumberCtor::init(QV4::ExecutionContext *scope)
     Heap::FunctionObject::init(scope, QStringLiteral("Number"));
 }
 
-ReturnedValue NumberCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue NumberCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    double dbl = callData->argc() ? callData->args[0].toNumber() : 0.;
-    return Encode(m->engine()->newNumberObject(dbl));
+    double dbl = argc ? argv[0].toNumber() : 0.;
+    return Encode(f->engine()->newNumberObject(dbl));
 }
 
-ReturnedValue NumberCtor::call(const Managed *, CallData *callData)
+ReturnedValue NumberCtor::call(const FunctionObject *, const Value *, const Value *argv, int argc)
 {
-    double dbl = callData->argc() ? callData->args[0].toNumber() : 0.;
+    double dbl = argc ? argv[0].toNumber() : 0.;
     return Encode(dbl);
 }
 
diff --git a/src/qml/jsruntime/qv4numberobject_p.h b/src/qml/jsruntime/qv4numberobject_p.h
index b89c7e8beb..e4ff87c93a 100644
--- a/src/qml/jsruntime/qv4numberobject_p.h
+++ b/src/qml/jsruntime/qv4numberobject_p.h
@@ -79,8 +79,8 @@ struct NumberCtor: FunctionObject
 {
     V4_OBJECT2(NumberCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *that, CallData *callData);
-    static ReturnedValue call(const Managed *, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct NumberPrototype: NumberObject
diff --git a/src/qml/jsruntime/qv4object.cpp b/src/qml/jsruntime/qv4object.cpp
index 5e9954d0f5..1859466348 100644
--- a/src/qml/jsruntime/qv4object.cpp
+++ b/src/qml/jsruntime/qv4object.cpp
@@ -395,14 +395,14 @@ bool Object::hasOwnProperty(uint index) const
     return false;
 }
 
-ReturnedValue Object::callAsConstructor(const Managed *m, CallData *)
+ReturnedValue Object::callAsConstructor(const FunctionObject *f, const Value *, int)
 {
-    return m->engine()->throwTypeError();
+    return f->engine()->throwTypeError();
 }
 
-ReturnedValue Object::call(const Managed *m, CallData *)
+ReturnedValue Object::call(const FunctionObject *f, const Value *, const Value *, int)
 {
-    return m->engine()->throwTypeError();
+    return f->engine()->throwTypeError();
 }
 
 ReturnedValue Object::get(const Managed *m, String *name, bool *hasProperty)
diff --git a/src/qml/jsruntime/qv4object_p.h b/src/qml/jsruntime/qv4object_p.h
index 477e341b07..af68f09700 100644
--- a/src/qml/jsruntime/qv4object_p.h
+++ b/src/qml/jsruntime/qv4object_p.h
@@ -175,8 +175,8 @@ Q_STATIC_ASSERT(Object::markTable == ((2 << 2) | (2 << 4)));
 struct ObjectVTable
 {
     VTable vTable;
-    ReturnedValue (*call)(const Managed *, CallData *data);
-    ReturnedValue (*callAsConstructor)(const Managed *, CallData *data);
+    ReturnedValue (*call)(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
+    ReturnedValue (*callAsConstructor)(const FunctionObject *, const Value *argv, int argc);
     ReturnedValue (*get)(const Managed *, String *name, bool *hasProperty);
     ReturnedValue (*getIndexed)(const Managed *, uint index, bool *hasProperty);
     bool (*put)(Managed *, String *name, const Value &value);
@@ -428,8 +428,8 @@ public:
     { return vtable()->instanceOf(this, var); }
 
 protected:
-    static ReturnedValue callAsConstructor(const Managed *m, CallData *);
-    static ReturnedValue call(const Managed *m, CallData *);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
     static ReturnedValue get(const Managed *m, String *name, bool *hasProperty);
     static ReturnedValue getIndexed(const Managed *m, uint index, bool *hasProperty);
     static bool put(Managed *m, String *name, const Value &value);
diff --git a/src/qml/jsruntime/qv4objectproto.cpp b/src/qml/jsruntime/qv4objectproto.cpp
index b5446628bd..07573e61f3 100644
--- a/src/qml/jsruntime/qv4objectproto.cpp
+++ b/src/qml/jsruntime/qv4objectproto.cpp
@@ -61,11 +61,11 @@ void Heap::ObjectCtor::init(QV4::ExecutionContext *scope)
     Heap::FunctionObject::init(scope, QStringLiteral("Object"));
 }
 
-ReturnedValue ObjectCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue ObjectCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    ExecutionEngine *v4 = m->engine();
-    const ObjectCtor *ctor = static_cast<const ObjectCtor *>(m);
-    if (!callData->argc() || callData->args[0].isUndefined() || callData->args[0].isNull()) {
+    ExecutionEngine *v4 = f->engine();
+    const ObjectCtor *ctor = static_cast<const ObjectCtor *>(f);
+    if (!argc || argv[0].isUndefined() || argv[0].isNull()) {
         Scope scope(v4);
         ScopedObject obj(scope, scope.engine->newObject());
         ScopedObject proto(scope, ctor->get(scope.engine->id_prototype()));
@@ -73,17 +73,17 @@ ReturnedValue ObjectCtor::callAsConstructor(const Managed *m, CallData *callData
             obj->setPrototype(proto);
         return obj.asReturnedValue();
     } else {
-        return callData->args[0].toObject(v4)->asReturnedValue();
+        return argv[0].toObject(v4)->asReturnedValue();
     }
 }
 
-ReturnedValue ObjectCtor::call(const Managed *m, CallData *callData)
+ReturnedValue ObjectCtor::call(const FunctionObject *m, const Value *, const Value *argv, int argc)
 {
     ExecutionEngine *v4 = m->engine();
-    if (!callData->argc() || callData->args[0].isUndefined() || callData->args[0].isNull()) {
+    if (!argc || argv[0].isUndefined() || argv[0].isNull()) {
         return v4->newObject()->asReturnedValue();
     } else {
-        return callData->args[0].toObject(v4)->asReturnedValue();
+        return argv[0].toObject(v4)->asReturnedValue();
     }
 }
 
diff --git a/src/qml/jsruntime/qv4objectproto_p.h b/src/qml/jsruntime/qv4objectproto_p.h
index cdfdfd5536..7c97963baa 100644
--- a/src/qml/jsruntime/qv4objectproto_p.h
+++ b/src/qml/jsruntime/qv4objectproto_p.h
@@ -70,8 +70,8 @@ struct ObjectCtor: FunctionObject
 {
     V4_OBJECT2(ObjectCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *that, CallData *callData);
-    static ReturnedValue call(const Managed *m, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *m, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct ObjectPrototype: Object
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index 0679732e1b..9746b82817 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -1894,17 +1894,17 @@ QV4::ReturnedValue QObjectMethod::method_destroy(QV4::ExecutionEngine *engine, c
     return Encode::undefined();
 }
 
-ReturnedValue QObjectMethod::call(const Managed *m, CallData *callData)
+ReturnedValue QObjectMethod::call(const FunctionObject *m, const Value *thisObject, const Value *argv, int argc)
 {
     const QObjectMethod *This = static_cast<const QObjectMethod*>(m);
-    return This->callInternal(callData);
+    return This->callInternal(thisObject, argv, argc);
 }
 
-ReturnedValue QObjectMethod::callInternal(CallData *callData) const
+ReturnedValue QObjectMethod::callInternal(const Value *thisObject, const Value *argv, int argc) const
 {
     ExecutionEngine *v4 = engine();
     if (d()->index == DestroyMethod)
-        return method_destroy(v4, callData->args, callData->argc());
+        return method_destroy(v4, argv, argc);
     else if (d()->index == ToStringMethod)
         return method_toString(v4);
 
@@ -1944,8 +1944,11 @@ ReturnedValue QObjectMethod::callInternal(CallData *callData) const
         }
     }
 
+    Scope scope(v4);
+    JSCallData cData(scope, argc, argv, thisObject);
+    CallData *callData = cData.callData();
+
     if (method.isV4Function()) {
-        Scope scope(v4);
         QV4::ScopedValue rv(scope, QV4::Primitive::undefinedValue());
         QQmlV4Function func(callData, rv, v4);
         QQmlV4Function *funcptr = &func;
@@ -2022,13 +2025,14 @@ void QMetaObjectWrapper::init(ExecutionEngine *) {
     }
 }
 
-ReturnedValue QMetaObjectWrapper::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue QMetaObjectWrapper::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    const QMetaObjectWrapper *This = static_cast<const QMetaObjectWrapper*>(m);
-    return This->constructInternal(callData);
+    const QMetaObjectWrapper *This = static_cast<const QMetaObjectWrapper*>(f);
+    return This->constructInternal(argv, argc);
 }
 
-ReturnedValue QMetaObjectWrapper::constructInternal(CallData * callData) const {
+ReturnedValue QMetaObjectWrapper::constructInternal(const Value *argv, int argc) const
+{
 
     d()->ensureConstructorsCache();
 
@@ -2041,6 +2045,8 @@ ReturnedValue QMetaObjectWrapper::constructInternal(CallData * callData) const {
 
     Scope scope(v4);
     Scoped<QObjectWrapper> object(scope);
+    JSCallData cData(scope, argc, argv);
+    CallData *callData = cData.callData();
 
     if (d()->constructorCount == 1) {
         object = callConstructor(d()->constructors[0], v4, callData);
diff --git a/src/qml/jsruntime/qv4qobjectwrapper_p.h b/src/qml/jsruntime/qv4qobjectwrapper_p.h
index 2368884465..7b31fcc1e5 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper_p.h
+++ b/src/qml/jsruntime/qv4qobjectwrapper_p.h
@@ -237,9 +237,9 @@ struct Q_QML_EXPORT QObjectMethod : public QV4::FunctionObject
     QV4::ReturnedValue method_toString(QV4::ExecutionEngine *engine) const;
     QV4::ReturnedValue method_destroy(QV4::ExecutionEngine *ctx, const Value *args, int argc) const;
 
-    static ReturnedValue call(const Managed *, CallData *callData);
+    static ReturnedValue call(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
 
-    ReturnedValue callInternal(CallData *callData) const;
+    ReturnedValue callInternal(const Value *thisObject, const Value *argv, int argc) const;
 
     static QPair<QObject *, int> extractQtMethod(const QV4::FunctionObject *function);
 };
@@ -251,14 +251,14 @@ struct Q_QML_EXPORT QMetaObjectWrapper : public QV4::FunctionObject
     V4_NEEDS_DESTROY
 
     static ReturnedValue create(ExecutionEngine *engine, const QMetaObject* metaObject);
-    static ReturnedValue callAsConstructor(const Managed *, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *, const Value *argv, int argc);
     static bool isEqualTo(Managed *a, Managed *b);
 
     const QMetaObject *metaObject() const { return d()->metaObject; }
 
 private:
     void init(ExecutionEngine *engine);
-    ReturnedValue constructInternal(CallData *callData) const;
+    ReturnedValue constructInternal(const Value *argv, int argc) const;
     ReturnedValue callConstructor(const QQmlPropertyData &data, QV4::ExecutionEngine *engine, QV4::CallData *callArgs) const;
     ReturnedValue callOverloadedConstructor(QV4::ExecutionEngine *engine, QV4::CallData *callArgs) const;
 
diff --git a/src/qml/jsruntime/qv4regexpobject.cpp b/src/qml/jsruntime/qv4regexpobject.cpp
index f5a8fa3f2b..3ff5349e74 100644
--- a/src/qml/jsruntime/qv4regexpobject.cpp
+++ b/src/qml/jsruntime/qv4regexpobject.cpp
@@ -214,11 +214,11 @@ void Heap::RegExpCtor::clearLastMatch()
     lastMatchEnd = 0;
 }
 
-ReturnedValue RegExpCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue RegExpCtor::callAsConstructor(const FunctionObject *fo, const Value *argv, int argc)
 {
-    Scope scope(m->engine());
-    ScopedValue r(scope, callData->argument(0));
-    ScopedValue f(scope, callData->argument(1));
+    Scope scope(fo->engine());
+    ScopedValue r(scope, argc ? argv[0] : Primitive::undefinedValue());
+    ScopedValue f(scope, argc > 1 ? argv[1] : Primitive::undefinedValue());
     Scoped<RegExpObject> re(scope, r);
     if (re) {
         if (!f->isUndefined())
@@ -263,14 +263,14 @@ ReturnedValue RegExpCtor::callAsConstructor(const Managed *m, CallData *callData
     return Encode(scope.engine->newRegExpObject(regexp));
 }
 
-ReturnedValue RegExpCtor::call(const Managed *that, CallData *callData)
+ReturnedValue RegExpCtor::call(const FunctionObject *f, const Value *, const Value *argv, int argc)
 {
-    if (callData->argc() > 0 && callData->args[0].as<RegExpObject>()) {
-        if (callData->argc() == 1 || callData->args[1].isUndefined())
-            return Encode(callData->args[0]);
+    if (argc > 0 && argv[0].as<RegExpObject>()) {
+        if (argc == 1 || argv[1].isUndefined())
+            return Encode(argv[0]);
     }
 
-    return callAsConstructor(that, callData);
+    return callAsConstructor(f, argv, argc);
 }
 
 void RegExpPrototype::init(ExecutionEngine *engine, Object *constructor)
diff --git a/src/qml/jsruntime/qv4regexpobject_p.h b/src/qml/jsruntime/qv4regexpobject_p.h
index 7db862c502..1f92516928 100644
--- a/src/qml/jsruntime/qv4regexpobject_p.h
+++ b/src/qml/jsruntime/qv4regexpobject_p.h
@@ -150,8 +150,8 @@ struct RegExpCtor: FunctionObject
     int lastMatchStart() { return d()->lastMatchStart; }
     int lastMatchEnd() { return d()->lastMatchEnd; }
 
-    static ReturnedValue callAsConstructor(const Managed *m, CallData *callData);
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct RegExpPrototype: RegExpObject
diff --git a/src/qml/jsruntime/qv4runtime.cpp b/src/qml/jsruntime/qv4runtime.cpp
index 42981949c9..7a5d114271 100644
--- a/src/qml/jsruntime/qv4runtime.cpp
+++ b/src/qml/jsruntime/qv4runtime.cpp
@@ -977,25 +977,25 @@ ReturnedValue Runtime::method_callGlobalLookup(ExecutionEngine *engine, uint ind
 ReturnedValue Runtime::method_callPossiblyDirectEval(ExecutionEngine *engine, Value *argv, int argc)
 {
     Scope scope(engine);
-    JSCallData callData(scope, argc, argv);
+    ScopedValue thisObject(scope);
 
     ExecutionContext &ctx = static_cast<ExecutionContext &>(engine->currentStackFrame->jsFrame->context);
-    ScopedFunctionObject function(scope, ctx.getPropertyAndBase(engine->id_eval(), callData->thisObject));
+    ScopedFunctionObject function(scope, ctx.getPropertyAndBase(engine->id_eval(), thisObject));
     if (engine->hasException)
         return Encode::undefined();
 
     if (!function) {
         QString objectAsString = QStringLiteral("[null]");
-        if (!callData->thisObject->isUndefined())
-            objectAsString = callData->thisObject->toQStringNoThrow();
+        if (!thisObject->isUndefined())
+            objectAsString = thisObject->toQStringNoThrow();
         QString msg = QStringLiteral("Property 'eval' of object %2 is not a function").arg(objectAsString);
         return engine->throwTypeError(msg);
     }
 
     if (function->d() == engine->evalFunction()->d())
-        return static_cast<EvalFunction *>(function.getPointer())->evalCall(callData.callData(function), true);
+        return static_cast<EvalFunction *>(function.getPointer())->evalCall(thisObject, argv, argc, true);
 
-    return function->call(callData);
+    return function->call(thisObject, argv, argc);
 }
 
 ReturnedValue Runtime::method_callName(ExecutionEngine *engine, int nameIndex, Value *argv, int argc)
diff --git a/src/qml/jsruntime/qv4stringobject.cpp b/src/qml/jsruntime/qv4stringobject.cpp
index 0ab096c2bb..571a638355 100644
--- a/src/qml/jsruntime/qv4stringobject.cpp
+++ b/src/qml/jsruntime/qv4stringobject.cpp
@@ -143,23 +143,23 @@ void Heap::StringCtor::init(QV4::ExecutionContext *scope)
     Heap::FunctionObject::init(scope, QStringLiteral("String"));
 }
 
-ReturnedValue StringCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue StringCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    ExecutionEngine *v4 = static_cast<const Object *>(m)->engine();
+    ExecutionEngine *v4 = static_cast<const Object *>(f)->engine();
     Scope scope(v4);
     ScopedString value(scope);
-    if (callData->argc())
-        value = callData->args[0].toString(v4);
+    if (argc)
+        value = argv[0].toString(v4);
     else
         value = v4->newString();
     return Encode(v4->newStringObject(value));
 }
 
-ReturnedValue StringCtor::call(const Managed *m, CallData *callData)
+ReturnedValue StringCtor::call(const FunctionObject *m, const Value *, const Value *argv, int argc)
 {
     ExecutionEngine *v4 = m->engine();
-    if (callData->argc())
-        return callData->args[0].toString(v4)->asReturnedValue();
+    if (argc)
+        return argv[0].toString(v4)->asReturnedValue();
     else
         return v4->newString()->asReturnedValue();
 }
@@ -419,7 +419,7 @@ ReturnedValue StringPrototype::method_match(const BuiltinFunction *b, CallData *
 
     if (!callData->args[0].as<RegExpObject>()) {
         // convert args[0] to a regexp
-        callData->args[0] = RegExpCtor::callAsConstructor(b, callData);
+        callData->args[0] = RegExpCtor::callAsConstructor(b, callData->args, callData->argc());
         if (v4->hasException)
             return Encode::undefined();
     }
diff --git a/src/qml/jsruntime/qv4stringobject_p.h b/src/qml/jsruntime/qv4stringobject_p.h
index 349eb5f9d8..a76684384d 100644
--- a/src/qml/jsruntime/qv4stringobject_p.h
+++ b/src/qml/jsruntime/qv4stringobject_p.h
@@ -106,8 +106,8 @@ struct StringCtor: FunctionObject
 {
     V4_OBJECT2(StringCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *m, CallData *callData);
-    static ReturnedValue call(const Managed *, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
 };
 
 struct StringPrototype: StringObject
diff --git a/src/qml/jsruntime/qv4typedarray.cpp b/src/qml/jsruntime/qv4typedarray.cpp
index 7c2c623b93..c1fbec70ea 100644
--- a/src/qml/jsruntime/qv4typedarray.cpp
+++ b/src/qml/jsruntime/qv4typedarray.cpp
@@ -209,14 +209,14 @@ void Heap::TypedArrayCtor::init(QV4::ExecutionContext *scope, TypedArray::Type t
     type = t;
 }
 
-ReturnedValue TypedArrayCtor::callAsConstructor(const Managed *m, CallData *callData)
+ReturnedValue TypedArrayCtor::callAsConstructor(const FunctionObject *f, const Value *argv, int argc)
 {
-    Scope scope(m->engine());
-    Scoped<TypedArrayCtor> that(scope, static_cast<const TypedArrayCtor *>(m));
+    Scope scope(f->engine());
+    const TypedArrayCtor *that = static_cast<const TypedArrayCtor *>(f);
 
-    if (!callData->argc() || !callData->args[0].isObject()) {
+    if (!argc || !argv[0].isObject()) {
         // ECMA 6 22.2.1.1
-        double l = callData->argc() ? callData->args[0].toNumber() : 0;
+        double l = argc ? argv[0].toNumber() : 0;
         if (scope.engine->hasException)
             return Encode::undefined();
         uint len = (uint)l;
@@ -234,7 +234,7 @@ ReturnedValue TypedArrayCtor::callAsConstructor(const Managed *m, CallData *call
 
         return array.asReturnedValue();
     }
-    Scoped<TypedArray> typedArray(scope, callData->argument(0));
+    Scoped<TypedArray> typedArray(scope, argc ? argv[0] : Primitive::undefinedValue());
     if (!!typedArray) {
         // ECMA 6 22.2.1.2
         Scoped<ArrayBuffer> buffer(scope, typedArray->d()->buffer);
@@ -272,23 +272,23 @@ ReturnedValue TypedArrayCtor::callAsConstructor(const Managed *m, CallData *call
 
         return array.asReturnedValue();
     }
-    Scoped<ArrayBuffer> buffer(scope, callData->argument(0));
+    Scoped<ArrayBuffer> buffer(scope, argc ? argv[0] : Primitive::undefinedValue());
     if (!!buffer) {
         // ECMA 6 22.2.1.4
 
-        double dbyteOffset = callData->argc() > 1 ? callData->args[1].toInteger() : 0;
+        double dbyteOffset = argc > 1 ? argv[1].toInteger() : 0;
         uint byteOffset = (uint)dbyteOffset;
         uint elementSize = operations[that->d()->type].bytesPerElement;
         if (dbyteOffset < 0 || (byteOffset % elementSize) || dbyteOffset > buffer->byteLength())
             return scope.engine->throwRangeError(QStringLiteral("new TypedArray: invalid byteOffset"));
 
         uint byteLength;
-        if (callData->argc() < 3 || callData->args[2].isUndefined()) {
+        if (argc < 3 || argv[2].isUndefined()) {
             byteLength = buffer->byteLength() - byteOffset;
             if (buffer->byteLength() < byteOffset || byteLength % elementSize)
                 return scope.engine->throwRangeError(QStringLiteral("new TypedArray: invalid length"));
         } else {
-            double l = qBound(0., callData->args[2].toInteger(), (double)UINT_MAX);
+            double l = qBound(0., argv[2].toInteger(), (double)UINT_MAX);
             if (scope.engine->hasException)
                 return Encode::undefined();
             l *= elementSize;
@@ -306,7 +306,7 @@ ReturnedValue TypedArrayCtor::callAsConstructor(const Managed *m, CallData *call
 
     // ECMA 6 22.2.1.3
 
-    ScopedObject o(scope, callData->argument(0));
+    ScopedObject o(scope, argc ? argv[0] : Primitive::undefinedValue());
     uint l = (uint) qBound(0., ScopedValue(scope, o->get(scope.engine->id_length()))->toInteger(), (double)UINT_MAX);
     if (scope.engine->hasException)
         return scope.engine->throwTypeError();
@@ -337,9 +337,9 @@ ReturnedValue TypedArrayCtor::callAsConstructor(const Managed *m, CallData *call
     return array.asReturnedValue();
 }
 
-ReturnedValue TypedArrayCtor::call(const Managed *that, CallData *callData)
+ReturnedValue TypedArrayCtor::call(const FunctionObject *f, const Value *, const Value *argv, int argc)
 {
-    return callAsConstructor(that, callData);
+    return callAsConstructor(f, argv, argc);
 }
 
 void Heap::TypedArray::init(Type t)
diff --git a/src/qml/jsruntime/qv4typedarray_p.h b/src/qml/jsruntime/qv4typedarray_p.h
index ae82f2b9b5..6fe53e68d5 100644
--- a/src/qml/jsruntime/qv4typedarray_p.h
+++ b/src/qml/jsruntime/qv4typedarray_p.h
@@ -141,8 +141,8 @@ struct TypedArrayCtor: FunctionObject
 {
     V4_OBJECT2(TypedArrayCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *m, CallData *callData);
-    static ReturnedValue call(const Managed *that, CallData *callData);
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *argv, int argc);
+    static ReturnedValue call(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc);
 };
 
 
diff --git a/src/qml/qml/qqmlxmlhttprequest.cpp b/src/qml/qml/qqmlxmlhttprequest.cpp
index fcc837fb95..323074e12f 100644
--- a/src/qml/qml/qqmlxmlhttprequest.cpp
+++ b/src/qml/qml/qqmlxmlhttprequest.cpp
@@ -1635,12 +1635,10 @@ struct QQmlXMLHttpRequestCtor : public FunctionObject
 {
     V4_OBJECT2(QQmlXMLHttpRequestCtor, FunctionObject)
 
-    static ReturnedValue callAsConstructor(const Managed *that, QV4::CallData *)
+    static ReturnedValue callAsConstructor(const FunctionObject *f, const Value *, int)
     {
-        Scope scope(that->engine());
-        Scoped<QQmlXMLHttpRequestCtor> ctor(scope, that->as<QQmlXMLHttpRequestCtor>());
-        if (!ctor)
-            return scope.engine->throwTypeError();
+        Scope scope(f->engine());
+        const QQmlXMLHttpRequestCtor *ctor = static_cast<const QQmlXMLHttpRequestCtor *>(f);
 
         QQmlXMLHttpRequest *r = new QQmlXMLHttpRequest(scope.engine->v8Engine->networkAccessManager());
         Scoped<QQmlXMLHttpRequestWrapper> w(scope, scope.engine->memoryManager->allocObject<QQmlXMLHttpRequestWrapper>(r));
@@ -1649,7 +1647,7 @@ struct QQmlXMLHttpRequestCtor : public FunctionObject
         return w.asReturnedValue();
     }
 
-    static ReturnedValue call(const Managed *, QV4::CallData *) {
+    static ReturnedValue call(const FunctionObject *, const Value *, const Value *, int) {
         return Encode::undefined();
     }
 
diff --git a/src/qml/types/qqmldelegatemodel.cpp b/src/qml/types/qqmldelegatemodel.cpp
index 3f801ec2b5..967f89971d 100644
--- a/src/qml/types/qqmldelegatemodel.cpp
+++ b/src/qml/types/qqmldelegatemodel.cpp
@@ -96,15 +96,15 @@ struct DelegateModelGroupFunction : QV4::FunctionObject
         return scope->engine()->memoryManager->allocObject<DelegateModelGroupFunction>(scope, flag, code);
     }
 
-    static ReturnedValue call(const QV4::Managed *that, QV4::CallData *callData)
+    static ReturnedValue call(const QV4::FunctionObject *that, const Value *thisObject, const Value *argv, int argc)
     {
         QV4::Scope scope(that->engine());
         QV4::Scoped<DelegateModelGroupFunction> f(scope, static_cast<const DelegateModelGroupFunction *>(that));
-        QV4::Scoped<QQmlDelegateModelItemObject> o(scope, callData->thisObject);
+        QV4::Scoped<QQmlDelegateModelItemObject> o(scope, thisObject);
         if (!o)
             return scope.engine->throwTypeError(QStringLiteral("Not a valid VisualData object"));
 
-        QV4::ScopedValue v(scope, callData->argument(0));
+        QV4::ScopedValue v(scope, argc ? argv[0] : Primitive::undefinedValue());
         return f->d()->code(o->d()->item, f->d()->flag, v);
     }
 };