0ct0pu5/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2
ladybird/Userland/Libraries/LibJS/AST.cpp
Ali Mohammad Pur 12b283f32f LibJS: Make accessing the current function's arguments cheaper 
Instead of going through an environment record, make arguments of the
currently executing function generate references via the argument index,
which can later be resolved directly through the ExecutionContext.
2021-10-08 12:25:24 +02:00

3372 lines
121 KiB
C++
Raw Blame History

/*
* Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2020-2021, Linus Groh <linusg@serenityos.org>
* Copyright (c) 2021, David Tuin <davidot@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Demangle.h>
#include <AK/HashMap.h>
#include <AK/HashTable.h>
#include <AK/ScopeGuard.h>
#include <AK/StringBuilder.h>
#include <AK/TemporaryChange.h>
#include <LibCrypto/BigInt/SignedBigInteger.h>
#include <LibJS/AST.h>
#include <LibJS/Interpreter.h>
#include <LibJS/Runtime/AbstractOperations.h>
#include <LibJS/Runtime/Accessor.h>
#include <LibJS/Runtime/Array.h>
#include <LibJS/Runtime/BigInt.h>
#include <LibJS/Runtime/ECMAScriptFunctionObject.h>
#include <LibJS/Runtime/Error.h>
#include <LibJS/Runtime/FunctionEnvironment.h>
#include <LibJS/Runtime/GlobalObject.h>
#include <LibJS/Runtime/IteratorOperations.h>
#include <LibJS/Runtime/MarkedValueList.h>
#include <LibJS/Runtime/NativeFunction.h>
#include <LibJS/Runtime/ObjectEnvironment.h>
#include <LibJS/Runtime/PrimitiveString.h>
#include <LibJS/Runtime/Reference.h>
#include <LibJS/Runtime/RegExpObject.h>
#include <LibJS/Runtime/Shape.h>
#include <typeinfo>
namespace JS {
class InterpreterNodeScope {
AK_MAKE_NONCOPYABLE(InterpreterNodeScope);
AK_MAKE_NONMOVABLE(InterpreterNodeScope);
public:
InterpreterNodeScope(Interpreter& interpreter, ASTNode const& node)
: m_interpreter(interpreter)
, m_chain_node { nullptr, node }
{
m_interpreter.vm().running_execution_context().current_node = &node;
m_interpreter.push_ast_node(m_chain_node);
}
~InterpreterNodeScope()
{
m_interpreter.pop_ast_node();
}
private:
Interpreter& m_interpreter;
ExecutingASTNodeChain m_chain_node;
};
String ASTNode::class_name() const
{
// NOTE: We strip the "JS::" prefix.
return demangle(typeid(*this).name()).substring(4);
}
static void update_function_name(Value value, FlyString const& name)
{
if (!value.is_function())
return;
auto& function = value.as_function();
if (is<ECMAScriptFunctionObject>(function) && function.name().is_empty())
static_cast<ECMAScriptFunctionObject&>(function).set_name(name);
}
static String get_function_name(GlobalObject& global_object, Value value)
{
if (value.is_symbol())
return String::formatted("[{}]", value.as_symbol().description());
if (value.is_string())
return value.as_string().string();
return value.to_string(global_object);
}
Value ScopeNode::evaluate_statements(Interpreter& interpreter, GlobalObject& global_object) const
{
// FIXME: This should use completions but for now we just use the vm to communicate things.
auto& vm = interpreter.vm();
Value last_value;
for (auto& node : children()) {
auto value = node.execute(interpreter, global_object);
if (!value.is_empty())
last_value = value;
if (vm.should_unwind()) {
break;
}
}
return last_value;
}
Value FunctionBody::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
// Note: Scoping should have already been setup by whoever is calling this FunctionBody.
auto function_result = evaluate_statements(interpreter, global_object);
if (interpreter.exception())
return {};
if (interpreter.vm().unwind_until() != ScopeType::Function)
function_result = js_undefined();
else
interpreter.vm().stop_unwind();
return function_result;
}
// 14.2.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation
Value BlockStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto& vm = interpreter.vm();
Environment* old_environment { nullptr };
ArmedScopeGuard restore_environment = [&] {
vm.running_execution_context().lexical_environment = old_environment;
};
// Optimization: We only need a new lexical environment if there are any lexical declarations. :^)
if (has_lexical_declarations()) {
old_environment = vm.running_execution_context().lexical_environment;
auto* block_environment = new_declarative_environment(*old_environment);
block_declaration_instantiation(global_object, block_environment);
vm.running_execution_context().lexical_environment = block_environment;
} else {
restore_environment.disarm();
}
auto block_value = evaluate_statements(interpreter, global_object);
if (!labels().is_empty() && vm.should_unwind_until(ScopeType::Breakable, labels()))
vm.stop_unwind();
if (vm.exception())
return {};
return block_value;
}
Value Program::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
VERIFY(interpreter.lexical_environment() && interpreter.lexical_environment()->is_global_environment());
auto& global_env = static_cast<GlobalEnvironment&>(*interpreter.lexical_environment());
TRY_OR_DISCARD(global_declaration_instantiation(interpreter, global_object, global_env));
return evaluate_statements(interpreter, global_object);
}
Value FunctionDeclaration::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
if (m_is_hoisted) {
// Perform special annexB steps see step 3 of: https://tc39.es/ecma262/#sec-web-compat-functiondeclarationinstantiation
auto function_object = interpreter.vm().running_execution_context().lexical_environment->get_binding_value(global_object, name(), false);
interpreter.vm().running_execution_context().variable_environment->set_mutable_binding(global_object, name(), function_object, false);
VERIFY(!interpreter.exception());
}
return {};
}
Value FunctionExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
return instantiate_ordinary_function_expression(interpreter, global_object, name());
}
// 15.2.5 Runtime Semantics: InstantiateOrdinaryFunctionExpression, https://tc39.es/ecma262/#sec-runtime-semantics-instantiateordinaryfunctionexpression
Value FunctionExpression::instantiate_ordinary_function_expression(Interpreter& interpreter, GlobalObject& global_object, FlyString given_name) const
{
if (given_name.is_empty())
given_name = "";
auto has_own_name = !name().is_empty();
auto const& used_name = has_own_name ? name() : given_name;
auto* scope = interpreter.lexical_environment();
if (has_own_name) {
VERIFY(scope);
scope = new_declarative_environment(*scope);
scope->create_immutable_binding(global_object, name(), false);
}
auto closure = ECMAScriptFunctionObject::create(global_object, used_name, body(), parameters(), function_length(), scope, kind(), is_strict_mode(), might_need_arguments_object(), is_arrow_function());
// FIXME: 6. Perform SetFunctionName(closure, name).
// FIXME: 7. Perform MakeConstructor(closure).
if (has_own_name)
scope->initialize_binding(global_object, name(), closure);
return closure;
}
Value ExpressionStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
return m_expression->execute(interpreter, global_object);
}
CallExpression::ThisAndCallee CallExpression::compute_this_and_callee(Interpreter& interpreter, GlobalObject& global_object, Reference const& callee_reference) const
{
auto& vm = interpreter.vm();
if (callee_reference.is_property_reference()) {
auto this_value = callee_reference.get_this_value();
auto callee = callee_reference.get_value(global_object);
if (vm.exception())
return {};
return { this_value, callee };
}
// [[Call]] will handle that in non-strict mode the this value becomes the global object
return {
js_undefined(),
callee_reference.is_unresolvable()
? m_callee->execute(interpreter, global_object)
: callee_reference.get_value(global_object)
};
}
// 13.3.8.1 Runtime Semantics: ArgumentListEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
static void argument_list_evaluation(Interpreter& interpreter, GlobalObject& global_object, Vector<CallExpression::Argument> const& arguments, MarkedValueList& list)
{
auto& vm = global_object.vm();
list.ensure_capacity(arguments.size());
for (auto& argument : arguments) {
auto value = argument.value->execute(interpreter, global_object);
if (vm.exception())
return;
if (argument.is_spread) {
get_iterator_values(global_object, value, [&](Value iterator_value) {
if (vm.exception())
return IterationDecision::Break;
list.append(iterator_value);
return IterationDecision::Continue;
});
if (vm.exception())
return;
} else {
list.append(value);
}
}
}
Value NewExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto& vm = interpreter.vm();
auto callee_value = m_callee->execute(interpreter, global_object);
if (vm.exception())
return {};
if (!callee_value.is_function() || !callee_value.as_function().has_constructor()) {
throw_type_error_for_callee(interpreter, global_object, callee_value, "constructor"sv);
return {};
}
MarkedValueList arg_list(vm.heap());
argument_list_evaluation(interpreter, global_object, m_arguments, arg_list);
if (interpreter.exception())
return {};
auto& function = callee_value.as_function();
return vm.construct(function, function, move(arg_list));
}
void CallExpression::throw_type_error_for_callee(Interpreter& interpreter, GlobalObject& global_object, Value callee_value, StringView call_type) const
{
auto& vm = interpreter.vm();
if (is<Identifier>(*m_callee) || is<MemberExpression>(*m_callee)) {
String expression_string;
if (is<Identifier>(*m_callee)) {
expression_string = static_cast<Identifier const&>(*m_callee).string();
} else {
expression_string = static_cast<MemberExpression const&>(*m_callee).to_string_approximation();
}
vm.throw_exception<TypeError>(global_object, ErrorType::IsNotAEvaluatedFrom, callee_value.to_string_without_side_effects(), call_type, expression_string);
} else {
vm.throw_exception<TypeError>(global_object, ErrorType::IsNotA, callee_value.to_string_without_side_effects(), call_type);
}
}
Value CallExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto& vm = interpreter.vm();
auto callee_reference = m_callee->to_reference(interpreter, global_object);
if (vm.exception())
return {};
auto [this_value, callee] = compute_this_and_callee(interpreter, global_object, callee_reference);
if (vm.exception())
return {};
VERIFY(!callee.is_empty());
MarkedValueList arg_list(vm.heap());
argument_list_evaluation(interpreter, global_object, m_arguments, arg_list);
if (interpreter.exception())
return {};
if (!callee.is_function()) {
throw_type_error_for_callee(interpreter, global_object, callee, "function"sv);
return {};
}
auto& function = callee.as_function();
if (&function == global_object.eval_function()
&& callee_reference.is_environment_reference()
&& callee_reference.name().is_string()
&& callee_reference.name().as_string() == vm.names.eval.as_string()) {
auto script_value = arg_list.size() == 0 ? js_undefined() : arg_list[0];
return TRY_OR_DISCARD(perform_eval(script_value, global_object, vm.in_strict_mode() ? CallerMode::Strict : CallerMode::NonStrict, EvalMode::Direct));
}
return TRY_OR_DISCARD(vm.call(function, this_value, move(arg_list)));
}
// 13.3.7.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
// SuperCall : super Arguments
Value SuperCall::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto& vm = interpreter.vm();
// 1. Let newTarget be GetNewTarget().
auto new_target = vm.get_new_target();
if (vm.exception())
return {};
// 2. Assert: Type(newTarget) is Object.
VERIFY(new_target.is_function());
// 3. Let func be ! GetSuperConstructor().
auto* func = get_super_constructor(interpreter.vm());
VERIFY(!vm.exception());
// 4. Let argList be ? ArgumentListEvaluation of Arguments.
MarkedValueList arg_list(vm.heap());
argument_list_evaluation(interpreter, global_object, m_arguments, arg_list);
if (interpreter.exception())
return {};
// 5. If IsConstructor(func) is false, throw a TypeError exception.
if (!func || !func->value_of().is_constructor()) {
vm.throw_exception<TypeError>(global_object, ErrorType::NotAConstructor, "Super constructor");
return {};
}
// 6. Let result be ? Construct(func, argList, newTarget).
auto& function = new_target.as_function();
auto result = vm.construct(static_cast<FunctionObject&>(*func), function, move(arg_list));
if (vm.exception())
return {};
// 7. Let thisER be GetThisEnvironment().
auto& this_er = verify_cast<FunctionEnvironment>(get_this_environment(interpreter.vm()));
// 8. Perform ? thisER.BindThisValue(result).
this_er.bind_this_value(global_object, result);
if (vm.exception())
return {};
// 9. Let F be thisER.[[FunctionObject]].
// 10. Assert: F is an ECMAScript function object. (NOTE: This is implied by the strong C++ type.)
[[maybe_unused]] auto& f = this_er.function_object();
// 11. Perform ? InitializeInstanceElements(result, F).
VERIFY(result.is_object());
vm.initialize_instance_elements(result.as_object(), f);
// 12. Return result.
return result;
}
Value YieldExpression::execute(Interpreter&, GlobalObject&) const
{
// This should be transformed to a return.
VERIFY_NOT_REACHED();
}
Value ReturnStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto value = argument() ? argument()->execute(interpreter, global_object) : js_undefined();
if (interpreter.exception())
return {};
interpreter.vm().unwind(ScopeType::Function);
return value;
}
Value IfStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto predicate_result = m_predicate->execute(interpreter, global_object);
if (interpreter.exception())
return {};
if (predicate_result.to_boolean())
return m_consequent->execute(interpreter, global_object);
if (m_alternate)
return m_alternate->execute(interpreter, global_object);
return js_undefined();
}
// 14.11.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-with-statement-runtime-semantics-evaluation
// WithStatement : with ( Expression ) Statement
Value WithStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
// 1. Let value be the result of evaluating Expression.
auto value = m_object->execute(interpreter, global_object);
if (interpreter.exception())
return {};
// 2. Let obj be ? ToObject(? GetValue(value)).
auto* object = value.to_object(global_object);
if (interpreter.exception())
return {};
// 3. Let oldEnv be the running execution context's LexicalEnvironment.
auto* old_environment = interpreter.vm().running_execution_context().lexical_environment;
// 4. Let newEnv be NewObjectEnvironment(obj, true, oldEnv).
auto* new_environment = new_object_environment(*object, true, old_environment);
if (interpreter.exception())
return {};
// 5. Set the running execution context's LexicalEnvironment to newEnv.
interpreter.vm().running_execution_context().lexical_environment = new_environment;
// 6. Let C be the result of evaluating Statement.
auto result = m_body->execute(interpreter, global_object).value_or(js_undefined());
// 7. Set the running execution context's LexicalEnvironment to oldEnv.
interpreter.vm().running_execution_context().lexical_environment = old_environment;
if (interpreter.exception())
return {};
// 8. Return Completion(UpdateEmpty(C, undefined)).
return result;
}
Value WhileStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto last_value = js_undefined();
for (;;) {
auto test_result = m_test->execute(interpreter, global_object);
if (interpreter.exception())
return {};
if (!test_result.to_boolean())
break;
last_value = m_body->execute(interpreter, global_object).value_or(last_value);
if (interpreter.exception())
return {};
if (interpreter.vm().should_unwind()) {
if (interpreter.vm().should_unwind_until(ScopeType::Continuable, m_labels)) {
interpreter.vm().stop_unwind();
} else if (interpreter.vm().should_unwind_until(ScopeType::Breakable, m_labels)) {
interpreter.vm().stop_unwind();
break;
} else {
return last_value;
}
}
}
return last_value;
}
Value DoWhileStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto last_value = js_undefined();
for (;;) {
if (interpreter.exception())
return {};
last_value = m_body->execute(interpreter, global_object).value_or(last_value);
if (interpreter.exception())
return {};
if (interpreter.vm().should_unwind()) {
if (interpreter.vm().should_unwind_until(ScopeType::Continuable, m_labels)) {
interpreter.vm().stop_unwind();
} else if (interpreter.vm().should_unwind_until(ScopeType::Breakable, m_labels)) {
interpreter.vm().stop_unwind();
break;
} else {
return last_value;
}
}
auto test_result = m_test->execute(interpreter, global_object);
if (interpreter.exception())
return {};
if (!test_result.to_boolean())
break;
}
return last_value;
}
Value ForStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
// Note we don't always set a new environment but to use RAII we must do this here.
auto* old_environment = interpreter.lexical_environment();
ScopeGuard restore_old_environment = [&] {
interpreter.vm().running_execution_context().lexical_environment = old_environment;
};
Vector<FlyString> let_declarations;
if (m_init) {
if (is<VariableDeclaration>(*m_init) && static_cast<VariableDeclaration const&>(*m_init).declaration_kind() != DeclarationKind::Var) {
auto* loop_environment = new_declarative_environment(*old_environment);
auto& declaration = static_cast<VariableDeclaration const&>(*m_init);
declaration.for_each_bound_name([&](auto const& name) {
if (declaration.declaration_kind() == DeclarationKind::Const) {
loop_environment->create_immutable_binding(global_object, name, true);
} else {
loop_environment->create_mutable_binding(global_object, name, false);
let_declarations.append(name);
}
return IterationDecision::Continue;
});
interpreter.vm().running_execution_context().lexical_environment = loop_environment;
}
m_init->execute(interpreter, global_object);
if (interpreter.exception())
return {};
}
auto last_value = js_undefined();
// 14.7.4.4 CreatePerIterationEnvironment ( perIterationBindings ), https://tc39.es/ecma262/#sec-createperiterationenvironment
auto create_per_iteration_environment = [&]() -> ThrowCompletionOr<void> {
if (let_declarations.is_empty())
return {};
auto* last_iteration_env = interpreter.lexical_environment();
auto* outer = last_iteration_env->outer_environment();
VERIFY(outer);
auto* this_iteration_env = new_declarative_environment(*outer);
for (auto& name : let_declarations) {
this_iteration_env->create_mutable_binding(global_object, name, false);
auto last_value = last_iteration_env->get_binding_value(global_object, name, true);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
VERIFY(!last_value.is_empty());
this_iteration_env->initialize_binding(global_object, name, last_value);
}
interpreter.vm().running_execution_context().lexical_environment = this_iteration_env;
return {};
};
TRY_OR_DISCARD(create_per_iteration_environment());
auto test_empty_or_true = [&] {
if (!m_test)
return true;
auto test_result = m_test->execute(interpreter, global_object);
if (interpreter.exception())
return false;
return test_result.to_boolean();
};
while (true) {
if (!test_empty_or_true())
break;
last_value = m_body->execute(interpreter, global_object).value_or(last_value);
if (interpreter.exception())
return {};
if (interpreter.vm().should_unwind()) {
if (interpreter.vm().should_unwind_until(ScopeType::Continuable, m_labels)) {
interpreter.vm().stop_unwind();
} else if (interpreter.vm().should_unwind_until(ScopeType::Breakable, m_labels)) {
interpreter.vm().stop_unwind();
break;
} else {
return last_value;
}
}
TRY_OR_DISCARD(create_per_iteration_environment());
if (m_update) {
m_update->execute(interpreter, global_object);
if (interpreter.exception())
return {};
}
}
if (interpreter.exception())
return {};
return last_value;
}
struct ForInOfHeadState {
explicit ForInOfHeadState(Variant<NonnullRefPtr<ASTNode>, NonnullRefPtr<BindingPattern>> lhs)
{
lhs.visit(
[&](NonnullRefPtr<ASTNode>& ast_node) {
expression_lhs = ast_node.ptr();
},
[&](NonnullRefPtr<BindingPattern>& pattern) {
pattern_lhs = pattern.ptr();
destructuring = true;
lhs_kind = Assignment;
});
}
ASTNode* expression_lhs = nullptr;
BindingPattern* pattern_lhs = nullptr;
enum LhsKind {
Assignment,
VarBinding,
LexicalBinding
};
LhsKind lhs_kind = Assignment;
bool destructuring = false;
Value rhs_value;
// 14.7.5.7 ForIn/OfBodyEvaluation ( lhs, stmt, iteratorRecord, iterationKind, lhsKind, labelSet [ , iteratorKind ] ), https://tc39.es/ecma262/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset
// Note: This is only steps 6.g through 6.j of the method because we currently implement for-in without an iterator so to prevent duplicated code we do this part here.
ThrowCompletionOr<void> execute_head(Interpreter& interpreter, GlobalObject& global_object, Value next_value) const
{
VERIFY(!next_value.is_empty());
Optional<Reference> lhs_reference;
Environment* iteration_environment = nullptr;
// g. If lhsKind is either assignment or varBinding, then
if (lhs_kind == Assignment || lhs_kind == VarBinding) {
if (!destructuring) {
VERIFY(expression_lhs);
if (is<VariableDeclaration>(*expression_lhs)) {
auto& declaration = static_cast<VariableDeclaration const&>(*expression_lhs);
VERIFY(declaration.declarations().first().target().has<NonnullRefPtr<Identifier>>());
lhs_reference = declaration.declarations().first().target().get<NonnullRefPtr<Identifier>>()->to_reference(interpreter, global_object);
} else {
VERIFY(is<Identifier>(*expression_lhs) || is<MemberExpression>(*expression_lhs));
auto& expression = static_cast<Expression const&>(*expression_lhs);
lhs_reference = expression.to_reference(interpreter, global_object);
}
}
}
// h. Else,
else {
VERIFY(expression_lhs && is<VariableDeclaration>(*expression_lhs));
iteration_environment = new_declarative_environment(*interpreter.lexical_environment());
auto& for_declaration = static_cast<VariableDeclaration const&>(*expression_lhs);
for_declaration.for_each_bound_name([&](auto const& name) {
if (for_declaration.declaration_kind() == DeclarationKind::Const)
iteration_environment->create_immutable_binding(global_object, name, false);
else
iteration_environment->create_mutable_binding(global_object, name, true);
});
interpreter.vm().running_execution_context().lexical_environment = iteration_environment;
if (!destructuring) {
VERIFY(for_declaration.declarations().first().target().has<NonnullRefPtr<Identifier>>());
lhs_reference = interpreter.vm().resolve_binding(for_declaration.declarations().first().target().get<NonnullRefPtr<Identifier>>()->string());
}
}
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
// i. If destructuring is false, then
if (!destructuring) {
VERIFY(lhs_reference.has_value());
if (lhs_kind == LexicalBinding)
lhs_reference->initialize_referenced_binding(global_object, next_value);
else
lhs_reference->put_value(global_object, next_value);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
return {};
}
// j. Else,
if (lhs_kind == Assignment) {
VERIFY(pattern_lhs);
return interpreter.vm().destructuring_assignment_evaluation(*pattern_lhs, next_value, global_object);
}
VERIFY(expression_lhs && is<VariableDeclaration>(*expression_lhs));
auto& for_declaration = static_cast<VariableDeclaration const&>(*expression_lhs);
auto& binding_pattern = for_declaration.declarations().first().target().get<NonnullRefPtr<BindingPattern>>();
VERIFY(lhs_kind == VarBinding || iteration_environment);
// At this point iteration_environment is undefined if lhs_kind == VarBinding which means this does both
// branch j.ii and j.iii because ForBindingInitialization is just a forwarding call to BindingInitialization.
return interpreter.vm().binding_initialization(binding_pattern, next_value, iteration_environment, global_object);
}
};
// 14.7.5.5 Runtime Semantics: ForInOfLoopEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
// 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
// This method combines ForInOfLoopEvaluation and ForIn/OfHeadEvaluation for similar reason as ForIn/OfBodyEvaluation, to prevent code duplication.
// For the same reason we also skip step 6 and 7 of ForIn/OfHeadEvaluation as this is done by the appropriate for loop type.
static ThrowCompletionOr<ForInOfHeadState> for_in_of_head_execute(Interpreter& interpreter, GlobalObject& global_object, Variant<NonnullRefPtr<ASTNode>, NonnullRefPtr<BindingPattern>> lhs, Expression const& rhs)
{
ForInOfHeadState state(lhs);
if (auto* ast_ptr = lhs.get_pointer<NonnullRefPtr<ASTNode>>(); ast_ptr && is<VariableDeclaration>(*(*ast_ptr))) {
// Runtime Semantics: ForInOfLoopEvaluation, for any of:
// ForInOfStatement : for ( var ForBinding in Expression ) Statement
// ForInOfStatement : for ( ForDeclaration in Expression ) Statement
// ForInOfStatement : for ( var ForBinding of AssignmentExpression ) Statement
// ForInOfStatement : for ( ForDeclaration of AssignmentExpression ) Statement
// 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
Environment* new_environment = nullptr;
auto& variable_declaration = static_cast<VariableDeclaration const&>(*(*ast_ptr));
VERIFY(variable_declaration.declarations().size() == 1);
state.destructuring = variable_declaration.declarations().first().target().has<NonnullRefPtr<BindingPattern>>();
if (variable_declaration.declaration_kind() == DeclarationKind::Var) {
state.lhs_kind = ForInOfHeadState::VarBinding;
auto& variable = variable_declaration.declarations().first();
// B.3.5 Initializers in ForIn Statement Heads, https://tc39.es/ecma262/#sec-initializers-in-forin-statement-heads
if (variable.init()) {
VERIFY(variable.target().has<NonnullRefPtr<Identifier>>());
auto& binding_id = variable.target().get<NonnullRefPtr<Identifier>>()->string();
auto reference = interpreter.vm().resolve_binding(binding_id);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
auto result = TRY(interpreter.vm().named_evaluation_if_anonymous_function(global_object, *variable.init(), binding_id));
reference.put_value(global_object, result);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
}
} else {
state.lhs_kind = ForInOfHeadState::LexicalBinding;
new_environment = new_declarative_environment(*interpreter.lexical_environment());
variable_declaration.for_each_bound_name([&](auto const& name) {
new_environment->create_mutable_binding(global_object, name, false);
});
}
if (new_environment) {
// 2.d Set the running execution context's LexicalEnvironment to newEnv.
TemporaryChange<Environment*> scope_change(interpreter.vm().running_execution_context().lexical_environment, new_environment);
// 3. Let exprRef be the result of evaluating expr.
// 5. Let exprValue be ? GetValue(exprRef).
state.rhs_value = rhs.execute(interpreter, global_object);
// Note that since a reference stores it's environment it doesn't matter we only reset
// this after step 5. (Also we have no way of separating these steps at this point)
// 4. Set the running execution context's LexicalEnvironment to oldEnv.
} else {
// 3. Let exprRef be the result of evaluating expr.
// 5. Let exprValue be ? GetValue(exprRef).
state.rhs_value = rhs.execute(interpreter, global_object);
}
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
return state;
}
// Runtime Semantics: ForInOfLoopEvaluation, for any of:
// ForInOfStatement : for ( LeftHandSideExpression in Expression ) Statement
// ForInOfStatement : for ( LeftHandSideExpression of AssignmentExpression ) Statement
// 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
// We can skip step 1, 2 and 4 here (on top of already skipping step 6 and 7).
// 3. Let exprRef be the result of evaluating expr.
// 5. Let exprValue be ? GetValue(exprRef).
state.rhs_value = rhs.execute(interpreter, global_object);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
return state;
}
Value ForInStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto for_in_head_state = TRY_OR_DISCARD(for_in_of_head_execute(interpreter, global_object, m_lhs, *m_rhs));
auto rhs_result = for_in_head_state.rhs_value;
// 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
if (rhs_result.is_nullish())
return js_undefined();
auto* object = rhs_result.to_object(global_object);
VERIFY(object);
// 14.7.5.7 ForIn/OfBodyEvaluation ( lhs, stmt, iteratorRecord, iterationKind, lhsKind, labelSet [ , iteratorKind ] ), https://tc39.es/ecma262/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset
Environment* old_environment = interpreter.lexical_environment();
auto restore_scope = ScopeGuard([&] {
interpreter.vm().running_execution_context().lexical_environment = old_environment;
});
auto last_value = js_undefined();
while (object) {
auto property_names = TRY_OR_DISCARD(object->enumerable_own_property_names(Object::PropertyKind::Key));
for (auto& value : property_names) {
TRY_OR_DISCARD(for_in_head_state.execute_head(interpreter, global_object, value));
last_value = m_body->execute(interpreter, global_object).value_or(last_value);
interpreter.vm().running_execution_context().lexical_environment = old_environment;
if (interpreter.exception())
return {};
if (interpreter.vm().should_unwind()) {
if (interpreter.vm().should_unwind_until(ScopeType::Continuable, m_labels)) {
interpreter.vm().stop_unwind();
} else if (interpreter.vm().should_unwind_until(ScopeType::Breakable, m_labels)) {
interpreter.vm().stop_unwind();
break;
} else {
return last_value;
}
}
}
object = TRY_OR_DISCARD(object->internal_get_prototype_of());
}
return last_value;
}
Value ForOfStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto for_of_head_state = TRY_OR_DISCARD(for_in_of_head_execute(interpreter, global_object, m_lhs, m_rhs));
auto rhs_result = for_of_head_state.rhs_value;
auto last_value = js_undefined();
// 14.7.5.7 ForIn/OfBodyEvaluation ( lhs, stmt, iteratorRecord, iterationKind, lhsKind, labelSet [ , iteratorKind ] ), https://tc39.es/ecma262/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset
// We use get_iterator_values which behaves like ForIn/OfBodyEvaluation with iteratorKind iterate.
Environment* old_environment = interpreter.lexical_environment();
auto restore_scope = ScopeGuard([&] {
interpreter.vm().running_execution_context().lexical_environment = old_environment;
});
get_iterator_values(global_object, rhs_result, [&](Value value) {
auto result = for_of_head_state.execute_head(interpreter, global_object, value);
if (result.is_error())
return IterationDecision::Break;
last_value = m_body->execute(interpreter, global_object).value_or(last_value);
interpreter.vm().running_execution_context().lexical_environment = old_environment;
if (interpreter.exception())
return IterationDecision::Break;
if (interpreter.vm().should_unwind()) {
if (interpreter.vm().should_unwind_until(ScopeType::Continuable, m_labels)) {
interpreter.vm().stop_unwind();
} else if (interpreter.vm().should_unwind_until(ScopeType::Breakable, m_labels)) {
interpreter.vm().stop_unwind();
return IterationDecision::Break;
} else {
return IterationDecision::Break;
}
}
return IterationDecision::Continue;
});
if (interpreter.exception())
return {};
return last_value;
}
Value BinaryExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto lhs_result = m_lhs->execute(interpreter, global_object);
if (interpreter.exception())
return {};
auto rhs_result = m_rhs->execute(interpreter, global_object);
if (interpreter.exception())
return {};
switch (m_op) {
case BinaryOp::Addition:
return add(global_object, lhs_result, rhs_result);
case BinaryOp::Subtraction:
return sub(global_object, lhs_result, rhs_result);
case BinaryOp::Multiplication:
return mul(global_object, lhs_result, rhs_result);
case BinaryOp::Division:
return div(global_object, lhs_result, rhs_result);
case BinaryOp::Modulo:
return mod(global_object, lhs_result, rhs_result);
case BinaryOp::Exponentiation:
return exp(global_object, lhs_result, rhs_result);
case BinaryOp::StrictlyEquals:
return Value(is_strictly_equal(lhs_result, rhs_result));
case BinaryOp::StrictlyInequals:
return Value(!is_strictly_equal(lhs_result, rhs_result));
case BinaryOp::LooselyEquals:
return Value(is_loosely_equal(global_object, lhs_result, rhs_result));
case BinaryOp::LooselyInequals:
return Value(!is_loosely_equal(global_object, lhs_result, rhs_result));
case BinaryOp::GreaterThan:
return greater_than(global_object, lhs_result, rhs_result);
case BinaryOp::GreaterThanEquals:
return greater_than_equals(global_object, lhs_result, rhs_result);
case BinaryOp::LessThan:
return less_than(global_object, lhs_result, rhs_result);
case BinaryOp::LessThanEquals:
return less_than_equals(global_object, lhs_result, rhs_result);
case BinaryOp::BitwiseAnd:
return bitwise_and(global_object, lhs_result, rhs_result);
case BinaryOp::BitwiseOr:
return bitwise_or(global_object, lhs_result, rhs_result);
case BinaryOp::BitwiseXor:
return bitwise_xor(global_object, lhs_result, rhs_result);
case BinaryOp::LeftShift:
return left_shift(global_object, lhs_result, rhs_result);
case BinaryOp::RightShift:
return right_shift(global_object, lhs_result, rhs_result);
case BinaryOp::UnsignedRightShift:
return unsigned_right_shift(global_object, lhs_result, rhs_result);
case BinaryOp::In:
return in(global_object, lhs_result, rhs_result);
case BinaryOp::InstanceOf:
return instance_of(global_object, lhs_result, rhs_result);
}
VERIFY_NOT_REACHED();
}
Value LogicalExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto lhs_result = m_lhs->execute(interpreter, global_object);
if (interpreter.exception())
return {};
switch (m_op) {
case LogicalOp::And:
if (lhs_result.to_boolean()) {
auto rhs_result = m_rhs->execute(interpreter, global_object);
if (interpreter.exception())
return {};
return rhs_result;
}
return lhs_result;
case LogicalOp::Or: {
if (lhs_result.to_boolean())
return lhs_result;
auto rhs_result = m_rhs->execute(interpreter, global_object);
if (interpreter.exception())
return {};
return rhs_result;
}
case LogicalOp::NullishCoalescing:
if (lhs_result.is_nullish()) {
auto rhs_result = m_rhs->execute(interpreter, global_object);
if (interpreter.exception())
return {};
return rhs_result;
}
return lhs_result;
}
VERIFY_NOT_REACHED();
}
Reference Expression::to_reference(Interpreter&, GlobalObject&) const
{
return {};
}
Reference Identifier::to_reference(Interpreter& interpreter, GlobalObject&) const
{
if (m_cached_environment_coordinate.has_value()) {
auto* environment = interpreter.vm().running_execution_context().lexical_environment;
for (size_t i = 0; i < m_cached_environment_coordinate->hops; ++i)
environment = environment->outer_environment();
VERIFY(environment);
VERIFY(environment->is_declarative_environment());
if (!environment->is_permanently_screwed_by_eval()) {
if (m_lexically_bound_function_argument.has_value()) {
return Reference {
*environment,
string(),
*m_lexically_bound_function_argument,
interpreter.vm().in_strict_mode(),
m_cached_environment_coordinate,
&interpreter.vm().running_execution_context(),
};
}
return Reference { *environment, string(), interpreter.vm().in_strict_mode(), m_cached_environment_coordinate };
}
m_cached_environment_coordinate = {};
}
if (m_lexically_bound_function_argument.has_value()) {
return Reference {
string(),
*m_lexically_bound_function_argument,
interpreter.vm().in_strict_mode(),
&interpreter.vm().running_execution_context(),
};
}
auto reference = interpreter.vm().resolve_binding(string());
if (reference.environment_coordinate().has_value())
m_cached_environment_coordinate = reference.environment_coordinate();
return reference;
}
Reference MemberExpression::to_reference(Interpreter& interpreter, GlobalObject& global_object) const
{
// 13.3.7.1 Runtime Semantics: Evaluation
// SuperProperty : super [ Expression ]
// SuperProperty : super . IdentifierName
// https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
if (is<SuperExpression>(object())) {
// 1. Let env be GetThisEnvironment().
auto& environment = get_this_environment(interpreter.vm());
// 2. Let actualThis be ? env.GetThisBinding().
auto actual_this = environment.get_this_binding(global_object);
StringOrSymbol property_key;
if (is_computed()) {
// SuperProperty : super [ Expression ]
// 3. Let propertyNameReference be the result of evaluating Expression.
// 4. Let propertyNameValue be ? GetValue(propertyNameReference).
auto property_name_value = m_property->execute(interpreter, global_object);
if (interpreter.exception())
return {};
// 5. Let propertyKey be ? ToPropertyKey(propertyNameValue).
property_key = property_name_value.to_property_key(global_object);
} else {
// SuperProperty : super . IdentifierName
// 3. Let propertyKey be StringValue of IdentifierName.
VERIFY(is<Identifier>(property()));
property_key = static_cast<Identifier const&>(property()).string();
}
// 6. If the code matched by this SuperProperty is strict mode code, let strict be true; else let strict be false.
bool strict = interpreter.vm().in_strict_mode();
// 7. Return ? MakeSuperPropertyReference(actualThis, propertyKey, strict).
return TRY_OR_DISCARD(make_super_property_reference(global_object, actual_this, property_key, strict));
}
auto base_reference = m_object->to_reference(interpreter, global_object);
if (interpreter.exception())
return {};
Value base_value;
if (base_reference.is_valid_reference())
base_value = base_reference.get_value(global_object);
else
base_value = m_object->execute(interpreter, global_object);
if (interpreter.exception())
return {};
VERIFY(!base_value.is_empty());
// From here on equivalent to
// 13.3.4 EvaluatePropertyAccessWithIdentifierKey ( baseValue, identifierName, strict ), https://tc39.es/ecma262/#sec-evaluate-property-access-with-identifier-key
PropertyName property_name;
if (is_computed()) {
// Weird order which I can't quite find from the specs.
auto value = m_property->execute(interpreter, global_object);
if (interpreter.exception())
return Reference {};
TRY_OR_DISCARD(require_object_coercible(global_object, base_value));
VERIFY(!value.is_empty());
property_name = PropertyName::from_value(global_object, value);
if (interpreter.exception())
return Reference {};
} else {
property_name = verify_cast<Identifier>(*m_property).string();
TRY_OR_DISCARD(require_object_coercible(global_object, base_value));
}
if (!property_name.is_valid())
return Reference {};
auto strict = interpreter.vm().in_strict_mode();
return Reference { base_value, move(property_name), {}, strict };
}
Value UnaryExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto& vm = interpreter.vm();
if (m_op == UnaryOp::Delete) {
auto reference = m_lhs->to_reference(interpreter, global_object);
if (interpreter.exception())
return {};
return Value(reference.delete_(global_object));
}
Value lhs_result;
if (m_op == UnaryOp::Typeof && is<Identifier>(*m_lhs)) {
auto reference = m_lhs->to_reference(interpreter, global_object);
if (interpreter.exception())
return {};
if (reference.is_unresolvable()) {
lhs_result = js_undefined();
} else {
lhs_result = reference.get_value(global_object);
if (interpreter.exception())
return {};
}
VERIFY(!lhs_result.is_empty());
} else {
lhs_result = m_lhs->execute(interpreter, global_object);
if (interpreter.exception())
return {};
}
switch (m_op) {
case UnaryOp::BitwiseNot:
return bitwise_not(global_object, lhs_result);
case UnaryOp::Not:
return Value(!lhs_result.to_boolean());
case UnaryOp::Plus:
return unary_plus(global_object, lhs_result);
case UnaryOp::Minus:
return unary_minus(global_object, lhs_result);
case UnaryOp::Typeof:
return js_string(vm, lhs_result.typeof());
case UnaryOp::Void:
return js_undefined();
case UnaryOp::Delete:
VERIFY_NOT_REACHED();
}
VERIFY_NOT_REACHED();
}
Value SuperExpression::execute(Interpreter&, GlobalObject&) const
{
// The semantics for SuperExpression are handled in CallExpression and SuperCall.
VERIFY_NOT_REACHED();
}
Value ClassMethod::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
return m_function->execute(interpreter, global_object);
}
Value ClassField::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
return {};
}
Value ClassExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
// FIXME: Set value.[[SourceText]] to the source text matched by ClassExpression.
return TRY_OR_DISCARD(class_definition_evaluation(interpreter, global_object, m_name, m_name.is_null() ? "" : m_name));
}
Value ClassDeclaration::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto name = m_class_expression->name();
VERIFY(!name.is_empty());
auto class_constructor = TRY_OR_DISCARD(m_class_expression->class_definition_evaluation(interpreter, global_object, name, name));
if (interpreter.lexical_environment()) {
interpreter.lexical_environment()->initialize_binding(global_object, name, class_constructor);
} else {
auto reference = interpreter.vm().resolve_binding(name);
reference.put_value(global_object, class_constructor);
if (interpreter.exception())
return {};
}
return {};
}
// 15.7.14 Runtime Semantics: ClassDefinitionEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-classdefinitionevaluation
ThrowCompletionOr<Value> ClassExpression::class_definition_evaluation(Interpreter& interpreter, GlobalObject& global_object, FlyString const& binding_name, FlyString const& class_name) const
{
auto& vm = interpreter.vm();
auto* environment = vm.lexical_environment();
VERIFY(environment);
auto* class_scope = new_declarative_environment(*environment);
if (!binding_name.is_null())
class_scope->create_immutable_binding(global_object, binding_name, true);
ArmedScopeGuard restore_environment = [&] {
vm.running_execution_context().lexical_environment = environment;
};
vm.running_execution_context().lexical_environment = class_scope;
Value class_constructor_value = m_constructor->execute(interpreter, global_object);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
update_function_name(class_constructor_value, class_name);
VERIFY(class_constructor_value.is_function() && is<ECMAScriptFunctionObject>(class_constructor_value.as_function()));
auto* class_constructor = static_cast<ECMAScriptFunctionObject*>(&class_constructor_value.as_function());
class_constructor->set_is_class_constructor();
Value super_constructor = js_undefined();
if (!m_super_class.is_null()) {
super_constructor = m_super_class->execute(interpreter, global_object);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
if (!super_constructor.is_function() && !super_constructor.is_null())
return interpreter.vm().throw_completion<TypeError>(global_object, ErrorType::ClassExtendsValueNotAConstructorOrNull, super_constructor.to_string_without_side_effects());
class_constructor->set_constructor_kind(ECMAScriptFunctionObject::ConstructorKind::Derived);
Object* super_constructor_prototype = nullptr;
if (!super_constructor.is_null()) {
auto super_constructor_prototype_value = TRY(super_constructor.as_object().get(vm.names.prototype));
if (!super_constructor_prototype_value.is_object() && !super_constructor_prototype_value.is_null())
return interpreter.vm().throw_completion<TypeError>(global_object, ErrorType::ClassExtendsValueInvalidPrototype, super_constructor_prototype_value.to_string_without_side_effects());
if (super_constructor_prototype_value.is_object())
super_constructor_prototype = &super_constructor_prototype_value.as_object();
}
auto* prototype = Object::create(global_object, super_constructor_prototype);
prototype->define_direct_property(vm.names.constructor, class_constructor, 0);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
class_constructor->define_direct_property(vm.names.prototype, prototype, Attribute::Writable);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
TRY(class_constructor->internal_set_prototype_of(super_constructor.is_null() ? global_object.function_prototype() : &super_constructor.as_object()));
}
auto class_prototype = TRY(class_constructor->get(vm.names.prototype));
if (!class_prototype.is_object())
return interpreter.vm().throw_completion<TypeError>(global_object, ErrorType::NotAnObject, "Class prototype");
for (auto const& method : m_methods) {
auto method_value = method.execute(interpreter, global_object);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
auto& method_function = static_cast<ECMAScriptFunctionObject&>(method_value.as_function());
auto key = method.key().execute(interpreter, global_object);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
auto property_key = key.to_property_key(global_object);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
auto& target = method.is_static() ? *class_constructor : class_prototype.as_object();
method_function.set_home_object(&target);
switch (method.kind()) {
case ClassMethod::Kind::Method:
TRY(target.define_property_or_throw(property_key, { .value = method_value, .writable = true, .enumerable = false, .configurable = true }));
break;
case ClassMethod::Kind::Getter:
update_function_name(method_value, String::formatted("get {}", get_function_name(global_object, key)));
TRY(target.define_property_or_throw(property_key, { .get = &method_function, .enumerable = true, .configurable = true }));
break;
case ClassMethod::Kind::Setter:
update_function_name(method_value, String::formatted("set {}", get_function_name(global_object, key)));
TRY(target.define_property_or_throw(property_key, { .set = &method_function, .enumerable = true, .configurable = true }));
break;
default:
VERIFY_NOT_REACHED();
}
}
for (auto& field : m_fields) {
auto key = field.key().execute(interpreter, global_object);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
auto property_key = key.to_property_key(global_object);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
ECMAScriptFunctionObject* initializer = nullptr;
if (field.initializer()) {
auto copy_initializer = field.initializer();
auto body = create_ast_node<ExpressionStatement>(field.initializer()->source_range(), copy_initializer.release_nonnull());
// FIXME: A potential optimization is not creating the functions here since these are never directly accessible.
initializer = ECMAScriptFunctionObject::create(interpreter.global_object(), property_key.to_display_string(), *body, {}, 0, interpreter.lexical_environment(), FunctionKind::Regular, false, false);
initializer->set_home_object(field.is_static() ? class_constructor : &class_prototype.as_object());
}
if (field.is_static()) {
Value field_value = js_undefined();
if (initializer)
field_value = TRY(interpreter.vm().call(*initializer, class_constructor_value));
TRY(class_constructor->create_data_property_or_throw(property_key, field_value));
} else {
class_constructor->add_field(property_key, initializer);
}
}
vm.running_execution_context().lexical_environment = environment;
restore_environment.disarm();
if (!binding_name.is_null())
class_scope->initialize_binding(global_object, binding_name, class_constructor);
return Value(class_constructor);
}
static void print_indent(int indent)
{
out("{}", String::repeated(' ', indent * 2));
}
void ASTNode::dump(int indent) const
{
print_indent(indent);
outln("{}", class_name());
}
void ScopeNode::dump(int indent) const
{
ASTNode::dump(indent);
if (!m_lexical_declarations.is_empty()) {
print_indent(indent + 1);
outln("(Lexical declarations)");
for (auto& declaration : m_lexical_declarations)
declaration.dump(indent + 2);
}
if (!m_var_declarations.is_empty()) {
print_indent(indent + 1);
outln("(Variable declarations)");
for (auto& declaration : m_var_declarations)
declaration.dump(indent + 2);
}
if (!m_functions_hoistable_with_annexB_extension.is_empty()) {
print_indent(indent + 1);
outln("(Hoisted functions via annexB extension)");
for (auto& declaration : m_functions_hoistable_with_annexB_extension)
declaration.dump(indent + 2);
}
if (!m_children.is_empty()) {
print_indent(indent + 1);
outln("(Children)");
for (auto& child : children())
child.dump(indent + 2);
}
}
void BinaryExpression::dump(int indent) const
{
const char* op_string = nullptr;
switch (m_op) {
case BinaryOp::Addition:
op_string = "+";
break;
case BinaryOp::Subtraction:
op_string = "-";
break;
case BinaryOp::Multiplication:
op_string = "*";
break;
case BinaryOp::Division:
op_string = "/";
break;
case BinaryOp::Modulo:
op_string = "%";
break;
case BinaryOp::Exponentiation:
op_string = "**";
break;
case BinaryOp::StrictlyEquals:
op_string = "===";
break;
case BinaryOp::StrictlyInequals:
op_string = "!==";
break;
case BinaryOp::LooselyEquals:
op_string = "==";
break;
case BinaryOp::LooselyInequals:
op_string = "!=";
break;
case BinaryOp::GreaterThan:
op_string = ">";
break;
case BinaryOp::GreaterThanEquals:
op_string = ">=";
break;
case BinaryOp::LessThan:
op_string = "<";
break;
case BinaryOp::LessThanEquals:
op_string = "<=";
break;
case BinaryOp::BitwiseAnd:
op_string = "&";
break;
case BinaryOp::BitwiseOr:
op_string = "|";
break;
case BinaryOp::BitwiseXor:
op_string = "^";
break;
case BinaryOp::LeftShift:
op_string = "<<";
break;
case BinaryOp::RightShift:
op_string = ">>";
break;
case BinaryOp::UnsignedRightShift:
op_string = ">>>";
break;
case BinaryOp::In:
op_string = "in";
break;
case BinaryOp::InstanceOf:
op_string = "instanceof";
break;
}
print_indent(indent);
outln("{}", class_name());
m_lhs->dump(indent + 1);
print_indent(indent + 1);
outln("{}", op_string);
m_rhs->dump(indent + 1);
}
void LogicalExpression::dump(int indent) const
{
const char* op_string = nullptr;
switch (m_op) {
case LogicalOp::And:
op_string = "&&";
break;
case LogicalOp::Or:
op_string = "||";
break;
case LogicalOp::NullishCoalescing:
op_string = "??";
break;
}
print_indent(indent);
outln("{}", class_name());
m_lhs->dump(indent + 1);
print_indent(indent + 1);
outln("{}", op_string);
m_rhs->dump(indent + 1);
}
void UnaryExpression::dump(int indent) const
{
const char* op_string = nullptr;
switch (m_op) {
case UnaryOp::BitwiseNot:
op_string = "~";
break;
case UnaryOp::Not:
op_string = "!";
break;
case UnaryOp::Plus:
op_string = "+";
break;
case UnaryOp::Minus:
op_string = "-";
break;
case UnaryOp::Typeof:
op_string = "typeof ";
break;
case UnaryOp::Void:
op_string = "void ";
break;
case UnaryOp::Delete:
op_string = "delete ";
break;
}
print_indent(indent);
outln("{}", class_name());
print_indent(indent + 1);
outln("{}", op_string);
m_lhs->dump(indent + 1);
}
void CallExpression::dump(int indent) const
{
print_indent(indent);
if (is<NewExpression>(*this))
outln("CallExpression [new]");
else
outln("CallExpression");
m_callee->dump(indent + 1);
for (auto& argument : m_arguments)
argument.value->dump(indent + 1);
}
void SuperCall::dump(int indent) const
{
print_indent(indent);
outln("SuperCall");
for (auto& argument : m_arguments)
argument.value->dump(indent + 1);
}
void ClassDeclaration::dump(int indent) const
{
ASTNode::dump(indent);
m_class_expression->dump(indent + 1);
}
void ClassDeclaration::for_each_bound_name(IteratorOrVoidFunction<FlyString const&> callback) const
{
if (!m_class_expression->name().is_empty())
callback(m_class_expression->name());
}
void ClassExpression::dump(int indent) const
{
print_indent(indent);
outln("ClassExpression: \"{}\"", m_name);
print_indent(indent);
outln("(Constructor)");
m_constructor->dump(indent + 1);
if (!m_super_class.is_null()) {
print_indent(indent);
outln("(Super Class)");
m_super_class->dump(indent + 1);
}
print_indent(indent);
outln("(Methods)");
for (auto& method : m_methods)
method.dump(indent + 1);
print_indent(indent);
outln("(Fields)");
for (auto& field : m_fields)
field.dump(indent + 1);
}
void ClassMethod::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
outln("(Key)");
m_key->dump(indent + 1);
const char* kind_string = nullptr;
switch (m_kind) {
case Kind::Method:
kind_string = "Method";
break;
case Kind::Getter:
kind_string = "Getter";
break;
case Kind::Setter:
kind_string = "Setter";
break;
}
print_indent(indent);
outln("Kind: {}", kind_string);
print_indent(indent);
outln("Static: {}", m_is_static);
print_indent(indent);
outln("(Function)");
m_function->dump(indent + 1);
}
void ClassField::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
outln("(Key)");
m_key->dump(indent + 1);
print_indent(indent);
outln("Static: {}", m_is_static);
if (m_initializer) {
print_indent(indent);
outln("(Initializer)");
m_initializer->dump(indent + 1);
}
}
void StringLiteral::dump(int indent) const
{
print_indent(indent);
outln("StringLiteral \"{}\"", m_value);
}
void SuperExpression::dump(int indent) const
{
print_indent(indent);
outln("super");
}
void NumericLiteral::dump(int indent) const
{
print_indent(indent);
outln("NumericLiteral {}", m_value);
}
void BigIntLiteral::dump(int indent) const
{
print_indent(indent);
outln("BigIntLiteral {}", m_value);
}
void BooleanLiteral::dump(int indent) const
{
print_indent(indent);
outln("BooleanLiteral {}", m_value);
}
void NullLiteral::dump(int indent) const
{
print_indent(indent);
outln("null");
}
bool BindingPattern::contains_expression() const
{
for (auto& entry : entries) {
if (entry.initializer)
return true;
if (auto binding_ptr = entry.alias.get_pointer<NonnullRefPtr<BindingPattern>>(); binding_ptr && (*binding_ptr)->contains_expression())
return true;
}
return false;
}
void BindingPattern::dump(int indent) const
{
print_indent(indent);
outln("BindingPattern {}", kind == Kind::Array ? "Array" : "Object");
for (auto& entry : entries) {
print_indent(indent + 1);
outln("(Property)");
if (kind == Kind::Object) {
print_indent(indent + 2);
outln("(Identifier)");
if (entry.name.has<NonnullRefPtr<Identifier>>()) {
entry.name.get<NonnullRefPtr<Identifier>>()->dump(indent + 3);
} else {
entry.name.get<NonnullRefPtr<Expression>>()->dump(indent + 3);
}
} else if (entry.is_elision()) {
print_indent(indent + 2);
outln("(Elision)");
continue;
}
print_indent(indent + 2);
outln("(Pattern{})", entry.is_rest ? " rest=true" : "");
if (entry.alias.has<NonnullRefPtr<Identifier>>()) {
entry.alias.get<NonnullRefPtr<Identifier>>()->dump(indent + 3);
} else if (entry.alias.has<NonnullRefPtr<BindingPattern>>()) {
entry.alias.get<NonnullRefPtr<BindingPattern>>()->dump(indent + 3);
} else if (entry.alias.has<NonnullRefPtr<MemberExpression>>()) {
entry.alias.get<NonnullRefPtr<MemberExpression>>()->dump(indent + 3);
} else {
print_indent(indent + 3);
outln("<empty>");
}
if (entry.initializer) {
print_indent(indent + 2);
outln("(Initializer)");
entry.initializer->dump(indent + 3);
}
}
}
void FunctionNode::dump(int indent, String const& class_name) const
{
print_indent(indent);
outln("{}{} '{}'", class_name, m_kind == FunctionKind::Generator ? "*" : "", name());
if (!m_parameters.is_empty()) {
print_indent(indent + 1);
outln("(Parameters)");
for (auto& parameter : m_parameters) {
print_indent(indent + 2);
if (parameter.is_rest)
out("...");
parameter.binding.visit(
[&](FlyString const& name) {
outln("{}", name);
},
[&](BindingPattern const& pattern) {
pattern.dump(indent + 2);
});
if (parameter.default_value)
parameter.default_value->dump(indent + 3);
}
}
print_indent(indent + 1);
outln("(Body)");
body().dump(indent + 2);
}
void FunctionDeclaration::dump(int indent) const
{
FunctionNode::dump(indent, class_name());
}
void FunctionDeclaration::for_each_bound_name(IteratorOrVoidFunction<FlyString const&> callback) const
{
if (!name().is_empty())
callback(name());
}
void FunctionExpression::dump(int indent) const
{
FunctionNode::dump(indent, class_name());
}
void YieldExpression::dump(int indent) const
{
ASTNode::dump(indent);
if (argument())
argument()->dump(indent + 1);
}
void ReturnStatement::dump(int indent) const
{
ASTNode::dump(indent);
if (argument())
argument()->dump(indent + 1);
}
void IfStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
outln("If");
predicate().dump(indent + 1);
consequent().dump(indent + 1);
if (alternate()) {
print_indent(indent);
outln("Else");
alternate()->dump(indent + 1);
}
}
void WhileStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
outln("While");
test().dump(indent + 1);
body().dump(indent + 1);
}
void WithStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent + 1);
outln("Object");
object().dump(indent + 2);
print_indent(indent + 1);
outln("Body");
body().dump(indent + 2);
}
void DoWhileStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
outln("DoWhile");
test().dump(indent + 1);
body().dump(indent + 1);
}
void ForStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
outln("For");
if (init())
init()->dump(indent + 1);
if (test())
test()->dump(indent + 1);
if (update())
update()->dump(indent + 1);
body().dump(indent + 1);
}
void ForInStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
outln("ForIn");
lhs().visit([&](auto& lhs) { lhs->dump(indent + 1); });
rhs().dump(indent + 1);
body().dump(indent + 1);
}
void ForOfStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
outln("ForOf");
lhs().visit([&](auto& lhs) { lhs->dump(indent + 1); });
rhs().dump(indent + 1);
body().dump(indent + 1);
}
Value Identifier::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto reference = to_reference(interpreter, global_object);
if (interpreter.exception())
return {};
return reference.get_value(global_object);
}
void Identifier::dump(int indent) const
{
print_indent(indent);
outln("Identifier \"{}\"", m_string);
}
void SpreadExpression::dump(int indent) const
{
ASTNode::dump(indent);
m_target->dump(indent + 1);
}
Value SpreadExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
return m_target->execute(interpreter, global_object);
}
Value ThisExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
return interpreter.vm().resolve_this_binding(global_object);
}
void ThisExpression::dump(int indent) const
{
ASTNode::dump(indent);
}
// 13.15.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-assignment-operators-runtime-semantics-evaluation
Value AssignmentExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
if (m_op == AssignmentOp::Assignment) {
// AssignmentExpression : LeftHandSideExpression = AssignmentExpression
return m_lhs.visit(
[&](NonnullRefPtr<Expression>& lhs) -> JS::Value {
auto reference = lhs->to_reference(interpreter, global_object);
if (interpreter.exception())
return {};
Value rhs_result;
if (lhs->is_identifier()) {
auto& identifier_name = static_cast<Identifier const&>(*lhs).string();
rhs_result = TRY_OR_DISCARD(interpreter.vm().named_evaluation_if_anonymous_function(global_object, m_rhs, identifier_name));
} else {
rhs_result = m_rhs->execute(interpreter, global_object);
}
if (interpreter.exception())
return {};
reference.put_value(global_object, rhs_result);
if (interpreter.exception())
return {};
return rhs_result;
},
[&](NonnullRefPtr<BindingPattern>& pattern) -> JS::Value {
Value rhs_result = m_rhs->execute(interpreter, global_object);
if (interpreter.exception())
return {};
TRY_OR_DISCARD(interpreter.vm().destructuring_assignment_evaluation(pattern, rhs_result, global_object));
return rhs_result;
});
}
VERIFY(m_lhs.has<NonnullRefPtr<Expression>>());
auto& lhs_expression = *m_lhs.get<NonnullRefPtr<Expression>>();
auto reference = lhs_expression.to_reference(interpreter, global_object);
if (interpreter.exception())
return {};
auto lhs_result = reference.get_value(global_object);
if (interpreter.exception())
return {};
// AssignmentExpression : LeftHandSideExpression {&&=, ||=, ??=} AssignmentExpression
if (m_op == AssignmentOp::AndAssignment || m_op == AssignmentOp::OrAssignment || m_op == AssignmentOp::NullishAssignment) {
switch (m_op) {
case AssignmentOp::AndAssignment:
if (!lhs_result.to_boolean())
return lhs_result;
break;
case AssignmentOp::OrAssignment:
if (lhs_result.to_boolean())
return lhs_result;
break;
case AssignmentOp::NullishAssignment:
if (!lhs_result.is_nullish())
return lhs_result;
break;
default:
VERIFY_NOT_REACHED();
}
Value rhs_result;
if (lhs_expression.is_identifier()) {
auto& identifier_name = static_cast<Identifier const&>(lhs_expression).string();
rhs_result = TRY_OR_DISCARD(interpreter.vm().named_evaluation_if_anonymous_function(global_object, m_rhs, identifier_name));
} else {
rhs_result = m_rhs->execute(interpreter, global_object);
if (interpreter.exception())
return {};
}
reference.put_value(global_object, rhs_result);
if (interpreter.exception())
return {};
return rhs_result;
}
// AssignmentExpression : LeftHandSideExpression AssignmentOperator AssignmentExpression
auto rhs_result = m_rhs->execute(interpreter, global_object);
if (interpreter.exception())
return {};
switch (m_op) {
case AssignmentOp::AdditionAssignment:
rhs_result = add(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::SubtractionAssignment:
rhs_result = sub(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::MultiplicationAssignment:
rhs_result = mul(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::DivisionAssignment:
rhs_result = div(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::ModuloAssignment:
rhs_result = mod(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::ExponentiationAssignment:
rhs_result = exp(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::BitwiseAndAssignment:
rhs_result = bitwise_and(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::BitwiseOrAssignment:
rhs_result = bitwise_or(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::BitwiseXorAssignment:
rhs_result = bitwise_xor(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::LeftShiftAssignment:
rhs_result = left_shift(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::RightShiftAssignment:
rhs_result = right_shift(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::UnsignedRightShiftAssignment:
rhs_result = unsigned_right_shift(global_object, lhs_result, rhs_result);
break;
case AssignmentOp::Assignment:
case AssignmentOp::AndAssignment:
case AssignmentOp::OrAssignment:
case AssignmentOp::NullishAssignment:
VERIFY_NOT_REACHED();
}
if (interpreter.exception())
return {};
reference.put_value(global_object, rhs_result);
if (interpreter.exception())
return {};
return rhs_result;
}
Value UpdateExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto reference = m_argument->to_reference(interpreter, global_object);
if (interpreter.exception())
return {};
auto old_value = reference.get_value(global_object);
if (interpreter.exception())
return {};
old_value = old_value.to_numeric(global_object);
if (interpreter.exception())
return {};
Value new_value;
switch (m_op) {
case UpdateOp::Increment:
if (old_value.is_number())
new_value = Value(old_value.as_double() + 1);
else
new_value = js_bigint(interpreter.heap(), old_value.as_bigint().big_integer().plus(Crypto::SignedBigInteger { 1 }));
break;
case UpdateOp::Decrement:
if (old_value.is_number())
new_value = Value(old_value.as_double() - 1);
else
new_value = js_bigint(interpreter.heap(), old_value.as_bigint().big_integer().minus(Crypto::SignedBigInteger { 1 }));
break;
default:
VERIFY_NOT_REACHED();
}
reference.put_value(global_object, new_value);
if (interpreter.exception())
return {};
return m_prefixed ? new_value : old_value;
}
void AssignmentExpression::dump(int indent) const
{
const char* op_string = nullptr;
switch (m_op) {
case AssignmentOp::Assignment:
op_string = "=";
break;
case AssignmentOp::AdditionAssignment:
op_string = "+=";
break;
case AssignmentOp::SubtractionAssignment:
op_string = "-=";
break;
case AssignmentOp::MultiplicationAssignment:
op_string = "*=";
break;
case AssignmentOp::DivisionAssignment:
op_string = "/=";
break;
case AssignmentOp::ModuloAssignment:
op_string = "%=";
break;
case AssignmentOp::ExponentiationAssignment:
op_string = "**=";
break;
case AssignmentOp::BitwiseAndAssignment:
op_string = "&=";
break;
case AssignmentOp::BitwiseOrAssignment:
op_string = "|=";
break;
case AssignmentOp::BitwiseXorAssignment:
op_string = "^=";
break;
case AssignmentOp::LeftShiftAssignment:
op_string = "<<=";
break;
case AssignmentOp::RightShiftAssignment:
op_string = ">>=";
break;
case AssignmentOp::UnsignedRightShiftAssignment:
op_string = ">>>=";
break;
case AssignmentOp::AndAssignment:
op_string = "&&=";
break;
case AssignmentOp::OrAssignment:
op_string = "||=";
break;
case AssignmentOp::NullishAssignment:
op_string = "\?\?=";
break;
}
ASTNode::dump(indent);
print_indent(indent + 1);
outln("{}", op_string);
m_lhs.visit([&](auto& lhs) { lhs->dump(indent + 1); });
m_rhs->dump(indent + 1);
}
void UpdateExpression::dump(int indent) const
{
const char* op_string = nullptr;
switch (m_op) {
case UpdateOp::Increment:
op_string = "++";
break;
case UpdateOp::Decrement:
op_string = "--";
break;
}
ASTNode::dump(indent);
if (m_prefixed) {
print_indent(indent + 1);
outln("{}", op_string);
}
m_argument->dump(indent + 1);
if (!m_prefixed) {
print_indent(indent + 1);
outln("{}", op_string);
}
}
Value VariableDeclaration::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
for (auto& declarator : m_declarations) {
if (auto* init = declarator.init()) {
declarator.target().visit(
[&](NonnullRefPtr<Identifier> const& id) {
auto reference = id->to_reference(interpreter, global_object);
if (interpreter.exception())
return;
auto initializer_result_or_error = interpreter.vm().named_evaluation_if_anonymous_function(global_object, *init, id->string());
if (initializer_result_or_error.is_error())
return;
auto initializer_result = initializer_result_or_error.release_value();
VERIFY(!initializer_result.is_empty());
if (m_declaration_kind == DeclarationKind::Var)
reference.put_value(global_object, initializer_result);
else
reference.initialize_referenced_binding(global_object, initializer_result);
},
[&](NonnullRefPtr<BindingPattern> const& pattern) {
auto initializer_result = init->execute(interpreter, global_object);
if (interpreter.exception())
return;
Environment* environment = m_declaration_kind == DeclarationKind::Var ? nullptr : interpreter.lexical_environment();
// FIXME: I want to use TRY_OR_DISCARD here but can't return...
auto result = interpreter.vm().binding_initialization(pattern, initializer_result, environment, global_object);
(void)result;
});
if (interpreter.exception())
return {};
} else if (m_declaration_kind != DeclarationKind::Var) {
VERIFY(declarator.target().has<NonnullRefPtr<Identifier>>());
auto& identifier = declarator.target().get<NonnullRefPtr<Identifier>>();
auto reference = identifier->to_reference(interpreter, global_object);
reference.initialize_referenced_binding(global_object, js_undefined());
if (interpreter.exception())
return {};
}
}
return {};
}
Value VariableDeclarator::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
// NOTE: VariableDeclarator execution is handled by VariableDeclaration.
VERIFY_NOT_REACHED();
}
void VariableDeclaration::for_each_bound_name(IteratorOrVoidFunction<FlyString const&> callback) const
{
for (auto& entry : declarations()) {
entry.target().template visit(
[&](const NonnullRefPtr<Identifier>& id) {
callback(id->string());
},
[&](const NonnullRefPtr<BindingPattern>& binding) {
binding->for_each_bound_name([&](const auto& name) {
callback(name);
});
});
}
}
void VariableDeclaration::dump(int indent) const
{
const char* declaration_kind_string = nullptr;
switch (m_declaration_kind) {
case DeclarationKind::Let:
declaration_kind_string = "Let";
break;
case DeclarationKind::Var:
declaration_kind_string = "Var";
break;
case DeclarationKind::Const:
declaration_kind_string = "Const";
break;
}
ASTNode::dump(indent);
print_indent(indent + 1);
outln("{}", declaration_kind_string);
for (auto& declarator : m_declarations)
declarator.dump(indent + 1);
}
void VariableDeclarator::dump(int indent) const
{
ASTNode::dump(indent);
m_target.visit([indent](const auto& value) { value->dump(indent + 1); });
if (m_init)
m_init->dump(indent + 1);
}
void ObjectProperty::dump(int indent) const
{
ASTNode::dump(indent);
m_key->dump(indent + 1);
m_value->dump(indent + 1);
}
void ObjectExpression::dump(int indent) const
{
ASTNode::dump(indent);
for (auto& property : m_properties) {
property.dump(indent + 1);
}
}
void ExpressionStatement::dump(int indent) const
{
ASTNode::dump(indent);
m_expression->dump(indent + 1);
}
Value ObjectProperty::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
// NOTE: ObjectProperty execution is handled by ObjectExpression.
VERIFY_NOT_REACHED();
}
Value ObjectExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto* object = Object::create(global_object, global_object.object_prototype());
for (auto& property : m_properties) {
auto key = property.key().execute(interpreter, global_object);
if (interpreter.exception())
return {};
if (property.type() == ObjectProperty::Type::Spread) {
if (key.is_object() && is<Array>(key.as_object())) {
auto& array_to_spread = static_cast<Array&>(key.as_object());
for (auto& entry : array_to_spread.indexed_properties()) {
auto value = TRY_OR_DISCARD(array_to_spread.get(entry.index()));
object->indexed_properties().put(entry.index(), value);
if (interpreter.exception())
return {};
}
} else if (key.is_object()) {
auto& obj_to_spread = key.as_object();
for (auto& it : obj_to_spread.shape().property_table_ordered()) {
if (it.value.attributes.is_enumerable()) {
object->define_direct_property(it.key, TRY_OR_DISCARD(obj_to_spread.get(it.key)), JS::default_attributes);
if (interpreter.exception())
return {};
}
}
} else if (key.is_string()) {
auto& str_to_spread = key.as_string().string();
for (size_t i = 0; i < str_to_spread.length(); i++) {
object->define_direct_property(i, js_string(interpreter.heap(), str_to_spread.substring(i, 1)), JS::default_attributes);
if (interpreter.exception())
return {};
}
}
continue;
}
auto value = property.value().execute(interpreter, global_object);
if (interpreter.exception())
return {};
if (value.is_function() && property.is_method())
static_cast<ECMAScriptFunctionObject&>(value.as_function()).set_home_object(object);
String name = get_function_name(global_object, key);
if (property.type() == ObjectProperty::Type::Getter) {
name = String::formatted("get {}", name);
} else if (property.type() == ObjectProperty::Type::Setter) {
name = String::formatted("set {}", name);
}
update_function_name(value, name);
switch (property.type()) {
case ObjectProperty::Type::Getter:
VERIFY(value.is_function());
object->define_direct_accessor(PropertyName::from_value(global_object, key), &value.as_function(), nullptr, Attribute::Configurable | Attribute::Enumerable);
break;
case ObjectProperty::Type::Setter:
VERIFY(value.is_function());
object->define_direct_accessor(PropertyName::from_value(global_object, key), nullptr, &value.as_function(), Attribute::Configurable | Attribute::Enumerable);
break;
case ObjectProperty::Type::KeyValue:
object->define_direct_property(PropertyName::from_value(global_object, key), value, JS::default_attributes);
break;
case ObjectProperty::Type::Spread:
default:
VERIFY_NOT_REACHED();
}
if (interpreter.exception())
return {};
}
return object;
}
void MemberExpression::dump(int indent) const
{
print_indent(indent);
outln("{}(computed={})", class_name(), is_computed());
m_object->dump(indent + 1);
m_property->dump(indent + 1);
}
PropertyName MemberExpression::computed_property_name(Interpreter& interpreter, GlobalObject& global_object) const
{
if (!is_computed())
return verify_cast<Identifier>(*m_property).string();
auto value = m_property->execute(interpreter, global_object);
if (interpreter.exception())
return {};
VERIFY(!value.is_empty());
return PropertyName::from_value(global_object, value);
}
String MemberExpression::to_string_approximation() const
{
String object_string = "<object>";
if (is<Identifier>(*m_object))
object_string = static_cast<Identifier const&>(*m_object).string();
if (is_computed())
return String::formatted("{}[<computed>]", object_string);
return String::formatted("{}.{}", object_string, verify_cast<Identifier>(*m_property).string());
}
Value MemberExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto reference = to_reference(interpreter, global_object);
if (interpreter.exception())
return {};
return reference.get_value(global_object);
}
void OptionalChain::dump(int indent) const
{
print_indent(indent);
outln("{}", class_name());
m_base->dump(indent + 1);
for (auto& reference : m_references) {
reference.visit(
[&](Call const& call) {
print_indent(indent + 1);
outln("Call({})", call.mode == Mode::Optional ? "Optional" : "Not Optional");
for (auto& argument : call.arguments)
argument.value->dump(indent + 2);
},
[&](ComputedReference const& ref) {
print_indent(indent + 1);
outln("ComputedReference({})", ref.mode == Mode::Optional ? "Optional" : "Not Optional");
ref.expression->dump(indent + 2);
},
[&](MemberReference const& ref) {
print_indent(indent + 1);
outln("MemberReference({})", ref.mode == Mode::Optional ? "Optional" : "Not Optional");
ref.identifier->dump(indent + 2);
});
}
}
Optional<OptionalChain::ReferenceAndValue> OptionalChain::to_reference_and_value(JS::Interpreter& interpreter, JS::GlobalObject& global_object) const
{
// Note: This is wrapped in an optional to allow base_reference = ...
Optional<JS::Reference> base_reference = m_base->to_reference(interpreter, global_object);
auto base = base_reference->is_unresolvable() ? m_base->execute(interpreter, global_object) : base_reference->get_value(global_object);
if (interpreter.exception())
return {};
for (auto& reference : m_references) {
auto is_optional = reference.visit([](auto& ref) { return ref.mode; }) == Mode::Optional;
if (is_optional && base.is_nullish())
return ReferenceAndValue { {}, js_undefined() };
auto expression = reference.visit(
[&](Call const& call) -> NonnullRefPtr<Expression> {
return create_ast_node<CallExpression>(source_range(),
create_ast_node<SyntheticReferenceExpression>(source_range(), *base_reference, base),
call.arguments);
},
[&](ComputedReference const& ref) -> NonnullRefPtr<Expression> {
return create_ast_node<MemberExpression>(source_range(),
create_ast_node<SyntheticReferenceExpression>(source_range(), *base_reference, base),
ref.expression,
true);
},
[&](MemberReference const& ref) -> NonnullRefPtr<Expression> {
return create_ast_node<MemberExpression>(source_range(),
create_ast_node<SyntheticReferenceExpression>(source_range(), *base_reference, base),
ref.identifier,
false);
});
if (is<CallExpression>(*expression)) {
base_reference = JS::Reference {};
base = expression->execute(interpreter, global_object);
} else {
base_reference = expression->to_reference(interpreter, global_object);
base = base_reference->get_value(global_object);
}
if (interpreter.exception())
return {};
}
return ReferenceAndValue { base_reference.release_value(), base };
}
Value OptionalChain::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
if (auto result = to_reference_and_value(interpreter, global_object); result.has_value())
return result.release_value().value;
return {};
}
JS::Reference OptionalChain::to_reference(Interpreter& interpreter, GlobalObject& global_object) const
{
if (auto result = to_reference_and_value(interpreter, global_object); result.has_value())
return result.release_value().reference;
return {};
}
void MetaProperty::dump(int indent) const
{
String name;
if (m_type == MetaProperty::Type::NewTarget)
name = "new.target";
else if (m_type == MetaProperty::Type::ImportMeta)
name = "import.meta";
else
VERIFY_NOT_REACHED();
print_indent(indent);
outln("{} {}", class_name(), name);
}
Value MetaProperty::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
if (m_type == MetaProperty::Type::NewTarget)
return interpreter.vm().get_new_target().value_or(js_undefined());
if (m_type == MetaProperty::Type::ImportMeta)
TODO();
VERIFY_NOT_REACHED();
}
Value StringLiteral::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
return js_string(interpreter.heap(), m_value);
}
Value NumericLiteral::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
return Value(m_value);
}
Value BigIntLiteral::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
Crypto::SignedBigInteger integer;
if (m_value[0] == '0' && m_value.length() >= 3) {
if (m_value[1] == 'x' || m_value[1] == 'X') {
return js_bigint(interpreter.heap(), Crypto::SignedBigInteger::from_base(16, m_value.substring(2, m_value.length() - 3)));
} else if (m_value[1] == 'o' || m_value[1] == 'O') {
return js_bigint(interpreter.heap(), Crypto::SignedBigInteger::from_base(8, m_value.substring(2, m_value.length() - 3)));
} else if (m_value[1] == 'b' || m_value[1] == 'B') {
return js_bigint(interpreter.heap(), Crypto::SignedBigInteger::from_base(2, m_value.substring(2, m_value.length() - 3)));
}
}
return js_bigint(interpreter.heap(), Crypto::SignedBigInteger::from_base(10, m_value.substring(0, m_value.length() - 1)));
}
Value BooleanLiteral::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
return Value(m_value);
}
Value NullLiteral::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
return js_null();
}
void RegExpLiteral::dump(int indent) const
{
print_indent(indent);
outln("{} (/{}/{})", class_name(), pattern(), flags());
}
Value RegExpLiteral::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
Regex<ECMA262> regex(parsed_regex(), parsed_pattern(), parsed_flags());
return RegExpObject::create(global_object, move(regex), pattern(), flags());
}
void ArrayExpression::dump(int indent) const
{
ASTNode::dump(indent);
for (auto& element : m_elements) {
if (element) {
element->dump(indent + 1);
} else {
print_indent(indent + 1);
outln("<empty>");
}
}
}
Value ArrayExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto* array = Array::create(global_object, 0);
array->indexed_properties();
size_t index = 0;
for (auto& element : m_elements) {
auto value = Value();
if (element) {
value = element->execute(interpreter, global_object);
if (interpreter.exception())
return {};
if (is<SpreadExpression>(*element)) {
get_iterator_values(global_object, value, [&](Value iterator_value) {
array->indexed_properties().put(index++, iterator_value, default_attributes);
return IterationDecision::Continue;
});
if (interpreter.exception())
return {};
continue;
}
}
array->indexed_properties().put(index++, value, default_attributes);
}
return array;
}
void TemplateLiteral::dump(int indent) const
{
ASTNode::dump(indent);
for (auto& expression : m_expressions)
expression.dump(indent + 1);
}
Value TemplateLiteral::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
StringBuilder string_builder;
for (auto& expression : m_expressions) {
auto expr = expression.execute(interpreter, global_object);
if (interpreter.exception())
return {};
auto string = expr.to_string(global_object);
if (interpreter.exception())
return {};
string_builder.append(string);
}
return js_string(interpreter.heap(), string_builder.build());
}
void TaggedTemplateLiteral::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent + 1);
outln("(Tag)");
m_tag->dump(indent + 2);
print_indent(indent + 1);
outln("(Template Literal)");
m_template_literal->dump(indent + 2);
}
Value TaggedTemplateLiteral::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto& vm = interpreter.vm();
auto tag = m_tag->execute(interpreter, global_object);
if (vm.exception())
return {};
if (!tag.is_function()) {
vm.throw_exception<TypeError>(global_object, ErrorType::NotAFunction, tag.to_string_without_side_effects());
return {};
}
auto& tag_function = tag.as_function();
auto& expressions = m_template_literal->expressions();
auto* strings = Array::create(global_object, 0);
MarkedValueList arguments(vm.heap());
arguments.append(strings);
for (size_t i = 0; i < expressions.size(); ++i) {
auto value = expressions[i].execute(interpreter, global_object);
if (vm.exception())
return {};
// tag`${foo}` -> "", foo, "" -> tag(["", ""], foo)
// tag`foo${bar}baz${qux}` -> "foo", bar, "baz", qux, "" -> tag(["foo", "baz", ""], bar, qux)
if (i % 2 == 0) {
strings->indexed_properties().append(value);
} else {
arguments.append(value);
}
}
auto* raw_strings = Array::create(global_object, 0);
for (auto& raw_string : m_template_literal->raw_strings()) {
auto value = raw_string.execute(interpreter, global_object);
if (vm.exception())
return {};
raw_strings->indexed_properties().append(value);
}
strings->define_direct_property(vm.names.raw, raw_strings, 0);
return TRY_OR_DISCARD(vm.call(tag_function, js_undefined(), move(arguments)));
}
void TryStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
outln("(Block)");
block().dump(indent + 1);
if (handler()) {
print_indent(indent);
outln("(Handler)");
handler()->dump(indent + 1);
}
if (finalizer()) {
print_indent(indent);
outln("(Finalizer)");
finalizer()->dump(indent + 1);
}
}
void CatchClause::dump(int indent) const
{
print_indent(indent);
m_parameter.visit(
[&](FlyString const& parameter) {
if (parameter.is_null())
outln("CatchClause");
else
outln("CatchClause ({})", parameter);
},
[&](NonnullRefPtr<BindingPattern> const& pattern) {
outln("CatchClause");
print_indent(indent);
outln("(Parameter)");
pattern->dump(indent + 2);
});
body().dump(indent + 1);
}
void ThrowStatement::dump(int indent) const
{
ASTNode::dump(indent);
argument().dump(indent + 1);
}
void TryStatement::add_label(FlyString string)
{
m_block->add_label(move(string));
}
Value TryStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
// FIXME: Use Completions here to be closer to the spec.
auto result = m_block->execute(interpreter, global_object);
if (interpreter.vm().unwind_until() == ScopeType::Try)
interpreter.vm().stop_unwind();
if (auto* exception = interpreter.exception()) {
// 14.15.2 Runtime Semantics: CatchClauseEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-catchclauseevaluation
if (m_handler) {
interpreter.vm().clear_exception();
auto* catch_scope = new_declarative_environment(*interpreter.lexical_environment());
m_handler->parameter().visit(
[&](FlyString const& parameter) {
catch_scope->create_mutable_binding(global_object, parameter, false);
},
[&](NonnullRefPtr<BindingPattern> const& pattern) {
pattern->for_each_bound_name([&](auto& name) {
catch_scope->create_mutable_binding(global_object, name, false);
});
});
TemporaryChange<Environment*> scope_change(interpreter.vm().running_execution_context().lexical_environment, catch_scope);
m_handler->parameter().visit(
[&](FlyString const& parameter) {
catch_scope->initialize_binding(global_object, parameter, exception->value());
},
[&](NonnullRefPtr<BindingPattern> const& pattern) {
(void)interpreter.vm().binding_initialization(pattern, exception->value(), catch_scope, global_object);
});
if (!interpreter.exception())
result = m_handler->body().execute(interpreter, global_object);
}
}
if (m_finalizer) {
// Keep, if any, and then clear the current exception so we can
// execute() the finalizer without an exception in our way.
auto* previous_exception = interpreter.exception();
interpreter.vm().clear_exception();
// Remember what scope type we were unwinding to, and temporarily
// clear it as well (e.g. return from handler).
auto unwind_until = interpreter.vm().unwind_until();
interpreter.vm().stop_unwind();
auto finalizer_result = m_finalizer->execute(interpreter, global_object);
if (interpreter.vm().should_unwind()) {
// This was NOT a 'normal' completion (e.g. return from finalizer).
result = finalizer_result;
} else {
// Continue unwinding to whatever we found ourselves unwinding
// to when the finalizer was entered (e.g. return from handler,
// which is unaffected by normal completion from finalizer).
interpreter.vm().unwind(unwind_until);
// If we previously had an exception and the finalizer didn't
// throw a new one, restore the old one.
if (previous_exception && !interpreter.exception())
interpreter.vm().set_exception(*previous_exception);
}
}
return result.value_or(js_undefined());
}
Value CatchClause::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
// NOTE: CatchClause execution is handled by TryStatement.
VERIFY_NOT_REACHED();
return {};
}
Value ThrowStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto value = m_argument->execute(interpreter, global_object);
if (interpreter.vm().exception())
return {};
interpreter.vm().throw_exception(global_object, value);
return {};
}
// 14.12.2 Runtime Semantics: CaseBlockEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-caseblockevaluation
Value SwitchStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
// FIXME: This needs a massive refactoring, ideally once we start using continue, break, and return completions.
// Instead of having an optional test expression, SwitchCase should be split into CaseClause and DefaultClause.
// https://tc39.es/ecma262/#sec-switch-statement
InterpreterNodeScope node_scope { interpreter, *this };
auto discriminant_result = m_discriminant->execute(interpreter, global_object);
if (interpreter.exception())
return {};
auto* old_environment = interpreter.lexical_environment();
ScopeGuard restore_environment = [&] {
interpreter.vm().running_execution_context().lexical_environment = old_environment;
};
auto* block_environment = new_declarative_environment(*old_environment);
block_declaration_instantiation(global_object, block_environment);
interpreter.vm().running_execution_context().lexical_environment = block_environment;
Optional<size_t> first_passing_case;
for (size_t i = 0; i < m_cases.size(); ++i) {
auto& switch_case = m_cases[i];
if (switch_case.test()) {
auto test_result = switch_case.test()->execute(interpreter, global_object);
if (interpreter.exception())
return {};
if (is_strictly_equal(discriminant_result, test_result)) {
first_passing_case = i;
break;
}
}
}
// FIXME: we could optimize and store the location of the default case in a member variable.
if (!first_passing_case.has_value()) {
for (size_t i = 0; i < m_cases.size(); ++i) {
auto& switch_case = m_cases[i];
if (!switch_case.test()) {
first_passing_case = i;
break;
}
}
}
auto last_value = js_undefined();
if (!first_passing_case.has_value()) {
return last_value;
}
VERIFY(first_passing_case.value() < m_cases.size());
for (size_t i = first_passing_case.value(); i < m_cases.size(); ++i) {
auto& switch_case = m_cases[i];
for (auto& statement : switch_case.children()) {
auto value = statement.execute(interpreter, global_object);
if (!value.is_empty())
last_value = value;
if (interpreter.exception())
return {};
if (interpreter.vm().should_unwind()) {
if (interpreter.vm().should_unwind_until(ScopeType::Continuable, m_labels)) {
// No stop_unwind(), the outer loop will handle that - we just need to break out of the switch/case.
return last_value;
} else if (interpreter.vm().should_unwind_until(ScopeType::Breakable, m_labels)) {
interpreter.vm().stop_unwind();
return last_value;
} else {
return last_value;
}
}
}
}
return last_value;
}
Value SwitchCase::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
// NOTE: SwitchCase execution is handled by SwitchStatement.
VERIFY_NOT_REACHED();
return {};
}
Value BreakStatement::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
interpreter.vm().unwind(ScopeType::Breakable, m_target_label);
return {};
}
Value ContinueStatement::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
interpreter.vm().unwind(ScopeType::Continuable, m_target_label);
return {};
}
void SwitchStatement::dump(int indent) const
{
ASTNode::dump(indent);
m_discriminant->dump(indent + 1);
for (auto& switch_case : m_cases) {
switch_case.dump(indent + 1);
}
}
void SwitchCase::dump(int indent) const
{
print_indent(indent + 1);
if (m_test) {
outln("(Test)");
m_test->dump(indent + 2);
} else {
outln("(Default)");
}
print_indent(indent + 1);
outln("(Consequent)");
ScopeNode::dump(indent + 2);
}
Value ConditionalExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
auto test_result = m_test->execute(interpreter, global_object);
if (interpreter.exception())
return {};
Value result;
if (test_result.to_boolean()) {
result = m_consequent->execute(interpreter, global_object);
} else {
result = m_alternate->execute(interpreter, global_object);
}
if (interpreter.exception())
return {};
return result;
}
void ConditionalExpression::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent + 1);
outln("(Test)");
m_test->dump(indent + 2);
print_indent(indent + 1);
outln("(Consequent)");
m_consequent->dump(indent + 2);
print_indent(indent + 1);
outln("(Alternate)");
m_alternate->dump(indent + 2);
}
void SequenceExpression::dump(int indent) const
{
ASTNode::dump(indent);
for (auto& expression : m_expressions)
expression.dump(indent + 1);
}
Value SequenceExpression::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
Value last_value;
for (auto& expression : m_expressions) {
last_value = expression.execute(interpreter, global_object);
if (interpreter.exception())
return {};
}
return last_value;
}
Value DebuggerStatement::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
// Sorry, no JavaScript debugger available (yet)!
return {};
}
void ScopeNode::for_each_lexically_scoped_declaration(IteratorOrVoidFunction<Declaration const&>&& callback) const
{
for (auto& declaration : m_lexical_declarations) {
if (callback(declaration) == IterationDecision::Break)
break;
}
}
void ScopeNode::for_each_lexically_declared_name(IteratorOrVoidFunction<FlyString const&>&& callback) const
{
auto running = true;
for (auto& declaration : m_lexical_declarations) {
declaration.for_each_bound_name([&](auto const& name) {
if (callback(name) == IterationDecision::Break) {
running = false;
return IterationDecision::Break;
}
return IterationDecision::Continue;
});
if (!running)
break;
}
}
void ScopeNode::for_each_var_declared_name(IteratorOrVoidFunction<FlyString const&>&& callback) const
{
auto running = true;
for (auto& declaration : m_var_declarations) {
declaration.for_each_bound_name([&](auto const& name) {
if (callback(name) == IterationDecision::Break) {
running = false;
return IterationDecision::Break;
}
return IterationDecision::Continue;
});
if (!running)
break;
}
}
void ScopeNode::for_each_var_function_declaration_in_reverse_order(IteratorOrVoidFunction<FunctionDeclaration const&>&& callback) const
{
for (ssize_t i = m_var_declarations.size() - 1; i >= 0; i--) {
auto& declaration = m_var_declarations[i];
if (is<FunctionDeclaration>(declaration)) {
if (callback(static_cast<FunctionDeclaration const&>(declaration)) == IterationDecision::Break)
break;
}
}
}
void ScopeNode::for_each_var_scoped_variable_declaration(IteratorOrVoidFunction<VariableDeclaration const&>&& callback) const
{
for (auto& declaration : m_var_declarations) {
if (!is<FunctionDeclaration>(declaration)) {
VERIFY(is<VariableDeclaration>(declaration));
if (callback(static_cast<VariableDeclaration const&>(declaration)) == IterationDecision::Break)
break;
}
}
}
void ScopeNode::for_each_function_hoistable_with_annexB_extension(IteratorOrVoidFunction<FunctionDeclaration&>&& callback) const
{
for (auto& function : m_functions_hoistable_with_annexB_extension) {
// We need const_cast here since it might have to set a property on function declaration.
if (callback(const_cast<FunctionDeclaration&>(function)) == IterationDecision::Break)
break;
}
}
void ScopeNode::add_lexical_declaration(NonnullRefPtr<Declaration> declaration)
{
m_lexical_declarations.append(move(declaration));
}
void ScopeNode::add_var_scoped_declaration(NonnullRefPtr<Declaration> declaration)
{
m_var_declarations.append(move(declaration));
}
void ScopeNode::add_hoisted_function(NonnullRefPtr<FunctionDeclaration> declaration)
{
m_functions_hoistable_with_annexB_extension.append(move(declaration));
}
Value ImportStatement::execute(Interpreter& interpreter, GlobalObject&) const
{
InterpreterNodeScope node_scope { interpreter, *this };
dbgln("Modules are not fully supported yet!");
TODO();
return {};
}
Value ExportStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
{
InterpreterNodeScope node_scope { interpreter, *this };
if (m_statement)
return m_statement->execute(interpreter, global_object);
return {};
}
void ExportStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent + 1);
outln("(ExportEntries)");
auto string_or_null = [](String const& string) -> String {
if (string.is_empty()) {
return "null";
}
return String::formatted("\"{}\"", string);
};
for (auto& entry : m_entries) {
print_indent(indent + 2);
outln("ModuleRequest: {}, ImportName: {}, LocalName: {}, ExportName: {}", string_or_null(entry.module_request), entry.kind == ExportEntry::ModuleRequest ? string_or_null(entry.local_or_import_name) : "null", entry.kind != ExportEntry::ModuleRequest ? string_or_null(entry.local_or_import_name) : "null", string_or_null(entry.export_name));
}
}
void ImportStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent + 1);
if (m_entries.is_empty()) {
// direct from "module" import
outln("Entire module '{}'", m_module_request);
} else {
outln("(ExportEntries) from {}", m_module_request);
for (auto& entry : m_entries) {
print_indent(indent + 2);
outln("ImportName: {}, LocalName: {}", entry.import_name, entry.local_name);
}
}
}
bool ExportStatement::has_export(StringView export_name) const
{
return any_of(m_entries.begin(), m_entries.end(), [&](auto& entry) {
return entry.export_name == export_name;
});
}
bool ImportStatement::has_bound_name(StringView name) const
{
return any_of(m_entries.begin(), m_entries.end(), [&](auto& entry) {
return entry.local_name == name;
});
}
// 14.2.3 BlockDeclarationInstantiation ( code, env ), https://tc39.es/ecma262/#sec-blockdeclarationinstantiation
void ScopeNode::block_declaration_instantiation(GlobalObject& global_object, Environment* environment) const
{
// See also B.3.2.6 Changes to BlockDeclarationInstantiation, https://tc39.es/ecma262/#sec-web-compat-blockdeclarationinstantiation
VERIFY(environment);
for_each_lexically_scoped_declaration([&](Declaration const& declaration) {
auto is_constant_declaration = declaration.is_constant_declaration();
declaration.for_each_bound_name([&](auto const& name) {
if (is_constant_declaration) {
environment->create_immutable_binding(global_object, name, true);
} else {
if (!environment->has_binding(name))
environment->create_mutable_binding(global_object, name, false);
}
});
if (is<FunctionDeclaration>(declaration)) {
auto& function_declaration = static_cast<FunctionDeclaration const&>(declaration);
auto* function = ECMAScriptFunctionObject::create(global_object, function_declaration.name(), function_declaration.body(), function_declaration.parameters(), function_declaration.function_length(), environment, function_declaration.kind(), function_declaration.is_strict_mode(), function_declaration.might_need_arguments_object());
VERIFY(is<DeclarativeEnvironment>(*environment));
static_cast<DeclarativeEnvironment&>(*environment).initialize_or_set_mutable_binding({}, global_object, function_declaration.name(), function);
}
});
}
// 16.1.7 GlobalDeclarationInstantiation ( script, env ), https://tc39.es/ecma262/#sec-globaldeclarationinstantiation
ThrowCompletionOr<void> Program::global_declaration_instantiation(Interpreter& interpreter, GlobalObject& global_object, GlobalEnvironment& global_environment) const
{
for_each_lexically_declared_name([&](FlyString const& name) {
if (global_environment.has_var_declaration(name) || global_environment.has_lexical_declaration(name)) {
interpreter.vm().throw_exception<SyntaxError>(global_object, ErrorType::FixmeAddAnErrorStringWithMessage, "Lexical variable top level already declared");
return IterationDecision::Break;
}
auto restricted_global = global_environment.has_restricted_global_property(name);
if (interpreter.exception())
return IterationDecision::Break;
if (restricted_global)
interpreter.vm().throw_exception<SyntaxError>(global_object, ErrorType::FixmeAddAnErrorStringWithMessage, "Restricted global property");
return IterationDecision::Continue;
});
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
for_each_var_declared_name([&](auto const& name) {
if (global_environment.has_lexical_declaration(name)) {
interpreter.vm().throw_exception<SyntaxError>(global_object, ErrorType::FixmeAddAnErrorStringWithMessage, "Var declared variable top level also lexically declared");
return IterationDecision::Break;
}
return IterationDecision::Continue;
});
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
HashTable<FlyString> declared_function_names;
Vector<FunctionDeclaration const&> functions_to_initialize;
for_each_var_function_declaration_in_reverse_order([&](FunctionDeclaration const& function) {
if (declared_function_names.set(function.name()) != AK::HashSetResult::InsertedNewEntry)
return IterationDecision::Continue;
auto function_definable = global_environment.can_declare_global_function(function.name());
if (interpreter.exception())
return IterationDecision::Break;
if (!function_definable) {
interpreter.vm().throw_exception<TypeError>(global_object, ErrorType::FixmeAddAnErrorStringWithMessage, "Global function not definable");
return IterationDecision::Break;
}
functions_to_initialize.append(function);
return IterationDecision::Continue;
});
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
HashTable<FlyString> declared_var_names;
for_each_var_scoped_variable_declaration([&](Declaration const& declaration) {
declaration.for_each_bound_name([&](auto const& name) {
if (declared_function_names.contains(name))
return IterationDecision::Continue;
auto var_definable = global_environment.can_declare_global_var(name);
if (interpreter.exception())
return IterationDecision::Break;
if (!var_definable) {
interpreter.vm().throw_exception<TypeError>(global_object, ErrorType::FixmeAddAnErrorStringWithMessage, "Global variable not definable");
return IterationDecision::Break;
}
declared_var_names.set(name);
return IterationDecision::Continue;
});
if (interpreter.exception())
return IterationDecision::Break;
return IterationDecision::Continue;
});
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
if (!m_is_strict_mode) {
for_each_function_hoistable_with_annexB_extension([&](FunctionDeclaration& function_declaration) {
auto& function_name = function_declaration.name();
if (global_environment.has_lexical_declaration(function_name))
return IterationDecision::Continue;
auto function_definable = global_environment.can_declare_global_function(function_name);
if (interpreter.exception())
return IterationDecision::Break;
if (!function_definable) {
interpreter.vm().throw_exception<TypeError>(global_object, ErrorType::FixmeAddAnErrorStringWithMessage, "Global function not definable");
return IterationDecision::Break;
}
if (!declared_function_names.contains(function_name) && !declared_var_names.contains(function_name)) {
global_environment.create_global_var_binding(function_name, false);
if (interpreter.exception())
return IterationDecision::Break;
declared_function_names.set(function_name);
}
function_declaration.set_should_do_additional_annexB_steps();
return IterationDecision::Continue;
});
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
// We should not use declared function names below here anymore since these functions are not in there in the spec.
declared_function_names.clear();
}
for_each_lexically_scoped_declaration([&](Declaration const& declaration) {
declaration.for_each_bound_name([&](auto const& name) {
if (declaration.is_constant_declaration())
global_environment.create_immutable_binding(global_object, name, true);
else
global_environment.create_mutable_binding(global_object, name, false);
if (interpreter.exception())
return IterationDecision::Break;
return IterationDecision::Continue;
});
if (interpreter.exception())
return IterationDecision::Break;
return IterationDecision::Continue;
});
for (auto& declaration : functions_to_initialize) {
auto* function = ECMAScriptFunctionObject::create(global_object, declaration.name(), declaration.body(), declaration.parameters(), declaration.function_length(), &global_environment, declaration.kind(), declaration.is_strict_mode(), declaration.might_need_arguments_object());
global_environment.create_global_function_binding(declaration.name(), function, false);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
}
for (auto& var_name : declared_var_names) {
global_environment.create_global_var_binding(var_name, false);
if (auto* exception = interpreter.exception())
return throw_completion(exception->value());
}
return {};
}
}
Reference in a new issue View git blame Copy permalink