Convert builtin methods to return a ReturnedValue

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

53 files changed, 1542 insertions, 1485 deletions

diff --git a/src/imports/localstorage/plugin.cpp b/src/imports/localstorage/plugin.cpp
index de89f120bc..83d73c5bc9 100644
--- a/src/imports/localstorage/plugin.cpp
+++ b/src/imports/localstorage/plugin.cpp
@@ -124,16 +124,16 @@ public:
 
 DEFINE_MANAGED_VTABLE(QQmlSqlDatabaseWrapper);
 
-static Value qmlsqldatabase_version(SimpleCallContext *ctx)
+static ReturnedValue qmlsqldatabase_version(SimpleCallContext *ctx)
 {
     QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
     if (!r || r->type != QQmlSqlDatabaseWrapper::Database)
         V4THROW_REFERENCE("Not a SQLDatabase object");
 
-    return Value::fromString(ctx->engine->newString(r->version));
+    return Value::fromString(ctx->engine->newString(r->version)).asReturnedValue();
 }
 
-static Value qmlsqldatabase_rows_length(SimpleCallContext *ctx)
+static ReturnedValue qmlsqldatabase_rows_length(SimpleCallContext *ctx)
 {
     QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
     if (!r || r->type != QQmlSqlDatabaseWrapper::Rows)
@@ -148,18 +148,18 @@ static Value qmlsqldatabase_rows_length(SimpleCallContext *ctx)
             s = 0;
         }
     }
-    return Value::fromInt32(s);
+    return Encode(s);
 }
 
-static Value qmlsqldatabase_rows_forwardOnly(SimpleCallContext *ctx)
+static ReturnedValue qmlsqldatabase_rows_forwardOnly(SimpleCallContext *ctx)
 {
     QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
     if (!r || r->type != QQmlSqlDatabaseWrapper::Rows)
         V4THROW_REFERENCE("Not a SQLDatabase::Rows object");
-    return Value::fromBoolean(r->sqlQuery.isForwardOnly());
+    return Encode(r->sqlQuery.isForwardOnly());
 }
 
-static Value qmlsqldatabase_rows_setForwardOnly(SimpleCallContext *ctx)
+static ReturnedValue qmlsqldatabase_rows_setForwardOnly(SimpleCallContext *ctx)
 {
     QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
     if (!r || r->type != QQmlSqlDatabaseWrapper::Rows)
@@ -168,7 +168,7 @@ static Value qmlsqldatabase_rows_setForwardOnly(SimpleCallContext *ctx)
         ctx->throwTypeError();
 
     r->sqlQuery.setForwardOnly(ctx->arguments[0].toBoolean());
-    return Value::undefinedValue();
+    return Encode::undefined();
 }
 
 QQmlSqlDatabaseData::~QQmlSqlDatabaseData()
@@ -191,7 +191,7 @@ static QString qmlsqldatabase_databaseFile(const QString& connectionName, QV8Eng
     return qmlsqldatabase_databasesPath(engine) + QDir::separator() + connectionName;
 }
 
-static Value qmlsqldatabase_rows_index(QQmlSqlDatabaseWrapper *r, ExecutionEngine *v4, quint32 index, bool *hasProperty = 0)
+static ReturnedValue qmlsqldatabase_rows_index(QQmlSqlDatabaseWrapper *r, ExecutionEngine *v4, quint32 index, bool *hasProperty = 0)
 {
     QV8Engine *v8 = v4->v8Engine;
 
@@ -209,11 +209,11 @@ static Value qmlsqldatabase_rows_index(QQmlSqlDatabaseWrapper *r, ExecutionEngin
         }
         if (hasProperty)
             *hasProperty = true;
-        return Value::fromObject(row);
+        return Value::fromObject(row).asReturnedValue();
     } else {
         if (hasProperty)
             *hasProperty = false;
-        return Value::undefinedValue();
+        return Value::undefinedValue().asReturnedValue();
     }
 }
 
@@ -223,10 +223,10 @@ ReturnedValue QQmlSqlDatabaseWrapper::getIndexed(Managed *m, uint index, bool *h
     if (!r || r->type != QQmlSqlDatabaseWrapper::Rows)
         return Object::getIndexed(m, index, hasProperty);
 
-    return qmlsqldatabase_rows_index(r, m->engine(), index, hasProperty).asReturnedValue();
+    return qmlsqldatabase_rows_index(r, m->engine(), index, hasProperty);
 }
 
-static Value qmlsqldatabase_rows_item(SimpleCallContext *ctx)
+static ReturnedValue qmlsqldatabase_rows_item(SimpleCallContext *ctx)
 {
     QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
     if (!r || r->type != QQmlSqlDatabaseWrapper::Rows)
@@ -235,7 +235,7 @@ static Value qmlsqldatabase_rows_item(SimpleCallContext *ctx)
     return qmlsqldatabase_rows_index(r, ctx->engine, ctx->argumentCount ? ctx->arguments[0].toUInt32() : 0);
 }
 
-static Value qmlsqldatabase_executeSql(SimpleCallContext *ctx)
+static ReturnedValue qmlsqldatabase_executeSql(SimpleCallContext *ctx)
 {
     QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
     if (!r || r->type != QQmlSqlDatabaseWrapper::Query)
@@ -307,13 +307,13 @@ static Value qmlsqldatabase_executeSql(SimpleCallContext *ctx)
     if (err)
         V4THROW_SQL(SQLEXCEPTION_DATABASE_ERR,query.lastError().text());
 
-    return result;
+    return result.asReturnedValue();
 }
 
-static Value qmlsqldatabase_changeVersion(SimpleCallContext *ctx)
+static ReturnedValue qmlsqldatabase_changeVersion(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 2)
-        return Value::undefinedValue();
+        return Encode::undefined();
 
     Scope scope(ctx);
 
@@ -370,10 +370,10 @@ static Value qmlsqldatabase_changeVersion(SimpleCallContext *ctx)
 #endif
     }
 
-    return Value::undefinedValue();
+    return Encode::undefined();
 }
 
-static Value qmlsqldatabase_transaction_shared(SimpleCallContext *ctx, bool readOnly)
+static ReturnedValue qmlsqldatabase_transaction_shared(SimpleCallContext *ctx, bool readOnly)
 {
     QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
     if (!r || r->type != QQmlSqlDatabaseWrapper::Database)
@@ -415,15 +415,15 @@ static Value qmlsqldatabase_transaction_shared(SimpleCallContext *ctx, bool read
             db.rollback();
     }
 
-    return Value::undefinedValue();
+    return Encode::undefined();
 }
 
-static Value qmlsqldatabase_transaction(SimpleCallContext *ctx)
+static ReturnedValue qmlsqldatabase_transaction(SimpleCallContext *ctx)
 {
     return qmlsqldatabase_transaction_shared(ctx, false);
 }
 
-static Value qmlsqldatabase_read_transaction(SimpleCallContext *ctx)
+static ReturnedValue qmlsqldatabase_read_transaction(SimpleCallContext *ctx)
 {
     return qmlsqldatabase_transaction_shared(ctx, true);
 }
diff --git a/src/particles/qquickv4particledata.cpp b/src/particles/qquickv4particledata.cpp
index 2cb95b4a91..1a574600e0 100644
--- a/src/particles/qquickv4particledata.cpp
+++ b/src/particles/qquickv4particledata.cpp
@@ -298,7 +298,7 @@ public:
     QV4::PersistentValue proto;
 };
 
-static QV4::Value particleData_discard(QV4::SimpleCallContext *ctx)
+static QV4::ReturnedValue particleData_discard(QV4::SimpleCallContext *ctx)
 {
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>();
 
@@ -306,101 +306,101 @@ static QV4::Value particleData_discard(QV4::SimpleCallContext *ctx)
         ctx->throwError(QStringLiteral("Not a valid ParticleData object"));
 
     r->datum->lifeSpan = 0; //Don't kill(), because it could still be in the middle of being created
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-static QV4::Value particleData_lifeLeft(QV4::SimpleCallContext *ctx)
+static QV4::ReturnedValue particleData_lifeLeft(QV4::SimpleCallContext *ctx)
 {
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>();
     if (!r || !r->datum)
         ctx->throwError(QStringLiteral("Not a valid ParticleData object"));
 
-    return QV4::Value::fromDouble(r->datum->lifeLeft());
+    return QV4::Encode(r->datum->lifeLeft());
 }
 
-static QV4::Value particleData_curSize(QV4::SimpleCallContext *ctx)
+static QV4::ReturnedValue particleData_curSize(QV4::SimpleCallContext *ctx)
 {
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>();
     if (!r || !r->datum)
         ctx->throwError(QStringLiteral("Not a valid ParticleData object"));
 
-    return QV4::Value::fromDouble(r->datum->curSize());
+    return QV4::Encode(r->datum->curSize());
 }
-#define COLOR_GETTER_AND_SETTER(VAR, NAME) static QV4::Value particleData_get_ ## NAME (QV4::SimpleCallContext *ctx) \
+#define COLOR_GETTER_AND_SETTER(VAR, NAME) static QV4::ReturnedValue particleData_get_ ## NAME (QV4::SimpleCallContext *ctx) \
 { \
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>(); \
     if (!r || !r->datum) \
         ctx->throwError(QStringLiteral("Not a valid ParticleData object")); \
 \
-    return QV4::Value::fromDouble((r->datum->color. VAR )/255.0);\
+    return QV4::Encode((r->datum->color. VAR )/255.0);\
 }\
 \
-static QV4::Value particleData_set_ ## NAME (QV4::SimpleCallContext *ctx)\
+static QV4::ReturnedValue particleData_set_ ## NAME (QV4::SimpleCallContext *ctx)\
 {\
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>(); \
     if (!r || !r->datum)\
         ctx->throwError(QStringLiteral("Not a valid ParticleData object"));\
 \
     r->datum->color. VAR = qMin(255, qMax(0, (int)floor(ctx->argument(0).toNumber() * 255.0)));\
-    return QV4::Value::undefinedValue(); \
+    return QV4::Encode::undefined(); \
 }
 
 
-#define SEMIBOOL_GETTER_AND_SETTER(VARIABLE) static QV4::Value particleData_get_ ## VARIABLE (QV4::SimpleCallContext *ctx) \
+#define SEMIBOOL_GETTER_AND_SETTER(VARIABLE) static QV4::ReturnedValue particleData_get_ ## VARIABLE (QV4::SimpleCallContext *ctx) \
 { \
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>(); \
     if (!r || !r->datum) \
         ctx->throwError(QStringLiteral("Not a valid ParticleData object")); \
 \
-    return QV4::Value::fromBoolean(r->datum-> VARIABLE);\
+    return QV4::Encode(r->datum-> VARIABLE);\
 }\
 \
-static QV4::Value particleData_set_ ## VARIABLE (QV4::SimpleCallContext *ctx)\
+static QV4::ReturnedValue particleData_set_ ## VARIABLE (QV4::SimpleCallContext *ctx)\
 {\
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>(); \
     if (!r || !r->datum)\
         ctx->throwError(QStringLiteral("Not a valid ParticleData object"));\
 \
     r->datum-> VARIABLE = ctx->argument(0).toBoolean() ? 1.0 : 0.0;\
-    return QV4::Value::undefinedValue(); \
+    return QV4::Encode::undefined(); \
 }
 
-#define FLOAT_GETTER_AND_SETTER(VARIABLE) static QV4::Value particleData_get_ ## VARIABLE (QV4::SimpleCallContext *ctx) \
+#define FLOAT_GETTER_AND_SETTER(VARIABLE) static QV4::ReturnedValue particleData_get_ ## VARIABLE (QV4::SimpleCallContext *ctx) \
 { \
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>(); \
     if (!r || !r->datum) \
         ctx->throwError(QStringLiteral("Not a valid ParticleData object")); \
 \
-    return QV4::Value::fromDouble(r->datum-> VARIABLE);\
+    return QV4::Encode(r->datum-> VARIABLE);\
 }\
 \
-static QV4::Value particleData_set_ ## VARIABLE (QV4::SimpleCallContext *ctx)\
+static QV4::ReturnedValue particleData_set_ ## VARIABLE (QV4::SimpleCallContext *ctx)\
 {\
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>(); \
     if (!r || !r->datum)\
         ctx->throwError(QStringLiteral("Not a valid ParticleData object"));\
 \
     r->datum-> VARIABLE = ctx->argument(0).toNumber();\
-    return QV4::Value::undefinedValue(); \
+    return QV4::Encode::undefined(); \
 }
 
-#define FAKE_FLOAT_GETTER_AND_SETTER(VARIABLE, GETTER, SETTER) static QV4::Value particleData_get_ ## VARIABLE (QV4::SimpleCallContext *ctx) \
+#define FAKE_FLOAT_GETTER_AND_SETTER(VARIABLE, GETTER, SETTER) static QV4::ReturnedValue particleData_get_ ## VARIABLE (QV4::SimpleCallContext *ctx) \
 { \
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>(); \
     if (!r || !r->datum) \
         ctx->throwError(QStringLiteral("Not a valid ParticleData object")); \
 \
-    return QV4::Value::fromDouble(r->datum-> GETTER ());\
+    return QV4::Encode(r->datum-> GETTER ());\
 }\
 \
-static QV4::Value particleData_set_ ## VARIABLE (QV4::SimpleCallContext *ctx)\
+static QV4::ReturnedValue particleData_set_ ## VARIABLE (QV4::SimpleCallContext *ctx)\
 {\
     QV4ParticleData *r = ctx->thisObject.as<QV4ParticleData>(); \
     if (!r || !r->datum)\
         ctx->throwError(QStringLiteral("Not a valid ParticleData object"));\
 \
     r->datum-> SETTER ( ctx->argument(0).toNumber() );\
-    return QV4::Value::undefinedValue(); \
+    return QV4::Encode::undefined(); \
 }
 
 #define REGISTER_ACCESSOR(PROTO, ENGINE, VARIABLE, NAME) \
diff --git a/src/qml/jsruntime/qv4argumentsobject.cpp b/src/qml/jsruntime/qv4argumentsobject.cpp
index f4ee1143c9..6c028de372 100644
--- a/src/qml/jsruntime/qv4argumentsobject.cpp
+++ b/src/qml/jsruntime/qv4argumentsobject.cpp
@@ -44,10 +44,10 @@
 
 using namespace QV4;
 
-static Value throwTypeError(SimpleCallContext *ctx)
+static ReturnedValue throwTypeError(SimpleCallContext *ctx)
 {
     ctx->throwTypeError();
-    return Value::undefinedValue();
+    return Value::undefinedValue().asReturnedValue();
 }
 
 DEFINE_MANAGED_VTABLE(ArgumentsObject);
diff --git a/src/qml/jsruntime/qv4arrayobject.cpp b/src/qml/jsruntime/qv4arrayobject.cpp
index c4c9994df7..10d8f4e5c1 100644
--- a/src/qml/jsruntime/qv4arrayobject.cpp
+++ b/src/qml/jsruntime/qv4arrayobject.cpp
@@ -128,14 +128,14 @@ uint ArrayPrototype::getLength(ExecutionContext *ctx, Object *o)
     return v->toUInt32();
 }
 
-Value ArrayPrototype::method_isArray(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_isArray(SimpleCallContext *ctx)
 {
     Value arg = ctx->argument(0);
     bool isArray = arg.asArrayObject();
-    return Value::fromBoolean(isArray);
+    return Value::fromBoolean(isArray).asReturnedValue();
 }
 
-Value ArrayPrototype::method_toString(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_toString(SimpleCallContext *ctx)
 {
     QV4::Scope scope(ctx);
     QV4::Object *o = ctx->thisObject.toObject(ctx);
@@ -144,17 +144,17 @@ Value ArrayPrototype::method_toString(SimpleCallContext *ctx)
     if (f) {
         ScopedCallData d(scope, 0);
         d->thisObject = ctx->thisObject;
-        return Value::fromReturnedValue(f->call(d));
+        return f->call(d);
     }
     return ObjectPrototype::method_toString(ctx);
 }
 
-Value ArrayPrototype::method_toLocaleString(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_toLocaleString(SimpleCallContext *ctx)
 {
     return method_toString(ctx);
 }
 
-Value ArrayPrototype::method_concat(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_concat(SimpleCallContext *ctx)
 {
     ArrayObject *result = ctx->engine->newArrayObject();
 
@@ -181,10 +181,10 @@ Value ArrayPrototype::method_concat(SimpleCallContext *ctx)
             result->arraySet(getLength(ctx, result), arg);
     }
 
-    return Value::fromObject(result);
+    return Value::fromObject(result).asReturnedValue();
 }
 
-Value ArrayPrototype::method_join(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_join(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Value arg = ctx->argument(0);
@@ -202,7 +202,7 @@ Value ArrayPrototype::method_join(SimpleCallContext *ctx)
     static QSet<Object *> visitedArrayElements;
 
     if (! r2 || visitedArrayElements.contains(self.getPointer()))
-        return Value::fromString(ctx, QString());
+        return Value::fromString(ctx, QString()).asReturnedValue();
 
     // avoid infinite recursion
     visitedArrayElements.insert(self.getPointer());
@@ -241,10 +241,10 @@ Value ArrayPrototype::method_join(SimpleCallContext *ctx)
     }
 
     visitedArrayElements.remove(self.getPointer());
-    return Value::fromString(ctx, R);
+    return Value::fromString(ctx, R).asReturnedValue();
 }
 
-Value ArrayPrototype::method_pop(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_pop(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -253,7 +253,7 @@ Value ArrayPrototype::method_pop(SimpleCallContext *ctx)
     if (!len) {
         if (!instance->isArrayObject())
             instance->put(ctx->engine->id_length, Value::fromInt32(0));
-        return Value::undefinedValue();
+        return Value::undefinedValue().asReturnedValue();
     }
 
     ScopedValue result(scope, instance->getIndexed(len - 1));
@@ -263,10 +263,10 @@ Value ArrayPrototype::method_pop(SimpleCallContext *ctx)
         instance->setArrayLengthUnchecked(len - 1);
     else
         instance->put(ctx->engine->id_length, Value::fromDouble(len - 1));
-    return result;
+    return result.asReturnedValue();
 }
 
-Value ArrayPrototype::method_push(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_push(SimpleCallContext *ctx)
 {
     Object *instance = ctx->thisObject.toObject(ctx);
     uint len = getLength(ctx, instance);
@@ -283,7 +283,7 @@ Value ArrayPrototype::method_push(SimpleCallContext *ctx)
             instance->put(ctx->engine->id_length, Value::fromDouble(newLen));
         else
             ctx->throwRangeError(Value::fromString(ctx, QStringLiteral("Array.prototype.push: Overflow")));
-        return Value::fromDouble(newLen);
+        return Value::fromDouble(newLen).asReturnedValue();
     }
 
     if (!instance->protoHasArray() && instance->arrayDataLen <= len) {
@@ -314,12 +314,12 @@ Value ArrayPrototype::method_push(SimpleCallContext *ctx)
         instance->put(ctx->engine->id_length, Value::fromDouble(len));
 
     if (len < INT_MAX)
-        return Value::fromInt32(len);
-    return Value::fromDouble((double)len);
+        return Value::fromInt32(len).asReturnedValue();
+    return Value::fromDouble((double)len).asReturnedValue();
 
 }
 
-Value ArrayPrototype::method_reverse(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_reverse(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -342,10 +342,10 @@ Value ArrayPrototype::method_reverse(SimpleCallContext *ctx)
         else
             instance->deleteIndexedProperty(hi);
     }
-    return Value::fromObject(instance);
+    return Value::fromObject(instance).asReturnedValue();
 }
 
-Value ArrayPrototype::method_shift(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_shift(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -354,7 +354,7 @@ Value ArrayPrototype::method_shift(SimpleCallContext *ctx)
     if (!len) {
         if (!instance->isArrayObject())
             instance->put(ctx->engine->id_length, Value::fromInt32(0));
-        return Value::undefinedValue();
+        return Value::undefinedValue().asReturnedValue();
     }
 
     Property *front = 0;
@@ -396,10 +396,10 @@ Value ArrayPrototype::method_shift(SimpleCallContext *ctx)
         instance->setArrayLengthUnchecked(len - 1);
     else
         instance->put(ctx->engine->id_length, Value::fromDouble(len - 1));
-    return result;
+    return result.asReturnedValue();
 }
 
-Value ArrayPrototype::method_slice(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_slice(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *o = ctx->thisObject.toObject(ctx);
@@ -435,10 +435,10 @@ Value ArrayPrototype::method_slice(SimpleCallContext *ctx)
         }
         ++n;
     }
-    return Value::fromObject(result);
+    return Value::fromObject(result).asReturnedValue();
 }
 
-Value ArrayPrototype::method_sort(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_sort(SimpleCallContext *ctx)
 {
     Object *instance = ctx->thisObject.toObject(ctx);
 
@@ -446,10 +446,10 @@ Value ArrayPrototype::method_sort(SimpleCallContext *ctx)
 
     Value comparefn = ctx->argument(0);
     instance->arraySort(ctx, instance, comparefn, len);
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
-Value ArrayPrototype::method_splice(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_splice(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -508,10 +508,10 @@ Value ArrayPrototype::method_splice(SimpleCallContext *ctx)
     ctx->strictMode = true;
     instance->put(ctx->engine->id_length, Value::fromDouble(len - deleteCount + itemCount));
 
-    return Value::fromObject(newArray);
+    return Value::fromObject(newArray).asReturnedValue();
 }
 
-Value ArrayPrototype::method_unshift(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_unshift(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -559,18 +559,18 @@ Value ArrayPrototype::method_unshift(SimpleCallContext *ctx)
         instance->put(ctx->engine->id_length, Value::fromDouble(newLen));
 
     if (newLen < INT_MAX)
-        return Value::fromInt32(newLen);
-    return Value::fromDouble((double)newLen);
+        return Value::fromInt32(newLen).asReturnedValue();
+    return Value::fromDouble((double)newLen).asReturnedValue();
 }
 
-Value ArrayPrototype::method_indexOf(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_indexOf(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
 
     Object *instance = ctx->thisObject.toObject(ctx);
     uint len = getLength(ctx, instance);
     if (!len)
-        return Value::fromInt32(-1);
+        return Value::fromInt32(-1).asReturnedValue();
 
     ScopedValue searchValue(scope);
     uint fromIndex = 0;
@@ -583,7 +583,7 @@ Value ArrayPrototype::method_indexOf(SimpleCallContext *ctx)
     if (ctx->argumentCount >= 2) {
         double f = ctx->argument(1).toInteger();
         if (f >= len)
-            return Value::fromInt32(-1);
+            return Value::fromInt32(-1).asReturnedValue();
         if (f < 0)
             f = qMax(len + f, 0.);
         fromIndex = (uint) f;
@@ -595,22 +595,22 @@ Value ArrayPrototype::method_indexOf(SimpleCallContext *ctx)
             bool exists;
             v = instance->getIndexed(k, &exists);
             if (exists && __qmljs_strict_equal(v, searchValue))
-                return Value::fromDouble(k);
+                return Value::fromDouble(k).asReturnedValue();
         }
-        return Value::fromInt32(-1);
+        return Value::fromInt32(-1).asReturnedValue();
     }
 
-    return instance->arrayIndexOf(searchValue, fromIndex, len, ctx, instance);
+    return instance->arrayIndexOf(searchValue, fromIndex, len, ctx, instance).asReturnedValue();
 }
 
-Value ArrayPrototype::method_lastIndexOf(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_lastIndexOf(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
 
     Object *instance = ctx->thisObject.toObject(ctx);
     uint len = getLength(ctx, instance);
     if (!len)
-        return Value::fromInt32(-1);
+        return Value::fromInt32(-1).asReturnedValue();
 
     ScopedValue searchValue(scope);
     uint fromIndex = len;
@@ -627,7 +627,7 @@ Value ArrayPrototype::method_lastIndexOf(SimpleCallContext *ctx)
         else if (f < 0) {
             f = len + f;
             if (f < 0)
-                return Value::fromInt32(-1);
+                return Value::fromInt32(-1).asReturnedValue();
         }
         fromIndex = (uint) f + 1;
     }
@@ -638,12 +638,12 @@ Value ArrayPrototype::method_lastIndexOf(SimpleCallContext *ctx)
         bool exists;
         v = instance->getIndexed(k, &exists);
         if (exists && __qmljs_strict_equal(v, searchValue))
-            return Value::fromDouble(k);
+            return Value::fromDouble(k).asReturnedValue();
     }
-    return Value::fromInt32(-1);
+    return Value::fromInt32(-1).asReturnedValue();
 }
 
-Value ArrayPrototype::method_every(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_every(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -674,10 +674,10 @@ Value ArrayPrototype::method_every(SimpleCallContext *ctx)
         r = callback->call(callData);
         ok = r->toBoolean();
     }
-    return Value::fromBoolean(ok);
+    return Value::fromBoolean(ok).asReturnedValue();
 }
 
-Value ArrayPrototype::method_some(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_some(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -703,12 +703,12 @@ Value ArrayPrototype::method_some(SimpleCallContext *ctx)
         callData->args[1] = Value::fromDouble(k);
         Value r = Value::fromReturnedValue(callback->call(callData));
         if (r.toBoolean())
-            return Value::fromBoolean(true);
+            return Value::fromBoolean(true).asReturnedValue();
     }
-    return Value::fromBoolean(false);
+    return Value::fromBoolean(false).asReturnedValue();
 }
 
-Value ArrayPrototype::method_forEach(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_forEach(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -734,10 +734,10 @@ Value ArrayPrototype::method_forEach(SimpleCallContext *ctx)
         callData->args[1] = Value::fromDouble(k);
         callback->call(callData);
     }
-    return Value::undefinedValue();
+    return Value::undefinedValue().asReturnedValue();
 }
 
-Value ArrayPrototype::method_map(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_map(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -771,10 +771,10 @@ Value ArrayPrototype::method_map(SimpleCallContext *ctx)
         mapped = callback->call(callData);
         a->arraySet(k, mapped);
     }
-    return Value::fromObject(a);
+    return Value::fromObject(a).asReturnedValue();
 }
 
-Value ArrayPrototype::method_filter(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_filter(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -812,10 +812,10 @@ Value ArrayPrototype::method_filter(SimpleCallContext *ctx)
             ++to;
         }
     }
-    return Value::fromObject(a);
+    return Value::fromObject(a).asReturnedValue();
 }
 
-Value ArrayPrototype::method_reduce(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_reduce(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -860,10 +860,10 @@ Value ArrayPrototype::method_reduce(SimpleCallContext *ctx)
         }
         ++k;
     }
-    return acc;
+    return acc.asReturnedValue();
 }
 
-Value ArrayPrototype::method_reduceRight(SimpleCallContext *ctx)
+ReturnedValue ArrayPrototype::method_reduceRight(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *instance = ctx->thisObject.toObject(ctx);
@@ -877,7 +877,7 @@ Value ArrayPrototype::method_reduceRight(SimpleCallContext *ctx)
     if (len == 0) {
         if (ctx->argumentCount == 1)
             ctx->throwTypeError();
-        return ctx->argument(1);
+        return ctx->argument(1).asReturnedValue();
     }
 
     uint k = len;
@@ -912,6 +912,6 @@ Value ArrayPrototype::method_reduceRight(SimpleCallContext *ctx)
         }
         --k;
     }
-    return acc;
+    return acc.asReturnedValue();
 }
 
diff --git a/src/qml/jsruntime/qv4arrayobject_p.h b/src/qml/jsruntime/qv4arrayobject_p.h
index 33c32f3cd6..6bf9fcd409 100644
--- a/src/qml/jsruntime/qv4arrayobject_p.h
+++ b/src/qml/jsruntime/qv4arrayobject_p.h
@@ -68,28 +68,28 @@ struct ArrayPrototype: ArrayObject
 
     static uint getLength(ExecutionContext *ctx, Object *o);
 
-    static Value method_isArray(SimpleCallContext *ctx);
-    static Value method_toString(SimpleCallContext *ctx);
-    static Value method_toLocaleString(SimpleCallContext *ctx);
-    static Value method_concat(SimpleCallContext *ctx);
-    static Value method_join(SimpleCallContext *ctx);
-    static Value method_pop(SimpleCallContext *ctx);
-    static Value method_push(SimpleCallContext *ctx);
-    static Value method_reverse(SimpleCallContext *ctx);
-    static Value method_shift(SimpleCallContext *ctx);
-    static Value method_slice(SimpleCallContext *ctx);
-    static Value method_sort(SimpleCallContext *ctx);
-    static Value method_splice(SimpleCallContext *ctx);
-    static Value method_unshift(SimpleCallContext *ctx);
-    static Value method_indexOf(SimpleCallContext *ctx);
-    static Value method_lastIndexOf(SimpleCallContext *ctx);
-    static Value method_every(SimpleCallContext *ctx);
-    static Value method_some(SimpleCallContext *ctx);
-    static Value method_forEach(SimpleCallContext *ctx);
-    static Value method_map(SimpleCallContext *ctx);
-    static Value method_filter(SimpleCallContext *ctx);
-    static Value method_reduce(SimpleCallContext *ctx);
-    static Value method_reduceRight(SimpleCallContext *ctx);
+    static ReturnedValue method_isArray(SimpleCallContext *ctx);
+    static ReturnedValue method_toString(SimpleCallContext *ctx);
+    static ReturnedValue method_toLocaleString(SimpleCallContext *ctx);
+    static ReturnedValue method_concat(SimpleCallContext *ctx);
+    static ReturnedValue method_join(SimpleCallContext *ctx);
+    static ReturnedValue method_pop(SimpleCallContext *ctx);
+    static ReturnedValue method_push(SimpleCallContext *ctx);
+    static ReturnedValue method_reverse(SimpleCallContext *ctx);
+    static ReturnedValue method_shift(SimpleCallContext *ctx);
+    static ReturnedValue method_slice(SimpleCallContext *ctx);
+    static ReturnedValue method_sort(SimpleCallContext *ctx);
+    static ReturnedValue method_splice(SimpleCallContext *ctx);
+    static ReturnedValue method_unshift(SimpleCallContext *ctx);
+    static ReturnedValue method_indexOf(SimpleCallContext *ctx);
+    static ReturnedValue method_lastIndexOf(SimpleCallContext *ctx);
+    static ReturnedValue method_every(SimpleCallContext *ctx);
+    static ReturnedValue method_some(SimpleCallContext *ctx);
+    static ReturnedValue method_forEach(SimpleCallContext *ctx);
+    static ReturnedValue method_map(SimpleCallContext *ctx);
+    static ReturnedValue method_filter(SimpleCallContext *ctx);
+    static ReturnedValue method_reduce(SimpleCallContext *ctx);
+    static ReturnedValue method_reduceRight(SimpleCallContext *ctx);
 };
 
 
diff --git a/src/qml/jsruntime/qv4booleanobject.cpp b/src/qml/jsruntime/qv4booleanobject.cpp
index fc76830a2f..6fb21433d6 100644
--- a/src/qml/jsruntime/qv4booleanobject.cpp
+++ b/src/qml/jsruntime/qv4booleanobject.cpp
@@ -72,7 +72,7 @@ void BooleanPrototype::init(ExecutionContext *ctx, const Value &ctor)
     defineDefaultProperty(ctx, QStringLiteral("valueOf"), method_valueOf);
 }
 
-Value BooleanPrototype::method_toString(SimpleCallContext *ctx)
+ReturnedValue BooleanPrototype::method_toString(SimpleCallContext *ctx)
 {
     bool result;
     if (ctx->thisObject.isBoolean()) {
@@ -84,14 +84,14 @@ Value BooleanPrototype::method_toString(SimpleCallContext *ctx)
         result = thisObject->value.booleanValue();
     }
 
-    return Value::fromString(ctx, QLatin1String(result ? "true" : "false"));
+    return Value::fromString(ctx, QLatin1String(result ? "true" : "false")).asReturnedValue();
 }
 
-Value BooleanPrototype::method_valueOf(SimpleCallContext *ctx)
+ReturnedValue BooleanPrototype::method_valueOf(SimpleCallContext *ctx)
 {
     BooleanObject *thisObject = ctx->thisObject.asBooleanObject();
     if (!thisObject)
         ctx->throwTypeError();
 
-    return thisObject->value;
+    return thisObject->value.asReturnedValue();
 }
diff --git a/src/qml/jsruntime/qv4booleanobject_p.h b/src/qml/jsruntime/qv4booleanobject_p.h
index 6a04cb4b7e..db4dc881c1 100644
--- a/src/qml/jsruntime/qv4booleanobject_p.h
+++ b/src/qml/jsruntime/qv4booleanobject_p.h
@@ -65,8 +65,8 @@ struct BooleanPrototype: BooleanObject
     BooleanPrototype(InternalClass *ic): BooleanObject(ic) {}
     void init(ExecutionContext *ctx, const Value &ctor);
 
-    static Value method_toString(SimpleCallContext *ctx);
-    static Value method_valueOf(SimpleCallContext *ctx);
+    static ReturnedValue method_toString(SimpleCallContext *ctx);
+    static ReturnedValue method_valueOf(SimpleCallContext *ctx);
 };
 
 
diff --git a/src/qml/jsruntime/qv4dateobject.cpp b/src/qml/jsruntime/qv4dateobject.cpp
index de56fcd5f3..26e9a4af0e 100644
--- a/src/qml/jsruntime/qv4dateobject.cpp
+++ b/src/qml/jsruntime/qv4dateobject.cpp
@@ -768,12 +768,12 @@ double DatePrototype::getThisDate(ExecutionContext *ctx)
     }
 }
 
-Value DatePrototype::method_parse(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_parse(SimpleCallContext *ctx)
 {
-    return Value::fromDouble(ParseString(ctx->argument(0).toString(ctx)->toQString()));
+    return Encode(ParseString(ctx->argument(0).toString(ctx)->toQString()));
 }
 
-Value DatePrototype::method_UTC(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_UTC(SimpleCallContext *ctx)
 {
     const int numArgs = ctx->argumentCount;
     if (numArgs >= 2) {
@@ -788,221 +788,221 @@ Value DatePrototype::method_UTC(SimpleCallContext *ctx)
             year += 1900;
         double t = MakeDate(MakeDay(year, month, day),
                             MakeTime(hours, mins, secs, ms));
-        return Value::fromDouble(TimeClip(t));
+        return Encode(TimeClip(t));
     }
-    return Value::undefinedValue();
+    return Encode::undefined();
 }
 
-Value DatePrototype::method_now(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_now(SimpleCallContext *ctx)
 {
     Q_UNUSED(ctx);
     double t = currentTime();
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_toString(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_toString(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
-    return Value::fromString(ctx, ToString(t));
+    return Value::fromString(ctx, ToString(t)).asReturnedValue();
 }
 
-Value DatePrototype::method_toDateString(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_toDateString(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
-    return Value::fromString(ctx, ToDateString(t));
+    return Value::fromString(ctx, ToDateString(t)).asReturnedValue();
 }
 
-Value DatePrototype::method_toTimeString(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_toTimeString(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
-    return Value::fromString(ctx, ToTimeString(t));
+    return Value::fromString(ctx, ToTimeString(t)).asReturnedValue();
 }
 
-Value DatePrototype::method_toLocaleString(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_toLocaleString(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
-    return Value::fromString(ctx, ToLocaleString(t));
+    return Value::fromString(ctx, ToLocaleString(t)).asReturnedValue();
 }
 
-Value DatePrototype::method_toLocaleDateString(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_toLocaleDateString(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
-    return Value::fromString(ctx, ToLocaleDateString(t));
+    return Value::fromString(ctx, ToLocaleDateString(t)).asReturnedValue();
 }
 
-Value DatePrototype::method_toLocaleTimeString(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_toLocaleTimeString(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
-    return Value::fromString(ctx, ToLocaleTimeString(t));
+    return Value::fromString(ctx, ToLocaleTimeString(t)).asReturnedValue();
 }
 
-Value DatePrototype::method_valueOf(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_valueOf(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getTime(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getTime(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getYear(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getYear(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = YearFromTime(LocalTime(t)) - 1900;
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getFullYear(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getFullYear(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = YearFromTime(LocalTime(t));
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getUTCFullYear(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getUTCFullYear(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = YearFromTime(t);
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getMonth(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getMonth(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = MonthFromTime(LocalTime(t));
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getUTCMonth(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getUTCMonth(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = MonthFromTime(t);
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getDate(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getDate(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = DateFromTime(LocalTime(t));
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getUTCDate(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getUTCDate(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = DateFromTime(t);
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getDay(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getDay(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = WeekDay(LocalTime(t));
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getUTCDay(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getUTCDay(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = WeekDay(t);
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getHours(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getHours(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = HourFromTime(LocalTime(t));
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getUTCHours(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getUTCHours(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = HourFromTime(t);
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getMinutes(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getMinutes(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = MinFromTime(LocalTime(t));
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getUTCMinutes(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getUTCMinutes(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = MinFromTime(t);
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getSeconds(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getSeconds(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = SecFromTime(LocalTime(t));
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getUTCSeconds(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getUTCSeconds(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = SecFromTime(t);
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getMilliseconds(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getMilliseconds(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = msFromTime(LocalTime(t));
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getUTCMilliseconds(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getUTCMilliseconds(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = msFromTime(t);
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_getTimezoneOffset(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_getTimezoneOffset(SimpleCallContext *ctx)
 {
     double t = getThisDate(ctx);
     if (! std::isnan(t))
         t = (t - LocalTime(t)) / msPerMinute;
-    return Value::fromDouble(t);
+    return Encode(t);
 }
 
-Value DatePrototype::method_setTime(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setTime(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
         ctx->throwTypeError();
 
     self->value.setDouble(TimeClip(ctx->argument(0).toNumber()));
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setMilliseconds(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setMilliseconds(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1011,10 +1011,10 @@ Value DatePrototype::method_setMilliseconds(SimpleCallContext *ctx)
     double t = LocalTime(self->value.asDouble());
     double ms = ctx->argument(0).toNumber();
     self->value.setDouble(TimeClip(UTC(MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), ms)))));
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setUTCMilliseconds(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setUTCMilliseconds(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1023,10 +1023,10 @@ Value DatePrototype::method_setUTCMilliseconds(SimpleCallContext *ctx)
     double t = self->value.asDouble();
     double ms = ctx->argument(0).toNumber();
     self->value.setDouble(TimeClip(UTC(MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), ms)))));
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setSeconds(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setSeconds(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1037,10 +1037,10 @@ Value DatePrototype::method_setSeconds(SimpleCallContext *ctx)
     double ms = (ctx->argumentCount < 2) ? msFromTime(t) : ctx->argument(1).toNumber();
     t = TimeClip(UTC(MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), sec, ms))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setUTCSeconds(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setUTCSeconds(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1051,10 +1051,10 @@ Value DatePrototype::method_setUTCSeconds(SimpleCallContext *ctx)
     double ms = (ctx->argumentCount < 2) ? msFromTime(t) : ctx->argument(1).toNumber();
     t = TimeClip(UTC(MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), sec, ms))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setMinutes(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setMinutes(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1066,10 +1066,10 @@ Value DatePrototype::method_setMinutes(SimpleCallContext *ctx)
     double ms = (ctx->argumentCount < 3) ? msFromTime(t) : ctx->argument(2).toNumber();
     t = TimeClip(UTC(MakeDate(Day(t), MakeTime(HourFromTime(t), min, sec, ms))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setUTCMinutes(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setUTCMinutes(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1081,10 +1081,10 @@ Value DatePrototype::method_setUTCMinutes(SimpleCallContext *ctx)
     double ms = (ctx->argumentCount < 3) ? msFromTime(t) : ctx->argument(2).toNumber();
     t = TimeClip(UTC(MakeDate(Day(t), MakeTime(HourFromTime(t), min, sec, ms))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setHours(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setHours(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1097,10 +1097,10 @@ Value DatePrototype::method_setHours(SimpleCallContext *ctx)
     double ms = (ctx->argumentCount < 4) ? msFromTime(t) : ctx->argument(3).toNumber();
     t = TimeClip(UTC(MakeDate(Day(t), MakeTime(hour, min, sec, ms))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setUTCHours(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setUTCHours(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1113,10 +1113,10 @@ Value DatePrototype::method_setUTCHours(SimpleCallContext *ctx)
     double ms = (ctx->argumentCount < 4) ? msFromTime(t) : ctx->argument(3).toNumber();
     t = TimeClip(UTC(MakeDate(Day(t), MakeTime(hour, min, sec, ms))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setDate(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setDate(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1126,10 +1126,10 @@ Value DatePrototype::method_setDate(SimpleCallContext *ctx)
     double date = ctx->argument(0).toNumber();
     t = TimeClip(UTC(MakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), date), TimeWithinDay(t))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setUTCDate(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setUTCDate(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1139,10 +1139,10 @@ Value DatePrototype::method_setUTCDate(SimpleCallContext *ctx)
     double date = ctx->argument(0).toNumber();
     t = TimeClip(UTC(MakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), date), TimeWithinDay(t))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setMonth(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setMonth(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1153,10 +1153,10 @@ Value DatePrototype::method_setMonth(SimpleCallContext *ctx)
     double date = (ctx->argumentCount < 2) ? DateFromTime(t) : ctx->argument(1).toNumber();
     t = TimeClip(UTC(MakeDate(MakeDay(YearFromTime(t), month, date), TimeWithinDay(t))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setUTCMonth(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setUTCMonth(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1167,10 +1167,10 @@ Value DatePrototype::method_setUTCMonth(SimpleCallContext *ctx)
     double date = (ctx->argumentCount < 2) ? DateFromTime(t) : ctx->argument(1).toNumber();
     t = TimeClip(UTC(MakeDate(MakeDay(YearFromTime(t), month, date), TimeWithinDay(t))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setYear(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setYear(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1193,10 +1193,10 @@ Value DatePrototype::method_setYear(SimpleCallContext *ctx)
         r = TimeClip(r);
     }
     self->value.setDouble(r);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setUTCFullYear(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setUTCFullYear(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1208,10 +1208,10 @@ Value DatePrototype::method_setUTCFullYear(SimpleCallContext *ctx)
     double date = (ctx->argumentCount < 3) ? DateFromTime(t) : ctx->argument(2).toNumber();
     t = TimeClip(UTC(MakeDate(MakeDay(year, month, date), TimeWithinDay(t))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_setFullYear(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_setFullYear(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1225,17 +1225,17 @@ Value DatePrototype::method_setFullYear(SimpleCallContext *ctx)
     double date = (ctx->argumentCount < 3) ? DateFromTime(t) : ctx->argument(2).toNumber();
     t = TimeClip(UTC(MakeDate(MakeDay(year, month, date), TimeWithinDay(t))));
     self->value.setDouble(t);
-    return self->value;
+    return self->value.asReturnedValue();
 }
 
-Value DatePrototype::method_toUTCString(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_toUTCString(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
         ctx->throwTypeError();
 
     double t = self->value.asDouble();
-    return Value::fromString(ctx, ToUTCString(t));
+    return Value::fromString(ctx, ToUTCString(t)).asReturnedValue();
 }
 
 static void addZeroPrefixedInt(QString &str, int num, int nDigits)
@@ -1251,7 +1251,7 @@ static void addZeroPrefixedInt(QString &str, int num, int nDigits)
     }
 }
 
-Value DatePrototype::method_toISOString(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_toISOString(SimpleCallContext *ctx)
 {
     DateObject *self = ctx->thisObject.asDateObject();
     if (!self)
@@ -1265,7 +1265,7 @@ Value DatePrototype::method_toISOString(SimpleCallContext *ctx)
     int year = (int)YearFromTime(t);
     if (year < 0 || year > 9999) {
         if (qAbs(year) >= 1000000)
-            return Value::fromString(ctx, QStringLiteral("Invalid Date"));
+            return Value::fromString(ctx, QStringLiteral("Invalid Date")).asReturnedValue();
         result += year < 0 ? '-' : '+';
         year = qAbs(year);
         addZeroPrefixedInt(result, year, 6);
@@ -1286,17 +1286,17 @@ Value DatePrototype::method_toISOString(SimpleCallContext *ctx)
     addZeroPrefixedInt(result, msFromTime(t), 3);
     result += 'Z';
 
-    return Value::fromString(ctx, result);
+    return Value::fromString(ctx, result).asReturnedValue();
 }
 
-Value DatePrototype::method_toJSON(SimpleCallContext *ctx)
+ReturnedValue DatePrototype::method_toJSON(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     ScopedValue O(scope, __qmljs_to_object(ctx, ValueRef(&ctx->thisObject)));
     ScopedValue tv(scope, __qmljs_to_primitive(O, NUMBER_HINT));
 
     if (tv->isNumber() && !std::isfinite(tv->toNumber()))
-        return Value::nullValue();
+        return Encode::null();
 
     ScopedValue v(scope, O->objectValue()->get(ctx->engine->newString(QStringLiteral("toISOString"))));
     FunctionObject *toIso = v->asFunctionObject();
@@ -1306,7 +1306,7 @@ Value DatePrototype::method_toJSON(SimpleCallContext *ctx)
 
     ScopedCallData callData(scope, 0);
     callData->thisObject = ctx->thisObject;
-    return Value::fromReturnedValue(toIso->call(callData));
+    return toIso->call(callData);
 }
 
 void DatePrototype::timezoneUpdated()
diff --git a/src/qml/jsruntime/qv4dateobject_p.h b/src/qml/jsruntime/qv4dateobject_p.h
index 84748f2107..c405b5d9b5 100644
--- a/src/qml/jsruntime/qv4dateobject_p.h
+++ b/src/qml/jsruntime/qv4dateobject_p.h
@@ -80,55 +80,55 @@ struct DatePrototype: DateObject
 
     static double getThisDate(ExecutionContext *ctx);
 
-    static Value method_parse(SimpleCallContext *ctx);
-    static Value method_UTC(SimpleCallContext *ctx);
-    static Value method_now(SimpleCallContext *ctx);
-
-    static Value method_toString(SimpleCallContext *ctx);
-    static Value method_toDateString(SimpleCallContext *ctx);
-    static Value method_toTimeString(SimpleCallContext *ctx);
-    static Value method_toLocaleString(SimpleCallContext *ctx);
-    static Value method_toLocaleDateString(SimpleCallContext *ctx);
-    static Value method_toLocaleTimeString(SimpleCallContext *ctx);
-    static Value method_valueOf(SimpleCallContext *ctx);
-    static Value method_getTime(SimpleCallContext *ctx);
-    static Value method_getYear(SimpleCallContext *ctx);
-    static Value method_getFullYear(SimpleCallContext *ctx);
-    static Value method_getUTCFullYear(SimpleCallContext *ctx);
-    static Value method_getMonth(SimpleCallContext *ctx);
-    static Value method_getUTCMonth(SimpleCallContext *ctx);
-    static Value method_getDate(SimpleCallContext *ctx);
-    static Value method_getUTCDate(SimpleCallContext *ctx);
-    static Value method_getDay(SimpleCallContext *ctx);
-    static Value method_getUTCDay(SimpleCallContext *ctx);
-    static Value method_getHours(SimpleCallContext *ctx);
-    static Value method_getUTCHours(SimpleCallContext *ctx);
-    static Value method_getMinutes(SimpleCallContext *ctx);
-    static Value method_getUTCMinutes(SimpleCallContext *ctx);
-    static Value method_getSeconds(SimpleCallContext *ctx);
-    static Value method_getUTCSeconds(SimpleCallContext *ctx);
-    static Value method_getMilliseconds(SimpleCallContext *ctx);
-    static Value method_getUTCMilliseconds(SimpleCallContext *ctx);
-    static Value method_getTimezoneOffset(SimpleCallContext *ctx);
-    static Value method_setTime(SimpleCallContext *ctx);
-    static Value method_setMilliseconds(SimpleCallContext *ctx);
-    static Value method_setUTCMilliseconds(SimpleCallContext *ctx);
-    static Value method_setSeconds(SimpleCallContext *ctx);
-    static Value method_setUTCSeconds(SimpleCallContext *ctx);
-    static Value method_setMinutes(SimpleCallContext *ctx);
-    static Value method_setUTCMinutes(SimpleCallContext *ctx);
-    static Value method_setHours(SimpleCallContext *ctx);
-    static Value method_setUTCHours(SimpleCallContext *ctx);
-    static Value method_setDate(SimpleCallContext *ctx);
-    static Value method_setUTCDate(SimpleCallContext *ctx);
-    static Value method_setMonth(SimpleCallContext *ctx);
-    static Value method_setUTCMonth(SimpleCallContext *ctx);
-    static Value method_setYear(SimpleCallContext *ctx);
-    static Value method_setFullYear(SimpleCallContext *ctx);
-    static Value method_setUTCFullYear(SimpleCallContext *ctx);
-    static Value method_toUTCString(SimpleCallContext *ctx);
-    static Value method_toISOString(SimpleCallContext *ctx);
-    static Value method_toJSON(SimpleCallContext *ctx);
+    static ReturnedValue method_parse(SimpleCallContext *ctx);
+    static ReturnedValue method_UTC(SimpleCallContext *ctx);
+    static ReturnedValue method_now(SimpleCallContext *ctx);
+
+    static ReturnedValue method_toString(SimpleCallContext *ctx);
+    static ReturnedValue method_toDateString(SimpleCallContext *ctx);
+    static ReturnedValue method_toTimeString(SimpleCallContext *ctx);
+    static ReturnedValue method_toLocaleString(SimpleCallContext *ctx);
+    static ReturnedValue method_toLocaleDateString(SimpleCallContext *ctx);
+    static ReturnedValue method_toLocaleTimeString(SimpleCallContext *ctx);
+    static ReturnedValue method_valueOf(SimpleCallContext *ctx);
+    static ReturnedValue method_getTime(SimpleCallContext *ctx);
+    static ReturnedValue method_getYear(SimpleCallContext *ctx);
+    static ReturnedValue method_getFullYear(SimpleCallContext *ctx);
+    static ReturnedValue method_getUTCFullYear(SimpleCallContext *ctx);
+    static ReturnedValue method_getMonth(SimpleCallContext *ctx);
+    static ReturnedValue method_getUTCMonth(SimpleCallContext *ctx);
+    static ReturnedValue method_getDate(SimpleCallContext *ctx);
+    static ReturnedValue method_getUTCDate(SimpleCallContext *ctx);
+    static ReturnedValue method_getDay(SimpleCallContext *ctx);
+    static ReturnedValue method_getUTCDay(SimpleCallContext *ctx);
+    static ReturnedValue method_getHours(SimpleCallContext *ctx);
+    static ReturnedValue method_getUTCHours(SimpleCallContext *ctx);
+    static ReturnedValue method_getMinutes(SimpleCallContext *ctx);
+    static ReturnedValue method_getUTCMinutes(SimpleCallContext *ctx);
+    static ReturnedValue method_getSeconds(SimpleCallContext *ctx);
+    static ReturnedValue method_getUTCSeconds(SimpleCallContext *ctx);
+    static ReturnedValue method_getMilliseconds(SimpleCallContext *ctx);
+    static ReturnedValue method_getUTCMilliseconds(SimpleCallContext *ctx);
+    static ReturnedValue method_getTimezoneOffset(SimpleCallContext *ctx);
+    static ReturnedValue method_setTime(SimpleCallContext *ctx);
+    static ReturnedValue method_setMilliseconds(SimpleCallContext *ctx);
+    static ReturnedValue method_setUTCMilliseconds(SimpleCallContext *ctx);
+    static ReturnedValue method_setSeconds(SimpleCallContext *ctx);
+    static ReturnedValue method_setUTCSeconds(SimpleCallContext *ctx);
+    static ReturnedValue method_setMinutes(SimpleCallContext *ctx);
+    static ReturnedValue method_setUTCMinutes(SimpleCallContext *ctx);
+    static ReturnedValue method_setHours(SimpleCallContext *ctx);
+    static ReturnedValue method_setUTCHours(SimpleCallContext *ctx);
+    static ReturnedValue method_setDate(SimpleCallContext *ctx);
+    static ReturnedValue method_setUTCDate(SimpleCallContext *ctx);
+    static ReturnedValue method_setMonth(SimpleCallContext *ctx);
+    static ReturnedValue method_setUTCMonth(SimpleCallContext *ctx);
+    static ReturnedValue method_setYear(SimpleCallContext *ctx);
+    static ReturnedValue method_setFullYear(SimpleCallContext *ctx);
+    static ReturnedValue method_setUTCFullYear(SimpleCallContext *ctx);
+    static ReturnedValue method_toUTCString(SimpleCallContext *ctx);
+    static ReturnedValue method_toISOString(SimpleCallContext *ctx);
+    static ReturnedValue method_toJSON(SimpleCallContext *ctx);
 
     static void timezoneUpdated();
 };
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index eaea2bbddc..3f9b8175bc 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -338,7 +338,7 @@ ExecutionContext *ExecutionEngine::pushGlobalContext()
     return current;
 }
 
-FunctionObject *ExecutionEngine::newBuiltinFunction(ExecutionContext *scope, String *name, Value (*code)(SimpleCallContext *))
+FunctionObject *ExecutionEngine::newBuiltinFunction(ExecutionContext *scope, String *name, ReturnedValue (*code)(SimpleCallContext *))
 {
     BuiltinFunction *f = new (memoryManager) BuiltinFunction(scope, name, code);
     return f;
diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index 1dbffa28aa..60b3ddbf73 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -261,7 +261,7 @@ struct Q_QML_EXPORT ExecutionEngine
     void pushContext(SimpleCallContext *context);
     ExecutionContext *popContext();
 
-    FunctionObject *newBuiltinFunction(ExecutionContext *scope, String *name, Value (*code)(SimpleCallContext *));
+    FunctionObject *newBuiltinFunction(ExecutionContext *scope, String *name, ReturnedValue (*code)(SimpleCallContext *));
     BoundFunction *newBoundFunction(ExecutionContext *scope, FunctionObject *target, Value boundThis, const QVector<Value> &boundArgs);
 
     Object *newObject();
diff --git a/src/qml/jsruntime/qv4errorobject.cpp b/src/qml/jsruntime/qv4errorobject.cpp
index 90b4189e6f..7c75d1162a 100644
--- a/src/qml/jsruntime/qv4errorobject.cpp
+++ b/src/qml/jsruntime/qv4errorobject.cpp
@@ -127,7 +127,7 @@ ErrorObject::ErrorObject(InternalClass *ic, const QString &message, const QStrin
     defineDefaultProperty(ic->engine, QStringLiteral("message"), Value::fromString(ic->engine->newString(message)));
 }
 
-Value ErrorObject::method_get_stack(SimpleCallContext *ctx)
+ReturnedValue ErrorObject::method_get_stack(SimpleCallContext *ctx)
 {
     ErrorObject *This = ctx->thisObject.asErrorObject();
     if (!This)
@@ -148,7 +148,7 @@ Value ErrorObject::method_get_stack(SimpleCallContext *ctx)
         }
         This->stack = ctx->engine->newString(trace);
     }
-    return Value::fromString(This->stack);
+    return Value::fromString(This->stack).asReturnedValue();
 }
 
 void ErrorObject::markObjects(Managed *that)
@@ -326,7 +326,7 @@ void ErrorPrototype::init(ExecutionEngine *engine, const Value &ctor, Object *ob
     obj->defineDefaultProperty(engine, QStringLiteral("message"), Value::fromString(engine, QString()));
 }
 
-Value ErrorPrototype::method_toString(SimpleCallContext *ctx)
+ReturnedValue ErrorPrototype::method_toString(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
 
@@ -355,5 +355,5 @@ Value ErrorPrototype::method_toString(SimpleCallContext *ctx)
         str = qname + QLatin1String(": ") + qmessage;
     }
 
-    return Value::fromString(ctx, str);
+    return Value::fromString(ctx, str).asReturnedValue();
 }
diff --git a/src/qml/jsruntime/qv4errorobject_p.h b/src/qml/jsruntime/qv4errorobject_p.h
index a9eab58414..d16057b035 100644
--- a/src/qml/jsruntime/qv4errorobject_p.h
+++ b/src/qml/jsruntime/qv4errorobject_p.h
@@ -72,7 +72,7 @@ struct ErrorObject: Object {
     ExecutionEngine::StackTrace stackTrace;
     String *stack;
 
-    static Value method_get_stack(SimpleCallContext *ctx);
+    static ReturnedValue method_get_stack(SimpleCallContext *ctx);
     static void markObjects(Managed *that);
     static void destroy(Managed *that) { static_cast<ErrorObject *>(that)->~ErrorObject(); }
 };
@@ -189,7 +189,7 @@ struct ErrorPrototype: ErrorObject
     void init(ExecutionEngine *engine, const Value &ctor) { init(engine, ctor, this); }
 
     static void init(ExecutionEngine *engine, const Value &ctor, Object *obj);
-    static Value method_toString(SimpleCallContext *ctx);
+    static ReturnedValue method_toString(SimpleCallContext *ctx);
 };
 
 struct EvalErrorPrototype: ErrorObject
diff --git a/src/qml/jsruntime/qv4functionobject.cpp b/src/qml/jsruntime/qv4functionobject.cpp
index 66d0dfd63e..a80ea3fc12 100644
--- a/src/qml/jsruntime/qv4functionobject.cpp
+++ b/src/qml/jsruntime/qv4functionobject.cpp
@@ -172,7 +172,7 @@ ReturnedValue FunctionObject::construct(Managed *that, CallData *)
 
 ReturnedValue FunctionObject::call(Managed *, CallData *)
 {
-    return Value::undefinedValue().asReturnedValue();
+    return Encode::undefined();
 }
 
 void FunctionObject::markObjects(Managed *that)
@@ -281,16 +281,16 @@ void FunctionPrototype::init(ExecutionContext *ctx, const Value &ctor)
 
 }
 
-Value FunctionPrototype::method_toString(SimpleCallContext *ctx)
+ReturnedValue FunctionPrototype::method_toString(SimpleCallContext *ctx)
 {
     FunctionObject *fun = ctx->thisObject.asFunctionObject();
     if (!fun)
         ctx->throwTypeError();
 
-    return Value::fromString(ctx, QStringLiteral("function() { [code] }"));
+    return Value::fromString(ctx, QStringLiteral("function() { [code] }")).asReturnedValue();
 }
 
-Value FunctionPrototype::method_apply(SimpleCallContext *ctx)
+ReturnedValue FunctionPrototype::method_apply(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     FunctionObject *o = ctx->thisObject.asFunctionObject();
@@ -307,7 +307,7 @@ Value FunctionPrototype::method_apply(SimpleCallContext *ctx)
         len = 0;
         if (!arg.isNullOrUndefined()) {
             ctx->throwTypeError();
-            return Value::undefinedValue();
+            return Encode::undefined();
         }
     } else {
         len = ArrayPrototype::getLength(ctx, arr);
@@ -329,10 +329,10 @@ Value FunctionPrototype::method_apply(SimpleCallContext *ctx)
     }
 
     callData->thisObject = thisArg;
-    return Value::fromReturnedValue(o->call(callData));
+    return o->call(callData);
 }
 
-Value FunctionPrototype::method_call(SimpleCallContext *ctx)
+ReturnedValue FunctionPrototype::method_call(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Value thisArg = ctx->argument(0);
@@ -347,10 +347,10 @@ Value FunctionPrototype::method_call(SimpleCallContext *ctx)
                   ctx->arguments + ctx->argumentCount, callData->args);
     }
     callData->thisObject = thisArg;
-    return Value::fromReturnedValue(o->call(callData));
+    return o->call(callData);
 }
 
-Value FunctionPrototype::method_bind(SimpleCallContext *ctx)
+ReturnedValue FunctionPrototype::method_bind(SimpleCallContext *ctx)
 {
     FunctionObject *target = ctx->thisObject.asFunctionObject();
     if (!target)
@@ -363,14 +363,14 @@ Value FunctionPrototype::method_bind(SimpleCallContext *ctx)
 
 
     BoundFunction *f = ctx->engine->newBoundFunction(ctx->engine->rootContext, target, boundThis, boundArgs);
-    return Value::fromObject(f);
+    return Value::fromObject(f).asReturnedValue();
 }
 
 
-static Value throwTypeError(SimpleCallContext *ctx)
+static ReturnedValue throwTypeError(SimpleCallContext *ctx)
 {
     ctx->throwTypeError();
-    return Value::undefinedValue();
+    return 0;
 }
 
 DEFINE_MANAGED_VTABLE(ScriptFunction);
@@ -571,7 +571,7 @@ ReturnedValue SimpleScriptFunction::call(Managed *that, CallData *callData)
 
 DEFINE_MANAGED_VTABLE(BuiltinFunction);
 
-BuiltinFunction::BuiltinFunction(ExecutionContext *scope, String *name, Value (*code)(SimpleCallContext *))
+BuiltinFunction::BuiltinFunction(ExecutionContext *scope, String *name, ReturnedValue (*code)(SimpleCallContext *))
     : FunctionObject(scope, name)
     , code(code)
 {
@@ -582,13 +582,14 @@ BuiltinFunction::BuiltinFunction(ExecutionContext *scope, String *name, Value (*
 ReturnedValue BuiltinFunction::construct(Managed *f, CallData *)
 {
     f->engine()->current->throwTypeError();
-    return Value::undefinedValue().asReturnedValue();
+    return Encode::undefined();
 }
 
 ReturnedValue BuiltinFunction::call(Managed *that, CallData *callData)
 {
     BuiltinFunction *f = static_cast<BuiltinFunction *>(that);
     ExecutionEngine *v4 = f->engine();
+    Scope scope(v4);
     ExecutionContext *context = v4->current;
 
     SimpleCallContext ctx;
@@ -600,7 +601,7 @@ ReturnedValue BuiltinFunction::call(Managed *that, CallData *callData)
     ctx.argumentCount = callData->argc;
     v4->pushContext(&ctx);
 
-    Value result;
+    ScopedValue result(scope);
     try {
         result = f->code(&ctx);
     } catch (Exception &ex) {
diff --git a/src/qml/jsruntime/qv4functionobject_p.h b/src/qml/jsruntime/qv4functionobject_p.h
index 5526568690..25bc39047f 100644
--- a/src/qml/jsruntime/qv4functionobject_p.h
+++ b/src/qml/jsruntime/qv4functionobject_p.h
@@ -158,16 +158,16 @@ struct FunctionPrototype: FunctionObject
     FunctionPrototype(InternalClass *ic);
     void init(ExecutionContext *ctx, const Value &ctor);
 
-    static Value method_toString(SimpleCallContext *ctx);
-    static Value method_apply(SimpleCallContext *ctx);
-    static Value method_call(SimpleCallContext *ctx);
-    static Value method_bind(SimpleCallContext *ctx);
+    static ReturnedValue method_toString(SimpleCallContext *ctx);
+    static ReturnedValue method_apply(SimpleCallContext *ctx);
+    static ReturnedValue method_call(SimpleCallContext *ctx);
+    static ReturnedValue method_bind(SimpleCallContext *ctx);
 };
 
 struct BuiltinFunction: FunctionObject {
-    Value (*code)(SimpleCallContext *);
+    ReturnedValue (*code)(SimpleCallContext *);
 
-    BuiltinFunction(ExecutionContext *scope, String *name, Value (*code)(SimpleCallContext *));
+    BuiltinFunction(ExecutionContext *scope, String *name, ReturnedValue (*code)(SimpleCallContext *));
 
     static ReturnedValue construct(Managed *, CallData *);
     static ReturnedValue call(Managed *that, CallData *callData);
diff --git a/src/qml/jsruntime/qv4globalobject.cpp b/src/qml/jsruntime/qv4globalobject.cpp
index b6748b17af..46a07c07c3 100644
--- a/src/qml/jsruntime/qv4globalobject.cpp
+++ b/src/qml/jsruntime/qv4globalobject.cpp
@@ -357,7 +357,7 @@ EvalFunction::EvalFunction(ExecutionContext *scope)
 ReturnedValue EvalFunction::evalCall(Value /*thisObject*/, Value *args, int argc, bool directCall)
 {
     if (argc < 1)
-        return Value::undefinedValue().asReturnedValue();
+        return Encode::undefined();
 
     ExecutionContext *parentContext = engine()->current;
     ExecutionEngine *engine = parentContext->engine;
@@ -383,7 +383,7 @@ ReturnedValue EvalFunction::evalCall(Value /*thisObject*/, Value *args, int argc
 
     Function *function = script.function();
     if (!function)
-        return Value::undefinedValue().asReturnedValue();
+        return Encode::undefined();
 
     strictMode = function->isStrict() || (ctx->strictMode);
 
@@ -465,7 +465,7 @@ static inline int toInt(const QChar &qc, int R)
 }
 
 // parseInt [15.1.2.2]
-Value GlobalFunctions::method_parseInt(SimpleCallContext *context)
+ReturnedValue GlobalFunctions::method_parseInt(SimpleCallContext *context)
 {
     Value string = context->argument(0);
     Value radix = context->argument(1);
@@ -487,7 +487,7 @@ Value GlobalFunctions::method_parseInt(SimpleCallContext *context)
     bool stripPrefix = true; // 7
     if (R) { // 8
         if (R < 2 || R > 36)
-            return Value::fromDouble(std::numeric_limits<double>::quiet_NaN()); // 8a
+            return Encode(std::numeric_limits<double>::quiet_NaN()); // 8a
         if (R != 16)
             stripPrefix = false; // 8b
     } else { // 9
@@ -504,13 +504,13 @@ Value GlobalFunctions::method_parseInt(SimpleCallContext *context)
     // 11: Z is progressively built below
     // 13: this is handled by the toInt function
     if (pos == end) // 12
-        return Value::fromDouble(std::numeric_limits<double>::quiet_NaN());
+        return Encode(std::numeric_limits<double>::quiet_NaN());
     bool overflow = false;
     qint64 v_overflow;
     unsigned overflow_digit_count = 0;
     int d = toInt(*pos++, R);
     if (d == -1)
-        return Value::fromDouble(std::numeric_limits<double>::quiet_NaN());
+        return Encode(std::numeric_limits<double>::quiet_NaN());
     qint64 v = d;
     while (pos != end) {
         d = toInt(*pos++, R);
@@ -537,14 +537,14 @@ Value GlobalFunctions::method_parseInt(SimpleCallContext *context)
     if (overflow) {
         double result = (double) v_overflow * pow(R, overflow_digit_count);
         result += v;
-        return Value::fromDouble(sign * result);
+        return Encode(sign * result);
     } else {
-        return Value::fromDouble(sign * (double) v); // 15
+        return Encode(sign * (double) v); // 15
     }
 }
 
 // parseFloat [15.1.2.3]
-Value GlobalFunctions::method_parseFloat(SimpleCallContext *context)
+ReturnedValue GlobalFunctions::method_parseFloat(SimpleCallContext *context)
 {
     Value string = context->argument(0);
 
@@ -555,47 +555,47 @@ Value GlobalFunctions::method_parseFloat(SimpleCallContext *context)
     // 4:
     if (trimmed.startsWith(QLatin1String("Infinity"))
             || trimmed.startsWith(QLatin1String("+Infinity")))
-        return Value::fromDouble(Q_INFINITY);
+        return Encode(Q_INFINITY);
     if (trimmed.startsWith("-Infinity"))
-        return Value::fromDouble(-Q_INFINITY);
+        return Encode(-Q_INFINITY);
     QByteArray ba = trimmed.toLatin1();
     bool ok;
     const char *begin = ba.constData();
     const char *end = 0;
     double d = qstrtod(begin, &end, &ok);
     if (end - begin == 0)
-        return Value::fromDouble(std::numeric_limits<double>::quiet_NaN()); // 3
+        return Encode(std::numeric_limits<double>::quiet_NaN()); // 3
     else
-        return Value::fromDouble(d);
+        return Encode(d);
 }
 
 /// isNaN [15.1.2.4]
-Value GlobalFunctions::method_isNaN(SimpleCallContext *context)
+ReturnedValue GlobalFunctions::method_isNaN(SimpleCallContext *context)
 {
     const Value &v = context->argument(0);
     if (v.integerCompatible())
-        return Value::fromBoolean(false);
+        return Encode(false);
 
     double d = v.toNumber();
-    return Value::fromBoolean(std::isnan(d));
+    return Encode(std::isnan(d));
 }
 
 /// isFinite [15.1.2.5]
-Value GlobalFunctions::method_isFinite(SimpleCallContext *context)
+ReturnedValue GlobalFunctions::method_isFinite(SimpleCallContext *context)
 {
     const Value &v = context->argument(0);
     if (v.integerCompatible())
-        return Value::fromBoolean(true);
+        return Encode(true);
 
     double d = v.toNumber();
-    return Value::fromBoolean(std::isfinite(d));
+    return Encode(std::isfinite(d));
 }
 
 /// decodeURI [15.1.3.1]
-Value GlobalFunctions::method_decodeURI(SimpleCallContext *context)
+ReturnedValue GlobalFunctions::method_decodeURI(SimpleCallContext *context)
 {
     if (context->argumentCount == 0)
-        return Value::undefinedValue();
+        return Encode::undefined();
 
     QString uriString = context->arguments[0].toString(context)->toQString();
     bool ok;
@@ -603,14 +603,14 @@ Value GlobalFunctions::method_decodeURI(SimpleCallContext *context)
     if (!ok)
         context->throwURIError(Value::fromString(context, QStringLiteral("malformed URI sequence")));
 
-    return Value::fromString(context, out);
+    return Value::fromString(context, out).asReturnedValue();
 }
 
 /// decodeURIComponent [15.1.3.2]
-Value GlobalFunctions::method_decodeURIComponent(SimpleCallContext *context)
+ReturnedValue GlobalFunctions::method_decodeURIComponent(SimpleCallContext *context)
 {
     if (context->argumentCount == 0)
-        return Value::undefinedValue();
+        return Encode::undefined();
 
     QString uriString = context->arguments[0].toString(context)->toQString();
     bool ok;
@@ -618,14 +618,14 @@ Value GlobalFunctions::method_decodeURIComponent(SimpleCallContext *context)
     if (!ok)
         context->throwURIError(Value::fromString(context, QStringLiteral("malformed URI sequence")));
 
-    return Value::fromString(context, out);
+    return Value::fromString(context, out).asReturnedValue();
 }
 
 /// encodeURI [15.1.3.3]
-Value GlobalFunctions::method_encodeURI(SimpleCallContext *context)
+ReturnedValue GlobalFunctions::method_encodeURI(SimpleCallContext *context)
 {
     if (context->argumentCount == 0)
-        return Value::undefinedValue();
+        return Encode::undefined();
 
     QString uriString = context->arguments[0].toString(context)->toQString();
     bool ok;
@@ -633,14 +633,14 @@ Value GlobalFunctions::method_encodeURI(SimpleCallContext *context)
     if (!ok)
         context->throwURIError(Value::fromString(context, QStringLiteral("malformed URI sequence")));
 
-    return Value::fromString(context, out);
+    return Value::fromString(context, out).asReturnedValue();
 }
 
 /// encodeURIComponent [15.1.3.4]
-Value GlobalFunctions::method_encodeURIComponent(SimpleCallContext *context)
+ReturnedValue GlobalFunctions::method_encodeURIComponent(SimpleCallContext *context)
 {
     if (context->argumentCount == 0)
-        return Value::undefinedValue();
+        return Encode::undefined();
 
     QString uriString = context->arguments[0].toString(context)->toQString();
     bool ok;
@@ -648,23 +648,23 @@ Value GlobalFunctions::method_encodeURIComponent(SimpleCallContext *context)
     if (!ok)
         context->throwURIError(Value::fromString(context, QStringLiteral("malformed URI sequence")));
 
-    return Value::fromString(context, out);
+    return Value::fromString(context, out).asReturnedValue();
 }
 
-Value GlobalFunctions::method_escape(SimpleCallContext *context)
+ReturnedValue GlobalFunctions::method_escape(SimpleCallContext *context)
 {
     if (!context->argumentCount)
-        return Value::fromString(context, QStringLiteral("undefined"));
+        return Value::fromString(context, QStringLiteral("undefined")).asReturnedValue();
 
     QString str = context->argument(0).toString(context)->toQString();
-    return Value::fromString(context, escape(str));
+    return Value::fromString(context, escape(str)).asReturnedValue();
 }
 
-Value GlobalFunctions::method_unescape(SimpleCallContext *context)
+ReturnedValue GlobalFunctions::method_unescape(SimpleCallContext *context)
 {
     if (!context->argumentCount)
-        return Value::fromString(context, QStringLiteral("undefined"));
+        return Value::fromString(context, QStringLiteral("undefined")).asReturnedValue();
 
     QString str = context->argument(0).toString(context)->toQString();
-    return Value::fromString(context, unescape(str));
+    return Value::fromString(context, unescape(str)).asReturnedValue();
 }
diff --git a/src/qml/jsruntime/qv4globalobject_p.h b/src/qml/jsruntime/qv4globalobject_p.h
index c58078c26d..b9219a210c 100644
--- a/src/qml/jsruntime/qv4globalobject_p.h
+++ b/src/qml/jsruntime/qv4globalobject_p.h
@@ -63,16 +63,16 @@ protected:
 
 struct GlobalFunctions
 {
-    static Value method_parseInt(SimpleCallContext *context);
-    static Value method_parseFloat(SimpleCallContext *context);
-    static Value method_isNaN(SimpleCallContext *context);
-    static Value method_isFinite(SimpleCallContext *context);
-    static Value method_decodeURI(SimpleCallContext *context);
-    static Value method_decodeURIComponent(SimpleCallContext *context);
-    static Value method_encodeURI(SimpleCallContext *context);
-    static Value method_encodeURIComponent(SimpleCallContext *context);
-    static Value method_escape(SimpleCallContext *context);
-    static Value method_unescape(SimpleCallContext *context);
+    static ReturnedValue method_parseInt(SimpleCallContext *context);
+    static ReturnedValue method_parseFloat(SimpleCallContext *context);
+    static ReturnedValue method_isNaN(SimpleCallContext *context);
+    static ReturnedValue method_isFinite(SimpleCallContext *context);
+    static ReturnedValue method_decodeURI(SimpleCallContext *context);
+    static ReturnedValue method_decodeURIComponent(SimpleCallContext *context);
+    static ReturnedValue method_encodeURI(SimpleCallContext *context);
+    static ReturnedValue method_encodeURIComponent(SimpleCallContext *context);
+    static ReturnedValue method_escape(SimpleCallContext *context);
+    static ReturnedValue method_unescape(SimpleCallContext *context);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4include.cpp b/src/qml/jsruntime/qv4include.cpp
index 4da351dede..3bbfc4a322 100644
--- a/src/qml/jsruntime/qv4include.cpp
+++ b/src/qml/jsruntime/qv4include.cpp
@@ -172,10 +172,10 @@ void QV4Include::finished()
 /*
     Documented in qv8engine.cpp
 */
-QV4::Value QV4Include::include(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QV4Include::method_include(QV4::SimpleCallContext *ctx)
 {
     if (!ctx->argumentCount)
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
     QV4::ExecutionEngine *v4 = ctx->engine;
     QV8Engine *engine = v4->v8Engine;
@@ -230,7 +230,7 @@ QV4::Value QV4Include::include(QV4::SimpleCallContext *ctx)
         callback(callbackFunction, result);
     }
 
-    return result;
+    return result.asReturnedValue();
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/jsruntime/qv4include_p.h b/src/qml/jsruntime/qv4include_p.h
index bb582cd2c7..ccc634e066 100644
--- a/src/qml/jsruntime/qv4include_p.h
+++ b/src/qml/jsruntime/qv4include_p.h
@@ -78,7 +78,7 @@ public:
         Exception = 3
     };
 
-    static QV4::Value include(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_include(QV4::SimpleCallContext *ctx);
 
 private Q_SLOTS:
     void finished();
diff --git a/src/qml/jsruntime/qv4jsonobject.cpp b/src/qml/jsruntime/qv4jsonobject.cpp
index c1cc5391b2..f63d67ef0e 100644
--- a/src/qml/jsruntime/qv4jsonobject.cpp
+++ b/src/qml/jsruntime/qv4jsonobject.cpp
@@ -874,7 +874,7 @@ JsonObject::JsonObject(ExecutionContext *context)
 }
 
 
-Value JsonObject::method_parse(SimpleCallContext *ctx)
+ReturnedValue JsonObject::method_parse(SimpleCallContext *ctx)
 {
     QString jtext = ctx->argument(0).toString(ctx)->toQString();
 
@@ -887,10 +887,10 @@ Value JsonObject::method_parse(SimpleCallContext *ctx)
         ctx->throwSyntaxError("JSON.parse: Parse error");
     }
 
-    return result;
+    return result.asReturnedValue();
 }
 
-Value JsonObject::method_stringify(SimpleCallContext *ctx)
+ReturnedValue JsonObject::method_stringify(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
 
@@ -930,8 +930,8 @@ Value JsonObject::method_stringify(SimpleCallContext *ctx)
 
     QString result = stringify.Str(QString(), ctx->argument(0));
     if (result.isEmpty())
-        return Value::undefinedValue();
-    return Value::fromString(ctx, result);
+        return Encode::undefined();
+    return Value::fromString(ctx, result).asReturnedValue();
 }
 
 
diff --git a/src/qml/jsruntime/qv4jsonobject_p.h b/src/qml/jsruntime/qv4jsonobject_p.h
index ccd99d5488..e68236622a 100644
--- a/src/qml/jsruntime/qv4jsonobject_p.h
+++ b/src/qml/jsruntime/qv4jsonobject_p.h
@@ -56,8 +56,8 @@ private:
 public:
     JsonObject(ExecutionContext *context);
 
-    static Value method_parse(SimpleCallContext *ctx);
-    static Value method_stringify(SimpleCallContext *ctx);
+    static ReturnedValue method_parse(SimpleCallContext *ctx);
+    static ReturnedValue method_stringify(SimpleCallContext *ctx);
 
     static QV4::Value fromJsonValue(ExecutionEngine *engine, const QJsonValue &value);
     static QV4::Value fromJsonObject(ExecutionEngine *engine, const QJsonObject &object);
diff --git a/src/qml/jsruntime/qv4mathobject.cpp b/src/qml/jsruntime/qv4mathobject.cpp
index 0e7b32d429..cf2d5afd3f 100644
--- a/src/qml/jsruntime/qv4mathobject.cpp
+++ b/src/qml/jsruntime/qv4mathobject.cpp
@@ -96,112 +96,112 @@ static double copySign(double x, double y)
     return x;
 }
 
-Value MathObject::method_abs(SimpleCallContext *context)
+ReturnedValue MathObject::method_abs(SimpleCallContext *context)
 {
     if (!context->argumentCount)
-        return Value::fromDouble(qSNaN());
+        return Encode(qSNaN());
 
     if (context->arguments[0].isInteger()) {
         int i = context->arguments[0].integerValue();
-        return Value::fromInt32(i < 0 ? - i : i);
+        return Encode(i < 0 ? - i : i);
     }
 
     double v = context->arguments[0].toNumber();
     if (v == 0) // 0 | -0
-        return Value::fromDouble(0);
+        return Encode(0);
 
-    return Value::fromDouble(v < 0 ? -v : v);
+    return Encode(v < 0 ? -v : v);
 }
 
-Value MathObject::method_acos(SimpleCallContext *context)
+ReturnedValue MathObject::method_acos(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : 2;
     if (v > 1)
-        return Value::fromDouble(qSNaN());
+        return Encode(qSNaN());
 
-    return Value::fromDouble(::acos(v));
+    return Encode(::acos(v));
 }
 
-Value MathObject::method_asin(SimpleCallContext *context)
+ReturnedValue MathObject::method_asin(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : 2;
     if (v > 1)
-        return Value::fromDouble(qSNaN());
+        return Encode(qSNaN());
     else
-        return Value::fromDouble(::asin(v));
+        return Encode(::asin(v));
 }
 
-Value MathObject::method_atan(SimpleCallContext *context)
+ReturnedValue MathObject::method_atan(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
     if (v == 0.0)
-        return Value::fromDouble(v);
+        return Encode(v);
     else
-        return Value::fromDouble(::atan(v));
+        return Encode(::atan(v));
 }
 
-Value MathObject::method_atan2(SimpleCallContext *context)
+ReturnedValue MathObject::method_atan2(SimpleCallContext *context)
 {
     double v1 = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
     double v2 = context->argumentCount > 1 ? context->arguments[1].toNumber() : qSNaN();
 
     if ((v1 < 0) && qIsFinite(v1) && qIsInf(v2) && (copySign(1.0, v2) == 1.0))
-        return Value::fromDouble(copySign(0, -1.0));
+        return Encode(copySign(0, -1.0));
 
     if ((v1 == 0.0) && (v2 == 0.0)) {
         if ((copySign(1.0, v1) == 1.0) && (copySign(1.0, v2) == -1.0)) {
-            return Value::fromDouble(qt_PI);
+            return Encode(qt_PI);
         } else if ((copySign(1.0, v1) == -1.0) && (copySign(1.0, v2) == -1.0)) {
-            return Value::fromDouble(-qt_PI);
+            return Encode(-qt_PI);
         }
     }
-    return Value::fromDouble(::atan2(v1, v2));
+    return Encode(::atan2(v1, v2));
 }
 
-Value MathObject::method_ceil(SimpleCallContext *context)
+ReturnedValue MathObject::method_ceil(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
     if (v < 0.0 && v > -1.0)
-        return Value::fromDouble(copySign(0, -1.0));
+        return Encode(copySign(0, -1.0));
     else
-        return Value::fromDouble(::ceil(v));
+        return Encode(::ceil(v));
 }
 
-Value MathObject::method_cos(SimpleCallContext *context)
+ReturnedValue MathObject::method_cos(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
-    return Value::fromDouble(::cos(v));
+    return Encode(::cos(v));
 }
 
-Value MathObject::method_exp(SimpleCallContext *context)
+ReturnedValue MathObject::method_exp(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
     if (qIsInf(v)) {
         if (copySign(1.0, v) == -1.0)
-            return Value::fromDouble(0);
+            return Encode(0);
         else
-            return Value::fromDouble(qInf());
+            return Encode(qInf());
     } else {
-        return Value::fromDouble(::exp(v));
+        return Encode(::exp(v));
     }
 }
 
-Value MathObject::method_floor(SimpleCallContext *context)
+ReturnedValue MathObject::method_floor(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
-    return Value::fromDouble(::floor(v));
+    return Encode(::floor(v));
 }
 
-Value MathObject::method_log(SimpleCallContext *context)
+ReturnedValue MathObject::method_log(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
     if (v < 0)
-        return Value::fromDouble(qSNaN());
+        return Encode(qSNaN());
     else
-        return Value::fromDouble(::log(v));
+        return Encode(::log(v));
 }
 
-Value MathObject::method_max(SimpleCallContext *context)
+ReturnedValue MathObject::method_max(SimpleCallContext *context)
 {
     double mx = -qInf();
     for (unsigned i = 0; i < context->argumentCount; ++i) {
@@ -209,10 +209,10 @@ Value MathObject::method_max(SimpleCallContext *context)
         if (x > mx || std::isnan(x))
             mx = x;
     }
-    return Value::fromDouble(mx);
+    return Encode(mx);
 }
 
-Value MathObject::method_min(SimpleCallContext *context)
+ReturnedValue MathObject::method_min(SimpleCallContext *context)
 {
     double mx = qInf();
     for (unsigned i = 0; i < context->argumentCount; ++i) {
@@ -222,34 +222,34 @@ Value MathObject::method_min(SimpleCallContext *context)
             mx = x;
         }
     }
-    return Value::fromDouble(mx);
+    return Encode(mx);
 }
 
-Value MathObject::method_pow(SimpleCallContext *context)
+ReturnedValue MathObject::method_pow(SimpleCallContext *context)
 {
     double x = context->argumentCount > 0 ? context->arguments[0].toNumber() : qSNaN();
     double y = context->argumentCount > 1 ? context->arguments[1].toNumber() : qSNaN();
 
     if (std::isnan(y))
-        return Value::fromDouble(qSNaN());
+        return Encode(qSNaN());
 
     if (y == 0) {
-        return Value::fromDouble(1);
+        return Encode(1);
     } else if (((x == 1) || (x == -1)) && std::isinf(y)) {
-        return Value::fromDouble(qSNaN());
+        return Encode(qSNaN());
     } else if (((x == 0) && copySign(1.0, x) == 1.0) && (y < 0)) {
-        return Value::fromDouble(qInf());
+        return Encode(qInf());
     } else if ((x == 0) && copySign(1.0, x) == -1.0) {
         if (y < 0) {
             if (::fmod(-y, 2.0) == 1.0)
-                return Value::fromDouble(-qInf());
+                return Encode(-qInf());
             else
-                return Value::fromDouble(qInf());
+                return Encode(qInf());
         } else if (y > 0) {
             if (::fmod(y, 2.0) == 1.0)
-                return Value::fromDouble(copySign(0, -1.0));
+                return Encode(copySign(0, -1.0));
             else
-                return Value::fromDouble(0);
+                return Encode(0);
         }
     }
 
@@ -257,54 +257,54 @@ Value MathObject::method_pow(SimpleCallContext *context)
     else if (qIsInf(x) && copySign(1.0, x) == -1.0) {
         if (y > 0) {
             if (::fmod(y, 2.0) == 1.0)
-                return Value::fromDouble(-qInf());
+                return Encode(-qInf());
             else
-                return Value::fromDouble(qInf());
+                return Encode(qInf());
         } else if (y < 0) {
             if (::fmod(-y, 2.0) == 1.0)
-                return Value::fromDouble(copySign(0, -1.0));
+                return Encode(copySign(0, -1.0));
             else
-                return Value::fromDouble(0);
+                return Encode(0);
         }
     }
 #endif
     else {
-        return Value::fromDouble(::pow(x, y));
+        return Encode(::pow(x, y));
     }
     // ###
-    return Value::fromDouble(qSNaN());
+    return Encode(qSNaN());
 }
 
-Value MathObject::method_random(SimpleCallContext *)
+ReturnedValue MathObject::method_random(SimpleCallContext *)
 {
-    return Value::fromDouble(qrand() / (double) RAND_MAX);
+    return Encode(qrand() / (double) RAND_MAX);
 }
 
-Value MathObject::method_round(SimpleCallContext *context)
+ReturnedValue MathObject::method_round(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
     v = copySign(::floor(v + 0.5), v);
-    return Value::fromDouble(v);
+    return Encode(v);
 }
 
-Value MathObject::method_sin(SimpleCallContext *context)
+ReturnedValue MathObject::method_sin(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
-    return Value::fromDouble(::sin(v));
+    return Encode(::sin(v));
 }
 
-Value MathObject::method_sqrt(SimpleCallContext *context)
+ReturnedValue MathObject::method_sqrt(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
-    return Value::fromDouble(::sqrt(v));
+    return Encode(::sqrt(v));
 }
 
-Value MathObject::method_tan(SimpleCallContext *context)
+ReturnedValue MathObject::method_tan(SimpleCallContext *context)
 {
     double v = context->argumentCount ? context->arguments[0].toNumber() : qSNaN();
     if (v == 0.0)
-        return Value::fromDouble(v);
+        return Encode(v);
     else
-        return Value::fromDouble(::tan(v));
+        return Encode(::tan(v));
 }
 
diff --git a/src/qml/jsruntime/qv4mathobject_p.h b/src/qml/jsruntime/qv4mathobject_p.h
index 03c36bcc68..cdadc875f9 100644
--- a/src/qml/jsruntime/qv4mathobject_p.h
+++ b/src/qml/jsruntime/qv4mathobject_p.h
@@ -51,24 +51,24 @@ struct MathObject: Object
 {
     MathObject(ExecutionContext *ctx);
 
-    static Value method_abs(SimpleCallContext *context);
-    static Value method_acos(SimpleCallContext *context);
-    static Value method_asin(SimpleCallContext *context);
-    static Value method_atan(SimpleCallContext *context);
-    static Value method_atan2(SimpleCallContext *context);
-    static Value method_ceil(SimpleCallContext *context);
-    static Value method_cos(SimpleCallContext *context);
-    static Value method_exp(SimpleCallContext *context);
-    static Value method_floor(SimpleCallContext *context);
-    static Value method_log(SimpleCallContext *context);
-    static Value method_max(SimpleCallContext *context);
-    static Value method_min(SimpleCallContext *context);
-    static Value method_pow(SimpleCallContext *context);
-    static Value method_random(SimpleCallContext *context);
-    static Value method_round(SimpleCallContext *context);
-    static Value method_sin(SimpleCallContext *context);
-    static Value method_sqrt(SimpleCallContext *context);
-    static Value method_tan(SimpleCallContext *context);
+    static ReturnedValue method_abs(SimpleCallContext *context);
+    static ReturnedValue method_acos(SimpleCallContext *context);
+    static ReturnedValue method_asin(SimpleCallContext *context);
+    static ReturnedValue method_atan(SimpleCallContext *context);
+    static ReturnedValue method_atan2(SimpleCallContext *context);
+    static ReturnedValue method_ceil(SimpleCallContext *context);
+    static ReturnedValue method_cos(SimpleCallContext *context);
+    static ReturnedValue method_exp(SimpleCallContext *context);
+    static ReturnedValue method_floor(SimpleCallContext *context);
+    static ReturnedValue method_log(SimpleCallContext *context);
+    static ReturnedValue method_max(SimpleCallContext *context);
+    static ReturnedValue method_min(SimpleCallContext *context);
+    static ReturnedValue method_pow(SimpleCallContext *context);
+    static ReturnedValue method_random(SimpleCallContext *context);
+    static ReturnedValue method_round(SimpleCallContext *context);
+    static ReturnedValue method_sin(SimpleCallContext *context);
+    static ReturnedValue method_sqrt(SimpleCallContext *context);
+    static ReturnedValue method_tan(SimpleCallContext *context);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4numberobject.cpp b/src/qml/jsruntime/qv4numberobject.cpp
index 0f62a68903..f335e73123 100644
--- a/src/qml/jsruntime/qv4numberobject.cpp
+++ b/src/qml/jsruntime/qv4numberobject.cpp
@@ -106,7 +106,7 @@ inline Value thisNumberValue(ExecutionContext *ctx)
     return n->value;
 }
 
-Value NumberPrototype::method_toString(SimpleCallContext *ctx)
+ReturnedValue NumberPrototype::method_toString(SimpleCallContext *ctx)
 {
     double num = thisNumberValue(ctx).asDouble();
 
@@ -116,13 +116,13 @@ Value NumberPrototype::method_toString(SimpleCallContext *ctx)
         if (radix < 2 || radix > 36) {
             ctx->throwError(QString::fromLatin1("Number.prototype.toString: %0 is not a valid radix")
                             .arg(radix));
-            return Value::undefinedValue();
+            return Encode::undefined();
         }
 
         if (std::isnan(num)) {
-            return Value::fromString(ctx, QStringLiteral("NaN"));
+            return Value::fromString(ctx, QStringLiteral("NaN")).asReturnedValue();
         } else if (qIsInf(num)) {
-            return Value::fromString(ctx, QLatin1String(num < 0 ? "-Infinity" : "Infinity"));
+            return Value::fromString(ctx, QLatin1String(num < 0 ? "-Infinity" : "Infinity")).asReturnedValue();
         }
 
         if (radix != 10) {
@@ -152,28 +152,28 @@ Value NumberPrototype::method_toString(SimpleCallContext *ctx)
             }
             if (negative)
                 str.prepend(QLatin1Char('-'));
-            return Value::fromString(ctx, str);
+            return Value::fromString(ctx, str).asReturnedValue();
         }
     }
 
     String *str = Value::fromDouble(num).toString(ctx);
-    return Value::fromString(str);
+    return Value::fromString(str).asReturnedValue();
 }
 
-Value NumberPrototype::method_toLocaleString(SimpleCallContext *ctx)
+ReturnedValue NumberPrototype::method_toLocaleString(SimpleCallContext *ctx)
 {
     Value v = thisNumberValue(ctx);
 
     String *str = v.toString(ctx);
-    return Value::fromString(str);
+    return Value::fromString(str).asReturnedValue();
 }
 
-Value NumberPrototype::method_valueOf(SimpleCallContext *ctx)
+ReturnedValue NumberPrototype::method_valueOf(SimpleCallContext *ctx)
 {
-    return thisNumberValue(ctx);
+    return thisNumberValue(ctx).asReturnedValue();
 }
 
-Value NumberPrototype::method_toFixed(SimpleCallContext *ctx)
+ReturnedValue NumberPrototype::method_toFixed(SimpleCallContext *ctx)
 {
     double v = thisNumberValue(ctx).asDouble();
 
@@ -196,11 +196,11 @@ Value NumberPrototype::method_toFixed(SimpleCallContext *ctx)
     else if (v < 1.e21)
         str = QString::number(v, 'f', int (fdigits));
     else
-        return Value::fromReturnedValue(__qmljs_string_from_number(ctx, v));
-    return Value::fromString(ctx, str);
+        return __qmljs_string_from_number(ctx, v);
+    return Value::fromString(ctx, str).asReturnedValue();
 }
 
-Value NumberPrototype::method_toExponential(SimpleCallContext *ctx)
+ReturnedValue NumberPrototype::method_toExponential(SimpleCallContext *ctx)
 {
     double d = thisNumberValue(ctx).asDouble();
 
@@ -220,10 +220,10 @@ Value NumberPrototype::method_toExponential(SimpleCallContext *ctx)
     double_conversion::DoubleToStringConverter::EcmaScriptConverter().ToExponential(d, fdigits, &builder);
     QString result = QString::fromLatin1(builder.Finalize());
 
-    return Value::fromString(ctx, result);
+    return Value::fromString(ctx, result).asReturnedValue();
 }
 
-Value NumberPrototype::method_toPrecision(SimpleCallContext *ctx)
+ReturnedValue NumberPrototype::method_toPrecision(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
 
@@ -231,7 +231,7 @@ Value NumberPrototype::method_toPrecision(SimpleCallContext *ctx)
 
     Value prec = ctx->argument(0);
     if (prec.isUndefined())
-        return Value::fromReturnedValue(__qmljs_to_string(v, ctx));
+        return __qmljs_to_string(v, ctx);
 
     double precision = prec.toInt32();
     if (precision < 1 || precision > 21) {
@@ -244,5 +244,5 @@ Value NumberPrototype::method_toPrecision(SimpleCallContext *ctx)
     double_conversion::DoubleToStringConverter::EcmaScriptConverter().ToPrecision(v->asDouble(), precision, &builder);
     QString result = QString::fromLatin1(builder.Finalize());
 
-    return Value::fromString(ctx, result);
+    return Value::fromString(ctx, result).asReturnedValue();
 }
diff --git a/src/qml/jsruntime/qv4numberobject_p.h b/src/qml/jsruntime/qv4numberobject_p.h
index a024b7f334..6d66a6b1c1 100644
--- a/src/qml/jsruntime/qv4numberobject_p.h
+++ b/src/qml/jsruntime/qv4numberobject_p.h
@@ -65,12 +65,12 @@ struct NumberPrototype: NumberObject
     NumberPrototype(InternalClass *ic): NumberObject(ic) {}
     void init(ExecutionContext *ctx, const Value &ctor);
 
-    static Value method_toString(SimpleCallContext *ctx);
-    static Value method_toLocaleString(SimpleCallContext *ctx);
-    static Value method_valueOf(SimpleCallContext *ctx);
-    static Value method_toFixed(SimpleCallContext *ctx);
-    static Value method_toExponential(SimpleCallContext *ctx);
-    static Value method_toPrecision(SimpleCallContext *ctx);
+    static ReturnedValue method_toString(SimpleCallContext *ctx);
+    static ReturnedValue method_toLocaleString(SimpleCallContext *ctx);
+    static ReturnedValue method_valueOf(SimpleCallContext *ctx);
+    static ReturnedValue method_toFixed(SimpleCallContext *ctx);
+    static ReturnedValue method_toExponential(SimpleCallContext *ctx);
+    static ReturnedValue method_toPrecision(SimpleCallContext *ctx);
 };
 
 
diff --git a/src/qml/jsruntime/qv4object.cpp b/src/qml/jsruntime/qv4object.cpp
index a7945334f8..cec9ee3761 100644
--- a/src/qml/jsruntime/qv4object.cpp
+++ b/src/qml/jsruntime/qv4object.cpp
@@ -231,7 +231,7 @@ void Object::defineDefaultProperty(ExecutionEngine *engine, const QString &name,
     defineDefaultProperty(engine->newIdentifier(name), value);
 }
 
-void Object::defineDefaultProperty(ExecutionContext *context, const QString &name, Value (*code)(SimpleCallContext *), int argumentCount)
+void Object::defineDefaultProperty(ExecutionContext *context, const QString &name, ReturnedValue (*code)(SimpleCallContext *), int argumentCount)
 {
     Q_UNUSED(argumentCount);
     String *s = context->engine->newIdentifier(name);
@@ -240,7 +240,7 @@ void Object::defineDefaultProperty(ExecutionContext *context, const QString &nam
     defineDefaultProperty(s, Value::fromObject(function));
 }
 
-void Object::defineDefaultProperty(ExecutionEngine *engine, const QString &name, Value (*code)(SimpleCallContext *), int argumentCount)
+void Object::defineDefaultProperty(ExecutionEngine *engine, const QString &name, ReturnedValue (*code)(SimpleCallContext *), int argumentCount)
 {
     Q_UNUSED(argumentCount);
     String *s = engine->newIdentifier(name);
@@ -250,13 +250,13 @@ void Object::defineDefaultProperty(ExecutionEngine *engine, const QString &name,
 }
 
 void Object::defineAccessorProperty(ExecutionEngine *engine, const QString &name,
-                                    Value (*getter)(SimpleCallContext *), Value (*setter)(SimpleCallContext *))
+                                    ReturnedValue (*getter)(SimpleCallContext *), ReturnedValue (*setter)(SimpleCallContext *))
 {
     String *s = engine->newString(name);
     defineAccessorProperty(s, getter, setter);
 }
 
-void Object::defineAccessorProperty(String *name, Value (*getter)(SimpleCallContext *), Value (*setter)(SimpleCallContext *))
+void Object::defineAccessorProperty(String *name, ReturnedValue (*getter)(SimpleCallContext *), ReturnedValue (*setter)(SimpleCallContext *))
 {
     ExecutionEngine *v4 = engine();
     Property *p = insertMember(name, QV4::Attr_Accessor|QV4::Attr_NotConfigurable|QV4::Attr_NotEnumerable);
diff --git a/src/qml/jsruntime/qv4object_p.h b/src/qml/jsruntime/qv4object_p.h
index d64d2d119d..983f058148 100644
--- a/src/qml/jsruntime/qv4object_p.h
+++ b/src/qml/jsruntime/qv4object_p.h
@@ -165,10 +165,10 @@ struct Q_QML_EXPORT Object: Managed {
     void defineDefaultProperty(String *name, Value value);
     void defineDefaultProperty(ExecutionContext *context, const QString &name, Value value);
     void defineDefaultProperty(ExecutionEngine *engine, const QString &name, Value value);
-    void defineDefaultProperty(ExecutionContext *context, const QString &name, Value (*code)(SimpleCallContext *), int count = 0);
-    void defineDefaultProperty(ExecutionEngine *engine, const QString &name, Value (*code)(SimpleCallContext *), int count = 0);
-    void defineAccessorProperty(ExecutionEngine *engine, const QString &name, Value (*getter)(SimpleCallContext *), Value (*setter)(SimpleCallContext *));
-    void defineAccessorProperty(String *name, Value (*getter)(SimpleCallContext *), Value (*setter)(SimpleCallContext *));
+    void defineDefaultProperty(ExecutionContext *context, const QString &name, ReturnedValue (*code)(SimpleCallContext *), int count = 0);
+    void defineDefaultProperty(ExecutionEngine *engine, const QString &name, ReturnedValue (*code)(SimpleCallContext *), int count = 0);
+    void defineAccessorProperty(ExecutionEngine *engine, const QString &name, ReturnedValue (*getter)(SimpleCallContext *), ReturnedValue (*setter)(SimpleCallContext *));
+    void defineAccessorProperty(String *name, ReturnedValue (*getter)(SimpleCallContext *), ReturnedValue (*setter)(SimpleCallContext *));
     /* Fixed: Writable: false, Enumerable: false, Configurable: false */
     void defineReadonlyProperty(ExecutionEngine *engine, const QString &name, Value value);
     void defineReadonlyProperty(String *name, Value value);
diff --git a/src/qml/jsruntime/qv4objectproto.cpp b/src/qml/jsruntime/qv4objectproto.cpp
index 1192dd5952..0d168ea814 100644
--- a/src/qml/jsruntime/qv4objectproto.cpp
+++ b/src/qml/jsruntime/qv4objectproto.cpp
@@ -135,17 +135,17 @@ void ObjectPrototype::init(ExecutionContext *ctx, const Value &ctor)
     p->setSetter(v4->newBuiltinFunction(v4->rootContext, v4->id___proto__, method_set_proto));
 }
 
-Value ObjectPrototype::method_getPrototypeOf(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_getPrototypeOf(SimpleCallContext *ctx)
 {
     Value o = ctx->argument(0);
     if (! o.isObject())
         ctx->throwTypeError();
 
     Object *p = o.objectValue()->prototype();
-    return p ? Value::fromObject(p) : Value::nullValue();
+    return p ? Value::fromObject(p).asReturnedValue() : Encode::null();
 }
 
-Value ObjectPrototype::method_getOwnPropertyDescriptor(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_getOwnPropertyDescriptor(SimpleCallContext *ctx)
 {
     Value O = ctx->argument(0);
     if (!O.isObject())
@@ -157,17 +157,17 @@ Value ObjectPrototype::method_getOwnPropertyDescriptor(SimpleCallContext *ctx)
     return fromPropertyDescriptor(ctx, desc, attrs);
 }
 
-Value ObjectPrototype::method_getOwnPropertyNames(SimpleCallContext *context)
+ReturnedValue ObjectPrototype::method_getOwnPropertyNames(SimpleCallContext *context)
 {
     Object *O = context->argumentCount ? context->arguments[0].asObject() : 0;
     if (!O)
         context->throwTypeError();
 
     ArrayObject *array = getOwnPropertyNames(context->engine, context->arguments[0]);
-    return Value::fromObject(array);
+    return Value::fromObject(array).asReturnedValue();
 }
 
-Value ObjectPrototype::method_create(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_create(SimpleCallContext *ctx)
 {
     Value O = ctx->argument(0);
     if (!O.isObject() && !O.isNull())
@@ -182,10 +182,10 @@ Value ObjectPrototype::method_create(SimpleCallContext *ctx)
         method_defineProperties(ctx);
     }
 
-    return objValue;
+    return objValue.asReturnedValue();
 }
 
-Value ObjectPrototype::method_defineProperty(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_defineProperty(SimpleCallContext *ctx)
 {
     Value O = ctx->argument(0);
     if (!O.isObject())
@@ -201,10 +201,10 @@ Value ObjectPrototype::method_defineProperty(SimpleCallContext *ctx)
     if (!O.objectValue()->__defineOwnProperty__(ctx, name, pd, attrs))
         ctx->throwTypeError();
 
-    return O;
+    return O.asReturnedValue();
 }
 
-Value ObjectPrototype::method_defineProperties(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_defineProperties(SimpleCallContext *ctx)
 {
     Value O = ctx->argument(0);
     if (!O.isObject())
@@ -232,10 +232,10 @@ Value ObjectPrototype::method_defineProperties(SimpleCallContext *ctx)
             ctx->throwTypeError();
     }
 
-    return O;
+    return O.asReturnedValue();
 }
 
-Value ObjectPrototype::method_seal(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_seal(SimpleCallContext *ctx)
 {
     if (!ctx->argument(0).isObject())
         ctx->throwTypeError();
@@ -251,10 +251,10 @@ Value ObjectPrototype::method_seal(SimpleCallContext *ctx)
             o->arrayAttributes[i].setConfigurable(false);
     }
 
-    return ctx->argument(0);
+    return ctx->argument(0).asReturnedValue();
 }
 
-Value ObjectPrototype::method_freeze(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_freeze(SimpleCallContext *ctx)
 {
     if (!ctx->argument(0).isObject())
         ctx->throwTypeError();
@@ -271,83 +271,83 @@ Value ObjectPrototype::method_freeze(SimpleCallContext *ctx)
         if (o->arrayAttributes[i].isData())
             o->arrayAttributes[i].setWritable(false);
     }
-    return ctx->argument(0);
+    return ctx->argument(0).asReturnedValue();
 }
 
-Value ObjectPrototype::method_preventExtensions(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_preventExtensions(SimpleCallContext *ctx)
 {
     if (!ctx->argument(0).isObject())
         ctx->throwTypeError();
 
     Object *o = ctx->argument(0).objectValue();
     o->extensible = false;
-    return ctx->argument(0);
+    return ctx->argument(0).asReturnedValue();
 }
 
-Value ObjectPrototype::method_isSealed(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_isSealed(SimpleCallContext *ctx)
 {
     if (!ctx->argument(0).isObject())
         ctx->throwTypeError();
 
     Object *o = ctx->argument(0).objectValue();
     if (o->extensible)
-        return Value::fromBoolean(false);
+        return Encode(false);
 
     if (o->internalClass != o->internalClass->sealed())
-        return Value::fromBoolean(false);
+        return Encode(false);
 
     if (!o->arrayDataLen)
-        return Value::fromBoolean(true);
+        return Encode(true);
 
     if (!o->arrayAttributes)
-        return Value::fromBoolean(false);
+        return Encode(false);
 
     for (uint i = 0; i < o->arrayDataLen; ++i) {
         if (!o->arrayAttributes[i].isGeneric())
             if (o->arrayAttributes[i].isConfigurable())
-                return Value::fromBoolean(false);
+                return Encode(false);
     }
 
-    return Value::fromBoolean(true);
+    return Encode(true);
 }
 
-Value ObjectPrototype::method_isFrozen(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_isFrozen(SimpleCallContext *ctx)
 {
     if (!ctx->argument(0).isObject())
         ctx->throwTypeError();
 
     Object *o = ctx->argument(0).objectValue();
     if (o->extensible)
-        return Value::fromBoolean(false);
+        return Encode(false);
 
     if (o->internalClass != o->internalClass->frozen())
-        return Value::fromBoolean(false);
+        return Encode(false);
 
     if (!o->arrayDataLen)
-        return Value::fromBoolean(true);
+        return Encode(true);
 
     if (!o->arrayAttributes)
-        return Value::fromBoolean(false);
+        return Encode(false);
 
     for (uint i = 0; i < o->arrayDataLen; ++i) {
         if (!o->arrayAttributes[i].isGeneric())
             if (o->arrayAttributes[i].isConfigurable() || o->arrayAttributes[i].isWritable())
-                return Value::fromBoolean(false);
+                return Encode(false);
     }
 
-    return Value::fromBoolean(true);
+    return Encode(true);
 }
 
-Value ObjectPrototype::method_isExtensible(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_isExtensible(SimpleCallContext *ctx)
 {
     if (!ctx->argument(0).isObject())
         ctx->throwTypeError();
 
     Object *o = ctx->argument(0).objectValue();
-    return Value::fromBoolean(o->extensible);
+    return Encode(o->extensible);
 }
 
-Value ObjectPrototype::method_keys(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_keys(SimpleCallContext *ctx)
 {
     if (!ctx->argument(0).isObject())
         ctx->throwTypeError();
@@ -364,23 +364,23 @@ Value ObjectPrototype::method_keys(SimpleCallContext *ctx)
         a->push_back(name);
     }
 
-    return Value::fromObject(a);
+    return Value::fromObject(a).asReturnedValue();
 }
 
-Value ObjectPrototype::method_toString(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_toString(SimpleCallContext *ctx)
 {
     if (ctx->thisObject.isUndefined()) {
-        return Value::fromString(ctx, QStringLiteral("[object Undefined]"));
+        return Value::fromString(ctx, QStringLiteral("[object Undefined]")).asReturnedValue();
     } else if (ctx->thisObject.isNull()) {
-        return Value::fromString(ctx, QStringLiteral("[object Null]"));
+        return Value::fromString(ctx, QStringLiteral("[object Null]")).asReturnedValue();
     } else {
         Value obj = Value::fromReturnedValue(__qmljs_to_object(ctx, ValueRef(&ctx->thisObject)));
         QString className = obj.objectValue()->className();
-        return Value::fromString(ctx, QString::fromUtf8("[object %1]").arg(className));
+        return Value::fromString(ctx, QString::fromUtf8("[object %1]").arg(className)).asReturnedValue();
     }
 }
 
-Value ObjectPrototype::method_toLocaleString(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_toLocaleString(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     Object *o = ctx->thisObject.toObject(ctx);
@@ -389,51 +389,51 @@ Value ObjectPrototype::method_toLocaleString(SimpleCallContext *ctx)
         ctx->throwTypeError();
     ScopedCallData callData(scope, 0);
     callData->thisObject = Value::fromObject(o);
-    return Value::fromReturnedValue(f->call(callData));
+    return f->call(callData);
 }
 
-Value ObjectPrototype::method_valueOf(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_valueOf(SimpleCallContext *ctx)
 {
-    return Value::fromObject(ctx->thisObject.toObject(ctx));
+    return Value::fromObject(ctx->thisObject.toObject(ctx)).asReturnedValue();
 }
 
-Value ObjectPrototype::method_hasOwnProperty(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_hasOwnProperty(SimpleCallContext *ctx)
 {
     String *P = ctx->argument(0).toString(ctx);
     Object *O = ctx->thisObject.toObject(ctx);
     bool r = O->__getOwnProperty__(P) != 0;
     if (!r)
         r = !O->query(P).isEmpty();
-    return Value::fromBoolean(r);
+    return Encode(r);
 }
 
-Value ObjectPrototype::method_isPrototypeOf(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_isPrototypeOf(SimpleCallContext *ctx)
 {
     Value V = ctx->argument(0);
     if (! V.isObject())
-        return Value::fromBoolean(false);
+        return Encode(false);
 
     Object *O = ctx->thisObject.toObject(ctx);
     Object *proto = V.objectValue()->prototype();
     while (proto) {
         if (O == proto)
-            return Value::fromBoolean(true);
+            return Encode(true);
         proto = proto->prototype();
     }
-    return Value::fromBoolean(false);
+    return Encode(false);
 }
 
-Value ObjectPrototype::method_propertyIsEnumerable(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_propertyIsEnumerable(SimpleCallContext *ctx)
 {
     String *p = ctx->argument(0).toString(ctx);
 
     Object *o = ctx->thisObject.toObject(ctx);
     PropertyAttributes attrs;
     o->__getOwnProperty__(p, &attrs);
-    return Value::fromBoolean(attrs.isEnumerable());
+    return Encode(attrs.isEnumerable());
 }
 
-Value ObjectPrototype::method_defineGetter(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_defineGetter(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 2)
         ctx->throwTypeError();
@@ -446,16 +446,16 @@ Value ObjectPrototype::method_defineGetter(SimpleCallContext *ctx)
     Object *o = ctx->thisObject.asObject();
     if (!o) {
         if (!ctx->thisObject.isUndefined())
-            return Value::undefinedValue();
+            return Encode::undefined();
         o = ctx->engine->globalObject;
     }
 
     Property pd = Property::fromAccessor(f, 0);
     o->__defineOwnProperty__(ctx, prop, pd, Attr_Accessor);
-    return Value::undefinedValue();
+    return Encode::undefined();
 }
 
-Value ObjectPrototype::method_defineSetter(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_defineSetter(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 2)
         ctx->throwTypeError();
@@ -468,25 +468,25 @@ Value ObjectPrototype::method_defineSetter(SimpleCallContext *ctx)
     Object *o = ctx->thisObject.asObject();
     if (!o) {
         if (!ctx->thisObject.isUndefined())
-            return Value::undefinedValue();
+            return Encode::undefined();
         o = ctx->engine->globalObject;
     }
 
     Property pd = Property::fromAccessor(0, f);
     o->__defineOwnProperty__(ctx, prop, pd, Attr_Accessor);
-    return Value::undefinedValue();
+    return Encode::undefined();
 }
 
-Value ObjectPrototype::method_get_proto(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_get_proto(SimpleCallContext *ctx)
 {
     Object *o = ctx->thisObject.asObject();
     if (!o)
         ctx->throwTypeError();
 
-    return Value::fromObject(o->prototype());
+    return Value::fromObject(o->prototype()).asReturnedValue();
 }
 
-Value ObjectPrototype::method_set_proto(SimpleCallContext *ctx)
+ReturnedValue ObjectPrototype::method_set_proto(SimpleCallContext *ctx)
 {
     Object *o = ctx->thisObject.asObject();
     if (!o)
@@ -506,7 +506,7 @@ Value ObjectPrototype::method_set_proto(SimpleCallContext *ctx)
     }
     if (!ok)
         ctx->throwTypeError(QStringLiteral("Cyclic __proto__ value"));
-    return Value::undefinedValue();
+    return Encode::undefined();
 }
 
 void ObjectPrototype::toPropertyDescriptor(ExecutionContext *ctx, Value v, Property *desc, PropertyAttributes *attrs)
@@ -573,10 +573,10 @@ void ObjectPrototype::toPropertyDescriptor(ExecutionContext *ctx, Value v, Prope
 }
 
 
-Value ObjectPrototype::fromPropertyDescriptor(ExecutionContext *ctx, const Property *desc, PropertyAttributes attrs)
+ReturnedValue ObjectPrototype::fromPropertyDescriptor(ExecutionContext *ctx, const Property *desc, PropertyAttributes attrs)
 {
     if (!desc)
-        return Value::undefinedValue();
+        return Encode::undefined();
 
     ExecutionEngine *engine = ctx->engine;
 //    Let obj be the result of creating a new object as if by the expression new Object() where Object is the standard built-in constructor with that name.
@@ -599,7 +599,7 @@ Value ObjectPrototype::fromPropertyDescriptor(ExecutionContext *ctx, const Prope
     pd.value = Value::fromBoolean(attrs.isConfigurable());
     o->__defineOwnProperty__(ctx, engine->newString(QStringLiteral("configurable")), pd, Attr_Data);
 
-    return Value::fromObject(o);
+    return Value::fromObject(o).asReturnedValue();
 }
 
 
diff --git a/src/qml/jsruntime/qv4objectproto_p.h b/src/qml/jsruntime/qv4objectproto_p.h
index a8294d2f47..f9f6853eb9 100644
--- a/src/qml/jsruntime/qv4objectproto_p.h
+++ b/src/qml/jsruntime/qv4objectproto_p.h
@@ -66,35 +66,35 @@ struct ObjectPrototype: Object
 
     void init(ExecutionContext *ctx, const Value &ctor);
 
-    static Value method_getPrototypeOf(SimpleCallContext *ctx);
-    static Value method_getOwnPropertyDescriptor(SimpleCallContext *ctx);
-    static Value method_getOwnPropertyNames(SimpleCallContext *context);
-    static Value method_create(SimpleCallContext *ctx);
-    static Value method_defineProperty(SimpleCallContext *ctx);
-    static Value method_defineProperties(SimpleCallContext *ctx);
-    static Value method_seal(SimpleCallContext *ctx);
-    static Value method_freeze(SimpleCallContext *ctx);
-    static Value method_preventExtensions(SimpleCallContext *ctx);
-    static Value method_isSealed(SimpleCallContext *ctx);
-    static Value method_isFrozen(SimpleCallContext *ctx);
-    static Value method_isExtensible(SimpleCallContext *ctx);
-    static Value method_keys(SimpleCallContext *ctx);
-
-    static Value method_toString(SimpleCallContext *ctx);
-    static Value method_toLocaleString(SimpleCallContext *ctx);
-    static Value method_valueOf(SimpleCallContext *ctx);
-    static Value method_hasOwnProperty(SimpleCallContext *ctx);
-    static Value method_isPrototypeOf(SimpleCallContext *ctx);
-    static Value method_propertyIsEnumerable(SimpleCallContext *ctx);
-
-    static Value method_defineGetter(SimpleCallContext *ctx);
-    static Value method_defineSetter(SimpleCallContext *ctx);
-
-    static Value method_get_proto(SimpleCallContext *ctx);
-    static Value method_set_proto(SimpleCallContext *ctx);
+    static ReturnedValue method_getPrototypeOf(SimpleCallContext *ctx);
+    static ReturnedValue method_getOwnPropertyDescriptor(SimpleCallContext *ctx);
+    static ReturnedValue method_getOwnPropertyNames(SimpleCallContext *context);
+    static ReturnedValue method_create(SimpleCallContext *ctx);
+    static ReturnedValue method_defineProperty(SimpleCallContext *ctx);
+    static ReturnedValue method_defineProperties(SimpleCallContext *ctx);
+    static ReturnedValue method_seal(SimpleCallContext *ctx);
+    static ReturnedValue method_freeze(SimpleCallContext *ctx);
+    static ReturnedValue method_preventExtensions(SimpleCallContext *ctx);
+    static ReturnedValue method_isSealed(SimpleCallContext *ctx);
+    static ReturnedValue method_isFrozen(SimpleCallContext *ctx);
+    static ReturnedValue method_isExtensible(SimpleCallContext *ctx);
+    static ReturnedValue method_keys(SimpleCallContext *ctx);
+
+    static ReturnedValue method_toString(SimpleCallContext *ctx);
+    static ReturnedValue method_toLocaleString(SimpleCallContext *ctx);
+    static ReturnedValue method_valueOf(SimpleCallContext *ctx);
+    static ReturnedValue method_hasOwnProperty(SimpleCallContext *ctx);
+    static ReturnedValue method_isPrototypeOf(SimpleCallContext *ctx);
+    static ReturnedValue method_propertyIsEnumerable(SimpleCallContext *ctx);
+
+    static ReturnedValue method_defineGetter(SimpleCallContext *ctx);
+    static ReturnedValue method_defineSetter(SimpleCallContext *ctx);
+
+    static ReturnedValue method_get_proto(SimpleCallContext *ctx);
+    static ReturnedValue method_set_proto(SimpleCallContext *ctx);
 
     static void toPropertyDescriptor(ExecutionContext *ctx, Value v, Property *desc, PropertyAttributes *attrs);
-    static Value fromPropertyDescriptor(ExecutionContext *ctx, const Property *desc, PropertyAttributes attrs);
+    static ReturnedValue fromPropertyDescriptor(ExecutionContext *ctx, const Property *desc, PropertyAttributes attrs);
 
     static ArrayObject *getOwnPropertyNames(ExecutionEngine *v4, const Value &o);
 };
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index b42851778d..438465ef9b 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -780,7 +780,7 @@ struct QObjectSlotDispatcher : public QtPrivate::QSlotObjectBase
 
 } // namespace QV4
 
-Value QObjectWrapper::method_connect(SimpleCallContext *ctx)
+ReturnedValue QObjectWrapper::method_connect(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount == 0)
         V4THROW_ERROR("Function.prototype.connect: no arguments given");
@@ -816,10 +816,10 @@ Value QObjectWrapper::method_connect(SimpleCallContext *ctx)
 
     QObjectPrivate::connect(signalObject, signalIndex, slot, Qt::AutoConnection);
 
-    return QV4::Value::undefinedValue();
+    return Encode::undefined();
 }
 
-Value QObjectWrapper::method_disconnect(SimpleCallContext *ctx)
+ReturnedValue QObjectWrapper::method_disconnect(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount == 0)
         V4THROW_ERROR("Function.prototype.disconnect: no arguments given");
@@ -865,7 +865,7 @@ Value QObjectWrapper::method_disconnect(SimpleCallContext *ctx)
 
     QObjectPrivate::disconnect(signalObject, signalIndex, reinterpret_cast<void**>(&a));
 
-    return QV4::Value::undefinedValue();
+    return Encode::undefined();
 }
 
 static void markChildQObjectsRecursively(QObject *parent)
@@ -1022,7 +1022,7 @@ private:
 };
 }
 
-static QV4::Value CallMethod(QObject *object, int index, int returnType, int argCount,
+static QV4::ReturnedValue CallMethod(QObject *object, int index, int returnType, int argCount,
                                         int *argTypes, QV8Engine *engine, CallArgs &callArgs)
 {
     if (argCount > 0) {
@@ -1052,7 +1052,7 @@ static QV4::Value CallMethod(QObject *object, int index, int returnType, int arg
 
         QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, argData.data());
 
-        return args[0].toValue(engine);
+        return args[0].toValue(engine).asReturnedValue();
 
     } else if (returnType != QMetaType::Void) {
         
@@ -1063,13 +1063,13 @@ static QV4::Value CallMethod(QObject *object, int index, int returnType, int arg
 
         QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, args);
 
-        return arg.toValue(engine);
+        return arg.toValue(engine).asReturnedValue();
 
     } else {
 
         void *args[] = { 0 };
         QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, args);
-        return QV4::Value::undefinedValue();
+        return Encode::undefined();
 
     }
 }
@@ -1265,7 +1265,7 @@ static const QQmlPropertyData * RelatedMethod(QObject *object,
     }
 }
 
-static QV4::Value CallPrecise(QObject *object, const QQmlPropertyData &data,
+static QV4::ReturnedValue CallPrecise(QObject *object, const QQmlPropertyData &data,
                                          QV8Engine *engine, CallArgs &callArgs)
 {
     QByteArray unknownTypeError;
@@ -1319,7 +1319,7 @@ Resolve the overloaded method to call.  The algorithm works conceptually like th
         If two or more overloads have the same match score, call the last one.  The match
         score is constructed by adding the matchScore() result for each of the parameters.
 */
-static QV4::Value CallOverloaded(QObject *object, const QQmlPropertyData &data,
+static QV4::ReturnedValue CallOverloaded(QObject *object, const QQmlPropertyData &data,
                                             QV8Engine *engine, CallArgs &callArgs)
 {
     int argumentCount = callArgs.Length();
@@ -1650,7 +1650,7 @@ QObjectMethod::QObjectMethod(ExecutionContext *scope, QObject *object, int index
     subtype = WrappedQtMethod;
 }
 
-QV4::Value QObjectMethod::method_toString(QV4::ExecutionContext *ctx)
+QV4::ReturnedValue QObjectMethod::method_toString(QV4::ExecutionContext *ctx)
 {
     QString result;
     if (m_object) {
@@ -1671,13 +1671,13 @@ QV4::Value QObjectMethod::method_toString(QV4::ExecutionContext *ctx)
         result = QLatin1String("null");
     }
 
-    return QV4::Value::fromString(ctx, result);
+    return QV4::Value::fromString(ctx, result).asReturnedValue();
 }
 
-QV4::Value QObjectMethod::method_destroy(QV4::ExecutionContext *ctx, const Value *args, int argc)
+QV4::ReturnedValue QObjectMethod::method_destroy(QV4::ExecutionContext *ctx, const Value *args, int argc)
 {
     if (!m_object)
-        return QV4::Value::undefinedValue();
+        return Encode::undefined();
     if (QQmlData::keepAliveDuringGarbageCollection(m_object))
         ctx->throwError(QStringLiteral("Invalid attempt to destroy() an indestructible object"));
 
@@ -1690,16 +1690,16 @@ QV4::Value QObjectMethod::method_destroy(QV4::ExecutionContext *ctx, const Value
     else
         m_object->deleteLater();
 
-    return QV4::Value::undefinedValue();
+    return Encode::undefined();
 }
 
 ReturnedValue QObjectMethod::call(Managed *m, CallData *callData)
 {
     QObjectMethod *This = static_cast<QObjectMethod*>(m);
-    return This->callInternal(callData).asReturnedValue();
+    return This->callInternal(callData);
 }
 
-Value QObjectMethod::callInternal(CallData *callData)
+ReturnedValue QObjectMethod::callInternal(CallData *callData)
 {
     ExecutionContext *context = engine()->current;
     if (m_index == DestroyMethod)
@@ -1709,11 +1709,11 @@ Value QObjectMethod::callInternal(CallData *callData)
 
     QObject *object = m_object.data();
     if (!object)
-        return QV4::Value::undefinedValue();
+        return Encode::undefined();
 
     QQmlData *ddata = QQmlData::get(object);
     if (!ddata)
-        return QV4::Value::undefinedValue();
+        return Encode::undefined();
 
     QV8Engine *v8Engine = context->engine->v8Engine;
 
@@ -1723,7 +1723,7 @@ Value QObjectMethod::callInternal(CallData *callData)
         if (ddata->propertyCache) {
             QQmlPropertyData *d = ddata->propertyCache->method(m_index);
             if (!d)
-                return QV4::Value::undefinedValue();
+                return QV4::Encode::undefined();
             method = *d;
         }
     }
@@ -1732,7 +1732,7 @@ Value QObjectMethod::callInternal(CallData *callData)
         method.load(object->metaObject()->method(m_index));
 
         if (method.coreIndex == -1)
-            return QV4::Value::undefinedValue();
+            return QV4::Encode::undefined();
     }
 
     if (method.isV4Function()) {
@@ -1746,7 +1746,7 @@ Value QObjectMethod::callInternal(CallData *callData)
         void *args[] = { 0, &funcptr };
         QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, method.coreIndex, args);
 
-        return rv;
+        return rv.asReturnedValue();
     }
 
     CallArgs callArgs(callData->argc, callData->args);
diff --git a/src/qml/jsruntime/qv4qobjectwrapper_p.h b/src/qml/jsruntime/qv4qobjectwrapper_p.h
index 716e72d375..4c860e1786 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper_p.h
+++ b/src/qml/jsruntime/qv4qobjectwrapper_p.h
@@ -116,8 +116,8 @@ private:
         static_cast<QObjectWrapper *>(that)->~QObjectWrapper();
     }
 
-    static Value method_connect(SimpleCallContext *ctx);
-    static Value method_disconnect(SimpleCallContext *ctx);
+    static ReturnedValue method_connect(SimpleCallContext *ctx);
+    static ReturnedValue method_disconnect(SimpleCallContext *ctx);
 };
 
 struct QObjectMethod : public QV4::FunctionObject
@@ -134,8 +134,8 @@ struct QObjectMethod : public QV4::FunctionObject
 private:
     QObjectMethod(QV4::ExecutionContext *scope, QObject *object, int index, const QV4::Value &qmlGlobal);
 
-    QV4::Value method_toString(QV4::ExecutionContext *ctx);
-    QV4::Value method_destroy(QV4::ExecutionContext *ctx, const Value *args, int argc);
+    QV4::ReturnedValue method_toString(QV4::ExecutionContext *ctx);
+    QV4::ReturnedValue method_destroy(QV4::ExecutionContext *ctx, const Value *args, int argc);
 
     QPointer<QObject> m_object;
     int m_index;
@@ -143,7 +143,7 @@ private:
 
     static ReturnedValue call(Managed *, CallData *callData);
 
-    Value callInternal(CallData *callData);
+    ReturnedValue callInternal(CallData *callData);
 
     static void destroy(Managed *that)
     {
diff --git a/src/qml/jsruntime/qv4regexpobject.cpp b/src/qml/jsruntime/qv4regexpobject.cpp
index 3dcd49f6a5..355108ad23 100644
--- a/src/qml/jsruntime/qv4regexpobject.cpp
+++ b/src/qml/jsruntime/qv4regexpobject.cpp
@@ -297,7 +297,7 @@ void RegExpPrototype::init(ExecutionContext *ctx, const Value &ctor)
     defineDefaultProperty(ctx, QStringLiteral("compile"), method_compile, 2);
 }
 
-Value RegExpPrototype::method_exec(SimpleCallContext *ctx)
+ReturnedValue RegExpPrototype::method_exec(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
 
@@ -312,14 +312,14 @@ Value RegExpPrototype::method_exec(SimpleCallContext *ctx)
     int offset = r->global ? r->lastIndexProperty(ctx)->value.toInt32() : 0;
     if (offset < 0 || offset > s.length()) {
         r->lastIndexProperty(ctx)->value = Value::fromInt32(0);
-        return Value::nullValue();
+        return Encode::null();
     }
 
     uint* matchOffsets = (uint*)alloca(r->value->captureCount() * 2 * sizeof(uint));
     int result = r->value->match(s, offset, matchOffsets);
     if (result == -1) {
         r->lastIndexProperty(ctx)->value = Value::fromInt32(0);
-        return Value::nullValue();
+        return Encode::null();
     }
 
     // fill in result data
@@ -340,25 +340,26 @@ Value RegExpPrototype::method_exec(SimpleCallContext *ctx)
     if (r->global)
         r->lastIndexProperty(ctx)->value = Value::fromInt32(matchOffsets[1]);
 
-    return Value::fromObject(array);
+    return Value::fromObject(array).asReturnedValue();
 }
 
-Value RegExpPrototype::method_test(SimpleCallContext *ctx)
+ReturnedValue RegExpPrototype::method_test(SimpleCallContext *ctx)
 {
-    Value r = method_exec(ctx);
-    return Value::fromBoolean(!r.isNull());
+    Scope scope(ctx);
+    ScopedValue r(scope, method_exec(ctx));
+    return Encode(!r->isNull());
 }
 
-Value RegExpPrototype::method_toString(SimpleCallContext *ctx)
+ReturnedValue RegExpPrototype::method_toString(SimpleCallContext *ctx)
 {
     RegExpObject *r = ctx->thisObject.as<RegExpObject>();
     if (!r)
         ctx->throwTypeError();
 
-    return Value::fromString(ctx, r->toString());
+    return Value::fromString(ctx, r->toString()).asReturnedValue();
 }
 
-Value RegExpPrototype::method_compile(SimpleCallContext *ctx)
+ReturnedValue RegExpPrototype::method_compile(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     RegExpObject *r = ctx->thisObject.as<RegExpObject>();
@@ -371,7 +372,7 @@ Value RegExpPrototype::method_compile(SimpleCallContext *ctx)
 
     r->value = re->value;
     r->global = re->global;
-    return Value::undefinedValue();
+    return Encode::undefined();
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/jsruntime/qv4regexpobject_p.h b/src/qml/jsruntime/qv4regexpobject_p.h
index e95f3620fd..65c1f49371 100644
--- a/src/qml/jsruntime/qv4regexpobject_p.h
+++ b/src/qml/jsruntime/qv4regexpobject_p.h
@@ -117,10 +117,10 @@ struct RegExpPrototype: RegExpObject
     RegExpPrototype(InternalClass *ic): RegExpObject(ic) {}
     void init(ExecutionContext *ctx, const Value &ctor);
 
-    static Value method_exec(SimpleCallContext *ctx);
-    static Value method_test(SimpleCallContext *ctx);
-    static Value method_toString(SimpleCallContext *ctx);
-    static Value method_compile(SimpleCallContext *ctx);
+    static ReturnedValue method_exec(SimpleCallContext *ctx);
+    static ReturnedValue method_test(SimpleCallContext *ctx);
+    static ReturnedValue method_toString(SimpleCallContext *ctx);
+    static ReturnedValue method_compile(SimpleCallContext *ctx);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4scopedvalue_p.h b/src/qml/jsruntime/qv4scopedvalue_p.h
index 0382c7bb4b..68cc2848b3 100644
--- a/src/qml/jsruntime/qv4scopedvalue_p.h
+++ b/src/qml/jsruntime/qv4scopedvalue_p.h
@@ -357,6 +357,39 @@ private:
     CallData *ptr;
 };
 
+struct Encode : private Value {
+    static ReturnedValue undefined() {
+        return quint64(_Undefined_Type) << Tag_Shift;
+    }
+    static ReturnedValue null() {
+        return quint64(_Null_Type) << Tag_Shift;
+    }
+
+    Encode(bool b) {
+        tag = _Boolean_Type;
+        int_32 = b;
+    }
+    Encode(double d) {
+        dbl = d;
+    }
+    Encode(int i) {
+        tag = _Integer_Type;
+        int_32 = i;
+    }
+    Encode(uint i) {
+        if (i <= INT_MAX) {
+            tag = _Integer_Type;
+            int_32 = i;
+        } else {
+            dbl = i;
+        }
+    }
+
+    operator ReturnedValue() const {
+        return val;
+    }
+};
+
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp
index 68ae33335e..99c1878a9e 100644
--- a/src/qml/jsruntime/qv4sequenceobject.cpp
+++ b/src/qml/jsruntime/qv4sequenceobject.cpp
@@ -389,7 +389,7 @@ public:
             storeReference();
     }
 
-    static QV4::Value method_get_length(QV4::SimpleCallContext *ctx)
+    static QV4::ReturnedValue method_get_length(QV4::SimpleCallContext *ctx)
     {
         QQmlSequence<Container> *This = ctx->thisObject.as<QQmlSequence<Container> >();
         if (!This)
@@ -397,13 +397,13 @@ public:
 
         if (This->m_isReference) {
             if (!This->m_object)
-                return QV4::Value::fromInt32(0);
+                return QV4::Encode(0);
             This->loadReference();
         }
-        return QV4::Value::fromInt32(This->m_container.count());
+        return QV4::Encode(This->m_container.count());
     }
 
-    static QV4::Value method_set_length(QV4::SimpleCallContext* ctx)
+    static QV4::ReturnedValue method_set_length(QV4::SimpleCallContext* ctx)
     {
         QQmlSequence<Container> *This = ctx->thisObject.as<QQmlSequence<Container> >();
         if (!This)
@@ -413,19 +413,19 @@ public:
         /* Qt containers have int (rather than uint) allowable indexes. */
         if (newLength > INT_MAX) {
             generateWarning(ctx, QLatin1String("Index out of range during length set"));
-            return QV4::Value::undefinedValue();
+            return QV4::Encode::undefined();
         }
         /* Read the sequence from the QObject property if we're a reference */
         if (This->m_isReference) {
             if (!This->m_object)
-                return QV4::Value::undefinedValue();
+                return QV4::Encode::undefined();
             This->loadReference();
         }
         /* Determine whether we need to modify the sequence */
         qint32 newCount = static_cast<qint32>(newLength);
         qint32 count = This->m_container.count();
         if (newCount == count) {
-            return QV4::Value::undefinedValue();
+            return QV4::Encode::undefined();
         } else if (newCount > count) {
             /* according to ECMA262r3 we need to insert */
             /* undefined values increasing length to newLength. */
@@ -447,7 +447,7 @@ public:
             /* write back.  already checked that object is non-null, so skip that check here. */
             This->storeReference();
         }
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
     }
 
     QVariant toVariant() const
@@ -538,14 +538,14 @@ void SequencePrototype::init(QV4::ExecutionEngine *engine)
     defineDefaultProperty(engine, QStringLiteral("valueOf"), method_valueOf, 0);
 }
 
-QV4::Value SequencePrototype::method_sort(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue SequencePrototype::method_sort(QV4::SimpleCallContext *ctx)
 {
     QV4::Object *o = ctx->thisObject.asObject();
     if (!o || !o->isListType())
         ctx->throwTypeError();
 
     if (ctx->argumentCount >= 2)
-        return ctx->thisObject;
+        return ctx->thisObject.asReturnedValue();
 
 #define CALL_SORT(SequenceElementType, SequenceElementTypeName, SequenceType, DefaultValue) \
         if (QQml##SequenceElementTypeName##List *s = o->as<QQml##SequenceElementTypeName##List>()) { \
@@ -555,7 +555,7 @@ QV4::Value SequencePrototype::method_sort(QV4::SimpleCallContext *ctx)
         FOREACH_QML_SEQUENCE_TYPE(CALL_SORT)
 
 #undef CALL_SORT
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 #define IS_SEQUENCE(unused1, unused2, SequenceType, unused3) \
diff --git a/src/qml/jsruntime/qv4sequenceobject_p.h b/src/qml/jsruntime/qv4sequenceobject_p.h
index ceae4e6f97..2a81f81d26 100644
--- a/src/qml/jsruntime/qv4sequenceobject_p.h
+++ b/src/qml/jsruntime/qv4sequenceobject_p.h
@@ -69,12 +69,12 @@ struct SequencePrototype : public QV4::Object
 
     void init(QV4::ExecutionEngine *engine);
 
-    static QV4::Value method_valueOf(QV4::SimpleCallContext *ctx)
+    static QV4::ReturnedValue method_valueOf(QV4::SimpleCallContext *ctx)
     {
-        return QV4::Value::fromString(ctx->thisObject.toString(ctx));
+        return QV4::Value::fromString(ctx->thisObject.toString(ctx)).asReturnedValue();
     }
 
-    static QV4::Value method_sort(QV4::SimpleCallContext *ctx);
+    static ReturnedValue method_sort(QV4::SimpleCallContext *ctx);
 
     static bool isSequenceType(int sequenceTypeId);
     static QV4::Value newSequence(QV4::ExecutionEngine *engine, int sequenceTypeId, QObject *object, int propertyIndex, bool *succeeded);
diff --git a/src/qml/jsruntime/qv4stringobject.cpp b/src/qml/jsruntime/qv4stringobject.cpp
index 7a5252f3ad..dfdb639d1e 100644
--- a/src/qml/jsruntime/qv4stringobject.cpp
+++ b/src/qml/jsruntime/qv4stringobject.cpp
@@ -237,18 +237,18 @@ static QString getThisString(ExecutionContext *context, Value thisObject)
     return str->toQString();
 }
 
-Value StringPrototype::method_toString(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_toString(SimpleCallContext *context)
 {
     if (context->thisObject.isString())
-        return context->thisObject;
+        return context->thisObject.asReturnedValue();
 
     StringObject *o = context->thisObject.asStringObject();
     if (!o)
         context->throwTypeError();
-    return o->value;
+    return o->value.asReturnedValue();
 }
 
-Value StringPrototype::method_charAt(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_charAt(SimpleCallContext *context)
 {
     const QString str = getThisString(context, context->thisObject);
 
@@ -260,10 +260,10 @@ Value StringPrototype::method_charAt(SimpleCallContext *context)
     if (pos >= 0 && pos < str.length())
         result += str.at(pos);
 
-    return Value::fromString(context, result);
+    return Value::fromString(context, result).asReturnedValue();
 }
 
-Value StringPrototype::method_charCodeAt(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_charCodeAt(SimpleCallContext *context)
 {
     const QString str = getThisString(context, context->thisObject);
 
@@ -273,12 +273,12 @@ Value StringPrototype::method_charCodeAt(SimpleCallContext *context)
 
 
     if (pos >= 0 && pos < str.length())
-        return Value::fromInt32(str.at(pos).unicode());
+        return Encode(str.at(pos).unicode());
 
-    return Value::fromDouble(qSNaN());
+    return Encode(qSNaN());
 }
 
-Value StringPrototype::method_concat(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_concat(SimpleCallContext *context)
 {
     Scope scope(context);
 
@@ -291,10 +291,10 @@ Value StringPrototype::method_concat(SimpleCallContext *context)
         value += v->stringValue()->toQString();
     }
 
-    return Value::fromString(context, value);
+    return Value::fromString(context, value).asReturnedValue();
 }
 
-Value StringPrototype::method_indexOf(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_indexOf(SimpleCallContext *context)
 {
     QString value = getThisString(context, context->thisObject);
 
@@ -310,10 +310,10 @@ Value StringPrototype::method_indexOf(SimpleCallContext *context)
     if (! value.isEmpty())
         index = value.indexOf(searchString, qMin(qMax(pos, 0), value.length()));
 
-    return Value::fromDouble(index);
+    return Encode(index);
 }
 
-Value StringPrototype::method_lastIndexOf(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_lastIndexOf(SimpleCallContext *context)
 {
     Scope scope(context);
 
@@ -334,19 +334,19 @@ Value StringPrototype::method_lastIndexOf(SimpleCallContext *context)
     if (!searchString.isEmpty() && pos == value.length())
         --pos;
     if (searchString.isNull() && pos == 0)
-        return Value::fromDouble(-1);
+        return Encode(-1);
     int index = value.lastIndexOf(searchString, pos);
-    return Value::fromDouble(index);
+    return Encode(index);
 }
 
-Value StringPrototype::method_localeCompare(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_localeCompare(SimpleCallContext *context)
 {
     const QString value = getThisString(context, context->thisObject);
     const QString that = (context->argumentCount ? context->arguments[0] : Value::undefinedValue()).toString(context)->toQString();
-    return Value::fromDouble(QString::localeAwareCompare(value, that));
+    return Encode(QString::localeAwareCompare(value, that));
 }
 
-Value StringPrototype::method_match(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_match(SimpleCallContext *context)
 {
     if (context->thisObject.isUndefined() || context->thisObject.isNull())
         context->throwTypeError();
@@ -375,7 +375,7 @@ Value StringPrototype::method_match(SimpleCallContext *context)
     callData->thisObject = Value::fromObject(rx);
     callData->args[0] = Value::fromString(s);
     if (!global)
-        return Value::fromReturnedValue(exec->call(callData));
+        return exec->call(callData);
 
     String *lastIndex = context->engine->newString(QStringLiteral("lastIndex"));
     rx->put(lastIndex, Value::fromInt32(0));
@@ -404,9 +404,9 @@ Value StringPrototype::method_match(SimpleCallContext *context)
         ++n;
     }
     if (!n)
-        return Value::nullValue();
+        return Encode::null();
 
-    return Value::fromObject(a);
+    return Value::fromObject(a).asReturnedValue();
 
 }
 
@@ -455,7 +455,7 @@ static void appendReplacementString(QString *result, const QString &input, const
     }
 }
 
-Value StringPrototype::method_replace(SimpleCallContext *ctx)
+ReturnedValue StringPrototype::method_replace(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     QString string;
@@ -563,10 +563,10 @@ Value StringPrototype::method_replace(SimpleCallContext *ctx)
     if (matchOffsets != _matchOffsets)
         free(matchOffsets);
 
-    return Value::fromString(ctx, result);
+    return Value::fromString(ctx, result).asReturnedValue();
 }
 
-Value StringPrototype::method_search(SimpleCallContext *ctx)
+ReturnedValue StringPrototype::method_search(SimpleCallContext *ctx)
 {
     Scope scope(ctx);
     QString string;
@@ -586,11 +586,11 @@ Value StringPrototype::method_search(SimpleCallContext *ctx)
     uint* matchOffsets = (uint*)alloca(regExp->value->captureCount() * 2 * sizeof(uint));
     uint result = regExp->value->match(string, /*offset*/0, matchOffsets);
     if (result == JSC::Yarr::offsetNoMatch)
-        return Value::fromInt32(-1);
-    return Value::fromUInt32(result);
+        return Encode(-1);
+    return Encode(result);
 }
 
-Value StringPrototype::method_slice(SimpleCallContext *ctx)
+ReturnedValue StringPrototype::method_slice(SimpleCallContext *ctx)
 {
     const QString text = getThisString(ctx);
     const double length = text.length();
@@ -613,10 +613,10 @@ Value StringPrototype::method_slice(SimpleCallContext *ctx)
     const int intEnd = int(end);
 
     int count = qMax(0, intEnd - intStart);
-    return Value::fromString(ctx, text.mid(intStart, count));
+    return Value::fromString(ctx, text.mid(intStart, count)).asReturnedValue();
 }
 
-Value StringPrototype::method_split(SimpleCallContext *ctx)
+ReturnedValue StringPrototype::method_split(SimpleCallContext *ctx)
 {
     QString text;
     if (StringObject *thisObject = ctx->thisObject.asStringObject())
@@ -633,15 +633,15 @@ Value StringPrototype::method_split(SimpleCallContext *ctx)
     if (separatorValue.isUndefined()) {
         if (limitValue.isUndefined()) {
             array->push_back(Value::fromString(ctx, text));
-            return result;
+            return result.asReturnedValue();
         }
-        return Value::fromString(ctx, text.left(limitValue.toInteger()));
+        return Value::fromString(ctx, text.left(limitValue.toInteger())).asReturnedValue();
     }
 
     uint limit = limitValue.isUndefined() ? UINT_MAX : limitValue.toUInt32();
 
     if (limit == 0)
-        return result;
+        return result.asReturnedValue();
 
     if (RegExpObject* re = separatorValue.as<RegExpObject>()) {
         if (re->value->pattern().isEmpty()) {
@@ -679,7 +679,7 @@ Value StringPrototype::method_split(SimpleCallContext *ctx)
         if (separator.isEmpty()) {
             for (uint i = 0; i < qMin(limit, uint(text.length())); ++i)
                 array->push_back(Value::fromString(ctx, text.mid(i, 1)));
-            return result;
+            return result.asReturnedValue();
         }
 
         int start = 0;
@@ -693,10 +693,10 @@ Value StringPrototype::method_split(SimpleCallContext *ctx)
         if (array->arrayLength() < limit && start != -1)
             array->push_back(Value::fromString(ctx, text.mid(start)));
     }
-    return result;
+    return result.asReturnedValue();
 }
 
-Value StringPrototype::method_substr(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_substr(SimpleCallContext *context)
 {
     const QString value = getThisString(context, context->thisObject);
 
@@ -716,10 +716,10 @@ Value StringPrototype::method_substr(SimpleCallContext *context)
 
     qint32 x = Value::toInt32(start);
     qint32 y = Value::toInt32(length);
-    return Value::fromString(context, value.mid(x, y));
+    return Value::fromString(context, value.mid(x, y)).asReturnedValue();
 }
 
-Value StringPrototype::method_substring(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_substring(SimpleCallContext *context)
 {
     QString value = getThisString(context, context->thisObject);
     int length = value.length();
@@ -754,32 +754,32 @@ Value StringPrototype::method_substring(SimpleCallContext *context)
 
     qint32 x = (int)start;
     qint32 y = (int)(end - start);
-    return Value::fromString(context, value.mid(x, y));
+    return Value::fromString(context, value.mid(x, y)).asReturnedValue();
 }
 
-Value StringPrototype::method_toLowerCase(SimpleCallContext *ctx)
+ReturnedValue StringPrototype::method_toLowerCase(SimpleCallContext *ctx)
 {
     QString value = getThisString(ctx);
-    return Value::fromString(ctx, value.toLower());
+    return Value::fromString(ctx, value.toLower()).asReturnedValue();
 }
 
-Value StringPrototype::method_toLocaleLowerCase(SimpleCallContext *ctx)
+ReturnedValue StringPrototype::method_toLocaleLowerCase(SimpleCallContext *ctx)
 {
     return method_toLowerCase(ctx);
 }
 
-Value StringPrototype::method_toUpperCase(SimpleCallContext *ctx)
+ReturnedValue StringPrototype::method_toUpperCase(SimpleCallContext *ctx)
 {
     QString value = getThisString(ctx);
-    return Value::fromString(ctx, value.toUpper());
+    return Value::fromString(ctx, value.toUpper()).asReturnedValue();
 }
 
-Value StringPrototype::method_toLocaleUpperCase(SimpleCallContext *ctx)
+ReturnedValue StringPrototype::method_toLocaleUpperCase(SimpleCallContext *ctx)
 {
     return method_toUpperCase(ctx);
 }
 
-Value StringPrototype::method_fromCharCode(SimpleCallContext *context)
+ReturnedValue StringPrototype::method_fromCharCode(SimpleCallContext *context)
 {
     QString str(context->argumentCount, Qt::Uninitialized);
     QChar *ch = str.data();
@@ -787,10 +787,10 @@ Value StringPrototype::method_fromCharCode(SimpleCallContext *context)
         *ch = QChar(context->arguments[i].toUInt16());
         ++ch;
     }
-    return Value::fromString(context, str);
+    return Value::fromString(context, str).asReturnedValue();
 }
 
-Value StringPrototype::method_trim(SimpleCallContext *ctx)
+ReturnedValue StringPrototype::method_trim(SimpleCallContext *ctx)
 {
     if (ctx->thisObject.isNull() || ctx->thisObject.isUndefined())
         ctx->throwTypeError();
@@ -807,5 +807,5 @@ Value StringPrototype::method_trim(SimpleCallContext *ctx)
             break;
     }
 
-    return Value::fromString(ctx, QString(chars + start, end - start + 1));
+    return Value::fromString(ctx, QString(chars + start, end - start + 1)).asReturnedValue();
 }
diff --git a/src/qml/jsruntime/qv4stringobject_p.h b/src/qml/jsruntime/qv4stringobject_p.h
index 42c2a208d9..15607a209e 100644
--- a/src/qml/jsruntime/qv4stringobject_p.h
+++ b/src/qml/jsruntime/qv4stringobject_p.h
@@ -82,26 +82,26 @@ struct StringPrototype: StringObject
     StringPrototype(InternalClass *ic): StringObject(ic) {}
     void init(ExecutionEngine *engine, const Value &ctor);
 
-    static Value method_toString(SimpleCallContext *context);
-    static Value method_charAt(SimpleCallContext *context);
-    static Value method_charCodeAt(SimpleCallContext *context);
-    static Value method_concat(SimpleCallContext *context);
-    static Value method_indexOf(SimpleCallContext *context);
-    static Value method_lastIndexOf(SimpleCallContext *context);
-    static Value method_localeCompare(SimpleCallContext *context);
-    static Value method_match(SimpleCallContext *context);
-    static Value method_replace(SimpleCallContext *ctx);
-    static Value method_search(SimpleCallContext *ctx);
-    static Value method_slice(SimpleCallContext *ctx);
-    static Value method_split(SimpleCallContext *ctx);
-    static Value method_substr(SimpleCallContext *context);
-    static Value method_substring(SimpleCallContext *context);
-    static Value method_toLowerCase(SimpleCallContext *ctx);
-    static Value method_toLocaleLowerCase(SimpleCallContext *ctx);
-    static Value method_toUpperCase(SimpleCallContext *ctx);
-    static Value method_toLocaleUpperCase(SimpleCallContext *ctx);
-    static Value method_fromCharCode(SimpleCallContext *context);
-    static Value method_trim(SimpleCallContext *ctx);
+    static ReturnedValue method_toString(SimpleCallContext *context);
+    static ReturnedValue method_charAt(SimpleCallContext *context);
+    static ReturnedValue method_charCodeAt(SimpleCallContext *context);
+    static ReturnedValue method_concat(SimpleCallContext *context);
+    static ReturnedValue method_indexOf(SimpleCallContext *context);
+    static ReturnedValue method_lastIndexOf(SimpleCallContext *context);
+    static ReturnedValue method_localeCompare(SimpleCallContext *context);
+    static ReturnedValue method_match(SimpleCallContext *context);
+    static ReturnedValue method_replace(SimpleCallContext *ctx);
+    static ReturnedValue method_search(SimpleCallContext *ctx);
+    static ReturnedValue method_slice(SimpleCallContext *ctx);
+    static ReturnedValue method_split(SimpleCallContext *ctx);
+    static ReturnedValue method_substr(SimpleCallContext *context);
+    static ReturnedValue method_substring(SimpleCallContext *context);
+    static ReturnedValue method_toLowerCase(SimpleCallContext *ctx);
+    static ReturnedValue method_toLocaleLowerCase(SimpleCallContext *ctx);
+    static ReturnedValue method_toUpperCase(SimpleCallContext *ctx);
+    static ReturnedValue method_toLocaleUpperCase(SimpleCallContext *ctx);
+    static ReturnedValue method_fromCharCode(SimpleCallContext *context);
+    static ReturnedValue method_trim(SimpleCallContext *ctx);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4variantobject.cpp b/src/qml/jsruntime/qv4variantobject.cpp
index 574f612f74..ed3342aa58 100644
--- a/src/qml/jsruntime/qv4variantobject.cpp
+++ b/src/qml/jsruntime/qv4variantobject.cpp
@@ -152,15 +152,15 @@ void VariantPrototype::init(ExecutionEngine *engine)
     defineDefaultProperty(engine, QStringLiteral("toString"), method_toString, 0);
 }
 
-QV4::Value VariantPrototype::method_preserve(SimpleCallContext *ctx)
+QV4::ReturnedValue VariantPrototype::method_preserve(SimpleCallContext *ctx)
 {
     VariantObject *o = ctx->thisObject.as<QV4::VariantObject>();
     if (o && o->isScarce())
         o->node.remove();
-    return Value::undefinedValue();
+    return Encode::undefined();
 }
 
-QV4::Value VariantPrototype::method_destroy(SimpleCallContext *ctx)
+QV4::ReturnedValue VariantPrototype::method_destroy(SimpleCallContext *ctx)
 {
     VariantObject *o = ctx->thisObject.as<QV4::VariantObject>();
     if (o) {
@@ -168,42 +168,42 @@ QV4::Value VariantPrototype::method_destroy(SimpleCallContext *ctx)
             o->node.remove();
         o->data = QVariant();
     }
-    return QV4::Value::undefinedValue();
+    return Encode::undefined();
 }
 
-QV4::Value VariantPrototype::method_toString(SimpleCallContext *ctx)
+QV4::ReturnedValue VariantPrototype::method_toString(SimpleCallContext *ctx)
 {
     VariantObject *o = ctx->thisObject.as<QV4::VariantObject>();
     if (!o)
-        return Value::undefinedValue();
+        return Encode::undefined();
     QString result = o->data.toString();
     if (result.isEmpty() && !o->data.canConvert(QVariant::String))
         result = QString::fromLatin1("QVariant(%0)").arg(QString::fromLatin1(o->data.typeName()));
-    return Value::fromString(ctx->engine->newString(result));
+    return Value::fromString(ctx->engine->newString(result)).asReturnedValue();
 }
 
-QV4::Value VariantPrototype::method_valueOf(SimpleCallContext *ctx)
+QV4::ReturnedValue VariantPrototype::method_valueOf(SimpleCallContext *ctx)
 {
     VariantObject *o = ctx->thisObject.as<QV4::VariantObject>();
     if (o) {
         QVariant v = o->data;
         switch (v.type()) {
         case QVariant::Invalid:
-            return Value::undefinedValue();
+            return Encode::undefined();
         case QVariant::String:
-            return Value::fromString(ctx->engine->newString(v.toString()));
+            return Value::fromString(ctx->engine->newString(v.toString())).asReturnedValue();
         case QVariant::Int:
-            return Value::fromInt32(v.toInt());
+            return Encode(v.toInt());
         case QVariant::Double:
         case QVariant::UInt:
-            return Value::fromDouble(v.toDouble());
+            return Encode(v.toDouble());
         case QVariant::Bool:
-            return Value::fromBoolean(v.toBool());
+            return Encode(v.toBool());
         default:
             break;
         }
     }
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/jsruntime/qv4variantobject_p.h b/src/qml/jsruntime/qv4variantobject_p.h
index eadf0ac4cf..60a48374b0 100644
--- a/src/qml/jsruntime/qv4variantobject_p.h
+++ b/src/qml/jsruntime/qv4variantobject_p.h
@@ -89,10 +89,10 @@ public:
 
     void init(ExecutionEngine *engine);
 
-    static Value method_preserve(SimpleCallContext *ctx);
-    static Value method_destroy(SimpleCallContext *ctx);
-    static Value method_toString(SimpleCallContext *ctx);
-    static Value method_valueOf(SimpleCallContext *ctx);
+    static ReturnedValue method_preserve(SimpleCallContext *ctx);
+    static ReturnedValue method_destroy(SimpleCallContext *ctx);
+    static ReturnedValue method_toString(SimpleCallContext *ctx);
+    static ReturnedValue method_valueOf(SimpleCallContext *ctx);
 };
 
 }
diff --git a/src/qml/qml/qqmlcomponent.cpp b/src/qml/qml/qqmlcomponent.cpp
index 8cea3b6a69..9fbfa33a16 100644
--- a/src/qml/qml/qqmlcomponent.cpp
+++ b/src/qml/qml/qqmlcomponent.cpp
@@ -1093,11 +1093,11 @@ class QmlIncubatorObject : public QV4::Object, public QQmlIncubator
 public:
     QmlIncubatorObject(QV8Engine *engine, IncubationMode = Asynchronous);
 
-    static QV4::Value method_get_statusChanged(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_statusChanged(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_status(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_object(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_forceCompletion(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_statusChanged(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_statusChanged(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_status(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_object(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_forceCompletion(QV4::SimpleCallContext *ctx);
 
     static void destroy(Managed *that);
     static void markObjects(Managed *that);
@@ -1405,16 +1405,16 @@ QQmlComponentExtension::QQmlComponentExtension(QV8Engine *engine)
     incubationProto = QV4::Value::fromObject(proto);
 }
 
-QV4::Value QmlIncubatorObject::method_get_object(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QmlIncubatorObject::method_get_object(QV4::SimpleCallContext *ctx)
 {
     QmlIncubatorObject *o = ctx->thisObject.as<QmlIncubatorObject>();
     if (!o)
         ctx->throwTypeError();
 
-    return QV4::QObjectWrapper::wrap(ctx->engine, o->object());
+    return QV4::QObjectWrapper::wrap(ctx->engine, o->object()).asReturnedValue();
 }
 
-QV4::Value QmlIncubatorObject::method_forceCompletion(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QmlIncubatorObject::method_forceCompletion(QV4::SimpleCallContext *ctx)
 {
     QmlIncubatorObject *o = ctx->thisObject.as<QmlIncubatorObject>();
     if (!o)
@@ -1422,35 +1422,35 @@ QV4::Value QmlIncubatorObject::method_forceCompletion(QV4::SimpleCallContext *ct
 
     o->forceCompletion();
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-QV4::Value QmlIncubatorObject::method_get_status(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QmlIncubatorObject::method_get_status(QV4::SimpleCallContext *ctx)
 {
     QmlIncubatorObject *o = ctx->thisObject.as<QmlIncubatorObject>();
     if (!o)
         ctx->throwTypeError();
 
-    return QV4::Value::fromUInt32(o->status());
+    return QV4::Encode(o->status());
 }
 
-QV4::Value QmlIncubatorObject::method_get_statusChanged(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QmlIncubatorObject::method_get_statusChanged(QV4::SimpleCallContext *ctx)
 {
     QmlIncubatorObject *o = ctx->thisObject.as<QmlIncubatorObject>();
     if (!o)
         ctx->throwTypeError();
 
-    return o->m_statusChanged;
+    return o->m_statusChanged.asReturnedValue();
 }
 
-QV4::Value QmlIncubatorObject::method_set_statusChanged(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QmlIncubatorObject::method_set_statusChanged(QV4::SimpleCallContext *ctx)
 {
     QmlIncubatorObject *o = ctx->thisObject.as<QmlIncubatorObject>();
     if (!o || ctx->argumentCount < 1)
         ctx->throwTypeError();
 
     o->m_statusChanged = ctx->arguments[0];
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 QQmlComponentExtension::~QQmlComponentExtension()
diff --git a/src/qml/qml/qqmllocale.cpp b/src/qml/qml/qqmllocale.cpp
index 4cdcb96857..27c8dff598 100644
--- a/src/qml/qml/qqmllocale.cpp
+++ b/src/qml/qml/qqmllocale.cpp
@@ -74,33 +74,33 @@ public:
         return thisObject->locale;
     }
 
-    static QV4::Value method_currencySymbol(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_dateTimeFormat(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_timeFormat(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_dateFormat(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_monthName(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_standaloneMonthName(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_dayName(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_standaloneDayName(QV4::SimpleCallContext *ctx);
-
-    static QV4::Value method_get_firstDayOfWeek(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_measurementSystem(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_textDirection(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_weekDays(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_uiLanguages(QV4::SimpleCallContext *ctx);
-
-    static QV4::Value method_get_name(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_nativeLanguageName(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_nativeCountryName(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_decimalPoint(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_groupSeparator(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_percent(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_zeroDigit(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_negativeSign(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_positiveSign(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_exponential(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_amText(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_pmText(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_currencySymbol(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_dateTimeFormat(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_timeFormat(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_dateFormat(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_monthName(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_standaloneMonthName(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_dayName(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_standaloneDayName(QV4::SimpleCallContext *ctx);
+
+    static QV4::ReturnedValue method_get_firstDayOfWeek(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_measurementSystem(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_textDirection(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_weekDays(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_uiLanguages(QV4::SimpleCallContext *ctx);
+
+    static QV4::ReturnedValue method_get_name(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_nativeLanguageName(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_nativeCountryName(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_decimalPoint(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_groupSeparator(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_percent(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_zeroDigit(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_negativeSign(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_positiveSign(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_exponential(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_amText(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_pmText(QV4::SimpleCallContext *ctx);
 
 private:
     static void destroy(Managed *that)
@@ -126,16 +126,16 @@ static bool isLocaleObject(const QV4::Value &val)
 
 void QQmlDateExtension::registerExtension(QV4::ExecutionEngine *engine)
 {
-    engine->dateClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleString"), toLocaleString);
-    engine->dateClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleTimeString"), toLocaleTimeString);
-    engine->dateClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleDateString"), toLocaleDateString);
-    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleString"), fromLocaleString);
-    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleTimeString"), fromLocaleTimeString);
-    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleDateString"), fromLocaleDateString);
-    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("timeZoneUpdated"), timeZoneUpdated);
+    engine->dateClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleString"), method_toLocaleString);
+    engine->dateClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleTimeString"), method_toLocaleTimeString);
+    engine->dateClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleDateString"), method_toLocaleDateString);
+    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleString"), method_fromLocaleString);
+    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleTimeString"), method_fromLocaleTimeString);
+    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleDateString"), method_fromLocaleDateString);
+    engine->dateCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("timeZoneUpdated"), method_timeZoneUpdated);
 }
 
-QV4::Value QQmlDateExtension::toLocaleString(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlDateExtension::method_toLocaleString(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount > 2)
         return QV4::DatePrototype::method_toLocaleString(ctx);
@@ -149,7 +149,7 @@ QV4::Value QQmlDateExtension::toLocaleString(QV4::SimpleCallContext *ctx)
     if (ctx->argumentCount == 0) {
         // Use QLocale for standard toLocaleString() function
         QLocale locale;
-        return QV4::Value::fromString(ctx, locale.toString(dt));
+        return QV4::Value::fromString(ctx, locale.toString(dt)).asReturnedValue();
     }
 
     if (!isLocaleObject(ctx->arguments[0]))
@@ -174,10 +174,10 @@ QV4::Value QQmlDateExtension::toLocaleString(QV4::SimpleCallContext *ctx)
          formattedDt = r->locale.toString(dt, enumFormat);
     }
 
-    return QV4::Value::fromString(ctx, formattedDt);
+    return QV4::Value::fromString(ctx, formattedDt).asReturnedValue();
 }
 
-QV4::Value QQmlDateExtension::toLocaleTimeString(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlDateExtension::method_toLocaleTimeString(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount > 2)
         return QV4::DatePrototype::method_toLocaleTimeString(ctx);
@@ -192,7 +192,7 @@ QV4::Value QQmlDateExtension::toLocaleTimeString(QV4::SimpleCallContext *ctx)
     if (ctx->argumentCount == 0) {
         // Use QLocale for standard toLocaleString() function
         QLocale locale;
-        return QV4::Value::fromString(ctx, locale.toString(time));
+        return QV4::Value::fromString(ctx, locale.toString(time)).asReturnedValue();
     }
 
     if (!isLocaleObject(ctx->arguments[0]))
@@ -217,10 +217,10 @@ QV4::Value QQmlDateExtension::toLocaleTimeString(QV4::SimpleCallContext *ctx)
          formattedTime = r->locale.toString(time, enumFormat);
     }
 
-    return QV4::Value::fromString(ctx, formattedTime);
+    return QV4::Value::fromString(ctx, formattedTime).asReturnedValue();
 }
 
-QV4::Value QQmlDateExtension::toLocaleDateString(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlDateExtension::method_toLocaleDateString(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount > 2)
         return QV4::DatePrototype::method_toLocaleDateString(ctx);
@@ -235,7 +235,7 @@ QV4::Value QQmlDateExtension::toLocaleDateString(QV4::SimpleCallContext *ctx)
     if (ctx->argumentCount == 0) {
         // Use QLocale for standard toLocaleString() function
         QLocale locale;
-        return QV4::Value::fromString(ctx, locale.toString(date));
+        return QV4::Value::fromString(ctx, locale.toString(date)).asReturnedValue();
     }
 
     if (!isLocaleObject(ctx->arguments[0]))
@@ -260,17 +260,17 @@ QV4::Value QQmlDateExtension::toLocaleDateString(QV4::SimpleCallContext *ctx)
          formattedDate = r->locale.toString(date, enumFormat);
     }
 
-    return QV4::Value::fromString(ctx, formattedDate);
+    return QV4::Value::fromString(ctx, formattedDate).asReturnedValue();
 }
 
-QV4::Value QQmlDateExtension::fromLocaleString(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlDateExtension::method_fromLocaleString(QV4::SimpleCallContext *ctx)
 {
     QV4::ExecutionEngine * const engine = ctx->engine;
     if (ctx->argumentCount == 1 && ctx->arguments[0].isString()) {
         QLocale locale;
         QString dateString = ctx->arguments[0].stringValue()->toQString();
         QDateTime dt = locale.toDateTime(dateString);
-        return QV4::Value::fromObject(engine->newDateObject(dt));
+        return QV4::Value::fromObject(engine->newDateObject(dt)).asReturnedValue();
     }
 
     if (ctx->argumentCount < 1 || ctx->argumentCount > 3 || !isLocaleObject(ctx->arguments[0]))
@@ -296,10 +296,10 @@ QV4::Value QQmlDateExtension::fromLocaleString(QV4::SimpleCallContext *ctx)
         dt = r->locale.toDateTime(dateString, enumFormat);
     }
 
-    return QV4::Value::fromObject(engine->newDateObject(dt));
+    return QV4::Value::fromObject(engine->newDateObject(dt)).asReturnedValue();
 }
 
-QV4::Value QQmlDateExtension::fromLocaleTimeString(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlDateExtension::method_fromLocaleTimeString(QV4::SimpleCallContext *ctx)
 {
     QV4::ExecutionEngine * const engine = ctx->engine;
 
@@ -309,7 +309,7 @@ QV4::Value QQmlDateExtension::fromLocaleTimeString(QV4::SimpleCallContext *ctx)
         QTime time = locale.toTime(timeString);
         QDateTime dt = QDateTime::currentDateTime();
         dt.setTime(time);
-        return QV4::Value::fromObject(engine->newDateObject(dt));
+        return QV4::Value::fromObject(engine->newDateObject(dt)).asReturnedValue();
     }
 
     if (ctx->argumentCount < 1 || ctx->argumentCount > 3 || !isLocaleObject(ctx->arguments[0]))
@@ -338,10 +338,10 @@ QV4::Value QQmlDateExtension::fromLocaleTimeString(QV4::SimpleCallContext *ctx)
     QDateTime dt = QDateTime::currentDateTime();
     dt.setTime(tm);
 
-    return QV4::Value::fromObject(engine->newDateObject(dt));
+    return QV4::Value::fromObject(engine->newDateObject(dt)).asReturnedValue();
 }
 
-QV4::Value QQmlDateExtension::fromLocaleDateString(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlDateExtension::method_fromLocaleDateString(QV4::SimpleCallContext *ctx)
 {
     QV4::ExecutionEngine * const engine = ctx->engine;
 
@@ -349,7 +349,7 @@ QV4::Value QQmlDateExtension::fromLocaleDateString(QV4::SimpleCallContext *ctx)
         QLocale locale;
         QString dateString = ctx->arguments[0].stringValue()->toQString();
         QDate date = locale.toDate(dateString);
-        return QV4::Value::fromObject(engine->newDateObject(QDateTime(date)));
+        return QV4::Value::fromObject(engine->newDateObject(QDateTime(date))).asReturnedValue();
     }
 
     if (ctx->argumentCount < 1 || ctx->argumentCount > 3 || !isLocaleObject(ctx->arguments[0]))
@@ -375,17 +375,17 @@ QV4::Value QQmlDateExtension::fromLocaleDateString(QV4::SimpleCallContext *ctx)
         dt = r->locale.toDate(dateString, enumFormat);
     }
 
-    return QV4::Value::fromObject(engine->newDateObject(QDateTime(dt)));
+    return QV4::Value::fromObject(engine->newDateObject(QDateTime(dt))).asReturnedValue();
 }
 
-QV4::Value QQmlDateExtension::timeZoneUpdated(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlDateExtension::method_timeZoneUpdated(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 0)
         V4THROW_ERROR("Locale: Date.timeZoneUpdated(): Invalid arguments");
 
     QV4::DatePrototype::timezoneUpdated();
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 //-----------------
@@ -393,12 +393,12 @@ QV4::Value QQmlDateExtension::timeZoneUpdated(QV4::SimpleCallContext *ctx)
 
 void QQmlNumberExtension::registerExtension(QV4::ExecutionEngine *engine)
 {
-    engine->numberClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleString"), toLocaleString);
-    engine->numberClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleCurrencyString"), toLocaleCurrencyString);
-    engine->numberCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleString"), fromLocaleString);
+    engine->numberClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleString"), method_toLocaleString);
+    engine->numberClass->prototype->defineDefaultProperty(engine, QStringLiteral("toLocaleCurrencyString"), method_toLocaleCurrencyString);
+    engine->numberCtor.objectValue()->defineDefaultProperty(engine, QStringLiteral("fromLocaleString"), method_fromLocaleString);
 }
 
-QV4::Value QQmlNumberExtension::toLocaleString(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlNumberExtension::method_toLocaleString(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount > 3)
         V4THROW_ERROR("Locale: Number.toLocaleString(): Invalid arguments");
@@ -408,7 +408,7 @@ QV4::Value QQmlNumberExtension::toLocaleString(QV4::SimpleCallContext *ctx)
     if (ctx->argumentCount == 0) {
         // Use QLocale for standard toLocaleString() function
         QLocale locale;
-        return QV4::Value::fromString(ctx, locale.toString(number));
+        return QV4::Value::fromString(ctx, locale.toString(number)).asReturnedValue();
     }
 
     if (!isLocaleObject(ctx->arguments[0]))
@@ -431,10 +431,10 @@ QV4::Value QQmlNumberExtension::toLocaleString(QV4::SimpleCallContext *ctx)
          prec = ctx->arguments[2].toInt32();
     }
 
-    return QV4::Value::fromString(ctx, r->locale.toString(number, (char)format, prec));
+    return QV4::Value::fromString(ctx, r->locale.toString(number, (char)format, prec)).asReturnedValue();
 }
 
-QV4::Value QQmlNumberExtension::toLocaleCurrencyString(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlNumberExtension::method_toLocaleCurrencyString(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount > 2)
         V4THROW_ERROR("Locale: Number.toLocaleCurrencyString(): Invalid arguments");
@@ -444,7 +444,7 @@ QV4::Value QQmlNumberExtension::toLocaleCurrencyString(QV4::SimpleCallContext *c
     if (ctx->argumentCount == 0) {
         // Use QLocale for standard toLocaleString() function
         QLocale locale;
-        return QV4::Value::fromString(ctx, locale.toString(number));
+        return QV4::Value::fromString(ctx, locale.toString(number)).asReturnedValue();
     }
 
     if (!isLocaleObject(ctx->arguments[0]))
@@ -459,10 +459,10 @@ QV4::Value QQmlNumberExtension::toLocaleCurrencyString(QV4::SimpleCallContext *c
         symbol = ctx->arguments[1].toQStringNoThrow();
     }
 
-    return QV4::Value::fromString(ctx, r->locale.toCurrencyString(number, symbol));
+    return QV4::Value::fromString(ctx, r->locale.toCurrencyString(number, symbol)).asReturnedValue();
 }
 
-QV4::Value QQmlNumberExtension::fromLocaleString(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlNumberExtension::method_fromLocaleString(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 1 || ctx->argumentCount > 2)
         V4THROW_ERROR("Locale: Number.fromLocaleString(): Invalid arguments");
@@ -482,7 +482,7 @@ QV4::Value QQmlNumberExtension::fromLocaleString(QV4::SimpleCallContext *ctx)
 
     QV4::String *ns = ctx->arguments[numberIdx].toString(ctx);
     if (ns->isEmpty())
-        return QV4::Value::fromDouble(Q_QNAN);
+        return QV4::Encode(Q_QNAN);
 
     bool ok = false;
     double val = locale.toDouble(ns->toQString(), &ok);
@@ -490,34 +490,34 @@ QV4::Value QQmlNumberExtension::fromLocaleString(QV4::SimpleCallContext *ctx)
     if (!ok)
         V4THROW_ERROR("Locale: Number.fromLocaleString(): Invalid format")
 
-    return QV4::Value::fromDouble(val);
+    return QV4::Encode(val);
 }
 
 //--------------
 // Locale object
 
-QV4::Value QQmlLocaleData::method_get_firstDayOfWeek(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlLocaleData::method_get_firstDayOfWeek(QV4::SimpleCallContext *ctx)
 {
     QLocale locale = getThisLocale(ctx);
     int fdow = int(locale.firstDayOfWeek());
     if (fdow == 7)
         fdow = 0; // Qt::Sunday = 7, but Sunday is 0 in JS Date
-    return QV4::Value::fromInt32(fdow);
+    return QV4::Encode(fdow);
 }
 
-QV4::Value QQmlLocaleData::method_get_measurementSystem(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlLocaleData::method_get_measurementSystem(QV4::SimpleCallContext *ctx)
 {
     QLocale locale = getThisLocale(ctx);
-    return QV4::Value::fromInt32(locale.measurementSystem());
+    return QV4::Encode(locale.measurementSystem());
 }
 
-QV4::Value QQmlLocaleData::method_get_textDirection(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlLocaleData::method_get_textDirection(QV4::SimpleCallContext *ctx)
 {
     QLocale locale = getThisLocale(ctx);
-    return QV4::Value::fromInt32(locale.textDirection());
+    return QV4::Encode(locale.textDirection());
 }
 
-QV4::Value QQmlLocaleData::method_get_weekDays(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlLocaleData::method_get_weekDays(QV4::SimpleCallContext *ctx)
 {
     QLocale locale = getThisLocale(ctx);
     QList<Qt::DayOfWeek> days = locale.weekdays();
@@ -533,10 +533,10 @@ QV4::Value QQmlLocaleData::method_get_weekDays(QV4::SimpleCallContext *ctx)
     }
     result->setArrayLengthUnchecked(days.size());
 
-    return QV4::Value::fromObject(result);
+    return QV4::Value::fromObject(result).asReturnedValue();
 }
 
-QV4::Value QQmlLocaleData::method_get_uiLanguages(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlLocaleData::method_get_uiLanguages(QV4::SimpleCallContext *ctx)
 {
     QLocale locale = getThisLocale(ctx);
     QStringList langs = locale.uiLanguages();
@@ -547,10 +547,10 @@ QV4::Value QQmlLocaleData::method_get_uiLanguages(QV4::SimpleCallContext *ctx)
         result->arrayData[i].value = QV4::Value::fromString(ctx, langs.at(i));
     result->setArrayLengthUnchecked(langs.size());
 
-    return QV4::Value::fromObject(result);
+    return QV4::Value::fromObject(result).asReturnedValue();
 }
 
-QV4::Value QQmlLocaleData::method_currencySymbol(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlLocaleData::method_currencySymbol(QV4::SimpleCallContext *ctx)
 {
     QLocale locale = getThisLocale(ctx);
     if (ctx->argumentCount > 1)
@@ -562,11 +562,11 @@ QV4::Value QQmlLocaleData::method_currencySymbol(QV4::SimpleCallContext *ctx)
         format = QLocale::CurrencySymbolFormat(intFormat);
     }
 
-    return QV4::Value::fromString(ctx, locale.currencySymbol(format));
+    return QV4::Value::fromString(ctx, locale.currencySymbol(format)).asReturnedValue();
 }
 
 #define LOCALE_FORMAT(FUNC) \
-QV4::Value QQmlLocaleData::method_ ##FUNC (QV4::SimpleCallContext *ctx) { \
+QV4::ReturnedValue QQmlLocaleData::method_ ##FUNC (QV4::SimpleCallContext *ctx) { \
     QLocale locale = getThisLocale(ctx); \
     if (ctx->argumentCount > 1) \
         V4THROW_ERROR("Locale: " #FUNC "(): Invalid arguments"); \
@@ -575,7 +575,7 @@ QV4::Value QQmlLocaleData::method_ ##FUNC (QV4::SimpleCallContext *ctx) { \
         quint32 intFormat = ctx->arguments[0].toUInt32(); \
         format = QLocale::FormatType(intFormat); \
     } \
-    return QV4::Value::fromString(ctx, locale. FUNC (format)); \
+    return QV4::Value::fromString(ctx, locale. FUNC (format)).asReturnedValue(); \
 }
 
 LOCALE_FORMAT(dateTimeFormat)
@@ -584,7 +584,7 @@ LOCALE_FORMAT(dateFormat)
 
 // +1 added to idx because JS is 0-based, whereas QLocale months begin at 1.
 #define LOCALE_FORMATTED_MONTHNAME(VARIABLE) \
-QV4::Value QQmlLocaleData::method_ ## VARIABLE (QV4::SimpleCallContext *ctx) {\
+QV4::ReturnedValue QQmlLocaleData::method_ ## VARIABLE (QV4::SimpleCallContext *ctx) {\
     QLocale locale = getThisLocale(ctx); \
     if (ctx->argumentCount < 1 || ctx->argumentCount > 2) \
         V4THROW_ERROR("Locale: " #VARIABLE "(): Invalid arguments"); \
@@ -604,12 +604,12 @@ QV4::Value QQmlLocaleData::method_ ## VARIABLE (QV4::SimpleCallContext *ctx) {\
     } else { \
         name = locale. VARIABLE(idx, enumFormat); \
     } \
-    return QV4::Value::fromString(ctx, name); \
+    return QV4::Value::fromString(ctx, name).asReturnedValue(); \
 }
 
 // 0 -> 7 as Qt::Sunday is 7, but Sunday is 0 in JS Date
 #define LOCALE_FORMATTED_DAYNAME(VARIABLE) \
-QV4::Value QQmlLocaleData::method_ ## VARIABLE (QV4::SimpleCallContext *ctx) {\
+QV4::ReturnedValue QQmlLocaleData::method_ ## VARIABLE (QV4::SimpleCallContext *ctx) {\
     QLocale locale = getThisLocale(ctx); \
     if (ctx->argumentCount < 1 || ctx->argumentCount > 2) \
         V4THROW_ERROR("Locale: " #VARIABLE "(): Invalid arguments"); \
@@ -630,7 +630,7 @@ QV4::Value QQmlLocaleData::method_ ## VARIABLE (QV4::SimpleCallContext *ctx) {\
     } else { \
         name = locale. VARIABLE(idx, enumFormat); \
     } \
-    return QV4::Value::fromString(ctx, name); \
+    return QV4::Value::fromString(ctx, name).asReturnedValue(); \
 }
 
 LOCALE_FORMATTED_MONTHNAME(monthName)
@@ -638,10 +638,10 @@ LOCALE_FORMATTED_MONTHNAME(standaloneMonthName)
 LOCALE_FORMATTED_DAYNAME(dayName)
 LOCALE_FORMATTED_DAYNAME(standaloneDayName)
 
-#define LOCALE_STRING_PROPERTY(VARIABLE) QV4::Value QQmlLocaleData::method_get_ ## VARIABLE (QV4::SimpleCallContext* ctx) \
+#define LOCALE_STRING_PROPERTY(VARIABLE) QV4::ReturnedValue QQmlLocaleData::method_get_ ## VARIABLE (QV4::SimpleCallContext* ctx) \
 { \
     QLocale locale = getThisLocale(ctx); \
-    return QV4::Value::fromString(ctx, locale. VARIABLE());\
+    return QV4::Value::fromString(ctx, locale. VARIABLE()).asReturnedValue();\
 }
 
 LOCALE_STRING_PROPERTY(name)
@@ -820,10 +820,10 @@ QV4::Value QQmlLocale::locale(QV8Engine *v8engine, const QString &locale)
 
 void QQmlLocale::registerStringLocaleCompare(QV4::ExecutionEngine *engine)
 {
-    engine->stringClass->prototype->defineDefaultProperty(engine, QStringLiteral("localeCompare"), localeCompare);
+    engine->stringClass->prototype->defineDefaultProperty(engine, QStringLiteral("localeCompare"), method_localeCompare);
 }
 
-QV4::Value QQmlLocale::localeCompare(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlLocale::method_localeCompare(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1 || (!ctx->arguments[0].isString() && !ctx->arguments[0].asStringObject()))
         return QV4::StringPrototype::method_localeCompare(ctx);
@@ -834,7 +834,7 @@ QV4::Value QQmlLocale::localeCompare(QV4::SimpleCallContext *ctx)
     QString thisString = ctx->thisObject.toQStringNoThrow();
     QString thatString = ctx->arguments[0].toQStringNoThrow();
 
-    return QV4::Value::fromInt32(QString::localeAwareCompare(thisString, thatString));
+    return QV4::Encode(QString::localeAwareCompare(thisString, thatString));
 }
 
 /*!
diff --git a/src/qml/qml/qqmllocale_p.h b/src/qml/qml/qqmllocale_p.h
index 3bc8b6096e..5088693269 100644
--- a/src/qml/qml/qqmllocale_p.h
+++ b/src/qml/qml/qqmllocale_p.h
@@ -58,13 +58,13 @@ public:
     static void registerExtension(QV4::ExecutionEngine *engine);
 
 private:
-    static QV4::Value toLocaleString(QV4::SimpleCallContext *ctx);
-    static QV4::Value toLocaleTimeString(QV4::SimpleCallContext *ctx);
-    static QV4::Value toLocaleDateString(QV4::SimpleCallContext *ctx);
-    static QV4::Value fromLocaleString(QV4::SimpleCallContext *ctx);
-    static QV4::Value fromLocaleTimeString(QV4::SimpleCallContext *ctx);
-    static QV4::Value fromLocaleDateString(QV4::SimpleCallContext *ctx);
-    static QV4::Value timeZoneUpdated(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_toLocaleString(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_toLocaleTimeString(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_toLocaleDateString(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_fromLocaleString(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_fromLocaleTimeString(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_fromLocaleDateString(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_timeZoneUpdated(QV4::SimpleCallContext *ctx);
 };
 
 
@@ -74,9 +74,9 @@ public:
     static void registerExtension(QV4::ExecutionEngine *engine);
 
 private:
-    static QV4::Value toLocaleString(QV4::SimpleCallContext *ctx);
-    static QV4::Value fromLocaleString(QV4::SimpleCallContext *ctx);
-    static QV4::Value toLocaleCurrencyString(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_toLocaleString(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_fromLocaleString(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_toLocaleCurrencyString(QV4::SimpleCallContext *ctx);
 };
 
 
@@ -125,7 +125,7 @@ public:
 private:
     QQmlLocale();
 
-    static QV4::Value localeCompare(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_localeCompare(QV4::SimpleCallContext *ctx);
 };
 
 
diff --git a/src/qml/qml/qqmlvaluetypewrapper.cpp b/src/qml/qml/qqmlvaluetypewrapper.cpp
index 98b2497b0d..d9ee928858 100644
--- a/src/qml/qml/qqmlvaluetypewrapper.cpp
+++ b/src/qml/qml/qqmlvaluetypewrapper.cpp
@@ -239,7 +239,7 @@ bool QmlValueTypeWrapper::isEqual(const QVariant& value)
     }
 }
 
-Value QmlValueTypeWrapper::method_toString(SimpleCallContext *ctx)
+ReturnedValue QmlValueTypeWrapper::method_toString(SimpleCallContext *ctx)
 {
     Object *o = ctx->thisObject.asObject();
     if (!o)
@@ -251,15 +251,15 @@ Value QmlValueTypeWrapper::method_toString(SimpleCallContext *ctx)
     if (w->objectType == QmlValueTypeWrapper::Reference) {
         QmlValueTypeReference *reference = static_cast<QmlValueTypeReference *>(w);
         if (reference->object && readReferenceValue(reference)) {
-            return w->v8->toString(w->type->toString());
+            return w->v8->toString(w->type->toString()).asReturnedValue();
         } else {
-            return QV4::Value::undefinedValue();
+            return QV4::Encode::undefined();
         }
     } else {
         Q_ASSERT(w->objectType == QmlValueTypeWrapper::Copy);
         QmlValueTypeCopy *copy = static_cast<QmlValueTypeCopy *>(w);
         w->type->setValue(copy->value);
-        return w->v8->toString(w->type->toString());
+        return w->v8->toString(w->type->toString()).asReturnedValue();
     }
 }
 
diff --git a/src/qml/qml/qqmlvaluetypewrapper_p.h b/src/qml/qml/qqmlvaluetypewrapper_p.h
index aa9de3330e..2483b8e26b 100644
--- a/src/qml/qml/qqmlvaluetypewrapper_p.h
+++ b/src/qml/qml/qqmlvaluetypewrapper_p.h
@@ -89,7 +89,7 @@ public:
     static bool isEqualTo(Managed *m, Managed *other);
     static PropertyAttributes query(const Managed *, String *name);
 
-    static QV4::Value method_toString(SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_toString(SimpleCallContext *ctx);
 
     QV8Engine *v8;
     ObjectType objectType;
diff --git a/src/qml/qml/qqmlxmlhttprequest.cpp b/src/qml/qml/qqmlxmlhttprequest.cpp
index 85ae7fbe6c..651a2703f3 100644
--- a/src/qml/qml/qqmlxmlhttprequest.cpp
+++ b/src/qml/qml/qqmlxmlhttprequest.cpp
@@ -270,17 +270,17 @@ public:
     static void initClass(ExecutionEngine *engine);
 
     // JS API
-    static Value method_get_nodeName(SimpleCallContext *ctx);
-    static Value method_get_nodeValue(SimpleCallContext *ctx);
-    static Value method_get_nodeType(SimpleCallContext *ctx);
-
-    static Value method_get_parentNode(SimpleCallContext *ctx);
-    static Value method_get_childNodes(SimpleCallContext *ctx);
-    static Value method_get_firstChild(SimpleCallContext *ctx);
-    static Value method_get_lastChild(SimpleCallContext *ctx);
-    static Value method_get_previousSibling(SimpleCallContext *ctx);
-    static Value method_get_nextSibling(SimpleCallContext *ctx);
-    static Value method_get_attributes(SimpleCallContext *ctx);
+    static ReturnedValue method_get_nodeName(SimpleCallContext *ctx);
+    static ReturnedValue method_get_nodeValue(SimpleCallContext *ctx);
+    static ReturnedValue method_get_nodeType(SimpleCallContext *ctx);
+
+    static ReturnedValue method_get_parentNode(SimpleCallContext *ctx);
+    static ReturnedValue method_get_childNodes(SimpleCallContext *ctx);
+    static ReturnedValue method_get_firstChild(SimpleCallContext *ctx);
+    static ReturnedValue method_get_lastChild(SimpleCallContext *ctx);
+    static ReturnedValue method_get_previousSibling(SimpleCallContext *ctx);
+    static ReturnedValue method_get_nextSibling(SimpleCallContext *ctx);
+    static ReturnedValue method_get_attributes(SimpleCallContext *ctx);
 
     //static Value ownerDocument(SimpleCallContext *ctx);
     //static Value namespaceURI(SimpleCallContext *ctx);
@@ -343,10 +343,10 @@ class Attr : public Node
 {
 public:
     // JS API
-    static Value name(SimpleCallContext *ctx);
+    static ReturnedValue method_name(SimpleCallContext *ctx);
 //    static Value specified(SimpleCallContext *);
-    static Value value(SimpleCallContext *ctx);
-    static Value ownerElement(SimpleCallContext *ctx);
+    static ReturnedValue method_value(SimpleCallContext *ctx);
+    static ReturnedValue method_ownerElement(SimpleCallContext *ctx);
 //    static Value schemaTypeInfo(SimpleCallContext *);
 //    static Value isId(SimpleCallContext *c);
 
@@ -358,7 +358,7 @@ class CharacterData : public Node
 {
 public:
     // JS API
-    static Value length(SimpleCallContext *ctx);
+    static ReturnedValue method_length(SimpleCallContext *ctx);
 
     // C++ API
     static Value prototype(ExecutionEngine *v4);
@@ -368,8 +368,8 @@ class Text : public CharacterData
 {
 public:
     // JS API
-    static Value isElementContentWhitespace(SimpleCallContext *ctx);
-    static Value wholeText(SimpleCallContext *ctx);
+    static ReturnedValue method_isElementContentWhitespace(SimpleCallContext *ctx);
+    static ReturnedValue method_wholeText(SimpleCallContext *ctx);
 
     // C++ API
     static Value prototype(ExecutionEngine *);
@@ -386,14 +386,14 @@ class Document : public Node
 {
 public:
     // JS API
-    static Value xmlVersion(SimpleCallContext *ctx);
-    static Value xmlEncoding(SimpleCallContext *ctx);
-    static Value xmlStandalone(SimpleCallContext *ctx);
-    static Value documentElement(SimpleCallContext *ctx);
+    static ReturnedValue method_xmlVersion(SimpleCallContext *ctx);
+    static ReturnedValue method_xmlEncoding(SimpleCallContext *ctx);
+    static ReturnedValue method_xmlStandalone(SimpleCallContext *ctx);
+    static ReturnedValue method_documentElement(SimpleCallContext *ctx);
 
     // C++ API
     static Value prototype(ExecutionEngine *);
-    static Value load(QV8Engine *engine, const QByteArray &data);
+    static ReturnedValue load(QV8Engine *engine, const QByteArray &data);
 };
 
 }
@@ -408,7 +408,7 @@ void NodeImpl::release()
     document->release();
 }
 
-Value NodePrototype::method_get_nodeName(SimpleCallContext *ctx)
+ReturnedValue NodePrototype::method_get_nodeName(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
     if (!r)
@@ -429,10 +429,10 @@ Value NodePrototype::method_get_nodeName(SimpleCallContext *ctx)
         name = r->d->name;
         break;
     }
-    return Value::fromString(ctx->engine->newString(name));
+    return Value::fromString(ctx->engine->newString(name)).asReturnedValue();
 }
 
-Value NodePrototype::method_get_nodeValue(SimpleCallContext *ctx)
+ReturnedValue NodePrototype::method_get_nodeValue(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
     if (!r)
@@ -445,21 +445,21 @@ Value NodePrototype::method_get_nodeValue(SimpleCallContext *ctx)
         r->d->type == NodeImpl::Entity ||
         r->d->type == NodeImpl::EntityReference ||
         r->d->type == NodeImpl::Notation)
-        return Value::nullValue();
+        return Encode::null();
 
-    return Value::fromString(ctx->engine->newString(r->d->data));
+    return Value::fromString(ctx->engine->newString(r->d->data)).asReturnedValue();
 }
 
-Value NodePrototype::method_get_nodeType(SimpleCallContext *ctx)
+ReturnedValue NodePrototype::method_get_nodeType(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
     if (!r)
         ctx->throwTypeError();
 
-    return Value::fromInt32(r->d->type);
+    return Encode(r->d->type);
 }
 
-Value NodePrototype::method_get_parentNode(SimpleCallContext *ctx)
+ReturnedValue NodePrototype::method_get_parentNode(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
     if (!r)
@@ -467,11 +467,13 @@ Value NodePrototype::method_get_parentNode(SimpleCallContext *ctx)
 
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    if (r->d->parent) return Node::create(engine, r->d->parent);
-    else return Value::nullValue();
+    if (r->d->parent)
+        return Node::create(engine, r->d->parent).asReturnedValue();
+    else
+        return Encode::null();
 }
 
-Value NodePrototype::method_get_childNodes(SimpleCallContext *ctx)
+ReturnedValue NodePrototype::method_get_childNodes(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
     if (!r)
@@ -479,10 +481,10 @@ Value NodePrototype::method_get_childNodes(SimpleCallContext *ctx)
 
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    return NodeList::create(engine, r->d);
+    return NodeList::create(engine, r->d).asReturnedValue();
 }
 
-Value NodePrototype::method_get_firstChild(SimpleCallContext *ctx)
+ReturnedValue NodePrototype::method_get_firstChild(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
     if (!r)
@@ -490,11 +492,13 @@ Value NodePrototype::method_get_firstChild(SimpleCallContext *ctx)
 
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    if (r->d->children.isEmpty()) return Value::nullValue();
-    else return Node::create(engine, r->d->children.first());
+    if (r->d->children.isEmpty())
+        return Encode::null();
+    else
+        return Node::create(engine, r->d->children.first()).asReturnedValue();
 }
 
-Value NodePrototype::method_get_lastChild(SimpleCallContext *ctx)
+ReturnedValue NodePrototype::method_get_lastChild(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
     if (!r)
@@ -502,11 +506,13 @@ Value NodePrototype::method_get_lastChild(SimpleCallContext *ctx)
 
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    if (r->d->children.isEmpty()) return Value::nullValue();
-    else return Node::create(engine, r->d->children.last());
+    if (r->d->children.isEmpty())
+        return Encode::null();
+    else
+        return Node::create(engine, r->d->children.last()).asReturnedValue();
 }
 
-Value NodePrototype::method_get_previousSibling(SimpleCallContext *ctx)
+ReturnedValue NodePrototype::method_get_previousSibling(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
     if (!r)
@@ -514,19 +520,22 @@ Value NodePrototype::method_get_previousSibling(SimpleCallContext *ctx)
 
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    if (!r->d->parent) return Value::nullValue();
+    if (!r->d->parent)
+        return Encode::null();
 
     for (int ii = 0; ii < r->d->parent->children.count(); ++ii) {
         if (r->d->parent->children.at(ii) == r->d) {
-            if (ii == 0) return Value::nullValue();
-            else return Node::create(engine, r->d->parent->children.at(ii - 1));
+            if (ii == 0)
+                return Encode::null();
+            else
+                return Node::create(engine, r->d->parent->children.at(ii - 1)).asReturnedValue();
         }
     }
 
-    return Value::nullValue();
+    return Encode::null();
 }
 
-Value NodePrototype::method_get_nextSibling(SimpleCallContext *ctx)
+ReturnedValue NodePrototype::method_get_nextSibling(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
     if (!r)
@@ -534,19 +543,22 @@ Value NodePrototype::method_get_nextSibling(SimpleCallContext *ctx)
 
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    if (!r->d->parent) return Value::nullValue();
+    if (!r->d->parent)
+        return Encode::null();
 
     for (int ii = 0; ii < r->d->parent->children.count(); ++ii) {
         if (r->d->parent->children.at(ii) == r->d) {
-            if ((ii + 1) == r->d->parent->children.count()) return Value::nullValue();
-            else return Node::create(engine, r->d->parent->children.at(ii + 1)); 
+            if ((ii + 1) == r->d->parent->children.count())
+                return Encode::null();
+            else
+                return Node::create(engine, r->d->parent->children.at(ii + 1)).asReturnedValue();
         }
     }
 
-    return Value::nullValue();
+    return Encode::null();
 }
 
-Value NodePrototype::method_get_attributes(SimpleCallContext *ctx)
+ReturnedValue NodePrototype::method_get_attributes(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
     if (!r)
@@ -555,9 +567,9 @@ Value NodePrototype::method_get_attributes(SimpleCallContext *ctx)
     QV8Engine *engine = ctx->engine->v8Engine;
 
     if (r->d->type != NodeImpl::Element)
-        return Value::nullValue();
+        return Encode::null();
     else
-        return NamedNodeMap::create(engine, r->d, r->d->attributes);
+        return NamedNodeMap::create(engine, r->d, r->d->attributes).asReturnedValue();
 }
 
 Value NodePrototype::getProto(ExecutionEngine *v4)
@@ -624,49 +636,53 @@ Value Attr::prototype(ExecutionEngine *engine)
     if (d->attrPrototype.isEmpty()) {
         Object *p = engine->newObject();
         p->setPrototype(NodePrototype::getProto(engine).asObject());
-        p->defineAccessorProperty(engine, QStringLiteral("name"), name, 0);
-        p->defineAccessorProperty(engine, QStringLiteral("value"), value, 0);
-        p->defineAccessorProperty(engine, QStringLiteral("ownerElement"), ownerElement, 0);
+        p->defineAccessorProperty(engine, QStringLiteral("name"), method_name, 0);
+        p->defineAccessorProperty(engine, QStringLiteral("value"), method_value, 0);
+        p->defineAccessorProperty(engine, QStringLiteral("ownerElement"), method_ownerElement, 0);
         d->attrPrototype = Value::fromObject(p);
         engine->v8Engine->freezeObject(d->attrPrototype.value());
     }
     return d->attrPrototype.value();
 }
 
-Value Attr::name(SimpleCallContext *ctx)
+ReturnedValue Attr::method_name(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
-    if (!r) return Value::undefinedValue();
+    if (!r)
+        return Encode::undefined();
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    return engine->toString(r->d->name);
+    return engine->toString(r->d->name).asReturnedValue();
 }
 
-Value Attr::value(SimpleCallContext *ctx)
+ReturnedValue Attr::method_value(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
-    if (!r) return Value::undefinedValue();
+    if (!r)
+        return Encode::undefined();
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    return engine->toString(r->d->data);
+    return engine->toString(r->d->data).asReturnedValue();
 }
 
-Value Attr::ownerElement(SimpleCallContext *ctx)
+ReturnedValue Attr::method_ownerElement(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
-    if (!r) return Value::undefinedValue();
+    if (!r)
+        return Encode::undefined();
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    return Node::create(engine, r->d->parent);
+    return Node::create(engine, r->d->parent).asReturnedValue();
 }
 
-Value CharacterData::length(SimpleCallContext *ctx)
+ReturnedValue CharacterData::method_length(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
-    if (!r) return Value::undefinedValue();
+    if (!r)
+        return Encode::undefined();
     QV8Engine *engine = ctx->engine->v8Engine;
     Q_UNUSED(engine)
-    return Value::fromInt32(r->d->data.length());
+    return Encode(r->d->data.length());
 }
 
 Value CharacterData::prototype(ExecutionEngine *v4)
@@ -676,28 +692,29 @@ Value CharacterData::prototype(ExecutionEngine *v4)
         Object *p = v4->newObject();
         p->setPrototype(NodePrototype::getProto(v4).asObject());
         p->defineAccessorProperty(v4, QStringLiteral("data"), NodePrototype::method_get_nodeValue, 0);
-        p->defineAccessorProperty(v4, QStringLiteral("length"), length, 0);
+        p->defineAccessorProperty(v4, QStringLiteral("length"), method_length, 0);
         d->characterDataPrototype = Value::fromObject(p);
         v4->v8Engine->freezeObject(d->characterDataPrototype);
     }
     return d->characterDataPrototype.value();
 }
 
-Value Text::isElementContentWhitespace(SimpleCallContext *ctx)
+ReturnedValue Text::method_isElementContentWhitespace(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
-    if (!r) return Value::undefinedValue();
+    if (!r) return Encode::undefined();
 
-    return Value::fromBoolean(r->d->data.trimmed().isEmpty());
+    return Encode(r->d->data.trimmed().isEmpty());
 }
 
-Value Text::wholeText(SimpleCallContext *ctx)
+ReturnedValue Text::method_wholeText(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
-    if (!r) return Value::undefinedValue();
+    if (!r)
+        return Encode::undefined();
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    return engine->toString(r->d->data);
+    return engine->toString(r->d->data).asReturnedValue();
 }
 
 Value Text::prototype(ExecutionEngine *v4)
@@ -706,8 +723,8 @@ Value Text::prototype(ExecutionEngine *v4)
     if (d->textPrototype.isEmpty()) {
         Object *p = v4->newObject();
         p->setPrototype(CharacterData::prototype(v4).asObject());
-        p->defineAccessorProperty(v4, QStringLiteral("isElementContentWhitespace"), isElementContentWhitespace, 0);
-        p->defineAccessorProperty(v4, QStringLiteral("wholeText"), wholeText, 0);
+        p->defineAccessorProperty(v4, QStringLiteral("isElementContentWhitespace"), method_isElementContentWhitespace, 0);
+        p->defineAccessorProperty(v4, QStringLiteral("wholeText"), method_wholeText, 0);
         d->textPrototype = Value::fromObject(p);
         v4->v8Engine->freezeObject(d->textPrototype);
     }
@@ -733,17 +750,17 @@ Value Document::prototype(ExecutionEngine *v4)
     if (d->documentPrototype.isEmpty()) {
         Object *p = v4->newObject();
         p->setPrototype(NodePrototype::getProto(v4).asObject());
-        p->defineAccessorProperty(v4, QStringLiteral("xmlVersion"), xmlVersion, 0);
-        p->defineAccessorProperty(v4, QStringLiteral("xmlEncoding"), xmlEncoding, 0);
-        p->defineAccessorProperty(v4, QStringLiteral("xmlStandalone"), xmlStandalone, 0);
-        p->defineAccessorProperty(v4, QStringLiteral("documentElement"), documentElement, 0);
+        p->defineAccessorProperty(v4, QStringLiteral("xmlVersion"), method_xmlVersion, 0);
+        p->defineAccessorProperty(v4, QStringLiteral("xmlEncoding"), method_xmlEncoding, 0);
+        p->defineAccessorProperty(v4, QStringLiteral("xmlStandalone"), method_xmlStandalone, 0);
+        p->defineAccessorProperty(v4, QStringLiteral("documentElement"), method_documentElement, 0);
         d->documentPrototype = Value::fromObject(p);
         v4->v8Engine->freezeObject(d->documentPrototype);
     }
     return d->documentPrototype.value();
 }
 
-Value Document::load(QV8Engine *engine, const QByteArray &data)
+ReturnedValue Document::load(QV8Engine *engine, const QByteArray &data)
 {
     Q_ASSERT(engine);
     ExecutionEngine *v4 = QV8Engine::getV4(engine);
@@ -823,12 +840,12 @@ Value Document::load(QV8Engine *engine, const QByteArray &data)
     if (!document || reader.hasError()) {
         if (document)
             document->release();
-        return Value::nullValue();
+        return Encode::null();
     }
 
     Object *instance = new (v4->memoryManager) Node(v4, document);
     instance->setPrototype(Document::prototype(v4).asObject());
-    return Value::fromObject(instance);
+    return Value::fromObject(instance).asReturnedValue();
 }
 
 Node::Node(const Node &o)
@@ -859,7 +876,7 @@ ReturnedValue NamedNodeMap::getIndexed(Managed *m, uint index, bool *hasProperty
     }
     if (hasProperty)
         *hasProperty = false;
-    return Value::undefinedValue().asReturnedValue();
+    return Encode::undefined();
 }
 
 ReturnedValue NamedNodeMap::get(Managed *m, String *name, bool *hasProperty)
@@ -886,7 +903,7 @@ ReturnedValue NamedNodeMap::get(Managed *m, String *name, bool *hasProperty)
 
     if (hasProperty)
         *hasProperty = false;
-    return Value::undefinedValue().asReturnedValue();
+    return Encode::undefined();
 }
 
 Value NamedNodeMap::create(QV8Engine *engine, NodeImpl *data, const QList<NodeImpl *> &list)
@@ -913,7 +930,7 @@ ReturnedValue NodeList::getIndexed(Managed *m, uint index, bool *hasProperty)
     }
     if (hasProperty)
         *hasProperty = false;
-    return Value::undefinedValue().asReturnedValue();
+    return Encode::undefined();
 }
 
 ReturnedValue NodeList::get(Managed *m, String *name, bool *hasProperty)
@@ -938,40 +955,44 @@ Value NodeList::create(QV8Engine *engine, NodeImpl *data)
     return Value::fromObject(instance);
 }
 
-Value Document::documentElement(SimpleCallContext *ctx)
+ReturnedValue Document::method_documentElement(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
-    if (!r || r->d->type != NodeImpl::Document) return Value::undefinedValue();
+    if (!r || r->d->type != NodeImpl::Document)
+        return Encode::undefined();
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    return Node::create(engine, static_cast<DocumentImpl *>(r->d)->root);
+    return Node::create(engine, static_cast<DocumentImpl *>(r->d)->root).asReturnedValue();
 }
 
-Value Document::xmlStandalone(SimpleCallContext *ctx)
+ReturnedValue Document::method_xmlStandalone(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
-    if (!r || r->d->type != NodeImpl::Document) return Value::undefinedValue();
+    if (!r || r->d->type != NodeImpl::Document)
+        return Encode::undefined();
     QV8Engine *engine = ctx->engine->v8Engine;
     Q_UNUSED(engine)
-    return Value::fromBoolean(static_cast<DocumentImpl *>(r->d)->isStandalone);
+    return Encode(static_cast<DocumentImpl *>(r->d)->isStandalone);
 }
 
-Value Document::xmlVersion(SimpleCallContext *ctx)
+ReturnedValue Document::method_xmlVersion(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
-    if (!r || r->d->type != NodeImpl::Document) return Value::undefinedValue();
+    if (!r || r->d->type != NodeImpl::Document)
+        return Encode::undefined();
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    return engine->toString(static_cast<DocumentImpl *>(r->d)->version);
+    return engine->toString(static_cast<DocumentImpl *>(r->d)->version).asReturnedValue();
 }
 
-Value Document::xmlEncoding(SimpleCallContext *ctx)
+ReturnedValue Document::method_xmlEncoding(SimpleCallContext *ctx)
 {
     Node *r = ctx->thisObject.as<Node>();
-    if (!r || r->d->type != NodeImpl::Document) return Value::undefinedValue();
+    if (!r || r->d->type != NodeImpl::Document)
+        return Encode::undefined();
     QV8Engine *engine = ctx->engine->v8Engine;
 
-    return engine->toString(static_cast<DocumentImpl *>(r->d)->encoding);
+    return engine->toString(static_cast<DocumentImpl *>(r->d)->encoding).asReturnedValue();
 }
 
 class QQmlXMLHttpRequest : public QObject
@@ -1584,18 +1605,18 @@ struct QQmlXMLHttpRequestCtor : public FunctionObject
 
     void setupProto();
 
-    static Value method_open(SimpleCallContext *ctx);
-    static Value method_setRequestHeader(SimpleCallContext *ctx);
-    static Value method_send(SimpleCallContext *ctx);
-    static Value method_abort(SimpleCallContext *ctx);
-    static Value method_getResponseHeader(SimpleCallContext *ctx);
-    static Value method_getAllResponseHeaders(SimpleCallContext *ctx);
+    static ReturnedValue method_open(SimpleCallContext *ctx);
+    static ReturnedValue method_setRequestHeader(SimpleCallContext *ctx);
+    static ReturnedValue method_send(SimpleCallContext *ctx);
+    static ReturnedValue method_abort(SimpleCallContext *ctx);
+    static ReturnedValue method_getResponseHeader(SimpleCallContext *ctx);
+    static ReturnedValue method_getAllResponseHeaders(SimpleCallContext *ctx);
 
-    static Value method_get_readyState(SimpleCallContext *ctx);
-    static Value method_get_status(SimpleCallContext *ctx);
-    static Value method_get_statusText(SimpleCallContext *ctx);
-    static Value method_get_responseText(SimpleCallContext *ctx);
-    static Value method_get_responseXML(SimpleCallContext *ctx);
+    static ReturnedValue method_get_readyState(SimpleCallContext *ctx);
+    static ReturnedValue method_get_status(SimpleCallContext *ctx);
+    static ReturnedValue method_get_statusText(SimpleCallContext *ctx);
+    static ReturnedValue method_get_responseText(SimpleCallContext *ctx);
+    static ReturnedValue method_get_responseXML(SimpleCallContext *ctx);
 
 
     Object *proto;
@@ -1633,7 +1654,7 @@ void QQmlXMLHttpRequestCtor::setupProto()
 
 
 // XMLHttpRequest methods
-Value QQmlXMLHttpRequestCtor::method_open(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_open(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
@@ -1678,10 +1699,10 @@ Value QQmlXMLHttpRequestCtor::method_open(SimpleCallContext *ctx)
     if (!username.isNull()) url.setUserName(username);
     if (!password.isNull()) url.setPassword(password);
 
-    return r->open(constructMeObject(ctx->thisObject, engine), method, url);
+    return r->open(constructMeObject(ctx->thisObject, engine), method, url).asReturnedValue();
 }
 
-Value QQmlXMLHttpRequestCtor::method_setRequestHeader(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_setRequestHeader(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
@@ -1720,14 +1741,14 @@ Value QQmlXMLHttpRequestCtor::method_setRequestHeader(SimpleCallContext *ctx)
         nameUpper == QLatin1String("VIA") ||
         nameUpper.startsWith(QLatin1String("PROXY-")) ||
         nameUpper.startsWith(QLatin1String("SEC-"))) 
-        return Value::undefinedValue();
+        return Encode::undefined();
 
     r->addHeader(name, value);
 
-    return Value::undefinedValue();
+    return Encode::undefined();
 }
 
-Value QQmlXMLHttpRequestCtor::method_send(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_send(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
@@ -1744,20 +1765,20 @@ Value QQmlXMLHttpRequestCtor::method_send(SimpleCallContext *ctx)
     if (ctx->argumentCount > 0)
         data = ctx->arguments[0].toQStringNoThrow().toUtf8();
 
-    return r->send(constructMeObject(ctx->thisObject, engine), data);
+    return r->send(constructMeObject(ctx->thisObject, engine), data).asReturnedValue();
 }
 
-Value QQmlXMLHttpRequestCtor::method_abort(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_abort(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->request;
 
-    return r->abort(constructMeObject(ctx->thisObject, ctx->engine->v8Engine));
+    return r->abort(constructMeObject(ctx->thisObject, ctx->engine->v8Engine)).asReturnedValue();
 }
 
-Value QQmlXMLHttpRequestCtor::method_getResponseHeader(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_getResponseHeader(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
@@ -1774,10 +1795,10 @@ Value QQmlXMLHttpRequestCtor::method_getResponseHeader(SimpleCallContext *ctx)
         r->readyState() != QQmlXMLHttpRequest::HeadersReceived)
         V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
-    return engine->toString(r->header(ctx->arguments[0].toQStringNoThrow()));
+    return engine->toString(r->header(ctx->arguments[0].toQStringNoThrow())).asReturnedValue();
 }
 
-Value QQmlXMLHttpRequestCtor::method_getAllResponseHeaders(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_getAllResponseHeaders(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
@@ -1794,21 +1815,21 @@ Value QQmlXMLHttpRequestCtor::method_getAllResponseHeaders(SimpleCallContext *ct
         r->readyState() != QQmlXMLHttpRequest::HeadersReceived)
         V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
-    return engine->toString(r->headers());
+    return engine->toString(r->headers()).asReturnedValue();
 }
 
 // XMLHttpRequest properties
-Value QQmlXMLHttpRequestCtor::method_get_readyState(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_get_readyState(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
         V4THROW_REFERENCE("Not an XMLHttpRequest object");
     QQmlXMLHttpRequest *r = w->request;
 
-    return Value::fromUInt32(r->readyState());
+    return Encode(r->readyState());
 }
 
-Value QQmlXMLHttpRequestCtor::method_get_status(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_get_status(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
@@ -1820,12 +1841,12 @@ Value QQmlXMLHttpRequestCtor::method_get_status(SimpleCallContext *ctx)
         V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
     if (r->errorFlag())
-        return Value::fromInt32(0);
+        return Encode(0);
     else
-        return Value::fromInt32(r->replyStatus());
+        return Encode(r->replyStatus());
 }
 
-Value QQmlXMLHttpRequestCtor::method_get_statusText(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_get_statusText(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
@@ -1839,12 +1860,12 @@ Value QQmlXMLHttpRequestCtor::method_get_statusText(SimpleCallContext *ctx)
         V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
     if (r->errorFlag())
-        return engine->toString(QString());
+        return engine->toString(QString()).asReturnedValue();
     else
-        return engine->toString(r->replyStatusText());
+        return engine->toString(r->replyStatusText()).asReturnedValue();
 }
 
-Value QQmlXMLHttpRequestCtor::method_get_responseText(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_get_responseText(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
@@ -1855,12 +1876,12 @@ Value QQmlXMLHttpRequestCtor::method_get_responseText(SimpleCallContext *ctx)
 
     if (r->readyState() != QQmlXMLHttpRequest::Loading &&
         r->readyState() != QQmlXMLHttpRequest::Done)
-        return engine->toString(QString());
+        return engine->toString(QString()).asReturnedValue();
     else 
-        return engine->toString(r->responseBody());
+        return engine->toString(r->responseBody()).asReturnedValue();
 }
 
-Value QQmlXMLHttpRequestCtor::method_get_responseXML(SimpleCallContext *ctx)
+ReturnedValue QQmlXMLHttpRequestCtor::method_get_responseXML(SimpleCallContext *ctx)
 {
     QQmlXMLHttpRequestWrapper *w = ctx->thisObject.as<QQmlXMLHttpRequestWrapper>();
     if (!w)
@@ -1870,7 +1891,7 @@ Value QQmlXMLHttpRequestCtor::method_get_responseXML(SimpleCallContext *ctx)
     if (!r->receivedXml() ||
         (r->readyState() != QQmlXMLHttpRequest::Loading &&
          r->readyState() != QQmlXMLHttpRequest::Done)) {
-        return Value::nullValue();
+        return Encode::null();
     } else {
         return Document::load(ctx->engine->v8Engine, r->rawResponseBody());
     }
diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
index 867d63e551..59457df30c 100644
--- a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
+++ b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
@@ -103,7 +103,7 @@ QV4::QtObject::QtObject(ExecutionEngine *v4, QQmlEngine *qmlEngine)
     put(v4->newString("Asynchronous"), QV4::Value::fromInt32(0));
     put(v4->newString("Synchronous"), QV4::Value::fromInt32(1));
 
-    defineDefaultProperty(v4, QStringLiteral("include"), QV4Include::include);
+    defineDefaultProperty(v4, QStringLiteral("include"), QV4Include::method_include);
     defineDefaultProperty(v4, QStringLiteral("isQtObject"), method_isQtObject);
     defineDefaultProperty(v4, QStringLiteral("rgba"), method_rgba);
     defineDefaultProperty(v4, QStringLiteral("hsla"), method_hsla);
@@ -168,12 +168,12 @@ QV4::QtObject::QtObject(ExecutionEngine *v4, QQmlEngine *qmlEngine)
 \qmlmethod bool Qt::isQtObject(object)
 Returns true if \c object is a valid reference to a Qt or QML object, otherwise false.
 */
-Value QtObject::method_isQtObject(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_isQtObject(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount == 0)
-        return QV4::Value::fromBoolean(false);
+        return QV4::Encode(false);
 
-    return QV4::Value::fromBoolean(ctx->arguments[0].as<QV4::QObjectWrapper>() != 0);
+    return QV4::Encode(ctx->arguments[0].as<QV4::QObjectWrapper>() != 0);
 }
 
 /*!
@@ -182,7 +182,7 @@ Value QtObject::method_isQtObject(QV4::SimpleCallContext *ctx)
 Returns a color with the specified \c red, \c green, \c blue and \c alpha components.
 All components should be in the range 0-1 inclusive.
 */
-Value QtObject::method_rgba(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_rgba(QV4::SimpleCallContext *ctx)
 {
     int argCount = ctx->argumentCount;
     if (argCount < 3 || argCount > 4)
@@ -202,7 +202,7 @@ Value QtObject::method_rgba(QV4::SimpleCallContext *ctx)
     if (a < 0.0) a=0.0;
     if (a > 1.0) a=1.0;
 
-    return ctx->engine->v8Engine->fromVariant(QQml_colorProvider()->fromRgbF(r, g, b, a));
+    return ctx->engine->v8Engine->fromVariant(QQml_colorProvider()->fromRgbF(r, g, b, a)).asReturnedValue();
 }
 
 /*!
@@ -211,7 +211,7 @@ Value QtObject::method_rgba(QV4::SimpleCallContext *ctx)
 Returns a color with the specified \c hue, \c saturation, \c lightness and \c alpha components.
 All components should be in the range 0-1 inclusive.
 */
-Value QtObject::method_hsla(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_hsla(QV4::SimpleCallContext *ctx)
 {
     int argCount = ctx->argumentCount;
     if (argCount < 3 || argCount > 4)
@@ -231,7 +231,7 @@ Value QtObject::method_hsla(QV4::SimpleCallContext *ctx)
     if (a < 0.0) a=0.0;
     if (a > 1.0) a=1.0;
 
-    return ctx->engine->v8Engine->fromVariant(QQml_colorProvider()->fromHslF(h, s, l, a));
+    return ctx->engine->v8Engine->fromVariant(QQml_colorProvider()->fromHslF(h, s, l, a)).asReturnedValue();
 }
 
 /*!
@@ -242,7 +242,7 @@ may be either color values or string values.  If a string value is supplied it
 must be convertible to a color, as described for the \l{colorbasictypedocs}{color}
 basic type.
 */
-Value QtObject::method_colorEqual(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_colorEqual(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 2)
         V4THROW_ERROR("Qt.colorEqual(): Invalid arguments");
@@ -272,7 +272,7 @@ Value QtObject::method_colorEqual(QV4::SimpleCallContext *ctx)
     }
 
     bool equal = (lhs == rhs);
-    return QV4::Value::fromBoolean(equal);
+    return QV4::Encode(equal);
 }
 
 /*!
@@ -282,7 +282,7 @@ Returns a \c rect with the top-left corner at \c x, \c y and the specified \c wi
 
 The returned object has \c x, \c y, \c width and \c height attributes with the given values.
 */
-Value QtObject::method_rect(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_rect(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 4)
         V4THROW_ERROR("Qt.rect(): Invalid arguments");
@@ -292,14 +292,14 @@ Value QtObject::method_rect(QV4::SimpleCallContext *ctx)
     double w = ctx->arguments[2].toNumber();
     double h = ctx->arguments[3].toNumber();
 
-    return ctx->engine->v8Engine->fromVariant(QVariant::fromValue(QRectF(x, y, w, h)));
+    return ctx->engine->v8Engine->fromVariant(QVariant::fromValue(QRectF(x, y, w, h))).asReturnedValue();
 }
 
 /*!
 \qmlmethod point Qt::point(int x, int y)
 Returns a Point with the specified \c x and \c y coordinates.
 */
-Value QtObject::method_point(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_point(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 2)
         V4THROW_ERROR("Qt.point(): Invalid arguments");
@@ -307,14 +307,14 @@ Value QtObject::method_point(QV4::SimpleCallContext *ctx)
     double x = ctx->arguments[0].toNumber();
     double y = ctx->arguments[1].toNumber();
 
-    return ctx->engine->v8Engine->fromVariant(QVariant::fromValue(QPointF(x, y)));
+    return ctx->engine->v8Engine->fromVariant(QVariant::fromValue(QPointF(x, y))).asReturnedValue();
 }
 
 /*!
 \qmlmethod Qt::size(int width, int height)
 Returns a Size with the specified \c width and \c height.
 */
-Value QtObject::method_size(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_size(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 2)
         V4THROW_ERROR("Qt.size(): Invalid arguments");
@@ -322,7 +322,7 @@ Value QtObject::method_size(QV4::SimpleCallContext *ctx)
     double w = ctx->arguments[0].toNumber();
     double h = ctx->arguments[1].toNumber();
 
-    return ctx->engine->v8Engine->fromVariant(QVariant::fromValue(QSizeF(w, h)));
+    return ctx->engine->v8Engine->fromVariant(QVariant::fromValue(QSizeF(w, h))).asReturnedValue();
 }
 
 /*!
@@ -333,7 +333,7 @@ key-value pairs where valid keys are the \l{fontbasictypedocs}{font} type's
 subproperty names, and the values are valid values for each subproperty.
 Invalid keys will be ignored.
 */
-Value QtObject::method_font(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_font(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1 || !ctx->arguments[0].isObject())
         V4THROW_ERROR("Qt.font(): Invalid arguments");
@@ -343,7 +343,7 @@ Value QtObject::method_font(QV4::SimpleCallContext *ctx)
     QVariant v = QQml_valueTypeProvider()->createVariantFromJsObject(QMetaType::QFont, QQmlV4Handle(ctx->arguments[0]), v8engine, &ok);
     if (!ok)
         V4THROW_ERROR("Qt.font(): Invalid argument: no valid font subproperties specified");
-    return v8engine->fromVariant(v);
+    return v8engine->fromVariant(v).asReturnedValue();
 }
 
 
@@ -352,7 +352,7 @@ Value QtObject::method_font(QV4::SimpleCallContext *ctx)
 \qmlmethod Qt::vector2d(real x, real y)
 Returns a Vector2D with the specified \c x and \c y.
 */
-Value QtObject::method_vector2d(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_vector2d(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 2)
         V4THROW_ERROR("Qt.vector2d(): Invalid arguments");
@@ -363,14 +363,14 @@ Value QtObject::method_vector2d(QV4::SimpleCallContext *ctx)
 
     const void *params[] = { xy };
     QV8Engine *v8engine = ctx->engine->v8Engine;
-    return v8engine->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector2D, 1, params));
+    return v8engine->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector2D, 1, params)).asReturnedValue();
 }
 
 /*!
 \qmlmethod Qt::vector3d(real x, real y, real z)
 Returns a Vector3D with the specified \c x, \c y and \c z.
 */
-Value QtObject::method_vector3d(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_vector3d(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 3)
         V4THROW_ERROR("Qt.vector3d(): Invalid arguments");
@@ -382,14 +382,14 @@ Value QtObject::method_vector3d(QV4::SimpleCallContext *ctx)
 
     const void *params[] = { xyz };
     QV8Engine *v8engine = ctx->engine->v8Engine;
-    return v8engine->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector3D, 1, params));
+    return v8engine->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector3D, 1, params)).asReturnedValue();
 }
 
 /*!
 \qmlmethod Qt::vector4d(real x, real y, real z, real w)
 Returns a Vector4D with the specified \c x, \c y, \c z and \c w.
 */
-Value QtObject::method_vector4d(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_vector4d(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 4)
         V4THROW_ERROR("Qt.vector4d(): Invalid arguments");
@@ -402,14 +402,14 @@ Value QtObject::method_vector4d(QV4::SimpleCallContext *ctx)
 
     const void *params[] = { xyzw };
     QV8Engine *v8engine = ctx->engine->v8Engine;
-    return v8engine->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector4D, 1, params));
+    return v8engine->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector4D, 1, params)).asReturnedValue();
 }
 
 /*!
 \qmlmethod Qt::quaternion(real scalar, real x, real y, real z)
 Returns a Quaternion with the specified \c scalar, \c x, \c y, and \c z.
 */
-Value QtObject::method_quaternion(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_quaternion(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 4)
         V4THROW_ERROR("Qt.quaternion(): Invalid arguments");
@@ -422,7 +422,7 @@ Value QtObject::method_quaternion(QV4::SimpleCallContext *ctx)
 
     const void *params[] = { sxyz };
     QV8Engine *v8engine = ctx->engine->v8Engine;
-    return v8engine->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QQuaternion, 1, params));
+    return v8engine->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QQuaternion, 1, params)).asReturnedValue();
 }
 
 /*!
@@ -432,7 +432,7 @@ Alternatively, the function may be called with a single argument
 where that argument is a JavaScript array which contains the sixteen
 matrix values.
 */
-Value QtObject::method_matrix4x4(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_matrix4x4(QV4::SimpleCallContext *ctx)
 {
     QV8Engine *v8engine = ctx->engine->v8Engine;
 
@@ -441,7 +441,7 @@ Value QtObject::method_matrix4x4(QV4::SimpleCallContext *ctx)
         QVariant v = QQml_valueTypeProvider()->createVariantFromJsObject(QMetaType::QMatrix4x4, QQmlV4Handle(ctx->arguments[0]), v8engine, &ok);
         if (!ok)
             V4THROW_ERROR("Qt.matrix4x4(): Invalid argument: not a valid matrix4x4 values array");
-        return v8engine->fromVariant(v);
+        return v8engine->fromVariant(v).asReturnedValue();
     }
 
     if (ctx->argumentCount != 16)
@@ -466,7 +466,7 @@ Value QtObject::method_matrix4x4(QV4::SimpleCallContext *ctx)
     vals[15] = ctx->arguments[15].toNumber();
 
     const void *params[] = { vals };
-    return v8engine->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QMatrix4x4, 1, params));
+    return v8engine->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QMatrix4x4, 1, params)).asReturnedValue();
 }
 
 /*!
@@ -483,7 +483,7 @@ by factor and converts the color back to RGB.
 
 If \c factor is not supplied, returns a color 50% lighter than \c baseColor (factor 1.5).
 */
-Value QtObject::method_lighter(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_lighter(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1 && ctx->argumentCount != 2)
         V4THROW_ERROR("Qt.lighter(): Invalid arguments");
@@ -494,17 +494,17 @@ Value QtObject::method_lighter(QV4::SimpleCallContext *ctx)
         bool ok = false;
         v = QQmlStringConverters::colorFromString(v.toString(), &ok);
         if (!ok) {
-            return QV4::Value::nullValue();
+            return QV4::Encode::null();
         }
     } else if (v.userType() != QVariant::Color) {
-        return QV4::Value::nullValue();
+        return QV4::Encode::null();
     }
 
     qreal factor = 1.5;
     if (ctx->argumentCount == 2)
         factor = ctx->arguments[1].toNumber();
 
-    return v8engine->fromVariant(QQml_colorProvider()->lighter(v, factor));
+    return v8engine->fromVariant(QQml_colorProvider()->lighter(v, factor)).asReturnedValue();
 }
 
 /*!
@@ -522,7 +522,7 @@ by factor and converts the color back to RGB.
 
 If \c factor is not supplied, returns a color 50% darker than \c baseColor (factor 2.0).
 */
-Value QtObject::method_darker(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_darker(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1 && ctx->argumentCount != 2)
         V4THROW_ERROR("Qt.darker(): Invalid arguments");
@@ -533,17 +533,17 @@ Value QtObject::method_darker(QV4::SimpleCallContext *ctx)
         bool ok = false;
         v = QQmlStringConverters::colorFromString(v.toString(), &ok);
         if (!ok) {
-            return QV4::Value::nullValue();
+            return QV4::Encode::null();
         }
     } else if (v.userType() != QVariant::Color) {
-        return QV4::Value::nullValue();
+        return QV4::Encode::null();
     }
 
     qreal factor = 2.0;
     if (ctx->argumentCount == 2)
         factor = ctx->arguments[1].toNumber();
 
-    return v8engine->fromVariant(QQml_colorProvider()->darker(v, factor));
+    return v8engine->fromVariant(QQml_colorProvider()->darker(v, factor)).asReturnedValue();
 }
 
 /*!
@@ -570,7 +570,7 @@ Value QtObject::method_darker(QV4::SimpleCallContext *ctx)
 
     Tint is most useful when a subtle change is intended to be conveyed due to some event; you can then use tinting to more effectively tune the visible color.
 */
-Value QtObject::method_tint(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_tint(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 2)
         V4THROW_ERROR("Qt.tint(): Invalid arguments");
@@ -583,10 +583,10 @@ Value QtObject::method_tint(QV4::SimpleCallContext *ctx)
         bool ok = false;
         v1 = QQmlStringConverters::colorFromString(v1.toString(), &ok);
         if (!ok) {
-            return QV4::Value::nullValue();
+            return QV4::Encode::null();
         }
     } else if (v1.userType() != QVariant::Color) {
-        return QV4::Value::nullValue();
+        return QV4::Encode::null();
     }
 
     // tint color
@@ -595,13 +595,13 @@ Value QtObject::method_tint(QV4::SimpleCallContext *ctx)
         bool ok = false;
         v2 = QQmlStringConverters::colorFromString(v2.toString(), &ok);
         if (!ok) {
-            return QV4::Value::nullValue();
+            return QV4::Encode::null();
         }
     } else if (v2.userType() != QVariant::Color) {
-        return QV4::Value::nullValue();
+        return QV4::Encode::null();
     }
 
-    return v8engine->fromVariant(QQml_colorProvider()->tint(v1, v2));
+    return v8engine->fromVariant(QQml_colorProvider()->tint(v1, v2)).asReturnedValue();
 }
 
 /*!
@@ -620,7 +620,7 @@ If \a format is not specified, \a date is formatted using
 
 \sa Locale
 */
-Value QtObject::method_formatDate(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_formatDate(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 1 || ctx->argumentCount > 2)
         V4THROW_ERROR("Qt.formatDate(): Invalid arguments");
@@ -645,7 +645,7 @@ Value QtObject::method_formatDate(QV4::SimpleCallContext *ctx)
          formattedDate = date.toString(enumFormat);
     }
 
-    return v8engine->fromVariant(QVariant::fromValue(formattedDate));
+    return v8engine->fromVariant(QVariant::fromValue(formattedDate)).asReturnedValue();
 }
 
 /*!
@@ -663,7 +663,7 @@ If \a format is not specified, \a time is formatted using
 
 \sa Locale
 */
-Value QtObject::method_formatTime(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_formatTime(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 1 || ctx->argumentCount > 2)
         V4THROW_ERROR("Qt.formatTime(): Invalid arguments");
@@ -694,7 +694,7 @@ Value QtObject::method_formatTime(QV4::SimpleCallContext *ctx)
          formattedTime = time.toString(enumFormat);
     }
 
-    return v8engine->fromVariant(QVariant::fromValue(formattedTime));
+    return v8engine->fromVariant(QVariant::fromValue(formattedTime)).asReturnedValue();
 }
 
 /*!
@@ -787,7 +787,7 @@ with the \a format values below to produce the following results:
 
     \sa Locale
 */
-Value QtObject::method_formatDateTime(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_formatDateTime(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 1 || ctx->argumentCount > 2)
         V4THROW_ERROR("Qt.formatDateTime(): Invalid arguments");
@@ -812,29 +812,29 @@ Value QtObject::method_formatDateTime(QV4::SimpleCallContext *ctx)
          formattedDt = dt.toString(enumFormat);
     }
 
-    return v8engine->fromVariant(QVariant::fromValue(formattedDt));
+    return v8engine->fromVariant(QVariant::fromValue(formattedDt)).asReturnedValue();
 }
 
 /*!
 \qmlmethod bool Qt::openUrlExternally(url target)
 Attempts to open the specified \c target url in an external application, based on the user's desktop preferences. Returns true if it succeeds, and false otherwise.
 */
-Value QtObject::method_openUrlExternally(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_openUrlExternally(QV4::SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1)
-        return QV4::Value::fromBoolean(false);
+        return QV4::Encode(false);
 
     QV8Engine *v8engine = ctx->engine->v8Engine;
 
-    QUrl url(method_resolvedUrl(ctx).toQStringNoThrow());
-    return v8engine->fromVariant(QQml_guiProvider()->openUrlExternally(url));
+    QUrl url(Value::fromReturnedValue(method_resolvedUrl(ctx)).toQStringNoThrow());
+    return v8engine->fromVariant(QQml_guiProvider()->openUrlExternally(url)).asReturnedValue();
 }
 
 /*!
   \qmlmethod url Qt::resolvedUrl(url url)
   Returns \a url resolved relative to the URL of the caller.
 */
-Value QtObject::method_resolvedUrl(QV4::SimpleCallContext *ctx)
+ReturnedValue QtObject::method_resolvedUrl(QV4::SimpleCallContext *ctx)
 {
     QV8Engine *v8engine = ctx->engine->v8Engine;
 
@@ -845,67 +845,67 @@ Value QtObject::method_resolvedUrl(QV4::SimpleCallContext *ctx)
     if (p) {
         QQmlContextData *ctxt = v8engine->callingContext();
         if (ctxt)
-            return Value::fromString(ctx, ctxt->resolvedUrl(url).toString());
+            return Value::fromString(ctx, ctxt->resolvedUrl(url).toString()).asReturnedValue();
         else
-            return Value::fromString(ctx, url.toString());
+            return Value::fromString(ctx, url.toString()).asReturnedValue();
     }
 
-    return Value::fromString(ctx, e->baseUrl().resolved(url).toString());
+    return Value::fromString(ctx, e->baseUrl().resolved(url).toString()).asReturnedValue();
 }
 
 /*!
 \qmlmethod list<string> Qt::fontFamilies()
 Returns a list of the font families available to the application.
 */
-Value QtObject::method_fontFamilies(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_fontFamilies(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 0)
         V4THROW_ERROR("Qt.fontFamilies(): Invalid arguments");
 
     QV8Engine *v8engine = ctx->engine->v8Engine;
-    return v8engine->fromVariant(QVariant(QQml_guiProvider()->fontFamilies()));
+    return v8engine->fromVariant(QVariant(QQml_guiProvider()->fontFamilies())).asReturnedValue();
 }
 
 /*!
 \qmlmethod string Qt::md5(data)
 Returns a hex string of the md5 hash of \c data.
 */
-Value QtObject::method_md5(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_md5(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1)
         V4THROW_ERROR("Qt.md5(): Invalid arguments");
 
     QByteArray data = ctx->arguments[0].toQStringNoThrow().toUtf8();
     QByteArray result = QCryptographicHash::hash(data, QCryptographicHash::Md5);
-    return Value::fromString(ctx, QLatin1String(result.toHex()));
+    return Value::fromString(ctx, QLatin1String(result.toHex())).asReturnedValue();
 }
 
 /*!
 \qmlmethod string Qt::btoa(data)
 Binary to ASCII - this function returns a base64 encoding of \c data.
 */
-Value QtObject::method_btoa(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_btoa(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1)
         V4THROW_ERROR("Qt.btoa(): Invalid arguments");
 
     QByteArray data = ctx->arguments[0].toQStringNoThrow().toUtf8();
 
-    return Value::fromString(ctx, QLatin1String(data.toBase64()));
+    return Value::fromString(ctx, QLatin1String(data.toBase64())).asReturnedValue();
 }
 
 /*!
 \qmlmethod string Qt::atob(data)
 ASCII to binary - this function returns a base64 decoding of \c data.
 */
-Value QtObject::method_atob(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_atob(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1)
         V4THROW_ERROR("Qt.atob(): Invalid arguments");
 
     QByteArray data = ctx->arguments[0].toQStringNoThrow().toLatin1();
 
-    return Value::fromString(ctx, QString::fromUtf8(QByteArray::fromBase64(data)));
+    return Value::fromString(ctx, QString::fromUtf8(QByteArray::fromBase64(data))).asReturnedValue();
 }
 
 /*!
@@ -915,12 +915,12 @@ Within the \l {Prototyping with qmlscene}, this causes the launcher application
 to quit a C++ application when this method is called, connect the
 QQmlEngine::quit() signal to the QCoreApplication::quit() slot.
 */
-Value QtObject::method_quit(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_quit(SimpleCallContext *ctx)
 {
     QV8Engine *v8engine = ctx->engine->v8Engine;
 
     QQmlEnginePrivate::get(v8engine->engine())->sendQuit();
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
@@ -947,7 +947,7 @@ If this is the case, consider using \l{QtQml2::Qt::createComponent()}{Qt.createC
 
 See \l {Dynamic QML Object Creation from JavaScript} for more information on using this function.
 */
-Value QtObject::method_createQmlObject(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_createQmlObject(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 2 || ctx->argumentCount > 3)
         V4THROW_ERROR("Qt.createQmlObject(): Invalid arguments");
@@ -988,7 +988,7 @@ Value QtObject::method_createQmlObject(SimpleCallContext *ctx)
 
     QString qml = ctx->arguments[0].toQStringNoThrow();
     if (qml.isEmpty())
-        return QV4::Value::nullValue();
+        return QV4::Encode::null();
 
     QUrl url;
     if (ctx->argumentCount > 2)
@@ -1010,7 +1010,7 @@ Value QtObject::method_createQmlObject(SimpleCallContext *ctx)
 
     if (component.isError()) {
         ctx->throwError(Error::create(v8engine, component.errors()));
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
     }
 
     if (!component.isReady())
@@ -1034,12 +1034,12 @@ Value QtObject::method_createQmlObject(SimpleCallContext *ctx)
 
     if (component.isError()) {
         ctx->throwError(Error::create(v8engine, component.errors()));
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
     }
 
     Q_ASSERT(obj);
 
-    return QV4::QObjectWrapper::wrap(ctx->engine, obj);
+    return QV4::QObjectWrapper::wrap(ctx->engine, obj).asReturnedValue();
 }
 
 /*!
@@ -1073,7 +1073,7 @@ See \l {Dynamic QML Object Creation from JavaScript} for more information on usi
 To create a QML object from an arbitrary string of QML (instead of a file),
 use \l{QtQml2::Qt::createQmlObject()}{Qt.createQmlObject()}.
 */
-Value QtObject::method_createComponent(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_createComponent(SimpleCallContext *ctx)
 {
     const QString invalidArgs = QStringLiteral("Qt.createComponent(): Invalid arguments");
     const QString invalidParent = QStringLiteral("Qt.createComponent(): Invalid parent object");
@@ -1091,7 +1091,7 @@ Value QtObject::method_createComponent(SimpleCallContext *ctx)
 
     QString arg = ctx->arguments[0].toQStringNoThrow();
     if (arg.isEmpty())
-        return QV4::Value::nullValue();
+        return QV4::Encode::null();
 
     QQmlComponent::CompilationMode compileMode = QQmlComponent::PreferSynchronous;
     QObject *parentArg = 0;
@@ -1133,7 +1133,7 @@ Value QtObject::method_createComponent(SimpleCallContext *ctx)
     QQmlData::get(c, true)->explicitIndestructibleSet = false;
     QQmlData::get(c)->indestructible = false;
 
-    return QV4::QObjectWrapper::wrap(ctx->engine, c);
+    return QV4::QObjectWrapper::wrap(ctx->engine, c).asReturnedValue();
 }
 
 /*!
@@ -1156,7 +1156,7 @@ Value QtObject::method_createComponent(SimpleCallContext *ctx)
 
     \sa QtQuick2::Locale
 */
-Value QtObject::method_locale(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_locale(SimpleCallContext *ctx)
 {
     QString code;
     if (ctx->argumentCount > 1)
@@ -1168,7 +1168,7 @@ Value QtObject::method_locale(SimpleCallContext *ctx)
     if (ctx->argumentCount == 1)
         code = ctx->arguments[0].toQStringNoThrow();
 
-    return QQmlLocale::locale(v8engine, code);
+    return QQmlLocale::locale(v8engine, code).asReturnedValue();
 }
 
 namespace {
@@ -1250,7 +1250,7 @@ DEFINE_MANAGED_VTABLE(BindingFunction);
 
     \since QtQuick 2.0
 */
-Value QtObject::method_binding(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_binding(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1)
         V4THROW_ERROR("binding() requires 1 argument");
@@ -1258,11 +1258,11 @@ Value QtObject::method_binding(SimpleCallContext *ctx)
     if (!f)
         V4THROW_TYPE("binding(): argument (binding expression) must be a function");
 
-    return QV4::Value::fromObject(new (ctx->engine->memoryManager) BindingFunction(f));
+    return QV4::Value::fromObject(new (ctx->engine->memoryManager) BindingFunction(f)).asReturnedValue();
 }
 
 
-Value QtObject::method_get_platform(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_get_platform(SimpleCallContext *ctx)
 {
     // ### inefficient. Should be just a value based getter
     Object *o = ctx->thisObject.asObject();
@@ -1276,10 +1276,10 @@ Value QtObject::method_get_platform(SimpleCallContext *ctx)
         // Only allocate a platform object once
         qt->m_platform = new QQmlPlatform(ctx->engine->v8Engine->publicEngine());
 
-    return QV4::QObjectWrapper::wrap(ctx->engine, qt->m_platform);
+    return QV4::QObjectWrapper::wrap(ctx->engine, qt->m_platform).asReturnedValue();
 }
 
-Value QtObject::method_get_application(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_get_application(SimpleCallContext *ctx)
 {
     // ### inefficient. Should be just a value based getter
     Object *o = ctx->thisObject.asObject();
@@ -1293,15 +1293,15 @@ Value QtObject::method_get_application(SimpleCallContext *ctx)
         // Only allocate an application object once
         qt->m_application = QQml_guiProvider()->application(ctx->engine->v8Engine->publicEngine());
 
-    return QV4::QObjectWrapper::wrap(ctx->engine, qt->m_application);
+    return QV4::QObjectWrapper::wrap(ctx->engine, qt->m_application).asReturnedValue();
 }
 
 #ifndef QT_NO_IM
-Value QtObject::method_get_inputMethod(SimpleCallContext *ctx)
+ReturnedValue QtObject::method_get_inputMethod(SimpleCallContext *ctx)
 {
     QObject *o = QQml_guiProvider()->inputMethod();
     QQmlEngine::setObjectOwnership(o, QQmlEngine::CppOwnership);
-    return QV4::QObjectWrapper::wrap(ctx->engine, o);
+    return QV4::QObjectWrapper::wrap(ctx->engine, o).asReturnedValue();
 }
 #endif
 
@@ -1358,8 +1358,8 @@ static QString jsStack(QV4::ExecutionEngine *engine) {
     return stack;
 }
 
-static QV4::Value writeToConsole(ConsoleLogTypes logType, SimpleCallContext *ctx,
-                                bool printStack = false)
+static QV4::ReturnedValue writeToConsole(ConsoleLogTypes logType, SimpleCallContext *ctx,
+                                         bool printStack = false)
 {
     QString result;
     QV4::ExecutionEngine *v4 = ctx->engine;
@@ -1396,15 +1396,15 @@ static QV4::Value writeToConsole(ConsoleLogTypes logType, SimpleCallContext *ctx
         break;
     }
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-QV4::Value ConsoleObject::method_error(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_error(SimpleCallContext *ctx)
 {
     return writeToConsole(Error, ctx);
 }
 
-QV4::Value ConsoleObject::method_log(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_log(SimpleCallContext *ctx)
 {
     //console.log
     //console.debug
@@ -1413,7 +1413,7 @@ QV4::Value ConsoleObject::method_log(SimpleCallContext *ctx)
     return writeToConsole(Log, ctx);
 }
 
-QV4::Value ConsoleObject::method_profile(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_profile(SimpleCallContext *ctx)
 {
     //DeclarativeDebugTrace cannot handle nested profiling
     //although v8 can handle several profiling at once,
@@ -1431,10 +1431,10 @@ QV4::Value ConsoleObject::method_profile(SimpleCallContext *ctx)
         logger.warning("Profiling is already in progress. First, end current profiling session.");
     }
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-QV4::Value ConsoleObject::method_profileEnd(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_profileEnd(SimpleCallContext *ctx)
 {
     //DeclarativeDebugTrace cannot handle nested profiling
     //although v8 can handle several profiling at once,
@@ -1457,10 +1457,10 @@ QV4::Value ConsoleObject::method_profileEnd(SimpleCallContext *ctx)
         logger.warning("Profiling was not started.");
     }
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-QV4::Value ConsoleObject::method_time(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_time(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1)
         V4THROW_ERROR("console.time(): Invalid arguments");
@@ -1469,10 +1469,10 @@ QV4::Value ConsoleObject::method_time(SimpleCallContext *ctx)
 
     QString name = ctx->arguments[0].toQStringNoThrow();
     v8engine->startTimer(name);
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-QV4::Value ConsoleObject::method_timeEnd(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_timeEnd(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 1)
         V4THROW_ERROR("console.time(): Invalid arguments");
@@ -1485,10 +1485,10 @@ QV4::Value ConsoleObject::method_timeEnd(SimpleCallContext *ctx)
     if (wasRunning) {
         qDebug("%s: %llims", qPrintable(name), elapsed);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-QV4::Value ConsoleObject::method_count(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_count(SimpleCallContext *ctx)
 {
     // first argument: name to print. Ignore any additional arguments
     QString name;
@@ -1508,10 +1508,10 @@ QV4::Value ConsoleObject::method_count(SimpleCallContext *ctx)
     QMessageLogger(qPrintable(scriptName), frame.line,
                    qPrintable(frame.function)).debug("%s", qPrintable(message));
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-QV4::Value ConsoleObject::method_trace(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_trace(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount != 0)
         V4THROW_ERROR("console.trace(): Invalid arguments");
@@ -1524,15 +1524,15 @@ QV4::Value ConsoleObject::method_trace(SimpleCallContext *ctx)
     QMessageLogger logger(frame.source.toUtf8().constData(), frame.line, frame.function.toUtf8().constData());
 
     logger.debug("%s", qPrintable(stack));
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-QV4::Value ConsoleObject::method_warn(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_warn(SimpleCallContext *ctx)
 {
     return writeToConsole(Warn, ctx);
 }
 
-QV4::Value ConsoleObject::method_assert(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_assert(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount == 0)
         V4THROW_ERROR("console.assert(): Missing argument");
@@ -1555,17 +1555,17 @@ QV4::Value ConsoleObject::method_assert(SimpleCallContext *ctx)
         logger.critical("%s\n%s", qPrintable(message), qPrintable(stack));
 
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-QV4::Value ConsoleObject::method_exception(SimpleCallContext *ctx)
+QV4::ReturnedValue ConsoleObject::method_exception(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount == 0)
         V4THROW_ERROR("console.exception(): Missing argument");
 
     writeToConsole(Error, ctx, true);
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 
@@ -1594,7 +1594,7 @@ void QV4::GlobalExtensions::init(QQmlEngine *qmlEngine, Object *globalObject)
 
     // string prototype extension
     QV4::Object *stringProto = v4->stringClass->prototype;
-    stringProto->defineDefaultProperty(v4, QStringLiteral("arg"), string_arg);
+    stringProto->defineDefaultProperty(v4, QStringLiteral("arg"), method_string_arg);
 }
 
 
@@ -1616,7 +1616,7 @@ void QV4::GlobalExtensions::init(QQmlEngine *qmlEngine, Object *globalObject)
 
     \sa {Internationalization and Localization with Qt Quick}
 */
-Value GlobalExtensions::method_qsTranslate(SimpleCallContext *ctx)
+ReturnedValue GlobalExtensions::method_qsTranslate(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 2)
         V4THROW_ERROR("qsTranslate() requires at least two arguments");
@@ -1647,7 +1647,7 @@ Value GlobalExtensions::method_qsTranslate(SimpleCallContext *ctx)
                                                  comment.toUtf8().constData(),
                                                  n);
 
-    return Value::fromString(ctx, result);
+    return Value::fromString(ctx, result).asReturnedValue();
 }
 
 /*!
@@ -1672,11 +1672,11 @@ Value GlobalExtensions::method_qsTranslate(SimpleCallContext *ctx)
 
     \sa {Internationalization and Localization with Qt Quick}
 */
-Value GlobalExtensions::method_qsTranslateNoOp(SimpleCallContext *ctx)
+ReturnedValue GlobalExtensions::method_qsTranslateNoOp(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 2)
-        return QV4::Value::undefinedValue();
-    return ctx->arguments[1];
+        return QV4::Encode::undefined();
+    return ctx->arguments[1].asReturnedValue();
 }
 
 /*!
@@ -1696,7 +1696,7 @@ Value GlobalExtensions::method_qsTranslateNoOp(SimpleCallContext *ctx)
 
     \sa {Internationalization and Localization with Qt Quick}
 */
-Value GlobalExtensions::method_qsTr(SimpleCallContext *ctx)
+ReturnedValue GlobalExtensions::method_qsTr(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 1)
         V4THROW_ERROR("qsTr() requires at least one argument");
@@ -1725,7 +1725,7 @@ Value GlobalExtensions::method_qsTr(SimpleCallContext *ctx)
     QString result = QCoreApplication::translate(context.toUtf8().constData(), text.toUtf8().constData(),
                                                  comment.toUtf8().constData(), n);
 
-    return Value::fromString(ctx, result);
+    return Value::fromString(ctx, result).asReturnedValue();
 }
 
 /*!
@@ -1750,11 +1750,11 @@ Value GlobalExtensions::method_qsTr(SimpleCallContext *ctx)
 
     \sa {Internationalization and Localization with Qt Quick}
 */
-Value GlobalExtensions::method_qsTrNoOp(SimpleCallContext *ctx)
+ReturnedValue GlobalExtensions::method_qsTrNoOp(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 1)
-        return QV4::Value::undefinedValue();
-    return ctx->arguments[0];
+        return QV4::Encode::undefined();
+    return ctx->arguments[0].asReturnedValue();
 }
 
 /*!
@@ -1787,7 +1787,7 @@ Value GlobalExtensions::method_qsTrNoOp(SimpleCallContext *ctx)
 
     \sa QT_TRID_NOOP, {Internationalization and Localization with Qt Quick}
 */
-Value GlobalExtensions::method_qsTrId(SimpleCallContext *ctx)
+ReturnedValue GlobalExtensions::method_qsTrId(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 1)
         V4THROW_ERROR("qsTrId() requires at least one argument");
@@ -1800,7 +1800,7 @@ Value GlobalExtensions::method_qsTrId(SimpleCallContext *ctx)
     if (ctx->argumentCount > 1)
         n = ctx->arguments[1].toInt32();
 
-    return Value::fromString(ctx, qtTrId(ctx->arguments[0].toQStringNoThrow().toUtf8().constData(), n));
+    return Value::fromString(ctx, qtTrId(ctx->arguments[0].toQStringNoThrow().toUtf8().constData(), n)).asReturnedValue();
 }
 
 /*!
@@ -1819,25 +1819,25 @@ Value GlobalExtensions::method_qsTrId(SimpleCallContext *ctx)
 
     \sa qsTrId(), {Internationalization and Localization with Qt Quick}
 */
-Value GlobalExtensions::method_qsTrIdNoOp(SimpleCallContext *ctx)
+ReturnedValue GlobalExtensions::method_qsTrIdNoOp(SimpleCallContext *ctx)
 {
     if (ctx->argumentCount < 1)
-        return QV4::Value::undefinedValue();
-    return ctx->arguments[0];
+        return QV4::Encode::undefined();
+    return ctx->arguments[0].asReturnedValue();
 }
 #endif // QT_NO_TRANSLATION
 
 
-QV4::Value GlobalExtensions::method_gc(SimpleCallContext *ctx)
+QV4::ReturnedValue GlobalExtensions::method_gc(SimpleCallContext *ctx)
 {
     ctx->engine->memoryManager->runGC();
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 
 
-Value GlobalExtensions::string_arg(SimpleCallContext *ctx)
+ReturnedValue GlobalExtensions::method_string_arg(SimpleCallContext *ctx)
 {
     QString value = ctx->thisObject.toQStringNoThrow();
     if (ctx->argumentCount != 1)
@@ -1845,13 +1845,13 @@ Value GlobalExtensions::string_arg(SimpleCallContext *ctx)
 
     QV4::Value arg = ctx->arguments[0];
     if (arg.isInteger())
-        return Value::fromString(ctx, value.arg(arg.integerValue()));
+        return Value::fromString(ctx, value.arg(arg.integerValue())).asReturnedValue();
     else if (arg.isDouble())
-        return Value::fromString(ctx, value.arg(arg.doubleValue()));
+        return Value::fromString(ctx, value.arg(arg.doubleValue())).asReturnedValue();
     else if (arg.isBoolean())
-        return Value::fromString(ctx, value.arg(arg.booleanValue()));
+        return Value::fromString(ctx, value.arg(arg.booleanValue())).asReturnedValue();
 
-    return Value::fromString(ctx, value.arg(arg.toQStringNoThrow()));
+    return Value::fromString(ctx, value.arg(arg.toQStringNoThrow())).asReturnedValue();
 }
 
 
diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions_p.h b/src/qml/qml/v8/qqmlbuiltinfunctions_p.h
index d03605f48a..070796f03c 100644
--- a/src/qml/qml/v8/qqmlbuiltinfunctions_p.h
+++ b/src/qml/qml/v8/qqmlbuiltinfunctions_p.h
@@ -68,41 +68,41 @@ struct QtObject : Object
     Q_MANAGED
     QtObject(ExecutionEngine *v4, QQmlEngine *qmlEngine);
 
-    static Value method_isQtObject(SimpleCallContext *ctx);
-    static Value method_rgba(SimpleCallContext *ctx);
-    static Value method_hsla(SimpleCallContext *ctx);
-    static Value method_colorEqual(SimpleCallContext *ctx);
-    static Value method_font(SimpleCallContext *ctx);
-    static Value method_rect(SimpleCallContext *ctx);
-    static Value method_point(SimpleCallContext *ctx);
-    static Value method_size(SimpleCallContext *ctx);
-    static Value method_vector2d(SimpleCallContext *ctx);
-    static Value method_vector3d(SimpleCallContext *ctx);
-    static Value method_vector4d(SimpleCallContext *ctx);
-    static Value method_quaternion(SimpleCallContext *ctx);
-    static Value method_matrix4x4(SimpleCallContext *ctx);
-    static Value method_lighter(SimpleCallContext *ctx);
-    static Value method_darker(SimpleCallContext *ctx);
-    static Value method_tint(SimpleCallContext *ctx);
-    static Value method_formatDate(SimpleCallContext *ctx);
-    static Value method_formatTime(SimpleCallContext *ctx);
-    static Value method_formatDateTime(SimpleCallContext *ctx);
-    static Value method_openUrlExternally(SimpleCallContext *ctx);
-    static Value method_fontFamilies(SimpleCallContext *ctx);
-    static Value method_md5(SimpleCallContext *ctx);
-    static Value method_btoa(SimpleCallContext *ctx);
-    static Value method_atob(SimpleCallContext *ctx);
-    static Value method_quit(SimpleCallContext *ctx);
-    static Value method_resolvedUrl(SimpleCallContext *ctx);
-    static Value method_createQmlObject(SimpleCallContext *ctx);
-    static Value method_createComponent(SimpleCallContext *ctx);
-    static Value method_locale(SimpleCallContext *ctx);
-    static Value method_binding(SimpleCallContext *ctx);
-
-    static Value method_get_platform(SimpleCallContext *ctx);
-    static Value method_get_application(SimpleCallContext *ctx);
+    static ReturnedValue method_isQtObject(SimpleCallContext *ctx);
+    static ReturnedValue method_rgba(SimpleCallContext *ctx);
+    static ReturnedValue method_hsla(SimpleCallContext *ctx);
+    static ReturnedValue method_colorEqual(SimpleCallContext *ctx);
+    static ReturnedValue method_font(SimpleCallContext *ctx);
+    static ReturnedValue method_rect(SimpleCallContext *ctx);
+    static ReturnedValue method_point(SimpleCallContext *ctx);
+    static ReturnedValue method_size(SimpleCallContext *ctx);
+    static ReturnedValue method_vector2d(SimpleCallContext *ctx);
+    static ReturnedValue method_vector3d(SimpleCallContext *ctx);
+    static ReturnedValue method_vector4d(SimpleCallContext *ctx);
+    static ReturnedValue method_quaternion(SimpleCallContext *ctx);
+    static ReturnedValue method_matrix4x4(SimpleCallContext *ctx);
+    static ReturnedValue method_lighter(SimpleCallContext *ctx);
+    static ReturnedValue method_darker(SimpleCallContext *ctx);
+    static ReturnedValue method_tint(SimpleCallContext *ctx);
+    static ReturnedValue method_formatDate(SimpleCallContext *ctx);
+    static ReturnedValue method_formatTime(SimpleCallContext *ctx);
+    static ReturnedValue method_formatDateTime(SimpleCallContext *ctx);
+    static ReturnedValue method_openUrlExternally(SimpleCallContext *ctx);
+    static ReturnedValue method_fontFamilies(SimpleCallContext *ctx);
+    static ReturnedValue method_md5(SimpleCallContext *ctx);
+    static ReturnedValue method_btoa(SimpleCallContext *ctx);
+    static ReturnedValue method_atob(SimpleCallContext *ctx);
+    static ReturnedValue method_quit(SimpleCallContext *ctx);
+    static ReturnedValue method_resolvedUrl(SimpleCallContext *ctx);
+    static ReturnedValue method_createQmlObject(SimpleCallContext *ctx);
+    static ReturnedValue method_createComponent(SimpleCallContext *ctx);
+    static ReturnedValue method_locale(SimpleCallContext *ctx);
+    static ReturnedValue method_binding(SimpleCallContext *ctx);
+
+    static ReturnedValue method_get_platform(SimpleCallContext *ctx);
+    static ReturnedValue method_get_application(SimpleCallContext *ctx);
 #ifndef QT_NO_IM
-    static Value method_get_inputMethod(SimpleCallContext *ctx);
+    static ReturnedValue method_get_inputMethod(SimpleCallContext *ctx);
 #endif
 
     QObject *m_platform;
@@ -113,17 +113,17 @@ struct ConsoleObject : Object
 {
     ConsoleObject(ExecutionEngine *v4);
 
-    static Value method_error(SimpleCallContext *ctx);
-    static Value method_log(SimpleCallContext *ctx);
-    static Value method_profile(SimpleCallContext *ctx);
-    static Value method_profileEnd(SimpleCallContext *ctx);
-    static Value method_time(SimpleCallContext *ctx);
-    static Value method_timeEnd(SimpleCallContext *ctx);
-    static Value method_count(SimpleCallContext *ctx);
-    static Value method_trace(SimpleCallContext *ctx);
-    static Value method_warn(SimpleCallContext *ctx);
-    static Value method_assert(SimpleCallContext *ctx);
-    static Value method_exception(SimpleCallContext *ctx);
+    static ReturnedValue method_error(SimpleCallContext *ctx);
+    static ReturnedValue method_log(SimpleCallContext *ctx);
+    static ReturnedValue method_profile(SimpleCallContext *ctx);
+    static ReturnedValue method_profileEnd(SimpleCallContext *ctx);
+    static ReturnedValue method_time(SimpleCallContext *ctx);
+    static ReturnedValue method_timeEnd(SimpleCallContext *ctx);
+    static ReturnedValue method_count(SimpleCallContext *ctx);
+    static ReturnedValue method_trace(SimpleCallContext *ctx);
+    static ReturnedValue method_warn(SimpleCallContext *ctx);
+    static ReturnedValue method_assert(SimpleCallContext *ctx);
+    static ReturnedValue method_exception(SimpleCallContext *ctx);
 
 };
 
@@ -131,17 +131,17 @@ struct GlobalExtensions {
     static void init(QQmlEngine *qmlEngine, Object *globalObject);
 
 #ifndef QT_NO_TRANSLATION
-    static Value method_qsTranslate(SimpleCallContext *ctx);
-    static Value method_qsTranslateNoOp(SimpleCallContext *ctx);
-    static Value method_qsTr(SimpleCallContext *ctx);
-    static Value method_qsTrNoOp(SimpleCallContext *ctx);
-    static Value method_qsTrId(SimpleCallContext *ctx);
-    static Value method_qsTrIdNoOp(SimpleCallContext *ctx);
+    static ReturnedValue method_qsTranslate(SimpleCallContext *ctx);
+    static ReturnedValue method_qsTranslateNoOp(SimpleCallContext *ctx);
+    static ReturnedValue method_qsTr(SimpleCallContext *ctx);
+    static ReturnedValue method_qsTrNoOp(SimpleCallContext *ctx);
+    static ReturnedValue method_qsTrId(SimpleCallContext *ctx);
+    static ReturnedValue method_qsTrIdNoOp(SimpleCallContext *ctx);
 #endif
-    static Value method_gc(SimpleCallContext *ctx);
+    static ReturnedValue method_gc(SimpleCallContext *ctx);
 
     // on String:prototype
-    static Value string_arg(SimpleCallContext *ctx);
+    static ReturnedValue method_string_arg(SimpleCallContext *ctx);
 
 };
 
diff --git a/src/qml/types/qqmldelegatemodel.cpp b/src/qml/types/qqmldelegatemodel.cpp
index 3e7b23161c..163407c809 100644
--- a/src/qml/types/qqmldelegatemodel.cpp
+++ b/src/qml/types/qqmldelegatemodel.cpp
@@ -1690,18 +1690,18 @@ int QQmlDelegateModelItemMetaType::parseGroups(const QV4::Value &groups) const
     return groupFlags;
 }
 
-QV4::Value QQmlDelegateModelItem::get_model(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlDelegateModelItem::get_model(QV4::SimpleCallContext *ctx)
 {
     QQmlDelegateModelItemObject *o = ctx->thisObject.as<QQmlDelegateModelItemObject>();
     if (!o)
         ctx->throwTypeError(QStringLiteral("Not a valid VisualData object"));
     if (!o->item->metaType->model)
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
-    return o->item->get();
+    return o->item->get().asReturnedValue();
 }
 
-QV4::Value QQmlDelegateModelItem::get_groups(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlDelegateModelItem::get_groups(QV4::SimpleCallContext *ctx)
 {
     QQmlDelegateModelItemObject *o = ctx->thisObject.as<QQmlDelegateModelItemObject>();
     if (!o)
@@ -1713,10 +1713,10 @@ QV4::Value QQmlDelegateModelItem::get_groups(QV4::SimpleCallContext *ctx)
             groups.append(o->item->metaType->groupNames.at(i - 1));
     }
 
-    return ctx->engine->v8Engine->fromVariant(groups);
+    return ctx->engine->v8Engine->fromVariant(groups).asReturnedValue();
 }
 
-QV4::Value QQmlDelegateModelItem::set_groups(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQmlDelegateModelItem::set_groups(QV4::SimpleCallContext *ctx)
 {
     QQmlDelegateModelItemObject *o = ctx->thisObject.as<QQmlDelegateModelItemObject>();
     if (!o)
@@ -1725,14 +1725,14 @@ QV4::Value QQmlDelegateModelItem::set_groups(QV4::SimpleCallContext *ctx)
         ctx->throwTypeError();
 
     if (!o->item->metaType->model)
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
     QQmlDelegateModelPrivate *model = QQmlDelegateModelPrivate::get(o->item->metaType->model);
 
     const int groupFlags = model->m_cacheMetaType->parseGroups(ctx->arguments[0]);
     const int cacheIndex = model->m_cache.indexOf(o->item);
     Compositor::iterator it = model->m_compositor.find(Compositor::Cache, cacheIndex);
     model->setGroups(it, 1, Compositor::Cache, groupFlags);
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 QV4::Value QQmlDelegateModelItem::get_member(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &)
@@ -3106,25 +3106,25 @@ struct QQmlDelegateModelGroupChange : QV4::Object
         vtbl = &static_vtbl;
     }
 
-    static QV4::Value method_get_index(QV4::SimpleCallContext *ctx) {
+    static QV4::ReturnedValue method_get_index(QV4::SimpleCallContext *ctx) {
         QQmlDelegateModelGroupChange *that = ctx->thisObject.as<QQmlDelegateModelGroupChange>();
         if (!that)
             ctx->throwTypeError();
-        return QV4::Value::fromInt32(that->change.index);
+        return QV4::Encode(that->change.index);
     }
-    static QV4::Value method_get_count(QV4::SimpleCallContext *ctx) {
+    static QV4::ReturnedValue method_get_count(QV4::SimpleCallContext *ctx) {
         QQmlDelegateModelGroupChange *that = ctx->thisObject.as<QQmlDelegateModelGroupChange>();
         if (!that)
             ctx->throwTypeError();
-        return QV4::Value::fromInt32(that->change.count);
+        return QV4::Encode(that->change.count);
     }
-    static QV4::Value method_get_moveId(QV4::SimpleCallContext *ctx) {
+    static QV4::ReturnedValue method_get_moveId(QV4::SimpleCallContext *ctx) {
         QQmlDelegateModelGroupChange *that = ctx->thisObject.as<QQmlDelegateModelGroupChange>();
         if (!that)
             ctx->throwTypeError();
         if (that->change.moveId < 0)
-            return QV4::Value::undefinedValue();
-        return QV4::Value::fromInt32(that->change.moveId);
+            return QV4::Encode::undefined();
+        return QV4::Encode(that->change.moveId);
     }
 
     QQmlChangeSet::Change change;
@@ -3180,7 +3180,7 @@ public:
         if (name == m->engine()->id_length) {
             if (hasProperty)
                 *hasProperty = true;
-            return QV4::Value::fromInt32(array->count()).asReturnedValue();
+            return QV4::Encode(array->count());
         }
 
         return Object::get(m, name, hasProperty);
diff --git a/src/qml/types/qqmldelegatemodel_p_p.h b/src/qml/types/qqmldelegatemodel_p_p.h
index 10c5a0f3c4..9b1b64b8db 100644
--- a/src/qml/types/qqmldelegatemodel_p_p.h
+++ b/src/qml/types/qqmldelegatemodel_p_p.h
@@ -133,9 +133,9 @@ public:
     virtual void setValue(const QString &role, const QVariant &value) { Q_UNUSED(role); Q_UNUSED(value); }
     virtual bool resolveIndex(const QQmlAdaptorModel &, int) { return false; }
 
-    static QV4::Value get_model(QV4::SimpleCallContext *ctx);
-    static QV4::Value get_groups(QV4::SimpleCallContext *ctx);
-    static QV4::Value set_groups(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue get_model(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue get_groups(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue set_groups(QV4::SimpleCallContext *ctx);
     static QV4::Value get_member(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &);
     static QV4::Value set_member(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &arg);
     static QV4::Value get_index(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &arg);
diff --git a/src/qml/types/qquickworkerscript.cpp b/src/qml/types/qquickworkerscript.cpp
index 6a7374c09e..07acf13314 100644
--- a/src/qml/types/qquickworkerscript.cpp
+++ b/src/qml/types/qquickworkerscript.cpp
@@ -181,7 +181,7 @@ public:
 
     int m_nextId;
 
-    static QV4::Value sendMessage(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_sendMessage(QV4::SimpleCallContext *ctx);
 
 signals:
     void stopThread();
@@ -234,7 +234,7 @@ void QQuickWorkerScriptEnginePrivate::WorkerEngine::init()
     QV4::FunctionObject *createsendconstructor = createsendscript.run().asFunctionObject();
 
     QV4::Value function = QV4::Value::fromObject(m_v4Engine->newBuiltinFunction(m_v4Engine->rootContext, m_v4Engine->newString(QStringLiteral("sendMessage")),
-                                                          QQuickWorkerScriptEnginePrivate::sendMessage));
+                                                          QQuickWorkerScriptEnginePrivate::method_sendMessage));
     QV4::ScopedCallData callData(scope, 1);
     callData->args[0] = function;
     callData->thisObject = global();
@@ -278,7 +278,7 @@ QQuickWorkerScriptEnginePrivate::QQuickWorkerScriptEnginePrivate(QQmlEngine *eng
 {
 }
 
-QV4::Value QQuickWorkerScriptEnginePrivate::sendMessage(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickWorkerScriptEnginePrivate::method_sendMessage(QV4::SimpleCallContext *ctx)
 {
     WorkerEngine *engine = (WorkerEngine*)ctx->engine->v8Engine;
 
@@ -289,12 +289,12 @@ QV4::Value QQuickWorkerScriptEnginePrivate::sendMessage(QV4::SimpleCallContext *
     QMutexLocker locker(&engine->p->m_lock);
     WorkerScript *script = engine->p->workers.value(id);
     if (!script)
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
     if (script->owner)
         QCoreApplication::postEvent(script->owner, new WorkerDataEvent(0, data));
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 // Requires handle scope and context scope
diff --git a/src/qml/util/qqmladaptormodel.cpp b/src/qml/util/qqmladaptormodel.cpp
index ffd9de0e16..b64a393bd3 100644
--- a/src/qml/util/qqmladaptormodel.cpp
+++ b/src/qml/util/qqmladaptormodel.cpp
@@ -63,13 +63,13 @@ public:
 
 V8_DEFINE_EXTENSION(QQmlAdaptorModelEngineData, engineData)
 
-static QV4::Value get_index(QV4::SimpleCallContext *ctx)
+static QV4::ReturnedValue get_index(QV4::SimpleCallContext *ctx)
 {
     QQmlDelegateModelItemObject *o = ctx->thisObject.as<QQmlDelegateModelItemObject>();
     if (!o)
         ctx->throwTypeError(QStringLiteral("Not a valid VisualData object"));
 
-    return QV4::Value::fromInt32(o->item->index);
+    return QV4::Encode(o->item->index);
 }
 
 template <typename T, typename M> static void setModelDataType(QMetaObjectBuilder *builder, M *metaType)
@@ -194,7 +194,7 @@ public:
         dataType->watchedRoles += newRoles;
     }
 
-    static QV4::Value get_hasModelChildren(QV4::SimpleCallContext *ctx)
+    static QV4::ReturnedValue get_hasModelChildren(QV4::SimpleCallContext *ctx)
     {
         QQmlDelegateModelItemObject *o = ctx->thisObject.as<QQmlDelegateModelItemObject>();
         if (!o)
@@ -203,9 +203,9 @@ public:
         const QQmlAdaptorModel *const model = static_cast<QQmlDMCachedModelData *>(o->item)->type->model;
         if (o->item->index >= 0 && *model) {
             const QAbstractItemModel * const aim = model->aim();
-            return QV4::Value::fromBoolean(aim->hasChildren(aim->index(o->item->index, 0, model->rootIndex)));
+            return QV4::Encode(aim->hasChildren(aim->index(o->item->index, 0, model->rootIndex)));
         } else {
-            return QV4::Value::fromBoolean(false);
+            return QV4::Encode(false);
         }
     }
 
@@ -578,16 +578,16 @@ public:
         }
     }
 
-    static QV4::Value get_modelData(QV4::SimpleCallContext *ctx)
+    static QV4::ReturnedValue get_modelData(QV4::SimpleCallContext *ctx)
     {
         QQmlDelegateModelItemObject *o = ctx->thisObject.as<QQmlDelegateModelItemObject>();
         if (!o)
             ctx->throwTypeError(QStringLiteral("Not a valid VisualData object"));
 
-        return ctx->engine->v8Engine->fromVariant(static_cast<QQmlDMListAccessorData *>(o->item)->cachedData);
+        return ctx->engine->v8Engine->fromVariant(static_cast<QQmlDMListAccessorData *>(o->item)->cachedData).asReturnedValue();
     }
 
-    static QV4::Value set_modelData(QV4::SimpleCallContext *ctx)
+    static QV4::ReturnedValue set_modelData(QV4::SimpleCallContext *ctx)
     {
         QQmlDelegateModelItemObject *o = ctx->thisObject.as<QQmlDelegateModelItemObject>();
         if (!o)
@@ -596,6 +596,7 @@ public:
             ctx->throwTypeError();
 
         static_cast<QQmlDMListAccessorData *>(o->item)->setModelData(ctx->engine->v8Engine->toVariant(ctx->arguments[0], QVariant::Invalid));
+        return QV4::Encode::undefined();
     }
 
     QV4::Value get()
diff --git a/src/quick/items/context2d/qquickcontext2d.cpp b/src/quick/items/context2d/qquickcontext2d.cpp
index cf692c34eb..f3a3f28ccb 100644
--- a/src/quick/items/context2d/qquickcontext2d.cpp
+++ b/src/quick/items/context2d/qquickcontext2d.cpp
@@ -488,45 +488,45 @@ public:
     }
     QQuickContext2D* context;
 
-    static QV4::Value method_get_globalAlpha(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_globalAlpha(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_globalCompositeOperation(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_globalCompositeOperation(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_fillStyle(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_fillStyle(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_fillRule(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_fillRule(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_strokeStyle(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_strokeStyle(QV4::SimpleCallContext *ctx);
-
-    static QV4::Value method_get_lineCap(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_lineCap(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_lineJoin(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_lineJoin(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_lineWidth(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_lineWidth(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_miterLimit(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_miterLimit(QV4::SimpleCallContext *ctx);
-
-    static QV4::Value method_get_shadowBlur(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_shadowBlur(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_shadowColor(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_shadowColor(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_shadowOffsetX(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_shadowOffsetX(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_shadowOffsetY(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_shadowOffsetY(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_globalAlpha(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_globalAlpha(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_globalCompositeOperation(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_globalCompositeOperation(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_fillStyle(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_fillStyle(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_fillRule(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_fillRule(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_strokeStyle(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_strokeStyle(QV4::SimpleCallContext *ctx);
+
+    static QV4::ReturnedValue method_get_lineCap(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_lineCap(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_lineJoin(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_lineJoin(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_lineWidth(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_lineWidth(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_miterLimit(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_miterLimit(QV4::SimpleCallContext *ctx);
+
+    static QV4::ReturnedValue method_get_shadowBlur(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_shadowBlur(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_shadowColor(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_shadowColor(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_shadowOffsetX(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_shadowOffsetX(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_shadowOffsetY(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_shadowOffsetY(QV4::SimpleCallContext *ctx);
 
     // should these two be on the proto?
-    static QV4::Value method_get_path(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_path(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_path(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_path(QV4::SimpleCallContext *ctx);
 
-    static QV4::Value method_get_font(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_font(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_textAlign(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_textAlign(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_textBaseline(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_set_textBaseline(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_font(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_font(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_textAlign(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_textAlign(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_textBaseline(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_set_textBaseline(QV4::SimpleCallContext *ctx);
 
 protected:
     static void destroy(Managed *that)
@@ -591,50 +591,50 @@ public:
         defineAccessorProperty(engine, QStringLiteral("canvas"), QQuickJSContext2DPrototype::method_get_canvas, 0);
     }
 
-    static QV4::Value method_get_canvas(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_restore(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_reset(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_save(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_rotate(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_scale(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_translate(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_setTransform(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_transform(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_resetTransform(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_shear(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_createLinearGradient(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_createRadialGradient(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_createConicalGradient(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_createPattern(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_clearRect(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_fillRect(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_strokeRect(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_arc(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_arcTo(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_beginPath(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_bezierCurveTo(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_clip(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_closePath(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_fill(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_lineTo(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_moveTo(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_quadraticCurveTo(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_rect(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_roundedRect(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_ellipse(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_text(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_stroke(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_isPointInPath(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_drawFocusRing(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_setCaretSelectionRect(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_caretBlinkRate(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_fillText(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_strokeText(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_measureText(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_drawImage(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_createImageData(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_getImageData(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_putImageData(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_canvas(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_restore(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_reset(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_save(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_rotate(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_scale(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_translate(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_setTransform(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_transform(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_resetTransform(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_shear(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_createLinearGradient(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_createRadialGradient(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_createConicalGradient(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_createPattern(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_clearRect(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_fillRect(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_strokeRect(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_arc(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_arcTo(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_beginPath(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_bezierCurveTo(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_clip(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_closePath(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_fill(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_lineTo(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_moveTo(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_quadraticCurveTo(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_rect(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_roundedRect(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_ellipse(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_text(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_stroke(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_isPointInPath(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_drawFocusRing(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_setCaretSelectionRect(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_caretBlinkRate(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_fillText(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_strokeText(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_measureText(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_drawImage(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_createImageData(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_getImageData(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_putImageData(QV4::SimpleCallContext *ctx);
 
 };
 
@@ -656,7 +656,7 @@ public:
     bool patternRepeatX:1;
     bool patternRepeatY:1;
 
-    static QV4::Value gradient_proto_addColorStop(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue gradient_proto_addColorStop(QV4::SimpleCallContext *ctx);
 protected:
     static void destroy(Managed *that)
     {
@@ -876,7 +876,7 @@ struct QQuickJSContext2DPixelData : public QV4::Object
     static QV4::ReturnedValue getIndexed(QV4::Managed *m, uint index, bool *hasProperty);
     static void putIndexed(QV4::Managed *m, uint index, const QV4::Value &value);
 
-    static QV4::Value proto_get_length(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue proto_get_length(QV4::SimpleCallContext *ctx);
 
     QImage image;
 };
@@ -896,9 +896,9 @@ struct QQuickJSContext2DImageData : public QV4::Object
         defineAccessorProperty(engine, QStringLiteral("data"), method_get_data, 0);
     }
 
-    static QV4::Value method_get_width(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_height(QV4::SimpleCallContext *ctx);
-    static QV4::Value method_get_data(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_width(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_height(QV4::SimpleCallContext *ctx);
+    static QV4::ReturnedValue method_get_data(QV4::SimpleCallContext *ctx);
 
     static void markObjects(Managed *that) {
         static_cast<QQuickJSContext2DImageData *>(that)->pixelData.mark();
@@ -939,12 +939,12 @@ static QV4::Value qt_create_image_data(qreal w, qreal h, QV8Engine* engine, cons
 
      This property is read only.
 */
-QV4::Value QQuickJSContext2DPrototype::method_get_canvas(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_get_canvas(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return QV4::QObjectWrapper::wrap(ctx->engine, r->context->canvas());
+    return QV4::QObjectWrapper::wrap(ctx->engine, r->context->canvas()).asReturnedValue();
 }
 
 /*!
@@ -953,27 +953,27 @@ QV4::Value QQuickJSContext2DPrototype::method_get_canvas(QV4::SimpleCallContext
 
     \sa save()
 */
-QV4::Value QQuickJSContext2DPrototype::method_restore(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_restore(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->popState();
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
     \qmlmethod object QtQuick2::Context2D::reset()
     Resets the context state and properties to the default values.
 */
-QV4::Value QQuickJSContext2DPrototype::method_reset(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_reset(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->reset();
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -1006,14 +1006,14 @@ QV4::Value QQuickJSContext2DPrototype::method_reset(QV4::SimpleCallContext *ctx)
     The current path is NOT part of the drawing state. The path can be reset by
     invoking the beginPath() method.
 */
-QV4::Value QQuickJSContext2DPrototype::method_save(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_save(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->pushState();
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 // transformations
@@ -1034,14 +1034,14 @@ QV4::Value QQuickJSContext2DPrototype::method_save(QV4::SimpleCallContext *ctx)
     where the \a angle of rotation is in radians.
 
 */
-QV4::Value QQuickJSContext2DPrototype::method_rotate(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_rotate(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     if (ctx->argumentCount == 1)
         r->context->rotate(ctx->arguments[0].toNumber());
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -1061,7 +1061,7 @@ QV4::Value QQuickJSContext2DPrototype::method_rotate(QV4::SimpleCallContext *ctx
 
     \image qml-item-canvas-scale.png
 */
-QV4::Value QQuickJSContext2DPrototype::method_scale(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_scale(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1069,7 +1069,7 @@ QV4::Value QQuickJSContext2DPrototype::method_scale(QV4::SimpleCallContext *ctx)
 
     if (ctx->argumentCount == 2)
         r->context->scale(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber());
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -1105,7 +1105,7 @@ QV4::Value QQuickJSContext2DPrototype::method_scale(QV4::SimpleCallContext *ctx)
 
     \sa transform()
 */
-QV4::Value QQuickJSContext2DPrototype::method_setTransform(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_setTransform(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1119,7 +1119,7 @@ QV4::Value QQuickJSContext2DPrototype::method_setTransform(QV4::SimpleCallContex
                                                         , ctx->arguments[4].toNumber()
                                                         , ctx->arguments[5].toNumber());
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -1133,7 +1133,7 @@ QV4::Value QQuickJSContext2DPrototype::method_setTransform(QV4::SimpleCallContex
 
     \sa setTransform()
 */
-QV4::Value QQuickJSContext2DPrototype::method_transform(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_transform(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1147,7 +1147,7 @@ QV4::Value QQuickJSContext2DPrototype::method_transform(QV4::SimpleCallContext *
                                                   , ctx->arguments[4].toNumber()
                                                   , ctx->arguments[5].toNumber());
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -1159,7 +1159,7 @@ QV4::Value QQuickJSContext2DPrototype::method_transform(QV4::SimpleCallContext *
     Translating the origin enables you to draw patterns of different objects on the canvas
     without having to measure the coordinates manually for each shape.
 */
-QV4::Value QQuickJSContext2DPrototype::method_translate(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_translate(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1167,7 +1167,7 @@ QV4::Value QQuickJSContext2DPrototype::method_translate(QV4::SimpleCallContext *
 
     if (ctx->argumentCount == 2)
             r->context->translate(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber());
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 
@@ -1179,14 +1179,14 @@ QV4::Value QQuickJSContext2DPrototype::method_translate(QV4::SimpleCallContext *
 
     \sa transform(), setTransform(), reset()
 */
-QV4::Value QQuickJSContext2DPrototype::method_resetTransform(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_resetTransform(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->setTransform(1, 0, 0, 1, 0, 0);
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 
@@ -1196,7 +1196,7 @@ QV4::Value QQuickJSContext2DPrototype::method_resetTransform(QV4::SimpleCallCont
     Shears the transformation matrix by \a sh in the horizontal direction and
     \a sv in the vertical direction.
 */
-QV4::Value QQuickJSContext2DPrototype::method_shear(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_shear(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1204,7 +1204,7 @@ QV4::Value QQuickJSContext2DPrototype::method_shear(QV4::SimpleCallContext *ctx)
     if (ctx->argumentCount == 2)
             r->context->shear(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber());
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 // compositing
 
@@ -1215,15 +1215,15 @@ QV4::Value QQuickJSContext2DPrototype::method_shear(QV4::SimpleCallContext *ctx)
      The value must be in the range from \c 0.0 (fully transparent) to \c 1.0 (fully opaque).
      The default value is \c 1.0.
 */
-QV4::Value QQuickJSContext2D::method_get_globalAlpha(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_globalAlpha(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return QV4::Value::fromDouble(r->context->state.globalAlpha);
+    return QV4::Encode(r->context->state.globalAlpha);
 }
 
-QV4::Value QQuickJSContext2D::method_set_globalAlpha(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_globalAlpha(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1231,13 +1231,13 @@ QV4::Value QQuickJSContext2D::method_set_globalAlpha(QV4::SimpleCallContext *ctx
     double globalAlpha = ctx->argument(0).toNumber();
 
     if (!qIsFinite(globalAlpha))
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
     if (globalAlpha >= 0.0 && globalAlpha <= 1.0 && r->context->state.globalAlpha != globalAlpha) {
         r->context->state.globalAlpha = globalAlpha;
         r->context->buffer()->setGlobalAlpha(r->context->state.globalAlpha);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
@@ -1266,15 +1266,15 @@ QV4::Value QQuickJSContext2D::method_set_globalAlpha(QV4::SimpleCallContext *ctx
      extension composition modes are provided as "vendorName-operationName" syntax, for example: QPainter::CompositionMode_Exclusion is provided as
      "qt-exclusion".
 */
-QV4::Value QQuickJSContext2D::method_get_globalCompositeOperation(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_globalCompositeOperation(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return QV4::Value::fromString(ctx->engine->newString(qt_composite_mode_to_string(r->context->state.globalCompositeOperation)));
+    return QV4::Value::fromString(ctx->engine->newString(qt_composite_mode_to_string(r->context->state.globalCompositeOperation))).asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_globalCompositeOperation(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_globalCompositeOperation(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1282,13 +1282,13 @@ QV4::Value QQuickJSContext2D::method_set_globalCompositeOperation(QV4::SimpleCal
     QString mode = ctx->argument(0).toQStringNoThrow();
     QPainter::CompositionMode cm = qt_composite_mode_from_string(mode);
     if (cm == QPainter::CompositionMode_SourceOver && mode != QStringLiteral("source-over"))
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
     if (cm != r->context->state.globalCompositeOperation) {
         r->context->state.globalCompositeOperation = cm;
         r->context->buffer()->setGlobalCompositeOperation(cm);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 // colors and styles
@@ -1314,7 +1314,7 @@ QV4::Value QQuickJSContext2D::method_set_globalCompositeOperation(QV4::SimpleCal
      \sa createPattern()
      \sa strokeStyle
  */
-QV4::Value QQuickJSContext2D::method_get_fillStyle(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_fillStyle(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1322,19 +1322,19 @@ QV4::Value QQuickJSContext2D::method_get_fillStyle(QV4::SimpleCallContext *ctx)
     QColor color = r->context->state.fillStyle.color();
     if (color.isValid()) {
         if (color.alpha() == 255)
-            return QV4::Value::fromString(ctx->engine->newString(color.name()));
+            return QV4::Value::fromString(ctx->engine->newString(color.name())).asReturnedValue();
         QString alphaString = QString::number(color.alphaF(), 'f');
         while (alphaString.endsWith(QLatin1Char('0')))
             alphaString.chop(1);
         if (alphaString.endsWith(QLatin1Char('.')))
             alphaString += QLatin1Char('0');
         QString str = QString::fromLatin1("rgba(%1, %2, %3, %4)").arg(color.red()).arg(color.green()).arg(color.blue()).arg(alphaString);
-        return QV4::Value::fromString(ctx->engine->newString(str));
+        return QV4::Value::fromString(ctx->engine->newString(str)).asReturnedValue();
     }
-    return r->context->m_fillStyle.value();
+    return r->context->m_fillStyle.value().asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_fillStyle(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_fillStyle(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1366,7 +1366,7 @@ QV4::Value QQuickJSContext2D::method_set_fillStyle(QV4::SimpleCallContext *ctx)
             r->context->m_fillStyle = value;
        }
    }
-   return QV4::Value::undefinedValue();
+   return QV4::Encode::undefined();
 }
 /*!
     \qmlproperty enumeration QtQuick2::Context2D::fillRule
@@ -1380,16 +1380,16 @@ QV4::Value QQuickJSContext2D::method_set_fillStyle(QV4::SimpleCallContext *ctx)
 
      \sa fillStyle
  */
-QV4::Value QQuickJSContext2D::method_get_fillRule(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_fillRule(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     QV8Engine *engine = ctx->engine->v8Engine;
-    return engine->fromVariant(r->context->state.fillRule);
+    return engine->fromVariant(r->context->state.fillRule).asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_fillRule(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_fillRule(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1406,7 +1406,7 @@ QV4::Value QQuickJSContext2D::method_set_fillRule(QV4::SimpleCallContext *ctx)
         //error
     }
     r->context->m_path.setFillRule(r->context->state.fillRule);
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 /*!
     \qmlproperty variant QtQuick2::Context2D::strokeStyle
@@ -1421,7 +1421,7 @@ QV4::Value QQuickJSContext2D::method_set_fillRule(QV4::SimpleCallContext *ctx)
      \sa createPattern()
      \sa fillStyle
  */
-QV4::Value QQuickJSContext2D::method_get_strokeStyle(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_strokeStyle(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1429,19 +1429,19 @@ QV4::Value QQuickJSContext2D::method_get_strokeStyle(QV4::SimpleCallContext *ctx
     QColor color = r->context->state.strokeStyle.color();
     if (color.isValid()) {
         if (color.alpha() == 255)
-            return QV4::Value::fromString(ctx->engine->newString(color.name()));
+            return QV4::Value::fromString(ctx->engine->newString(color.name())).asReturnedValue();
         QString alphaString = QString::number(color.alphaF(), 'f');
         while (alphaString.endsWith(QLatin1Char('0')))
             alphaString.chop(1);
         if (alphaString.endsWith(QLatin1Char('.')))
             alphaString += QLatin1Char('0');
         QString str = QString::fromLatin1("rgba(%1, %2, %3, %4)").arg(color.red()).arg(color.green()).arg(color.blue()).arg(alphaString);
-        return QV4::Value::fromString(ctx->engine->newString(str));
+        return QV4::Value::fromString(ctx->engine->newString(str)).asReturnedValue();
     }
-    return r->context->m_strokeStyle.value();
+    return r->context->m_strokeStyle.value().asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_strokeStyle(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_strokeStyle(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1474,7 +1474,7 @@ QV4::Value QQuickJSContext2D::method_set_strokeStyle(QV4::SimpleCallContext *ctx
              r->context->m_strokeStyle = value;
         }
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
@@ -1494,7 +1494,7 @@ QV4::Value QQuickJSContext2D::method_set_strokeStyle(QV4::SimpleCallContext *ctx
     \sa strokeStyle
   */
 
-QV4::Value QQuickJSContext2DPrototype::method_createLinearGradient(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_createLinearGradient(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1520,10 +1520,10 @@ QV4::Value QQuickJSContext2DPrototype::method_createLinearGradient(QV4::SimpleCa
         QQuickContext2DStyle *gradient = new (v4->memoryManager) QQuickContext2DStyle(v4);
         gradient->setPrototype(ed->gradientProto.value().asObject());
         gradient->brush = QLinearGradient(x0, y0, x1, y1);
-        return QV4::Value::fromObject(gradient);
+        return QV4::Value::fromObject(gradient).asReturnedValue();
     }
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -1539,7 +1539,7 @@ QV4::Value QQuickJSContext2DPrototype::method_createLinearGradient(QV4::SimpleCa
     \sa strokeStyle
   */
 
-QV4::Value QQuickJSContext2DPrototype::method_createRadialGradient(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_createRadialGradient(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1573,10 +1573,10 @@ QV4::Value QQuickJSContext2DPrototype::method_createRadialGradient(QV4::SimpleCa
         QQuickContext2DStyle *gradient = new (v4->memoryManager) QQuickContext2DStyle(v4);
         gradient->setPrototype(ed->gradientProto.value().asObject());
         gradient->brush = QRadialGradient(QPointF(x1, y1), r0+r1, QPointF(x0, y0));
-        return QV4::Value::fromObject(gradient);
+        return QV4::Value::fromObject(gradient).asReturnedValue();
     }
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -1592,7 +1592,7 @@ QV4::Value QQuickJSContext2DPrototype::method_createRadialGradient(QV4::SimpleCa
     \sa strokeStyle
   */
 
-QV4::Value QQuickJSContext2DPrototype::method_createConicalGradient(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_createConicalGradient(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1618,10 +1618,10 @@ QV4::Value QQuickJSContext2DPrototype::method_createConicalGradient(QV4::SimpleC
         QQuickContext2DStyle *gradient = new (v4->memoryManager) QQuickContext2DStyle(v4);
         gradient->setPrototype(ed->gradientProto.value().asObject());
         gradient->brush = QConicalGradient(x, y, angle);
-        return QV4::Value::fromObject(gradient);
+        return QV4::Value::fromObject(gradient).asReturnedValue();
     }
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 /*!
   \qmlmethod variant QtQuick2::Context2D::createPattern(color color, enumeration patternMode)
@@ -1666,7 +1666,7 @@ QV4::Value QQuickJSContext2DPrototype::method_createConicalGradient(QV4::SimpleC
   \sa strokeStyle
   \sa fillStyle
   */
-QV4::Value QQuickJSContext2DPrototype::method_createPattern(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_createPattern(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -1720,10 +1720,10 @@ QV4::Value QQuickJSContext2DPrototype::method_createPattern(QV4::SimpleCallConte
             }
         }
 
-        return QV4::Value::fromObject(pattern);
+        return QV4::Value::fromObject(pattern).asReturnedValue();
 
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 // line styles
@@ -1738,24 +1738,24 @@ QV4::Value QQuickJSContext2DPrototype::method_createPattern(QV4::SimpleCallConte
     \endlist
     Other values are ignored.
 */
-QV4::Value QQuickJSContext2D::method_get_lineCap(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_lineCap(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     switch (r->context->state.lineCap) {
     case Qt::RoundCap:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("round")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("round"))).asReturnedValue();
     case Qt::SquareCap:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("square")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("square"))).asReturnedValue();
     case Qt::FlatCap:
     default:
         break;
     }
-    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("butt")));
+    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("butt"))).asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_lineCap(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_lineCap(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1769,13 +1769,13 @@ QV4::Value QQuickJSContext2D::method_set_lineCap(QV4::SimpleCallContext *ctx)
     else if (lineCap == QStringLiteral("square"))
         cap = Qt::SquareCap;
     else
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
     if (cap != r->context->state.lineCap) {
         r->context->state.lineCap = cap;
         r->context->buffer()->setLineCap(cap);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
@@ -1792,24 +1792,24 @@ QV4::Value QQuickJSContext2D::method_set_lineCap(QV4::SimpleCallContext *ctx)
     \endlist
     Other values are ignored.
 */
-QV4::Value QQuickJSContext2D::method_get_lineJoin(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_lineJoin(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     switch (r->context->state.lineJoin) {
     case Qt::RoundJoin:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("round")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("round"))).asReturnedValue();
     case Qt::BevelJoin:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("bevel")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("bevel"))).asReturnedValue();
     case Qt::MiterJoin:
     default:
         break;
     }
-    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("miter")));
+    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("miter"))).asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_lineJoin(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_lineJoin(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1823,28 +1823,28 @@ QV4::Value QQuickJSContext2D::method_set_lineJoin(QV4::SimpleCallContext *ctx)
     else if (lineJoin == QStringLiteral("miter"))
         join = Qt::SvgMiterJoin;
     else
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
     if (join != r->context->state.lineJoin) {
         r->context->state.lineJoin = join;
         r->context->buffer()->setLineJoin(join);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
     \qmlproperty real QtQuick2::Context2D::lineWidth
      Holds the current line width. Values that are not finite values greater than zero are ignored.
  */
-QV4::Value QQuickJSContext2D::method_get_lineWidth(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_lineWidth(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return QV4::Value::fromDouble(r->context->state.lineWidth);
+    return QV4::Encode(r->context->state.lineWidth);
 }
 
-QV4::Value QQuickJSContext2D::method_set_lineWidth(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_lineWidth(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1855,7 +1855,7 @@ QV4::Value QQuickJSContext2D::method_set_lineWidth(QV4::SimpleCallContext *ctx)
         r->context->state.lineWidth = w;
         r->context->buffer()->setLineWidth(w);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
@@ -1863,15 +1863,15 @@ QV4::Value QQuickJSContext2D::method_set_lineWidth(QV4::SimpleCallContext *ctx)
      Holds the current miter limit ratio.
      The default miter limit value is 10.0.
  */
-QV4::Value QQuickJSContext2D::method_get_miterLimit(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_miterLimit(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return QV4::Value::fromDouble(r->context->state.miterLimit);
+    return QV4::Encode(r->context->state.miterLimit);
 }
 
-QV4::Value QQuickJSContext2D::method_set_miterLimit(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_miterLimit(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1882,7 +1882,7 @@ QV4::Value QQuickJSContext2D::method_set_miterLimit(QV4::SimpleCallContext *ctx)
         r->context->state.miterLimit = ml;
         r->context->buffer()->setMiterLimit(ml);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 // shadows
@@ -1890,15 +1890,15 @@ QV4::Value QQuickJSContext2D::method_set_miterLimit(QV4::SimpleCallContext *ctx)
     \qmlproperty real QtQuick2::Context2D::shadowBlur
      Holds the current level of blur applied to shadows
  */
-QV4::Value QQuickJSContext2D::method_get_shadowBlur(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_shadowBlur(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return QV4::Value::fromDouble(r->context->state.shadowBlur);
+    return QV4::Encode(r->context->state.shadowBlur);
 }
 
-QV4::Value QQuickJSContext2D::method_set_shadowBlur(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_shadowBlur(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1909,22 +1909,22 @@ QV4::Value QQuickJSContext2D::method_set_shadowBlur(QV4::SimpleCallContext *ctx)
         r->context->state.shadowBlur = blur;
         r->context->buffer()->setShadowBlur(blur);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
     \qmlproperty string QtQuick2::Context2D::shadowColor
      Holds the current shadow color.
  */
-QV4::Value QQuickJSContext2D::method_get_shadowColor(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_shadowColor(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return QV4::Value::fromString(ctx->engine->newString(r->context->state.shadowColor.name()));
+    return QV4::Value::fromString(ctx->engine->newString(r->context->state.shadowColor.name())).asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_shadowColor(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_shadowColor(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1935,7 +1935,7 @@ QV4::Value QQuickJSContext2D::method_set_shadowColor(QV4::SimpleCallContext *ctx
         r->context->state.shadowColor = color;
         r->context->buffer()->setShadowColor(color);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 
@@ -1945,15 +1945,15 @@ QV4::Value QQuickJSContext2D::method_set_shadowColor(QV4::SimpleCallContext *ctx
 
      \sa shadowOffsetY
  */
-QV4::Value QQuickJSContext2D::method_get_shadowOffsetX(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_shadowOffsetX(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return QV4::Value::fromDouble(r->context->state.shadowOffsetX);
+    return QV4::Encode(r->context->state.shadowOffsetX);
 }
 
-QV4::Value QQuickJSContext2D::method_set_shadowOffsetX(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_shadowOffsetX(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1963,7 +1963,7 @@ QV4::Value QQuickJSContext2D::method_set_shadowOffsetX(QV4::SimpleCallContext *c
         r->context->state.shadowOffsetX = offsetX;
         r->context->buffer()->setShadowOffsetX(offsetX);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 /*!
     \qmlproperty qreal QtQuick2::Context2D::shadowOffsetY
@@ -1971,15 +1971,15 @@ QV4::Value QQuickJSContext2D::method_set_shadowOffsetX(QV4::SimpleCallContext *c
 
      \sa shadowOffsetX
  */
-QV4::Value QQuickJSContext2D::method_get_shadowOffsetY(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_shadowOffsetY(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return QV4::Value::fromDouble(r->context->state.shadowOffsetY);
+    return QV4::Encode(r->context->state.shadowOffsetY);
 }
 
-QV4::Value QQuickJSContext2D::method_set_shadowOffsetY(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_shadowOffsetY(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -1989,18 +1989,18 @@ QV4::Value QQuickJSContext2D::method_set_shadowOffsetY(QV4::SimpleCallContext *c
         r->context->state.shadowOffsetY = offsetY;
         r->context->buffer()->setShadowOffsetY(offsetY);
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
-QV4::Value QQuickJSContext2D::method_get_path(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_path(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return r->context->m_v4path.value();
+    return r->context->m_v4path.value().asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_path(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_path(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -2015,7 +2015,7 @@ QV4::Value QQuickJSContext2D::method_set_path(QV4::SimpleCallContext *ctx)
         QQuickSvgParser::parsePathDataFast(path, r->context->m_path);
     }
     r->context->m_v4path = value;
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 //rects
@@ -2023,7 +2023,7 @@ QV4::Value QQuickJSContext2D::method_set_path(QV4::SimpleCallContext *ctx)
   \qmlmethod object QtQuick2::Context2D::clearRect(real x, real y, real w, real h)
   Clears all pixels on the canvas in the given rectangle to transparent black.
   */
-QV4::Value QQuickJSContext2DPrototype::method_clearRect(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_clearRect(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2035,7 +2035,7 @@ QV4::Value QQuickJSContext2DPrototype::method_clearRect(QV4::SimpleCallContext *
                               ctx->arguments[2].toNumber(),
                               ctx->arguments[3].toNumber());
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 /*!
   \qmlmethod object QtQuick2::Context2D::fillRect(real x, real y, real w, real h)
@@ -2043,14 +2043,14 @@ QV4::Value QQuickJSContext2DPrototype::method_clearRect(QV4::SimpleCallContext *
 
    \sa fillStyle
   */
-QV4::Value QQuickJSContext2DPrototype::method_fillRect(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_fillRect(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     if (ctx->argumentCount == 4)
         r->context->fillRect(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber(), ctx->arguments[2].toNumber(), ctx->arguments[3].toNumber());
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2063,7 +2063,7 @@ QV4::Value QQuickJSContext2DPrototype::method_fillRect(QV4::SimpleCallContext *c
    \sa lineJoin
    \sa miterLimit
   */
-QV4::Value QQuickJSContext2DPrototype::method_strokeRect(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_strokeRect(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2071,7 +2071,7 @@ QV4::Value QQuickJSContext2DPrototype::method_strokeRect(QV4::SimpleCallContext
     if (ctx->argumentCount == 4)
         r->context->strokeRect(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber(), ctx->arguments[2].toNumber(), ctx->arguments[3].toNumber());
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 // Complex shapes (paths) API
@@ -2095,7 +2095,7 @@ QV4::Value QQuickJSContext2DPrototype::method_strokeRect(QV4::SimpleCallContext
     \sa arcTo, {http://www.w3.org/TR/2dcontext/#dom-context-2d-arc}{W3C's 2D
     Context Standard for arc()}
 */
-QV4::Value QQuickJSContext2DPrototype::method_arc(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_arc(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2119,7 +2119,7 @@ QV4::Value QQuickJSContext2DPrototype::method_arc(QV4::SimpleCallContext *ctx)
                         antiClockwise);
     }
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2145,7 +2145,7 @@ QV4::Value QQuickJSContext2DPrototype::method_arc(QV4::SimpleCallContext *ctx)
     \sa arc, {http://www.w3.org/TR/2dcontext/#dom-context-2d-arcto}{W3C's 2D
     Context Standard for arcTo()}
 */
-QV4::Value QQuickJSContext2DPrototype::method_arcTo(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_arcTo(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2163,7 +2163,7 @@ QV4::Value QQuickJSContext2DPrototype::method_arcTo(QV4::SimpleCallContext *ctx)
                           radius);
     }
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2171,7 +2171,7 @@ QV4::Value QQuickJSContext2DPrototype::method_arcTo(QV4::SimpleCallContext *ctx)
 
    Resets the current path to a new path.
   */
-QV4::Value QQuickJSContext2DPrototype::method_beginPath(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_beginPath(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2179,7 +2179,7 @@ QV4::Value QQuickJSContext2DPrototype::method_beginPath(QV4::SimpleCallContext *
 
     r->context->beginPath();
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2201,7 +2201,7 @@ QV4::Value QQuickJSContext2DPrototype::method_beginPath(QV4::SimpleCallContext *
   \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-beziercurveto}{W3C 2d context standard for bezierCurveTo}
   \sa {http://www.openrise.com/lab/FlowerPower/}{The beautiful flower demo by using bezierCurveTo}
   */
-QV4::Value QQuickJSContext2DPrototype::method_bezierCurveTo(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_bezierCurveTo(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2216,12 +2216,12 @@ QV4::Value QQuickJSContext2DPrototype::method_bezierCurveTo(QV4::SimpleCallConte
         qreal y = ctx->arguments[5].toNumber();
 
         if (!qIsFinite(cp1x) || !qIsFinite(cp1y) || !qIsFinite(cp2x) || !qIsFinite(cp2y) || !qIsFinite(x) || !qIsFinite(y))
-            return ctx->thisObject;
+            return ctx->thisObject.asReturnedValue();
 
         r->context->bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
     }
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2248,13 +2248,13 @@ QV4::Value QQuickJSContext2DPrototype::method_bezierCurveTo(QV4::SimpleCallConte
     \sa fill()
    \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-clip}{W3C 2d context standard for clip}
   */
-QV4::Value QQuickJSContext2DPrototype::method_clip(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_clip(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->clip();
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2264,7 +2264,7 @@ QV4::Value QQuickJSContext2DPrototype::method_clip(QV4::SimpleCallContext *ctx)
 
    \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-closepath}{W3C 2d context standard for closePath}
   */
-QV4::Value QQuickJSContext2DPrototype::method_closePath(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_closePath(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2272,7 +2272,7 @@ QV4::Value QQuickJSContext2DPrototype::method_closePath(QV4::SimpleCallContext *
 
     r->context->closePath();
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2284,12 +2284,12 @@ QV4::Value QQuickJSContext2DPrototype::method_closePath(QV4::SimpleCallContext *
 
    \sa fillStyle
   */
-QV4::Value QQuickJSContext2DPrototype::method_fill(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_fill(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r);
     r->context->fill();
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2297,7 +2297,7 @@ QV4::Value QQuickJSContext2DPrototype::method_fill(QV4::SimpleCallContext *ctx)
 
    Draws a line from the current position to the point (x, y).
  */
-QV4::Value QQuickJSContext2DPrototype::method_lineTo(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_lineTo(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2308,12 +2308,12 @@ QV4::Value QQuickJSContext2DPrototype::method_lineTo(QV4::SimpleCallContext *ctx
         qreal y = ctx->arguments[1].toNumber();
 
         if (!qIsFinite(x) || !qIsFinite(y))
-            return ctx->thisObject;
+            return ctx->thisObject.asReturnedValue();
 
         r->context->lineTo(x, y);
     }
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2321,7 +2321,7 @@ QV4::Value QQuickJSContext2DPrototype::method_lineTo(QV4::SimpleCallContext *ctx
 
    Creates a new subpath with the given point.
  */
-QV4::Value QQuickJSContext2DPrototype::method_moveTo(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_moveTo(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2331,10 +2331,10 @@ QV4::Value QQuickJSContext2DPrototype::method_moveTo(QV4::SimpleCallContext *ctx
         qreal y = ctx->arguments[1].toNumber();
 
         if (!qIsFinite(x) || !qIsFinite(y))
-            return ctx->thisObject;
+            return ctx->thisObject.asReturnedValue();
         r->context->moveTo(x, y);
     }
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2344,7 +2344,7 @@ QV4::Value QQuickJSContext2DPrototype::method_moveTo(QV4::SimpleCallContext *ctx
 
    See \l{http://www.w3.org/TR/2dcontext/#dom-context-2d-quadraticcurveto}{W3C 2d context standard for  for quadraticCurveTo}
  */
-QV4::Value QQuickJSContext2DPrototype::method_quadraticCurveTo(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_quadraticCurveTo(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2356,12 +2356,12 @@ QV4::Value QQuickJSContext2DPrototype::method_quadraticCurveTo(QV4::SimpleCallCo
         qreal y = ctx->arguments[3].toNumber();
 
         if (!qIsFinite(cpx) || !qIsFinite(cpy) || !qIsFinite(x) || !qIsFinite(y))
-            return ctx->thisObject;
+            return ctx->thisObject.asReturnedValue();
 
         r->context->quadraticCurveTo(cpx, cpy, x, y);
     }
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2369,14 +2369,14 @@ QV4::Value QQuickJSContext2DPrototype::method_quadraticCurveTo(QV4::SimpleCallCo
 
    Adds a rectangle at position (\c x, \c y), with the given width \c w and height \c h, as a closed subpath.
  */
-QV4::Value QQuickJSContext2DPrototype::method_rect(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_rect(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     if (ctx->argumentCount == 4)
         r->context->rect(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber(), ctx->arguments[2].toNumber(), ctx->arguments[3].toNumber());
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2385,7 +2385,7 @@ QV4::Value QQuickJSContext2DPrototype::method_rect(QV4::SimpleCallContext *ctx)
    Adds the given rectangle rect with rounded corners to the path. The \c xRadius and \c yRadius arguments specify the radius of the
    ellipses defining the corners of the rounded rectangle.
  */
-QV4::Value QQuickJSContext2DPrototype::method_roundedRect(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_roundedRect(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2397,7 +2397,7 @@ QV4::Value QQuickJSContext2DPrototype::method_roundedRect(QV4::SimpleCallContext
                               , ctx->arguments[3].toNumber()
                               , ctx->arguments[4].toNumber()
                               , ctx->arguments[5].toNumber());
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2408,7 +2408,7 @@ QV4::Value QQuickJSContext2DPrototype::method_roundedRect(QV4::SimpleCallContext
 
   The ellipse is composed of a clockwise curve, starting and finishing at zero degrees (the 3 o'clock position).
  */
-QV4::Value QQuickJSContext2DPrototype::method_ellipse(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_ellipse(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2417,7 +2417,7 @@ QV4::Value QQuickJSContext2DPrototype::method_ellipse(QV4::SimpleCallContext *ct
     if (ctx->argumentCount == 4)
         r->context->ellipse(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber(), ctx->arguments[2].toNumber(), ctx->arguments[3].toNumber());
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2426,7 +2426,7 @@ QV4::Value QQuickJSContext2DPrototype::method_ellipse(QV4::SimpleCallContext *ct
   Adds the given \c text to the path as a set of closed subpaths created from the current context font supplied.
   The subpaths are positioned so that the left end of the text's baseline lies at the point specified by (\c x, \c y).
  */
-QV4::Value QQuickJSContext2DPrototype::method_text(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_text(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2436,10 +2436,10 @@ QV4::Value QQuickJSContext2DPrototype::method_text(QV4::SimpleCallContext *ctx)
         qreal y = ctx->arguments[2].toNumber();
 
         if (!qIsFinite(x) || !qIsFinite(y))
-            return ctx->thisObject;
+            return ctx->thisObject.asReturnedValue();
         r->context->text(ctx->arguments[0].toQStringNoThrow(), x, y);
     }
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2451,13 +2451,13 @@ QV4::Value QQuickJSContext2DPrototype::method_text(QV4::SimpleCallContext *ctx)
 
    \sa strokeStyle
   */
-QV4::Value QQuickJSContext2DPrototype::method_stroke(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_stroke(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->stroke();
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2467,7 +2467,7 @@ QV4::Value QQuickJSContext2DPrototype::method_stroke(QV4::SimpleCallContext *ctx
 
    \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-ispointinpath}{W3C 2d context standard for isPointInPath}
   */
-QV4::Value QQuickJSContext2DPrototype::method_isPointInPath(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_isPointInPath(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2475,24 +2475,24 @@ QV4::Value QQuickJSContext2DPrototype::method_isPointInPath(QV4::SimpleCallConte
     bool pointInPath = false;
     if (ctx->argumentCount == 2)
         pointInPath = r->context->isPointInPath(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber());
-    return QV4::Value::fromBoolean(pointInPath);
+    return QV4::Value::fromBoolean(pointInPath).asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2DPrototype::method_drawFocusRing(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_drawFocusRing(QV4::SimpleCallContext *ctx)
 {
     Q_UNUSED(ctx);
 
     V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::drawFocusRing is not supported");
 }
 
-QV4::Value QQuickJSContext2DPrototype::method_setCaretSelectionRect(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_setCaretSelectionRect(QV4::SimpleCallContext *ctx)
 {
     Q_UNUSED(ctx);
 
     V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::setCaretSelectionRect is not supported");
 }
 
-QV4::Value QQuickJSContext2DPrototype::method_caretBlinkRate(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_caretBlinkRate(QV4::SimpleCallContext *ctx)
 {
     Q_UNUSED(ctx);
 
@@ -2522,15 +2522,15 @@ QV4::Value QQuickJSContext2DPrototype::method_caretBlinkRate(QV4::SimpleCallCont
 
     The default font value is "10px sans-serif".
   */
-QV4::Value QQuickJSContext2D::method_get_font(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_font(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return QV4::Value::fromString(ctx->engine->newString(r->context->state.font.toString()));
+    return QV4::Value::fromString(ctx->engine->newString(r->context->state.font.toString())).asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_font(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_font(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -2540,7 +2540,7 @@ QV4::Value QQuickJSContext2D::method_set_font(QV4::SimpleCallContext *ctx)
     if (font != r->context->state.font) {
         r->context->state.font = font;
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
@@ -2557,28 +2557,28 @@ QV4::Value QQuickJSContext2D::method_set_font(QV4::SimpleCallContext *ctx)
   \endlist
   Other values are ignored. The default value is "start".
   */
-QV4::Value QQuickJSContext2D::method_get_textAlign(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_textAlign(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     switch (r->context->state.textAlign) {
     case QQuickContext2D::End:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("end")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("end"))).asReturnedValue();
     case QQuickContext2D::Left:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("left")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("left"))).asReturnedValue();
     case QQuickContext2D::Right:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("right")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("right"))).asReturnedValue();
     case QQuickContext2D::Center:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("center")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("center"))).asReturnedValue();
     case QQuickContext2D::Start:
     default:
         break;
     }
-    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("start")));
+    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("start"))).asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_textAlign(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_textAlign(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -2597,12 +2597,12 @@ QV4::Value QQuickJSContext2D::method_set_textAlign(QV4::SimpleCallContext *ctx)
     else if (textAlign == QStringLiteral("center"))
         ta = QQuickContext2D::Center;
     else
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
     if (ta != r->context->state.textAlign)
         r->context->state.textAlign = ta;
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
@@ -2620,28 +2620,28 @@ QV4::Value QQuickJSContext2D::method_set_textAlign(QV4::SimpleCallContext *ctx)
   \endlist
   Other values are ignored. The default value is "alphabetic".
   */
-QV4::Value QQuickJSContext2D::method_get_textBaseline(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_get_textBaseline(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     switch (r->context->state.textBaseline) {
     case QQuickContext2D::Hanging:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("hanging")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("hanging"))).asReturnedValue();
     case QQuickContext2D::Top:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("top")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("top"))).asReturnedValue();
     case QQuickContext2D::Bottom:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("bottom")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("bottom"))).asReturnedValue();
     case QQuickContext2D::Middle:
-        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("middle")));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("middle"))).asReturnedValue();
     case QQuickContext2D::Alphabetic:
     default:
         break;
     }
-    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("alphabetic")));
+    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("alphabetic"))).asReturnedValue();
 }
 
-QV4::Value QQuickJSContext2D::method_set_textBaseline(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2D::method_set_textBaseline(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
@@ -2659,12 +2659,12 @@ QV4::Value QQuickJSContext2D::method_set_textBaseline(QV4::SimpleCallContext *ct
     else if (textBaseline == QStringLiteral("middle"))
         tb = QQuickContext2D::Middle;
     else
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
     if (tb != r->context->state.textBaseline)
         r->context->state.textBaseline = tb;
 
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
@@ -2675,7 +2675,7 @@ QV4::Value QQuickJSContext2D::method_set_textBaseline(QV4::SimpleCallContext *ct
   \sa textBaseline
   \sa strokeText
   */
-QV4::Value QQuickJSContext2DPrototype::method_fillText(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_fillText(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2684,11 +2684,11 @@ QV4::Value QQuickJSContext2DPrototype::method_fillText(QV4::SimpleCallContext *c
         qreal x = ctx->arguments[1].toNumber();
         qreal y = ctx->arguments[2].toNumber();
         if (!qIsFinite(x) || !qIsFinite(y))
-            return ctx->thisObject;
+            return ctx->thisObject.asReturnedValue();
         QPainterPath textPath = r->context->createTextGlyphs(x, y, ctx->arguments[0].toQStringNoThrow());
         r->context->buffer()->fill(textPath);
     }
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 /*!
   \qmlmethod object QtQuick2::Context2D::strokeText(text, x, y)
@@ -2698,14 +2698,14 @@ QV4::Value QQuickJSContext2DPrototype::method_fillText(QV4::SimpleCallContext *c
   \sa textBaseline
   \sa fillText
   */
-QV4::Value QQuickJSContext2DPrototype::method_strokeText(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_strokeText(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     if (ctx->argumentCount == 3)
         r->context->drawText(ctx->arguments[0].toQStringNoThrow(), ctx->arguments[1].toNumber(), ctx->arguments[2].toNumber(), false);
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -2732,7 +2732,7 @@ QV4::Value QQuickJSContext2DPrototype::method_strokeText(QV4::SimpleCallContext
   \qmlmethod variant QtQuick2::Context2D::measureText(text)
   Returns a TextMetrics object with the metrics of the given text in the current font.
   */
-QV4::Value QQuickJSContext2DPrototype::method_measureText(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_measureText(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2742,9 +2742,9 @@ QV4::Value QQuickJSContext2DPrototype::method_measureText(QV4::SimpleCallContext
         uint width = fm.width(ctx->arguments[0].toQStringNoThrow());
         QV4::Object *tm = ctx->engine->newObject();
         tm->put(ctx->engine->newIdentifier(QStringLiteral("width")), QV4::Value::fromDouble(width));
-        return QV4::Value::fromObject(tm);
+        return QV4::Value::fromObject(tm).asReturnedValue();
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 // drawing images
@@ -2806,7 +2806,7 @@ QV4::Value QQuickJSContext2DPrototype::method_measureText(QV4::SimpleCallContext
 
   \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-drawimage}{W3C 2d context standard for drawImage}
 */
-QV4::Value QQuickJSContext2DPrototype::method_drawImage(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_drawImage(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -2814,11 +2814,11 @@ QV4::Value QQuickJSContext2DPrototype::method_drawImage(QV4::SimpleCallContext *
     qreal sx, sy, sw, sh, dx, dy, dw, dh;
 
     if (!ctx->argumentCount)
-        return ctx->thisObject;
+        return ctx->thisObject.asReturnedValue();
 
     //FIXME:This function should be moved to QQuickContext2D::drawImage(...)
     if (!r->context->state.invertibleCTM)
-        return ctx->thisObject;
+        return ctx->thisObject.asReturnedValue();
 
     QQmlRefPointer<QQuickCanvasPixmap> pixmap;
 
@@ -2858,7 +2858,7 @@ QV4::Value QQuickJSContext2DPrototype::method_drawImage(QV4::SimpleCallContext *
     }
 
     if (pixmap.isNull() || !pixmap->isValid())
-        return ctx->thisObject;
+        return ctx->thisObject.asReturnedValue();
 
     if (ctx->argumentCount == 3) {
         dx = ctx->arguments[1].toNumber();
@@ -2888,7 +2888,7 @@ QV4::Value QQuickJSContext2DPrototype::method_drawImage(QV4::SimpleCallContext *
         dw = ctx->arguments[7].toNumber();
         dh = ctx->arguments[8].toNumber();
     } else {
-        return ctx->thisObject;
+        return ctx->thisObject.asReturnedValue();
     }
 
     if (!qIsFinite(sx)
@@ -2899,7 +2899,7 @@ QV4::Value QQuickJSContext2DPrototype::method_drawImage(QV4::SimpleCallContext *
      || !qIsFinite(dy)
      || !qIsFinite(dw)
      || !qIsFinite(dh))
-        return ctx->thisObject;
+        return ctx->thisObject.asReturnedValue();
 
     if (sx < 0
     || sy < 0
@@ -2913,7 +2913,7 @@ QV4::Value QQuickJSContext2DPrototype::method_drawImage(QV4::SimpleCallContext *
 
     r->context->buffer()->drawPixmap(pixmap, QRectF(sx, sy, sw, sh), QRectF(dx, dy, dw, dh));
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 // pixel manipulation
@@ -2940,42 +2940,42 @@ QV4::Value QQuickJSContext2DPrototype::method_drawImage(QV4::SimpleCallContext *
   \qmlproperty int QtQuick2::CanvasImageData::width
   Holds the actual width dimension of the data in the ImageData object, in device pixels.
  */
-QV4::Value QQuickJSContext2DImageData::method_get_width(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DImageData::method_get_width(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2DImageData *imageData = ctx->thisObject.as<QQuickJSContext2DImageData>();
     if (!imageData)
         ctx->throwTypeError();
     QQuickJSContext2DPixelData *r = imageData->pixelData.as<QQuickJSContext2DPixelData>();
     if (!r)
-        return QV4::Value::fromInt32(0);
-    return QV4::Value::fromInt32(r->image.width());
+        return QV4::Encode(0);
+    return QV4::Encode(r->image.width());
 }
 
 /*!
   \qmlproperty int QtQuick2::CanvasImageData::height
   Holds the actual height dimension of the data in the ImageData object, in device pixels.
   */
-QV4::Value QQuickJSContext2DImageData::method_get_height(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DImageData::method_get_height(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2DImageData *imageData = ctx->thisObject.as<QQuickJSContext2DImageData>();
     if (!imageData)
         ctx->throwTypeError();
     QQuickJSContext2DPixelData *r = imageData->pixelData.as<QQuickJSContext2DPixelData>();
     if (!r)
-        return QV4::Value::fromInt32(0);
-    return QV4::Value::fromInt32(r->image.height());
+        return QV4::Encode(0);
+    return QV4::Encode(r->image.height());
 }
 
 /*!
   \qmlproperty object QtQuick2::CanvasImageData::data
   Holds the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
  */
-QV4::Value QQuickJSContext2DImageData::method_get_data(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DImageData::method_get_data(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2DImageData *imageData = ctx->thisObject.as<QQuickJSContext2DImageData>();
     if (!imageData)
         ctx->throwTypeError();
-    return imageData->pixelData;
+    return imageData->pixelData.asReturnedValue();
 }
 
 /*!
@@ -2996,13 +2996,13 @@ QV4::Value QQuickJSContext2DImageData::method_get_data(QV4::SimpleCallContext *c
   The length attribute of a CanvasPixelArray object must return this h×w×4 number value.
   This property is read only.
 */
-QV4::Value QQuickJSContext2DPixelData::proto_get_length(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPixelData::proto_get_length(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2DPixelData *r = ctx->thisObject.as<QQuickJSContext2DPixelData>();
     if (!r || r->image.isNull())
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
-    return QV4::Value::fromInt32(r->image.width() * r->image.height() * 4);
+    return QV4::Encode(r->image.width() * r->image.height() * 4);
 }
 
 QV4::ReturnedValue QQuickJSContext2DPixelData::getIndexed(QV4::Managed *m, uint index, bool *hasProperty)
@@ -3021,18 +3021,18 @@ QV4::ReturnedValue QQuickJSContext2DPixelData::getIndexed(QV4::Managed *m, uint
         pixel += col;
         switch (index % 4) {
         case 0:
-            return QV4::Value::fromInt32(qRed(*pixel)).asReturnedValue();
+            return QV4::Encode(qRed(*pixel));
         case 1:
-            return QV4::Value::fromInt32(qGreen(*pixel)).asReturnedValue();
+            return QV4::Encode(qGreen(*pixel));
         case 2:
-            return QV4::Value::fromInt32(qBlue(*pixel)).asReturnedValue();
+            return QV4::Encode(qBlue(*pixel));
         case 3:
-            return QV4::Value::fromInt32(qAlpha(*pixel)).asReturnedValue();
+            return QV4::Encode(qAlpha(*pixel));
         }
     }
     if (hasProperty)
         *hasProperty = false;
-    return QV4::Value::undefinedValue().asReturnedValue();
+    return QV4::Encode::undefined();
 }
 
 void QQuickJSContext2DPixelData::putIndexed(QV4::Managed *m, uint index, const QV4::Value &value)
@@ -3086,7 +3086,7 @@ void QQuickJSContext2DPixelData::putIndexed(QV4::Managed *m, uint index, const Q
     \sa Canvas::loadImage(), QtQuick2::Canvas::unloadImage(),
         QtQuick2::Canvas::isImageLoaded
   */
-QV4::Value QQuickJSContext2DPrototype::method_createImageData(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_createImageData(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -3099,11 +3099,11 @@ QV4::Value QQuickJSContext2DPrototype::method_createImageData(QV4::SimpleCallCon
             if (pa) {
                 qreal w = pa->image.width();
                 qreal h = pa->image.height();
-                return qt_create_image_data(w, h, engine, QImage());
+                return qt_create_image_data(w, h, engine, QImage()).asReturnedValue();
             }
         } else if (ctx->arguments[0].isString()) {
             QImage image = r->context->createPixmap(QUrl(ctx->arguments[0].toQStringNoThrow()))->image();
-            return qt_create_image_data(image.width(), image.height(), engine, image);
+            return qt_create_image_data(image.width(), image.height(), engine, image).asReturnedValue();
         }
     } else if (ctx->argumentCount == 2) {
         qreal w = ctx->arguments[0].toNumber();
@@ -3113,18 +3113,18 @@ QV4::Value QQuickJSContext2DPrototype::method_createImageData(QV4::SimpleCallCon
             V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createImageData(): invalid arguments");
 
         if (w > 0 && h > 0)
-            return qt_create_image_data(w, h, engine, QImage());
+            return qt_create_image_data(w, h, engine, QImage()).asReturnedValue();
         else
             V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createImageData(): invalid arguments");
     }
-    return QV4::Value::undefinedValue();
+    return QV4::Encode::undefined();
 }
 
 /*!
   \qmlmethod CanvasImageData QtQuick2::Context2D::getImageData(real sx, real sy, real sw, real sh)
   Returns an CanvasImageData object containing the image data for the given rectangle of the canvas.
   */
-QV4::Value QQuickJSContext2DPrototype::method_getImageData(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_getImageData(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
@@ -3144,21 +3144,21 @@ QV4::Value QQuickJSContext2DPrototype::method_getImageData(QV4::SimpleCallContex
         QImage image = r->context->canvas()->toImage(QRectF(x, y, w, h));
         QV4::Value imageData = qt_create_image_data(w, h, engine, image);
 
-        return imageData;
+        return imageData.asReturnedValue();
     }
-    return QV4::Value::nullValue();
+    return QV4::Encode::null();
 }
 
 /*!
   \qmlmethod object QtQuick2::Context2D::putImageData(CanvasImageData imageData, real dx, real dy, real dirtyX, real dirtyY, real dirtyWidth, real dirtyHeight)
   Paints the data from the given ImageData object onto the canvas. If a dirty rectangle (\a dirtyX, \a dirtyY, \a dirtyWidth, \a dirtyHeight) is provided, only the pixels from that rectangle are painted.
   */
-QV4::Value QQuickJSContext2DPrototype::method_putImageData(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickJSContext2DPrototype::method_putImageData(QV4::SimpleCallContext *ctx)
 {
     QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
     if (ctx->argumentCount != 3 && ctx->argumentCount != 7)
-        return QV4::Value::undefinedValue();
+        return QV4::Encode::undefined();
 
     if (!ctx->arguments[0].isObject())
         V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "Context2D::putImageData, the image data type mismatch");
@@ -3172,7 +3172,7 @@ QV4::Value QQuickJSContext2DPrototype::method_putImageData(QV4::SimpleCallContex
 
     QQuickJSContext2DImageData *imageData = ctx->arguments[0].as<QQuickJSContext2DImageData>();
     if (!imageData)
-        return ctx->thisObject;
+        return ctx->thisObject.asReturnedValue();
 
     QQuickJSContext2DPixelData *pixelArray = imageData->pixelData.as<QQuickJSContext2DPixelData>();
     if (pixelArray) {
@@ -3218,7 +3218,7 @@ QV4::Value QQuickJSContext2DPrototype::method_putImageData(QV4::SimpleCallContex
             }
 
             if (dirtyWidth <=0 || dirtyHeight <= 0)
-                return ctx->thisObject;
+                return ctx->thisObject.asReturnedValue();
         } else {
             dirtyX = 0;
             dirtyY = 0;
@@ -3229,7 +3229,7 @@ QV4::Value QQuickJSContext2DPrototype::method_putImageData(QV4::SimpleCallContex
         QImage image = pixelArray->image.copy(dirtyX, dirtyY, dirtyWidth, dirtyHeight);
         r->context->buffer()->drawImage(image, QRectF(dirtyX, dirtyY, dirtyWidth, dirtyHeight), QRectF(dx, dy, dirtyWidth, dirtyHeight));
     }
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 /*!
@@ -3252,7 +3252,7 @@ QV4::Value QQuickJSContext2DPrototype::method_putImageData(QV4::SimpleCallContex
   gradient.addColorStop(0.7, 'rgba(0, 255, 255, 1');
   \endcode
   */
-QV4::Value QQuickContext2DStyle::gradient_proto_addColorStop(QV4::SimpleCallContext *ctx)
+QV4::ReturnedValue QQuickContext2DStyle::gradient_proto_addColorStop(QV4::SimpleCallContext *ctx)
 {
     QQuickContext2DStyle *style = ctx->thisObject.as<QQuickContext2DStyle>();
     if (!style)
@@ -3285,7 +3285,7 @@ QV4::Value QQuickContext2DStyle::gradient_proto_addColorStop(QV4::SimpleCallCont
         style->brush = gradient;
     }
 
-    return ctx->thisObject;
+    return ctx->thisObject.asReturnedValue();
 }
 
 void QQuickContext2D::scale(qreal x,  qreal y)