ScriptFunction.cpp 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249
  1. /*
  2. * Copyright (c) 2020, Stephan Unverwerth <s.unverwerth@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Debug.h>
  7. #include <AK/Function.h>
  8. #include <LibJS/AST.h>
  9. #include <LibJS/Bytecode/BasicBlock.h>
  10. #include <LibJS/Bytecode/Generator.h>
  11. #include <LibJS/Bytecode/Interpreter.h>
  12. #include <LibJS/Bytecode/PassManager.h>
  13. #include <LibJS/Interpreter.h>
  14. #include <LibJS/Runtime/Array.h>
  15. #include <LibJS/Runtime/Error.h>
  16. #include <LibJS/Runtime/FunctionEnvironmentRecord.h>
  17. #include <LibJS/Runtime/GeneratorObject.h>
  18. #include <LibJS/Runtime/GeneratorObjectPrototype.h>
  19. #include <LibJS/Runtime/GlobalObject.h>
  20. #include <LibJS/Runtime/NativeFunction.h>
  21. #include <LibJS/Runtime/ScriptFunction.h>
  22. #include <LibJS/Runtime/Value.h>
  23. namespace JS {
  24. static ScriptFunction* typed_this(VM& vm, GlobalObject& global_object)
  25. {
  26. auto* this_object = vm.this_value(global_object).to_object(global_object);
  27. if (!this_object)
  28. return nullptr;
  29. if (!this_object->is_function()) {
  30. vm.throw_exception<TypeError>(global_object, ErrorType::NotAFunctionNoParam);
  31. return nullptr;
  32. }
  33. return static_cast<ScriptFunction*>(this_object);
  34. }
  35. ScriptFunction* ScriptFunction::create(GlobalObject& global_object, const FlyString& name, const Statement& body, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, EnvironmentRecord* parent_scope, FunctionKind kind, bool is_strict, bool is_arrow_function)
  36. {
  37. Object* prototype = nullptr;
  38. switch (kind) {
  39. case FunctionKind::Regular:
  40. prototype = global_object.function_prototype();
  41. break;
  42. case FunctionKind::Generator:
  43. prototype = global_object.generator_function_prototype();
  44. break;
  45. }
  46. return global_object.heap().allocate<ScriptFunction>(global_object, global_object, name, body, move(parameters), m_function_length, parent_scope, *prototype, kind, is_strict, is_arrow_function);
  47. }
  48. ScriptFunction::ScriptFunction(GlobalObject& global_object, const FlyString& name, const Statement& body, Vector<FunctionNode::Parameter> parameters, i32 function_length, EnvironmentRecord* parent_scope, Object& prototype, FunctionKind kind, bool is_strict, bool is_arrow_function)
  49. : Function(is_arrow_function ? vm().this_value(global_object) : Value(), {}, prototype)
  50. , m_name(name)
  51. , m_body(body)
  52. , m_parameters(move(parameters))
  53. , m_parent_scope(parent_scope)
  54. , m_function_length(function_length)
  55. , m_kind(kind)
  56. , m_is_strict(is_strict)
  57. , m_is_arrow_function(is_arrow_function)
  58. {
  59. }
  60. void ScriptFunction::initialize(GlobalObject& global_object)
  61. {
  62. auto& vm = this->vm();
  63. Function::initialize(global_object);
  64. if (!m_is_arrow_function) {
  65. auto* prototype = vm.heap().allocate<Object>(global_object, *global_object.new_script_function_prototype_object_shape());
  66. switch (m_kind) {
  67. case FunctionKind::Regular:
  68. prototype->define_property(vm.names.constructor, this, Attribute::Writable | Attribute::Configurable);
  69. break;
  70. case FunctionKind::Generator:
  71. // prototype is "g1.prototype" in figure-2 (https://tc39.es/ecma262/img/figure-2.png)
  72. prototype->set_prototype(global_object.generator_object_prototype());
  73. break;
  74. }
  75. define_property(vm.names.prototype, prototype, Attribute::Writable);
  76. }
  77. define_native_property(vm.names.length, length_getter, {}, Attribute::Configurable);
  78. define_native_property(vm.names.name, name_getter, {}, Attribute::Configurable);
  79. }
  80. ScriptFunction::~ScriptFunction()
  81. {
  82. }
  83. void ScriptFunction::visit_edges(Visitor& visitor)
  84. {
  85. Function::visit_edges(visitor);
  86. visitor.visit(m_parent_scope);
  87. }
  88. FunctionEnvironmentRecord* ScriptFunction::create_environment_record(Function& function_being_invoked)
  89. {
  90. HashMap<FlyString, Variable> variables;
  91. for (auto& parameter : m_parameters) {
  92. parameter.binding.visit(
  93. [&](const FlyString& name) { variables.set(name, { js_undefined(), DeclarationKind::Var }); },
  94. [&](const NonnullRefPtr<BindingPattern>& binding) {
  95. binding->for_each_bound_name([&](const auto& name) {
  96. variables.set(name, { js_undefined(), DeclarationKind::Var });
  97. });
  98. });
  99. }
  100. if (is<ScopeNode>(body())) {
  101. for (auto& declaration : static_cast<const ScopeNode&>(body()).variables()) {
  102. for (auto& declarator : declaration.declarations()) {
  103. declarator.target().visit(
  104. [&](const NonnullRefPtr<Identifier>& id) {
  105. variables.set(id->string(), { js_undefined(), declaration.declaration_kind() });
  106. },
  107. [&](const NonnullRefPtr<BindingPattern>& binding) {
  108. binding->for_each_bound_name([&](const auto& name) {
  109. variables.set(name, { js_undefined(), declaration.declaration_kind() });
  110. });
  111. });
  112. }
  113. }
  114. }
  115. auto* environment = heap().allocate<FunctionEnvironmentRecord>(global_object(), m_parent_scope, variables);
  116. environment->set_function_object(function_being_invoked);
  117. if (m_is_arrow_function) {
  118. if (is<FunctionEnvironmentRecord>(m_parent_scope))
  119. environment->set_new_target(static_cast<FunctionEnvironmentRecord*>(m_parent_scope)->new_target());
  120. }
  121. return environment;
  122. }
  123. Value ScriptFunction::execute_function_body()
  124. {
  125. auto& vm = this->vm();
  126. Interpreter* ast_interpreter = nullptr;
  127. auto* bytecode_interpreter = Bytecode::Interpreter::current();
  128. auto prepare_arguments = [&] {
  129. auto& execution_context_arguments = vm.running_execution_context().arguments;
  130. for (size_t i = 0; i < m_parameters.size(); ++i) {
  131. auto& parameter = m_parameters[i];
  132. parameter.binding.visit(
  133. [&](const auto& param) {
  134. Value argument_value;
  135. if (parameter.is_rest) {
  136. auto* array = Array::create(global_object());
  137. for (size_t rest_index = i; rest_index < execution_context_arguments.size(); ++rest_index)
  138. array->indexed_properties().append(execution_context_arguments[rest_index]);
  139. argument_value = move(array);
  140. } else if (i < execution_context_arguments.size() && !execution_context_arguments[i].is_undefined()) {
  141. argument_value = execution_context_arguments[i];
  142. } else if (parameter.default_value) {
  143. // FIXME: Support default arguments in the bytecode world!
  144. if (!bytecode_interpreter)
  145. argument_value = parameter.default_value->execute(*ast_interpreter, global_object());
  146. if (vm.exception())
  147. return;
  148. } else {
  149. argument_value = js_undefined();
  150. }
  151. if (i >= execution_context_arguments.size())
  152. execution_context_arguments.resize(i + 1);
  153. execution_context_arguments[i] = argument_value;
  154. vm.assign(param, argument_value, global_object(), true, vm.lexical_environment());
  155. });
  156. if (vm.exception())
  157. return;
  158. }
  159. };
  160. if (bytecode_interpreter) {
  161. prepare_arguments();
  162. if (!m_bytecode_executable.has_value()) {
  163. m_bytecode_executable = Bytecode::Generator::generate(m_body, m_kind == FunctionKind::Generator);
  164. auto& passes = JS::Bytecode::Interpreter::optimization_pipeline();
  165. passes.perform(*m_bytecode_executable);
  166. if constexpr (JS_BYTECODE_DEBUG) {
  167. dbgln("Optimisation passes took {}us", passes.elapsed());
  168. dbgln("Compiled Bytecode::Block for function '{}':", m_name);
  169. for (auto& block : m_bytecode_executable->basic_blocks)
  170. block.dump(*m_bytecode_executable);
  171. }
  172. }
  173. auto result = bytecode_interpreter->run(*m_bytecode_executable);
  174. if (m_kind != FunctionKind::Generator)
  175. return result;
  176. return GeneratorObject::create(global_object(), result, this, vm.running_execution_context().lexical_environment, bytecode_interpreter->snapshot_frame());
  177. } else {
  178. VERIFY(m_kind != FunctionKind::Generator);
  179. OwnPtr<Interpreter> local_interpreter;
  180. ast_interpreter = vm.interpreter_if_exists();
  181. if (!ast_interpreter) {
  182. local_interpreter = Interpreter::create_with_existing_global_object(global_object());
  183. ast_interpreter = local_interpreter.ptr();
  184. }
  185. VM::InterpreterExecutionScope scope(*ast_interpreter);
  186. prepare_arguments();
  187. if (vm.exception())
  188. return {};
  189. return ast_interpreter->execute_statement(global_object(), m_body, ScopeType::Function);
  190. }
  191. }
  192. Value ScriptFunction::call()
  193. {
  194. if (m_is_class_constructor) {
  195. vm().throw_exception<TypeError>(global_object(), ErrorType::ClassConstructorWithoutNew, m_name);
  196. return {};
  197. }
  198. return execute_function_body();
  199. }
  200. Value ScriptFunction::construct(Function&)
  201. {
  202. if (m_is_arrow_function || m_kind == FunctionKind::Generator) {
  203. vm().throw_exception<TypeError>(global_object(), ErrorType::NotAConstructor, m_name);
  204. return {};
  205. }
  206. return execute_function_body();
  207. }
  208. JS_DEFINE_NATIVE_GETTER(ScriptFunction::length_getter)
  209. {
  210. auto* function = typed_this(vm, global_object);
  211. if (!function)
  212. return {};
  213. return Value(static_cast<i32>(function->m_function_length));
  214. }
  215. JS_DEFINE_NATIVE_GETTER(ScriptFunction::name_getter)
  216. {
  217. auto* function = typed_this(vm, global_object);
  218. if (!function)
  219. return {};
  220. return js_string(vm, function->name().is_null() ? "" : function->name());
  221. }
  222. }