LibJS: Make Function::call() not require an Interpreter&

This makes a difference inside ScriptFunction::call(), which will now
instantiate a temporary Interpreter if one is not attached to the VM.

Author: awesomekling

Libraries/LibJS/Interpreter.cpp

@@ -44,6 +44,14 @@
 
 namespace JS {
 
+NonnullOwnPtr<Interpreter> Interpreter::create_with_existing_global_object(GlobalObject& global_object)
+{
+    DeferGC defer_gc(global_object.heap());
+    auto interpreter = adopt_own(*new Interpreter(global_object.vm()));
+    interpreter->m_global_object = make_handle(static_cast<Object*>(&global_object));
+    return interpreter;
+}
+
 Interpreter::Interpreter(VM& vm)
     : m_vm(vm)
     , m_console(*this)
@@ -84,28 +92,6 @@ const GlobalObject& Interpreter::global_object() const
     return static_cast<const GlobalObject&>(*m_global_object.cell());
 }
 
-Value Interpreter::call_internal(Function& function, Value this_value, Optional<MarkedValueList> arguments)
-{
-    ASSERT(!exception());
-
-    VM::InterpreterExecutionScope scope(*this);
-
-    auto& call_frame = vm().push_call_frame();
-    call_frame.function_name = function.name();
-    call_frame.this_value = function.bound_this().value_or(this_value);
-    call_frame.arguments = function.bound_arguments();
-    if (arguments.has_value())
-        call_frame.arguments.append(arguments.value().values());
-    call_frame.environment = function.create_environment();
-
-    ASSERT(call_frame.environment->this_binding_status() == LexicalEnvironment::ThisBindingStatus::Uninitialized);
-    call_frame.environment->bind_this_value(call_frame.this_value);
-
-    auto result = function.call(*this);
-    vm().pop_call_frame();
-    return result;
-}
-
 void Interpreter::enter_scope(const ScopeNode& scope_node, ArgumentVector arguments, ScopeType scope_type, GlobalObject& global_object)
 {
     for (auto& declaration : scope_node.functions()) {

Libraries/LibJS/Interpreter.h

@@ -58,6 +58,8 @@ class Interpreter : public Weakable<Interpreter> {
         return interpreter;
     }
 
+    static NonnullOwnPtr<Interpreter> create_with_existing_global_object(GlobalObject&);
+
     template<typename... Args>
     [[nodiscard]] ALWAYS_INLINE Value call(Function& function, Value this_value, Args... args)
     {
@@ -110,7 +112,10 @@ class Interpreter : public Weakable<Interpreter> {
 private:
     explicit Interpreter(VM&);
 
-    [[nodiscard]] Value call_internal(Function&, Value this_value, Optional<MarkedValueList>);
+    [[nodiscard]] Value call_internal(Function& function, Value this_value, Optional<MarkedValueList> arguments)
+    {
+        return vm().call(function, this_value, move(arguments));
+    }
 
     NonnullRefPtr<VM> m_vm;
 

Libraries/LibJS/Runtime/ArrayConstructor.cpp

@@ -59,15 +59,15 @@ void ArrayConstructor::initialize(GlobalObject& global_object)
     define_native_function("of", of, 0, attr);
 }
 
-Value ArrayConstructor::call(Interpreter& interpreter)
+Value ArrayConstructor::call()
 {
-    if (interpreter.argument_count() <= 0)
+    if (vm().argument_count() <= 0)
         return Array::create(global_object());
 
-    if (interpreter.argument_count() == 1 && interpreter.argument(0).is_number()) {
-        auto array_length_value = interpreter.argument(0);
+    if (vm().argument_count() == 1 && vm().argument(0).is_number()) {
+        auto array_length_value = vm().argument(0);
         if (!array_length_value.is_integer() || array_length_value.as_i32() < 0) {
-            interpreter.vm().throw_exception<TypeError>(global_object(), ErrorType::ArrayInvalidLength);
+            vm().throw_exception<TypeError>(global_object(), ErrorType::ArrayInvalidLength);
             return {};
         }
         auto* array = Array::create(global_object());
@@ -76,14 +76,14 @@ Value ArrayConstructor::call(Interpreter& interpreter)
     }
 
     auto* array = Array::create(global_object());
-    for (size_t i = 0; i < interpreter.argument_count(); ++i)
-        array->indexed_properties().append(interpreter.argument(i));
+    for (size_t i = 0; i < vm().argument_count(); ++i)
+        array->indexed_properties().append(vm().argument(i));
     return array;
 }
 
-Value ArrayConstructor::construct(Interpreter& interpreter, Function&)
+Value ArrayConstructor::construct(Interpreter&, Function&)
 {
-    return call(interpreter);
+    return call();
 }
 
 JS_DEFINE_NATIVE_FUNCTION(ArrayConstructor::from)

Libraries/LibJS/Runtime/ArrayConstructor.h

@@ -38,7 +38,7 @@ class ArrayConstructor final : public NativeFunction {
     virtual void initialize(GlobalObject&) override;
     virtual ~ArrayConstructor() override;
 
-    virtual Value call(Interpreter&) override;
+    virtual Value call() override;
     virtual Value construct(Interpreter&, Function& new_target) override;
 
 private:

Libraries/LibJS/Runtime/BigIntConstructor.cpp

@@ -54,20 +54,20 @@ BigIntConstructor::~BigIntConstructor()
 {
 }
 
-Value BigIntConstructor::call(Interpreter& interpreter)
+Value BigIntConstructor::call()
 {
-    auto primitive = interpreter.argument(0).to_primitive(interpreter, Value::PreferredType::Number);
-    if (interpreter.exception())
+    auto primitive = vm().argument(0).to_primitive(Value::PreferredType::Number);
+    if (vm().exception())
         return {};
     if (primitive.is_number()) {
         if (!primitive.is_integer()) {
-            interpreter.vm().throw_exception<RangeError>(global_object(), ErrorType::BigIntIntArgument);
+            vm().throw_exception<RangeError>(global_object(), ErrorType::BigIntIntArgument);
             return {};
         }
-        return js_bigint(interpreter, Crypto::SignedBigInteger { primitive.as_i32() });
+        return js_bigint(heap(), Crypto::SignedBigInteger { primitive.as_i32() });
     }
-    auto* bigint = interpreter.argument(0).to_bigint(interpreter);
-    if (interpreter.exception())
+    auto* bigint = vm().argument(0).to_bigint(global_object());
+    if (vm().exception())
         return {};
     return bigint;
 }

Libraries/LibJS/Runtime/BigIntConstructor.h

@@ -38,7 +38,7 @@ class BigIntConstructor final : public NativeFunction {
     virtual void initialize(GlobalObject&) override;
     virtual ~BigIntConstructor() override;
 
-    virtual Value call(Interpreter&) override;
+    virtual Value call() override;
     virtual Value construct(Interpreter&, Function& new_target) override;
 
 private:

Libraries/LibJS/Runtime/BooleanConstructor.cpp

@@ -49,9 +49,9 @@ BooleanConstructor::~BooleanConstructor()
 {
 }
 
-Value BooleanConstructor::call(Interpreter& interpreter)
+Value BooleanConstructor::call()
 {
-    return Value(interpreter.argument(0).to_boolean());
+    return Value(vm().argument(0).to_boolean());
 }
 
 Value BooleanConstructor::construct(Interpreter& interpreter, Function&)

Libraries/LibJS/Runtime/BooleanConstructor.h

@@ -38,7 +38,7 @@ class BooleanConstructor final : public NativeFunction {
     virtual void initialize(GlobalObject&) override;
     virtual ~BooleanConstructor() override;
 
-    virtual Value call(Interpreter&) override;
+    virtual Value call() override;
     virtual Value construct(Interpreter&, Function& new_target) override;
 
 private:

Libraries/LibJS/Runtime/BoundFunction.cpp

@@ -49,9 +49,9 @@ BoundFunction::~BoundFunction()
 {
 }
 
-Value BoundFunction::call(Interpreter& interpreter)
+Value BoundFunction::call()
 {
-    return m_target_function->call(interpreter);
+    return m_target_function->call();
 }
 
 Value BoundFunction::construct(Interpreter& interpreter, Function& new_target)

Libraries/LibJS/Runtime/BoundFunction.h

@@ -38,7 +38,7 @@ class BoundFunction final : public Function {
     virtual void initialize(GlobalObject&) override;
     virtual ~BoundFunction();
 
-    virtual Value call(Interpreter& interpreter) override;
+    virtual Value call() override;
 
     virtual Value construct(Interpreter&, Function& new_target) override;