RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-24 21:47:43 +00:00
Code Issues Activity Actions

LibJS: Implement generator functions (only in bytecode mode)

Browse source
This commit is contained in:
Ali Mohammad Pur 2021-06-11 01:38:30 +04:30 • committed by Andreas Kling
parent c53a86a3fe
commit 3234697eca
21 changed files with 407 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

15
Userland/Libraries/LibJS/AST.cpp
View file

@ -259,6 +259,12 @@ Value CallExpression::execute(Interpreter& interpreter, GlobalObject& global_obj
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 };
@ -1151,7 +1157,7 @@ void BindingPattern::dump(int indent) const
void FunctionNode::dump(int indent, const String& class_name) const
{
print_indent(indent);
outln("{} '{}'", class_name, name());
outln("{}{} '{}'", class_name, m_is_generator ? "*" : "", name());
if (!m_parameters.is_empty()) {
print_indent(indent + 1);
outln("(Parameters)");
@ -1193,6 +1199,13 @@ 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);

31
Userland/Libraries/LibJS/AST.h
View file

@ -227,14 +227,16 @@ public:
const Vector<Parameter>& parameters() const { return m_parameters; };
i32 function_length() const { return m_function_length; }
bool is_strict_mode() const { return m_is_strict_mode; }
bool is_generator() const { return m_is_generator; }
protected:
FunctionNode(const FlyString& name, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, NonnullRefPtrVector<VariableDeclaration> variables, bool is_strict_mode)
FunctionNode(const FlyString& name, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, NonnullRefPtrVector<VariableDeclaration> variables, bool is_generator, bool is_strict_mode)
: m_name(name)
, m_body(move(body))
, m_parameters(move(parameters))
, m_variables(move(variables))
, m_function_length(function_length)
, m_is_generator(is_generator)
, m_is_strict_mode(is_strict_mode)
{
}
@ -256,6 +258,7 @@ private:
const Vector<Parameter> m_parameters;
NonnullRefPtrVector<VariableDeclaration> m_variables;
const i32 m_function_length;
bool m_is_generator;
bool m_is_strict_mode;
};
@ -265,9 +268,9 @@ class FunctionDeclaration final
public:
static bool must_have_name() { return true; }
FunctionDeclaration(SourceRange source_range, const FlyString& name, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, NonnullRefPtrVector<VariableDeclaration> variables, bool is_strict_mode = false)
FunctionDeclaration(SourceRange source_range, const FlyString& name, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, NonnullRefPtrVector<VariableDeclaration> variables, bool is_generator, bool is_strict_mode = false)
: Declaration(move(source_range))
, FunctionNode(name, move(body), move(parameters), function_length, move(variables), is_strict_mode)
, FunctionNode(name, move(body), move(parameters), function_length, move(variables), is_generator, is_strict_mode)
{
}
@ -282,9 +285,9 @@ class FunctionExpression final
public:
static bool must_have_name() { return false; }
FunctionExpression(SourceRange source_range, const FlyString& name, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, NonnullRefPtrVector<VariableDeclaration> variables, bool is_strict_mode, bool is_arrow_function = false)
FunctionExpression(SourceRange source_range, const FlyString& name, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, NonnullRefPtrVector<VariableDeclaration> variables, bool is_generator, bool is_strict_mode, bool is_arrow_function = false)
: Expression(source_range)
, FunctionNode(name, move(body), move(parameters), function_length, move(variables), is_strict_mode)
, FunctionNode(name, move(body), move(parameters), function_length, move(variables), is_generator, is_strict_mode)
, m_is_arrow_function(is_arrow_function)
{
}
@ -318,6 +321,24 @@ public:
Value execute(Interpreter&, GlobalObject&) const override { return {}; }
};
class YieldExpression final : public Expression {
public:
explicit YieldExpression(SourceRange source_range, RefPtr<Expression> argument)
: Expression(move(source_range))
, m_argument(move(argument))
{
}
const Expression* argument() const { return m_argument; }
virtual Value execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
private:
RefPtr<Expression> m_argument;
};
class ReturnStatement final : public Statement {
public:
explicit ReturnStatement(SourceRange source_range, RefPtr<Expression> argument)

16
Userland/Libraries/LibJS/Bytecode/ASTCodegen.cpp
View file

@ -668,9 +668,25 @@ void ReturnStatement::generate_bytecode(Bytecode::Generator& generator) const
{
if (m_argument)
m_argument->generate_bytecode(generator);
if (generator.is_in_generator_function())
generator.emit<Bytecode::Op::Yield>(nullptr);
else
generator.emit<Bytecode::Op::Return>();
}
void YieldExpression::generate_bytecode(Bytecode::Generator& generator) const
{
VERIFY(generator.is_in_generator_function());
if (m_argument)
m_argument->generate_bytecode(generator);
auto& continuation_block = generator.make_block();
generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block });
generator.switch_to_basic_block(continuation_block);
}
void IfStatement::generate_bytecode(Bytecode::Generator& generator) const
{
// test

19
Userland/Libraries/LibJS/Bytecode/Generator.cpp
View file

@ -23,11 +23,28 @@ Generator::~Generator()
{
}
Executable Generator::generate(ASTNode const& node)
Executable Generator::generate(ASTNode const& node, bool is_in_generator_function)
{
Generator generator;
generator.switch_to_basic_block(generator.make_block());
if (is_in_generator_function) {
generator.enter_generator_context();
// Immediately yield with no value.
auto& start_block = generator.make_block();
generator.emit<Bytecode::Op::Yield>(Label { start_block });
generator.switch_to_basic_block(start_block);
}
node.generate_bytecode(generator);
if (is_in_generator_function) {
// Terminate all unterminated blocks with yield return
for (auto& block : generator.m_root_basic_blocks) {
if (block.is_terminated())
continue;
generator.switch_to_basic_block(block);
generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
generator.emit<Bytecode::Op::Yield>(nullptr);
}
}
return { move(generator.m_root_basic_blocks), move(generator.m_string_table), generator.m_next_register };
}

7
Userland/Libraries/LibJS/Bytecode/Generator.h
View file

@ -28,7 +28,7 @@ struct Executable {
class Generator {
public:
static Executable generate(ASTNode const&);
static Executable generate(ASTNode const&, bool is_in_generator_function = false);
Register allocate_register();
@ -109,6 +109,10 @@ public:
return m_string_table->insert(string);
}
bool is_in_generator_function() const { return m_is_in_generator_function; }
void enter_generator_context() { m_is_in_generator_function = true; }
void leave_generator_context() { m_is_in_generator_function = false; }
private:
Generator();
~Generator();
@ -122,6 +126,7 @@ private:
u32 m_next_register { 2 };
u32 m_next_block { 1 };
bool m_is_in_generator_function { false };
Vector<Label> m_continuable_scopes;
Vector<Label> m_breakable_scopes;
};

3
Userland/Libraries/LibJS/Bytecode/Instruction.h
View file

@ -61,7 +61,8 @@
O(PushLexicalEnvironment) \
O(EnterUnwindContext) \
O(LeaveUnwindContext) \
O(ContinuePendingUnwind)
O(ContinuePendingUnwind) \
O(Yield)
namespace JS::Bytecode {

9
Userland/Libraries/LibJS/Bytecode/Interpreter.cpp
View file

@ -35,7 +35,7 @@ Interpreter::~Interpreter()
s_current = nullptr;
}
Value Interpreter::run(Executable const& executable)
Value Interpreter::run(Executable const& executable, BasicBlock const* entry_point)
{
dbgln_if(JS_BYTECODE_DEBUG, "Bytecode::Interpreter will run unit {:p}", &executable);
@ -56,10 +56,14 @@ Value Interpreter::run(Executable const& executable)
VERIFY(!vm().exception());
}
auto block = &executable.basic_blocks.first();
auto block = entry_point ?: &executable.basic_blocks.first();
if (m_manually_entered_frames) {
VERIFY(registers().size() >= executable.number_of_registers);
} else {
m_register_windows.append(make<RegisterWindow>());
registers().resize(executable.number_of_registers);
registers()[Register::global_object_index] = Value(&global_object());
}
for (;;) {
Bytecode::InstructionStreamIterator pc(block->instruction_stream());
@ -124,6 +128,7 @@ Value Interpreter::run(Executable const& executable)
vm().set_last_value(Badge<Interpreter> {}, accumulator());
if (!m_manually_entered_frames)
m_register_windows.take_last();
auto return_value = m_return_value.value_or(js_undefined());

16
Userland/Libraries/LibJS/Bytecode/Interpreter.h
View file

@ -30,10 +30,23 @@ public:
GlobalObject& global_object() { return m_global_object; }
VM& vm() { return m_vm; }
Value run(Bytecode::Executable const&);
Value run(Bytecode::Executable const&, Bytecode::BasicBlock const* entry_point = nullptr);
ALWAYS_INLINE Value& accumulator() { return reg(Register::accumulator()); }
Value& reg(Register const& r) { return registers()[r.index()]; }
[[nodiscard]] RegisterWindow snapshot_frame() const { return m_register_windows.last(); }
void enter_frame(RegisterWindow const& frame)
{
++m_manually_entered_frames;
m_register_windows.append(make<RegisterWindow>(frame));
}
void leave_frame()
{
VERIFY(m_manually_entered_frames);
--m_manually_entered_frames;
m_register_windows.take_last();
}
void jump(Label const& label)
{
@ -55,6 +68,7 @@ private:
NonnullOwnPtrVector<RegisterWindow> m_register_windows;
Optional<BasicBlock const*> m_pending_jump;
Value m_return_value;
size_t m_manually_entered_frames { 0 };
Executable const* m_current_executable { nullptr };
Vector<UnwindInfo> m_unwind_contexts;
Handle<Exception> m_saved_exception;

22
Userland/Libraries/LibJS/Bytecode/Op.cpp
View file

@ -218,8 +218,7 @@ void Call::execute(Bytecode::Interpreter& interpreter) const
void NewFunction::execute(Bytecode::Interpreter& interpreter) const
{
auto& vm = interpreter.vm();
auto& global_object = interpreter.global_object();
interpreter.accumulator() = ScriptFunction::create(global_object, m_function_node.name(), m_function_node.body(), m_function_node.parameters(), m_function_node.function_length(), vm.current_scope(), m_function_node.is_strict_mode());
interpreter.accumulator() = ScriptFunction::create(interpreter.global_object(), m_function_node.name(), m_function_node.body(), m_function_node.parameters(), m_function_node.function_length(), vm.current_scope(), m_function_node.is_generator(), m_function_node.is_strict_mode());
}
void Return::execute(Bytecode::Interpreter& interpreter) const
@ -280,6 +279,18 @@ void PushLexicalEnvironment::execute(Bytecode::Interpreter& interpreter) const
interpreter.vm().call_frame().scope = block_lexical_environment;
}
void Yield::execute(Bytecode::Interpreter& interpreter) const
{
auto yielded_value = interpreter.accumulator().value_or(js_undefined());
auto object = JS::Object::create_empty(interpreter.global_object());
object->put("result", yielded_value);
if (m_continuation_label.has_value())
object->put("continuation", Value(static_cast<double>(reinterpret_cast<u64>(&m_continuation_label->block()))));
else
object->put("continuation", Value(0));
interpreter.do_return(object);
}
String Load::to_string(Bytecode::Executable const&) const
{
return String::formatted("Load {}", m_src);
@ -445,4 +456,11 @@ String PushLexicalEnvironment::to_string(const Bytecode::Executable& executable)
return builder.to_string();
}
String Yield::to_string(Bytecode::Executable const&) const
{
if (m_continuation_label.has_value())
return String::formatted("Yield continuation:@{}", m_continuation_label->block().name());
return String::formatted("Yield return");
}
}

25
Userland/Libraries/LibJS/Bytecode/Op.h
View file

@ -184,8 +184,6 @@ public:
void execute(Bytecode::Interpreter&) const;
String to_string(Bytecode::Executable const&) const;
size_t length() const { return sizeof(*this) + sizeof(Register) * m_element_count; }
private:
size_t m_element_count { 0 };
Register m_elements[];
@ -462,6 +460,28 @@ private:
Label m_resume_target;
};
class Yield final : public Instruction {
public:
constexpr static bool IsTerminator = true;
explicit Yield(Label continuation_label)
: Instruction(Type::Yield)
, m_continuation_label(continuation_label)
{
}
explicit Yield(std::nullptr_t)
: Instruction(Type::Yield)
{
}
void execute(Bytecode::Interpreter&) const;
String to_string(Bytecode::Executable const&) const;
private:
Optional<Label> m_continuation_label;
};
class PushLexicalEnvironment final : public Instruction {
public:
PushLexicalEnvironment(HashMap<u32, Variable> variables)
@ -472,6 +492,7 @@ public:
void execute(Bytecode::Interpreter&) const;
String to_string(Bytecode::Executable const&) const;
private:
HashMap<u32, Variable> m_variables;
};
}

1
Userland/Libraries/LibJS/CMakeLists.txt
View file

@ -45,6 +45,7 @@ set(SOURCES
Runtime/FunctionConstructor.cpp
Runtime/Function.cpp
Runtime/FunctionPrototype.cpp
Runtime/GeneratorObject.cpp
Runtime/GlobalObject.cpp
Runtime/IndexedProperties.cpp
Runtime/IteratorOperations.cpp

2
Userland/Libraries/LibJS/Interpreter.cpp
View file

@ -79,7 +79,7 @@ void Interpreter::enter_scope(const ScopeNode& scope_node, ScopeType scope_type,
{
ScopeGuard guard([&] {
for (auto& declaration : scope_node.functions()) {
auto* function = ScriptFunction::create(global_object, declaration.name(), declaration.body(), declaration.parameters(), declaration.function_length(), current_scope(), declaration.is_strict_mode());
auto* function = ScriptFunction::create(global_object, declaration.name(), declaration.body(), declaration.parameters(), declaration.function_length(), current_scope(), declaration.is_generator(), declaration.is_strict_mode());
vm().set_variable(declaration.name(), function, global_object);
}
});

29
Userland/Libraries/LibJS/Parser.cpp
View file

@ -590,9 +590,9 @@ NonnullRefPtr<ClassExpression> Parser::parse_class_expression(bool expect_class_
constructor_body->append(create_ast_node<ExpressionStatement>({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(super_call)));
constructor_body->add_variables(m_parser_state.m_var_scopes.last());
constructor = create_ast_node<FunctionExpression>({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, class_name, move(constructor_body), Vector { FunctionNode::Parameter { FlyString { "args" }, nullptr, true } }, 0, NonnullRefPtrVector<VariableDeclaration>(), true);
constructor = create_ast_node<FunctionExpression>({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, class_name, move(constructor_body), Vector { FunctionNode::Parameter { FlyString { "args" }, nullptr, true } }, 0, NonnullRefPtrVector<VariableDeclaration>(), false, true);
} else {
constructor = create_ast_node<FunctionExpression>({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, class_name, move(constructor_body), Vector<FunctionNode::Parameter> {}, 0, NonnullRefPtrVector<VariableDeclaration>(), true);
constructor = create_ast_node<FunctionExpression>({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, class_name, move(constructor_body), Vector<FunctionNode::Parameter> {}, 0, NonnullRefPtrVector<VariableDeclaration>(), false, true);
}
}
@ -634,6 +634,7 @@ NonnullRefPtr<Expression> Parser::parse_primary_expression()
syntax_error("'super' keyword unexpected here");
return create_ast_node<SuperExpression>({ m_parser_state.m_current_token.filename(), rule_start.position(), position() });
case TokenType::Identifier: {
read_as_identifier:;
if (!try_parse_arrow_function_expression_failed_at_position(position())) {
auto arrow_function_result = try_parse_arrow_function_expression(false);
if (!arrow_function_result.is_null())
@ -674,6 +675,10 @@ NonnullRefPtr<Expression> Parser::parse_primary_expression()
}
return parse_new_expression();
}
case TokenType::Yield:
if (!m_parser_state.m_in_generator_function_context)
goto read_as_identifier;
return parse_yield_expression();
default:
expected("primary expression");
consume();
@ -1256,6 +1261,16 @@ NonnullRefPtr<NewExpression> Parser::parse_new_expression()
return create_ast_node<NewExpression>({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(callee), move(arguments));
}
NonnullRefPtr<YieldExpression> Parser::parse_yield_expression()
{
auto rule_start = push_start();
consume(TokenType::Yield);
RefPtr<Expression> argument;
if (match_expression())
argument = parse_expression(0);
return create_ast_node<YieldExpression>({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(argument));
}
NonnullRefPtr<ReturnStatement> Parser::parse_return_statement()
{
auto rule_start = push_start();
@ -1336,9 +1351,14 @@ NonnullRefPtr<FunctionNodeType> Parser::parse_function_node(u8 parse_options)
ScopePusher scope(*this, ScopePusher::Var | ScopePusher::Function);
auto is_generator = false;
String name;
if (parse_options & FunctionNodeParseOptions::CheckForFunctionAndName) {
consume(TokenType::Function);
is_generator = match(TokenType::Asterisk);
if (is_generator)
consume(TokenType::Asterisk);
if (FunctionNodeType::must_have_name() || match(TokenType::Identifier))
name = consume(TokenType::Identifier).value();
}
@ -1351,6 +1371,7 @@ NonnullRefPtr<FunctionNodeType> Parser::parse_function_node(u8 parse_options)
function_length = parameters.size();
TemporaryChange change(m_parser_state.m_in_function_context, true);
TemporaryChange generator_change(m_parser_state.m_in_generator_function_context, m_parser_state.m_in_generator_function_context || is_generator);
auto old_labels_in_scope = move(m_parser_state.m_labels_in_scope);
ScopeGuard guard([&]() {
m_parser_state.m_labels_in_scope = move(old_labels_in_scope);
@ -1360,7 +1381,7 @@ NonnullRefPtr<FunctionNodeType> Parser::parse_function_node(u8 parse_options)
auto body = parse_block_statement(is_strict);
body->add_variables(m_parser_state.m_var_scopes.last());
body->add_functions(m_parser_state.m_function_scopes.last());
return create_ast_node<FunctionNodeType>({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, name, move(body), move(parameters), function_length, NonnullRefPtrVector<VariableDeclaration>(), is_strict);
return create_ast_node<FunctionNodeType>({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, name, move(body), move(parameters), function_length, NonnullRefPtrVector<VariableDeclaration>(), is_generator, is_strict);
}
Vector<FunctionNode::Parameter> Parser::parse_formal_parameters(int& function_length, u8 parse_options)
@ -2009,6 +2030,7 @@ bool Parser::match_expression() const
|| type == TokenType::This
|| type == TokenType::Super
|| type == TokenType::RegexLiteral
|| type == TokenType::Yield
|| match_unary_prefixed_expression();
}
@ -2085,6 +2107,7 @@ bool Parser::match_statement() const
auto type = m_parser_state.m_current_token.type();
return match_expression()
|| type == TokenType::Return
|| type == TokenType::Yield
|| type == TokenType::Do
|| type == TokenType::If
|| type == TokenType::Throw

2
Userland/Libraries/LibJS/Parser.h
View file

@ -77,6 +77,7 @@ public:
NonnullRefPtr<NewExpression> parse_new_expression();
NonnullRefPtr<ClassDeclaration> parse_class_declaration();
NonnullRefPtr<ClassExpression> parse_class_expression(bool expect_class_name);
NonnullRefPtr<YieldExpression> parse_yield_expression();
NonnullRefPtr<Expression> parse_property_key();
NonnullRefPtr<AssignmentExpression> parse_assignment_expression(AssignmentOp, NonnullRefPtr<Expression> lhs, int min_precedence, Associativity);
@ -200,6 +201,7 @@ private:
bool m_allow_super_property_lookup { false };
bool m_allow_super_constructor_call { false };
bool m_in_function_context { false };
bool m_in_generator_function_context { false };
bool m_in_arrow_function_context { false };
bool m_in_break_context { false };
bool m_in_continue_context { false };

2
Userland/Libraries/LibJS/Runtime/CommonPropertyNames.h
View file

@ -293,6 +293,8 @@ struct CommonPropertyNames {
FlyString catch_ { "catch" };
FlyString delete_ { "delete" };
FlyString for_ { "for" };
FlyString return_ { "return" };
FlyString throw_ { "throw" };
#define __ENUMERATE(x) FlyString x { #x };
ENUMERATE_STANDARD_PROPERTY_NAMES(__ENUMERATE)
#undef __ENUMERATE

163
Userland/Libraries/LibJS/Runtime/GeneratorObject.cpp Normal file
View file

@ -0,0 +1,163 @@
/*
* Copyright (c) 2021, Ali Mohammad Pur <mpfard@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/TemporaryChange.h>
#include <LibJS/Bytecode/Generator.h>
#include <LibJS/Bytecode/Interpreter.h>
#include <LibJS/Runtime/GeneratorObject.h>
#include <LibJS/Runtime/GlobalObject.h>
namespace JS {
GeneratorObject* GeneratorObject::create(GlobalObject& global_object, Value initial_value, ScriptFunction* generating_function, ScopeObject* generating_scope, Bytecode::RegisterWindow frame)
{
auto object = global_object.heap().allocate<GeneratorObject>(global_object, global_object);
object->m_generating_function = generating_function;
object->m_scope = generating_scope;
object->m_frame = move(frame);
object->m_previous_value = initial_value;
return object;
}
GeneratorObject::GeneratorObject(GlobalObject& global_object)
: Object(*global_object.object_prototype())
{
}
void GeneratorObject::initialize(GlobalObject& global_object)
{
auto& vm = this->vm();
Object::initialize(global_object);
define_native_function(vm.names.next, next);
define_native_function(vm.names.return_, return_);
define_native_function(vm.names.throw_, throw_);
}
GeneratorObject::~GeneratorObject()
{
}
void GeneratorObject::visit_edges(Cell::Visitor& visitor)
{
Object::visit_edges(visitor);
visitor.visit(m_scope);
visitor.visit(m_generating_function);
if (m_previous_value.is_object())
visitor.visit(&m_previous_value.as_object());
}
GeneratorObject* GeneratorObject::typed_this(VM& vm, GlobalObject& global_object)
{
auto* this_object = vm.this_value(global_object).to_object(global_object);
if (!this_object)
return {};
if (!is<GeneratorObject>(this_object)) {
vm.throw_exception<TypeError>(global_object, ErrorType::NotA, "Generator");
return nullptr;
}
return static_cast<GeneratorObject*>(this_object);
}
Value GeneratorObject::next_impl(VM& vm, GlobalObject& global_object, Optional<Value> value_to_throw)
{
auto bytecode_interpreter = Bytecode::Interpreter::current();
VERIFY(bytecode_interpreter);
auto generated_value = [](Value value) {
if (value.is_object())
return value.as_object().get("result");
return value.is_empty() ? js_undefined() : value;
};
auto generated_continuation = [&](Value value) -> Bytecode::BasicBlock const* {
if (value.is_object())
return reinterpret_cast<Bytecode::BasicBlock const*>(static_cast<u64>(value.as_object().get("continuation").to_double(global_object)));
return nullptr;
};
Value previous_generated_value { generated_value(m_previous_value) };
if (vm.exception())
return {};
auto result = Object::create_empty(global_object);
result->put("value", previous_generated_value);
if (m_done) {
result->put("done", Value(true));
return result;
}
// Extract the continuation
auto next_block = generated_continuation(m_previous_value);
if (vm.exception())
return {};
if (!next_block) {
// The generator has terminated, now we can simply return done=true.
m_done = true;
result->put("done", Value(true));
return result;
}
// Make sure it's an actual block
VERIFY(!m_generating_function->bytecode_executable()->basic_blocks.find_if([next_block](auto& block) { return block == next_block; }).is_end());
// Restore the snapshot registers
bytecode_interpreter->enter_frame(m_frame);
// Pretend that 'yield' returned the passed value, or threw
if (value_to_throw.has_value()) {
vm.throw_exception(global_object, value_to_throw.release_value());
bytecode_interpreter->accumulator() = js_undefined();
} else {
bytecode_interpreter->accumulator() = vm.argument(0);
}
// Temporarily switch to the captured scope
TemporaryChange change { vm.call_frame().scope, m_scope };
m_previous_value = bytecode_interpreter->run(*m_generating_function->bytecode_executable(), next_block);
bytecode_interpreter->leave_frame();
m_done = generated_continuation(m_previous_value) == nullptr;
result->put("value", generated_value(m_previous_value));
result->put("done", Value(m_done));
if (vm.exception())
return {};
return result;
}
JS_DEFINE_NATIVE_FUNCTION(GeneratorObject::next)
{
auto object = typed_this(vm, global_object);
if (!object)
return {};
return object->next_impl(vm, global_object, {});
}
JS_DEFINE_NATIVE_FUNCTION(GeneratorObject::return_)
{
auto object = typed_this(vm, global_object);
if (!object)
return {};
object->m_done = true;
return object->next_impl(vm, global_object, {});
}
JS_DEFINE_NATIVE_FUNCTION(GeneratorObject::throw_)
{
auto object = typed_this(vm, global_object);
if (!object)
return {};
return object->next_impl(vm, global_object, vm.argument(0));
}
}

40
Userland/Libraries/LibJS/Runtime/GeneratorObject.h Normal file
View file

@ -0,0 +1,40 @@
/*
* Copyright (c) 2021, Ali Mohammad Pur <mpfard@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <LibJS/Runtime/Object.h>
#include <LibJS/Runtime/ScriptFunction.h>
namespace JS {
class GeneratorObject final : public Object {
JS_OBJECT(GeneratorObject, Object);
public:
static GeneratorObject* create(GlobalObject&, Value, ScriptFunction*, ScopeObject*, Bytecode::RegisterWindow);
explicit GeneratorObject(GlobalObject&);
virtual void initialize(GlobalObject&) override;
virtual ~GeneratorObject() override;
void visit_edges(Cell::Visitor&) override;
static GeneratorObject* typed_this(VM&, GlobalObject&);
private:
JS_DECLARE_NATIVE_FUNCTION(next);
JS_DECLARE_NATIVE_FUNCTION(return_);
JS_DECLARE_NATIVE_FUNCTION(throw_);
Value next_impl(VM&, GlobalObject&, Optional<Value> value_to_throw);
ScopeObject* m_scope { nullptr };
ScriptFunction* m_generating_function { nullptr };
Value m_previous_value;
Bytecode::RegisterWindow m_frame;
bool m_done { false };
};
}

18
Userland/Libraries/LibJS/Runtime/ScriptFunction.cpp
View file

@ -13,7 +13,9 @@
#include <LibJS/Interpreter.h>
#include <LibJS/Runtime/Array.h>
#include <LibJS/Runtime/Error.h>
#include <LibJS/Runtime/GeneratorObject.h>
#include <LibJS/Runtime/GlobalObject.h>
#include <LibJS/Runtime/NativeFunction.h>
#include <LibJS/Runtime/ScriptFunction.h>
#include <LibJS/Runtime/Value.h>
@ -31,18 +33,19 @@ static ScriptFunction* typed_this(VM& vm, GlobalObject& global_object)
return static_cast<ScriptFunction*>(this_object);
}
ScriptFunction* ScriptFunction::create(GlobalObject& global_object, const FlyString& name, const Statement& body, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, ScopeObject* parent_scope, bool is_strict, bool is_arrow_function)
ScriptFunction* ScriptFunction::create(GlobalObject& global_object, const FlyString& name, const Statement& body, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, ScopeObject* parent_scope, bool is_generator, bool is_strict, bool is_arrow_function)
{
return global_object.heap().allocate<ScriptFunction>(global_object, global_object, name, body, move(parameters), m_function_length, parent_scope, *global_object.function_prototype(), is_strict, is_arrow_function);
return global_object.heap().allocate<ScriptFunction>(global_object, global_object, name, body, move(parameters), m_function_length, parent_scope, *global_object.function_prototype(), is_generator, is_strict, is_arrow_function);
}
ScriptFunction::ScriptFunction(GlobalObject& global_object, const FlyString& name, const Statement& body, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, ScopeObject* parent_scope, Object& prototype, bool is_strict, bool is_arrow_function)
ScriptFunction::ScriptFunction(GlobalObject& global_object, const FlyString& name, const Statement& body, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, ScopeObject* parent_scope, Object& prototype, bool is_generator, bool is_strict, bool is_arrow_function)
: Function(prototype, is_arrow_function ? vm().this_value(global_object) : Value(), {})
, m_name(name)
, m_body(body)
, m_parameters(move(parameters))
, m_parent_scope(parent_scope)
, m_function_length(m_function_length)
, m_is_generator(is_generator)
, m_is_strict(is_strict)
, m_is_arrow_function(is_arrow_function)
{
@ -152,15 +155,20 @@ Value ScriptFunction::execute_function_body()
if (bytecode_interpreter) {
prepare_arguments();
if (!m_bytecode_executable.has_value()) {
m_bytecode_executable = Bytecode::Generator::generate(m_body);
m_bytecode_executable = Bytecode::Generator::generate(m_body, m_is_generator);
if constexpr (JS_BYTECODE_DEBUG) {
dbgln("Compiled Bytecode::Block for function '{}':", m_name);
for (auto& block : m_bytecode_executable->basic_blocks)
block.dump(*m_bytecode_executable);
}
}
return bytecode_interpreter->run(*m_bytecode_executable);
auto result = bytecode_interpreter->run(*m_bytecode_executable);
if (!m_is_generator)
return result;
return GeneratorObject::create(global_object(), result, this, vm.call_frame().scope, bytecode_interpreter->snapshot_frame());
} else {
VERIFY(!m_is_generator);
OwnPtr<Interpreter> local_interpreter;
ast_interpreter = vm.interpreter_if_exists();

7
Userland/Libraries/LibJS/Runtime/ScriptFunction.h
View file

@ -16,9 +16,9 @@ class ScriptFunction final : public Function {
JS_OBJECT(ScriptFunction, Function);
public:
static ScriptFunction* create(GlobalObject&, const FlyString& name, const Statement& body, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, ScopeObject* parent_scope, bool is_strict, bool is_arrow_function = false);
static ScriptFunction* create(GlobalObject&, const FlyString& name, const Statement& body, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, ScopeObject* parent_scope, bool is_generator, bool is_strict, bool is_arrow_function = false);
ScriptFunction(GlobalObject&, const FlyString& name, const Statement& body, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, ScopeObject* parent_scope, Object& prototype, bool is_strict, bool is_arrow_function = false);
ScriptFunction(GlobalObject&, const FlyString& name, const Statement& body, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, ScopeObject* parent_scope, Object& prototype, bool is_generator, bool is_strict, bool is_arrow_function = false);
virtual void initialize(GlobalObject&) override;
virtual ~ScriptFunction();
@ -33,6 +33,8 @@ public:
void set_is_class_constructor() { m_is_class_constructor = true; };
auto& bytecode_executable() const { return m_bytecode_executable; }
protected:
virtual bool is_strict_mode() const final { return m_is_strict; }
@ -51,6 +53,7 @@ private:
Optional<Bytecode::Executable> m_bytecode_executable;
ScopeObject* m_parent_scope { nullptr };
i32 m_function_length { 0 };
bool m_is_generator { false };
bool m_is_strict { false };
bool m_is_arrow_function { false };
bool m_is_class_constructor { false };

2
Userland/Libraries/LibWeb/HTML/GlobalEventHandlers.cpp
View file

@ -49,7 +49,7 @@ void GlobalEventHandlers::set_event_handler_attribute(const FlyString& name, HTM
dbgln("Failed to parse script in event handler attribute '{}'", name);
return;
}
auto* function = JS::ScriptFunction::create(self.script_execution_context()->interpreter().global_object(), name, program->body(), program->parameters(), program->function_length(), nullptr, false, false);
auto* function = JS::ScriptFunction::create(self.script_execution_context()->interpreter().global_object(), name, program->body(), program->parameters(), program->function_length(), nullptr, false, false, false);
VERIFY(function);
listener = adopt_ref(*new DOM::EventListener(JS::make_handle(static_cast<JS::Function*>(function))));
}

2
Userland/Libraries/LibWeb/HTML/WebSocket.cpp
View file

@ -246,7 +246,7 @@ void WebSocket::set_event_handler_attribute(const FlyString& name, HTML::EventHa
dbgln("Failed to parse script in event handler attribute '{}'", name);
return;
}
auto* function = JS::ScriptFunction::create(script_execution_context()->interpreter().global_object(), name, program->body(), program->parameters(), program->function_length(), nullptr, false, false);
auto* function = JS::ScriptFunction::create(script_execution_context()->interpreter().global_object(), name, program->body(), program->parameters(), program->function_length(), nullptr, false, false, false);
VERIFY(function);
listener = adopt_ref(*new DOM::EventListener(JS::make_handle(static_cast<JS::Function*>(function))));
}