1 files changed, 84 insertions, 73 deletions

diff --git a/src/qml/jsruntime/qv4functionobject.cpp b/src/qml/jsruntime/qv4functionobject.cpp
index 0a12d013ac..6412e65fa9 100644
--- a/src/qml/jsruntime/qv4functionobject.cpp
+++ b/src/qml/jsruntime/qv4functionobject.cpp
@@ -37,7 +37,7 @@
 #include "qv4objectproto_p.h"
 #include "qv4stringobject_p.h"
 #include "qv4function_p.h"
-#include "qv4mm_p.h"
+#include <private/qv4mm_p.h>
 
 #include "qv4arrayobject_p.h"
 #include "qv4scopedvalue_p.h"
@@ -46,7 +46,7 @@
 #include <private/qqmljslexer_p.h>
 #include <private/qqmljsparser_p.h>
 #include <private/qqmljsast_p.h>
-#include <private/qqmlcontextwrapper_p.h>
+#include <private/qqmljavascriptexpression_p.h>
 #include <private/qqmlengine_p.h>
 #include <qv4codegen_p.h>
 #include "private/qlocale_tools_p.h"
@@ -63,7 +63,7 @@ using namespace QV4;
 DEFINE_OBJECT_VTABLE(FunctionObject);
 
 Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, QV4::String *name, bool createProto)
-    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype.asObject())
+    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype())
     , scope(scope->d())
     , function(Q_NULLPTR)
 {
@@ -73,7 +73,7 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, QV4::String *
 }
 
 Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, Function *function, bool createProto)
-    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype.asObject())
+    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype())
     , scope(scope->d())
     , function(Q_NULLPTR)
 {
@@ -84,7 +84,7 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, Function *fun
 }
 
 Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const QString &name, bool createProto)
-    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype.asObject())
+    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype())
     , scope(scope->d())
     , function(Q_NULLPTR)
 {
@@ -95,7 +95,7 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const QString
 }
 
 Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const QString &name, bool createProto)
-    : Heap::Object(scope->engine->functionClass, scope->engine->functionPrototype.asObject())
+    : Heap::Object(scope->engine->functionClass, scope->engine->functionPrototype())
     , scope(scope)
     , function(Q_NULLPTR)
 {
@@ -106,7 +106,7 @@ Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const QString &nam
 }
 
 Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const ReturnedValue name)
-    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype.asObject())
+    : Heap::Object(scope->d()->engine->functionClass, scope->d()->engine->functionPrototype())
     , scope(scope->d())
     , function(Q_NULLPTR)
 {
@@ -117,7 +117,7 @@ Heap::FunctionObject::FunctionObject(QV4::ExecutionContext *scope, const Returne
 }
 
 Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const ReturnedValue name)
-    : Heap::Object(scope->engine->functionClass, scope->engine->functionPrototype.asObject())
+    : Heap::Object(scope->engine->functionClass, scope->engine->functionPrototype())
     , scope(scope)
     , function(Q_NULLPTR)
 {
@@ -129,7 +129,7 @@ Heap::FunctionObject::FunctionObject(ExecutionContext *scope, const ReturnedValu
 
 Heap::FunctionObject::FunctionObject(InternalClass *ic, QV4::Object *prototype)
     : Heap::Object(ic, prototype)
-    , scope(ic->engine->rootContext())
+    , scope(ic->engine->rootContext()->d())
     , function(Q_NULLPTR)
 {
     Scope scope(ic->engine);
@@ -152,7 +152,7 @@ void FunctionObject::init(String *n, bool createProto)
 
     ensureMemberIndex(s.engine, Heap::FunctionObject::Index_Prototype);
     if (createProto) {
-        ScopedObject proto(s, scope()->engine->newObject(s.engine->protoClass, s.engine->objectPrototype.asObject()));
+        ScopedObject proto(s, scope()->engine->newObject(s.engine->protoClass, s.engine->objectPrototype()));
         proto->ensureMemberIndex(s.engine, Heap::FunctionObject::Index_ProtoConstructor);
         proto->memberData()->data[Heap::FunctionObject::Index_ProtoConstructor] = this->asReturnedValue();
         memberData()->data[Heap::FunctionObject::Index_Prototype] = proto.asReturnedValue();
@@ -161,12 +161,12 @@ void FunctionObject::init(String *n, bool createProto)
     }
 
     ScopedValue v(s, n);
-    defineReadonlyProperty(s.engine->id_name, v);
+    defineReadonlyProperty(s.engine->id_name(), v);
 }
 
-ReturnedValue FunctionObject::name()
+ReturnedValue FunctionObject::name() const
 {
-    return get(scope()->engine->id_name);
+    return get(scope()->engine->id_name());
 }
 
 
@@ -177,13 +177,12 @@ ReturnedValue FunctionObject::newInstance()
     return construct(callData);
 }
 
-ReturnedValue FunctionObject::construct(Managed *that, CallData *)
+ReturnedValue FunctionObject::construct(const Managed *that, CallData *)
 {
-    static_cast<FunctionObject *>(that)->internalClass()->engine->throwTypeError();
-    return Encode::undefined();
+    return static_cast<const FunctionObject *>(that)->engine()->throwTypeError();
 }
 
-ReturnedValue FunctionObject::call(Managed *, CallData *)
+ReturnedValue FunctionObject::call(const Managed *, CallData *)
 {
     return Encode::undefined();
 }
@@ -209,12 +208,12 @@ Heap::FunctionObject *FunctionObject::createScriptFunction(ExecutionContext *sco
 
 bool FunctionObject::isBinding() const
 {
-    return d()->vtable == QQmlBindingFunction::staticVTable();
+    return d()->vtable() == QQmlBindingFunction::staticVTable();
 }
 
 bool FunctionObject::isBoundFunction() const
 {
-    return d()->vtable == BoundFunction::staticVTable();
+    return d()->vtable() == BoundFunction::staticVTable();
 }
 
 QQmlSourceLocation FunctionObject::sourceLocation() const
@@ -237,10 +236,10 @@ Heap::FunctionCtor::FunctionCtor(QV4::ExecutionContext *scope)
 }
 
 // 15.3.2
-ReturnedValue FunctionCtor::construct(Managed *that, CallData *callData)
+ReturnedValue FunctionCtor::construct(const Managed *that, CallData *callData)
 {
-    Scope scope(static_cast<Object *>(that)->engine());
-    Scoped<FunctionCtor> f(scope, static_cast<FunctionCtor *>(that));
+    Scope scope(static_cast<const Object *>(that)->engine());
+    Scoped<FunctionCtor> f(scope, static_cast<const FunctionCtor *>(that));
     ScopedContext ctx(scope, scope.engine->currentContext());
     QString arguments;
     QString body;
@@ -287,7 +286,7 @@ ReturnedValue FunctionCtor::construct(Managed *that, CallData *callData)
 }
 
 // 15.3.1: This is equivalent to new Function(...)
-ReturnedValue FunctionCtor::call(Managed *that, CallData *callData)
+ReturnedValue FunctionCtor::call(const Managed *that, CallData *callData)
 {
     return construct(that, callData);
 }
@@ -304,12 +303,12 @@ void FunctionPrototype::init(ExecutionEngine *engine, Object *ctor)
     Scope scope(engine);
     ScopedObject o(scope);
 
-    ctor->defineReadonlyProperty(engine->id_length, Primitive::fromInt32(1));
-    ctor->defineReadonlyProperty(engine->id_prototype, (o = this));
+    ctor->defineReadonlyProperty(engine->id_length(), Primitive::fromInt32(1));
+    ctor->defineReadonlyProperty(engine->id_prototype(), (o = this));
 
-    defineReadonlyProperty(engine->id_length, Primitive::fromInt32(0));
+    defineReadonlyProperty(engine->id_length(), Primitive::fromInt32(0));
     defineDefaultProperty(QStringLiteral("constructor"), (o = ctor));
-    defineDefaultProperty(engine->id_toString, method_toString, 0);
+    defineDefaultProperty(engine->id_toString(), method_toString, 0);
     defineDefaultProperty(QStringLiteral("apply"), method_apply, 2);
     defineDefaultProperty(QStringLiteral("call"), method_call, 1);
     defineDefaultProperty(QStringLiteral("bind"), method_bind, 1);
@@ -318,7 +317,7 @@ void FunctionPrototype::init(ExecutionEngine *engine, Object *ctor)
 
 ReturnedValue FunctionPrototype::method_toString(CallContext *ctx)
 {
-    FunctionObject *fun = ctx->thisObject().asFunctionObject();
+    FunctionObject *fun = ctx->thisObject().as<FunctionObject>();
     if (!fun)
         return ctx->engine()->throwTypeError();
 
@@ -328,7 +327,7 @@ ReturnedValue FunctionPrototype::method_toString(CallContext *ctx)
 ReturnedValue FunctionPrototype::method_apply(CallContext *ctx)
 {
     Scope scope(ctx);
-    ScopedFunctionObject o(scope, ctx->thisObject().asFunctionObject());
+    ScopedFunctionObject o(scope, ctx->thisObject().as<FunctionObject>());
     if (!o)
         return ctx->engine()->throwTypeError();
 
@@ -370,7 +369,7 @@ ReturnedValue FunctionPrototype::method_call(CallContext *ctx)
 {
     Scope scope(ctx);
 
-    ScopedFunctionObject o(scope, ctx->thisObject().asFunctionObject());
+    ScopedFunctionObject o(scope, ctx->thisObject().as<FunctionObject>());
     if (!o)
         return ctx->engine()->throwTypeError();
 
@@ -409,15 +408,15 @@ Heap::ScriptFunction::ScriptFunction(QV4::ExecutionContext *scope, Function *fun
 {
 }
 
-ReturnedValue ScriptFunction::construct(Managed *that, CallData *callData)
+ReturnedValue ScriptFunction::construct(const Managed *that, CallData *callData)
 {
-    ExecutionEngine *v4 = static_cast<Object *>(that)->engine();
+    ExecutionEngine *v4 = static_cast<const Object *>(that)->engine();
     if (v4->hasException)
         return Encode::undefined();
     CHECK_STACK_LIMITS(v4);
 
     Scope scope(v4);
-    Scoped<ScriptFunction> f(scope, static_cast<ScriptFunction *>(that));
+    Scoped<ScriptFunction> f(scope, static_cast<const ScriptFunction *>(that));
 
     InternalClass *ic = scope.engine->emptyClass;
     ScopedObject proto(scope, f->protoForConstructor());
@@ -431,7 +430,7 @@ ReturnedValue ScriptFunction::construct(Managed *that, CallData *callData)
     ScopedValue result(scope, Q_V4_PROFILE(v4, f->function()));
 
     if (f->function()->compiledFunction->hasQmlDependencies())
-        QmlContextWrapper::registerQmlDependencies(v4, f->function()->compiledFunction);
+        QQmlPropertyCapture::registerQmlDependencies(v4, f->function()->compiledFunction);
 
     if (v4->hasException)
         return Encode::undefined();
@@ -441,15 +440,15 @@ ReturnedValue ScriptFunction::construct(Managed *that, CallData *callData)
     return obj.asReturnedValue();
 }
 
-ReturnedValue ScriptFunction::call(Managed *that, CallData *callData)
+ReturnedValue ScriptFunction::call(const Managed *that, CallData *callData)
 {
-    ExecutionEngine *v4 = static_cast<Object *>(that)->engine();
+    ExecutionEngine *v4 = static_cast<const Object *>(that)->engine();
     if (v4->hasException)
         return Encode::undefined();
     CHECK_STACK_LIMITS(v4);
 
     Scope scope(v4);
-    Scoped<ScriptFunction> f(scope, static_cast<ScriptFunction *>(that));
+    Scoped<ScriptFunction> f(scope, static_cast<const ScriptFunction *>(that));
     ScopedContext context(scope, v4->currentContext());
 
     Scoped<CallContext> ctx(scope, context->newCallContext(f, callData));
@@ -458,7 +457,7 @@ ReturnedValue ScriptFunction::call(Managed *that, CallData *callData)
     ScopedValue result(scope, Q_V4_PROFILE(v4, f->function()));
 
     if (f->function()->compiledFunction->hasQmlDependencies())
-        QmlContextWrapper::registerQmlDependencies(ctx->d()->engine, f->function()->compiledFunction);
+        QQmlPropertyCapture::registerQmlDependencies(scope.engine, f->function()->compiledFunction);
 
     return result->asReturnedValue();
 }
@@ -466,7 +465,7 @@ ReturnedValue ScriptFunction::call(Managed *that, CallData *callData)
 DEFINE_OBJECT_VTABLE(SimpleScriptFunction);
 
 Heap::SimpleScriptFunction::SimpleScriptFunction(QV4::ExecutionContext *scope, Function *function, bool createProto)
-    : Heap::FunctionObject(function->compilationUnit->engine->simpleScriptFunctionClass, function->compilationUnit->engine->functionPrototype.asObject())
+    : Heap::FunctionObject(function->compilationUnit->engine->simpleScriptFunctionClass, function->compilationUnit->engine->functionPrototype())
 {
     this->scope = scope->d();
 
@@ -481,7 +480,7 @@ Heap::SimpleScriptFunction::SimpleScriptFunction(QV4::ExecutionContext *scope, F
     if (createProto) {
         ScopedString name(s, function->name());
         f->init(name, createProto);
-        f->defineReadonlyProperty(scope->d()->engine->id_length, Primitive::fromInt32(f->formalParameterCount()));
+        f->defineReadonlyProperty(scope->d()->engine->id_length(), Primitive::fromInt32(f->formalParameterCount()));
     } else {
         f->ensureMemberIndex(s.engine, Index_Length);
         memberData->data[Index_Name] = function->name();
@@ -490,22 +489,22 @@ Heap::SimpleScriptFunction::SimpleScriptFunction(QV4::ExecutionContext *scope, F
 
     if (scope->d()->strictMode) {
         ScopedProperty pd(s);
-        pd->value = s.engine->thrower;
-        pd->set = s.engine->thrower;
-        f->insertMember(scope->d()->engine->id_caller, pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
-        f->insertMember(scope->d()->engine->id_arguments, pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
+        pd->value = s.engine->thrower();
+        pd->set = s.engine->thrower();
+        f->insertMember(scope->d()->engine->id_caller(), pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
+        f->insertMember(scope->d()->engine->id_arguments(), pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
     }
 }
 
-ReturnedValue SimpleScriptFunction::construct(Managed *that, CallData *callData)
+ReturnedValue SimpleScriptFunction::construct(const Managed *that, CallData *callData)
 {
-    ExecutionEngine *v4 = static_cast<Object *>(that)->engine();
+    ExecutionEngine *v4 = static_cast<const Object *>(that)->engine();
     if (v4->hasException)
         return Encode::undefined();
     CHECK_STACK_LIMITS(v4);
 
     Scope scope(v4);
-    Scoped<SimpleScriptFunction> f(scope, static_cast<SimpleScriptFunction *>(that));
+    Scoped<SimpleScriptFunction> f(scope, static_cast<const SimpleScriptFunction *>(that));
 
     InternalClass *ic = scope.engine->emptyClass;
     ScopedObject proto(scope, f->protoForConstructor());
@@ -514,7 +513,10 @@ ReturnedValue SimpleScriptFunction::construct(Managed *that, CallData *callData)
     ExecutionContextSaver ctxSaver(scope, v4->currentContext());
 
     CallContext::Data ctx(v4);
-    ctx.vtable = CallContext::staticVTable();
+#ifndef QT_NO_DEBUG
+    ctx.mm_data = 0; // make sure we don't run into the assertion in setVTable when allocating a context on the stack
+#endif
+    ctx.setVtable(CallContext::staticVTable());
     ctx.strictMode = f->strictMode();
     ctx.callData = callData;
     ctx.function = f->d();
@@ -529,27 +531,30 @@ ReturnedValue SimpleScriptFunction::construct(Managed *that, CallData *callData)
     ScopedObject result(scope, Q_V4_PROFILE(v4, f->function()));
 
     if (f->function()->compiledFunction->hasQmlDependencies())
-        QmlContextWrapper::registerQmlDependencies(v4, f->function()->compiledFunction);
+        QQmlPropertyCapture::registerQmlDependencies(v4, f->function()->compiledFunction);
 
     if (!result)
         return callData->thisObject.asReturnedValue();
     return result.asReturnedValue();
 }
 
-ReturnedValue SimpleScriptFunction::call(Managed *that, CallData *callData)
+ReturnedValue SimpleScriptFunction::call(const Managed *that, CallData *callData)
 {
-    ExecutionEngine *v4 = static_cast<SimpleScriptFunction *>(that)->internalClass()->engine;
+    ExecutionEngine *v4 = static_cast<const SimpleScriptFunction *>(that)->internalClass()->engine;
     if (v4->hasException)
         return Encode::undefined();
     CHECK_STACK_LIMITS(v4);
 
     Scope scope(v4);
-    Scoped<SimpleScriptFunction> f(scope, static_cast<SimpleScriptFunction *>(that));
+    Scoped<SimpleScriptFunction> f(scope, static_cast<const SimpleScriptFunction *>(that));
 
     ExecutionContextSaver ctxSaver(scope, v4->currentContext());
 
     CallContext::Data ctx(v4);
-    ctx.vtable = CallContext::staticVTable();
+#ifndef QT_NO_DEBUG
+    ctx.mm_data = 0; // make sure we don't run into the assertion in setVTable when allocating a context on the stack
+#endif
+    ctx.setVtable(CallContext::staticVTable());
     ctx.strictMode = f->strictMode();
     ctx.callData = callData;
     ctx.function = f->d();
@@ -564,7 +569,7 @@ ReturnedValue SimpleScriptFunction::call(Managed *that, CallData *callData)
     ScopedValue result(scope, Q_V4_PROFILE(v4, f->function()));
 
     if (f->function()->compiledFunction->hasQmlDependencies())
-        QmlContextWrapper::registerQmlDependencies(v4, f->function()->compiledFunction);
+        QQmlPropertyCapture::registerQmlDependencies(v4, f->function()->compiledFunction);
 
     return result->asReturnedValue();
 }
@@ -575,7 +580,7 @@ Heap::Object *SimpleScriptFunction::protoForConstructor()
     ScopedObject p(scope, protoProperty());
     if (p)
         return p->d();
-    return scope.engine->objectPrototype.asObject()->d();
+    return scope.engine->objectPrototype()->d();
 }
 
 
@@ -588,14 +593,14 @@ Heap::BuiltinFunction::BuiltinFunction(QV4::ExecutionContext *scope, QV4::String
 {
 }
 
-ReturnedValue BuiltinFunction::construct(Managed *f, CallData *)
+ReturnedValue BuiltinFunction::construct(const Managed *f, CallData *)
 {
-    return static_cast<BuiltinFunction *>(f)->internalClass()->engine->throwTypeError();
+    return static_cast<const BuiltinFunction *>(f)->internalClass()->engine->throwTypeError();
 }
 
-ReturnedValue BuiltinFunction::call(Managed *that, CallData *callData)
+ReturnedValue BuiltinFunction::call(const Managed *that, CallData *callData)
 {
-    BuiltinFunction *f = static_cast<BuiltinFunction *>(that);
+    const BuiltinFunction *f = static_cast<const BuiltinFunction *>(that);
     ExecutionEngine *v4 = f->internalClass()->engine;
     if (v4->hasException)
         return Encode::undefined();
@@ -605,7 +610,10 @@ ReturnedValue BuiltinFunction::call(Managed *that, CallData *callData)
     ExecutionContextSaver ctxSaver(scope, v4->currentContext());
 
     CallContext::Data ctx(v4);
-    ctx.vtable = CallContext::staticVTable();
+#ifndef QT_NO_DEBUG
+    ctx.mm_data = 0; // make sure we don't run into the assertion in setVTable when allocating a context on the stack
+#endif
+    ctx.setVtable(CallContext::staticVTable());
     ctx.strictMode = f->scope()->strictMode; // ### needed? scope or parent context?
     ctx.callData = callData;
     Q_ASSERT(v4->currentContext() == &ctx);
@@ -614,9 +622,9 @@ ReturnedValue BuiltinFunction::call(Managed *that, CallData *callData)
     return f->d()->code(sctx);
 }
 
-ReturnedValue IndexedBuiltinFunction::call(Managed *that, CallData *callData)
+ReturnedValue IndexedBuiltinFunction::call(const Managed *that, CallData *callData)
 {
-    IndexedBuiltinFunction *f = static_cast<IndexedBuiltinFunction *>(that);
+    const IndexedBuiltinFunction *f = static_cast<const IndexedBuiltinFunction *>(that);
     ExecutionEngine *v4 = f->internalClass()->engine;
     if (v4->hasException)
         return Encode::undefined();
@@ -626,7 +634,10 @@ ReturnedValue IndexedBuiltinFunction::call(Managed *that, CallData *callData)
     ExecutionContextSaver ctxSaver(scope, v4->currentContext());
 
     CallContext::Data ctx(v4);
-    ctx.vtable = CallContext::staticVTable();
+#ifndef QT_NO_DEBUG
+    ctx.mm_data = 0; // make sure we don't run into the assertion in setVTable when allocating a context on the stack
+#endif
+    ctx.setVtable(CallContext::staticVTable());
     ctx.strictMode = f->scope()->strictMode; // ### needed? scope or parent context?
     ctx.callData = callData;
     Q_ASSERT(v4->currentContext() == &ctx);
@@ -650,24 +661,24 @@ Heap::BoundFunction::BoundFunction(QV4::ExecutionContext *scope, QV4::FunctionOb
     Scope s(scope);
     ScopedObject f(s, this);
 
-    ScopedValue l(s, target->get(s.engine->id_length));
+    ScopedValue l(s, target->get(s.engine->id_length()));
     int len = l->toUInt32();
     if (boundArgs)
         len -= boundArgs->size();
     if (len < 0)
         len = 0;
-    f->defineReadonlyProperty(s.engine->id_length, Primitive::fromInt32(len));
+    f->defineReadonlyProperty(s.engine->id_length(), Primitive::fromInt32(len));
 
     ScopedProperty pd(s);
-    pd->value = s.engine->thrower;
-    pd->set = s.engine->thrower;
-    f->insertMember(s.engine->id_arguments, pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
-    f->insertMember(s.engine->id_caller, pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
+    pd->value = s.engine->thrower();
+    pd->set = s.engine->thrower();
+    f->insertMember(s.engine->id_arguments(), pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
+    f->insertMember(s.engine->id_caller(), pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
 }
 
-ReturnedValue BoundFunction::call(Managed *that, CallData *dd)
+ReturnedValue BoundFunction::call(const Managed *that, CallData *dd)
 {
-    BoundFunction *f = static_cast<BoundFunction *>(that);
+    const BoundFunction *f = static_cast<const BoundFunction *>(that);
     Scope scope(f->engine());
     if (scope.hasException())
         return Encode::undefined();
@@ -685,9 +696,9 @@ ReturnedValue BoundFunction::call(Managed *that, CallData *dd)
     return t->call(callData);
 }
 
-ReturnedValue BoundFunction::construct(Managed *that, CallData *dd)
+ReturnedValue BoundFunction::construct(const Managed *that, CallData *dd)
 {
-    BoundFunction *f = static_cast<BoundFunction *>(that);
+    const BoundFunction *f = static_cast<const BoundFunction *>(that);
     Scope scope(f->engine());
     if (scope.hasException())
         return Encode::undefined();