14 files changed, 247 insertions, 256 deletions

diff --git a/src/qml/jsruntime/qv4arrayobject.cpp b/src/qml/jsruntime/qv4arrayobject.cpp
index 6fba53a563..838c541900 100644
--- a/src/qml/jsruntime/qv4arrayobject.cpp
+++ b/src/qml/jsruntime/qv4arrayobject.cpp
@@ -84,11 +84,6 @@ ReturnedValue ArrayCtor::call(Managed *that, CallData *callData)
     return construct(that, callData);
 }
 
-ArrayPrototype::ArrayPrototype(InternalClass *ic)
-    : ArrayObject(ic)
-{
-}
-
 void ArrayPrototype::init(ExecutionEngine *engine, Object *ctor)
 {
     Scope scope(engine);
diff --git a/src/qml/jsruntime/qv4arrayobject_p.h b/src/qml/jsruntime/qv4arrayobject_p.h
index 97cffb398d..7f983b997d 100644
--- a/src/qml/jsruntime/qv4arrayobject_p.h
+++ b/src/qml/jsruntime/qv4arrayobject_p.h
@@ -63,8 +63,6 @@ struct ArrayCtor: FunctionObject
 
 struct ArrayPrototype: ArrayObject
 {
-    ArrayPrototype(InternalClass *ic);
-
     void init(ExecutionEngine *engine, Object *ctor);
 
     static ReturnedValue method_isArray(CallContext *ctx);
diff --git a/src/qml/jsruntime/qv4booleanobject_p.h b/src/qml/jsruntime/qv4booleanobject_p.h
index 3ff0569bc2..cbcbaabf51 100644
--- a/src/qml/jsruntime/qv4booleanobject_p.h
+++ b/src/qml/jsruntime/qv4booleanobject_p.h
@@ -63,7 +63,6 @@ struct BooleanCtor: FunctionObject
 
 struct BooleanPrototype: BooleanObject
 {
-    BooleanPrototype(InternalClass *ic): BooleanObject(ic) {}
     void init(ExecutionEngine *engine, Object *ctor);
 
     static ReturnedValue method_toString(CallContext *ctx);
diff --git a/src/qml/jsruntime/qv4dateobject.cpp b/src/qml/jsruntime/qv4dateobject.cpp
index e14523deb9..b7fac9432f 100644
--- a/src/qml/jsruntime/qv4dateobject.cpp
+++ b/src/qml/jsruntime/qv4dateobject.cpp
@@ -643,11 +643,11 @@ static double getLocalTZA()
 
 DEFINE_OBJECT_VTABLE(DateObject);
 
-DateObject::DateObject(ExecutionEngine *engine, const QDateTime &date)
-    : Object(engine->dateClass)
+DateObject::Data::Data(ExecutionEngine *engine, const QDateTime &date)
+    : Object::Data(engine->dateClass)
 {
     setVTable(staticVTable());
-    d()->value.setDouble(date.isValid() ? date.toMSecsSinceEpoch() : qSNaN());
+    value.setDouble(date.isValid() ? date.toMSecsSinceEpoch() : qSNaN());
 }
 
 QDateTime DateObject::toQDateTime() const
diff --git a/src/qml/jsruntime/qv4dateobject_p.h b/src/qml/jsruntime/qv4dateobject_p.h
index 3e8bdc3edf..d285680268 100644
--- a/src/qml/jsruntime/qv4dateobject_p.h
+++ b/src/qml/jsruntime/qv4dateobject_p.h
@@ -53,6 +53,18 @@ namespace QV4 {
 
 struct DateObject: Object {
     struct Data : Object::Data {
+        Data(ExecutionEngine *engine, const ValueRef date)
+            : Object::Data(engine->dateClass)
+        {
+            value = date;
+        }
+        Data(ExecutionEngine *engine, const QDateTime &date);
+        Data(InternalClass *ic)
+            : Object::Data(ic)
+        {
+            Q_ASSERT(internalClass->vtable == staticVTable());
+            value = Primitive::fromDouble(qSNaN());
+        }
         Value value;
     };
     struct {
@@ -66,20 +78,7 @@ struct DateObject: Object {
     Value &date() { return d()->value; }
     void setDate(const ValueRef date) { d()->value = date; }
 
-    DateObject(ExecutionEngine *engine, const ValueRef date)
-        : Object(engine->dateClass)
-    {
-        setDate(date);
-    }
-    DateObject(ExecutionEngine *engine, const QDateTime &date);
-
     QDateTime toQDateTime() const;
-
-protected:
-    DateObject(InternalClass *ic): Object(ic) {
-        Q_ASSERT(internalClass()->vtable == staticVTable());
-        d()->value = Primitive::fromDouble(qSNaN());
-    }
 };
 
 struct DateCtor: FunctionObject
@@ -95,7 +94,6 @@ struct DateCtor: FunctionObject
 
 struct DatePrototype: DateObject
 {
-    DatePrototype(InternalClass *ic): DateObject(ic) {}
     void init(ExecutionEngine *engine, Object *ctor);
 
     static double getThisDate(ExecutionContext *ctx);
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 863f4b22f7..965be8ed1f 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -258,13 +258,13 @@ ExecutionEngine::ExecutionEngine(EvalISelFactory *factory)
 
     memberDataClass = InternalClass::create(this, MemberData::staticVTable(), 0);
 
-    ObjectPrototype *objectPrototype = new (memoryManager) ObjectPrototype(InternalClass::create(this, ObjectPrototype::staticVTable(), 0));
+    ScopedObject objectPrototype(scope, new (this) ObjectPrototype::Data(InternalClass::create(this, ObjectPrototype::staticVTable(), 0)));
     objectClass = InternalClass::create(this, Object::staticVTable(), objectPrototype);
     Q_ASSERT(objectClass->vtable == Object::staticVTable());
 
     arrayClass = InternalClass::create(this, ArrayObject::staticVTable(), objectPrototype);
     arrayClass = arrayClass->addMember(id_length, Attr_NotConfigurable|Attr_NotEnumerable);
-    ArrayPrototype *arrayPrototype = new (memoryManager) ArrayPrototype(arrayClass);
+    ScopedObject arrayPrototype(scope, new (this) ArrayPrototype::Data(arrayClass));
     arrayClass = arrayClass->changePrototype(arrayPrototype);
 
     simpleArrayDataClass = InternalClass::create(this, SimpleArrayData::staticVTable(), 0);
@@ -279,23 +279,23 @@ ExecutionEngine::ExecutionEngine(EvalISelFactory *factory)
 
     initRootContext();
 
-    StringPrototype *stringPrototype = new (memoryManager) StringPrototype(InternalClass::create(this, StringPrototype::staticVTable(), objectPrototype));
+    ScopedObject stringPrototype(scope, new (this) StringPrototype::Data(InternalClass::create(this, StringPrototype::staticVTable(), objectPrototype)));
     stringObjectClass = InternalClass::create(this, String::staticVTable(), stringPrototype);
 
-    NumberPrototype *numberPrototype = new (memoryManager) NumberPrototype(InternalClass::create(this, NumberPrototype::staticVTable(), objectPrototype));
+    ScopedObject numberPrototype(scope, new (this) NumberPrototype::Data(InternalClass::create(this, NumberPrototype::staticVTable(), objectPrototype)));
     numberClass = InternalClass::create(this, NumberObject::staticVTable(), numberPrototype);
 
-    BooleanPrototype *booleanPrototype = new (memoryManager) BooleanPrototype(InternalClass::create(this, BooleanPrototype::staticVTable(), objectPrototype));
+    ScopedObject booleanPrototype(scope, new (this) BooleanPrototype::Data(InternalClass::create(this, BooleanPrototype::staticVTable(), objectPrototype)));
     booleanClass = InternalClass::create(this, BooleanObject::staticVTable(), booleanPrototype);
 
-    DatePrototype *datePrototype = new (memoryManager) DatePrototype(InternalClass::create(this, DatePrototype::staticVTable(), objectPrototype));
+    ScopedObject datePrototype(scope, new (this) DatePrototype::Data(InternalClass::create(this, DatePrototype::staticVTable(), objectPrototype)));
     dateClass = InternalClass::create(this, DateObject::staticVTable(), datePrototype);
 
     InternalClass *functionProtoClass = InternalClass::create(this, FunctionObject::staticVTable(), objectPrototype);
     uint index;
     functionProtoClass = functionProtoClass->addMember(id_prototype, Attr_NotEnumerable, &index);
     Q_ASSERT(index == FunctionObject::Index_Prototype);
-    Scoped<FunctionPrototype> functionPrototype(scope, new (this) FunctionPrototype::Data(functionProtoClass));
+    ScopedObject functionPrototype(scope, new (this) FunctionPrototype::Data(functionProtoClass));
     functionClass = InternalClass::create(this, FunctionObject::staticVTable(), functionPrototype);
     functionClass = functionClass->addMember(id_prototype, Attr_NotEnumerable|Attr_NotConfigurable, &index);
     Q_ASSERT(index == FunctionObject::Index_Prototype);
@@ -309,22 +309,22 @@ ExecutionEngine::ExecutionEngine(EvalISelFactory *factory)
     regExpExecArrayClass = regExpExecArrayClass->addMember(id_input, Attr_Data, &index);
     Q_ASSERT(index == RegExpObject::Index_ArrayInput);
 
-    ErrorPrototype *errorPrototype = new (memoryManager) ErrorPrototype(InternalClass::create(this, ErrorObject::staticVTable(), objectPrototype));
+    ScopedObject errorPrototype(scope, new (this) ErrorPrototype::Data(InternalClass::create(this, ErrorObject::staticVTable(), objectPrototype)));
     errorClass = InternalClass::create(this, ErrorObject::staticVTable(), errorPrototype);
-    EvalErrorPrototype *evalErrorPrototype = new (memoryManager) EvalErrorPrototype(errorClass);
+    ScopedObject evalErrorPrototype(scope, new (this) EvalErrorPrototype::Data(errorClass));
     evalErrorClass = InternalClass::create(this, EvalErrorObject::staticVTable(), evalErrorPrototype);
-    RangeErrorPrototype *rangeErrorPrototype = new (memoryManager) RangeErrorPrototype(errorClass);
+    ScopedObject rangeErrorPrototype(scope, new (this) RangeErrorPrototype::Data(errorClass));
     rangeErrorClass = InternalClass::create(this, RangeErrorObject::staticVTable(), rangeErrorPrototype);
-    ReferenceErrorPrototype *referenceErrorPrototype = new (memoryManager) ReferenceErrorPrototype(errorClass);
+    ScopedObject referenceErrorPrototype(scope, new (this) ReferenceErrorPrototype::Data(errorClass));
     referenceErrorClass = InternalClass::create(this, ReferenceErrorObject::staticVTable(), referenceErrorPrototype);
-    SyntaxErrorPrototype *syntaxErrorPrototype = new (memoryManager) SyntaxErrorPrototype(errorClass);
+    ScopedObject syntaxErrorPrototype(scope, new (this) SyntaxErrorPrototype::Data(errorClass));
     syntaxErrorClass = InternalClass::create(this, SyntaxErrorObject::staticVTable(), syntaxErrorPrototype);
-    TypeErrorPrototype *typeErrorPrototype = new (memoryManager) TypeErrorPrototype(errorClass);
+    ScopedObject typeErrorPrototype(scope, new (this) TypeErrorPrototype::Data(errorClass));
     typeErrorClass = InternalClass::create(this, TypeErrorObject::staticVTable(), typeErrorPrototype);
-    URIErrorPrototype *uRIErrorPrototype = new (memoryManager) URIErrorPrototype(errorClass);
+    ScopedObject uRIErrorPrototype(scope, new (this) URIErrorPrototype::Data(errorClass));
     uriErrorClass = InternalClass::create(this, URIErrorObject::staticVTable(), uRIErrorPrototype);
 
-    VariantPrototype *variantPrototype = new (memoryManager) VariantPrototype(InternalClass::create(this, VariantPrototype::staticVTable(), objectPrototype));
+    ScopedObject variantPrototype(scope, new (memoryManager) VariantPrototype(InternalClass::create(this, VariantPrototype::staticVTable(), objectPrototype)));
     variantClass = InternalClass::create(this, VariantObject::staticVTable(), variantPrototype);
     Q_ASSERT(variantClass->prototype == variantPrototype);
     Q_ASSERT(variantPrototype->internalClass()->prototype == objectPrototype);
@@ -347,23 +347,23 @@ ExecutionEngine::ExecutionEngine(EvalISelFactory *factory)
     typeErrorCtor = static_cast<HeapObject *>(new (this) TypeErrorCtor::Data(rootContext));
     uRIErrorCtor = static_cast<HeapObject *>(new (this) URIErrorCtor::Data(rootContext));
 
-    objectPrototype->init(this, objectCtor.asObject());
-    stringPrototype->init(this, stringCtor.asObject());
-    numberPrototype->init(this, numberCtor.asObject());
-    booleanPrototype->init(this, booleanCtor.asObject());
-    arrayPrototype->init(this, arrayCtor.asObject());
-    datePrototype->init(this, dateCtor.asObject());
-    functionPrototype->init(this, functionCtor.asObject());
-    regExpPrototype->init(this, regExpCtor.asObject());
-    errorPrototype->init(this, errorCtor.asObject());
-    evalErrorPrototype->init(this, evalErrorCtor.asObject());
-    rangeErrorPrototype->init(this, rangeErrorCtor.asObject());
-    referenceErrorPrototype->init(this, referenceErrorCtor.asObject());
-    syntaxErrorPrototype->init(this, syntaxErrorCtor.asObject());
-    typeErrorPrototype->init(this, typeErrorCtor.asObject());
-    uRIErrorPrototype->init(this, uRIErrorCtor.asObject());
-
-    variantPrototype->init();
+    static_cast<ObjectPrototype *>(objectPrototype.getPointer())->init(this, objectCtor.asObject());
+    static_cast<StringPrototype *>(stringPrototype.getPointer())->init(this, stringCtor.asObject());
+    static_cast<NumberPrototype *>(numberPrototype.getPointer())->init(this, numberCtor.asObject());
+    static_cast<BooleanPrototype *>(booleanPrototype.getPointer())->init(this, booleanCtor.asObject());
+    static_cast<ArrayPrototype *>(arrayPrototype.getPointer())->init(this, arrayCtor.asObject());
+    static_cast<DatePrototype *>(datePrototype.getPointer())->init(this, dateCtor.asObject());
+    static_cast<FunctionPrototype *>(functionPrototype.getPointer())->init(this, functionCtor.asObject());
+    static_cast<RegExpPrototype *>(regExpPrototype.getPointer())->init(this, regExpCtor.asObject());
+    static_cast<ErrorPrototype *>(errorPrototype.getPointer())->init(this, errorCtor.asObject());
+    static_cast<EvalErrorPrototype *>(evalErrorPrototype.getPointer())->init(this, evalErrorCtor.asObject());
+    static_cast<RangeErrorPrototype *>(rangeErrorPrototype.getPointer())->init(this, rangeErrorCtor.asObject());
+    static_cast<ReferenceErrorPrototype *>(referenceErrorPrototype.getPointer())->init(this, referenceErrorCtor.asObject());
+    static_cast<SyntaxErrorPrototype *>(syntaxErrorPrototype.getPointer())->init(this, syntaxErrorCtor.asObject());
+    static_cast<TypeErrorPrototype *>(typeErrorPrototype.getPointer())->init(this, typeErrorCtor.asObject());
+    static_cast<URIErrorPrototype *>(uRIErrorPrototype.getPointer())->init(this, uRIErrorCtor.asObject());
+
+    static_cast<VariantPrototype *>(variantPrototype.getPointer())->init();
     static_cast<SequencePrototype *>(sequencePrototype.managed())->init();
 
     //
@@ -507,29 +507,31 @@ String *ExecutionEngine::newIdentifier(const QString &text)
 
 Returned<Object> *ExecutionEngine::newStringObject(const ValueRef value)
 {
-    StringObject *object = new (memoryManager) StringObject(this, value);
+    Scope scope(this);
+    Scoped<StringObject> object(scope, new (this) StringObject::Data(this, value));
     return object->asReturned<Object>();
 }
 
 Returned<Object> *ExecutionEngine::newNumberObject(const ValueRef value)
 {
-    NumberObject *object = new (memoryManager) NumberObject(this, value);
+    Scope scope(this);
+    Scoped<NumberObject> object(scope, new (this) NumberObject::Data(this, value));
     return object->asReturned<Object>();
 }
 
 Returned<Object> *ExecutionEngine::newBooleanObject(const ValueRef value)
 {
-    Object *object = new (memoryManager) BooleanObject(this, value);
+    Scope scope(this);
+    ScopedObject object(scope, new (this) BooleanObject::Data(this, value));
     return object->asReturned<Object>();
 }
 
 Returned<ArrayObject> *ExecutionEngine::newArrayObject(int count)
 {
-    ArrayObject *object = new (memoryManager) ArrayObject(this);
+    Scope scope(this);
+    ScopedArrayObject object(scope, new (this) ArrayObject::Data(this));
 
     if (count) {
-        Scope scope(this);
-        ScopedValue protectArray(scope, object);
         if (count < 0x1000)
             object->arrayReserve(count);
         object->setArrayLengthUnchecked(count);
@@ -539,26 +541,30 @@ Returned<ArrayObject> *ExecutionEngine::newArrayObject(int count)
 
 Returned<ArrayObject> *ExecutionEngine::newArrayObject(const QStringList &list)
 {
-    ArrayObject *object = new (memoryManager) ArrayObject(this, list);
+    Scope scope(this);
+    ScopedArrayObject object(scope, new (this) ArrayObject::Data(this, list));
     return object->asReturned<ArrayObject>();
 }
 
 Returned<ArrayObject> *ExecutionEngine::newArrayObject(InternalClass *ic)
 {
-    ArrayObject *object = new (memoryManager) ArrayObject(ic);
+    Scope scope(this);
+    ScopedArrayObject object(scope, new (this) ArrayObject::Data(ic));
     return object->asReturned<ArrayObject>();
 }
 
 
 Returned<DateObject> *ExecutionEngine::newDateObject(const ValueRef value)
 {
-    DateObject *object = new (memoryManager) DateObject(this, value);
+    Scope scope(this);
+    Scoped<DateObject> object(scope, new (this) DateObject::Data(this, value));
     return object->asReturned<DateObject>();
 }
 
 Returned<DateObject> *ExecutionEngine::newDateObject(const QDateTime &dt)
 {
-    DateObject *object = new (memoryManager) DateObject(this, dt);
+    Scope scope(this);
+    Scoped<DateObject> object(scope, new (this) DateObject::Data(this, dt));
     return object->asReturned<DateObject>();
 }
 
@@ -593,7 +599,8 @@ Returned<RegExpObject> *ExecutionEngine::newRegExpObject(const QRegExp &re)
 
 Returned<Object> *ExecutionEngine::newErrorObject(const ValueRef value)
 {
-    ErrorObject *object = new (memoryManager) ErrorObject(errorClass, value);
+    Scope scope(this);
+    ScopedObject object(scope, new (this) ErrorObject::Data(errorClass, value));
     return object->asReturned<Object>();
 }
 
@@ -601,45 +608,51 @@ Returned<Object> *ExecutionEngine::newSyntaxErrorObject(const QString &message)
 {
     Scope scope(this);
     ScopedString s(scope, newString(message));
-    Object *error = new (memoryManager) SyntaxErrorObject(this, s);
+    ScopedObject error(scope, new (this) SyntaxErrorObject::Data(this, s));
     return error->asReturned<Object>();
 }
 
 Returned<Object> *ExecutionEngine::newSyntaxErrorObject(const QString &message, const QString &fileName, int line, int column)
 {
-    Object *error = new (memoryManager) SyntaxErrorObject(this, message, fileName, line, column);
+    Scope scope(this);
+    ScopedObject error(scope, new (this) SyntaxErrorObject::Data(this, message, fileName, line, column));
     return error->asReturned<Object>();
 }
 
 
 Returned<Object> *ExecutionEngine::newReferenceErrorObject(const QString &message)
 {
-    Object *o = new (memoryManager) ReferenceErrorObject(this, message);
+    Scope scope(this);
+    ScopedObject o(scope, new (this) ReferenceErrorObject::Data(this, message));
     return o->asReturned<Object>();
 }
 
 Returned<Object> *ExecutionEngine::newReferenceErrorObject(const QString &message, const QString &fileName, int lineNumber, int columnNumber)
 {
-    Object *o = new (memoryManager) ReferenceErrorObject(this, message, fileName, lineNumber, columnNumber);
+    Scope scope(this);
+    ScopedObject o(scope, new (this) ReferenceErrorObject::Data(this, message, fileName, lineNumber, columnNumber));
     return o->asReturned<Object>();
 }
 
 
 Returned<Object> *ExecutionEngine::newTypeErrorObject(const QString &message)
 {
-    Object *o = new (memoryManager) TypeErrorObject(this, message);
+    Scope scope(this);
+    ScopedObject o(scope, new (this) TypeErrorObject::Data(this, message));
     return o->asReturned<Object>();
 }
 
 Returned<Object> *ExecutionEngine::newRangeErrorObject(const QString &message)
 {
-    Object *o = new (memoryManager) RangeErrorObject(this, message);
+    Scope scope(this);
+    ScopedObject o(scope, new (this) RangeErrorObject::Data(this, message));
     return o->asReturned<Object>();
 }
 
 Returned<Object> *ExecutionEngine::newURIErrorObject(const ValueRef message)
 {
-    Object *o = new (memoryManager) URIErrorObject(this, message);
+    Scope scope(this);
+    ScopedObject o(scope, new (this) URIErrorObject::Data(this, message));
     return o->asReturned<Object>();
 }
 
diff --git a/src/qml/jsruntime/qv4errorobject.cpp b/src/qml/jsruntime/qv4errorobject.cpp
index 03ad40e307..83ef60efc3 100644
--- a/src/qml/jsruntime/qv4errorobject.cpp
+++ b/src/qml/jsruntime/qv4errorobject.cpp
@@ -71,86 +71,86 @@
 
 using namespace QV4;
 
-ErrorObject::ErrorObject(InternalClass *ic)
-    : Object(ic)
+ErrorObject::Data::Data(InternalClass *ic)
+    : Object::Data(ic)
 {
-    Scope scope(engine());
-    ScopedValue protectThis(scope, this);
+    Scope scope(ic->engine);
+    Scoped<ErrorObject> e(scope, this);
 
-    ScopedString s(scope, ic->engine->newString(QStringLiteral("Error")));
-    defineDefaultProperty(QStringLiteral("name"), s);
+    ScopedString s(scope, scope.engine->newString(QStringLiteral("Error")));
+    e->defineDefaultProperty(QStringLiteral("name"), s);
 }
 
-ErrorObject::ErrorObject(InternalClass *ic, const ValueRef message, ErrorType t)
-    : Object(ic)
+ErrorObject::Data::Data(InternalClass *ic, const ValueRef message, ErrorType t)
+    : Object::Data(ic)
 {
-    setSubtype(t);
+    subtype = t;
 
-    Scope scope(engine());
-    ScopedValue protectThis(scope, this);
+    Scope scope(ic->engine);
+    Scoped<ErrorObject> e(scope, this);
 
-    defineAccessorProperty(QStringLiteral("stack"), ErrorObject::method_get_stack, 0);
+    e->defineAccessorProperty(QStringLiteral("stack"), ErrorObject::method_get_stack, 0);
 
     if (!message->isUndefined())
-        defineDefaultProperty(QStringLiteral("message"), message);
+        e->defineDefaultProperty(QStringLiteral("message"), message);
     ScopedString s(scope);
-    defineDefaultProperty(QStringLiteral("name"), (s = ic->engine->newString(className())));
+    e->defineDefaultProperty(QStringLiteral("name"), (s = scope.engine->newString(e->className())));
 
-    d()->stackTrace = ic->engine->stackTrace();
-    if (!d()->stackTrace.isEmpty()) {
-        defineDefaultProperty(QStringLiteral("fileName"), (s = ic->engine->newString(d()->stackTrace.at(0).source)));
-        defineDefaultProperty(QStringLiteral("lineNumber"), Primitive::fromInt32(d()->stackTrace.at(0).line));
+    e->d()->stackTrace = scope.engine->stackTrace();
+    if (!e->d()->stackTrace.isEmpty()) {
+        e->defineDefaultProperty(QStringLiteral("fileName"), (s = scope.engine->newString(e->d()->stackTrace.at(0).source)));
+        e->defineDefaultProperty(QStringLiteral("lineNumber"), Primitive::fromInt32(e->d()->stackTrace.at(0).line));
     }
 }
 
-ErrorObject::ErrorObject(InternalClass *ic, const QString &message, ErrorObject::ErrorType t)
-    : Object(ic)
+ErrorObject::Data::Data(InternalClass *ic, const QString &message, ErrorObject::ErrorType t)
+    : Object::Data(ic)
 {
-    setSubtype(t);
+    subtype = t;
 
-    Scope scope(engine());
-    ScopedValue protectThis(scope, this);
+    Scope scope(ic->engine);
+    Scoped<ErrorObject> e(scope, this);
     ScopedString s(scope);
 
-    defineAccessorProperty(QStringLiteral("stack"), ErrorObject::method_get_stack, 0);
+    e->defineAccessorProperty(QStringLiteral("stack"), ErrorObject::method_get_stack, 0);
 
-    ScopedValue v(scope, ic->engine->newString(message));
-    defineDefaultProperty(QStringLiteral("message"), v);
-    defineDefaultProperty(QStringLiteral("name"), (s = ic->engine->newString(className())));
+    ScopedValue v(scope, scope.engine->newString(message));
+    e->defineDefaultProperty(QStringLiteral("message"), v);
+    e->defineDefaultProperty(QStringLiteral("name"), (s = scope.engine->newString(e->className())));
 
-    d()->stackTrace = ic->engine->stackTrace();
-    if (!d()->stackTrace.isEmpty()) {
-        defineDefaultProperty(QStringLiteral("fileName"), (s = ic->engine->newString(d()->stackTrace.at(0).source)));
-        defineDefaultProperty(QStringLiteral("lineNumber"), Primitive::fromInt32(d()->stackTrace.at(0).line));
+    e->d()->stackTrace = scope.engine->stackTrace();
+    if (!e->d()->stackTrace.isEmpty()) {
+        e->defineDefaultProperty(QStringLiteral("fileName"), (s = scope.engine->newString(e->d()->stackTrace.at(0).source)));
+        e->defineDefaultProperty(QStringLiteral("lineNumber"), Primitive::fromInt32(e->d()->stackTrace.at(0).line));
     }
 }
 
-ErrorObject::ErrorObject(InternalClass *ic, const QString &message, const QString &fileName, int line, int column, ErrorObject::ErrorType t)
-    : Object(ic)
+ErrorObject::Data::Data(InternalClass *ic, const QString &message, const QString &fileName, int line, int column, ErrorObject::ErrorType t)
+    : Object::Data(ic)
 {
-    setSubtype(t);
+    subtype = t;
 
-    Scope scope(engine());
-    ScopedValue protectThis(scope, this);
+    Scope scope(ic->engine);
+    Scoped<ErrorObject> e(scope, this);
     ScopedString s(scope);
 
-    defineAccessorProperty(QStringLiteral("stack"), ErrorObject::method_get_stack, 0);
-    defineDefaultProperty(QStringLiteral("name"), (s = ic->engine->newString(className())));
+    e->defineAccessorProperty(QStringLiteral("stack"), ErrorObject::method_get_stack, 0);
+    e->defineDefaultProperty(QStringLiteral("name"), (s = scope.engine->newString(e->className())));
 
-    d()->stackTrace = ic->engine->stackTrace();
+    e->d()->stackTrace = scope.engine->stackTrace();
     StackFrame frame;
     frame.source = fileName;
     frame.line = line;
     frame.column = column;
-    d()->stackTrace.prepend(frame);
+    e->d()->stackTrace.prepend(frame);
 
-    if (!d()->stackTrace.isEmpty()) {
-        defineDefaultProperty(QStringLiteral("fileName"), (s = ic->engine->newString(d()->stackTrace.at(0).source)));
-        defineDefaultProperty(QStringLiteral("lineNumber"), Primitive::fromInt32(d()->stackTrace.at(0).line));
+    if (!e->d()->stackTrace.isEmpty()) {
+        e->defineDefaultProperty(QStringLiteral("fileName"), (s = scope.engine->newString(e->d()->stackTrace.at(0).source)));
+        e->defineDefaultProperty(QStringLiteral("lineNumber"), Primitive::fromInt32(e->d()->stackTrace.at(0).line));
     }
 
-    ScopedValue v(scope, ic->engine->newString(message));
-    defineDefaultProperty(QStringLiteral("message"), v);
+    ScopedValue v(scope, scope.engine->newString(message));
+    e->defineDefaultProperty(QStringLiteral("message"), v);
 }
 
 ReturnedValue ErrorObject::method_get_stack(CallContext *ctx)
@@ -190,58 +190,58 @@ DEFINE_OBJECT_VTABLE(ErrorObject);
 
 DEFINE_OBJECT_VTABLE(SyntaxErrorObject);
 
-SyntaxErrorObject::SyntaxErrorObject(ExecutionEngine *engine, const ValueRef msg)
-    : ErrorObject(engine->syntaxErrorClass, msg, SyntaxError)
+SyntaxErrorObject::Data::Data(ExecutionEngine *engine, const ValueRef msg)
+    : ErrorObject::Data(engine->syntaxErrorClass, msg, SyntaxError)
 {
 }
 
-SyntaxErrorObject::SyntaxErrorObject(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber)
-    : ErrorObject(engine->syntaxErrorClass, msg, fileName, lineNumber, columnNumber, SyntaxError)
+SyntaxErrorObject::Data::Data(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber)
+    : ErrorObject::Data(engine->syntaxErrorClass, msg, fileName, lineNumber, columnNumber, SyntaxError)
 {
 }
 
-EvalErrorObject::EvalErrorObject(ExecutionEngine *engine, const ValueRef message)
-    : ErrorObject(engine->evalErrorClass, message, EvalError)
+EvalErrorObject::Data::Data(ExecutionEngine *engine, const ValueRef message)
+    : ErrorObject::Data(engine->evalErrorClass, message, EvalError)
 {
 }
 
-RangeErrorObject::RangeErrorObject(ExecutionEngine *engine, const ValueRef message)
-    : ErrorObject(engine->rangeErrorClass, message, RangeError)
+RangeErrorObject::Data::Data(ExecutionEngine *engine, const ValueRef message)
+    : ErrorObject::Data(engine->rangeErrorClass, message, RangeError)
 {
 }
 
-RangeErrorObject::RangeErrorObject(ExecutionEngine *engine, const QString &message)
-    : ErrorObject(engine->rangeErrorClass, message, RangeError)
+RangeErrorObject::Data::Data(ExecutionEngine *engine, const QString &message)
+    : ErrorObject::Data(engine->rangeErrorClass, message, RangeError)
 {
 }
 
-ReferenceErrorObject::ReferenceErrorObject(ExecutionEngine *engine, const ValueRef message)
-    : ErrorObject(engine->referenceErrorClass, message, ReferenceError)
+ReferenceErrorObject::Data::Data(ExecutionEngine *engine, const ValueRef message)
+    : ErrorObject::Data(engine->referenceErrorClass, message, ReferenceError)
 {
 }
 
-ReferenceErrorObject::ReferenceErrorObject(ExecutionEngine *engine, const QString &message)
-    : ErrorObject(engine->referenceErrorClass, message, ReferenceError)
+ReferenceErrorObject::Data::Data(ExecutionEngine *engine, const QString &message)
+    : ErrorObject::Data(engine->referenceErrorClass, message, ReferenceError)
 {
 }
 
-ReferenceErrorObject::ReferenceErrorObject(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber)
-    : ErrorObject(engine->referenceErrorClass, msg, fileName, lineNumber, columnNumber, ReferenceError)
+ReferenceErrorObject::Data::Data(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber)
+    : ErrorObject::Data(engine->referenceErrorClass, msg, fileName, lineNumber, columnNumber, ReferenceError)
 {
 }
 
-TypeErrorObject::TypeErrorObject(ExecutionEngine *engine, const ValueRef message)
-    : ErrorObject(engine->typeErrorClass, message, TypeError)
+TypeErrorObject::Data::Data(ExecutionEngine *engine, const ValueRef message)
+    : ErrorObject::Data(engine->typeErrorClass, message, TypeError)
 {
 }
 
-TypeErrorObject::TypeErrorObject(ExecutionEngine *engine, const QString &message)
-    : ErrorObject(engine->typeErrorClass, message, TypeError)
+TypeErrorObject::Data::Data(ExecutionEngine *engine, const QString &message)
+    : ErrorObject::Data(engine->typeErrorClass, message, TypeError)
 {
 }
 
-URIErrorObject::URIErrorObject(ExecutionEngine *engine, const ValueRef message)
-    : ErrorObject(engine->uriErrorClass, message, URIError)
+URIErrorObject::Data::Data(ExecutionEngine *engine, const ValueRef message)
+    : ErrorObject::Data(engine->uriErrorClass, message, URIError)
 {
 }
 
@@ -287,7 +287,7 @@ ReturnedValue EvalErrorCtor::construct(Managed *m, CallData *callData)
 {
     Scope scope(m->engine());
     ScopedValue v(scope, callData->argument(0));
-    return (new (m->engine()->memoryManager) EvalErrorObject(m->engine(), v))->asReturnedValue();
+    return (new (m->engine()) EvalErrorObject::Data(m->engine(), v))->asReturnedValue();
 }
 
 RangeErrorCtor::Data::Data(ExecutionContext *scope)
@@ -300,7 +300,7 @@ ReturnedValue RangeErrorCtor::construct(Managed *m, CallData *callData)
 {
     Scope scope(m->engine());
     ScopedValue v(scope, callData->argument(0));
-    return (new (m->engine()->memoryManager) RangeErrorObject(scope.engine, v))->asReturnedValue();
+    return (new (m->engine()) RangeErrorObject::Data(scope.engine, v))->asReturnedValue();
 }
 
 ReferenceErrorCtor::Data::Data(ExecutionContext *scope)
@@ -313,7 +313,7 @@ ReturnedValue ReferenceErrorCtor::construct(Managed *m, CallData *callData)
 {
     Scope scope(m->engine());
     ScopedValue v(scope, callData->argument(0));
-    return (new (m->engine()->memoryManager) ReferenceErrorObject(scope.engine, v))->asReturnedValue();
+    return (new (m->engine()) ReferenceErrorObject::Data(scope.engine, v))->asReturnedValue();
 }
 
 SyntaxErrorCtor::Data::Data(ExecutionContext *scope)
@@ -326,7 +326,7 @@ ReturnedValue SyntaxErrorCtor::construct(Managed *m, CallData *callData)
 {
     Scope scope(m->engine());
     ScopedValue v(scope, callData->argument(0));
-    return (new (m->engine()->memoryManager) SyntaxErrorObject(scope.engine, v))->asReturnedValue();
+    return (new (m->engine()) SyntaxErrorObject::Data(scope.engine, v))->asReturnedValue();
 }
 
 TypeErrorCtor::Data::Data(ExecutionContext *scope)
@@ -339,7 +339,7 @@ ReturnedValue TypeErrorCtor::construct(Managed *m, CallData *callData)
 {
     Scope scope(m->engine());
     ScopedValue v(scope, callData->argument(0));
-    return (new (m->engine()->memoryManager) TypeErrorObject(scope.engine, v))->asReturnedValue();
+    return (new (m->engine()) TypeErrorObject::Data(scope.engine, v))->asReturnedValue();
 }
 
 URIErrorCtor::Data::Data(ExecutionContext *scope)
@@ -352,7 +352,7 @@ ReturnedValue URIErrorCtor::construct(Managed *m, CallData *callData)
 {
     Scope scope(m->engine());
     ScopedValue v(scope, callData->argument(0));
-    return (new (m->engine()->memoryManager) URIErrorObject(scope.engine, v))->asReturnedValue();
+    return (new (m->engine()) URIErrorObject::Data(scope.engine, v))->asReturnedValue();
 }
 
 void ErrorPrototype::init(ExecutionEngine *engine, Object *ctor, Object *obj)
diff --git a/src/qml/jsruntime/qv4errorobject_p.h b/src/qml/jsruntime/qv4errorobject_p.h
index 2bfdd4972d..39d2e3c5c7 100644
--- a/src/qml/jsruntime/qv4errorobject_p.h
+++ b/src/qml/jsruntime/qv4errorobject_p.h
@@ -51,17 +51,6 @@ namespace QV4 {
 struct SyntaxErrorObject;
 
 struct ErrorObject: Object {
-    struct Data : Object::Data {
-        StackTrace stackTrace;
-        String *stack;
-    };
-    struct {
-        StackTrace stackTrace;
-        String *stack;
-    } __data;
-
-    V4_OBJECT
-    Q_MANAGED_TYPE(ErrorObject)
     enum {
         IsErrorObject = true
     };
@@ -75,11 +64,21 @@ struct ErrorObject: Object {
         TypeError,
         URIError
     };
+    struct Data : Object::Data {
+        Data(InternalClass *ic);
+        Data(InternalClass *ic, const ValueRef message, ErrorType t = Error);
+        Data(InternalClass *ic, const QString &message, ErrorType t = Error);
+        Data(InternalClass *ic, const QString &message, const QString &fileName, int line, int column, ErrorType t = Error);
+        StackTrace stackTrace;
+        String *stack;
+    };
+    struct {
+        StackTrace stackTrace;
+        String *stack;
+    } __data;
 
-    ErrorObject(InternalClass *ic);
-    ErrorObject(InternalClass *ic, const ValueRef message, ErrorType t = Error);
-    ErrorObject(InternalClass *ic, const QString &message, ErrorType t = Error);
-    ErrorObject(InternalClass *ic, const QString &message, const QString &fileName, int line, int column, ErrorType t = Error);
+    V4_OBJECT
+    Q_MANAGED_TYPE(ErrorObject)
 
     SyntaxErrorObject *asSyntaxError();
 
@@ -94,33 +93,45 @@ inline ErrorObject *value_cast(const Value &v) {
 }
 
 struct EvalErrorObject: ErrorObject {
-    EvalErrorObject(ExecutionEngine *engine, const ValueRef message);
+    struct Data : ErrorObject::Data {
+        Data(ExecutionEngine *engine, const ValueRef message);
+    };
 };
 
 struct RangeErrorObject: ErrorObject {
-    RangeErrorObject(ExecutionEngine *engine, const ValueRef message);
-    RangeErrorObject(ExecutionEngine *engine, const QString &msg);
+    struct Data : ErrorObject::Data {
+        Data(ExecutionEngine *engine, const ValueRef message);
+        Data(ExecutionEngine *engine, const QString &msg);
+    };
 };
 
 struct ReferenceErrorObject: ErrorObject {
-    ReferenceErrorObject(ExecutionEngine *engine, const ValueRef message);
-    ReferenceErrorObject(ExecutionEngine *engine, const QString &msg);
-    ReferenceErrorObject(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber);
+    struct Data : ErrorObject::Data {
+        Data(ExecutionEngine *engine, const ValueRef message);
+        Data(ExecutionEngine *engine, const QString &msg);
+        Data(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber);
+    };
 };
 
 struct SyntaxErrorObject: ErrorObject {
+    struct Data : ErrorObject::Data {
+        Data(ExecutionEngine *engine, const ValueRef message);
+        Data(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber);
+    };
     V4_OBJECT
-    SyntaxErrorObject(ExecutionEngine *engine, const ValueRef msg);
-    SyntaxErrorObject(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber);
 };
 
 struct TypeErrorObject: ErrorObject {
-    TypeErrorObject(ExecutionEngine *engine, const ValueRef message);
-    TypeErrorObject(ExecutionEngine *engine, const QString &msg);
+    struct Data : ErrorObject::Data {
+        Data(ExecutionEngine *engine, const ValueRef message);
+        Data(ExecutionEngine *engine, const QString &msg);
+    };
 };
 
 struct URIErrorObject: ErrorObject {
-    URIErrorObject(ExecutionEngine *engine, const ValueRef message);
+    struct Data : ErrorObject::Data {
+        Data(ExecutionEngine *engine, const ValueRef message);
+    };
 };
 
 struct ErrorCtor: FunctionObject
@@ -197,49 +208,41 @@ struct URIErrorCtor: ErrorCtor
 };
 
 
-struct ErrorPrototype: ErrorObject
+struct ErrorPrototype : ErrorObject
 {
-    // ### shouldn't be undefined
-    ErrorPrototype(InternalClass *ic): ErrorObject(ic) {}
     void init(ExecutionEngine *engine, Object *ctor) { init(engine, ctor, this); }
 
     static void init(ExecutionEngine *engine, Object *ctor, Object *obj);
     static ReturnedValue method_toString(CallContext *ctx);
 };
 
-struct EvalErrorPrototype: ErrorObject
+struct EvalErrorPrototype : ErrorObject
 {
-    EvalErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); }
     void init(ExecutionEngine *engine, Object *ctor) { ErrorPrototype::init(engine, ctor, this); }
 };
 
-struct RangeErrorPrototype: ErrorObject
+struct RangeErrorPrototype : ErrorObject
 {
-    RangeErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); }
     void init(ExecutionEngine *engine, Object *ctor) { ErrorPrototype::init(engine, ctor, this); }
 };
 
-struct ReferenceErrorPrototype: ErrorObject
+struct ReferenceErrorPrototype : ErrorObject
 {
-    ReferenceErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); }
     void init(ExecutionEngine *engine, Object *ctor) { ErrorPrototype::init(engine, ctor, this); }
 };
 
-struct SyntaxErrorPrototype: ErrorObject
+struct SyntaxErrorPrototype : ErrorObject
 {
-    SyntaxErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); }
     void init(ExecutionEngine *engine, Object *ctor) { ErrorPrototype::init(engine, ctor, this); }
 };
 
-struct TypeErrorPrototype: ErrorObject
+struct TypeErrorPrototype : ErrorObject
 {
-    TypeErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); }
     void init(ExecutionEngine *engine, Object *ctor) { ErrorPrototype::init(engine, ctor, this); }
 };
 
-struct URIErrorPrototype: ErrorObject
+struct URIErrorPrototype : ErrorObject
 {
-    URIErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); }
     void init(ExecutionEngine *engine, Object *ctor) { ErrorPrototype::init(engine, ctor, this); }
 };
 
diff --git a/src/qml/jsruntime/qv4numberobject_p.h b/src/qml/jsruntime/qv4numberobject_p.h
index 0a76159269..1b6371ee83 100644
--- a/src/qml/jsruntime/qv4numberobject_p.h
+++ b/src/qml/jsruntime/qv4numberobject_p.h
@@ -62,7 +62,6 @@ struct NumberCtor: FunctionObject
 
 struct NumberPrototype: NumberObject
 {
-    NumberPrototype(InternalClass *ic): NumberObject(ic) {}
     void init(ExecutionEngine *engine, Object *ctor);
 
     static ReturnedValue method_toString(CallContext *ctx);
diff --git a/src/qml/jsruntime/qv4object.cpp b/src/qml/jsruntime/qv4object.cpp
index 187e775395..b8993d3bde 100644
--- a/src/qml/jsruntime/qv4object.cpp
+++ b/src/qml/jsruntime/qv4object.cpp
@@ -1163,30 +1163,23 @@ void Object::initSparseArray()
 
 DEFINE_OBJECT_VTABLE(ArrayObject);
 
-ArrayObject::ArrayObject(ExecutionEngine *engine, const QStringList &list)
-    : Object(engine->arrayClass)
+ArrayObject::Data::Data(ExecutionEngine *engine, const QStringList &list)
+    : Object::Data(engine->arrayClass)
 {
-    init(engine);
+    init();
     Scope scope(engine);
-    ScopedValue protectThis(scope, this);
+    ScopedObject a(scope, this);
 
     // Converts a QStringList to JS.
     // The result is a new Array object with length equal to the length
     // of the QStringList, and the elements being the QStringList's
     // elements converted to JS Strings.
     int len = list.count();
-    arrayReserve(len);
+    a->arrayReserve(len);
     ScopedValue v(scope);
     for (int ii = 0; ii < len; ++ii)
-        arrayPut(ii, (v = engine->newString(list.at(ii))));
-    setArrayLengthUnchecked(len);
-}
-
-void ArrayObject::init(ExecutionEngine *engine)
-{
-    Q_UNUSED(engine);
-
-    memberData()[LengthPropertyIndex] = Primitive::fromInt32(0);
+        a->arrayPut(ii, (v = engine->newString(list.at(ii))));
+    a->setArrayLengthUnchecked(len);
 }
 
 ReturnedValue ArrayObject::getLookup(Managed *m, Lookup *l)
diff --git a/src/qml/jsruntime/qv4object_p.h b/src/qml/jsruntime/qv4object_p.h
index b98c77108e..a1b107dbf0 100644
--- a/src/qml/jsruntime/qv4object_p.h
+++ b/src/qml/jsruntime/qv4object_p.h
@@ -323,6 +323,17 @@ private:
 
 struct BooleanObject: Object {
     struct Data : Object::Data {
+        Data(ExecutionEngine *engine, const ValueRef val)
+            : Object::Data(engine->booleanClass)
+        {
+            value = val;
+        }
+        Data(InternalClass *ic)
+            : Object::Data(ic)
+        {
+            Q_ASSERT(internalClass->vtable == staticVTable());
+            value = Encode(false);
+        }
         Value value;
     };
     struct {
@@ -333,22 +344,19 @@ struct BooleanObject: Object {
 
     Value value() const { return d()->value; }
 
-    BooleanObject(ExecutionEngine *engine, const ValueRef val)
-        : Object(engine->booleanClass)
-    {
-        d()->value = val;
-    }
-protected:
-    BooleanObject(InternalClass *ic)
-        : Object(ic)
-    {
-        Q_ASSERT(internalClass()->vtable == staticVTable());
-        d()->value = Encode(false);
-    }
 };
 
 struct NumberObject: Object {
     struct Data : Object::Data {
+        Data(ExecutionEngine *engine, const ValueRef val)
+            : Object::Data(engine->numberClass) {
+            value = val;
+        }
+        Data(InternalClass *ic)
+            : Object::Data(ic) {
+            Q_ASSERT(internalClass->vtable == staticVTable());
+            value = Encode((int)0);
+        }
         Value value;
     };
     struct {
@@ -359,29 +367,23 @@ struct NumberObject: Object {
 
     Value value() const { return d()->value; }
 
-    NumberObject(ExecutionEngine *engine, const ValueRef val)
-        : Object(engine->numberClass) {
-        d()->value = val;
-    }
-protected:
-    NumberObject(InternalClass *ic)
-        : Object(ic) {
-        Q_ASSERT(internalClass()->vtable == staticVTable());
-        d()->value = Encode((int)0);
-    }
 };
 
 struct ArrayObject: Object {
+    struct Data : Object::Data {
+        Data(ExecutionEngine *engine) : Object::Data(engine->arrayClass) { init(); }
+        Data(ExecutionEngine *engine, const QStringList &list);
+        Data(InternalClass *ic) : Object::Data(ic) { init(); }
+        void init()
+        { memberData[LengthPropertyIndex] = Primitive::fromInt32(0); }
+    };
+
     V4_OBJECT
     Q_MANAGED_TYPE(ArrayObject)
     enum {
         LengthPropertyIndex = 0
     };
 
-    ArrayObject(ExecutionEngine *engine) : Object(engine->arrayClass) { init(engine); }
-    ArrayObject(ExecutionEngine *engine, const QStringList &list);
-    ArrayObject(InternalClass *ic) : Object(ic) { init(ic->engine); }
-
     void init(ExecutionEngine *engine);
 
     static ReturnedValue getLookup(Managed *m, Lookup *l);
diff --git a/src/qml/jsruntime/qv4objectproto_p.h b/src/qml/jsruntime/qv4objectproto_p.h
index 495fe3e755..e174565915 100644
--- a/src/qml/jsruntime/qv4objectproto_p.h
+++ b/src/qml/jsruntime/qv4objectproto_p.h
@@ -62,8 +62,6 @@ struct ObjectCtor: FunctionObject
 
 struct ObjectPrototype: Object
 {
-    ObjectPrototype(InternalClass *ic) : Object(ic) {}
-
     void init(ExecutionEngine *engine, Object *ctor);
 
     static ReturnedValue method_getPrototypeOf(CallContext *ctx);
diff --git a/src/qml/jsruntime/qv4stringobject.cpp b/src/qml/jsruntime/qv4stringobject.cpp
index c47e1ae5b9..3f683495cd 100644
--- a/src/qml/jsruntime/qv4stringobject.cpp
+++ b/src/qml/jsruntime/qv4stringobject.cpp
@@ -77,35 +77,29 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(StringObject);
 
-StringObject::StringObject(InternalClass *ic)
-    : Object(ic)
+StringObject::Data::Data(InternalClass *ic)
+    : Object::Data(ic)
 {
-    Q_ASSERT(internalClass()->vtable == staticVTable());
+    Q_ASSERT(internalClass->vtable == staticVTable());
+    value = ic->engine->newString(QStringLiteral(""))->asReturnedValue();
+    tmpProperty.value = Primitive::undefinedValue();
 
-    Scope scope(engine());
-    ScopedObject protectThis(scope, this);
-
-    d()->value = ic->engine->newString(QStringLiteral(""))->asReturnedValue();
-
-    d()->tmpProperty.value = Primitive::undefinedValue();
-
-    defineReadonlyProperty(ic->engine->id_length, Primitive::fromInt32(0));
+    Scope scope(ic->engine);
+    ScopedObject s(scope, this);
+    s->defineReadonlyProperty(ic->engine->id_length, Primitive::fromInt32(0));
 }
 
-StringObject::StringObject(ExecutionEngine *engine, const ValueRef val)
-    : Object(engine->stringObjectClass)
+StringObject::Data::Data(ExecutionEngine *engine, const ValueRef val)
+    : Object::Data(engine->stringObjectClass)
 {
+    value = val;
+    Q_ASSERT(value.isString());
+    tmpProperty.value = Primitive::undefinedValue();
     setVTable(staticVTable());
 
     Scope scope(engine);
-    ScopedObject protectThis(scope, this);
-
-    d()->value = *val;
-
-    d()->tmpProperty.value = Primitive::undefinedValue();
-
-    assert(d()->value.isString());
-    defineReadonlyProperty(engine->id_length, Primitive::fromUInt32(d()->value.stringValue()->toQString().length()));
+    ScopedObject s(scope, this);
+    s->defineReadonlyProperty(engine->id_length, Primitive::fromUInt32(value.stringValue()->toQString().length()));
 }
 
 Property *StringObject::getIndex(uint index) const
diff --git a/src/qml/jsruntime/qv4stringobject_p.h b/src/qml/jsruntime/qv4stringobject_p.h
index 6656e297a5..5cddec0edc 100644
--- a/src/qml/jsruntime/qv4stringobject_p.h
+++ b/src/qml/jsruntime/qv4stringobject_p.h
@@ -51,6 +51,8 @@ namespace QV4 {
 
 struct StringObject: Object {
     struct Data : Object::Data {
+        Data(ExecutionEngine *engine, const ValueRef value);
+        Data(InternalClass *ic);
         Value value;
         // ### get rid of tmpProperty
         mutable Property tmpProperty;
@@ -62,14 +64,12 @@ struct StringObject: Object {
     V4_OBJECT
     Q_MANAGED_TYPE(StringObject)
 
-    StringObject(ExecutionEngine *engine, const ValueRef value);
 
     Property *getIndex(uint index) const;
 
     static bool deleteIndexedProperty(Managed *m, uint index);
 
 protected:
-    StringObject(InternalClass *ic);
     static void advanceIterator(Managed *m, ObjectIterator *it, String *&name, uint *index, Property *p, PropertyAttributes *attrs);
     static void markObjects(Managed *that, ExecutionEngine *e);
 };
@@ -87,7 +87,6 @@ struct StringCtor: FunctionObject
 
 struct StringPrototype: StringObject
 {
-    StringPrototype(InternalClass *ic): StringObject(ic) {}
     void init(ExecutionEngine *engine, Object *ctor);
 
     static ReturnedValue method_toString(CallContext *context);