LibJS: Implement GeneratorFunctionConstructor::construct

Userland/Libraries/LibJS/Runtime/FunctionConstructor.cpp

@@ -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();
+    auto function = create_dynamic_function_node(global_object(), new_target, FunctionKind::Regular);
-    String parameters_source = "";
+    if (!function)
-    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());
         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());
 }
 
 }

Userland/Libraries/LibJS/Runtime/FunctionConstructor.h

@@ -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;

Userland/Libraries/LibJS/Runtime/GeneratorFunctionConstructor.cpp

@@ -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);
 }
 
 }