LibJS: Move most of Interpreter into VM

This patch moves the exception state, call stack and scope stack from
Interpreter to VM. I'm doing this to help myself discover what the
split between Interpreter and VM should be, by shuffling things around
and seeing what falls where.

With these changes, we no longer have a persistent lexical environment
for the current global object on the Interpreter's call stack. Instead,
we push/pop that environment on Interpreter::run() enter/exit.
Since it should only be used to find the global "this", and not for
variable storage (that goes directly into the global object instead!),
I had to insert some short-circuiting when walking the environment
parent chain during variable lookup.

Note that this is a "stepping stone" commit, not a final design.

1 files changed, 283 insertions, 2 deletions

diff --git a/Libraries/LibJS/Runtime/VM.cpp b/Libraries/LibJS/Runtime/VM.cpp
index 37c7341872..9989ca9172 100644
--- a/Libraries/LibJS/Runtime/VM.cpp
+++ b/Libraries/LibJS/Runtime/VM.cpp
@@ -24,10 +24,18 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <AK/StringBuilder.h>
+#include <AK/ScopeGuard.h>
 #include <LibJS/Interpreter.h>
+#include <LibJS/Runtime/Error.h>
+#include <LibJS/Runtime/GlobalObject.h>
+#include <LibJS/Runtime/Reference.h>
+#include <LibJS/Runtime/ScriptFunction.h>
 #include <LibJS/Runtime/Symbol.h>
 #include <LibJS/Runtime/VM.h>
 
+//#define VM_DEBUG
+
 namespace JS {
 
 NonnullRefPtr<VM> VM::create()
@@ -90,8 +98,19 @@ void VM::gather_roots(HashTable<Cell*>& roots)
     roots.set(m_empty_string);
     if (m_exception)
         roots.set(m_exception);
-    for (auto* interpreter : m_interpreters)
-        interpreter->gather_roots(roots);
+
+    if (m_last_value.is_cell())
+        roots.set(m_last_value.as_cell());
+
+    for (auto& call_frame : m_call_stack) {
+        if (call_frame.this_value.is_cell())
+            roots.set(call_frame.this_value.as_cell());
+        for (auto& argument : call_frame.arguments) {
+            if (argument.is_cell())
+                roots.set(argument.as_cell());
+        }
+        roots.set(call_frame.environment);
+    }
 
 #define __JS_ENUMERATE(SymbolName, snake_name) \
     roots.set(well_known_symbol_##snake_name());
@@ -113,4 +132,266 @@ Symbol* VM::get_global_symbol(const String& description)
     return new_global_symbol;
 }
 
+bool VM::in_strict_mode() const
+{
+    if (m_scope_stack.is_empty())
+        return true;
+    return m_scope_stack.last().scope_node->in_strict_mode();
+}
+
+void VM::enter_scope(const ScopeNode& scope_node, ArgumentVector arguments, ScopeType scope_type, GlobalObject& global_object)
+{
+    for (auto& declaration : scope_node.functions()) {
+        auto* function = ScriptFunction::create(global_object, declaration.name(), declaration.body(), declaration.parameters(), declaration.function_length(), current_environment());
+        set_variable(declaration.name(), function, global_object);
+    }
+
+    if (scope_type == ScopeType::Function) {
+        m_scope_stack.append({ scope_type, scope_node, false });
+        return;
+    }
+
+    HashMap<FlyString, Variable> scope_variables_with_declaration_kind;
+    scope_variables_with_declaration_kind.ensure_capacity(16);
+
+    for (auto& declaration : scope_node.variables()) {
+        for (auto& declarator : declaration.declarations()) {
+            if (scope_node.is_program()) {
+                global_object.put(declarator.id().string(), js_undefined());
+                if (exception())
+                    return;
+            } else {
+                scope_variables_with_declaration_kind.set(declarator.id().string(), { js_undefined(), declaration.declaration_kind() });
+            }
+        }
+    }
+
+    for (auto& argument : arguments) {
+        scope_variables_with_declaration_kind.set(argument.name, { argument.value, DeclarationKind::Var });
+    }
+
+    bool pushed_lexical_environment = false;
+
+    if (!scope_variables_with_declaration_kind.is_empty()) {
+        auto* block_lexical_environment = heap().allocate<LexicalEnvironment>(global_object, move(scope_variables_with_declaration_kind), current_environment());
+        m_call_stack.last().environment = block_lexical_environment;
+        pushed_lexical_environment = true;
+    }
+
+    m_scope_stack.append({ scope_type, scope_node, pushed_lexical_environment });
+}
+
+void VM::exit_scope(const ScopeNode& scope_node)
+{
+    while (!m_scope_stack.is_empty()) {
+        auto popped_scope = m_scope_stack.take_last();
+        if (popped_scope.pushed_environment)
+            m_call_stack.last().environment = m_call_stack.last().environment->parent();
+        if (popped_scope.scope_node.ptr() == &scope_node)
+            break;
+    }
+
+    // If we unwind all the way, just reset m_unwind_until so that future "return" doesn't break.
+    if (m_scope_stack.is_empty())
+        m_unwind_until = ScopeType::None;
+}
+
+void VM::set_variable(const FlyString& name, Value value, GlobalObject& global_object, bool first_assignment)
+{
+    if (m_call_stack.size()) {
+        for (auto* environment = current_environment(); environment; environment = environment->parent()) {
+            if (environment->type() == LexicalEnvironment::EnvironmentRecordType::Global)
+                break;
+            auto possible_match = environment->get(name);
+            if (possible_match.has_value()) {
+                if (!first_assignment && possible_match.value().declaration_kind == DeclarationKind::Const) {
+                    throw_exception<TypeError>(global_object, ErrorType::InvalidAssignToConst);
+                    return;
+                }
+
+                environment->set(name, { value, possible_match.value().declaration_kind });
+                return;
+            }
+        }
+    }
+
+    global_object.put(move(name), move(value));
+}
+
+Value VM::get_variable(const FlyString& name, GlobalObject& global_object)
+{
+    if (m_call_stack.size()) {
+        for (auto* environment = current_environment(); environment; environment = environment->parent()) {
+            if (environment->type() == LexicalEnvironment::EnvironmentRecordType::Global)
+                break;
+            auto possible_match = environment->get(name);
+            if (possible_match.has_value())
+                return possible_match.value().value;
+        }
+    }
+    auto value = global_object.get(name);
+    if (m_underscore_is_last_value && name == "_" && value.is_empty())
+        return m_last_value;
+    return value;
+}
+
+Reference VM::get_reference(const FlyString& name)
+{
+    if (m_call_stack.size()) {
+        for (auto* environment = current_environment(); environment; environment = environment->parent()) {
+            if (environment->type() == LexicalEnvironment::EnvironmentRecordType::Global)
+                break;
+            auto possible_match = environment->get(name);
+            if (possible_match.has_value())
+                return { Reference::LocalVariable, name };
+        }
+    }
+    return { Reference::GlobalVariable, name };
+}
+
+Value VM::execute_statement(GlobalObject& global_object, const Statement& statement, ArgumentVector arguments, ScopeType scope_type)
+{
+    if (!statement.is_scope_node())
+        return statement.execute(interpreter(), global_object);
+
+    auto& block = static_cast<const ScopeNode&>(statement);
+    enter_scope(block, move(arguments), scope_type, global_object);
+
+    if (block.children().is_empty())
+        m_last_value = js_undefined();
+
+    for (auto& node : block.children()) {
+        m_last_value = node.execute(interpreter(), global_object);
+        if (should_unwind()) {
+            if (!block.label().is_null() && should_unwind_until(ScopeType::Breakable, block.label()))
+                stop_unwind();
+            break;
+        }
+    }
+
+    bool did_return = m_unwind_until == ScopeType::Function;
+
+    if (m_unwind_until == scope_type)
+        m_unwind_until = ScopeType::None;
+
+    exit_scope(block);
+
+    return did_return ? m_last_value : js_undefined();
+}
+
+Value VM::construct(Function& function, Function& new_target, Optional<MarkedValueList> arguments, GlobalObject& global_object)
+{
+    auto& call_frame = push_call_frame();
+
+    ArmedScopeGuard call_frame_popper = [&] {
+        pop_call_frame();
+    };
+
+    call_frame.function_name = function.name();
+    call_frame.arguments = function.bound_arguments();
+    if (arguments.has_value())
+        call_frame.arguments.append(arguments.value().values());
+    call_frame.environment = function.create_environment();
+
+    current_environment()->set_new_target(&new_target);
+
+    Object* new_object = nullptr;
+    if (function.constructor_kind() == Function::ConstructorKind::Base) {
+        new_object = Object::create_empty(global_object);
+        current_environment()->bind_this_value(new_object);
+        if (exception())
+            return {};
+        auto prototype = new_target.get("prototype");
+        if (exception())
+            return {};
+        if (prototype.is_object()) {
+            new_object->set_prototype(&prototype.as_object());
+            if (exception())
+                return {};
+        }
+    }
+
+    // If we are a Derived constructor, |this| has not been constructed before super is called.
+    Value this_value = function.constructor_kind() == Function::ConstructorKind::Base ? new_object : Value {};
+    call_frame.this_value = this_value;
+    auto result = function.construct(interpreter(), new_target);
+
+    this_value = current_environment()->get_this_binding();
+    pop_call_frame();
+    call_frame_popper.disarm();
+
+    // If we are constructing an instance of a derived class,
+    // set the prototype on objects created by constructors that return an object (i.e. NativeFunction subclasses).
+    if (function.constructor_kind() == Function::ConstructorKind::Base && new_target.constructor_kind() == Function::ConstructorKind::Derived && result.is_object()) {
+        current_environment()->replace_this_binding(result);
+        auto prototype = new_target.get("prototype");
+        if (exception())
+            return {};
+        if (prototype.is_object()) {
+            result.as_object().set_prototype(&prototype.as_object());
+            if (exception())
+                return {};
+        }
+        return result;
+    }
+
+    if (exception())
+        return {};
+
+    if (result.is_object())
+        return result;
+
+    return this_value;
+}
+
+void VM::throw_exception(Exception* exception)
+{
+#ifdef VM_DEBUG
+    if (exception->value().is_object() && exception->value().as_object().is_error()) {
+        auto& error = static_cast<Error&>(exception->value().as_object());
+        dbg() << "Throwing JavaScript Error: " << error.name() << ", " << error.message();
+
+        for (ssize_t i = m_call_stack.size() - 1; i >= 0; --i) {
+            auto function_name = m_call_stack[i].function_name;
+            if (function_name.is_empty())
+                function_name = "<anonymous>";
+            dbg() << "  " << function_name;
+        }
+    }
+#endif
+    m_exception = exception;
+    unwind(ScopeType::Try);
+}
+
+String VM::join_arguments() const
+{
+    StringBuilder joined_arguments;
+    for (size_t i = 0; i < argument_count(); ++i) {
+        joined_arguments.append(argument(i).to_string_without_side_effects().characters());
+        if (i != argument_count() - 1)
+            joined_arguments.append(' ');
+    }
+    return joined_arguments.build();
+}
+
+Value VM::resolve_this_binding() const
+{
+    return get_this_environment()->get_this_binding();
+}
+
+const LexicalEnvironment* VM::get_this_environment() const
+{
+    // We will always return because the Global environment will always be reached, which has a |this| binding.
+    for (const LexicalEnvironment* environment = current_environment(); environment; environment = environment->parent()) {
+        if (environment->has_this_binding())
+            return environment;
+    }
+    ASSERT_NOT_REACHED();
+}
+
+Value VM::get_new_target() const
+{
+    return get_this_environment()->new_target();
+}
+
 }