beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-30 08:41:15 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

LibJS: Implement GeneratorFunctionConstructor::construct

Browse source
This commit is contained in:
Matthew Olsson 2021-06-16 10:52:48 -07:00 committed by Linus Groh
parent 22b17219ff
commit 9253fa1bad
Notes: sideshowbarker 2024-07-18 12:03:07 +09:00 
Author: https://github.com/mattco98
Commit: https://github.com/SerenityOS/serenity/commit/9253fa1bad7
Pull-request: https://github.com/SerenityOS/serenity/pull/8104
Reviewed-by: https://github.com/alimpfard
Reviewed-by: https://github.com/linusg
3 changed files with 72 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

78
Userland/Libraries/LibJS/Runtime/FunctionConstructor.cpp
View file

@ -4,11 +4,12 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/StringBuilder.h>
#include <LibJS/AST.h>
#include <LibJS/Interpreter.h>
#include <LibJS/Lexer.h>
#include <LibJS/Parser.h>
#include <LibJS/Runtime/Error.h>
#include <LibJS/Runtime/Function.h>
#include <LibJS/Runtime/FunctionConstructor.h>
#include <LibJS/Runtime/GlobalObject.h>
@ -31,6 +32,44 @@ FunctionConstructor::~FunctionConstructor()
{
}
// 20.2.1.1.1 CreateDynamicFunction ( constructor, newTarget, kind, args ), https://tc39.es/ecma262/#sec-createdynamicfunction
RefPtr<FunctionExpression> FunctionConstructor::create_dynamic_function_node(GlobalObject& global_object, Function&, FunctionKind kind)
{
auto& vm = global_object.vm();
String parameters_source = "";
String body_source = "";
if (vm.argument_count() == 1) {
body_source = vm.argument(0).to_string(global_object);
if (vm.exception())
return {};
}
if (vm.argument_count() > 1) {
Vector<String> parameters;
for (size_t i = 0; i < vm.argument_count() - 1; ++i) {
parameters.append(vm.argument(i).to_string(global_object));
if (vm.exception())
return {};
}
StringBuilder parameters_builder;
parameters_builder.join(',', parameters);
parameters_source = parameters_builder.build();
body_source = vm.argument(vm.argument_count() - 1).to_string(global_object);
if (vm.exception())
return {};
}
auto is_generator = kind == FunctionKind::Generator;
auto source = String::formatted("function{} anonymous({}\n) {{\n{}\n}}", is_generator ? "*" : "", parameters_source, body_source);
auto parser = Parser(Lexer(source));
auto function = parser.parse_function_node<FunctionExpression>();
if (parser.has_errors()) {
auto error = parser.errors()[0];
vm.throw_exception<SyntaxError>(global_object, error.to_string());
return {};
}
return function;
}
// 20.2.1.1 Function ( p1, p2, … , pn, body ), https://tc39.es/ecma262/#sec-function-p1-p2-pn-body
Value FunctionConstructor::call()
{
@ -38,41 +77,14 @@ Value FunctionConstructor::call()
}
// 20.2.1.1 Function ( p1, p2, … , pn, body ), https://tc39.es/ecma262/#sec-function-p1-p2-pn-body
Value FunctionConstructor::construct(Function&)
Value FunctionConstructor::construct(Function& new_target)
{
auto& vm = this->vm();
String parameters_source = "";
String body_source = "";
if (vm.argument_count() == 1) {
body_source = vm.argument(0).to_string(global_object());
if (vm.exception())
return {};
}
if (vm.argument_count() > 1) {
Vector<String> parameters;
for (size_t i = 0; i < vm.argument_count() - 1; ++i) {
parameters.append(vm.argument(i).to_string(global_object()));
if (vm.exception())
return {};
}
StringBuilder parameters_builder;
parameters_builder.join(',', parameters);
parameters_source = parameters_builder.build();
body_source = vm.argument(vm.argument_count() - 1).to_string(global_object());
if (vm.exception())
return {};
}
auto source = String::formatted("function anonymous({}\n) {{\n{}\n}}", parameters_source, body_source);
auto parser = Parser(Lexer(source));
auto function_expression = parser.parse_function_node<FunctionExpression>();
if (parser.has_errors()) {
auto error = parser.errors()[0];
vm.throw_exception<SyntaxError>(global_object(), error.to_string());
auto function = create_dynamic_function_node(global_object(), new_target, FunctionKind::Regular);
if (!function)
return {};
}
OwnPtr<Interpreter> local_interpreter;
Interpreter* interpreter = vm.interpreter_if_exists();
Interpreter* interpreter = vm().interpreter_if_exists();
if (!interpreter) {
local_interpreter = Interpreter::create_with_existing_global_object(global_object());
@ -80,7 +92,7 @@ Value FunctionConstructor::construct(Function&)
}
VM::InterpreterExecutionScope scope(*interpreter);
return function_expression->execute(*interpreter, global_object());
return function->execute(*interpreter, global_object());
}
}

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

@ -14,6 +14,8 @@ class FunctionConstructor final : public NativeFunction {
JS_OBJECT(FunctionConstructor, NativeFunction);
public:
static RefPtr<FunctionExpression> create_dynamic_function_node(GlobalObject& global_object, Function& new_target, FunctionKind kind);
explicit FunctionConstructor(GlobalObject&);
virtual void initialize(GlobalObject&) override;
virtual ~FunctionConstructor() override;

28
Userland/Libraries/LibJS/Runtime/GeneratorFunctionConstructor.cpp
View file

@ -4,10 +4,15 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Debug.h>
#include <AK/Optional.h>
#include <LibJS/Bytecode/Interpreter.h>
#include <LibJS/Lexer.h>
#include <LibJS/Parser.h>
#include <LibJS/Runtime/FunctionConstructor.h>
#include <LibJS/Runtime/Function.h>
#include <LibJS/Runtime/GeneratorFunctionConstructor.h>
#include <LibJS/Runtime/GlobalObject.h>
#include <LibJS/Runtime/ScriptFunction.h>
namespace JS {
@ -38,9 +43,26 @@ Value GeneratorFunctionConstructor::call()
}
// 27.3.1.1 GeneratorFunction ( p1, p2, … , pn, body ), https://tc39.es/ecma262/#sec-generatorfunction
Value GeneratorFunctionConstructor::construct(Function&)
Value GeneratorFunctionConstructor::construct(Function& new_target)
{
TODO();
auto function = FunctionConstructor::create_dynamic_function_node(global_object(), new_target, FunctionKind::Generator);
if (!function)
return {};
auto* bytecode_interpreter = Bytecode::Interpreter::current();
VERIFY(bytecode_interpreter);
auto executable = Bytecode::Generator::generate(function->body(), true);
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline();
passes.perform(executable);
if constexpr (JS_BYTECODE_DEBUG) {
dbgln("Optimisation passes took {}us", passes.elapsed());
dbgln("Compiled Bytecode::Block for function '{}':", function->name());
for (auto& block : executable.basic_blocks)
block.dump(executable);
}
return ScriptFunction::create(global_object(), function->name(), function->body(), function->parameters(), function->function_length(), vm().current_scope(), FunctionKind::Generator, function->is_strict_mode(), false);
}
}