Cleanup Object::define*Property API

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

41 files changed, 577 insertions, 592 deletions

diff --git a/src/imports/localstorage/plugin.cpp b/src/imports/localstorage/plugin.cpp
index 1c71c529ca..2a3cb1ccc5 100644
--- a/src/imports/localstorage/plugin.cpp
+++ b/src/imports/localstorage/plugin.cpp
@@ -446,23 +446,23 @@ QQmlSqlDatabaseData::QQmlSqlDatabaseData(QV8Engine *engine)
     Scope scope(v4);
     {
         Scoped<Object> proto(scope, v4->newObject());
-        proto->defineDefaultProperty(v4, QStringLiteral("transaction"), qmlsqldatabase_transaction);
-        proto->defineDefaultProperty(v4, QStringLiteral("readTransaction"), qmlsqldatabase_read_transaction);
-        proto->defineAccessorProperty(v4, QStringLiteral("version"), qmlsqldatabase_version, 0);
-        proto->defineDefaultProperty(v4, QStringLiteral("changeVersion"), qmlsqldatabase_changeVersion);
+        proto->defineDefaultProperty(QStringLiteral("transaction"), qmlsqldatabase_transaction);
+        proto->defineDefaultProperty(QStringLiteral("readTransaction"), qmlsqldatabase_read_transaction);
+        proto->defineAccessorProperty(QStringLiteral("version"), qmlsqldatabase_version, 0);
+        proto->defineDefaultProperty(QStringLiteral("changeVersion"), qmlsqldatabase_changeVersion);
         databaseProto = proto;
     }
 
     {
         Scoped<Object> proto(scope, v4->newObject());
-        proto->defineDefaultProperty(v4, QStringLiteral("executeSql"), qmlsqldatabase_executeSql);
+        proto->defineDefaultProperty(QStringLiteral("executeSql"), qmlsqldatabase_executeSql);
         queryProto = proto;
     }
     {
         Scoped<Object> proto(scope, v4->newObject());
-        proto->defineDefaultProperty(v4, QStringLiteral("item"), qmlsqldatabase_rows_item);
-        proto->defineAccessorProperty(v4, QStringLiteral("length"), qmlsqldatabase_rows_length, 0);
-        proto->defineAccessorProperty(v4, QStringLiteral("forwardOnly"),
+        proto->defineDefaultProperty(QStringLiteral("item"), qmlsqldatabase_rows_item);
+        proto->defineAccessorProperty(QStringLiteral("length"), qmlsqldatabase_rows_length, 0);
+        proto->defineAccessorProperty(QStringLiteral("forwardOnly"),
                                       qmlsqldatabase_rows_forwardOnly, qmlsqldatabase_rows_setForwardOnly);
         rowsProto = proto;
     }
diff --git a/src/particles/qquickv4particledata.cpp b/src/particles/qquickv4particledata.cpp
index 23018677ea..9f95edff3b 100644
--- a/src/particles/qquickv4particledata.cpp
+++ b/src/particles/qquickv4particledata.cpp
@@ -413,7 +413,7 @@ static QV4::ReturnedValue particleData_set_ ## VARIABLE (QV4::SimpleCallContext
 }
 
 #define REGISTER_ACCESSOR(PROTO, ENGINE, VARIABLE, NAME) \
-    PROTO ->defineAccessorProperty( ENGINE, QStringLiteral( #NAME ), particleData_get_ ## VARIABLE , particleData_set_ ## VARIABLE )
+    PROTO ->defineAccessorProperty( QStringLiteral( #NAME ), particleData_get_ ## VARIABLE , particleData_set_ ## VARIABLE )
 
 COLOR_GETTER_AND_SETTER(r, red)
 COLOR_GETTER_AND_SETTER(g, green)
@@ -456,9 +456,9 @@ QV8ParticleDataDeletable::QV8ParticleDataDeletable(QV8Engine *engine)
     QV4::Scope scope(v4);
     QV4::Scoped<QV4::Object> p(scope, v4->newObject());
 
-    p->defineDefaultProperty(v4, QStringLiteral("discard"), particleData_discard);
-    p->defineDefaultProperty(v4, QStringLiteral("lifeLeft"), particleData_lifeLeft);
-    p->defineDefaultProperty(v4, QStringLiteral("currentSize"), particleData_curSize);
+    p->defineDefaultProperty(QStringLiteral("discard"), particleData_discard);
+    p->defineDefaultProperty(QStringLiteral("lifeLeft"), particleData_lifeLeft);
+    p->defineDefaultProperty(QStringLiteral("currentSize"), particleData_curSize);
 
     REGISTER_ACCESSOR(p, v4, x, initialX);
     REGISTER_ACCESSOR(p, v4, y, initialY);
diff --git a/src/qml/jsruntime/qv4arrayobject.cpp b/src/qml/jsruntime/qv4arrayobject.cpp
index ce6bdca627..c066c3b533 100644
--- a/src/qml/jsruntime/qv4arrayobject.cpp
+++ b/src/qml/jsruntime/qv4arrayobject.cpp
@@ -91,33 +91,33 @@ ArrayPrototype::ArrayPrototype(InternalClass *ic)
 {
 }
 
-void ArrayPrototype::init(ExecutionContext *ctx, const Value &ctor)
+void ArrayPrototype::init(ExecutionEngine *engine, const Value &ctor)
 {
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_length, Value::fromInt32(1));
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_prototype, Value::fromObject(this));
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("isArray"), method_isArray, 1);
-    defineDefaultProperty(ctx, QStringLiteral("constructor"), ctor);
-    defineDefaultProperty(ctx, QStringLiteral("toString"), method_toString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("toLocaleString"), method_toLocaleString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("concat"), method_concat, 1);
-    defineDefaultProperty(ctx, QStringLiteral("join"), method_join, 1);
-    defineDefaultProperty(ctx, QStringLiteral("pop"), method_pop, 0);
-    defineDefaultProperty(ctx, QStringLiteral("push"), method_push, 1);
-    defineDefaultProperty(ctx, QStringLiteral("reverse"), method_reverse, 0);
-    defineDefaultProperty(ctx, QStringLiteral("shift"), method_shift, 0);
-    defineDefaultProperty(ctx, QStringLiteral("slice"), method_slice, 2);
-    defineDefaultProperty(ctx, QStringLiteral("sort"), method_sort, 1);
-    defineDefaultProperty(ctx, QStringLiteral("splice"), method_splice, 2);
-    defineDefaultProperty(ctx, QStringLiteral("unshift"), method_unshift, 1);
-    defineDefaultProperty(ctx, QStringLiteral("indexOf"), method_indexOf, 1);
-    defineDefaultProperty(ctx, QStringLiteral("lastIndexOf"), method_lastIndexOf, 1);
-    defineDefaultProperty(ctx, QStringLiteral("every"), method_every, 1);
-    defineDefaultProperty(ctx, QStringLiteral("some"), method_some, 1);
-    defineDefaultProperty(ctx, QStringLiteral("forEach"), method_forEach, 1);
-    defineDefaultProperty(ctx, QStringLiteral("map"), method_map, 1);
-    defineDefaultProperty(ctx, QStringLiteral("filter"), method_filter, 1);
-    defineDefaultProperty(ctx, QStringLiteral("reduce"), method_reduce, 1);
-    defineDefaultProperty(ctx, QStringLiteral("reduceRight"), method_reduceRight, 1);
+    ctor.objectValue()->defineReadonlyProperty(engine->id_length, Value::fromInt32(1));
+    ctor.objectValue()->defineReadonlyProperty(engine->id_prototype, Value::fromObject(this));
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("isArray"), method_isArray, 1);
+    defineDefaultProperty(QStringLiteral("constructor"), ctor);
+    defineDefaultProperty(QStringLiteral("toString"), method_toString, 0);
+    defineDefaultProperty(QStringLiteral("toLocaleString"), method_toLocaleString, 0);
+    defineDefaultProperty(QStringLiteral("concat"), method_concat, 1);
+    defineDefaultProperty(QStringLiteral("join"), method_join, 1);
+    defineDefaultProperty(QStringLiteral("pop"), method_pop, 0);
+    defineDefaultProperty(QStringLiteral("push"), method_push, 1);
+    defineDefaultProperty(QStringLiteral("reverse"), method_reverse, 0);
+    defineDefaultProperty(QStringLiteral("shift"), method_shift, 0);
+    defineDefaultProperty(QStringLiteral("slice"), method_slice, 2);
+    defineDefaultProperty(QStringLiteral("sort"), method_sort, 1);
+    defineDefaultProperty(QStringLiteral("splice"), method_splice, 2);
+    defineDefaultProperty(QStringLiteral("unshift"), method_unshift, 1);
+    defineDefaultProperty(QStringLiteral("indexOf"), method_indexOf, 1);
+    defineDefaultProperty(QStringLiteral("lastIndexOf"), method_lastIndexOf, 1);
+    defineDefaultProperty(QStringLiteral("every"), method_every, 1);
+    defineDefaultProperty(QStringLiteral("some"), method_some, 1);
+    defineDefaultProperty(QStringLiteral("forEach"), method_forEach, 1);
+    defineDefaultProperty(QStringLiteral("map"), method_map, 1);
+    defineDefaultProperty(QStringLiteral("filter"), method_filter, 1);
+    defineDefaultProperty(QStringLiteral("reduce"), method_reduce, 1);
+    defineDefaultProperty(QStringLiteral("reduceRight"), method_reduceRight, 1);
 }
 
 uint ArrayPrototype::getLength(ExecutionContext *ctx, Object *o)
diff --git a/src/qml/jsruntime/qv4arrayobject_p.h b/src/qml/jsruntime/qv4arrayobject_p.h
index a38a87f1f3..62a731f4e0 100644
--- a/src/qml/jsruntime/qv4arrayobject_p.h
+++ b/src/qml/jsruntime/qv4arrayobject_p.h
@@ -62,7 +62,7 @@ struct ArrayPrototype: ArrayObject
 {
     ArrayPrototype(InternalClass *ic);
 
-    void init(ExecutionContext *ctx, const Value &ctor);
+    void init(ExecutionEngine *engine, const Value &ctor);
 
     static uint getLength(ExecutionContext *ctx, Object *o);
 
diff --git a/src/qml/jsruntime/qv4booleanobject.cpp b/src/qml/jsruntime/qv4booleanobject.cpp
index 86ddebd6c3..28589e4104 100644
--- a/src/qml/jsruntime/qv4booleanobject.cpp
+++ b/src/qml/jsruntime/qv4booleanobject.cpp
@@ -63,13 +63,13 @@ ReturnedValue BooleanCtor::call(Managed *, CallData *callData)
     return Encode(value);
 }
 
-void BooleanPrototype::init(ExecutionContext *ctx, const Value &ctor)
+void BooleanPrototype::init(ExecutionEngine *engine, const Value &ctor)
 {
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_length, Value::fromInt32(1));
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_prototype, Value::fromObject(this));
-    defineDefaultProperty(ctx, QStringLiteral("constructor"), ctor);
-    defineDefaultProperty(ctx, QStringLiteral("toString"), method_toString);
-    defineDefaultProperty(ctx, QStringLiteral("valueOf"), method_valueOf);
+    ctor.objectValue()->defineReadonlyProperty(engine->id_length, Value::fromInt32(1));
+    ctor.objectValue()->defineReadonlyProperty(engine->id_prototype, Value::fromObject(this));
+    defineDefaultProperty(QStringLiteral("constructor"), ctor);
+    defineDefaultProperty(QStringLiteral("toString"), method_toString);
+    defineDefaultProperty(QStringLiteral("valueOf"), method_valueOf);
 }
 
 ReturnedValue BooleanPrototype::method_toString(SimpleCallContext *ctx)
diff --git a/src/qml/jsruntime/qv4booleanobject_p.h b/src/qml/jsruntime/qv4booleanobject_p.h
index ef74834a5c..a7b85deace 100644
--- a/src/qml/jsruntime/qv4booleanobject_p.h
+++ b/src/qml/jsruntime/qv4booleanobject_p.h
@@ -61,7 +61,7 @@ struct BooleanCtor: FunctionObject
 struct BooleanPrototype: BooleanObject
 {
     BooleanPrototype(InternalClass *ic): BooleanObject(ic) {}
-    void init(ExecutionContext *ctx, const Value &ctor);
+    void init(ExecutionEngine *engine, const Value &ctor);
 
     static ReturnedValue method_toString(SimpleCallContext *ctx);
     static ReturnedValue method_valueOf(SimpleCallContext *ctx);
diff --git a/src/qml/jsruntime/qv4dateobject.cpp b/src/qml/jsruntime/qv4dateobject.cpp
index 14e54a2e53..0a8aca4a01 100644
--- a/src/qml/jsruntime/qv4dateobject.cpp
+++ b/src/qml/jsruntime/qv4dateobject.cpp
@@ -701,63 +701,63 @@ ReturnedValue DateCtor::call(Managed *m, CallData *)
     return Value::fromString(m->engine()->current, ToString(t)).asReturnedValue();
 }
 
-void DatePrototype::init(ExecutionContext *ctx, const Value &ctor)
+void DatePrototype::init(ExecutionEngine *engine, const Value &ctor)
 {
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_prototype, Value::fromObject(this));
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_length, Value::fromInt32(7));
+    ctor.objectValue()->defineReadonlyProperty(engine->id_prototype, Value::fromObject(this));
+    ctor.objectValue()->defineReadonlyProperty(engine->id_length, Value::fromInt32(7));
     LocalTZA = getLocalTZA();
 
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("parse"), method_parse, 1);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("UTC"), method_UTC, 7);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("now"), method_now, 0);
-
-    defineDefaultProperty(ctx, QStringLiteral("constructor"), ctor);
-    defineDefaultProperty(ctx, QStringLiteral("toString"), method_toString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("toDateString"), method_toDateString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("toTimeString"), method_toTimeString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("toLocaleString"), method_toLocaleString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("toLocaleDateString"), method_toLocaleDateString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("toLocaleTimeString"), method_toLocaleTimeString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("valueOf"), method_valueOf, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getTime"), method_getTime, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getYear"), method_getYear, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getFullYear"), method_getFullYear, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getUTCFullYear"), method_getUTCFullYear, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getMonth"), method_getMonth, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getUTCMonth"), method_getUTCMonth, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getDate"), method_getDate, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getUTCDate"), method_getUTCDate, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getDay"), method_getDay, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getUTCDay"), method_getUTCDay, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getHours"), method_getHours, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getUTCHours"), method_getUTCHours, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getMinutes"), method_getMinutes, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getUTCMinutes"), method_getUTCMinutes, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getSeconds"), method_getSeconds, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getUTCSeconds"), method_getUTCSeconds, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getMilliseconds"), method_getMilliseconds, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getUTCMilliseconds"), method_getUTCMilliseconds, 0);
-    defineDefaultProperty(ctx, QStringLiteral("getTimezoneOffset"), method_getTimezoneOffset, 0);
-    defineDefaultProperty(ctx, QStringLiteral("setTime"), method_setTime, 1);
-    defineDefaultProperty(ctx, QStringLiteral("setMilliseconds"), method_setMilliseconds, 1);
-    defineDefaultProperty(ctx, QStringLiteral("setUTCMilliseconds"), method_setUTCMilliseconds, 1);
-    defineDefaultProperty(ctx, QStringLiteral("setSeconds"), method_setSeconds, 2);
-    defineDefaultProperty(ctx, QStringLiteral("setUTCSeconds"), method_setUTCSeconds, 2);
-    defineDefaultProperty(ctx, QStringLiteral("setMinutes"), method_setMinutes, 3);
-    defineDefaultProperty(ctx, QStringLiteral("setUTCMinutes"), method_setUTCMinutes, 3);
-    defineDefaultProperty(ctx, QStringLiteral("setHours"), method_setHours, 4);
-    defineDefaultProperty(ctx, QStringLiteral("setUTCHours"), method_setUTCHours, 4);
-    defineDefaultProperty(ctx, QStringLiteral("setDate"), method_setDate, 1);
-    defineDefaultProperty(ctx, QStringLiteral("setUTCDate"), method_setUTCDate, 1);
-    defineDefaultProperty(ctx, QStringLiteral("setMonth"), method_setMonth, 2);
-    defineDefaultProperty(ctx, QStringLiteral("setUTCMonth"), method_setUTCMonth, 2);
-    defineDefaultProperty(ctx, QStringLiteral("setYear"), method_setYear, 1);
-    defineDefaultProperty(ctx, QStringLiteral("setFullYear"), method_setFullYear, 3);
-    defineDefaultProperty(ctx, QStringLiteral("setUTCFullYear"), method_setUTCFullYear, 3);
-    defineDefaultProperty(ctx, QStringLiteral("toUTCString"), method_toUTCString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("toGMTString"), method_toUTCString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("toISOString"), method_toISOString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("toJSON"), method_toJSON, 1);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("parse"), method_parse, 1);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("UTC"), method_UTC, 7);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("now"), method_now, 0);
+
+    defineDefaultProperty(QStringLiteral("constructor"), ctor);
+    defineDefaultProperty(QStringLiteral("toString"), method_toString, 0);
+    defineDefaultProperty(QStringLiteral("toDateString"), method_toDateString, 0);
+    defineDefaultProperty(QStringLiteral("toTimeString"), method_toTimeString, 0);
+    defineDefaultProperty(QStringLiteral("toLocaleString"), method_toLocaleString, 0);
+    defineDefaultProperty(QStringLiteral("toLocaleDateString"), method_toLocaleDateString, 0);
+    defineDefaultProperty(QStringLiteral("toLocaleTimeString"), method_toLocaleTimeString, 0);
+    defineDefaultProperty(QStringLiteral("valueOf"), method_valueOf, 0);
+    defineDefaultProperty(QStringLiteral("getTime"), method_getTime, 0);
+    defineDefaultProperty(QStringLiteral("getYear"), method_getYear, 0);
+    defineDefaultProperty(QStringLiteral("getFullYear"), method_getFullYear, 0);
+    defineDefaultProperty(QStringLiteral("getUTCFullYear"), method_getUTCFullYear, 0);
+    defineDefaultProperty(QStringLiteral("getMonth"), method_getMonth, 0);
+    defineDefaultProperty(QStringLiteral("getUTCMonth"), method_getUTCMonth, 0);
+    defineDefaultProperty(QStringLiteral("getDate"), method_getDate, 0);
+    defineDefaultProperty(QStringLiteral("getUTCDate"), method_getUTCDate, 0);
+    defineDefaultProperty(QStringLiteral("getDay"), method_getDay, 0);
+    defineDefaultProperty(QStringLiteral("getUTCDay"), method_getUTCDay, 0);
+    defineDefaultProperty(QStringLiteral("getHours"), method_getHours, 0);
+    defineDefaultProperty(QStringLiteral("getUTCHours"), method_getUTCHours, 0);
+    defineDefaultProperty(QStringLiteral("getMinutes"), method_getMinutes, 0);
+    defineDefaultProperty(QStringLiteral("getUTCMinutes"), method_getUTCMinutes, 0);
+    defineDefaultProperty(QStringLiteral("getSeconds"), method_getSeconds, 0);
+    defineDefaultProperty(QStringLiteral("getUTCSeconds"), method_getUTCSeconds, 0);
+    defineDefaultProperty(QStringLiteral("getMilliseconds"), method_getMilliseconds, 0);
+    defineDefaultProperty(QStringLiteral("getUTCMilliseconds"), method_getUTCMilliseconds, 0);
+    defineDefaultProperty(QStringLiteral("getTimezoneOffset"), method_getTimezoneOffset, 0);
+    defineDefaultProperty(QStringLiteral("setTime"), method_setTime, 1);
+    defineDefaultProperty(QStringLiteral("setMilliseconds"), method_setMilliseconds, 1);
+    defineDefaultProperty(QStringLiteral("setUTCMilliseconds"), method_setUTCMilliseconds, 1);
+    defineDefaultProperty(QStringLiteral("setSeconds"), method_setSeconds, 2);
+    defineDefaultProperty(QStringLiteral("setUTCSeconds"), method_setUTCSeconds, 2);
+    defineDefaultProperty(QStringLiteral("setMinutes"), method_setMinutes, 3);
+    defineDefaultProperty(QStringLiteral("setUTCMinutes"), method_setUTCMinutes, 3);
+    defineDefaultProperty(QStringLiteral("setHours"), method_setHours, 4);
+    defineDefaultProperty(QStringLiteral("setUTCHours"), method_setUTCHours, 4);
+    defineDefaultProperty(QStringLiteral("setDate"), method_setDate, 1);
+    defineDefaultProperty(QStringLiteral("setUTCDate"), method_setUTCDate, 1);
+    defineDefaultProperty(QStringLiteral("setMonth"), method_setMonth, 2);
+    defineDefaultProperty(QStringLiteral("setUTCMonth"), method_setUTCMonth, 2);
+    defineDefaultProperty(QStringLiteral("setYear"), method_setYear, 1);
+    defineDefaultProperty(QStringLiteral("setFullYear"), method_setFullYear, 3);
+    defineDefaultProperty(QStringLiteral("setUTCFullYear"), method_setUTCFullYear, 3);
+    defineDefaultProperty(QStringLiteral("toUTCString"), method_toUTCString, 0);
+    defineDefaultProperty(QStringLiteral("toGMTString"), method_toUTCString, 0);
+    defineDefaultProperty(QStringLiteral("toISOString"), method_toISOString, 0);
+    defineDefaultProperty(QStringLiteral("toJSON"), method_toJSON, 1);
 }
 
 double DatePrototype::getThisDate(ExecutionContext *ctx)
diff --git a/src/qml/jsruntime/qv4dateobject_p.h b/src/qml/jsruntime/qv4dateobject_p.h
index 45a9420a41..758a2ce197 100644
--- a/src/qml/jsruntime/qv4dateobject_p.h
+++ b/src/qml/jsruntime/qv4dateobject_p.h
@@ -81,7 +81,7 @@ struct DateCtor: FunctionObject
 struct DatePrototype: DateObject
 {
     DatePrototype(InternalClass *ic): DateObject(ic) {}
-    void init(ExecutionContext *ctx, const Value &ctor);
+    void init(ExecutionEngine *engine, const Value &ctor);
 
     static double getThisDate(ExecutionContext *ctx);
 
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 331d9d83f4..4039e2135c 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -232,14 +232,14 @@ ExecutionEngine::ExecutionEngine(QQmlJS::EvalISelFactory *factory)
     typeErrorCtor = Value::fromObject(new (memoryManager) TypeErrorCtor(rootContext));
     uRIErrorCtor = Value::fromObject(new (memoryManager) URIErrorCtor(rootContext));
 
-    objectPrototype->init(rootContext, objectCtor);
+    objectPrototype->init(this, objectCtor);
     stringPrototype->init(this, stringCtor);
-    numberPrototype->init(rootContext, numberCtor);
-    booleanPrototype->init(rootContext, booleanCtor);
-    arrayPrototype->init(rootContext, arrayCtor);
-    datePrototype->init(rootContext, dateCtor);
-    functionPrototype->init(rootContext, functionCtor);
-    regExpPrototype->init(rootContext, regExpCtor);
+    numberPrototype->init(this, numberCtor);
+    booleanPrototype->init(this, booleanCtor);
+    arrayPrototype->init(this, arrayCtor);
+    datePrototype->init(this, dateCtor);
+    functionPrototype->init(this, functionCtor);
+    regExpPrototype->init(this, regExpCtor);
     errorPrototype->init(this, errorCtor);
     evalErrorPrototype->init(this, evalErrorCtor);
     rangeErrorPrototype->init(this, rangeErrorCtor);
@@ -248,8 +248,8 @@ ExecutionEngine::ExecutionEngine(QQmlJS::EvalISelFactory *factory)
     typeErrorPrototype->init(this, typeErrorCtor);
     uRIErrorPrototype->init(this, uRIErrorCtor);
 
-    variantPrototype->init(this);
-    sequencePrototype->init(this);
+    variantPrototype->init();
+    sequencePrototype->init();
 
     //
     // set up the global object
@@ -258,41 +258,41 @@ ExecutionEngine::ExecutionEngine(QQmlJS::EvalISelFactory *factory)
     rootContext->global = globalObject;
     rootContext->thisObject = Value::fromObject(globalObject);
 
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("Object"), objectCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("String"), stringCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("Number"), numberCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("Boolean"), booleanCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("Array"), arrayCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("Function"), functionCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("Date"), dateCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("RegExp"), regExpCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("Error"), errorCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("EvalError"), evalErrorCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("RangeError"), rangeErrorCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("ReferenceError"), referenceErrorCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("SyntaxError"), syntaxErrorCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("TypeError"), typeErrorCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("URIError"), uRIErrorCtor);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("Math"), Value::fromObject(new (memoryManager) MathObject(rootContext)));
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("JSON"), Value::fromObject(new (memoryManager) JsonObject(rootContext)));
-
-    globalObject->defineReadonlyProperty(this, QStringLiteral("undefined"), Value::undefinedValue());
-    globalObject->defineReadonlyProperty(this, QStringLiteral("NaN"), Value::fromDouble(std::numeric_limits<double>::quiet_NaN()));
-    globalObject->defineReadonlyProperty(this, QStringLiteral("Infinity"), Value::fromDouble(Q_INFINITY));
+    globalObject->defineDefaultProperty(QStringLiteral("Object"), objectCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("String"), stringCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("Number"), numberCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("Boolean"), booleanCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("Array"), arrayCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("Function"), functionCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("Date"), dateCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("RegExp"), regExpCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("Error"), errorCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("EvalError"), evalErrorCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("RangeError"), rangeErrorCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("ReferenceError"), referenceErrorCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("SyntaxError"), syntaxErrorCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("TypeError"), typeErrorCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("URIError"), uRIErrorCtor);
+    globalObject->defineDefaultProperty(QStringLiteral("Math"), Value::fromObject(new (memoryManager) MathObject(this)));
+    globalObject->defineDefaultProperty(QStringLiteral("JSON"), Value::fromObject(new (memoryManager) JsonObject(this)));
+
+    globalObject->defineReadonlyProperty(QStringLiteral("undefined"), Value::undefinedValue());
+    globalObject->defineReadonlyProperty(QStringLiteral("NaN"), Value::fromDouble(std::numeric_limits<double>::quiet_NaN()));
+    globalObject->defineReadonlyProperty(QStringLiteral("Infinity"), Value::fromDouble(Q_INFINITY));
 
     evalFunction = new (memoryManager) EvalFunction(rootContext);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("eval"), Value::fromObject(evalFunction));
-
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("parseInt"), GlobalFunctions::method_parseInt, 2);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("parseFloat"), GlobalFunctions::method_parseFloat, 1);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("isNaN"), GlobalFunctions::method_isNaN, 1);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("isFinite"), GlobalFunctions::method_isFinite, 1);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("decodeURI"), GlobalFunctions::method_decodeURI, 1);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("decodeURIComponent"), GlobalFunctions::method_decodeURIComponent, 1);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("encodeURI"), GlobalFunctions::method_encodeURI, 1);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("encodeURIComponent"), GlobalFunctions::method_encodeURIComponent, 1);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("escape"), GlobalFunctions::method_escape, 1);
-    globalObject->defineDefaultProperty(rootContext, QStringLiteral("unescape"), GlobalFunctions::method_unescape, 1);
+    globalObject->defineDefaultProperty(QStringLiteral("eval"), Value::fromObject(evalFunction));
+
+    globalObject->defineDefaultProperty(QStringLiteral("parseInt"), GlobalFunctions::method_parseInt, 2);
+    globalObject->defineDefaultProperty(QStringLiteral("parseFloat"), GlobalFunctions::method_parseFloat, 1);
+    globalObject->defineDefaultProperty(QStringLiteral("isNaN"), GlobalFunctions::method_isNaN, 1);
+    globalObject->defineDefaultProperty(QStringLiteral("isFinite"), GlobalFunctions::method_isFinite, 1);
+    globalObject->defineDefaultProperty(QStringLiteral("decodeURI"), GlobalFunctions::method_decodeURI, 1);
+    globalObject->defineDefaultProperty(QStringLiteral("decodeURIComponent"), GlobalFunctions::method_decodeURIComponent, 1);
+    globalObject->defineDefaultProperty(QStringLiteral("encodeURI"), GlobalFunctions::method_encodeURI, 1);
+    globalObject->defineDefaultProperty(QStringLiteral("encodeURIComponent"), GlobalFunctions::method_encodeURIComponent, 1);
+    globalObject->defineDefaultProperty(QStringLiteral("escape"), GlobalFunctions::method_escape, 1);
+    globalObject->defineDefaultProperty(QStringLiteral("unescape"), GlobalFunctions::method_unescape, 1);
 
     Scope scope(this);
     Scoped<String> name(scope, newString(QStringLiteral("thrower")));
diff --git a/src/qml/jsruntime/qv4errorobject.cpp b/src/qml/jsruntime/qv4errorobject.cpp
index 1fd539ae2f..0face7cf8c 100644
--- a/src/qml/jsruntime/qv4errorobject.cpp
+++ b/src/qml/jsruntime/qv4errorobject.cpp
@@ -78,7 +78,7 @@ ErrorObject::ErrorObject(InternalClass *ic)
 {
     type = Type_ErrorObject;
     vtbl = &static_vtbl;
-    defineDefaultProperty(ic->engine, QStringLiteral("name"), Value::fromString(ic->engine, "Error"));
+    defineDefaultProperty(QStringLiteral("name"), Value::fromString(ic->engine, "Error"));
 }
 
 ErrorObject::ErrorObject(InternalClass *ic, const Value &message, ErrorType t)
@@ -88,16 +88,16 @@ ErrorObject::ErrorObject(InternalClass *ic, const Value &message, ErrorType t)
     type = Type_ErrorObject;
     vtbl = &static_vtbl;
     subtype = t;
-    defineAccessorProperty(ic->engine, QStringLiteral("stack"), ErrorObject::method_get_stack, 0);
+    defineAccessorProperty(QStringLiteral("stack"), ErrorObject::method_get_stack, 0);
 
     if (!message.isUndefined())
-        defineDefaultProperty(ic->engine, QStringLiteral("message"), message);
-    defineDefaultProperty(ic->engine, QStringLiteral("name"), Value::fromString(ic->engine, className()));
+        defineDefaultProperty(QStringLiteral("message"), message);
+    defineDefaultProperty(QStringLiteral("name"), Value::fromString(ic->engine, className()));
 
     stackTrace = ic->engine->stackTrace();
     if (!stackTrace.isEmpty()) {
-        defineDefaultProperty(ic->engine, QStringLiteral("fileName"), Value::fromString(ic->engine, stackTrace.at(0).source));
-        defineDefaultProperty(ic->engine, QStringLiteral("lineNumber"), Value::fromInt32(stackTrace.at(0).line));
+        defineDefaultProperty(QStringLiteral("fileName"), Value::fromString(ic->engine, stackTrace.at(0).source));
+        defineDefaultProperty(QStringLiteral("lineNumber"), Value::fromInt32(stackTrace.at(0).line));
     }
 }
 
@@ -108,9 +108,9 @@ ErrorObject::ErrorObject(InternalClass *ic, const QString &message, const QStrin
     type = Type_ErrorObject;
     vtbl = &static_vtbl;
     subtype = t;
-    defineAccessorProperty(ic->engine, QStringLiteral("stack"), ErrorObject::method_get_stack, 0);
+    defineAccessorProperty(QStringLiteral("stack"), ErrorObject::method_get_stack, 0);
 
-    defineDefaultProperty(ic->engine, QStringLiteral("name"), Value::fromString(ic->engine, className()));
+    defineDefaultProperty(QStringLiteral("name"), Value::fromString(ic->engine, className()));
 
     stackTrace = ic->engine->stackTrace();
     ExecutionEngine::StackFrame frame;
@@ -120,11 +120,11 @@ ErrorObject::ErrorObject(InternalClass *ic, const QString &message, const QStrin
     stackTrace.prepend(frame);
 
     if (!stackTrace.isEmpty()) {
-        defineDefaultProperty(ic->engine, QStringLiteral("fileName"), Value::fromString(ic->engine, stackTrace.at(0).source));
-        defineDefaultProperty(ic->engine, QStringLiteral("lineNumber"), Value::fromInt32(stackTrace.at(0).line));
+        defineDefaultProperty(QStringLiteral("fileName"), Value::fromString(ic->engine, stackTrace.at(0).source));
+        defineDefaultProperty(QStringLiteral("lineNumber"), Value::fromInt32(stackTrace.at(0).line));
     }
 
-    defineDefaultProperty(ic->engine, QStringLiteral("message"), Value::fromString(ic->engine->newString(message)));
+    defineDefaultProperty(QStringLiteral("message"), Value::fromString(ic->engine->newString(message)));
 }
 
 ReturnedValue ErrorObject::method_get_stack(SimpleCallContext *ctx)
@@ -321,9 +321,9 @@ void ErrorPrototype::init(ExecutionEngine *engine, const Value &ctor, Object *ob
 {
     ctor.objectValue()->defineReadonlyProperty(engine->id_prototype, Value::fromObject(obj));
     ctor.objectValue()->defineReadonlyProperty(engine->id_length, Value::fromInt32(1));
-    obj->defineDefaultProperty(engine, QStringLiteral("constructor"), ctor);
-    obj->defineDefaultProperty(engine, QStringLiteral("toString"), method_toString, 0);
-    obj->defineDefaultProperty(engine, QStringLiteral("message"), Value::fromString(engine, QString()));
+    obj->defineDefaultProperty(QStringLiteral("constructor"), ctor);
+    obj->defineDefaultProperty(QStringLiteral("toString"), method_toString, 0);
+    obj->defineDefaultProperty(QStringLiteral("message"), Value::fromString(engine, QString()));
 }
 
 ReturnedValue ErrorPrototype::method_toString(SimpleCallContext *ctx)
diff --git a/src/qml/jsruntime/qv4functionobject.cpp b/src/qml/jsruntime/qv4functionobject.cpp
index 18bf4ed6b5..851bc49c6b 100644
--- a/src/qml/jsruntime/qv4functionobject.cpp
+++ b/src/qml/jsruntime/qv4functionobject.cpp
@@ -267,17 +267,17 @@ FunctionPrototype::FunctionPrototype(InternalClass *ic)
 {
 }
 
-void FunctionPrototype::init(ExecutionContext *ctx, const Value &ctor)
+void FunctionPrototype::init(ExecutionEngine *engine, const Value &ctor)
 {
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_length, Value::fromInt32(1));
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_prototype, Value::fromObject(this));
+    ctor.objectValue()->defineReadonlyProperty(engine->id_length, Value::fromInt32(1));
+    ctor.objectValue()->defineReadonlyProperty(engine->id_prototype, Value::fromObject(this));
 
-    defineReadonlyProperty(ctx->engine->id_length, Value::fromInt32(0));
-    defineDefaultProperty(ctx, QStringLiteral("constructor"), ctor);
-    defineDefaultProperty(ctx, QStringLiteral("toString"), method_toString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("apply"), method_apply, 2);
-    defineDefaultProperty(ctx, QStringLiteral("call"), method_call, 1);
-    defineDefaultProperty(ctx, QStringLiteral("bind"), method_bind, 1);
+    defineReadonlyProperty(engine->id_length, Value::fromInt32(0));
+    defineDefaultProperty(QStringLiteral("constructor"), ctor);
+    defineDefaultProperty(QStringLiteral("toString"), method_toString, 0);
+    defineDefaultProperty(QStringLiteral("apply"), method_apply, 2);
+    defineDefaultProperty(QStringLiteral("call"), method_call, 1);
+    defineDefaultProperty(QStringLiteral("bind"), method_bind, 1);
 
 }
 
diff --git a/src/qml/jsruntime/qv4functionobject_p.h b/src/qml/jsruntime/qv4functionobject_p.h
index a0f4cf9463..141bf22a49 100644
--- a/src/qml/jsruntime/qv4functionobject_p.h
+++ b/src/qml/jsruntime/qv4functionobject_p.h
@@ -159,7 +159,7 @@ struct FunctionCtor: FunctionObject
 struct FunctionPrototype: FunctionObject
 {
     FunctionPrototype(InternalClass *ic);
-    void init(ExecutionContext *ctx, const Value &ctor);
+    void init(ExecutionEngine *engine, const Value &ctor);
 
     static ReturnedValue method_toString(SimpleCallContext *ctx);
     static ReturnedValue method_apply(SimpleCallContext *ctx);
diff --git a/src/qml/jsruntime/qv4jsonobject.cpp b/src/qml/jsruntime/qv4jsonobject.cpp
index df6de78710..d67daff07f 100644
--- a/src/qml/jsruntime/qv4jsonobject.cpp
+++ b/src/qml/jsruntime/qv4jsonobject.cpp
@@ -867,13 +867,13 @@ QString Stringify::JA(ArrayObject *a)
 }
 
 
-JsonObject::JsonObject(ExecutionContext *context)
-    : Object(context->engine)
+JsonObject::JsonObject(ExecutionEngine *engine)
+    : Object(engine)
 {
     type = Type_JSONObject;
 
-    defineDefaultProperty(context, QStringLiteral("parse"), method_parse, 2);
-    defineDefaultProperty(context, QStringLiteral("stringify"), method_stringify, 3);
+    defineDefaultProperty(QStringLiteral("parse"), method_parse, 2);
+    defineDefaultProperty(QStringLiteral("stringify"), method_stringify, 3);
 }
 
 
diff --git a/src/qml/jsruntime/qv4jsonobject_p.h b/src/qml/jsruntime/qv4jsonobject_p.h
index 821cffcc7c..1dae5bbb40 100644
--- a/src/qml/jsruntime/qv4jsonobject_p.h
+++ b/src/qml/jsruntime/qv4jsonobject_p.h
@@ -54,7 +54,7 @@ struct JsonObject : Object {
 private:
     typedef QSet<QV4::Object *> V4ObjectSet;
 public:
-    JsonObject(ExecutionContext *context);
+    JsonObject(ExecutionEngine *engine);
 
     static ReturnedValue method_parse(SimpleCallContext *ctx);
     static ReturnedValue method_stringify(SimpleCallContext *ctx);
diff --git a/src/qml/jsruntime/qv4mathobject.cpp b/src/qml/jsruntime/qv4mathobject.cpp
index cf2d5afd3f..3d57b5fb2f 100644
--- a/src/qml/jsruntime/qv4mathobject.cpp
+++ b/src/qml/jsruntime/qv4mathobject.cpp
@@ -50,38 +50,38 @@ using namespace QV4;
 
 static const double qt_PI = 2.0 * ::asin(1.0);
 
-MathObject::MathObject(ExecutionContext *ctx)
-    : Object(ctx->engine)
+MathObject::MathObject(ExecutionEngine *engine)
+    : Object(engine)
 {
     type = Type_MathObject;
 
-    defineReadonlyProperty(ctx->engine, QStringLiteral("E"), Value::fromDouble(::exp(1.0)));
-    defineReadonlyProperty(ctx->engine, QStringLiteral("LN2"), Value::fromDouble(::log(2.0)));
-    defineReadonlyProperty(ctx->engine, QStringLiteral("LN10"), Value::fromDouble(::log(10.0)));
-    defineReadonlyProperty(ctx->engine, QStringLiteral("LOG2E"), Value::fromDouble(1.0/::log(2.0)));
-    defineReadonlyProperty(ctx->engine, QStringLiteral("LOG10E"), Value::fromDouble(1.0/::log(10.0)));
-    defineReadonlyProperty(ctx->engine, QStringLiteral("PI"), Value::fromDouble(qt_PI));
-    defineReadonlyProperty(ctx->engine, QStringLiteral("SQRT1_2"), Value::fromDouble(::sqrt(0.5)));
-    defineReadonlyProperty(ctx->engine, QStringLiteral("SQRT2"), Value::fromDouble(::sqrt(2.0)));
-
-    defineDefaultProperty(ctx, QStringLiteral("abs"), method_abs, 1);
-    defineDefaultProperty(ctx, QStringLiteral("acos"), method_acos, 1);
-    defineDefaultProperty(ctx, QStringLiteral("asin"), method_asin, 0);
-    defineDefaultProperty(ctx, QStringLiteral("atan"), method_atan, 1);
-    defineDefaultProperty(ctx, QStringLiteral("atan2"), method_atan2, 2);
-    defineDefaultProperty(ctx, QStringLiteral("ceil"), method_ceil, 1);
-    defineDefaultProperty(ctx, QStringLiteral("cos"), method_cos, 1);
-    defineDefaultProperty(ctx, QStringLiteral("exp"), method_exp, 1);
-    defineDefaultProperty(ctx, QStringLiteral("floor"), method_floor, 1);
-    defineDefaultProperty(ctx, QStringLiteral("log"), method_log, 1);
-    defineDefaultProperty(ctx, QStringLiteral("max"), method_max, 2);
-    defineDefaultProperty(ctx, QStringLiteral("min"), method_min, 2);
-    defineDefaultProperty(ctx, QStringLiteral("pow"), method_pow, 2);
-    defineDefaultProperty(ctx, QStringLiteral("random"), method_random, 0);
-    defineDefaultProperty(ctx, QStringLiteral("round"), method_round, 1);
-    defineDefaultProperty(ctx, QStringLiteral("sin"), method_sin, 1);
-    defineDefaultProperty(ctx, QStringLiteral("sqrt"), method_sqrt, 1);
-    defineDefaultProperty(ctx, QStringLiteral("tan"), method_tan, 1);
+    defineReadonlyProperty(QStringLiteral("E"), Value::fromDouble(::exp(1.0)));
+    defineReadonlyProperty(QStringLiteral("LN2"), Value::fromDouble(::log(2.0)));
+    defineReadonlyProperty(QStringLiteral("LN10"), Value::fromDouble(::log(10.0)));
+    defineReadonlyProperty(QStringLiteral("LOG2E"), Value::fromDouble(1.0/::log(2.0)));
+    defineReadonlyProperty(QStringLiteral("LOG10E"), Value::fromDouble(1.0/::log(10.0)));
+    defineReadonlyProperty(QStringLiteral("PI"), Value::fromDouble(qt_PI));
+    defineReadonlyProperty(QStringLiteral("SQRT1_2"), Value::fromDouble(::sqrt(0.5)));
+    defineReadonlyProperty(QStringLiteral("SQRT2"), Value::fromDouble(::sqrt(2.0)));
+
+    defineDefaultProperty(QStringLiteral("abs"), method_abs, 1);
+    defineDefaultProperty(QStringLiteral("acos"), method_acos, 1);
+    defineDefaultProperty(QStringLiteral("asin"), method_asin, 0);
+    defineDefaultProperty(QStringLiteral("atan"), method_atan, 1);
+    defineDefaultProperty(QStringLiteral("atan2"), method_atan2, 2);
+    defineDefaultProperty(QStringLiteral("ceil"), method_ceil, 1);
+    defineDefaultProperty(QStringLiteral("cos"), method_cos, 1);
+    defineDefaultProperty(QStringLiteral("exp"), method_exp, 1);
+    defineDefaultProperty(QStringLiteral("floor"), method_floor, 1);
+    defineDefaultProperty(QStringLiteral("log"), method_log, 1);
+    defineDefaultProperty(QStringLiteral("max"), method_max, 2);
+    defineDefaultProperty(QStringLiteral("min"), method_min, 2);
+    defineDefaultProperty(QStringLiteral("pow"), method_pow, 2);
+    defineDefaultProperty(QStringLiteral("random"), method_random, 0);
+    defineDefaultProperty(QStringLiteral("round"), method_round, 1);
+    defineDefaultProperty(QStringLiteral("sin"), method_sin, 1);
+    defineDefaultProperty(QStringLiteral("sqrt"), method_sqrt, 1);
+    defineDefaultProperty(QStringLiteral("tan"), method_tan, 1);
 }
 
 /* copies the sign from y to x and returns the result */
diff --git a/src/qml/jsruntime/qv4mathobject_p.h b/src/qml/jsruntime/qv4mathobject_p.h
index cdadc875f9..b65264b5dd 100644
--- a/src/qml/jsruntime/qv4mathobject_p.h
+++ b/src/qml/jsruntime/qv4mathobject_p.h
@@ -49,7 +49,7 @@ namespace QV4 {
 
 struct MathObject: Object
 {
-    MathObject(ExecutionContext *ctx);
+    MathObject(ExecutionEngine *engine);
 
     static ReturnedValue method_abs(SimpleCallContext *context);
     static ReturnedValue method_acos(SimpleCallContext *context);
diff --git a/src/qml/jsruntime/qv4numberobject.cpp b/src/qml/jsruntime/qv4numberobject.cpp
index b9b64cf534..eb64b92aa2 100644
--- a/src/qml/jsruntime/qv4numberobject.cpp
+++ b/src/qml/jsruntime/qv4numberobject.cpp
@@ -68,32 +68,32 @@ ReturnedValue NumberCtor::call(Managed *, CallData *callData)
     return Value::fromDouble(dbl).asReturnedValue();
 }
 
-void NumberPrototype::init(ExecutionContext *ctx, const Value &ctor)
+void NumberPrototype::init(ExecutionEngine *engine, const Value &ctor)
 {
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_prototype, Value::fromObject(this));
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_length, Value::fromInt32(1));
+    ctor.objectValue()->defineReadonlyProperty(engine->id_prototype, Value::fromObject(this));
+    ctor.objectValue()->defineReadonlyProperty(engine->id_length, Value::fromInt32(1));
 
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine, QStringLiteral("NaN"), Value::fromDouble(qSNaN()));
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine, QStringLiteral("NEGATIVE_INFINITY"), Value::fromDouble(-qInf()));
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine, QStringLiteral("POSITIVE_INFINITY"), Value::fromDouble(qInf()));
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine, QStringLiteral("MAX_VALUE"), Value::fromDouble(1.7976931348623158e+308));
+    ctor.objectValue()->defineReadonlyProperty(QStringLiteral("NaN"), Value::fromDouble(qSNaN()));
+    ctor.objectValue()->defineReadonlyProperty(QStringLiteral("NEGATIVE_INFINITY"), Value::fromDouble(-qInf()));
+    ctor.objectValue()->defineReadonlyProperty(QStringLiteral("POSITIVE_INFINITY"), Value::fromDouble(qInf()));
+    ctor.objectValue()->defineReadonlyProperty(QStringLiteral("MAX_VALUE"), Value::fromDouble(1.7976931348623158e+308));
 
 #ifdef __INTEL_COMPILER
 # pragma warning( push )
 # pragma warning(disable: 239)
 #endif
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine, QStringLiteral("MIN_VALUE"), Value::fromDouble(5e-324));
+    ctor.objectValue()->defineReadonlyProperty(QStringLiteral("MIN_VALUE"), Value::fromDouble(5e-324));
 #ifdef __INTEL_COMPILER
 # pragma warning( pop )
 #endif
 
-    defineDefaultProperty(ctx, QStringLiteral("constructor"), ctor);
-    defineDefaultProperty(ctx, QStringLiteral("toString"), method_toString);
-    defineDefaultProperty(ctx, QStringLiteral("toLocaleString"), method_toLocaleString);
-    defineDefaultProperty(ctx, QStringLiteral("valueOf"), method_valueOf);
-    defineDefaultProperty(ctx, QStringLiteral("toFixed"), method_toFixed, 1);
-    defineDefaultProperty(ctx, QStringLiteral("toExponential"), method_toExponential);
-    defineDefaultProperty(ctx, QStringLiteral("toPrecision"), method_toPrecision);
+    defineDefaultProperty(QStringLiteral("constructor"), ctor);
+    defineDefaultProperty(QStringLiteral("toString"), method_toString);
+    defineDefaultProperty(QStringLiteral("toLocaleString"), method_toLocaleString);
+    defineDefaultProperty(QStringLiteral("valueOf"), method_valueOf);
+    defineDefaultProperty(QStringLiteral("toFixed"), method_toFixed, 1);
+    defineDefaultProperty(QStringLiteral("toExponential"), method_toExponential);
+    defineDefaultProperty(QStringLiteral("toPrecision"), method_toPrecision);
 }
 
 inline Value thisNumberValue(ExecutionContext *ctx)
diff --git a/src/qml/jsruntime/qv4numberobject_p.h b/src/qml/jsruntime/qv4numberobject_p.h
index d2c4ce6569..d5a0cda287 100644
--- a/src/qml/jsruntime/qv4numberobject_p.h
+++ b/src/qml/jsruntime/qv4numberobject_p.h
@@ -61,7 +61,7 @@ struct NumberCtor: FunctionObject
 struct NumberPrototype: NumberObject
 {
     NumberPrototype(InternalClass *ic): NumberObject(ic) {}
-    void init(ExecutionContext *ctx, const Value &ctor);
+    void init(ExecutionEngine *engine, const Value &ctor);
 
     static ReturnedValue method_toString(SimpleCallContext *ctx);
     static ReturnedValue method_toLocaleString(SimpleCallContext *ctx);
diff --git a/src/qml/jsruntime/qv4object.cpp b/src/qml/jsruntime/qv4object.cpp
index b232718125..3acf4bf9ab 100644
--- a/src/qml/jsruntime/qv4object.cpp
+++ b/src/qml/jsruntime/qv4object.cpp
@@ -221,45 +221,29 @@ void Object::defineDefaultProperty(const StringRef name, Value value)
     pd->value = value;
 }
 
-void Object::defineDefaultProperty(ExecutionContext *context, const QString &name, Value value)
+void Object::defineDefaultProperty(const QString &name, Value value)
 {
-    Scope scope(context);
-    ScopedString s(scope, context->engine->newIdentifier(name));
+    ExecutionEngine *e = engine();
+    Scope scope(e);
+    ScopedString s(scope, e->newIdentifier(name));
     defineDefaultProperty(s, value);
 }
 
-void Object::defineDefaultProperty(ExecutionEngine *engine, const QString &name, Value value)
+void Object::defineDefaultProperty(const QString &name, ReturnedValue (*code)(SimpleCallContext *), int argumentCount)
 {
-    Scope scope(engine);
-    ScopedString s(scope, engine->newIdentifier(name));
-    defineDefaultProperty(s, value);
-}
-
-void Object::defineDefaultProperty(ExecutionContext *context, const QString &name, ReturnedValue (*code)(SimpleCallContext *), int argumentCount)
-{
-    Q_UNUSED(argumentCount);
-    Scope scope(context);
-    Scoped<String> s(scope, context->engine->newIdentifier(name));
-    Scoped<FunctionObject> function(scope, context->engine->newBuiltinFunction(context, s, code));
-    function->defineReadonlyProperty(context->engine->id_length, Value::fromInt32(argumentCount));
-    defineDefaultProperty(s, function.asValue());
-}
-
-void Object::defineDefaultProperty(ExecutionEngine *engine, const QString &name, ReturnedValue (*code)(SimpleCallContext *), int argumentCount)
-{
-    Q_UNUSED(argumentCount);
-    Scope scope(engine);
-    Scoped<String> s(scope, engine->newIdentifier(name));
-    Scoped<FunctionObject> function(scope, engine->newBuiltinFunction(engine->rootContext, s, code));
-    function->defineReadonlyProperty(engine->id_length, Value::fromInt32(argumentCount));
+    ExecutionEngine *e = engine();
+    Scope scope(e);
+    ScopedString s(scope, e->newIdentifier(name));
+    Scoped<FunctionObject> function(scope, e->newBuiltinFunction(e->rootContext, s, code));
+    function->defineReadonlyProperty(e->id_length, Value::fromInt32(argumentCount));
     defineDefaultProperty(s, function.asValue());
 }
 
-void Object::defineAccessorProperty(ExecutionEngine *engine, const QString &name,
-                                    ReturnedValue (*getter)(SimpleCallContext *), ReturnedValue (*setter)(SimpleCallContext *))
+void Object::defineAccessorProperty(const QString &name, ReturnedValue (*getter)(SimpleCallContext *), ReturnedValue (*setter)(SimpleCallContext *))
 {
-    Scope scope(engine);
-    Scoped<String> s(scope, engine->newIdentifier(name));
+    ExecutionEngine *e = engine();
+    Scope scope(e);
+    Scoped<String> s(scope, e->newIdentifier(name));
     defineAccessorProperty(s, getter, setter);
 }
 
@@ -274,16 +258,17 @@ void Object::defineAccessorProperty(const StringRef name, ReturnedValue (*getter
         p->setSetter(v4->newBuiltinFunction(v4->rootContext, name, setter)->getPointer());
 }
 
-void Object::defineReadonlyProperty(ExecutionEngine *engine, const QString &name, Value value)
+void Object::defineReadonlyProperty(const QString &name, Value value)
 {
-    defineReadonlyProperty(engine->newIdentifier(name), value);
+    QV4::ExecutionEngine *e = engine();
+    Scope scope(e);
+    ScopedString s(scope, e->newIdentifier(name));
+    defineReadonlyProperty(s, value);
 }
 
-void Object::defineReadonlyProperty(String *name, Value value)
+void Object::defineReadonlyProperty(const StringRef name, Value value)
 {
-    Scope scope(engine());
-    ScopedString s(scope, name);
-    Property *pd = insertMember(s, Attr_ReadOnly);
+    Property *pd = insertMember(name, Attr_ReadOnly);
     pd->value = value;
 }
 
diff --git a/src/qml/jsruntime/qv4object_p.h b/src/qml/jsruntime/qv4object_p.h
index b21bd7bec6..0ca64f71fe 100644
--- a/src/qml/jsruntime/qv4object_p.h
+++ b/src/qml/jsruntime/qv4object_p.h
@@ -164,15 +164,13 @@ struct Q_QML_EXPORT Object: Managed {
 
     /* The spec default: Writable: true, Enumerable: false, Configurable: true */
     void defineDefaultProperty(const StringRef name, Value value);
-    void defineDefaultProperty(ExecutionContext *context, const QString &name, Value value);
-    void defineDefaultProperty(ExecutionEngine *engine, const QString &name, Value value);
-    void defineDefaultProperty(ExecutionContext *context, const QString &name, ReturnedValue (*code)(SimpleCallContext *), int count = 0);
-    void defineDefaultProperty(ExecutionEngine *engine, const QString &name, ReturnedValue (*code)(SimpleCallContext *), int count = 0);
-    void defineAccessorProperty(ExecutionEngine *engine, const QString &name, ReturnedValue (*getter)(SimpleCallContext *), ReturnedValue (*setter)(SimpleCallContext *));
+    void defineDefaultProperty(const QString &name, Value value);
+    void defineDefaultProperty(const QString &name, ReturnedValue (*code)(SimpleCallContext *), int argumentCount = 0);
+    void defineAccessorProperty(const QString &name, ReturnedValue (*getter)(SimpleCallContext *), ReturnedValue (*setter)(SimpleCallContext *));
     void defineAccessorProperty(const StringRef name, ReturnedValue (*getter)(SimpleCallContext *), ReturnedValue (*setter)(SimpleCallContext *));
     /* Fixed: Writable: false, Enumerable: false, Configurable: false */
-    void defineReadonlyProperty(ExecutionEngine *engine, const QString &name, Value value);
-    void defineReadonlyProperty(String *name, Value value);
+    void defineReadonlyProperty(const QString &name, Value value);
+    void defineReadonlyProperty(const StringRef name, Value value);
 
     Property *insertMember(const StringRef s, PropertyAttributes attributes);
 
diff --git a/src/qml/jsruntime/qv4objectproto.cpp b/src/qml/jsruntime/qv4objectproto.cpp
index d0a94e8de7..67aeebf0a8 100644
--- a/src/qml/jsruntime/qv4objectproto.cpp
+++ b/src/qml/jsruntime/qv4objectproto.cpp
@@ -101,36 +101,35 @@ ReturnedValue ObjectCtor::call(Managed *m, CallData *callData)
     return __qmljs_to_object(m->engine()->current, ValueRef(&callData->args[0]));
 }
 
-void ObjectPrototype::init(ExecutionContext *ctx, const Value &ctor)
+void ObjectPrototype::init(ExecutionEngine *v4, const Value &ctor)
 {
-    ExecutionEngine *v4 = ctx->engine;
     Scope scope(v4);
 
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_prototype, Value::fromObject(this));
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_length, Value::fromInt32(1));
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("getPrototypeOf"), method_getPrototypeOf, 1);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("getOwnPropertyDescriptor"), method_getOwnPropertyDescriptor, 2);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("getOwnPropertyNames"), method_getOwnPropertyNames, 1);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("create"), method_create, 2);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("defineProperty"), method_defineProperty, 3);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("defineProperties"), method_defineProperties, 2);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("seal"), method_seal, 1);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("freeze"), method_freeze, 1);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("preventExtensions"), method_preventExtensions, 1);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("isSealed"), method_isSealed, 1);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("isFrozen"), method_isFrozen, 1);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("isExtensible"), method_isExtensible, 1);
-    ctor.objectValue()->defineDefaultProperty(ctx, QStringLiteral("keys"), method_keys, 1);
-
-    defineDefaultProperty(ctx, QStringLiteral("constructor"), ctor);
-    defineDefaultProperty(ctx, QStringLiteral("toString"), method_toString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("toLocaleString"), method_toLocaleString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("valueOf"), method_valueOf, 0);
-    defineDefaultProperty(ctx, QStringLiteral("hasOwnProperty"), method_hasOwnProperty, 1);
-    defineDefaultProperty(ctx, QStringLiteral("isPrototypeOf"), method_isPrototypeOf, 1);
-    defineDefaultProperty(ctx, QStringLiteral("propertyIsEnumerable"), method_propertyIsEnumerable, 1);
-    defineDefaultProperty(ctx, QStringLiteral("__defineGetter__"), method_defineGetter, 2);
-    defineDefaultProperty(ctx, QStringLiteral("__defineSetter__"), method_defineSetter, 2);
+    ctor.objectValue()->defineReadonlyProperty(v4->id_prototype, Value::fromObject(this));
+    ctor.objectValue()->defineReadonlyProperty(v4->id_length, Value::fromInt32(1));
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("getPrototypeOf"), method_getPrototypeOf, 1);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("getOwnPropertyDescriptor"), method_getOwnPropertyDescriptor, 2);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("getOwnPropertyNames"), method_getOwnPropertyNames, 1);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("create"), method_create, 2);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("defineProperty"), method_defineProperty, 3);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("defineProperties"), method_defineProperties, 2);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("seal"), method_seal, 1);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("freeze"), method_freeze, 1);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("preventExtensions"), method_preventExtensions, 1);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("isSealed"), method_isSealed, 1);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("isFrozen"), method_isFrozen, 1);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("isExtensible"), method_isExtensible, 1);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("keys"), method_keys, 1);
+
+    defineDefaultProperty(QStringLiteral("constructor"), ctor);
+    defineDefaultProperty(QStringLiteral("toString"), method_toString, 0);
+    defineDefaultProperty(QStringLiteral("toLocaleString"), method_toLocaleString, 0);
+    defineDefaultProperty(QStringLiteral("valueOf"), method_valueOf, 0);
+    defineDefaultProperty(QStringLiteral("hasOwnProperty"), method_hasOwnProperty, 1);
+    defineDefaultProperty(QStringLiteral("isPrototypeOf"), method_isPrototypeOf, 1);
+    defineDefaultProperty(QStringLiteral("propertyIsEnumerable"), method_propertyIsEnumerable, 1);
+    defineDefaultProperty(QStringLiteral("__defineGetter__"), method_defineGetter, 2);
+    defineDefaultProperty(QStringLiteral("__defineSetter__"), method_defineSetter, 2);
 
     Scoped<String> id_proto(scope, v4->id___proto__);
     Property *p = insertMember(StringRef(v4->id___proto__), Attr_Accessor|Attr_NotEnumerable);
diff --git a/src/qml/jsruntime/qv4objectproto_p.h b/src/qml/jsruntime/qv4objectproto_p.h
index 311d53864f..3930b39569 100644
--- a/src/qml/jsruntime/qv4objectproto_p.h
+++ b/src/qml/jsruntime/qv4objectproto_p.h
@@ -62,7 +62,7 @@ struct ObjectPrototype: Object
 {
     ObjectPrototype(InternalClass *ic) : Object(ic) {}
 
-    void init(ExecutionContext *ctx, const Value &ctor);
+    void init(ExecutionEngine *engine, const Value &ctor);
 
     static ReturnedValue method_getPrototypeOf(SimpleCallContext *ctx);
     static ReturnedValue method_getOwnPropertyDescriptor(SimpleCallContext *ctx);
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index a779a41293..9eb20f4bcb 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -240,8 +240,8 @@ QObjectWrapper::QObjectWrapper(ExecutionEngine *engine, QObject *object)
 
 void QObjectWrapper::initializeBindings(ExecutionEngine *engine)
 {
-    engine->functionClass->prototype->defineDefaultProperty(engine, QStringLiteral("connect"), method_connect);
-    engine->functionClass->prototype->defineDefaultProperty(engine, QStringLiteral("disconnect"), method_disconnect);
+    engine->functionClass->prototype->defineDefaultProperty(QStringLiteral("connect"), method_connect);
+    engine->functionClass->prototype->defineDefaultProperty(QStringLiteral("disconnect"), method_disconnect);
 }
 
 QQmlPropertyData *QObjectWrapper::findProperty(ExecutionEngine *engine, QQmlContextData *qmlContext, String *name, RevisionMode revisionMode, QQmlPropertyData *local) const
diff --git a/src/qml/jsruntime/qv4regexpobject.cpp b/src/qml/jsruntime/qv4regexpobject.cpp
index aa3f1c3fb5..76d3216fde 100644
--- a/src/qml/jsruntime/qv4regexpobject.cpp
+++ b/src/qml/jsruntime/qv4regexpobject.cpp
@@ -157,10 +157,10 @@ void RegExpObject::init(ExecutionEngine *engine)
         p.replace('/', QLatin1String("\\/"));
     }
 
-    defineReadonlyProperty(engine->newIdentifier(QStringLiteral("source")), Value::fromString(engine->newString(p)));
-    defineReadonlyProperty(engine->newIdentifier(QStringLiteral("global")), Value::fromBoolean(global));
-    defineReadonlyProperty(engine->newIdentifier(QStringLiteral("ignoreCase")), Value::fromBoolean(this->value->ignoreCase()));
-    defineReadonlyProperty(engine->newIdentifier(QStringLiteral("multiline")), Value::fromBoolean(this->value->multiLine()));
+    defineReadonlyProperty(QStringLiteral("source"), Value::fromString(engine->newString(p)));
+    defineReadonlyProperty(QStringLiteral("global"), Value::fromBoolean(global));
+    defineReadonlyProperty(QStringLiteral("ignoreCase"), Value::fromBoolean(this->value->ignoreCase()));
+    defineReadonlyProperty(QStringLiteral("multiline"), Value::fromBoolean(this->value->multiLine()));
 }
 
 
@@ -285,15 +285,15 @@ ReturnedValue RegExpCtor::call(Managed *that, CallData *callData)
     return construct(that, callData);
 }
 
-void RegExpPrototype::init(ExecutionContext *ctx, const Value &ctor)
+void RegExpPrototype::init(ExecutionEngine *engine, const Value &ctor)
 {
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_prototype, Value::fromObject(this));
-    ctor.objectValue()->defineReadonlyProperty(ctx->engine->id_length, Value::fromInt32(2));
-    defineDefaultProperty(ctx, QStringLiteral("constructor"), ctor);
-    defineDefaultProperty(ctx, QStringLiteral("exec"), method_exec, 1);
-    defineDefaultProperty(ctx, QStringLiteral("test"), method_test, 1);
-    defineDefaultProperty(ctx, QStringLiteral("toString"), method_toString, 0);
-    defineDefaultProperty(ctx, QStringLiteral("compile"), method_compile, 2);
+    ctor.objectValue()->defineReadonlyProperty(engine->id_prototype, Value::fromObject(this));
+    ctor.objectValue()->defineReadonlyProperty(engine->id_length, Value::fromInt32(2));
+    defineDefaultProperty(QStringLiteral("constructor"), ctor);
+    defineDefaultProperty(QStringLiteral("exec"), method_exec, 1);
+    defineDefaultProperty(QStringLiteral("test"), method_test, 1);
+    defineDefaultProperty(QStringLiteral("toString"), method_toString, 0);
+    defineDefaultProperty(QStringLiteral("compile"), method_compile, 2);
 }
 
 ReturnedValue RegExpPrototype::method_exec(SimpleCallContext *ctx)
diff --git a/src/qml/jsruntime/qv4regexpobject_p.h b/src/qml/jsruntime/qv4regexpobject_p.h
index 765e98176c..299be31f52 100644
--- a/src/qml/jsruntime/qv4regexpobject_p.h
+++ b/src/qml/jsruntime/qv4regexpobject_p.h
@@ -113,7 +113,7 @@ struct RegExpCtor: FunctionObject
 struct RegExpPrototype: RegExpObject
 {
     RegExpPrototype(InternalClass *ic): RegExpObject(ic) {}
-    void init(ExecutionContext *ctx, const Value &ctor);
+    void init(ExecutionEngine *engine, const Value &ctor);
 
     static ReturnedValue method_exec(SimpleCallContext *ctx);
     static ReturnedValue method_test(SimpleCallContext *ctx);
diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp
index 72356204b5..d1f9363a7b 100644
--- a/src/qml/jsruntime/qv4sequenceobject.cpp
+++ b/src/qml/jsruntime/qv4sequenceobject.cpp
@@ -175,7 +175,7 @@ public:
     {
         type = Type_QmlSequence;
         vtbl = &static_vtbl;
-        init(engine);
+        init();
     }
 
     QQmlSequence(QV4::ExecutionEngine *engine, QObject *object, int propertyIndex)
@@ -187,12 +187,12 @@ public:
         type = Type_QmlSequence;
         vtbl = &static_vtbl;
         loadReference();
-        init(engine);
+        init();
     }
 
-    void init(ExecutionEngine *engine)
+    void init()
     {
-        defineAccessorProperty(engine, QStringLiteral("length"), method_get_length, method_set_length);
+        defineAccessorProperty(QStringLiteral("length"), method_get_length, method_set_length);
     }
 
     QV4::Value containerGetIndexed(uint index, bool *hasProperty)
@@ -532,10 +532,10 @@ SequencePrototype::SequencePrototype(InternalClass *ic)
 }
 #undef REGISTER_QML_SEQUENCE_METATYPE
 
-void SequencePrototype::init(QV4::ExecutionEngine *engine)
+void SequencePrototype::init()
 {
-    defineDefaultProperty(engine, QStringLiteral("sort"), method_sort, 1);
-    defineDefaultProperty(engine, QStringLiteral("valueOf"), method_valueOf, 0);
+    defineDefaultProperty(QStringLiteral("sort"), method_sort, 1);
+    defineDefaultProperty(QStringLiteral("valueOf"), method_valueOf, 0);
 }
 
 QV4::ReturnedValue SequencePrototype::method_sort(QV4::SimpleCallContext *ctx)
diff --git a/src/qml/jsruntime/qv4sequenceobject_p.h b/src/qml/jsruntime/qv4sequenceobject_p.h
index f2d06d8918..260fea9897 100644
--- a/src/qml/jsruntime/qv4sequenceobject_p.h
+++ b/src/qml/jsruntime/qv4sequenceobject_p.h
@@ -67,7 +67,7 @@ struct SequencePrototype : public QV4::Object
 {
     SequencePrototype(QV4::InternalClass *ic);
 
-    void init(QV4::ExecutionEngine *engine);
+    void init();
 
     static ReturnedValue method_valueOf(QV4::SimpleCallContext *ctx)
     {
diff --git a/src/qml/jsruntime/qv4serialize.cpp b/src/qml/jsruntime/qv4serialize.cpp
index 390c3382f2..f74e8d2451 100644
--- a/src/qml/jsruntime/qv4serialize.cpp
+++ b/src/qml/jsruntime/qv4serialize.cpp
@@ -364,7 +364,8 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
         QQmlListModelWorkerAgent::VariantRef ref(agent);
         QVariant var = qVariantFromValue(ref);
         QV4::ScopedValue v(scope, engine->fromVariant((var)));
-        rv->asObject()->defineReadonlyProperty(v4->newString("__qml:hidden:ref"), v);
+        QV4::ScopedString s(scope, v4->newString("__qml:hidden:ref"));
+        rv->asObject()->defineReadonlyProperty(s, v);
 
         agent->release();
         agent->setV8Engine(engine);
diff --git a/src/qml/jsruntime/qv4stringobject.cpp b/src/qml/jsruntime/qv4stringobject.cpp
index afd6e440dc..274e5b4bce 100644
--- a/src/qml/jsruntime/qv4stringobject.cpp
+++ b/src/qml/jsruntime/qv4stringobject.cpp
@@ -184,29 +184,29 @@ void StringPrototype::init(ExecutionEngine *engine, const Value &ctor)
 {
     ctor.objectValue()->defineReadonlyProperty(engine->id_prototype, Value::fromObject(this));
     ctor.objectValue()->defineReadonlyProperty(engine->id_length, Value::fromInt32(1));
-    ctor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromCharCode"), method_fromCharCode, 1);
-
-    defineDefaultProperty(engine, QStringLiteral("constructor"), ctor);
-    defineDefaultProperty(engine, QStringLiteral("toString"), method_toString);
-    defineDefaultProperty(engine, QStringLiteral("valueOf"), method_toString); // valueOf and toString are identical
-    defineDefaultProperty(engine, QStringLiteral("charAt"), method_charAt, 1);
-    defineDefaultProperty(engine, QStringLiteral("charCodeAt"), method_charCodeAt, 1);
-    defineDefaultProperty(engine, QStringLiteral("concat"), method_concat, 1);
-    defineDefaultProperty(engine, QStringLiteral("indexOf"), method_indexOf, 1);
-    defineDefaultProperty(engine, QStringLiteral("lastIndexOf"), method_lastIndexOf, 1);
-    defineDefaultProperty(engine, QStringLiteral("localeCompare"), method_localeCompare, 1);
-    defineDefaultProperty(engine, QStringLiteral("match"), method_match, 1);
-    defineDefaultProperty(engine, QStringLiteral("replace"), method_replace, 2);
-    defineDefaultProperty(engine, QStringLiteral("search"), method_search, 1);
-    defineDefaultProperty(engine, QStringLiteral("slice"), method_slice, 2);
-    defineDefaultProperty(engine, QStringLiteral("split"), method_split, 2);
-    defineDefaultProperty(engine, QStringLiteral("substr"), method_substr, 2);
-    defineDefaultProperty(engine, QStringLiteral("substring"), method_substring, 2);
-    defineDefaultProperty(engine, QStringLiteral("toLowerCase"), method_toLowerCase);
-    defineDefaultProperty(engine, QStringLiteral("toLocaleLowerCase"), method_toLocaleLowerCase);
-    defineDefaultProperty(engine, QStringLiteral("toUpperCase"), method_toUpperCase);
-    defineDefaultProperty(engine, QStringLiteral("toLocaleUpperCase"), method_toLocaleUpperCase);
-    defineDefaultProperty(engine, QStringLiteral("trim"), method_trim);
+    ctor.objectValue()->defineDefaultProperty(QStringLiteral("fromCharCode"), method_fromCharCode, 1);
+
+    defineDefaultProperty(QStringLiteral("constructor"), ctor);
+    defineDefaultProperty(QStringLiteral("toString"), method_toString);
+    defineDefaultProperty(QStringLiteral("valueOf"), method_toString); // valueOf and toString are identical
+    defineDefaultProperty(QStringLiteral("charAt"), method_charAt, 1);
+    defineDefaultProperty(QStringLiteral("charCodeAt"), method_charCodeAt, 1);
+    defineDefaultProperty(QStringLiteral("concat"), method_concat, 1);
+    defineDefaultProperty(QStringLiteral("indexOf"), method_indexOf, 1);
+    defineDefaultProperty(QStringLiteral("lastIndexOf"), method_lastIndexOf, 1);
+    defineDefaultProperty(QStringLiteral("localeCompare"), method_localeCompare, 1);
+    defineDefaultProperty(QStringLiteral("match"), method_match, 1);
+    defineDefaultProperty(QStringLiteral("replace"), method_replace, 2);
+    defineDefaultProperty(QStringLiteral("search"), method_search, 1);
+    defineDefaultProperty(QStringLiteral("slice"), method_slice, 2);
+    defineDefaultProperty(QStringLiteral("split"), method_split, 2);
+    defineDefaultProperty(QStringLiteral("substr"), method_substr, 2);
+    defineDefaultProperty(QStringLiteral("substring"), method_substring, 2);
+    defineDefaultProperty(QStringLiteral("toLowerCase"), method_toLowerCase);
+    defineDefaultProperty(QStringLiteral("toLocaleLowerCase"), method_toLocaleLowerCase);
+    defineDefaultProperty(QStringLiteral("toUpperCase"), method_toUpperCase);
+    defineDefaultProperty(QStringLiteral("toLocaleUpperCase"), method_toLocaleUpperCase);
+    defineDefaultProperty(QStringLiteral("trim"), method_trim);
 }
 
 static QString getThisString(ExecutionContext *ctx)
diff --git a/src/qml/jsruntime/qv4variantobject.cpp b/src/qml/jsruntime/qv4variantobject.cpp
index cea946b66b..19a08a9ce7 100644
--- a/src/qml/jsruntime/qv4variantobject.cpp
+++ b/src/qml/jsruntime/qv4variantobject.cpp
@@ -144,12 +144,12 @@ VariantPrototype::VariantPrototype(InternalClass *ic)
 {
 }
 
-void VariantPrototype::init(ExecutionEngine *engine)
+void VariantPrototype::init()
 {
-    defineDefaultProperty(engine, QStringLiteral("preserve"), method_preserve, 0);
-    defineDefaultProperty(engine, QStringLiteral("destroy"), method_destroy, 0);
-    defineDefaultProperty(engine, QStringLiteral("valueOf"), method_valueOf, 0);
-    defineDefaultProperty(engine, QStringLiteral("toString"), method_toString, 0);
+    defineDefaultProperty(QStringLiteral("preserve"), method_preserve, 0);
+    defineDefaultProperty(QStringLiteral("destroy"), method_destroy, 0);
+    defineDefaultProperty(QStringLiteral("valueOf"), method_valueOf, 0);
+    defineDefaultProperty(QStringLiteral("toString"), method_toString, 0);
 }
 
 QV4::ReturnedValue VariantPrototype::method_preserve(SimpleCallContext *ctx)
diff --git a/src/qml/jsruntime/qv4variantobject_p.h b/src/qml/jsruntime/qv4variantobject_p.h
index 60a48374b0..65c1db0d88 100644
--- a/src/qml/jsruntime/qv4variantobject_p.h
+++ b/src/qml/jsruntime/qv4variantobject_p.h
@@ -87,7 +87,7 @@ struct VariantPrototype : VariantObject
 public:
     VariantPrototype(InternalClass *ic);
 
-    void init(ExecutionEngine *engine);
+    void init();
 
     static ReturnedValue method_preserve(SimpleCallContext *ctx);
     static ReturnedValue method_destroy(SimpleCallContext *ctx);
diff --git a/src/qml/qml/qqmlcomponent.cpp b/src/qml/qml/qqmlcomponent.cpp
index d3c30fc40d..483ae908b4 100644
--- a/src/qml/qml/qqmlcomponent.cpp
+++ b/src/qml/qml/qqmlcomponent.cpp
@@ -1407,11 +1407,11 @@ QQmlComponentExtension::QQmlComponentExtension(QV8Engine *engine)
     QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
     QV4::Scope scope(v4);
     QV4::Scoped<QV4::Object> proto(scope, v4->newObject());
-    proto->defineAccessorProperty(v4, QStringLiteral("onStatusChanged"),
+    proto->defineAccessorProperty(QStringLiteral("onStatusChanged"),
                                   QmlIncubatorObject::method_get_statusChanged, QmlIncubatorObject::method_set_statusChanged);
-    proto->defineAccessorProperty(v4, QStringLiteral("status"), QmlIncubatorObject::method_get_status, 0);
-    proto->defineAccessorProperty(v4, QStringLiteral("object"), QmlIncubatorObject::method_get_object, 0);
-    proto->defineDefaultProperty(v4, QStringLiteral("forceCompletion"), QmlIncubatorObject::method_forceCompletion);
+    proto->defineAccessorProperty(QStringLiteral("status"), QmlIncubatorObject::method_get_status, 0);
+    proto->defineAccessorProperty(QStringLiteral("object"), QmlIncubatorObject::method_get_object, 0);
+    proto->defineDefaultProperty(QStringLiteral("forceCompletion"), QmlIncubatorObject::method_forceCompletion);
 
     incubationProto = proto;
 }
diff --git a/src/qml/qml/qqmllocale.cpp b/src/qml/qml/qqmllocale.cpp
index d4998ec5ba..85d200e8e6 100644
--- a/src/qml/qml/qqmllocale.cpp
+++ b/src/qml/qml/qqmllocale.cpp
@@ -126,13 +126,13 @@ static bool isLocaleObject(const QV4::Value &val)
 
 void QQmlDateExtension::registerExtension(QV4::ExecutionEngine *engine)
 {
-    engine->dateClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleString"), method_toLocaleString);
-    engine->dateClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleTimeString"), method_toLocaleTimeString);
-    engine->dateClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleDateString"), method_toLocaleDateString);
-    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleString"), method_fromLocaleString);
-    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleTimeString"), method_fromLocaleTimeString);
-    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleDateString"), method_fromLocaleDateString);
-    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("timeZoneUpdated"), method_timeZoneUpdated);
+    engine->dateClass->prototype->defineDefaultProperty(QStringLiteral("toLocaleString"), method_toLocaleString);
+    engine->dateClass->prototype->defineDefaultProperty(QStringLiteral("toLocaleTimeString"), method_toLocaleTimeString);
+    engine->dateClass->prototype->defineDefaultProperty(QStringLiteral("toLocaleDateString"), method_toLocaleDateString);
+    engine->dateCtor.objectValue()->defineDefaultProperty(QStringLiteral("fromLocaleString"), method_fromLocaleString);
+    engine->dateCtor.objectValue()->defineDefaultProperty(QStringLiteral("fromLocaleTimeString"), method_fromLocaleTimeString);
+    engine->dateCtor.objectValue()->defineDefaultProperty(QStringLiteral("fromLocaleDateString"), method_fromLocaleDateString);
+    engine->dateCtor.objectValue()->defineDefaultProperty(QStringLiteral("timeZoneUpdated"), method_timeZoneUpdated);
 }
 
 QV4::ReturnedValue QQmlDateExtension::method_toLocaleString(QV4::SimpleCallContext *ctx)
@@ -405,9 +405,9 @@ QV4::ReturnedValue QQmlDateExtension::method_timeZoneUpdated(QV4::SimpleCallCont
 
 void QQmlNumberExtension::registerExtension(QV4::ExecutionEngine *engine)
 {
-    engine->numberClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleString"), method_toLocaleString);
-    engine->numberClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleCurrencyString"), method_toLocaleCurrencyString);
-    engine->numberCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleString"), method_fromLocaleString);
+    engine->numberClass->prototype->defineDefaultProperty(QStringLiteral("toLocaleString"), method_toLocaleString);
+    engine->numberClass->prototype->defineDefaultProperty(QStringLiteral("toLocaleCurrencyString"), method_toLocaleCurrencyString);
+    engine->numberCtor.objectValue()->defineDefaultProperty(QStringLiteral("fromLocaleString"), method_fromLocaleString);
 }
 
 QV4::ReturnedValue QQmlNumberExtension::method_toLocaleString(QV4::SimpleCallContext *ctx)
@@ -692,31 +692,31 @@ QV8LocaleDataDeletable::QV8LocaleDataDeletable(QV8Engine *engine)
     QV4::Scope scope(eng);
     QV4::Scoped<QV4::Object> o(scope, eng->newObject());
 
-    o->defineDefaultProperty(eng, QStringLiteral("dateFormat"), QQmlLocaleData::method_dateFormat, 0);
-    o->defineDefaultProperty(eng, QStringLiteral("standaloneDayName"), QQmlLocaleData::method_standaloneDayName, 0);
-    o->defineDefaultProperty(eng, QStringLiteral("standaloneMonthName"), QQmlLocaleData::method_standaloneMonthName, 0);
-    o->defineDefaultProperty(eng, QStringLiteral("dayName"), QQmlLocaleData::method_dayName, 0);
-    o->defineDefaultProperty(eng, QStringLiteral("timeFormat"), QQmlLocaleData::method_timeFormat, 0);
-    o->defineDefaultProperty(eng, QStringLiteral("monthName"), QQmlLocaleData::method_monthName, 0);
-    o->defineDefaultProperty(eng, QStringLiteral("currencySymbol"), QQmlLocaleData::method_currencySymbol, 0);
-    o->defineDefaultProperty(eng, QStringLiteral("dateTimeFormat"), QQmlLocaleData::method_dateTimeFormat, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("name"), QQmlLocaleData::method_get_name, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("positiveSign"), QQmlLocaleData::method_get_positiveSign, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("uiLanguages"), QQmlLocaleData::method_get_uiLanguages, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("firstDayOfWeek"), QQmlLocaleData::method_get_firstDayOfWeek, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("pmText"), QQmlLocaleData::method_get_pmText, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("percent"), QQmlLocaleData::method_get_percent, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("textDirection"), QQmlLocaleData::method_get_textDirection, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("weekDays"), QQmlLocaleData::method_get_weekDays, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("negativeSign"), QQmlLocaleData::method_get_negativeSign, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("groupSeparator"), QQmlLocaleData::method_get_groupSeparator, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("decimalPoint"), QQmlLocaleData::method_get_decimalPoint, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("nativeLanguageName"), QQmlLocaleData::method_get_nativeLanguageName, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("nativeCountryName"), QQmlLocaleData::method_get_nativeCountryName, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("zeroDigit"), QQmlLocaleData::method_get_zeroDigit, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("amText"), QQmlLocaleData::method_get_amText, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("measurementSystem"), QQmlLocaleData::method_get_measurementSystem, 0);
-    o->defineAccessorProperty(eng, QStringLiteral("exponential"), QQmlLocaleData::method_get_exponential, 0);
+    o->defineDefaultProperty(QStringLiteral("dateFormat"), QQmlLocaleData::method_dateFormat, 0);
+    o->defineDefaultProperty(QStringLiteral("standaloneDayName"), QQmlLocaleData::method_standaloneDayName, 0);
+    o->defineDefaultProperty(QStringLiteral("standaloneMonthName"), QQmlLocaleData::method_standaloneMonthName, 0);
+    o->defineDefaultProperty(QStringLiteral("dayName"), QQmlLocaleData::method_dayName, 0);
+    o->defineDefaultProperty(QStringLiteral("timeFormat"), QQmlLocaleData::method_timeFormat, 0);
+    o->defineDefaultProperty(QStringLiteral("monthName"), QQmlLocaleData::method_monthName, 0);
+    o->defineDefaultProperty(QStringLiteral("currencySymbol"), QQmlLocaleData::method_currencySymbol, 0);
+    o->defineDefaultProperty(QStringLiteral("dateTimeFormat"), QQmlLocaleData::method_dateTimeFormat, 0);
+    o->defineAccessorProperty(QStringLiteral("name"), QQmlLocaleData::method_get_name, 0);
+    o->defineAccessorProperty(QStringLiteral("positiveSign"), QQmlLocaleData::method_get_positiveSign, 0);
+    o->defineAccessorProperty(QStringLiteral("uiLanguages"), QQmlLocaleData::method_get_uiLanguages, 0);
+    o->defineAccessorProperty(QStringLiteral("firstDayOfWeek"), QQmlLocaleData::method_get_firstDayOfWeek, 0);
+    o->defineAccessorProperty(QStringLiteral("pmText"), QQmlLocaleData::method_get_pmText, 0);
+    o->defineAccessorProperty(QStringLiteral("percent"), QQmlLocaleData::method_get_percent, 0);
+    o->defineAccessorProperty(QStringLiteral("textDirection"), QQmlLocaleData::method_get_textDirection, 0);
+    o->defineAccessorProperty(QStringLiteral("weekDays"), QQmlLocaleData::method_get_weekDays, 0);
+    o->defineAccessorProperty(QStringLiteral("negativeSign"), QQmlLocaleData::method_get_negativeSign, 0);
+    o->defineAccessorProperty(QStringLiteral("groupSeparator"), QQmlLocaleData::method_get_groupSeparator, 0);
+    o->defineAccessorProperty(QStringLiteral("decimalPoint"), QQmlLocaleData::method_get_decimalPoint, 0);
+    o->defineAccessorProperty(QStringLiteral("nativeLanguageName"), QQmlLocaleData::method_get_nativeLanguageName, 0);
+    o->defineAccessorProperty(QStringLiteral("nativeCountryName"), QQmlLocaleData::method_get_nativeCountryName, 0);
+    o->defineAccessorProperty(QStringLiteral("zeroDigit"), QQmlLocaleData::method_get_zeroDigit, 0);
+    o->defineAccessorProperty(QStringLiteral("amText"), QQmlLocaleData::method_get_amText, 0);
+    o->defineAccessorProperty(QStringLiteral("measurementSystem"), QQmlLocaleData::method_get_measurementSystem, 0);
+    o->defineAccessorProperty(QStringLiteral("exponential"), QQmlLocaleData::method_get_exponential, 0);
 
     prototype = o;
 }
@@ -842,7 +842,7 @@ QV4::ReturnedValue QQmlLocale::locale(QV8Engine *v8engine, const QString &locale
 
 void QQmlLocale::registerStringLocaleCompare(QV4::ExecutionEngine *engine)
 {
-    engine->stringClass->prototype->defineDefaultProperty(engine, QStringLiteral("localeCompare"), method_localeCompare);
+    engine->stringClass->prototype->defineDefaultProperty(QStringLiteral("localeCompare"), method_localeCompare);
 }
 
 QV4::ReturnedValue QQmlLocale::method_localeCompare(QV4::SimpleCallContext *ctx)
diff --git a/src/qml/qml/qqmlvaluetypewrapper.cpp b/src/qml/qml/qqmlvaluetypewrapper.cpp
index b5073763b8..57c05b3a48 100644
--- a/src/qml/qml/qqmlvaluetypewrapper.cpp
+++ b/src/qml/qml/qqmlvaluetypewrapper.cpp
@@ -136,7 +136,7 @@ void QmlValueTypeWrapper::initProto(ExecutionEngine *v4)
 
     Scope scope(v4);
     Scoped<Object> o(scope, v4->newObject());
-    o->defineDefaultProperty(v4, QStringLiteral("toString"), method_toString, 1);
+    o->defineDefaultProperty(QStringLiteral("toString"), method_toString, 1);
     v4->qmlExtensions()->valueTypeWrapperPrototype = o.getPointer();
 }
 
diff --git a/src/qml/qml/qqmlxmlhttprequest.cpp b/src/qml/qml/qqmlxmlhttprequest.cpp
index 53fb6ad477..7aa68ad816 100644
--- a/src/qml/qml/qqmlxmlhttprequest.cpp
+++ b/src/qml/qml/qqmlxmlhttprequest.cpp
@@ -259,17 +259,17 @@ public:
         : Object(engine)
     {
         vtbl = &static_vtbl;
-        defineAccessorProperty(engine, QStringLiteral("nodeName"), method_get_nodeName, 0);
-        defineAccessorProperty(engine, QStringLiteral("nodeValue"), method_get_nodeValue, 0);
-        defineAccessorProperty(engine, QStringLiteral("nodeType"), method_get_nodeType, 0);
-
-        defineAccessorProperty(engine, QStringLiteral("parentNode"), method_get_parentNode, 0);
-        defineAccessorProperty(engine, QStringLiteral("childNodes"), method_get_childNodes, 0);
-        defineAccessorProperty(engine, QStringLiteral("firstChild"), method_get_firstChild, 0);
-        defineAccessorProperty(engine, QStringLiteral("lastChild"), method_get_lastChild, 0);
-        defineAccessorProperty(engine, QStringLiteral("previousSibling"), method_get_previousSibling, 0);
-        defineAccessorProperty(engine, QStringLiteral("nextSibling"), method_get_nextSibling, 0);
-        defineAccessorProperty(engine, QStringLiteral("attributes"), method_get_attributes, 0);
+        defineAccessorProperty(QStringLiteral("nodeName"), method_get_nodeName, 0);
+        defineAccessorProperty(QStringLiteral("nodeValue"), method_get_nodeValue, 0);
+        defineAccessorProperty(QStringLiteral("nodeType"), method_get_nodeType, 0);
+
+        defineAccessorProperty(QStringLiteral("parentNode"), method_get_parentNode, 0);
+        defineAccessorProperty(QStringLiteral("childNodes"), method_get_childNodes, 0);
+        defineAccessorProperty(QStringLiteral("firstChild"), method_get_firstChild, 0);
+        defineAccessorProperty(QStringLiteral("lastChild"), method_get_lastChild, 0);
+        defineAccessorProperty(QStringLiteral("previousSibling"), method_get_previousSibling, 0);
+        defineAccessorProperty(QStringLiteral("nextSibling"), method_get_nextSibling, 0);
+        defineAccessorProperty(QStringLiteral("attributes"), method_get_attributes, 0);
     }
 
     static void initClass(ExecutionEngine *engine);
@@ -629,7 +629,7 @@ Value Element::prototype(ExecutionEngine *engine)
         Scope scope(engine);
         Scoped<Object> p(scope, engine->newObject());
         p->setPrototype(NodePrototype::getProto(engine).asObject());
-        p->defineAccessorProperty(engine, QStringLiteral("tagName"), NodePrototype::method_get_nodeName, 0);
+        p->defineAccessorProperty(QStringLiteral("tagName"), NodePrototype::method_get_nodeName, 0);
         d->elementPrototype = p;
         engine->v8Engine->freezeObject(d->elementPrototype.value());
     }
@@ -643,9 +643,9 @@ Value Attr::prototype(ExecutionEngine *engine)
         Scope scope(engine);
         Scoped<Object> p(scope, engine->newObject());
         p->setPrototype(NodePrototype::getProto(engine).asObject());
-        p->defineAccessorProperty(engine, QStringLiteral("name"), method_name, 0);
-        p->defineAccessorProperty(engine, QStringLiteral("value"), method_value, 0);
-        p->defineAccessorProperty(engine, QStringLiteral("ownerElement"), method_ownerElement, 0);
+        p->defineAccessorProperty(QStringLiteral("name"), method_name, 0);
+        p->defineAccessorProperty(QStringLiteral("value"), method_value, 0);
+        p->defineAccessorProperty(QStringLiteral("ownerElement"), method_ownerElement, 0);
         d->attrPrototype = p;
         engine->v8Engine->freezeObject(d->attrPrototype.value());
     }
@@ -699,8 +699,8 @@ Value CharacterData::prototype(ExecutionEngine *v4)
         Scope scope(v4);
         Scoped<Object> p(scope, v4->newObject());
         p->setPrototype(NodePrototype::getProto(v4).asObject());
-        p->defineAccessorProperty(v4, QStringLiteral("data"), NodePrototype::method_get_nodeValue, 0);
-        p->defineAccessorProperty(v4, QStringLiteral("length"), method_length, 0);
+        p->defineAccessorProperty(QStringLiteral("data"), NodePrototype::method_get_nodeValue, 0);
+        p->defineAccessorProperty(QStringLiteral("length"), method_length, 0);
         d->characterDataPrototype = p;
         v4->v8Engine->freezeObject(d->characterDataPrototype);
     }
@@ -732,8 +732,8 @@ Value Text::prototype(ExecutionEngine *v4)
         Scope scope(v4);
         Scoped<Object> p(scope, v4->newObject());
         p->setPrototype(CharacterData::prototype(v4).asObject());
-        p->defineAccessorProperty(v4, QStringLiteral("isElementContentWhitespace"), method_isElementContentWhitespace, 0);
-        p->defineAccessorProperty(v4, QStringLiteral("wholeText"), method_wholeText, 0);
+        p->defineAccessorProperty(QStringLiteral("isElementContentWhitespace"), method_isElementContentWhitespace, 0);
+        p->defineAccessorProperty(QStringLiteral("wholeText"), method_wholeText, 0);
         d->textPrototype = p;
         v4->v8Engine->freezeObject(d->textPrototype);
     }
@@ -761,10 +761,10 @@ Value Document::prototype(ExecutionEngine *v4)
         Scope scope(v4);
         Scoped<Object> p(scope, v4->newObject());
         p->setPrototype(NodePrototype::getProto(v4).asObject());
-        p->defineAccessorProperty(v4, QStringLiteral("xmlVersion"), method_xmlVersion, 0);
-        p->defineAccessorProperty(v4, QStringLiteral("xmlEncoding"), method_xmlEncoding, 0);
-        p->defineAccessorProperty(v4, QStringLiteral("xmlStandalone"), method_xmlStandalone, 0);
-        p->defineAccessorProperty(v4, QStringLiteral("documentElement"), method_documentElement, 0);
+        p->defineAccessorProperty(QStringLiteral("xmlVersion"), method_xmlVersion, 0);
+        p->defineAccessorProperty(QStringLiteral("xmlEncoding"), method_xmlEncoding, 0);
+        p->defineAccessorProperty(QStringLiteral("xmlStandalone"), method_xmlStandalone, 0);
+        p->defineAccessorProperty(QStringLiteral("documentElement"), method_documentElement, 0);
         d->documentPrototype = p;
         v4->v8Engine->freezeObject(d->documentPrototype);
     }
@@ -1585,11 +1585,11 @@ struct QQmlXMLHttpRequestCtor : public FunctionObject
         : FunctionObject(engine->rootContext, engine->newString(QStringLiteral("XMLHttpRequest")))
     {
         vtbl = &static_vtbl;
-        defineReadonlyProperty(engine, QStringLiteral("UNSENT"), Value::fromInt32(0));
-        defineReadonlyProperty(engine, QStringLiteral("OPENED"), Value::fromInt32(1));
-        defineReadonlyProperty(engine, QStringLiteral("HEADERS_RECEIVED"), Value::fromInt32(2));
-        defineReadonlyProperty(engine, QStringLiteral("LOADING"), Value::fromInt32(3));
-        defineReadonlyProperty(engine, QStringLiteral("DONE"), Value::fromInt32(4));
+        defineReadonlyProperty(QStringLiteral("UNSENT"), Value::fromInt32(0));
+        defineReadonlyProperty(QStringLiteral("OPENED"), Value::fromInt32(1));
+        defineReadonlyProperty(QStringLiteral("HEADERS_RECEIVED"), Value::fromInt32(2));
+        defineReadonlyProperty(QStringLiteral("LOADING"), Value::fromInt32(3));
+        defineReadonlyProperty(QStringLiteral("DONE"), Value::fromInt32(4));
         if (!proto)
             setupProto();
         Scope scope(engine);
@@ -1653,26 +1653,26 @@ void QQmlXMLHttpRequestCtor::setupProto()
     proto = p.getPointer();
 
     // Methods
-    proto->defineDefaultProperty(v4, QStringLiteral("open"), method_open);
-    proto->defineDefaultProperty(v4, QStringLiteral("setRequestHeader"), method_setRequestHeader);
-    proto->defineDefaultProperty(v4, QStringLiteral("send"), method_send);
-    proto->defineDefaultProperty(v4, QStringLiteral("abort"), method_abort);
-    proto->defineDefaultProperty(v4, QStringLiteral("getResponseHeader"), method_getResponseHeader);
-    proto->defineDefaultProperty(v4, QStringLiteral("getAllResponseHeaders"), method_getAllResponseHeaders);
+    proto->defineDefaultProperty(QStringLiteral("open"), method_open);
+    proto->defineDefaultProperty(QStringLiteral("setRequestHeader"), method_setRequestHeader);
+    proto->defineDefaultProperty(QStringLiteral("send"), method_send);
+    proto->defineDefaultProperty(QStringLiteral("abort"), method_abort);
+    proto->defineDefaultProperty(QStringLiteral("getResponseHeader"), method_getResponseHeader);
+    proto->defineDefaultProperty(QStringLiteral("getAllResponseHeaders"), method_getAllResponseHeaders);
 
     // Read-only properties
-    proto->defineAccessorProperty(v4, QStringLiteral("readyState"), method_get_readyState, 0);
-    proto->defineAccessorProperty(v4, QStringLiteral("status"),method_get_status, 0);
-    proto->defineAccessorProperty(v4, QStringLiteral("statusText"),method_get_statusText, 0);
-    proto->defineAccessorProperty(v4, QStringLiteral("responseText"),method_get_responseText, 0);
-    proto->defineAccessorProperty(v4, QStringLiteral("responseXML"),method_get_responseXML, 0);
+    proto->defineAccessorProperty(QStringLiteral("readyState"), method_get_readyState, 0);
+    proto->defineAccessorProperty(QStringLiteral("status"),method_get_status, 0);
+    proto->defineAccessorProperty(QStringLiteral("statusText"),method_get_statusText, 0);
+    proto->defineAccessorProperty(QStringLiteral("responseText"),method_get_responseText, 0);
+    proto->defineAccessorProperty(QStringLiteral("responseXML"),method_get_responseXML, 0);
 
     // State values
-    proto->defineReadonlyProperty(v4, QStringLiteral("UNSENT"), Value::fromInt32(0));
-    proto->defineReadonlyProperty(v4, QStringLiteral("OPENED"), Value::fromInt32(1));
-    proto->defineReadonlyProperty(v4, QStringLiteral("HEADERS_RECEIVED"), Value::fromInt32(2));
-    proto->defineReadonlyProperty(v4, QStringLiteral("LOADING"), Value::fromInt32(3));
-    proto->defineReadonlyProperty(v4, QStringLiteral("DONE"), Value::fromInt32(4));
+    proto->defineReadonlyProperty(QStringLiteral("UNSENT"), Value::fromInt32(0));
+    proto->defineReadonlyProperty(QStringLiteral("OPENED"), Value::fromInt32(1));
+    proto->defineReadonlyProperty(QStringLiteral("HEADERS_RECEIVED"), Value::fromInt32(2));
+    proto->defineReadonlyProperty(QStringLiteral("LOADING"), Value::fromInt32(3));
+    proto->defineReadonlyProperty(QStringLiteral("DONE"), Value::fromInt32(4));
 }
 
 
@@ -1953,9 +1953,11 @@ void qt_rem_qmlxmlhttprequest(QV8Engine * /* engine */, void *d)
 void *qt_add_qmlxmlhttprequest(QV8Engine *engine)
 {
     ExecutionEngine *v4 = QV8Engine::getV4(engine);
+    Scope scope(v4);
 
-    QQmlXMLHttpRequestCtor *ctor = new (v4->memoryManager) QQmlXMLHttpRequestCtor(v4);
-    v4->globalObject->defineReadonlyProperty(v4->newString(QStringLiteral("XMLHttpRequest")), Value::fromObject(ctor));
+    Scoped<QQmlXMLHttpRequestCtor> ctor(scope, new (v4->memoryManager) QQmlXMLHttpRequestCtor(v4));
+    ScopedString s(scope, v4->newString(QStringLiteral("XMLHttpRequest")));
+    v4->globalObject->defineReadonlyProperty(s, ctor.asValue());
 
     QQmlXMLHttpRequestData *data = new QQmlXMLHttpRequestData;
     return data;
diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
index f03ec7ee19..816680e1d9 100644
--- a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
+++ b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
@@ -105,48 +105,48 @@ QV4::QtObject::QtObject(ExecutionEngine *v4, QQmlEngine *qmlEngine)
     put(v4->newString("Asynchronous"), QV4::Value::fromInt32(0));
     put(v4->newString("Synchronous"), QV4::Value::fromInt32(1));
 
-    defineDefaultProperty(v4, QStringLiteral("include"), QV4Include::method_include);
-    defineDefaultProperty(v4, QStringLiteral("isQtObject"), method_isQtObject);
-    defineDefaultProperty(v4, QStringLiteral("rgba"), method_rgba);
-    defineDefaultProperty(v4, QStringLiteral("hsla"), method_hsla);
-    defineDefaultProperty(v4, QStringLiteral("colorEqual"), method_colorEqual);
-    defineDefaultProperty(v4, QStringLiteral("rect"), method_rect);
-    defineDefaultProperty(v4, QStringLiteral("point"), method_point);
-    defineDefaultProperty(v4, QStringLiteral("size"), method_size);
-    defineDefaultProperty(v4, QStringLiteral("font"), method_font);
-
-    defineDefaultProperty(v4, QStringLiteral("vector2d"), method_vector2d);
-    defineDefaultProperty(v4, QStringLiteral("vector3d"), method_vector3d);
-    defineDefaultProperty(v4, QStringLiteral("vector4d"), method_vector4d);
-    defineDefaultProperty(v4, QStringLiteral("quaternion"), method_quaternion);
-    defineDefaultProperty(v4, QStringLiteral("matrix4x4"), method_matrix4x4);
-
-    defineDefaultProperty(v4, QStringLiteral("formatDate"), method_formatDate);
-    defineDefaultProperty(v4, QStringLiteral("formatTime"), method_formatTime);
-    defineDefaultProperty(v4, QStringLiteral("formatDateTime"), method_formatDateTime);
-
-    defineDefaultProperty(v4, QStringLiteral("openUrlExternally"), method_openUrlExternally);
-    defineDefaultProperty(v4, QStringLiteral("fontFamilies"), method_fontFamilies);
-    defineDefaultProperty(v4, QStringLiteral("md5"), method_md5);
-    defineDefaultProperty(v4, QStringLiteral("btoa"), method_btoa);
-    defineDefaultProperty(v4, QStringLiteral("atob"), method_atob);
-    defineDefaultProperty(v4, QStringLiteral("resolvedUrl"), method_resolvedUrl);
-    defineDefaultProperty(v4, QStringLiteral("locale"), method_locale);
-    defineDefaultProperty(v4, QStringLiteral("binding"), method_binding);
+    defineDefaultProperty(QStringLiteral("include"), QV4Include::method_include);
+    defineDefaultProperty(QStringLiteral("isQtObject"), method_isQtObject);
+    defineDefaultProperty(QStringLiteral("rgba"), method_rgba);
+    defineDefaultProperty(QStringLiteral("hsla"), method_hsla);
+    defineDefaultProperty(QStringLiteral("colorEqual"), method_colorEqual);
+    defineDefaultProperty(QStringLiteral("rect"), method_rect);
+    defineDefaultProperty(QStringLiteral("point"), method_point);
+    defineDefaultProperty(QStringLiteral("size"), method_size);
+    defineDefaultProperty(QStringLiteral("font"), method_font);
+
+    defineDefaultProperty(QStringLiteral("vector2d"), method_vector2d);
+    defineDefaultProperty(QStringLiteral("vector3d"), method_vector3d);
+    defineDefaultProperty(QStringLiteral("vector4d"), method_vector4d);
+    defineDefaultProperty(QStringLiteral("quaternion"), method_quaternion);
+    defineDefaultProperty(QStringLiteral("matrix4x4"), method_matrix4x4);
+
+    defineDefaultProperty(QStringLiteral("formatDate"), method_formatDate);
+    defineDefaultProperty(QStringLiteral("formatTime"), method_formatTime);
+    defineDefaultProperty(QStringLiteral("formatDateTime"), method_formatDateTime);
+
+    defineDefaultProperty(QStringLiteral("openUrlExternally"), method_openUrlExternally);
+    defineDefaultProperty(QStringLiteral("fontFamilies"), method_fontFamilies);
+    defineDefaultProperty(QStringLiteral("md5"), method_md5);
+    defineDefaultProperty(QStringLiteral("btoa"), method_btoa);
+    defineDefaultProperty(QStringLiteral("atob"), method_atob);
+    defineDefaultProperty(QStringLiteral("resolvedUrl"), method_resolvedUrl);
+    defineDefaultProperty(QStringLiteral("locale"), method_locale);
+    defineDefaultProperty(QStringLiteral("binding"), method_binding);
 
     if (qmlEngine) {
-        defineDefaultProperty(v4, QStringLiteral("lighter"), method_lighter);
-        defineDefaultProperty(v4, QStringLiteral("darker"), method_darker);
-        defineDefaultProperty(v4, QStringLiteral("tint"), method_tint);
-        defineDefaultProperty(v4, QStringLiteral("quit"), method_quit);
-        defineDefaultProperty(v4, QStringLiteral("createQmlObject"), method_createQmlObject);
-        defineDefaultProperty(v4, QStringLiteral("createComponent"), method_createComponent);
+        defineDefaultProperty(QStringLiteral("lighter"), method_lighter);
+        defineDefaultProperty(QStringLiteral("darker"), method_darker);
+        defineDefaultProperty(QStringLiteral("tint"), method_tint);
+        defineDefaultProperty(QStringLiteral("quit"), method_quit);
+        defineDefaultProperty(QStringLiteral("createQmlObject"), method_createQmlObject);
+        defineDefaultProperty(QStringLiteral("createComponent"), method_createComponent);
     }
 
-    defineAccessorProperty(v4, QStringLiteral("platform"), method_get_platform, 0);
-    defineAccessorProperty(v4, QStringLiteral("application"), method_get_application, 0);
+    defineAccessorProperty(QStringLiteral("platform"), method_get_platform, 0);
+    defineAccessorProperty(QStringLiteral("application"), method_get_application, 0);
 #ifndef QT_NO_IM
-    defineAccessorProperty(v4, QStringLiteral("inputMethod"), method_get_inputMethod, 0);
+    defineAccessorProperty(QStringLiteral("inputMethod"), method_get_inputMethod, 0);
 #endif
 }
 
@@ -1300,20 +1300,20 @@ ReturnedValue QtObject::method_get_inputMethod(SimpleCallContext *ctx)
 QV4::ConsoleObject::ConsoleObject(ExecutionEngine *v4)
     : Object(v4)
 {
-    defineDefaultProperty(v4, QStringLiteral("debug"), method_log);
-    defineDefaultProperty(v4, QStringLiteral("log"), method_log);
-    defineDefaultProperty(v4, QStringLiteral("info"), method_log);
-    defineDefaultProperty(v4, QStringLiteral("warn"), method_warn);
-    defineDefaultProperty(v4, QStringLiteral("error"), method_error);
-    defineDefaultProperty(v4, QStringLiteral("assert"), method_assert);
-
-    defineDefaultProperty(v4, QStringLiteral("count"), method_count);
-    defineDefaultProperty(v4, QStringLiteral("profile"), method_profile);
-    defineDefaultProperty(v4, QStringLiteral("profileEnd"), method_profileEnd);
-    defineDefaultProperty(v4, QStringLiteral("time"), method_time);
-    defineDefaultProperty(v4, QStringLiteral("timeEnd"), method_timeEnd);
-    defineDefaultProperty(v4, QStringLiteral("trace"), method_trace);
-    defineDefaultProperty(v4, QStringLiteral("exception"), method_exception);
+    defineDefaultProperty(QStringLiteral("debug"), method_log);
+    defineDefaultProperty(QStringLiteral("log"), method_log);
+    defineDefaultProperty(QStringLiteral("info"), method_log);
+    defineDefaultProperty(QStringLiteral("warn"), method_warn);
+    defineDefaultProperty(QStringLiteral("error"), method_error);
+    defineDefaultProperty(QStringLiteral("assert"), method_assert);
+
+    defineDefaultProperty(QStringLiteral("count"), method_count);
+    defineDefaultProperty(QStringLiteral("profile"), method_profile);
+    defineDefaultProperty(QStringLiteral("profileEnd"), method_profileEnd);
+    defineDefaultProperty(QStringLiteral("time"), method_time);
+    defineDefaultProperty(QStringLiteral("timeEnd"), method_timeEnd);
+    defineDefaultProperty(QStringLiteral("trace"), method_trace);
+    defineDefaultProperty(QStringLiteral("exception"), method_exception);
 }
 
 
@@ -1566,26 +1566,26 @@ void QV4::GlobalExtensions::init(QQmlEngine *qmlEngine, Object *globalObject)
     QV4::ExecutionEngine *v4 = globalObject->engine();
 
 #ifndef QT_NO_TRANSLATION
-    globalObject->defineDefaultProperty(v4, QStringLiteral("qsTranslate"), method_qsTranslate);
-    globalObject->defineDefaultProperty(v4, QStringLiteral("QT_TRANSLATE_NOOP"), method_qsTranslateNoOp);
-    globalObject->defineDefaultProperty(v4, QStringLiteral("qsTr"), method_qsTr);
-    globalObject->defineDefaultProperty(v4, QStringLiteral("QT_TR_NOOP"), method_qsTrNoOp);
-    globalObject->defineDefaultProperty(v4, QStringLiteral("qsTrId"), method_qsTrId);
-    globalObject->defineDefaultProperty(v4, QStringLiteral("QT_TRID_NOOP"), method_qsTrIdNoOp);
+    globalObject->defineDefaultProperty(QStringLiteral("qsTranslate"), method_qsTranslate);
+    globalObject->defineDefaultProperty(QStringLiteral("QT_TRANSLATE_NOOP"), method_qsTranslateNoOp);
+    globalObject->defineDefaultProperty(QStringLiteral("qsTr"), method_qsTr);
+    globalObject->defineDefaultProperty(QStringLiteral("QT_TR_NOOP"), method_qsTrNoOp);
+    globalObject->defineDefaultProperty(QStringLiteral("qsTrId"), method_qsTrId);
+    globalObject->defineDefaultProperty(QStringLiteral("QT_TRID_NOOP"), method_qsTrIdNoOp);
 #endif
 
-    globalObject->defineDefaultProperty(v4, QStringLiteral("print"), ConsoleObject::method_log);
-    globalObject->defineDefaultProperty(v4, QStringLiteral("gc"), method_gc);
+    globalObject->defineDefaultProperty(QStringLiteral("print"), ConsoleObject::method_log);
+    globalObject->defineDefaultProperty(QStringLiteral("gc"), method_gc);
 
     Value console = QV4::Value::fromObject(new (v4->memoryManager) QV4::ConsoleObject(v4));
-    globalObject->defineDefaultProperty(v4, QStringLiteral("console"), console);
+    globalObject->defineDefaultProperty(QStringLiteral("console"), console);
 
     Value qt = QV4::Value::fromObject(new (v4->memoryManager) QV4::QtObject(v4, qmlEngine));
-    globalObject->defineDefaultProperty(v4, QStringLiteral("Qt"), qt);
+    globalObject->defineDefaultProperty(QStringLiteral("Qt"), qt);
 
     // string prototype extension
     QV4::Object *stringProto = v4->stringClass->prototype;
-    stringProto->defineDefaultProperty(v4, QStringLiteral("arg"), method_string_arg);
+    stringProto->defineDefaultProperty(QStringLiteral("arg"), method_string_arg);
 }
 
 
diff --git a/src/qml/qml/v8/qv4domerrors.cpp b/src/qml/qml/v8/qv4domerrors.cpp
index f89831fa2f..c0dbd54e64 100644
--- a/src/qml/qml/v8/qv4domerrors.cpp
+++ b/src/qml/qml/v8/qv4domerrors.cpp
@@ -50,24 +50,24 @@ void qt_add_domexceptions(ExecutionEngine *e)
 {
     Scope scope(e);
     Scoped<Object> domexception(scope, e->newObject());
-    domexception->defineReadonlyProperty(e, QStringLiteral("INDEX_SIZE_ERR"), Value::fromInt32(DOMEXCEPTION_INDEX_SIZE_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("DOMSTRING_SIZE_ERR"), Value::fromInt32(DOMEXCEPTION_DOMSTRING_SIZE_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("HIERARCHY_REQUEST_ERR"), Value::fromInt32(DOMEXCEPTION_HIERARCHY_REQUEST_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("WRONG_DOCUMENT_ERR"), Value::fromInt32(DOMEXCEPTION_WRONG_DOCUMENT_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("INVALID_CHARACTER_ERR"), Value::fromInt32(DOMEXCEPTION_INVALID_CHARACTER_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("NO_DATA_ALLOWED_ERR"), Value::fromInt32(DOMEXCEPTION_NO_DATA_ALLOWED_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("NO_MODIFICATION_ALLOWED_ERR"), Value::fromInt32(DOMEXCEPTION_NO_MODIFICATION_ALLOWED_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("NOT_FOUND_ERR"), Value::fromInt32(DOMEXCEPTION_NOT_FOUND_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("NOT_SUPPORTED_ERR"), Value::fromInt32(DOMEXCEPTION_NOT_SUPPORTED_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("INUSE_ATTRIBUTE_ERR"), Value::fromInt32(DOMEXCEPTION_INUSE_ATTRIBUTE_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("INVALID_STATE_ERR"), Value::fromInt32(DOMEXCEPTION_INVALID_STATE_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("SYNTAX_ERR"), Value::fromInt32(DOMEXCEPTION_SYNTAX_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("INVALID_MODIFICATION_ERR"), Value::fromInt32(DOMEXCEPTION_INVALID_MODIFICATION_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("NAMESPACE_ERR"), Value::fromInt32(DOMEXCEPTION_NAMESPACE_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("INVALID_ACCESS_ERR"), Value::fromInt32(DOMEXCEPTION_INVALID_ACCESS_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("VALIDATION_ERR"), Value::fromInt32(DOMEXCEPTION_VALIDATION_ERR));
-    domexception->defineReadonlyProperty(e, QStringLiteral("TYPE_MISMATCH_ERR"), Value::fromInt32(DOMEXCEPTION_TYPE_MISMATCH_ERR));
-    e->globalObject->defineDefaultProperty(e->current, QStringLiteral("DOMException"), domexception.asValue());
+    domexception->defineReadonlyProperty(QStringLiteral("INDEX_SIZE_ERR"), Value::fromInt32(DOMEXCEPTION_INDEX_SIZE_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("DOMSTRING_SIZE_ERR"), Value::fromInt32(DOMEXCEPTION_DOMSTRING_SIZE_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("HIERARCHY_REQUEST_ERR"), Value::fromInt32(DOMEXCEPTION_HIERARCHY_REQUEST_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("WRONG_DOCUMENT_ERR"), Value::fromInt32(DOMEXCEPTION_WRONG_DOCUMENT_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("INVALID_CHARACTER_ERR"), Value::fromInt32(DOMEXCEPTION_INVALID_CHARACTER_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("NO_DATA_ALLOWED_ERR"), Value::fromInt32(DOMEXCEPTION_NO_DATA_ALLOWED_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("NO_MODIFICATION_ALLOWED_ERR"), Value::fromInt32(DOMEXCEPTION_NO_MODIFICATION_ALLOWED_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("NOT_FOUND_ERR"), Value::fromInt32(DOMEXCEPTION_NOT_FOUND_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("NOT_SUPPORTED_ERR"), Value::fromInt32(DOMEXCEPTION_NOT_SUPPORTED_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("INUSE_ATTRIBUTE_ERR"), Value::fromInt32(DOMEXCEPTION_INUSE_ATTRIBUTE_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("INVALID_STATE_ERR"), Value::fromInt32(DOMEXCEPTION_INVALID_STATE_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("SYNTAX_ERR"), Value::fromInt32(DOMEXCEPTION_SYNTAX_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("INVALID_MODIFICATION_ERR"), Value::fromInt32(DOMEXCEPTION_INVALID_MODIFICATION_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("NAMESPACE_ERR"), Value::fromInt32(DOMEXCEPTION_NAMESPACE_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("INVALID_ACCESS_ERR"), Value::fromInt32(DOMEXCEPTION_INVALID_ACCESS_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("VALIDATION_ERR"), Value::fromInt32(DOMEXCEPTION_VALIDATION_ERR));
+    domexception->defineReadonlyProperty(QStringLiteral("TYPE_MISMATCH_ERR"), Value::fromInt32(DOMEXCEPTION_TYPE_MISMATCH_ERR));
+    e->globalObject->defineDefaultProperty(QStringLiteral("DOMException"), domexception.asValue());
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/v8/qv4sqlerrors.cpp b/src/qml/qml/v8/qv4sqlerrors.cpp
index a203fd9980..9c97aacdbe 100644
--- a/src/qml/qml/v8/qv4sqlerrors.cpp
+++ b/src/qml/qml/v8/qv4sqlerrors.cpp
@@ -51,15 +51,15 @@ void qt_add_sqlexceptions(QV4::ExecutionEngine *engine)
 {
     Scope scope(engine);
     Scoped<Object> sqlexception(scope, engine->newObject());
-    sqlexception->defineReadonlyProperty(engine, QStringLiteral("UNKNOWN_ERR"), Value::fromInt32(SQLEXCEPTION_UNKNOWN_ERR));
-    sqlexception->defineReadonlyProperty(engine, QStringLiteral("DATABASE_ERR"), Value::fromInt32(SQLEXCEPTION_DATABASE_ERR));
-    sqlexception->defineReadonlyProperty(engine, QStringLiteral("VERSION_ERR"), Value::fromInt32(SQLEXCEPTION_VERSION_ERR));
-    sqlexception->defineReadonlyProperty(engine, QStringLiteral("TOO_LARGE_ERR"), Value::fromInt32(SQLEXCEPTION_TOO_LARGE_ERR));
-    sqlexception->defineReadonlyProperty(engine, QStringLiteral("QUOTA_ERR"), Value::fromInt32(SQLEXCEPTION_QUOTA_ERR));
-    sqlexception->defineReadonlyProperty(engine, QStringLiteral("SYNTAX_ERR"), Value::fromInt32(SQLEXCEPTION_SYNTAX_ERR));
-    sqlexception->defineReadonlyProperty(engine, QStringLiteral("CONSTRAINT_ERR"), Value::fromInt32(SQLEXCEPTION_CONSTRAINT_ERR));
-    sqlexception->defineReadonlyProperty(engine, QStringLiteral("TIMEOUT_ERR"), Value::fromInt32(SQLEXCEPTION_TIMEOUT_ERR));
-    engine->globalObject->defineDefaultProperty(engine->current, QStringLiteral("SQLException"), sqlexception.asValue());
+    sqlexception->defineReadonlyProperty(QStringLiteral("UNKNOWN_ERR"), Value::fromInt32(SQLEXCEPTION_UNKNOWN_ERR));
+    sqlexception->defineReadonlyProperty(QStringLiteral("DATABASE_ERR"), Value::fromInt32(SQLEXCEPTION_DATABASE_ERR));
+    sqlexception->defineReadonlyProperty(QStringLiteral("VERSION_ERR"), Value::fromInt32(SQLEXCEPTION_VERSION_ERR));
+    sqlexception->defineReadonlyProperty(QStringLiteral("TOO_LARGE_ERR"), Value::fromInt32(SQLEXCEPTION_TOO_LARGE_ERR));
+    sqlexception->defineReadonlyProperty(QStringLiteral("QUOTA_ERR"), Value::fromInt32(SQLEXCEPTION_QUOTA_ERR));
+    sqlexception->defineReadonlyProperty(QStringLiteral("SYNTAX_ERR"), Value::fromInt32(SQLEXCEPTION_SYNTAX_ERR));
+    sqlexception->defineReadonlyProperty(QStringLiteral("CONSTRAINT_ERR"), Value::fromInt32(SQLEXCEPTION_CONSTRAINT_ERR));
+    sqlexception->defineReadonlyProperty(QStringLiteral("TIMEOUT_ERR"), Value::fromInt32(SQLEXCEPTION_TIMEOUT_ERR));
+    engine->globalObject->defineDefaultProperty(QStringLiteral("SQLException"), sqlexception.asValue());
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/types/qqmldelegatemodel.cpp b/src/qml/types/qqmldelegatemodel.cpp
index 2e739bfcce..2908d1b47b 100644
--- a/src/qml/types/qqmldelegatemodel.cpp
+++ b/src/qml/types/qqmldelegatemodel.cpp
@@ -1627,8 +1627,8 @@ void QQmlDelegateModelItemMetaType::initializePrototype()
     QV4::Scope scope(v4);
 
     QV4::Scoped<QV4::Object> proto(scope, v4->newObject());
-    proto->defineAccessorProperty(v4, QStringLiteral("model"), QQmlDelegateModelItem::get_model, 0);
-    proto->defineAccessorProperty(v4, QStringLiteral("groups"), QQmlDelegateModelItem::get_groups, QQmlDelegateModelItem::set_groups);
+    proto->defineAccessorProperty(QStringLiteral("model"), QQmlDelegateModelItem::get_model, 0);
+    proto->defineAccessorProperty(QStringLiteral("groups"), QQmlDelegateModelItem::get_groups, QQmlDelegateModelItem::set_groups);
     QV4::ScopedString s(scope);
     s = v4->newString(QStringLiteral("isUnresolved"));
     QV4::Property *p = proto->insertMember(s, QV4::Attr_Accessor|QV4::Attr_NotConfigurable|QV4::Attr_NotEnumerable);
@@ -3242,9 +3242,9 @@ QQmlDelegateModelEngineData::QQmlDelegateModelEngineData(QV8Engine *e)
     QV4::Scope scope(v4);
 
     QV4::Scoped<QV4::Object> proto(scope, v4->newObject());
-    proto->defineAccessorProperty(v4, QStringLiteral("index"), QQmlDelegateModelGroupChange::method_get_index, 0);
-    proto->defineAccessorProperty(v4, QStringLiteral("count"), QQmlDelegateModelGroupChange::method_get_count, 0);
-    proto->defineAccessorProperty(v4, QStringLiteral("moveId"), QQmlDelegateModelGroupChange::method_get_moveId, 0);
+    proto->defineAccessorProperty(QStringLiteral("index"), QQmlDelegateModelGroupChange::method_get_index, 0);
+    proto->defineAccessorProperty(QStringLiteral("count"), QQmlDelegateModelGroupChange::method_get_count, 0);
+    proto->defineAccessorProperty(QStringLiteral("moveId"), QQmlDelegateModelGroupChange::method_get_moveId, 0);
     changeProto = proto;
 }
 
diff --git a/src/qml/util/qqmladaptormodel.cpp b/src/qml/util/qqmladaptormodel.cpp
index 4b1c30d4d2..7351e696c6 100644
--- a/src/qml/util/qqmladaptormodel.cpp
+++ b/src/qml/util/qqmladaptormodel.cpp
@@ -215,8 +215,8 @@ public:
         QV4::ExecutionEngine *v4 = data->v4;
         QV4::Scope scope(v4);
         QV4::Scoped<QV4::Object> proto(scope, v4->newObject());
-        proto->defineAccessorProperty(v4, QStringLiteral("index"), get_index, 0);
-        proto->defineAccessorProperty(v4, QStringLiteral("hasModelChildren"), get_hasModelChildren, 0);
+        proto->defineAccessorProperty(QStringLiteral("index"), get_index, 0);
+        proto->defineAccessorProperty(QStringLiteral("hasModelChildren"), get_hasModelChildren, 0);
 
         typedef QHash<QByteArray, int>::const_iterator iterator;
         for (iterator it = roleNames.constBegin(), end = roleNames.constEnd(); it != end; ++it) {
@@ -953,8 +953,8 @@ QQmlAdaptorModelEngineData::QQmlAdaptorModelEngineData(QV8Engine *e)
 {
     QV4::Scope scope(v4);
     QV4::Scoped<QV4::Object> proto(scope, v4->newObject());
-    proto->defineAccessorProperty(v4, QStringLiteral("index"), get_index, 0);
-    proto->defineAccessorProperty(v4, QStringLiteral("modelData"),
+    proto->defineAccessorProperty(QStringLiteral("index"), get_index, 0);
+    proto->defineAccessorProperty(QStringLiteral("modelData"),
                                   QQmlDMListAccessorData::get_modelData, QQmlDMListAccessorData::set_modelData);
     listItemProto = proto;
 }
diff --git a/src/quick/items/context2d/qquickcontext2d.cpp b/src/quick/items/context2d/qquickcontext2d.cpp
index ff7ad838f3..f84a6855dd 100644
--- a/src/quick/items/context2d/qquickcontext2d.cpp
+++ b/src/quick/items/context2d/qquickcontext2d.cpp
@@ -545,50 +545,50 @@ public:
     QQuickJSContext2DPrototype(QV4::ExecutionEngine *engine)
         : QV4::Object(engine)
     {
-        defineDefaultProperty(engine, QStringLiteral("quadraticCurveTo"), method_quadraticCurveTo, 0);
-        defineDefaultProperty(engine, QStringLiteral("restore"), method_restore, 0);
-        defineDefaultProperty(engine, QStringLiteral("moveTo"), method_moveTo, 0);
-        defineDefaultProperty(engine, QStringLiteral("lineTo"), method_lineTo, 0);
-        defineDefaultProperty(engine, QStringLiteral("caretBlinkRate"), method_caretBlinkRate, 0);
-        defineDefaultProperty(engine, QStringLiteral("clip"), method_clip, 0);
-        defineDefaultProperty(engine, QStringLiteral("setTransform"), method_setTransform, 0);
-        defineDefaultProperty(engine, QStringLiteral("text"), method_text, 0);
-        defineDefaultProperty(engine, QStringLiteral("roundedRect"), method_roundedRect, 0);
-        defineDefaultProperty(engine, QStringLiteral("createPattern"), method_createPattern, 0);
-        defineDefaultProperty(engine, QStringLiteral("stroke"), method_stroke, 0);
-        defineDefaultProperty(engine, QStringLiteral("arc"), method_arc, 0);
-        defineDefaultProperty(engine, QStringLiteral("createImageData"), method_createImageData, 0);
-        defineDefaultProperty(engine, QStringLiteral("measureText"), method_measureText, 0);
-        defineDefaultProperty(engine, QStringLiteral("ellipse"), method_ellipse, 0);
-        defineDefaultProperty(engine, QStringLiteral("fill"), method_fill, 0);
-        defineDefaultProperty(engine, QStringLiteral("save"), method_save, 0);
-        defineDefaultProperty(engine, QStringLiteral("scale"), method_scale, 0);
-        defineDefaultProperty(engine, QStringLiteral("drawImage"), method_drawImage, 0);
-        defineDefaultProperty(engine, QStringLiteral("transform"), method_transform, 0);
-        defineDefaultProperty(engine, QStringLiteral("fillText"), method_fillText, 0);
-        defineDefaultProperty(engine, QStringLiteral("strokeText"), method_strokeText, 0);
-        defineDefaultProperty(engine, QStringLiteral("translate"), method_translate, 0);
-        defineDefaultProperty(engine, QStringLiteral("createRadialGradient"), method_createRadialGradient, 0);
-        defineDefaultProperty(engine, QStringLiteral("shear"), method_shear, 0);
-        defineDefaultProperty(engine, QStringLiteral("isPointInPath"), method_isPointInPath, 0);
-        defineDefaultProperty(engine, QStringLiteral("bezierCurveTo"), method_bezierCurveTo, 0);
-        defineDefaultProperty(engine, QStringLiteral("resetTransform"), method_resetTransform, 0);
-        defineDefaultProperty(engine, QStringLiteral("arcTo"), method_arcTo, 0);
-        defineDefaultProperty(engine, QStringLiteral("fillRect"), method_fillRect, 0);
-        defineDefaultProperty(engine, QStringLiteral("createConicalGradient"), method_createConicalGradient, 0);
-        defineDefaultProperty(engine, QStringLiteral("drawFocusRing"), method_drawFocusRing, 0);
-        defineDefaultProperty(engine, QStringLiteral("beginPath"), method_beginPath, 0);
-        defineDefaultProperty(engine, QStringLiteral("clearRect"), method_clearRect, 0);
-        defineDefaultProperty(engine, QStringLiteral("rect"), method_rect, 0);
-        defineDefaultProperty(engine, QStringLiteral("reset"), method_reset, 0);
-        defineDefaultProperty(engine, QStringLiteral("rotate"), method_rotate, 0);
-        defineDefaultProperty(engine, QStringLiteral("setCaretSelectionRect"), method_setCaretSelectionRect, 0);
-        defineDefaultProperty(engine, QStringLiteral("putImageData"), method_putImageData, 0);
-        defineDefaultProperty(engine, QStringLiteral("getImageData"), method_getImageData, 0);
-        defineDefaultProperty(engine, QStringLiteral("createLinearGradient"), method_createLinearGradient, 0);
-        defineDefaultProperty(engine, QStringLiteral("strokeRect"), method_strokeRect, 0);
-        defineDefaultProperty(engine, QStringLiteral("closePath"), method_closePath, 0);
-        defineAccessorProperty(engine, QStringLiteral("canvas"), QQuickJSContext2DPrototype::method_get_canvas, 0);
+        defineDefaultProperty(QStringLiteral("quadraticCurveTo"), method_quadraticCurveTo, 0);
+        defineDefaultProperty(QStringLiteral("restore"), method_restore, 0);
+        defineDefaultProperty(QStringLiteral("moveTo"), method_moveTo, 0);
+        defineDefaultProperty(QStringLiteral("lineTo"), method_lineTo, 0);
+        defineDefaultProperty(QStringLiteral("caretBlinkRate"), method_caretBlinkRate, 0);
+        defineDefaultProperty(QStringLiteral("clip"), method_clip, 0);
+        defineDefaultProperty(QStringLiteral("setTransform"), method_setTransform, 0);
+        defineDefaultProperty(QStringLiteral("text"), method_text, 0);
+        defineDefaultProperty(QStringLiteral("roundedRect"), method_roundedRect, 0);
+        defineDefaultProperty(QStringLiteral("createPattern"), method_createPattern, 0);
+        defineDefaultProperty(QStringLiteral("stroke"), method_stroke, 0);
+        defineDefaultProperty(QStringLiteral("arc"), method_arc, 0);
+        defineDefaultProperty(QStringLiteral("createImageData"), method_createImageData, 0);
+        defineDefaultProperty(QStringLiteral("measureText"), method_measureText, 0);
+        defineDefaultProperty(QStringLiteral("ellipse"), method_ellipse, 0);
+        defineDefaultProperty(QStringLiteral("fill"), method_fill, 0);
+        defineDefaultProperty(QStringLiteral("save"), method_save, 0);
+        defineDefaultProperty(QStringLiteral("scale"), method_scale, 0);
+        defineDefaultProperty(QStringLiteral("drawImage"), method_drawImage, 0);
+        defineDefaultProperty(QStringLiteral("transform"), method_transform, 0);
+        defineDefaultProperty(QStringLiteral("fillText"), method_fillText, 0);
+        defineDefaultProperty(QStringLiteral("strokeText"), method_strokeText, 0);
+        defineDefaultProperty(QStringLiteral("translate"), method_translate, 0);
+        defineDefaultProperty(QStringLiteral("createRadialGradient"), method_createRadialGradient, 0);
+        defineDefaultProperty(QStringLiteral("shear"), method_shear, 0);
+        defineDefaultProperty(QStringLiteral("isPointInPath"), method_isPointInPath, 0);
+        defineDefaultProperty(QStringLiteral("bezierCurveTo"), method_bezierCurveTo, 0);
+        defineDefaultProperty(QStringLiteral("resetTransform"), method_resetTransform, 0);
+        defineDefaultProperty(QStringLiteral("arcTo"), method_arcTo, 0);
+        defineDefaultProperty(QStringLiteral("fillRect"), method_fillRect, 0);
+        defineDefaultProperty(QStringLiteral("createConicalGradient"), method_createConicalGradient, 0);
+        defineDefaultProperty(QStringLiteral("drawFocusRing"), method_drawFocusRing, 0);
+        defineDefaultProperty(QStringLiteral("beginPath"), method_beginPath, 0);
+        defineDefaultProperty(QStringLiteral("clearRect"), method_clearRect, 0);
+        defineDefaultProperty(QStringLiteral("rect"), method_rect, 0);
+        defineDefaultProperty(QStringLiteral("reset"), method_reset, 0);
+        defineDefaultProperty(QStringLiteral("rotate"), method_rotate, 0);
+        defineDefaultProperty(QStringLiteral("setCaretSelectionRect"), method_setCaretSelectionRect, 0);
+        defineDefaultProperty(QStringLiteral("putImageData"), method_putImageData, 0);
+        defineDefaultProperty(QStringLiteral("getImageData"), method_getImageData, 0);
+        defineDefaultProperty(QStringLiteral("createLinearGradient"), method_createLinearGradient, 0);
+        defineDefaultProperty(QStringLiteral("strokeRect"), method_strokeRect, 0);
+        defineDefaultProperty(QStringLiteral("closePath"), method_closePath, 0);
+        defineAccessorProperty(QStringLiteral("canvas"), QQuickJSContext2DPrototype::method_get_canvas, 0);
     }
 
     static QV4::ReturnedValue method_get_canvas(QV4::SimpleCallContext *ctx);
@@ -891,9 +891,9 @@ struct QQuickJSContext2DImageData : public QV4::Object
     {
         vtbl = &static_vtbl;
 
-        defineAccessorProperty(engine, QStringLiteral("width"), method_get_width, 0);
-        defineAccessorProperty(engine, QStringLiteral("height"), method_get_height, 0);
-        defineAccessorProperty(engine, QStringLiteral("data"), method_get_data, 0);
+        defineAccessorProperty(QStringLiteral("width"), method_get_width, 0);
+        defineAccessorProperty(QStringLiteral("height"), method_get_height, 0);
+        defineAccessorProperty(QStringLiteral("data"), method_get_data, 0);
     }
 
     static QV4::ReturnedValue method_get_width(QV4::SimpleCallContext *ctx);
@@ -4155,27 +4155,27 @@ QQuickContext2DEngineData::QQuickContext2DEngineData(QV8Engine *engine)
     QV4::Scope scope(v4);
 
     QV4::Scoped<QV4::Object> proto(scope, new (v4->memoryManager) QQuickJSContext2DPrototype(v4));
-    proto->defineAccessorProperty(v4, QStringLiteral("strokeStyle"), QQuickJSContext2D::method_get_strokeStyle, QQuickJSContext2D::method_set_strokeStyle);
-    proto->defineAccessorProperty(v4, QStringLiteral("font"), QQuickJSContext2D::method_get_font, QQuickJSContext2D::method_set_font);
-    proto->defineAccessorProperty(v4, QStringLiteral("fillRule"), QQuickJSContext2D::method_get_fillRule, QQuickJSContext2D::method_set_fillRule);
-    proto->defineAccessorProperty(v4, QStringLiteral("globalAlpha"), QQuickJSContext2D::method_get_globalAlpha, QQuickJSContext2D::method_set_globalAlpha);
-    proto->defineAccessorProperty(v4, QStringLiteral("lineCap"), QQuickJSContext2D::method_get_lineCap, QQuickJSContext2D::method_set_lineCap);
-    proto->defineAccessorProperty(v4, QStringLiteral("shadowOffsetX"), QQuickJSContext2D::method_get_shadowOffsetX, QQuickJSContext2D::method_set_shadowOffsetX);
-    proto->defineAccessorProperty(v4, QStringLiteral("shadowOffsetY"), QQuickJSContext2D::method_get_shadowOffsetY, QQuickJSContext2D::method_set_shadowOffsetY);
-    proto->defineAccessorProperty(v4, QStringLiteral("globalCompositeOperation"), QQuickJSContext2D::method_get_globalCompositeOperation, QQuickJSContext2D::method_set_globalCompositeOperation);
-    proto->defineAccessorProperty(v4, QStringLiteral("miterLimit"), QQuickJSContext2D::method_get_miterLimit, QQuickJSContext2D::method_set_miterLimit);
-    proto->defineAccessorProperty(v4, QStringLiteral("fillStyle"), QQuickJSContext2D::method_get_fillStyle, QQuickJSContext2D::method_set_fillStyle);
-    proto->defineAccessorProperty(v4, QStringLiteral("shadowColor"), QQuickJSContext2D::method_get_shadowColor, QQuickJSContext2D::method_set_shadowColor);
-    proto->defineAccessorProperty(v4, QStringLiteral("textBaseline"), QQuickJSContext2D::method_get_textBaseline, QQuickJSContext2D::method_set_textBaseline);
-    proto->defineAccessorProperty(v4, QStringLiteral("path"), QQuickJSContext2D::method_get_path, QQuickJSContext2D::method_set_path);
-    proto->defineAccessorProperty(v4, QStringLiteral("lineJoin"), QQuickJSContext2D::method_get_lineJoin, QQuickJSContext2D::method_set_lineJoin);
-    proto->defineAccessorProperty(v4, QStringLiteral("lineWidth"), QQuickJSContext2D::method_get_lineWidth, QQuickJSContext2D::method_set_lineWidth);
-    proto->defineAccessorProperty(v4, QStringLiteral("textAlign"), QQuickJSContext2D::method_get_textAlign, QQuickJSContext2D::method_set_textAlign);
-    proto->defineAccessorProperty(v4, QStringLiteral("shadowBlur"), QQuickJSContext2D::method_get_shadowBlur, QQuickJSContext2D::method_set_shadowBlur);
+    proto->defineAccessorProperty(QStringLiteral("strokeStyle"), QQuickJSContext2D::method_get_strokeStyle, QQuickJSContext2D::method_set_strokeStyle);
+    proto->defineAccessorProperty(QStringLiteral("font"), QQuickJSContext2D::method_get_font, QQuickJSContext2D::method_set_font);
+    proto->defineAccessorProperty(QStringLiteral("fillRule"), QQuickJSContext2D::method_get_fillRule, QQuickJSContext2D::method_set_fillRule);
+    proto->defineAccessorProperty(QStringLiteral("globalAlpha"), QQuickJSContext2D::method_get_globalAlpha, QQuickJSContext2D::method_set_globalAlpha);
+    proto->defineAccessorProperty(QStringLiteral("lineCap"), QQuickJSContext2D::method_get_lineCap, QQuickJSContext2D::method_set_lineCap);
+    proto->defineAccessorProperty(QStringLiteral("shadowOffsetX"), QQuickJSContext2D::method_get_shadowOffsetX, QQuickJSContext2D::method_set_shadowOffsetX);
+    proto->defineAccessorProperty(QStringLiteral("shadowOffsetY"), QQuickJSContext2D::method_get_shadowOffsetY, QQuickJSContext2D::method_set_shadowOffsetY);
+    proto->defineAccessorProperty(QStringLiteral("globalCompositeOperation"), QQuickJSContext2D::method_get_globalCompositeOperation, QQuickJSContext2D::method_set_globalCompositeOperation);
+    proto->defineAccessorProperty(QStringLiteral("miterLimit"), QQuickJSContext2D::method_get_miterLimit, QQuickJSContext2D::method_set_miterLimit);
+    proto->defineAccessorProperty(QStringLiteral("fillStyle"), QQuickJSContext2D::method_get_fillStyle, QQuickJSContext2D::method_set_fillStyle);
+    proto->defineAccessorProperty(QStringLiteral("shadowColor"), QQuickJSContext2D::method_get_shadowColor, QQuickJSContext2D::method_set_shadowColor);
+    proto->defineAccessorProperty(QStringLiteral("textBaseline"), QQuickJSContext2D::method_get_textBaseline, QQuickJSContext2D::method_set_textBaseline);
+    proto->defineAccessorProperty(QStringLiteral("path"), QQuickJSContext2D::method_get_path, QQuickJSContext2D::method_set_path);
+    proto->defineAccessorProperty(QStringLiteral("lineJoin"), QQuickJSContext2D::method_get_lineJoin, QQuickJSContext2D::method_set_lineJoin);
+    proto->defineAccessorProperty(QStringLiteral("lineWidth"), QQuickJSContext2D::method_get_lineWidth, QQuickJSContext2D::method_set_lineWidth);
+    proto->defineAccessorProperty(QStringLiteral("textAlign"), QQuickJSContext2D::method_get_textAlign, QQuickJSContext2D::method_set_textAlign);
+    proto->defineAccessorProperty(QStringLiteral("shadowBlur"), QQuickJSContext2D::method_get_shadowBlur, QQuickJSContext2D::method_set_shadowBlur);
     contextPrototype = proto;
 
     proto = v4->newObject();
-    proto->defineDefaultProperty(v4, QStringLiteral("addColorStop"), QQuickContext2DStyle::gradient_proto_addColorStop, 0);
+    proto->defineDefaultProperty(QStringLiteral("addColorStop"), QQuickContext2DStyle::gradient_proto_addColorStop, 0);
     gradientProto = proto;
 
     proto = v4->newObject();