QML: Make Heap::Object and all subclasses trivial

GCC6 might dead-store-eliminate out our secret write to Base::mmdata,
because it expects all memory content to be "undefined" before
constructor calls. Clang might take the same approach if the constructor
of Heap::Object is removed.

By making these structs trivial, it also makes them memcpy-able.

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

49 files changed, 360 insertions, 292 deletions

diff --git a/src/qml/jsruntime/qv4argumentsobject.cpp b/src/qml/jsruntime/qv4argumentsobject.cpp
index 156c21ca66..0dfdf25158 100644
--- a/src/qml/jsruntime/qv4argumentsobject.cpp
+++ b/src/qml/jsruntime/qv4argumentsobject.cpp
@@ -45,9 +45,10 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(ArgumentsObject);
 
-Heap::ArgumentsObject::ArgumentsObject(QV4::CallContext *context)
-    : fullyCreated(false)
+void Heap::ArgumentsObject::init(QV4::CallContext *context)
 {
+    Object::init();
+    fullyCreated = false;
     this->context = context->d();
     Q_ASSERT(vtable() == QV4::ArgumentsObject::staticVTable());
 
diff --git a/src/qml/jsruntime/qv4argumentsobject_p.h b/src/qml/jsruntime/qv4argumentsobject_p.h
index 6ccfd89fd4..37a8d0a94a 100644
--- a/src/qml/jsruntime/qv4argumentsobject_p.h
+++ b/src/qml/jsruntime/qv4argumentsobject_p.h
@@ -60,12 +60,12 @@ namespace QV4 {
 namespace Heap {
 
 struct ArgumentsGetterFunction : FunctionObject {
-    inline ArgumentsGetterFunction(QV4::ExecutionContext *scope, uint index);
+    inline void init(QV4::ExecutionContext *scope, uint index);
     uint index;
 };
 
 struct ArgumentsSetterFunction : FunctionObject {
-    inline ArgumentsSetterFunction(QV4::ExecutionContext *scope, uint index);
+    inline void init(QV4::ExecutionContext *scope, uint index);
     uint index;
 };
 
@@ -75,7 +75,7 @@ struct ArgumentsObject : Object {
         CalleePropertyIndex = 1,
         CallerPropertyIndex = 3
     };
-    ArgumentsObject(QV4::CallContext *context);
+    void init(QV4::CallContext *context);
     Pointer<CallContext> context;
     bool fullyCreated;
     Pointer<MemberData> mappedArguments;
@@ -91,11 +91,11 @@ struct ArgumentsGetterFunction: FunctionObject
     static void call(const Managed *that, Scope &scope, CallData *d);
 };
 
-inline
-Heap::ArgumentsGetterFunction::ArgumentsGetterFunction(QV4::ExecutionContext *scope, uint index)
-    : Heap::FunctionObject(scope)
-    , index(index)
+inline void
+Heap::ArgumentsGetterFunction::init(QV4::ExecutionContext *scope, uint index)
 {
+    Heap::FunctionObject::init(scope);
+    this->index = index;
 }
 
 struct ArgumentsSetterFunction: FunctionObject
@@ -106,11 +106,11 @@ struct ArgumentsSetterFunction: FunctionObject
     static void call(const Managed *that, Scope &scope, CallData *callData);
 };
 
-inline
-Heap::ArgumentsSetterFunction::ArgumentsSetterFunction(QV4::ExecutionContext *scope, uint index)
-    : Heap::FunctionObject(scope)
-    , index(index)
+inline void
+Heap::ArgumentsSetterFunction::init(QV4::ExecutionContext *scope, uint index)
 {
+    Heap::FunctionObject::init(scope);
+    this->index = index;
 }
 
 
diff --git a/src/qml/jsruntime/qv4arraybuffer.cpp b/src/qml/jsruntime/qv4arraybuffer.cpp
index e88f17a658..908fa52680 100644
--- a/src/qml/jsruntime/qv4arraybuffer.cpp
+++ b/src/qml/jsruntime/qv4arraybuffer.cpp
@@ -46,9 +46,9 @@ using namespace QV4;
 DEFINE_OBJECT_VTABLE(ArrayBufferCtor);
 DEFINE_OBJECT_VTABLE(ArrayBuffer);
 
-Heap::ArrayBufferCtor::ArrayBufferCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("ArrayBuffer"))
+void Heap::ArrayBufferCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("ArrayBuffer"));
 }
 
 void ArrayBufferCtor::construct(const Managed *m, Scope &scope, CallData *callData)
@@ -94,8 +94,9 @@ ReturnedValue ArrayBufferCtor::method_isView(CallContext *ctx)
 }
 
 
-Heap::ArrayBuffer::ArrayBuffer(size_t length)
+void Heap::ArrayBuffer::init(size_t length)
 {
+    Object::init();
     data = QTypedArrayData<char>::allocate(length + 1);
     if (!data) {
         data = 0;
@@ -106,9 +107,10 @@ Heap::ArrayBuffer::ArrayBuffer(size_t length)
     memset(data->data(), 0, length + 1);
 }
 
-Heap::ArrayBuffer::ArrayBuffer(const QByteArray& array)
-    : data(const_cast<QByteArray&>(array).data_ptr())
+void Heap::ArrayBuffer::init(const QByteArray& array)
 {
+    Object::init();
+    data = const_cast<QByteArray&>(array).data_ptr();
     data->ref.ref();
 }
 
diff --git a/src/qml/jsruntime/qv4arraybuffer_p.h b/src/qml/jsruntime/qv4arraybuffer_p.h
index a5ca0f6bad..bc56d1ea31 100644
--- a/src/qml/jsruntime/qv4arraybuffer_p.h
+++ b/src/qml/jsruntime/qv4arraybuffer_p.h
@@ -60,12 +60,12 @@ namespace QV4 {
 namespace Heap {
 
 struct ArrayBufferCtor : FunctionObject {
-    ArrayBufferCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 struct Q_QML_PRIVATE_EXPORT ArrayBuffer : Object {
-    ArrayBuffer(size_t length);
-    ArrayBuffer(const QByteArray& array);
+    void init(size_t length);
+    void init(const QByteArray& array);
     void destroy();
     QTypedArrayData<char> *data;
 
diff --git a/src/qml/jsruntime/qv4arraydata_p.h b/src/qml/jsruntime/qv4arraydata_p.h
index ba0cc7cb30..9f810a32d5 100644
--- a/src/qml/jsruntime/qv4arraydata_p.h
+++ b/src/qml/jsruntime/qv4arraydata_p.h
@@ -133,7 +133,7 @@ struct ArrayData : public Base {
     }
 
 };
-Q_STATIC_ASSERT(std::is_trivial<ArrayData>::value);
+V4_ASSERT_IS_TRIVIAL(ArrayData)
 
 struct SimpleArrayData : public ArrayData {
     uint mappedIndex(uint index) const { return (index + offset) % alloc; }
@@ -153,7 +153,7 @@ struct SimpleArrayData : public ArrayData {
         return attrs ? attrs[i] : Attr_Data;
     }
 };
-Q_STATIC_ASSERT(std::is_trivial<SimpleArrayData>::value);
+V4_ASSERT_IS_TRIVIAL(SimpleArrayData)
 
 struct SparseArrayData : public ArrayData {
     void destroy() { delete sparse; }
diff --git a/src/qml/jsruntime/qv4arrayobject.cpp b/src/qml/jsruntime/qv4arrayobject.cpp
index 4d15c6c137..76faef137f 100644
--- a/src/qml/jsruntime/qv4arrayobject.cpp
+++ b/src/qml/jsruntime/qv4arrayobject.cpp
@@ -49,9 +49,9 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(ArrayCtor);
 
-Heap::ArrayCtor::ArrayCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("Array"))
+void Heap::ArrayCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("Array"));
 }
 
 void ArrayCtor::construct(const Managed *m, Scope &scope, CallData *callData)
diff --git a/src/qml/jsruntime/qv4arrayobject_p.h b/src/qml/jsruntime/qv4arrayobject_p.h
index f49ed76b02..9a05bb8681 100644
--- a/src/qml/jsruntime/qv4arrayobject_p.h
+++ b/src/qml/jsruntime/qv4arrayobject_p.h
@@ -61,7 +61,7 @@ namespace QV4 {
 namespace Heap {
 
 struct ArrayCtor : FunctionObject {
-    ArrayCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4booleanobject.cpp b/src/qml/jsruntime/qv4booleanobject.cpp
index 57c54e15c4..8047993266 100644
--- a/src/qml/jsruntime/qv4booleanobject.cpp
+++ b/src/qml/jsruntime/qv4booleanobject.cpp
@@ -45,9 +45,9 @@ using namespace QV4;
 DEFINE_OBJECT_VTABLE(BooleanCtor);
 DEFINE_OBJECT_VTABLE(BooleanObject);
 
-Heap::BooleanCtor::BooleanCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("Boolean"))
+void Heap::BooleanCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("Boolean"));
 }
 
 void BooleanCtor::construct(const Managed *, Scope &scope, CallData *callData)
diff --git a/src/qml/jsruntime/qv4booleanobject_p.h b/src/qml/jsruntime/qv4booleanobject_p.h
index 17543e33e0..4c2f3c09e7 100644
--- a/src/qml/jsruntime/qv4booleanobject_p.h
+++ b/src/qml/jsruntime/qv4booleanobject_p.h
@@ -61,7 +61,7 @@ namespace QV4 {
 namespace Heap {
 
 struct BooleanCtor : FunctionObject {
-    BooleanCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4context_p.h b/src/qml/jsruntime/qv4context_p.h
index ffedf737ce..0b42288ccc 100644
--- a/src/qml/jsruntime/qv4context_p.h
+++ b/src/qml/jsruntime/qv4context_p.h
@@ -128,7 +128,7 @@ struct ExecutionContext : Base {
     bool strictMode : 8;
     int lineNumber;
 };
-Q_STATIC_ASSERT(std::is_trivial<ExecutionContext>::value);
+V4_ASSERT_IS_TRIVIAL(ExecutionContext)
 
 struct CallContext : ExecutionContext {
     static CallContext createOnStack(ExecutionEngine *v4);
@@ -145,20 +145,20 @@ struct CallContext : ExecutionContext {
     Value *locals;
     Pointer<Object> activation;
 };
-Q_STATIC_ASSERT(std::is_trivial<CallContext>::value);
+V4_ASSERT_IS_TRIVIAL(CallContext)
 
 struct GlobalContext : ExecutionContext {
     void init(ExecutionEngine *engine);
     Pointer<Object> global;
 };
-Q_STATIC_ASSERT(std::is_trivial<GlobalContext>::value);
+V4_ASSERT_IS_TRIVIAL(GlobalContext)
 
 struct CatchContext : ExecutionContext {
     void init(ExecutionContext *outerContext, String *exceptionVarName, const Value &exceptionValue);
     Pointer<String> exceptionVarName;
     Value exceptionValue;
 };
-Q_STATIC_ASSERT(std::is_trivial<CatchContext>::value);
+V4_ASSERT_IS_TRIVIAL(CatchContext)
 
 struct WithContext : ExecutionContext {
     void init(ExecutionContext *outerContext, Object *with)
@@ -175,7 +175,7 @@ struct WithContext : ExecutionContext {
 
     Pointer<Object> withObject;
 };
-Q_STATIC_ASSERT(std::is_trivial<WithContext>::value);
+V4_ASSERT_IS_TRIVIAL(WithContext)
 
 struct QmlContextWrapper;
 
diff --git a/src/qml/jsruntime/qv4dataview.cpp b/src/qml/jsruntime/qv4dataview.cpp
index fac3d5316c..db8376272d 100644
--- a/src/qml/jsruntime/qv4dataview.cpp
+++ b/src/qml/jsruntime/qv4dataview.cpp
@@ -49,9 +49,9 @@ using namespace QV4;
 DEFINE_OBJECT_VTABLE(DataViewCtor);
 DEFINE_OBJECT_VTABLE(DataView);
 
-Heap::DataViewCtor::DataViewCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("DataView"))
+void Heap::DataViewCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("DataView"));
 }
 
 void DataViewCtor::construct(const Managed *, Scope &scope, CallData *callData)
diff --git a/src/qml/jsruntime/qv4dataview_p.h b/src/qml/jsruntime/qv4dataview_p.h
index f996a4c2f1..246124394a 100644
--- a/src/qml/jsruntime/qv4dataview_p.h
+++ b/src/qml/jsruntime/qv4dataview_p.h
@@ -60,11 +60,11 @@ namespace QV4 {
 namespace Heap {
 
 struct DataViewCtor : FunctionObject {
-    DataViewCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 struct DataView : Object {
-    DataView() {}
+    void init() { Object::init(); }
     Pointer<ArrayBuffer> buffer;
     uint byteLength;
     uint byteOffset;
diff --git a/src/qml/jsruntime/qv4dateobject.cpp b/src/qml/jsruntime/qv4dateobject.cpp
index 04358fe3b5..4f3138a452 100644
--- a/src/qml/jsruntime/qv4dateobject.cpp
+++ b/src/qml/jsruntime/qv4dateobject.cpp
@@ -634,13 +634,15 @@ static double getLocalTZA()
 
 DEFINE_OBJECT_VTABLE(DateObject);
 
-Heap::DateObject::DateObject(const QDateTime &date)
+void Heap::DateObject::init(const QDateTime &date)
 {
+    Object::init();
     this->date = date.isValid() ? date.toMSecsSinceEpoch() : qt_qnan();
 }
 
-Heap::DateObject::DateObject(const QTime &time)
+void Heap::DateObject::init(const QTime &time)
 {
+    Object::init();
     if (!time.isValid()) {
         date = qt_qnan();
         return;
@@ -668,9 +670,9 @@ QDateTime DateObject::toQDateTime() const
 
 DEFINE_OBJECT_VTABLE(DateCtor);
 
-Heap::DateCtor::DateCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("Date"))
+void Heap::DateCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("Date"));
 }
 
 void DateCtor::construct(const Managed *, Scope &scope, CallData *callData)
diff --git a/src/qml/jsruntime/qv4dateobject_p.h b/src/qml/jsruntime/qv4dateobject_p.h
index c67acdcfa2..2d0648396e 100644
--- a/src/qml/jsruntime/qv4dateobject_p.h
+++ b/src/qml/jsruntime/qv4dateobject_p.h
@@ -63,24 +63,26 @@ namespace QV4 {
 namespace Heap {
 
 struct DateObject : Object {
-    DateObject()
+    void init()
     {
+        Object::init();
         date = qt_qnan();
     }
 
-    DateObject(const Value &date)
+    void init(const Value &date)
     {
+        Object::init();
         this->date = date.toNumber();
     }
-    DateObject(const QDateTime &date);
-    double date;
+    void init(const QDateTime &date);
+    void init(const QTime &time);
 
-    DateObject(const QTime &time);
+    double date;
 };
 
 
 struct DateCtor : FunctionObject {
-    DateCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4errorobject.cpp b/src/qml/jsruntime/qv4errorobject.cpp
index bb5d32cbd7..597ded6ae1 100644
--- a/src/qml/jsruntime/qv4errorobject.cpp
+++ b/src/qml/jsruntime/qv4errorobject.cpp
@@ -67,8 +67,9 @@
 
 using namespace QV4;
 
-Heap::ErrorObject::ErrorObject()
+void Heap::ErrorObject::init()
 {
+    Object::init();
     stackTrace = nullptr;
 
     Scope scope(internalClass->engine);
@@ -83,8 +84,9 @@ Heap::ErrorObject::ErrorObject()
     *propertyData(QV4::ErrorObject::Index_LineNumber) = Encode::undefined();
 }
 
-Heap::ErrorObject::ErrorObject(const Value &message, ErrorType t)
+void Heap::ErrorObject::init(const Value &message, ErrorType t)
 {
+    Object::init();
     errorType = t;
 
     Scope scope(internalClass->engine);
@@ -103,8 +105,9 @@ Heap::ErrorObject::ErrorObject(const Value &message, ErrorType t)
         *propertyData(QV4::ErrorObject::Index_Message) = message;
 }
 
-Heap::ErrorObject::ErrorObject(const Value &message, const QString &fileName, int line, int column, ErrorObject::ErrorType t)
+void Heap::ErrorObject::init(const Value &message, const QString &fileName, int line, int column, ErrorObject::ErrorType t)
 {
+    Object::init();
     errorType = t;
 
     Scope scope(internalClass->engine);
@@ -183,44 +186,44 @@ DEFINE_OBJECT_VTABLE(ErrorObject);
 
 DEFINE_OBJECT_VTABLE(SyntaxErrorObject);
 
-Heap::SyntaxErrorObject::SyntaxErrorObject(const Value &msg)
-    : Heap::ErrorObject(msg, SyntaxError)
+void Heap::SyntaxErrorObject::init(const Value &msg)
 {
+    Heap::ErrorObject::init(msg, SyntaxError);
 }
 
-Heap::SyntaxErrorObject::SyntaxErrorObject(const Value &msg, const QString &fileName, int lineNumber, int columnNumber)
-    : Heap::ErrorObject(msg, fileName, lineNumber, columnNumber, SyntaxError)
+void Heap::SyntaxErrorObject::init(const Value &msg, const QString &fileName, int lineNumber, int columnNumber)
 {
+    Heap::ErrorObject::init(msg, fileName, lineNumber, columnNumber, SyntaxError);
 }
 
-Heap::EvalErrorObject::EvalErrorObject(const Value &message)
-    : Heap::ErrorObject(message, EvalError)
+void Heap::EvalErrorObject::init(const Value &message)
 {
+    Heap::ErrorObject::init(message, EvalError);
 }
 
-Heap::RangeErrorObject::RangeErrorObject(const Value &message)
-    : Heap::ErrorObject(message, RangeError)
+void Heap::RangeErrorObject::init(const Value &message)
 {
+    Heap::ErrorObject::init(message, RangeError);
 }
 
-Heap::ReferenceErrorObject::ReferenceErrorObject(const Value &message)
-    : Heap::ErrorObject(message, ReferenceError)
+void Heap::ReferenceErrorObject::init(const Value &message)
 {
+    Heap::ErrorObject::init(message, ReferenceError);
 }
 
-Heap::ReferenceErrorObject::ReferenceErrorObject(const Value &msg, const QString &fileName, int lineNumber, int columnNumber)
-    : Heap::ErrorObject(msg, fileName, lineNumber, columnNumber, ReferenceError)
+void Heap::ReferenceErrorObject::init(const Value &msg, const QString &fileName, int lineNumber, int columnNumber)
 {
+    Heap::ErrorObject::init(msg, fileName, lineNumber, columnNumber, ReferenceError);
 }
 
-Heap::TypeErrorObject::TypeErrorObject(const Value &message)
-    : Heap::ErrorObject(message, TypeError)
+void Heap::TypeErrorObject::init(const Value &message)
 {
+    Heap::ErrorObject::init(message, TypeError);
 }
 
-Heap::URIErrorObject::URIErrorObject(const Value &message)
-    : Heap::ErrorObject(message, URIError)
+void Heap::URIErrorObject::init(const Value &message)
 {
+    Heap::ErrorObject::init(message, URIError);
 }
 
 DEFINE_OBJECT_VTABLE(ErrorCtor);
@@ -231,14 +234,14 @@ DEFINE_OBJECT_VTABLE(SyntaxErrorCtor);
 DEFINE_OBJECT_VTABLE(TypeErrorCtor);
 DEFINE_OBJECT_VTABLE(URIErrorCtor);
 
-Heap::ErrorCtor::ErrorCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("Error"))
+void Heap::ErrorCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("Error"));
 }
 
-Heap::ErrorCtor::ErrorCtor(QV4::ExecutionContext *scope, const QString &name)
-    : Heap::FunctionObject(scope, name)
+void Heap::ErrorCtor::init(QV4::ExecutionContext *scope, const QString &name)
 {
+    Heap::FunctionObject::init(scope, name);
 }
 
 void ErrorCtor::construct(const Managed *, Scope &scope, CallData *callData)
@@ -252,9 +255,9 @@ void ErrorCtor::call(const Managed *that, Scope &scope, CallData *callData)
     static_cast<const Object *>(that)->construct(scope, callData);
 }
 
-Heap::EvalErrorCtor::EvalErrorCtor(QV4::ExecutionContext *scope)
-    : Heap::ErrorCtor(scope, QStringLiteral("EvalError"))
+void Heap::EvalErrorCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::ErrorCtor::init(scope, QStringLiteral("EvalError"));
 }
 
 void EvalErrorCtor::construct(const Managed *, Scope &scope, CallData *callData)
@@ -263,9 +266,9 @@ void EvalErrorCtor::construct(const Managed *, Scope &scope, CallData *callData)
     scope.result = ErrorObject::create<EvalErrorObject>(scope.engine, v);
 }
 
-Heap::RangeErrorCtor::RangeErrorCtor(QV4::ExecutionContext *scope)
-    : Heap::ErrorCtor(scope, QStringLiteral("RangeError"))
+void Heap::RangeErrorCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::ErrorCtor::init(scope, QStringLiteral("RangeError"));
 }
 
 void RangeErrorCtor::construct(const Managed *, Scope &scope, CallData *callData)
@@ -274,9 +277,9 @@ void RangeErrorCtor::construct(const Managed *, Scope &scope, CallData *callData
     scope.result = ErrorObject::create<RangeErrorObject>(scope.engine, v);
 }
 
-Heap::ReferenceErrorCtor::ReferenceErrorCtor(QV4::ExecutionContext *scope)
-    : Heap::ErrorCtor(scope, QStringLiteral("ReferenceError"))
+void Heap::ReferenceErrorCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::ErrorCtor::init(scope, QStringLiteral("ReferenceError"));
 }
 
 void ReferenceErrorCtor::construct(const Managed *, Scope &scope, CallData *callData)
@@ -285,9 +288,9 @@ void ReferenceErrorCtor::construct(const Managed *, Scope &scope, CallData *call
     scope.result = ErrorObject::create<ReferenceErrorObject>(scope.engine, v);
 }
 
-Heap::SyntaxErrorCtor::SyntaxErrorCtor(QV4::ExecutionContext *scope)
-    : Heap::ErrorCtor(scope, QStringLiteral("SyntaxError"))
+void Heap::SyntaxErrorCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::ErrorCtor::init(scope, QStringLiteral("SyntaxError"));
 }
 
 void SyntaxErrorCtor::construct(const Managed *, Scope &scope, CallData *callData)
@@ -296,9 +299,9 @@ void SyntaxErrorCtor::construct(const Managed *, Scope &scope, CallData *callDat
     scope.result = ErrorObject::create<SyntaxErrorObject>(scope.engine, v);
 }
 
-Heap::TypeErrorCtor::TypeErrorCtor(QV4::ExecutionContext *scope)
-    : Heap::ErrorCtor(scope, QStringLiteral("TypeError"))
+void Heap::TypeErrorCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::ErrorCtor::init(scope, QStringLiteral("TypeError"));
 }
 
 void TypeErrorCtor::construct(const Managed *, Scope &scope, CallData *callData)
@@ -307,9 +310,9 @@ void TypeErrorCtor::construct(const Managed *, Scope &scope, CallData *callData)
     scope.result = ErrorObject::create<TypeErrorObject>(scope.engine, v);
 }
 
-Heap::URIErrorCtor::URIErrorCtor(QV4::ExecutionContext *scope)
-    : Heap::ErrorCtor(scope, QStringLiteral("URIError"))
+void Heap::URIErrorCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::ErrorCtor::init(scope, QStringLiteral("URIError"));
 }
 
 void URIErrorCtor::construct(const Managed *, Scope &scope, CallData *callData)
diff --git a/src/qml/jsruntime/qv4errorobject_p.h b/src/qml/jsruntime/qv4errorobject_p.h
index 206c7e6c59..b7a0889e08 100644
--- a/src/qml/jsruntime/qv4errorobject_p.h
+++ b/src/qml/jsruntime/qv4errorobject_p.h
@@ -73,9 +73,9 @@ struct ErrorObject : Object {
         URIError
     };
 
-    ErrorObject();
-    ErrorObject(const Value &message, ErrorType t = Error);
-    ErrorObject(const Value &message, const QString &fileName, int line, int column, ErrorType t = Error);
+    void init();
+    void init(const Value &message, ErrorType t = Error);
+    void init(const Value &message, const QString &fileName, int line, int column, ErrorType t = Error);
     void destroy() { delete stackTrace; }
 
     ErrorType errorType;
@@ -84,58 +84,58 @@ struct ErrorObject : Object {
 };
 
 struct EvalErrorObject : ErrorObject {
-    EvalErrorObject(const Value &message);
+    void init(const Value &message);
 };
 
 struct RangeErrorObject : ErrorObject {
-    RangeErrorObject(const Value &message);
+    void init(const Value &message);
 };
 
 struct ReferenceErrorObject : ErrorObject {
-    ReferenceErrorObject(const Value &message);
-    ReferenceErrorObject(const Value &msg, const QString &fileName, int lineNumber, int columnNumber);
+    void init(const Value &message);
+    void init(const Value &msg, const QString &fileName, int lineNumber, int columnNumber);
 };
 
 struct SyntaxErrorObject : ErrorObject {
-    SyntaxErrorObject(const Value &message);
-    SyntaxErrorObject(const Value &msg, const QString &fileName, int lineNumber, int columnNumber);
+    void init(const Value &message);
+    void init(const Value &msg, const QString &fileName, int lineNumber, int columnNumber);
 };
 
 struct TypeErrorObject : ErrorObject {
-    TypeErrorObject(const Value &message);
+    void init(const Value &message);
 };
 
 struct URIErrorObject : ErrorObject {
-    URIErrorObject(const Value &message);
+    void init(const Value &message);
 };
 
 struct ErrorCtor : Heap::FunctionObject {
-    ErrorCtor(QV4::ExecutionContext *scope);
-    ErrorCtor(QV4::ExecutionContext *scope, const QString &name);
+    void init(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope, const QString &name);
 };
 
 struct EvalErrorCtor : ErrorCtor {
-    EvalErrorCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 struct RangeErrorCtor : ErrorCtor {
-    RangeErrorCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 struct ReferenceErrorCtor : ErrorCtor {
-    ReferenceErrorCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 struct SyntaxErrorCtor : ErrorCtor {
-    SyntaxErrorCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 struct TypeErrorCtor : ErrorCtor {
-    TypeErrorCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 struct URIErrorCtor : ErrorCtor {
-    URIErrorCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4functionobject.cpp b/src/qml/jsruntime/qv4functionobject.cpp
index aa8c7d6a81..118ed89c43 100644
--- a/src/qml/jsruntime/qv4functionobject.cpp
+++ b/src/qml/jsruntime/qv4functionobject.cpp
@@ -68,18 +68,20 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(FunctionObject);
 
-Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, QV4::String *name, bool createProto)
-    : function(Q_NULLPTR)
+void Heap::FunctionObject::init(QV4::ExecutionContext *scope, QV4::String *name, bool createProto)
 {
+    Object::init();
+    function = nullptr;
     this->scope = scope->d();
     Scope s(scope->engine());
     ScopedFunctionObject f(s, this);
     f->init(name, createProto);
 }
 
-Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, Function *function, bool createProto)
-    : function(Q_NULLPTR)
+void Heap::FunctionObject::init(QV4::ExecutionContext *scope, Function *function, bool createProto)
 {
+    Object::init();
+    function = nullptr;
     this->scope = scope->d();
     Scope s(scope->engine());
     ScopedString name(s, function->name());
@@ -87,9 +89,10 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, Function *fun
     f->init(name, createProto);
 }
 
-Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const QString &name, bool createProto)
-    : function(Q_NULLPTR)
+void Heap::FunctionObject::init(QV4::ExecutionContext *scope, const QString &name, bool createProto)
 {
+    Object::init();
+    function = nullptr;
     this->scope = scope->d();
     Scope s(scope->engine());
     ScopedFunctionObject f(s, this);
@@ -97,9 +100,10 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const QString
     f->init(n, createProto);
 }
 
-Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const QString &name, bool createProto)
-    : function(Q_NULLPTR)
+void Heap::FunctionObject::init(ExecutionContext *scope, const QString &name, bool createProto)
 {
+    Object::init();
+    function = nullptr;
     this->scope = scope;
     Scope s(scope->engine);
     ScopedFunctionObject f(s, this);
@@ -107,9 +111,10 @@ Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const QString &nam
     f->init(n, createProto);
 }
 
-Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const ReturnedValue name)
-    : function(Q_NULLPTR)
+void Heap::FunctionObject::init(QV4::ExecutionContext *scope, const ReturnedValue name)
 {
+    Object::init();
+    function = nullptr;
     this->scope = scope->d();
     Scope s(scope);
     ScopedFunctionObject f(s, this);
@@ -117,9 +122,10 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const Returne
     f->init(n, false);
 }
 
-Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const ReturnedValue name)
-    : function(Q_NULLPTR)
+void Heap::FunctionObject::init(ExecutionContext *scope, const ReturnedValue name)
 {
+    Object::init();
+    function = nullptr;
     this->scope = scope;
     Scope s(scope->engine);
     ScopedFunctionObject f(s, this);
@@ -127,9 +133,10 @@ Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const ReturnedValu
     f->init(n, false);
 }
 
-Heap::FunctionObject::FunctionObject()
-    : function(Q_NULLPTR)
+void Heap::FunctionObject::init()
 {
+    Object::init();
+    function = nullptr;
     this->scope = internalClass->engine->rootContext()->d();
     Q_ASSERT(internalClass && internalClass->find(internalClass->engine->id_prototype()) == Index_Prototype);
     *propertyData(Index_Prototype) = Encode::undefined();
@@ -227,7 +234,7 @@ QQmlSourceLocation FunctionObject::sourceLocation() const
 {
     if (isBinding()) {
         Q_ASSERT(as<const QV4::QQmlBindingFunction>());
-        return static_cast<QV4::Heap::QQmlBindingFunction *>(d())->bindingLocation;
+        return *static_cast<QV4::Heap::QQmlBindingFunction *>(d())->bindingLocation;
     }
     QV4::Function *function = d()->function;
     Q_ASSERT(function);
@@ -237,9 +244,9 @@ QQmlSourceLocation FunctionObject::sourceLocation() const
 
 DEFINE_OBJECT_VTABLE(FunctionCtor);
 
-Heap::FunctionCtor::FunctionCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("Function"))
+void Heap::FunctionCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("Function"));
 }
 
 // 15.3.2
@@ -305,8 +312,9 @@ void FunctionCtor::call(const Managed *that, Scope &scope, CallData *callData)
 
 DEFINE_OBJECT_VTABLE(FunctionPrototype);
 
-Heap::FunctionPrototype::FunctionPrototype()
+void Heap::FunctionPrototype::init()
 {
+    Heap::FunctionObject::init();
 }
 
 void FunctionPrototype::init(ExecutionEngine *engine, Object *ctor)
@@ -417,9 +425,9 @@ ReturnedValue FunctionPrototype::method_bind(CallContext *ctx)
 
 DEFINE_OBJECT_VTABLE(ScriptFunction);
 
-Heap::ScriptFunction::ScriptFunction(QV4::ExecutionContext *scope, Function *function)
-    : Heap::SimpleScriptFunction(scope, function, true)
+void Heap::ScriptFunction::init(QV4::ExecutionContext *scope, Function *function)
 {
+    Heap::SimpleScriptFunction::init(scope, function, true);
 }
 
 void ScriptFunction::construct(const Managed *that, Scope &scope, CallData *callData)
@@ -478,8 +486,9 @@ void ScriptFunction::call(const Managed *that, Scope &scope, CallData *callData)
 
 DEFINE_OBJECT_VTABLE(SimpleScriptFunction);
 
-Heap::SimpleScriptFunction::SimpleScriptFunction(QV4::ExecutionContext *scope, Function *function, bool createProto)
+void Heap::SimpleScriptFunction::init(QV4::ExecutionContext *scope, Function *function, bool createProto)
 {
+    FunctionObject::init();
     this->scope = scope->d();
 
     this->function = function;
@@ -599,10 +608,10 @@ Heap::Object *SimpleScriptFunction::protoForConstructor()
 
 DEFINE_OBJECT_VTABLE(BuiltinFunction);
 
-Heap::BuiltinFunction::BuiltinFunction(QV4::ExecutionContext *scope, QV4::String *name, ReturnedValue (*code)(QV4::CallContext *))
-    : Heap::FunctionObject(scope, name)
-    , code(code)
+void Heap::BuiltinFunction::init(QV4::ExecutionContext *scope, QV4::String *name, ReturnedValue (*code)(QV4::CallContext *))
 {
+    Heap::FunctionObject::init(scope, name);
+    this->code = code;
 }
 
 void BuiltinFunction::construct(const Managed *f, Scope &scope, CallData *)
@@ -656,10 +665,10 @@ DEFINE_OBJECT_VTABLE(IndexedBuiltinFunction);
 
 DEFINE_OBJECT_VTABLE(BoundFunction);
 
-Heap::BoundFunction::BoundFunction(QV4::ExecutionContext *scope, QV4::FunctionObject *target,
-                                   const Value &boundThis, QV4::MemberData *boundArgs)
-    : Heap::FunctionObject(scope, QStringLiteral("__bound function__"))
+void Heap::BoundFunction::init(QV4::ExecutionContext *scope, QV4::FunctionObject *target,
+                               const Value &boundThis, QV4::MemberData *boundArgs)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("__bound function__"));
     this->target = target->d();
     this->boundArgs = boundArgs ? boundArgs->d() : 0;
     this->boundThis = boundThis;
diff --git a/src/qml/jsruntime/qv4functionobject_p.h b/src/qml/jsruntime/qv4functionobject_p.h
index f5a9376b9e..e58b83e2c3 100644
--- a/src/qml/jsruntime/qv4functionobject_p.h
+++ b/src/qml/jsruntime/qv4functionobject_p.h
@@ -69,13 +69,13 @@ struct Q_QML_PRIVATE_EXPORT FunctionObject : Object {
         Index_ProtoConstructor = 0
     };
 
-    FunctionObject(QV4::ExecutionContext *scope, QV4::String *name, bool createProto = false);
-    FunctionObject(QV4::ExecutionContext *scope, QV4::Function *function, bool createProto = false);
-    FunctionObject(QV4::ExecutionContext *scope, const QString &name = QString(), bool createProto = false);
-    FunctionObject(ExecutionContext *scope, const QString &name = QString(), bool createProto = false);
-    FunctionObject(QV4::ExecutionContext *scope, const ReturnedValue name);
-    FunctionObject(ExecutionContext *scope, const ReturnedValue name);
-    FunctionObject();
+    void init(QV4::ExecutionContext *scope, QV4::String *name, bool createProto = false);
+    void init(QV4::ExecutionContext *scope, QV4::Function *function, bool createProto = false);
+    void init(QV4::ExecutionContext *scope, const QString &name = QString(), bool createProto = false);
+    void init(ExecutionContext *scope, const QString &name = QString(), bool createProto = false);
+    void init(QV4::ExecutionContext *scope, const ReturnedValue name);
+    void init(ExecutionContext *scope, const ReturnedValue name);
+    void init();
     void destroy();
 
     unsigned int formalParameterCount() { return function ? function->nFormals : 0; }
@@ -87,20 +87,20 @@ struct Q_QML_PRIVATE_EXPORT FunctionObject : Object {
 };
 
 struct FunctionCtor : FunctionObject {
-    FunctionCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 struct FunctionPrototype : FunctionObject {
-    FunctionPrototype();
+    void init();
 };
 
 struct Q_QML_EXPORT BuiltinFunction : FunctionObject {
-    BuiltinFunction(QV4::ExecutionContext *scope, QV4::String *name, ReturnedValue (*code)(QV4::CallContext *));
+    void init(QV4::ExecutionContext *scope, QV4::String *name, ReturnedValue (*code)(QV4::CallContext *));
     ReturnedValue (*code)(QV4::CallContext *);
 };
 
 struct IndexedBuiltinFunction : FunctionObject {
-    inline IndexedBuiltinFunction(QV4::ExecutionContext *scope, uint index, ReturnedValue (*code)(QV4::CallContext *ctx, uint index));
+    inline void init(QV4::ExecutionContext *scope, uint index, ReturnedValue (*code)(QV4::CallContext *ctx, uint index));
     ReturnedValue (*code)(QV4::CallContext *, uint index);
     uint index;
 };
@@ -110,15 +110,15 @@ struct SimpleScriptFunction : FunctionObject {
         Index_Name = FunctionObject::Index_Prototype + 1,
         Index_Length
     };
-    SimpleScriptFunction(QV4::ExecutionContext *scope, Function *function, bool createProto);
+    void init(QV4::ExecutionContext *scope, Function *function, bool createProto);
 };
 
 struct ScriptFunction : SimpleScriptFunction {
-    ScriptFunction(QV4::ExecutionContext *scope, Function *function);
+    void init(QV4::ExecutionContext *scope, Function *function);
 };
 
 struct BoundFunction : FunctionObject {
-    BoundFunction(QV4::ExecutionContext *scope, QV4::FunctionObject *target, const Value &boundThis, QV4::MemberData *boundArgs);
+    void init(QV4::ExecutionContext *scope, QV4::FunctionObject *target, const Value &boundThis, QV4::MemberData *boundArgs);
     Pointer<FunctionObject> target;
     Value boundThis;
     Pointer<MemberData> boundArgs;
@@ -216,12 +216,12 @@ struct IndexedBuiltinFunction: FunctionObject
     static void call(const Managed *that, Scope &scope, CallData *callData);
 };
 
-Heap::IndexedBuiltinFunction::IndexedBuiltinFunction(QV4::ExecutionContext *scope, uint index,
-                                                     ReturnedValue (*code)(QV4::CallContext *ctx, uint index))
-    : Heap::FunctionObject(scope),
-      code(code)
-    , index(index)
+void Heap::IndexedBuiltinFunction::init(QV4::ExecutionContext *scope, uint index,
+                                        ReturnedValue (*code)(QV4::CallContext *ctx, uint index))
 {
+    Heap::FunctionObject::init(scope);
+    this->index = index;
+    this->code = code;
 }
 
 
diff --git a/src/qml/jsruntime/qv4globalobject.cpp b/src/qml/jsruntime/qv4globalobject.cpp
index b88e271a26..feb0d90d26 100644
--- a/src/qml/jsruntime/qv4globalobject.cpp
+++ b/src/qml/jsruntime/qv4globalobject.cpp
@@ -330,9 +330,9 @@ static QString decode(const QString &input, DecodeMode decodeMode, bool *ok)
 
 DEFINE_OBJECT_VTABLE(EvalFunction);
 
-Heap::EvalFunction::EvalFunction(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, scope->d()->engine->id_eval())
+void Heap::EvalFunction::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, scope->d()->engine->id_eval());
     Scope s(scope);
     ScopedFunctionObject f(s, this);
     f->defineReadonlyProperty(s.engine->id_length(), Primitive::fromInt32(1));
diff --git a/src/qml/jsruntime/qv4globalobject_p.h b/src/qml/jsruntime/qv4globalobject_p.h
index 403639f8c1..e8b3a92d34 100644
--- a/src/qml/jsruntime/qv4globalobject_p.h
+++ b/src/qml/jsruntime/qv4globalobject_p.h
@@ -60,7 +60,7 @@ namespace QV4 {
 namespace Heap {
 
 struct EvalFunction : FunctionObject {
-    EvalFunction(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4jsonobject.cpp b/src/qml/jsruntime/qv4jsonobject.cpp
index 5b665d8836..9636fefc14 100644
--- a/src/qml/jsruntime/qv4jsonobject.cpp
+++ b/src/qml/jsruntime/qv4jsonobject.cpp
@@ -867,8 +867,9 @@ QString Stringify::JA(ArrayObject *a)
 }
 
 
-Heap::JsonObject::JsonObject()
+void Heap::JsonObject::init()
 {
+    Object::init();
     Scope scope(internalClass->engine);
     ScopedObject o(scope, this);
 
diff --git a/src/qml/jsruntime/qv4jsonobject_p.h b/src/qml/jsruntime/qv4jsonobject_p.h
index c3a3b191c0..43248a214d 100644
--- a/src/qml/jsruntime/qv4jsonobject_p.h
+++ b/src/qml/jsruntime/qv4jsonobject_p.h
@@ -64,7 +64,7 @@ namespace QV4 {
 namespace Heap {
 
 struct JsonObject : Object {
-    JsonObject();
+    void init();
 };
 
 }
diff --git a/src/qml/jsruntime/qv4managed_p.h b/src/qml/jsruntime/qv4managed_p.h
index b56155b5db..0359559f34 100644
--- a/src/qml/jsruntime/qv4managed_p.h
+++ b/src/qml/jsruntime/qv4managed_p.h
@@ -88,9 +88,10 @@ inline void qYouForgotTheQ_MANAGED_Macro(T1, T2) {}
         QV4::Heap::DataClass *d_unchecked() const { return static_cast<QV4::Heap::DataClass *>(m()); } \
         QV4::Heap::DataClass *d() const { \
             QV4::Heap::DataClass *dptr = d_unchecked(); \
-            if (std::is_trivial<QV4::Heap::DataClass>::value) dptr->_checkIsInitialized(); \
+            dptr->_checkIsInitialized(); \
             return dptr; \
-        }
+        } \
+        V4_ASSERT_IS_TRIVIAL(QV4::Heap::DataClass)
 
 #define V4_MANAGED(DataClass, superClass) \
     private: \
diff --git a/src/qml/jsruntime/qv4mathobject.cpp b/src/qml/jsruntime/qv4mathobject.cpp
index 9fe8224736..e03b2762cc 100644
--- a/src/qml/jsruntime/qv4mathobject.cpp
+++ b/src/qml/jsruntime/qv4mathobject.cpp
@@ -51,8 +51,9 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(MathObject);
 
-Heap::MathObject::MathObject()
+void Heap::MathObject::init()
 {
+    Object::init();
     Scope scope(internalClass->engine);
     ScopedObject m(scope, this);
 
diff --git a/src/qml/jsruntime/qv4mathobject_p.h b/src/qml/jsruntime/qv4mathobject_p.h
index 01e778d9ec..f6b1a4395f 100644
--- a/src/qml/jsruntime/qv4mathobject_p.h
+++ b/src/qml/jsruntime/qv4mathobject_p.h
@@ -59,7 +59,7 @@ namespace QV4 {
 namespace Heap {
 
 struct MathObject : Object {
-    MathObject();
+    void init();
 };
 
 }
diff --git a/src/qml/jsruntime/qv4memberdata_p.h b/src/qml/jsruntime/qv4memberdata_p.h
index 41da730428..969eee3619 100644
--- a/src/qml/jsruntime/qv4memberdata_p.h
+++ b/src/qml/jsruntime/qv4memberdata_p.h
@@ -66,7 +66,7 @@ struct MemberData : Base {
     };
     Value data[1];
 };
-Q_STATIC_ASSERT(std::is_trivial<MemberData>::value);
+V4_ASSERT_IS_TRIVIAL(MemberData)
 
 }
 
diff --git a/src/qml/jsruntime/qv4numberobject.cpp b/src/qml/jsruntime/qv4numberobject.cpp
index f8e0d8763b..1733df34ae 100644
--- a/src/qml/jsruntime/qv4numberobject.cpp
+++ b/src/qml/jsruntime/qv4numberobject.cpp
@@ -71,9 +71,9 @@ const NumberLocale *NumberLocale::instance()
     return numberLocaleHolder();
 }
 
-Heap::NumberCtor::NumberCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("Number"))
+void Heap::NumberCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("Number"));
 }
 
 void NumberCtor::construct(const Managed *, Scope &scope, CallData *callData)
diff --git a/src/qml/jsruntime/qv4numberobject_p.h b/src/qml/jsruntime/qv4numberobject_p.h
index 2416165c78..6022b3a029 100644
--- a/src/qml/jsruntime/qv4numberobject_p.h
+++ b/src/qml/jsruntime/qv4numberobject_p.h
@@ -61,7 +61,7 @@ namespace QV4 {
 namespace Heap {
 
 struct NumberCtor : FunctionObject {
-    NumberCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4object.cpp b/src/qml/jsruntime/qv4object.cpp
index aeb185049f..00e6d230da 100644
--- a/src/qml/jsruntime/qv4object.cpp
+++ b/src/qml/jsruntime/qv4object.cpp
@@ -1160,10 +1160,10 @@ void Object::initSparseArray()
 
 DEFINE_OBJECT_VTABLE(ArrayObject);
 
-Heap::ArrayObject::ArrayObject(const QStringList &list)
-    : Heap::Object()
+void Heap::ArrayObject::init(const QStringList &list)
 {
-    init();
+    Object::init();
+    commonInit();
     Scope scope(internalClass->engine);
     ScopedObject a(scope, this);
 
diff --git a/src/qml/jsruntime/qv4object_p.h b/src/qml/jsruntime/qv4object_p.h
index 54ce2ea60d..6ddeb84d3c 100644
--- a/src/qml/jsruntime/qv4object_p.h
+++ b/src/qml/jsruntime/qv4object_p.h
@@ -68,7 +68,7 @@ namespace QV4 {
 namespace Heap {
 
 struct Object : Base {
-    inline Object() { Base::init(); }
+    void init() { Base::init(); }
 
     const Value *propertyData(uint index) const { if (index < inlineMemberSize) return reinterpret_cast<const Value *>(this) + inlineMemberOffset + index; return memberData->data + index - inlineMemberSize; }
     Value *propertyData(uint index) { if (index < inlineMemberSize) return reinterpret_cast<Value *>(this) + inlineMemberOffset + index; return memberData->data + index - inlineMemberSize; }
@@ -93,9 +93,10 @@ struct Object : Base {
         Data *d_unchecked() const { return static_cast<Data *>(m()); } \
         Data *d() const { \
             Data *dptr = d_unchecked(); \
-            if (std::is_trivial<Data>::value) dptr->_checkIsInitialized(); \
+            dptr->_checkIsInitialized(); \
             return dptr; \
-        }
+        } \
+        V4_ASSERT_IS_TRIVIAL(Data);
 
 #define V4_OBJECT2(DataClass, superClass) \
     private: \
@@ -111,9 +112,10 @@ struct Object : Base {
         QV4::Heap::DataClass *d_unchecked() const { return static_cast<QV4::Heap::DataClass *>(m()); } \
         QV4::Heap::DataClass *d() const { \
             QV4::Heap::DataClass *dptr = d_unchecked(); \
-            if (std::is_trivial<QV4::Heap::DataClass>::value) dptr->_checkIsInitialized(); \
+            dptr->_checkIsInitialized(); \
             return dptr; \
-        }
+        } \
+        V4_ASSERT_IS_TRIVIAL(QV4::Heap::DataClass);
 
 #define V4_INTERNALCLASS(c) \
     static QV4::InternalClass *defaultInternalClass(QV4::ExecutionEngine *e) \
@@ -375,18 +377,22 @@ private:
 namespace Heap {
 
 struct BooleanObject : Object {
-    BooleanObject() {}
-    BooleanObject(bool b)
-        : b(b)
-    {}
+    void init() { Object::init(); }
+    void init(bool b) {
+        Object::init();
+        this->b = b;
+    }
+
     bool b;
 };
 
 struct NumberObject : Object {
-    NumberObject() {}
-    NumberObject(double val)
-        : value(val)
-    {}
+    void init() { Object::init(); }
+    void init(double val) {
+        Object::init();
+        value = val;
+    }
+
     double value;
 };
 
@@ -395,10 +401,15 @@ struct ArrayObject : Object {
         LengthPropertyIndex = 0
     };
 
-    ArrayObject()
-    { init(); }
-    ArrayObject(const QStringList &list);
-    void init()
+    void init() {
+        Object::init();
+        commonInit();
+    }
+
+    void init(const QStringList &list);
+
+private:
+    void commonInit()
     { *propertyData(LengthPropertyIndex) = Primitive::fromInt32(0); }
 };
 
diff --git a/src/qml/jsruntime/qv4objectiterator.cpp b/src/qml/jsruntime/qv4objectiterator.cpp
index 4354e09248..7943a13ac0 100644
--- a/src/qml/jsruntime/qv4objectiterator.cpp
+++ b/src/qml/jsruntime/qv4objectiterator.cpp
@@ -45,30 +45,6 @@
 
 using namespace QV4;
 
-ObjectIterator::ObjectIterator(ExecutionEngine *e, Value *scratch1, Value *scratch2, Object *o, uint flags)
-    : engine(e)
-    , object(scratch1)
-    , current(scratch2)
-    , arrayNode(0)
-    , arrayIndex(0)
-    , memberIndex(0)
-    , flags(flags)
-{
-    init(o);
-}
-
-ObjectIterator::ObjectIterator(Scope &scope, const Object *o, uint flags)
-    : engine(scope.engine)
-    , object(scope.alloc(1))
-    , current(scope.alloc(1))
-    , arrayNode(0)
-    , arrayIndex(0)
-    , memberIndex(0)
-    , flags(flags)
-{
-    init(o);
-}
-
 void ObjectIterator::init(const Object *o)
 {
     object->setM(o ? o->m() : 0);
diff --git a/src/qml/jsruntime/qv4objectiterator_p.h b/src/qml/jsruntime/qv4objectiterator_p.h
index 6bef703a4d..98e94a95ea 100644
--- a/src/qml/jsruntime/qv4objectiterator_p.h
+++ b/src/qml/jsruntime/qv4objectiterator_p.h
@@ -57,7 +57,7 @@ QT_BEGIN_NAMESPACE
 
 namespace QV4 {
 
-struct Q_QML_EXPORT ObjectIterator
+struct Q_QML_EXPORT ObjectIteratorData
 {
     enum Flags {
         NoFlags = 0,
@@ -72,21 +72,52 @@ struct Q_QML_EXPORT ObjectIterator
     uint arrayIndex;
     uint memberIndex;
     uint flags;
+};
+V4_ASSERT_IS_TRIVIAL(ObjectIteratorData)
+
+struct Q_QML_EXPORT ObjectIterator: ObjectIteratorData
+{
+    ObjectIterator(ExecutionEngine *e, Value *scratch1, Value *scratch2, Object *o, uint flags)
+    {
+        engine = e;
+        object = scratch1;
+        current = scratch2;
+        arrayNode = nullptr;
+        arrayIndex = 0;
+        memberIndex = 0;
+        this->flags = flags;
+        init(o);
+    }
+
+    ObjectIterator(Scope &scope, const Object *o, uint flags)
+    {
+        engine = scope.engine;
+        object = scope.alloc(1);
+        current = scope.alloc(1);
+        arrayNode = nullptr;
+        arrayIndex = 0;
+        memberIndex = 0;
+        this->flags = flags;
+        init(o);
+    }
 
-    ObjectIterator(ExecutionEngine *e, Value *scratch1, Value *scratch2, Object *o, uint flags);
-    ObjectIterator(Scope &scope, const Object *o, uint flags);
-    void init(const Object *o);
     void next(Value *name, uint *index, Property *pd, PropertyAttributes *attributes = 0);
     ReturnedValue nextPropertyName(Value *value);
     ReturnedValue nextPropertyNameAsString(Value *value);
     ReturnedValue nextPropertyNameAsString();
+
+private:
+    void init(const Object *o);
 };
 
 namespace Heap {
 struct ForEachIteratorObject : Object {
-    ForEachIteratorObject(QV4::Object *o);
-    ObjectIterator it;
+    void init(QV4::Object *o);
+    ObjectIterator &it() { return *reinterpret_cast<ObjectIterator*>(&itData); }
     Value workArea[2];
+
+private:
+    ObjectIteratorData itData;
 };
 
 }
@@ -95,16 +126,18 @@ struct ForEachIteratorObject: Object {
     V4_OBJECT2(ForEachIteratorObject, Object)
     Q_MANAGED_TYPE(ForeachIteratorObject)
 
-    ReturnedValue nextPropertyName() { return d()->it.nextPropertyNameAsString(); }
+    ReturnedValue nextPropertyName() { return d()->it().nextPropertyNameAsString(); }
 
 protected:
     static void markObjects(Heap::Base *that, ExecutionEngine *e);
 };
 
 inline
-Heap::ForEachIteratorObject::ForEachIteratorObject(QV4::Object *o)
-    : it(internalClass->engine, workArea, workArea + 1, o, ObjectIterator::EnumerableOnly|ObjectIterator::WithProtoChain)
+void Heap::ForEachIteratorObject::init(QV4::Object *o)
 {
+    Object::init();
+    it() = ObjectIterator(internalClass->engine, workArea, workArea + 1, o,
+                          ObjectIterator::EnumerableOnly | ObjectIterator::WithProtoChain);
 }
 
 
diff --git a/src/qml/jsruntime/qv4objectproto.cpp b/src/qml/jsruntime/qv4objectproto.cpp
index cfd76166f2..6020c48250 100644
--- a/src/qml/jsruntime/qv4objectproto.cpp
+++ b/src/qml/jsruntime/qv4objectproto.cpp
@@ -54,9 +54,9 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(ObjectCtor);
 
-Heap::ObjectCtor::ObjectCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("Object"))
+void Heap::ObjectCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("Object"));
 }
 
 void ObjectCtor::construct(const Managed *that, Scope &scope, CallData *callData)
diff --git a/src/qml/jsruntime/qv4objectproto_p.h b/src/qml/jsruntime/qv4objectproto_p.h
index 47a37b196f..e3d85782d5 100644
--- a/src/qml/jsruntime/qv4objectproto_p.h
+++ b/src/qml/jsruntime/qv4objectproto_p.h
@@ -61,7 +61,7 @@ namespace QV4 {
 namespace Heap {
 
 struct ObjectCtor : FunctionObject {
-    ObjectCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index c977573b9b..fc3d147c1d 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -195,8 +195,9 @@ static QV4::ReturnedValue loadProperty(QV4::ExecutionEngine *v4, QObject *object
     }
 }
 
-Heap::QObjectWrapper::QObjectWrapper(QObject *object)
+void Heap::QObjectWrapper::init(QObject *object)
 {
+    Object::init();
     qObj.init(object);
 }
 
@@ -1680,7 +1681,7 @@ ReturnedValue QObjectMethod::create(ExecutionContext *scope, QObject *object, in
     method->d()->setObject(object);
 
     if (QQmlData *ddata = QQmlData::get(object))
-        method->d()->propertyCache = ddata->propertyCache;
+        method->d()->setPropertyCache(ddata->propertyCache);
 
     method->d()->index = index;
     return method.asReturnedValue();
@@ -1690,21 +1691,21 @@ ReturnedValue QObjectMethod::create(ExecutionContext *scope, const QQmlValueType
 {
     Scope valueScope(scope);
     Scoped<QObjectMethod> method(valueScope, valueScope.engine->memoryManager->allocObject<QObjectMethod>(scope));
-    method->d()->propertyCache = valueType->d()->propertyCache;
+    method->d()->setPropertyCache(valueType->d()->propertyCache());
     method->d()->index = index;
     method->d()->valueTypeWrapper = valueType->d();
     return method.asReturnedValue();
 }
 
-Heap::QObjectMethod::QObjectMethod(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope)
+void Heap::QObjectMethod::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope);
 }
 
 const QMetaObject *Heap::QObjectMethod::metaObject()
 {
-    if (propertyCache)
-        return propertyCache->createMetaObject();
+    if (propertyCache())
+        return propertyCache()->createMetaObject();
     return object()->metaObject();
 }
 
@@ -1776,13 +1777,13 @@ void QObjectMethod::callInternal(CallData *callData, Scope &scope) const
             return;
         }
 
-        object = QQmlObjectOrGadget(d()->propertyCache.data(), d()->valueTypeWrapper->gadgetPtr);
+        object = QQmlObjectOrGadget(d()->propertyCache(), d()->valueTypeWrapper->gadgetPtr);
     }
 
     QQmlPropertyData method;
 
-    if (d()->propertyCache) {
-        QQmlPropertyData *data = d()->propertyCache->method(d()->index);
+    if (d()->propertyCache()) {
+        QQmlPropertyData *data = d()->propertyCache()->method(d()->index);
         if (!data) {
             scope.result = QV4::Encode::undefined();
             return;
@@ -1825,7 +1826,7 @@ void QObjectMethod::callInternal(CallData *callData, Scope &scope) const
     if (!method.isOverload()) {
         scope.result = CallPrecise(object, method, v4, callData);
     } else {
-        scope.result = CallOverloaded(object, method, v4, callData, d()->propertyCache);
+        scope.result = CallOverloaded(object, method, v4, callData, d()->propertyCache());
     }
 }
 
@@ -1841,11 +1842,13 @@ void QObjectMethod::markObjects(Heap::Base *that, ExecutionEngine *e)
 DEFINE_OBJECT_VTABLE(QObjectMethod);
 
 
-Heap::QMetaObjectWrapper::QMetaObjectWrapper(const QMetaObject *metaObject)
-    : metaObject(metaObject)
-    , constructors(nullptr)
-    , constructorCount(0)
-{}
+void Heap::QMetaObjectWrapper::init(const QMetaObject *metaObject)
+{
+    FunctionObject::init();
+    this->metaObject = metaObject;
+    constructors = nullptr;
+    constructorCount = 0;
+}
 
 void Heap::QMetaObjectWrapper::destroy()
 {
@@ -2013,9 +2016,10 @@ DEFINE_OBJECT_VTABLE(QMetaObjectWrapper);
 
 
 
-Heap::QmlSignalHandler::QmlSignalHandler(QObject *object, int signalIndex)
-    : signalIndex(signalIndex)
+void Heap::QmlSignalHandler::init(QObject *object, int signalIndex)
 {
+    Object::init();
+    this->signalIndex = signalIndex;
     setObject(object);
 }
 
@@ -2023,7 +2027,7 @@ DEFINE_OBJECT_VTABLE(QmlSignalHandler);
 
 void QmlSignalHandler::initProto(ExecutionEngine *engine)
 {
-    if (engine->signalHandlerPrototype()->d())
+    if (engine->signalHandlerPrototype()->d_unchecked())
         return;
 
     Scope scope(engine);
diff --git a/src/qml/jsruntime/qv4qobjectwrapper_p.h b/src/qml/jsruntime/qv4qobjectwrapper_p.h
index 37397db55b..727af6c9c6 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper_p.h
+++ b/src/qml/jsruntime/qv4qobjectwrapper_p.h
@@ -78,7 +78,7 @@ namespace Heap {
 struct QQmlValueTypeWrapper;
 
 struct QObjectWrapper : Object {
-    QObjectWrapper(QObject *object);
+    void init(QObject *object);
     void destroy() { qObj.destroy(); }
 
     QObject *object() const { return qObj.data(); }
@@ -88,16 +88,22 @@ private:
 };
 
 struct QObjectMethod : FunctionObject {
-    QObjectMethod(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
     void destroy()
     {
-        propertyCache = nullptr;
+        setPropertyCache(nullptr);
         qObj.destroy();
         FunctionObject::destroy();
     }
 
-    QQmlRefPointer<QQmlPropertyCache> propertyCache;
-    int index;
+    QQmlPropertyCache *propertyCache() const { return _propertyCache; }
+    void setPropertyCache(QQmlPropertyCache *c) {
+        if (c)
+            c->addref();
+        if (_propertyCache)
+            _propertyCache->release();
+        _propertyCache = c;
+    }
 
     Pointer<QQmlValueTypeWrapper> valueTypeWrapper;
 
@@ -107,6 +113,10 @@ struct QObjectMethod : FunctionObject {
 
 private:
     QQmlQPointer<QObject> qObj;
+    QQmlPropertyCache *_propertyCache;
+
+public:
+    int index;
 };
 
 struct QMetaObjectWrapper : FunctionObject {
@@ -114,13 +124,13 @@ struct QMetaObjectWrapper : FunctionObject {
     QQmlPropertyData *constructors;
     int constructorCount;
 
-    QMetaObjectWrapper(const QMetaObject* metaObject);
+    void init(const QMetaObject* metaObject);
     void destroy();
     void ensureConstructorsCache();
 };
 
 struct QmlSignalHandler : Object {
-    QmlSignalHandler(QObject *object, int signalIndex);
+    void init(QObject *object, int signalIndex);
     void destroy() { qObj.destroy(); }
     int signalIndex;
 
diff --git a/src/qml/jsruntime/qv4regexp_p.h b/src/qml/jsruntime/qv4regexp_p.h
index b3bdeada94..d3e63375a5 100644
--- a/src/qml/jsruntime/qv4regexp_p.h
+++ b/src/qml/jsruntime/qv4regexp_p.h
@@ -91,7 +91,7 @@ struct RegExp : Base {
 
     int captureCount() const { return subPatternCount + 1; }
 };
-Q_STATIC_ASSERT(std::is_trivial<RegExp>::value);
+V4_ASSERT_IS_TRIVIAL(RegExp)
 
 }
 
diff --git a/src/qml/jsruntime/qv4regexpobject.cpp b/src/qml/jsruntime/qv4regexpobject.cpp
index b8780b8c53..4022d98c3f 100644
--- a/src/qml/jsruntime/qv4regexpobject.cpp
+++ b/src/qml/jsruntime/qv4regexpobject.cpp
@@ -69,8 +69,9 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(RegExpObject);
 
-Heap::RegExpObject::RegExpObject()
+void Heap::RegExpObject::init()
 {
+    Object::init();
     Scope scope(internalClass->engine);
     Scoped<QV4::RegExpObject> o(scope, this);
     o->d()->value = QV4::RegExp::create(scope.engine, QString(), false, false);
@@ -78,9 +79,10 @@ Heap::RegExpObject::RegExpObject()
     o->initProperties();
 }
 
-Heap::RegExpObject::RegExpObject(QV4::RegExp *value, bool global)
-    : global(global)
+void Heap::RegExpObject::init(QV4::RegExp *value, bool global)
 {
+    Object::init();
+    this->global = global;
     this->value = value->d();
     Scope scope(internalClass->engine);
     Scoped<QV4::RegExpObject> o(scope, this);
@@ -90,8 +92,9 @@ Heap::RegExpObject::RegExpObject(QV4::RegExp *value, bool global)
 // Converts a QRegExp to a JS RegExp.
 // The conversion is not 100% exact since ECMA regexp and QRegExp
 // have different semantics/flags, but we try to do our best.
-Heap::RegExpObject::RegExpObject(const QRegExp &re)
+void Heap::RegExpObject::init(const QRegExp &re)
 {
+    Object::init();
     global = false;
 
     // Convert the pattern to a ECMAScript pattern.
@@ -217,9 +220,9 @@ uint RegExpObject::flags() const
 
 DEFINE_OBJECT_VTABLE(RegExpCtor);
 
-Heap::RegExpCtor::RegExpCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("RegExp"))
+void Heap::RegExpCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("RegExp"));
     clearLastMatch();
 }
 
diff --git a/src/qml/jsruntime/qv4regexpobject_p.h b/src/qml/jsruntime/qv4regexpobject_p.h
index 655e120c16..2c82cfdfd1 100644
--- a/src/qml/jsruntime/qv4regexpobject_p.h
+++ b/src/qml/jsruntime/qv4regexpobject_p.h
@@ -74,16 +74,16 @@ namespace QV4 {
 namespace Heap {
 
 struct RegExpObject : Object {
-    RegExpObject();
-    RegExpObject(QV4::RegExp *value, bool global);
-    RegExpObject(const QRegExp &re);
+    void init();
+    void init(QV4::RegExp *value, bool global);
+    void init(const QRegExp &re);
 
     Pointer<RegExp> value;
     bool global;
 };
 
 struct RegExpCtor : FunctionObject {
-    RegExpCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
     Value lastMatch;
     Pointer<String> lastInput;
     int lastMatchStart;
diff --git a/src/qml/jsruntime/qv4script.cpp b/src/qml/jsruntime/qv4script.cpp
index e3475e5cd6..787047806a 100644
--- a/src/qml/jsruntime/qv4script.cpp
+++ b/src/qml/jsruntime/qv4script.cpp
@@ -65,7 +65,7 @@ namespace QV4 {
 namespace Heap {
 
 struct QmlBindingWrapper : FunctionObject {
-    QmlBindingWrapper(QV4::QmlContext *scope, Function *f);
+    void init(QV4::QmlContext *scope, Function *f);
 };
 
 }
@@ -84,9 +84,10 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(QmlBindingWrapper);
 
-Heap::QmlBindingWrapper::QmlBindingWrapper(QV4::QmlContext *scope, Function *f)
-    : Heap::FunctionObject(scope, scope->d()->engine->id_eval(), /*createProto = */ false)
+void Heap::QmlBindingWrapper::init(QV4::QmlContext *scope, Function *f)
 {
+    Heap::FunctionObject::init(scope, scope->d()->engine->id_eval(), /*createProto = */ false);
+
     Q_ASSERT(scope->inUse());
 
     function = f;
diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp
index fb9ef4a2b2..4b82a7d83f 100644
--- a/src/qml/jsruntime/qv4sequenceobject.cpp
+++ b/src/qml/jsruntime/qv4sequenceobject.cpp
@@ -216,8 +216,8 @@ namespace Heap {
 
 template <typename Container>
 struct QQmlSequence : Object {
-    QQmlSequence(const Container &container);
-    QQmlSequence(QObject *object, int propertyIndex);
+    void init(const Container &container);
+    void init(QObject *object, int propertyIndex);
     void destroy() {
         delete container;
         object.destroy();
@@ -557,11 +557,12 @@ public:
 
 
 template <typename Container>
-Heap::QQmlSequence<Container>::QQmlSequence(const Container &container)
-    : container(new Container(container))
-    , propertyIndex(-1)
-    , isReference(false)
+void Heap::QQmlSequence<Container>::init(const Container &container)
 {
+    Object::init();
+    this->container = new Container(container);
+    propertyIndex = -1;
+    isReference = false;
     object.init();
 
     QV4::Scope scope(internalClass->engine);
@@ -571,11 +572,12 @@ Heap::QQmlSequence<Container>::QQmlSequence(const Container &container)
 }
 
 template <typename Container>
-Heap::QQmlSequence<Container>::QQmlSequence(QObject *object, int propertyIndex)
-    : container(new Container)
-    , propertyIndex(propertyIndex)
-    , isReference(true)
+void Heap::QQmlSequence<Container>::init(QObject *object, int propertyIndex)
 {
+    Object::init();
+    this->container = new Container;
+    this->propertyIndex = propertyIndex;
+    isReference = true;
     this->object.init(object);
     QV4::Scope scope(internalClass->engine);
     QV4::Scoped<QV4::QQmlSequence<Container> > o(scope, this);
diff --git a/src/qml/jsruntime/qv4string_p.h b/src/qml/jsruntime/qv4string_p.h
index 40c5c8a263..df34ec0151 100644
--- a/src/qml/jsruntime/qv4string_p.h
+++ b/src/qml/jsruntime/qv4string_p.h
@@ -133,7 +133,7 @@ private:
     static void append(const String *data, QChar *ch);
 #endif
 };
-Q_STATIC_ASSERT(std::is_trivial<String>::value);
+V4_ASSERT_IS_TRIVIAL(String)
 
 }
 
diff --git a/src/qml/jsruntime/qv4stringobject.cpp b/src/qml/jsruntime/qv4stringobject.cpp
index 1c474fb18d..829ada0c1a 100644
--- a/src/qml/jsruntime/qv4stringobject.cpp
+++ b/src/qml/jsruntime/qv4stringobject.cpp
@@ -73,15 +73,17 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(StringObject);
 
-Heap::StringObject::StringObject()
+void Heap::StringObject::init()
 {
+    Object::init();
     Q_ASSERT(vtable() == QV4::StringObject::staticVTable());
     string = internalClass->engine->id_empty()->d();
     *propertyData(LengthPropertyIndex) = Primitive::fromInt32(0);
 }
 
-Heap::StringObject::StringObject(const QV4::String *str)
+void Heap::StringObject::init(const QV4::String *str)
 {
+    Object::init();
     string = str->d();
     *propertyData(LengthPropertyIndex) = Primitive::fromInt32(length());
 }
@@ -152,9 +154,9 @@ void StringObject::markObjects(Heap::Base *that, ExecutionEngine *e)
 
 DEFINE_OBJECT_VTABLE(StringCtor);
 
-Heap::StringCtor::StringCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("String"))
+void Heap::StringCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("String"));
 }
 
 void StringCtor::construct(const Managed *m, Scope &scope, CallData *callData)
diff --git a/src/qml/jsruntime/qv4stringobject_p.h b/src/qml/jsruntime/qv4stringobject_p.h
index 54425b0909..b9f9d44fe8 100644
--- a/src/qml/jsruntime/qv4stringobject_p.h
+++ b/src/qml/jsruntime/qv4stringobject_p.h
@@ -65,8 +65,8 @@ struct StringObject : Object {
         LengthPropertyIndex = 0
     };
 
-    StringObject();
-    StringObject(const QV4::String *string);
+    void init();
+    void init(const QV4::String *string);
     String *string;
 
     Heap::String *getIndex(uint index) const;
@@ -74,7 +74,7 @@ struct StringObject : Object {
 };
 
 struct StringCtor : FunctionObject {
-    StringCtor(QV4::ExecutionContext *scope);
+    void init(QV4::ExecutionContext *scope);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4typedarray.cpp b/src/qml/jsruntime/qv4typedarray.cpp
index ae5ebcad1b..009c573bf8 100644
--- a/src/qml/jsruntime/qv4typedarray.cpp
+++ b/src/qml/jsruntime/qv4typedarray.cpp
@@ -202,10 +202,10 @@ const TypedArrayOperations operations[Heap::TypedArray::NTypes] = {
 };
 
 
-Heap::TypedArrayCtor::TypedArrayCtor(QV4::ExecutionContext *scope, TypedArray::Type t)
-    : Heap::FunctionObject(scope, QLatin1String(operations[t].name))
-    , type(t)
+void Heap::TypedArrayCtor::init(QV4::ExecutionContext *scope, TypedArray::Type t)
 {
+    Heap::FunctionObject::init(scope, QLatin1String(operations[t].name));
+    type = t;
 }
 
 void TypedArrayCtor::construct(const Managed *m, Scope &scope, CallData *callData)
@@ -363,10 +363,11 @@ void TypedArrayCtor::call(const Managed *that, Scope &scope, CallData *callData)
     construct(that, scope, callData);
 }
 
-Heap::TypedArray::TypedArray(Type t)
-    : type(operations + t),
-      arrayType(t)
+void Heap::TypedArray::init(Type t)
 {
+    Object::init();
+    type = operations + t;
+    arrayType = t;
 }
 
 Heap::TypedArray *TypedArray::create(ExecutionEngine *e, Heap::TypedArray::Type t)
diff --git a/src/qml/jsruntime/qv4typedarray_p.h b/src/qml/jsruntime/qv4typedarray_p.h
index d96027b96a..0112d2e4a1 100644
--- a/src/qml/jsruntime/qv4typedarray_p.h
+++ b/src/qml/jsruntime/qv4typedarray_p.h
@@ -86,7 +86,7 @@ struct TypedArray : Object {
         NTypes
     };
 
-    TypedArray(Type t);
+    void init(Type t);
 
     const TypedArrayOperations *type;
     Pointer<ArrayBuffer> buffer;
@@ -96,13 +96,13 @@ struct TypedArray : Object {
 };
 
 struct TypedArrayCtor : FunctionObject {
-    TypedArrayCtor(QV4::ExecutionContext *scope, TypedArray::Type t);
+    void init(QV4::ExecutionContext *scope, TypedArray::Type t);
 
     TypedArray::Type type;
 };
 
 struct TypedArrayPrototype : Object {
-    inline TypedArrayPrototype(TypedArray::Type t);
+    inline void init(TypedArray::Type t);
     TypedArray::Type type;
 };
 
@@ -160,10 +160,11 @@ struct TypedArrayPrototype : Object
     static ReturnedValue method_subarray(CallContext *ctx);
 };
 
-inline
-Heap::TypedArrayPrototype::TypedArrayPrototype(TypedArray::Type t)
-    : type(t)
+inline void
+Heap::TypedArrayPrototype::init(TypedArray::Type t)
 {
+    Object::init();
+    type = t;
 }
 
 } // namespace QV4
diff --git a/src/qml/jsruntime/qv4value_p.h b/src/qml/jsruntime/qv4value_p.h
index 78cd4de9fb..6e28e21887 100644
--- a/src/qml/jsruntime/qv4value_p.h
+++ b/src/qml/jsruntime/qv4value_p.h
@@ -428,7 +428,7 @@ public:
     template<typename T>
     Value &operator=(const Scoped<T> &t);
 };
-Q_STATIC_ASSERT(std::is_trivial<Value>::value);
+V4_ASSERT_IS_TRIVIAL(Value)
 
 inline bool Value::isString() const
 {
diff --git a/src/qml/jsruntime/qv4variantobject.cpp b/src/qml/jsruntime/qv4variantobject.cpp
index eff4db268c..b26dd27913 100644
--- a/src/qml/jsruntime/qv4variantobject.cpp
+++ b/src/qml/jsruntime/qv4variantobject.cpp
@@ -50,13 +50,15 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(VariantObject);
 
-Heap::VariantObject::VariantObject()
+void Heap::VariantObject::init()
 {
+    Object::init();
     scarceData = new ExecutionEngine::ScarceResourceData;
 }
 
-Heap::VariantObject::VariantObject(const QVariant &value)
+void Heap::VariantObject::init(const QVariant &value)
 {
+    Object::init();
     scarceData = new ExecutionEngine::ScarceResourceData(value);
     if (isScarce())
         removeVmePropertyReference();
diff --git a/src/qml/jsruntime/qv4variantobject_p.h b/src/qml/jsruntime/qv4variantobject_p.h
index 5a6644bdcf..efaf5e1e65 100644
--- a/src/qml/jsruntime/qv4variantobject_p.h
+++ b/src/qml/jsruntime/qv4variantobject_p.h
@@ -66,8 +66,8 @@ namespace Heap {
 
 struct VariantObject : Object
 {
-    VariantObject();
-    VariantObject(const QVariant &value);
+    void init();
+    void init(const QVariant &value);
     void destroy() {
         Q_ASSERT(scarceData);
         if (isScarce())