Convert builtin methods to return a ReturnedValue

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

38 files changed, 704 insertions, 669 deletions

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);
 };
 
 }