ECMAScriptFunctionObject.cpp 60 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191
  1. /*
  2. * Copyright (c) 2020, Stephan Unverwerth <s.unverwerth@serenityos.org>
  3. * Copyright (c) 2020-2023, Linus Groh <linusg@serenityos.org>
  4. * Copyright (c) 2023, Andreas Kling <kling@serenityos.org>
  5. * Copyright (c) 2023, Shannon Booth <shannon@serenityos.org>
  6. *
  7. * SPDX-License-Identifier: BSD-2-Clause
  8. */
  9. #include <AK/Debug.h>
  10. #include <AK/Function.h>
  11. #include <LibJS/AST.h>
  12. #include <LibJS/Bytecode/BasicBlock.h>
  13. #include <LibJS/Bytecode/Generator.h>
  14. #include <LibJS/Bytecode/Interpreter.h>
  15. #include <LibJS/Interpreter.h>
  16. #include <LibJS/Runtime/AbstractOperations.h>
  17. #include <LibJS/Runtime/Array.h>
  18. #include <LibJS/Runtime/AsyncFunctionDriverWrapper.h>
  19. #include <LibJS/Runtime/AsyncGenerator.h>
  20. #include <LibJS/Runtime/ECMAScriptFunctionObject.h>
  21. #include <LibJS/Runtime/Error.h>
  22. #include <LibJS/Runtime/ExecutionContext.h>
  23. #include <LibJS/Runtime/FunctionEnvironment.h>
  24. #include <LibJS/Runtime/GeneratorObject.h>
  25. #include <LibJS/Runtime/GlobalObject.h>
  26. #include <LibJS/Runtime/NativeFunction.h>
  27. #include <LibJS/Runtime/PromiseCapability.h>
  28. #include <LibJS/Runtime/PromiseConstructor.h>
  29. #include <LibJS/Runtime/Value.h>
  30. namespace JS {
  31. NonnullGCPtr<ECMAScriptFunctionObject> ECMAScriptFunctionObject::create(Realm& realm, DeprecatedFlyString name, DeprecatedString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
  32. {
  33. Object* prototype = nullptr;
  34. switch (kind) {
  35. case FunctionKind::Normal:
  36. prototype = realm.intrinsics().function_prototype();
  37. break;
  38. case FunctionKind::Generator:
  39. prototype = realm.intrinsics().generator_function_prototype();
  40. break;
  41. case FunctionKind::Async:
  42. prototype = realm.intrinsics().async_function_prototype();
  43. break;
  44. case FunctionKind::AsyncGenerator:
  45. prototype = realm.intrinsics().async_generator_function_prototype();
  46. break;
  47. }
  48. return realm.heap().allocate<ECMAScriptFunctionObject>(realm, move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, move(local_variables_names), parent_environment, private_environment, *prototype, kind, is_strict, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function, move(class_field_initializer_name)).release_allocated_value_but_fixme_should_propagate_errors();
  49. }
  50. NonnullGCPtr<ECMAScriptFunctionObject> ECMAScriptFunctionObject::create(Realm& realm, DeprecatedFlyString name, Object& prototype, DeprecatedString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
  51. {
  52. return realm.heap().allocate<ECMAScriptFunctionObject>(realm, move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, move(local_variables_names), parent_environment, private_environment, prototype, kind, is_strict, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function, move(class_field_initializer_name)).release_allocated_value_but_fixme_should_propagate_errors();
  53. }
  54. ECMAScriptFunctionObject::ECMAScriptFunctionObject(DeprecatedFlyString name, DeprecatedString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> formal_parameters, i32 function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, Object& prototype, FunctionKind kind, bool strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
  55. : FunctionObject(prototype)
  56. , m_name(move(name))
  57. , m_function_length(function_length)
  58. , m_local_variables_names(move(local_variables_names))
  59. , m_environment(parent_environment)
  60. , m_private_environment(private_environment)
  61. , m_formal_parameters(move(formal_parameters))
  62. , m_ecmascript_code(ecmascript_code)
  63. , m_realm(&prototype.shape().realm())
  64. , m_source_text(move(source_text))
  65. , m_class_field_initializer_name(move(class_field_initializer_name))
  66. , m_strict(strict)
  67. , m_might_need_arguments_object(might_need_arguments_object)
  68. , m_contains_direct_call_to_eval(contains_direct_call_to_eval)
  69. , m_is_arrow_function(is_arrow_function)
  70. , m_kind(kind)
  71. {
  72. // NOTE: This logic is from OrdinaryFunctionCreate, https://tc39.es/ecma262/#sec-ordinaryfunctioncreate
  73. // 9. If thisMode is lexical-this, set F.[[ThisMode]] to lexical.
  74. if (m_is_arrow_function)
  75. m_this_mode = ThisMode::Lexical;
  76. // 10. Else if Strict is true, set F.[[ThisMode]] to strict.
  77. else if (m_strict)
  78. m_this_mode = ThisMode::Strict;
  79. else
  80. // 11. Else, set F.[[ThisMode]] to global.
  81. m_this_mode = ThisMode::Global;
  82. // 15. Set F.[[ScriptOrModule]] to GetActiveScriptOrModule().
  83. m_script_or_module = vm().get_active_script_or_module();
  84. // 15.1.3 Static Semantics: IsSimpleParameterList, https://tc39.es/ecma262/#sec-static-semantics-issimpleparameterlist
  85. m_has_simple_parameter_list = all_of(m_formal_parameters, [&](auto& parameter) {
  86. if (parameter.is_rest)
  87. return false;
  88. if (parameter.default_value)
  89. return false;
  90. if (!parameter.binding.template has<NonnullRefPtr<Identifier const>>())
  91. return false;
  92. return true;
  93. });
  94. }
  95. void ECMAScriptFunctionObject::initialize(Realm& realm)
  96. {
  97. auto& vm = this->vm();
  98. Base::initialize(realm);
  99. // Note: The ordering of these properties must be: length, name, prototype which is the order
  100. // they are defined in the spec: https://tc39.es/ecma262/#sec-function-instances .
  101. // This is observable through something like: https://tc39.es/ecma262/#sec-ordinaryownpropertykeys
  102. // which must give the properties in chronological order which in this case is the order they
  103. // are defined in the spec.
  104. MUST(define_property_or_throw(vm.names.length, { .value = Value(m_function_length), .writable = false, .enumerable = false, .configurable = true }));
  105. MUST(define_property_or_throw(vm.names.name, { .value = PrimitiveString::create(vm, m_name.is_null() ? "" : m_name), .writable = false, .enumerable = false, .configurable = true }));
  106. if (!m_is_arrow_function) {
  107. Object* prototype = nullptr;
  108. switch (m_kind) {
  109. case FunctionKind::Normal:
  110. prototype = MUST(vm.heap().allocate<Object>(realm, realm.intrinsics().new_ordinary_function_prototype_object_shape()));
  111. MUST(prototype->define_property_or_throw(vm.names.constructor, { .value = this, .writable = true, .enumerable = false, .configurable = true }));
  112. break;
  113. case FunctionKind::Generator:
  114. // prototype is "g1.prototype" in figure-2 (https://tc39.es/ecma262/img/figure-2.png)
  115. prototype = Object::create(realm, realm.intrinsics().generator_function_prototype_prototype());
  116. break;
  117. case FunctionKind::Async:
  118. break;
  119. case FunctionKind::AsyncGenerator:
  120. prototype = Object::create(realm, realm.intrinsics().async_generator_function_prototype_prototype());
  121. break;
  122. }
  123. // 27.7.4 AsyncFunction Instances, https://tc39.es/ecma262/#sec-async-function-instances
  124. // AsyncFunction instances do not have a prototype property as they are not constructible.
  125. if (m_kind != FunctionKind::Async)
  126. define_direct_property(vm.names.prototype, prototype, Attribute::Writable);
  127. }
  128. }
  129. // 10.2.1 [[Call]] ( thisArgument, argumentsList ), https://tc39.es/ecma262/#sec-ecmascript-function-objects-call-thisargument-argumentslist
  130. ThrowCompletionOr<Value> ECMAScriptFunctionObject::internal_call(Value this_argument, MarkedVector<Value> arguments_list)
  131. {
  132. auto& vm = this->vm();
  133. // 1. Let callerContext be the running execution context.
  134. // NOTE: No-op, kept by the VM in its execution context stack.
  135. ExecutionContext callee_context(heap());
  136. callee_context.local_variables.resize(m_local_variables_names.size());
  137. // Non-standard
  138. callee_context.arguments.extend(move(arguments_list));
  139. if (auto* interpreter = vm.interpreter_if_exists(); interpreter && interpreter->current_node())
  140. callee_context.source_range = interpreter->current_node()->unrealized_source_range();
  141. // 2. Let calleeContext be PrepareForOrdinaryCall(F, undefined).
  142. // NOTE: We throw if the end of the native stack is reached, so unlike in the spec this _does_ need an exception check.
  143. TRY(prepare_for_ordinary_call(callee_context, nullptr));
  144. // 3. Assert: calleeContext is now the running execution context.
  145. VERIFY(&vm.running_execution_context() == &callee_context);
  146. // 4. If F.[[IsClassConstructor]] is true, then
  147. if (m_is_class_constructor) {
  148. // a. Let error be a newly created TypeError object.
  149. // b. NOTE: error is created in calleeContext with F's associated Realm Record.
  150. auto throw_completion = vm.throw_completion<TypeError>(ErrorType::ClassConstructorWithoutNew, m_name);
  151. // c. Remove calleeContext from the execution context stack and restore callerContext as the running execution context.
  152. vm.pop_execution_context();
  153. // d. Return ThrowCompletion(error).
  154. return throw_completion;
  155. }
  156. // 5. Perform OrdinaryCallBindThis(F, calleeContext, thisArgument).
  157. ordinary_call_bind_this(callee_context, this_argument);
  158. // 6. Let result be Completion(OrdinaryCallEvaluateBody(F, argumentsList)).
  159. auto result = ordinary_call_evaluate_body();
  160. // 7. Remove calleeContext from the execution context stack and restore callerContext as the running execution context.
  161. vm.pop_execution_context();
  162. // 8. If result.[[Type]] is return, return result.[[Value]].
  163. if (result.type() == Completion::Type::Return)
  164. return *result.value();
  165. // 9. ReturnIfAbrupt(result).
  166. if (result.is_abrupt()) {
  167. VERIFY(result.is_error());
  168. return result;
  169. }
  170. // 10. Return undefined.
  171. return js_undefined();
  172. }
  173. // 10.2.2 [[Construct]] ( argumentsList, newTarget ), https://tc39.es/ecma262/#sec-ecmascript-function-objects-construct-argumentslist-newtarget
  174. ThrowCompletionOr<NonnullGCPtr<Object>> ECMAScriptFunctionObject::internal_construct(MarkedVector<Value> arguments_list, FunctionObject& new_target)
  175. {
  176. auto& vm = this->vm();
  177. // 1. Let callerContext be the running execution context.
  178. // NOTE: No-op, kept by the VM in its execution context stack.
  179. // 2. Let kind be F.[[ConstructorKind]].
  180. auto kind = m_constructor_kind;
  181. GCPtr<Object> this_argument;
  182. // 3. If kind is base, then
  183. if (kind == ConstructorKind::Base) {
  184. // a. Let thisArgument be ? OrdinaryCreateFromConstructor(newTarget, "%Object.prototype%").
  185. this_argument = TRY(ordinary_create_from_constructor<Object>(vm, new_target, &Intrinsics::object_prototype, ConstructWithPrototypeTag::Tag));
  186. }
  187. ExecutionContext callee_context(heap());
  188. callee_context.local_variables.resize(m_local_variables_names.size());
  189. // Non-standard
  190. callee_context.arguments.extend(move(arguments_list));
  191. if (auto* interpreter = vm.interpreter_if_exists(); interpreter && interpreter->current_node())
  192. callee_context.source_range = interpreter->current_node()->unrealized_source_range();
  193. // 4. Let calleeContext be PrepareForOrdinaryCall(F, newTarget).
  194. // NOTE: We throw if the end of the native stack is reached, so unlike in the spec this _does_ need an exception check.
  195. TRY(prepare_for_ordinary_call(callee_context, &new_target));
  196. // 5. Assert: calleeContext is now the running execution context.
  197. VERIFY(&vm.running_execution_context() == &callee_context);
  198. // 6. If kind is base, then
  199. if (kind == ConstructorKind::Base) {
  200. // a. Perform OrdinaryCallBindThis(F, calleeContext, thisArgument).
  201. ordinary_call_bind_this(callee_context, this_argument);
  202. // b. Let initializeResult be Completion(InitializeInstanceElements(thisArgument, F)).
  203. auto initialize_result = this_argument->initialize_instance_elements(*this);
  204. // c. If initializeResult is an abrupt completion, then
  205. if (initialize_result.is_throw_completion()) {
  206. // i. Remove calleeContext from the execution context stack and restore callerContext as the running execution context.
  207. vm.pop_execution_context();
  208. // ii. Return ? initializeResult.
  209. return initialize_result.throw_completion();
  210. }
  211. }
  212. // 7. Let constructorEnv be the LexicalEnvironment of calleeContext.
  213. auto constructor_env = callee_context.lexical_environment;
  214. // 8. Let result be Completion(OrdinaryCallEvaluateBody(F, argumentsList)).
  215. auto result = ordinary_call_evaluate_body();
  216. // 9. Remove calleeContext from the execution context stack and restore callerContext as the running execution context.
  217. vm.pop_execution_context();
  218. // 10. If result.[[Type]] is return, then
  219. if (result.type() == Completion::Type::Return) {
  220. // FIXME: This is leftover from untangling the call/construct mess - doesn't belong here in any way, but removing it breaks derived classes.
  221. // Likely fixed by making ClassDefinitionEvaluation fully spec compliant.
  222. if (kind == ConstructorKind::Derived && result.value()->is_object()) {
  223. auto prototype = TRY(new_target.get(vm.names.prototype));
  224. if (prototype.is_object())
  225. TRY(result.value()->as_object().internal_set_prototype_of(&prototype.as_object()));
  226. }
  227. // EOF (End of FIXME)
  228. // a. If Type(result.[[Value]]) is Object, return result.[[Value]].
  229. if (result.value()->is_object())
  230. return result.value()->as_object();
  231. // b. If kind is base, return thisArgument.
  232. if (kind == ConstructorKind::Base)
  233. return *this_argument;
  234. // c. If result.[[Value]] is not undefined, throw a TypeError exception.
  235. if (!result.value()->is_undefined())
  236. return vm.throw_completion<TypeError>(ErrorType::DerivedConstructorReturningInvalidValue);
  237. }
  238. // 11. Else, ReturnIfAbrupt(result).
  239. else if (result.is_abrupt()) {
  240. VERIFY(result.is_error());
  241. return result;
  242. }
  243. // 12. Let thisBinding be ? constructorEnv.GetThisBinding().
  244. auto this_binding = TRY(constructor_env->get_this_binding(vm));
  245. // 13. Assert: Type(thisBinding) is Object.
  246. VERIFY(this_binding.is_object());
  247. // 14. Return thisBinding.
  248. return this_binding.as_object();
  249. }
  250. void ECMAScriptFunctionObject::visit_edges(Visitor& visitor)
  251. {
  252. Base::visit_edges(visitor);
  253. visitor.visit(m_environment);
  254. visitor.visit(m_private_environment);
  255. visitor.visit(m_realm);
  256. visitor.visit(m_home_object);
  257. for (auto& field : m_fields) {
  258. if (auto* property_key_ptr = field.name.get_pointer<PropertyKey>(); property_key_ptr && property_key_ptr->is_symbol())
  259. visitor.visit(property_key_ptr->as_symbol());
  260. }
  261. m_script_or_module.visit(
  262. [](Empty) {},
  263. [&](auto& script_or_module) {
  264. visitor.visit(script_or_module.ptr());
  265. });
  266. }
  267. // 10.2.7 MakeMethod ( F, homeObject ), https://tc39.es/ecma262/#sec-makemethod
  268. void ECMAScriptFunctionObject::make_method(Object& home_object)
  269. {
  270. // 1. Set F.[[HomeObject]] to homeObject.
  271. m_home_object = &home_object;
  272. // 2. Return unused.
  273. }
  274. // 10.2.11 FunctionDeclarationInstantiation ( func, argumentsList ), https://tc39.es/ecma262/#sec-functiondeclarationinstantiation
  275. ThrowCompletionOr<void> ECMAScriptFunctionObject::function_declaration_instantiation(Interpreter* interpreter)
  276. {
  277. auto& vm = this->vm();
  278. auto& realm = *vm.current_realm();
  279. // 1. Let calleeContext be the running execution context.
  280. auto& callee_context = vm.running_execution_context();
  281. // 2. Let code be func.[[ECMAScriptCode]].
  282. ScopeNode const* scope_body = nullptr;
  283. if (is<ScopeNode>(*m_ecmascript_code))
  284. scope_body = static_cast<ScopeNode const*>(m_ecmascript_code.ptr());
  285. // 3. Let strict be func.[[Strict]].
  286. bool const strict = is_strict_mode();
  287. bool has_parameter_expressions = false;
  288. // 4. Let formals be func.[[FormalParameters]].
  289. auto const& formals = m_formal_parameters;
  290. // FIXME: Maybe compute has duplicates at parse time? (We need to anyway since it's an error in some cases)
  291. // 5. Let parameterNames be the BoundNames of formals.
  292. // 6. If parameterNames has any duplicate entries, let hasDuplicates be true. Otherwise, let hasDuplicates be false.
  293. bool has_duplicates = false;
  294. HashTable<DeprecatedFlyString> parameter_names;
  295. // NOTE: This loop performs step 5, 6, and 8.
  296. for (auto const& parameter : formals) {
  297. if (parameter.default_value)
  298. has_parameter_expressions = true;
  299. parameter.binding.visit(
  300. [&](Identifier const& identifier) {
  301. if (parameter_names.set(identifier.string()) != AK::HashSetResult::InsertedNewEntry)
  302. has_duplicates = true;
  303. },
  304. [&](NonnullRefPtr<BindingPattern const> const& pattern) {
  305. if (pattern->contains_expression())
  306. has_parameter_expressions = true;
  307. // NOTE: Nothing in the callback throws an exception.
  308. MUST(pattern->for_each_bound_identifier([&](auto& identifier) {
  309. if (parameter_names.set(identifier.string()) != AK::HashSetResult::InsertedNewEntry)
  310. has_duplicates = true;
  311. }));
  312. });
  313. }
  314. // 7. Let simpleParameterList be IsSimpleParameterList of formals.
  315. bool const simple_parameter_list = has_simple_parameter_list();
  316. // 8. Let hasParameterExpressions be ContainsExpression of formals.
  317. // NOTE: Already set above.
  318. // 9. Let varNames be the VarDeclaredNames of code.
  319. // 10. Let varDeclarations be the VarScopedDeclarations of code.
  320. // 11. Let lexicalNames be the LexicallyDeclaredNames of code.
  321. // NOTE: Not needed as we use iteration helpers for this instead.
  322. // 12. Let functionNames be a new empty List.
  323. HashTable<DeprecatedFlyString> function_names;
  324. // 13. Let functionsToInitialize be a new empty List.
  325. Vector<FunctionDeclaration const&> functions_to_initialize;
  326. // 14. For each element d of varDeclarations, in reverse List order, do
  327. // a. If d is neither a VariableDeclaration nor a ForBinding nor a BindingIdentifier, then
  328. // i. Assert: d is either a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration.
  329. // ii. Let fn be the sole element of the BoundNames of d.
  330. // iii. If functionNames does not contain fn, then
  331. // 1. Insert fn as the first element of functionNames.
  332. // 2. NOTE: If there are multiple function declarations for the same name, the last declaration is used.
  333. // 3. Insert d as the first element of functionsToInitialize.
  334. // NOTE: This block is done in step 18 below.
  335. // 15. Let argumentsObjectNeeded be true.
  336. auto arguments_object_needed = m_might_need_arguments_object;
  337. // 16. If func.[[ThisMode]] is lexical, then
  338. if (this_mode() == ThisMode::Lexical) {
  339. // a. NOTE: Arrow functions never have an arguments object.
  340. // b. Set argumentsObjectNeeded to false.
  341. arguments_object_needed = false;
  342. }
  343. // 17. Else if parameterNames contains "arguments", then
  344. else if (parameter_names.contains(vm.names.arguments.as_string())) {
  345. // a. Set argumentsObjectNeeded to false.
  346. arguments_object_needed = false;
  347. }
  348. // 18. Else if hasParameterExpressions is false, then
  349. // a. If functionNames contains "arguments" or lexicalNames contains "arguments", then
  350. // i. Set argumentsObjectNeeded to false.
  351. // NOTE: The block below is a combination of step 14 and step 18.
  352. if (scope_body) {
  353. // NOTE: Nothing in the callback throws an exception.
  354. MUST(scope_body->for_each_var_function_declaration_in_reverse_order([&](FunctionDeclaration const& function) {
  355. if (function_names.set(function.name()) == AK::HashSetResult::InsertedNewEntry)
  356. functions_to_initialize.append(function);
  357. }));
  358. auto const& arguments_name = vm.names.arguments.as_string();
  359. if (!has_parameter_expressions && function_names.contains(arguments_name))
  360. arguments_object_needed = false;
  361. if (!has_parameter_expressions && arguments_object_needed) {
  362. // NOTE: Nothing in the callback throws an exception.
  363. MUST(scope_body->for_each_lexically_declared_identifier([&](auto const& identifier) {
  364. if (identifier.string() == arguments_name)
  365. arguments_object_needed = false;
  366. }));
  367. }
  368. } else {
  369. arguments_object_needed = false;
  370. }
  371. GCPtr<Environment> environment;
  372. // 19. If strict is true or hasParameterExpressions is false, then
  373. if (strict || !has_parameter_expressions) {
  374. // a. NOTE: Only a single Environment Record is needed for the parameters, since calls to eval in strict mode code cannot create new bindings which are visible outside of the eval.
  375. // b. Let env be the LexicalEnvironment of calleeContext.
  376. environment = callee_context.lexical_environment;
  377. }
  378. // 20. Else,
  379. else {
  380. // a. NOTE: A separate Environment Record is needed to ensure that bindings created by direct eval calls in the formal parameter list are outside the environment where parameters are declared.
  381. // b. Let calleeEnv be the LexicalEnvironment of calleeContext.
  382. auto callee_env = callee_context.lexical_environment;
  383. // c. Let env be NewDeclarativeEnvironment(calleeEnv).
  384. environment = new_declarative_environment(*callee_env);
  385. // d. Assert: The VariableEnvironment of calleeContext is calleeEnv.
  386. VERIFY(callee_context.variable_environment == callee_context.lexical_environment);
  387. // e. Set the LexicalEnvironment of calleeContext to env.
  388. callee_context.lexical_environment = environment;
  389. }
  390. // 21. For each String paramName of parameterNames, do
  391. for (auto const& parameter_name : parameter_names) {
  392. // a. Let alreadyDeclared be ! env.HasBinding(paramName).
  393. auto already_declared = MUST(environment->has_binding(parameter_name));
  394. // b. NOTE: Early errors ensure that duplicate parameter names can only occur in non-strict functions that do not have parameter default values or rest parameters.
  395. // c. If alreadyDeclared is false, then
  396. if (!already_declared) {
  397. // i. Perform ! env.CreateMutableBinding(paramName, false).
  398. MUST(environment->create_mutable_binding(vm, parameter_name, false));
  399. // ii. If hasDuplicates is true, then
  400. if (has_duplicates) {
  401. // 1. Perform ! env.InitializeBinding(paramName, undefined).
  402. MUST(environment->initialize_binding(vm, parameter_name, js_undefined(), Environment::InitializeBindingHint::Normal));
  403. }
  404. }
  405. }
  406. // 22. If argumentsObjectNeeded is true, then
  407. if (arguments_object_needed) {
  408. Object* arguments_object;
  409. // a. If strict is true or simpleParameterList is false, then
  410. if (strict || !simple_parameter_list) {
  411. // i. Let ao be CreateUnmappedArgumentsObject(argumentsList).
  412. arguments_object = create_unmapped_arguments_object(vm, vm.running_execution_context().arguments);
  413. }
  414. // b. Else,
  415. else {
  416. // i. NOTE: A mapped argument object is only provided for non-strict functions that don't have a rest parameter, any parameter default value initializers, or any destructured parameters.
  417. // ii. Let ao be CreateMappedArgumentsObject(func, formals, argumentsList, env).
  418. arguments_object = create_mapped_arguments_object(vm, *this, formal_parameters(), vm.running_execution_context().arguments, *environment);
  419. }
  420. // c. If strict is true, then
  421. if (strict) {
  422. // i. Perform ! env.CreateImmutableBinding("arguments", false).
  423. MUST(environment->create_immutable_binding(vm, vm.names.arguments.as_string(), false));
  424. // ii. NOTE: In strict mode code early errors prevent attempting to assign to this binding, so its mutability is not observable.
  425. }
  426. // b. Else,
  427. else {
  428. // i. Perform ! env.CreateMutableBinding("arguments", false).
  429. MUST(environment->create_mutable_binding(vm, vm.names.arguments.as_string(), false));
  430. }
  431. // c. Perform ! env.InitializeBinding("arguments", ao).
  432. MUST(environment->initialize_binding(vm, vm.names.arguments.as_string(), arguments_object, Environment::InitializeBindingHint::Normal));
  433. // f. Let parameterBindings be the list-concatenation of parameterNames and « "arguments" ».
  434. parameter_names.set(vm.names.arguments.as_string());
  435. }
  436. // 23. Else,
  437. else {
  438. // a. Let parameterBindings be parameterNames.
  439. }
  440. // NOTE: We now treat parameterBindings as parameterNames.
  441. // 24. Let iteratorRecord be CreateListIteratorRecord(argumentsList).
  442. // 25. If hasDuplicates is true, then
  443. // a. Perform ? IteratorBindingInitialization of formals with arguments iteratorRecord and undefined.
  444. // 26. Else,
  445. // a. Perform ? IteratorBindingInitialization of formals with arguments iteratorRecord and env.
  446. // NOTE: The spec makes an iterator here to do IteratorBindingInitialization but we just do it manually
  447. auto& execution_context_arguments = vm.running_execution_context().arguments;
  448. size_t default_parameter_index = 0;
  449. for (size_t i = 0; i < m_formal_parameters.size(); ++i) {
  450. auto& parameter = m_formal_parameters[i];
  451. if (parameter.default_value)
  452. ++default_parameter_index;
  453. TRY(parameter.binding.visit(
  454. [&](auto const& param) -> ThrowCompletionOr<void> {
  455. Value argument_value;
  456. if (parameter.is_rest) {
  457. auto array = MUST(Array::create(realm, 0));
  458. for (size_t rest_index = i; rest_index < execution_context_arguments.size(); ++rest_index)
  459. array->indexed_properties().append(execution_context_arguments[rest_index]);
  460. argument_value = array;
  461. } else if (i < execution_context_arguments.size() && !execution_context_arguments[i].is_undefined()) {
  462. argument_value = execution_context_arguments[i];
  463. } else if (parameter.default_value) {
  464. auto* bytecode_interpreter = vm.bytecode_interpreter_if_exists();
  465. if (static_cast<FunctionKind>(m_kind) == FunctionKind::Generator || static_cast<FunctionKind>(m_kind) == FunctionKind::AsyncGenerator)
  466. bytecode_interpreter = &vm.bytecode_interpreter();
  467. if (bytecode_interpreter) {
  468. auto value_and_frame = bytecode_interpreter->run_and_return_frame(realm, *m_default_parameter_bytecode_executables[default_parameter_index - 1], nullptr);
  469. if (value_and_frame.value.is_error())
  470. return value_and_frame.value.release_error();
  471. // Resulting value is in the accumulator.
  472. argument_value = value_and_frame.frame->registers.at(0);
  473. } else if (interpreter) {
  474. argument_value = TRY(parameter.default_value->execute(*interpreter)).release_value();
  475. }
  476. } else {
  477. argument_value = js_undefined();
  478. }
  479. Environment* used_environment = has_duplicates ? nullptr : environment;
  480. if constexpr (IsSame<NonnullRefPtr<Identifier const> const&, decltype(param)>) {
  481. if ((vm.bytecode_interpreter_if_exists() || kind() == FunctionKind::Generator || kind() == FunctionKind::AsyncGenerator) && param->is_local()) {
  482. // NOTE: Local variables are supported only in bytecode interpreter
  483. callee_context.local_variables[param->local_variable_index()] = argument_value;
  484. return {};
  485. } else {
  486. Reference reference = TRY(vm.resolve_binding(param->string(), used_environment));
  487. // Here the difference from hasDuplicates is important
  488. if (has_duplicates)
  489. return reference.put_value(vm, argument_value);
  490. else
  491. return reference.initialize_referenced_binding(vm, argument_value);
  492. }
  493. }
  494. if constexpr (IsSame<NonnullRefPtr<BindingPattern const> const&, decltype(param)>) {
  495. // Here the difference from hasDuplicates is important
  496. return vm.binding_initialization(param, argument_value, used_environment);
  497. }
  498. }));
  499. }
  500. GCPtr<Environment> var_environment;
  501. HashTable<DeprecatedFlyString> instantiated_var_names;
  502. if (scope_body)
  503. instantiated_var_names.ensure_capacity(scope_body->var_declaration_count());
  504. // 27. If hasParameterExpressions is false, then
  505. if (!has_parameter_expressions) {
  506. // a. NOTE: Only a single Environment Record is needed for the parameters and top-level vars.
  507. // b. Let instantiatedVarNames be a copy of the List parameterBindings.
  508. // NOTE: Done in implementation of step 27.c.i.1 below
  509. if (scope_body) {
  510. // NOTE: Due to the use of MUST with `create_mutable_binding` and `initialize_binding` below,
  511. // an exception should not result from `for_each_var_declared_name`.
  512. // c. For each element n of varNames, do
  513. MUST(scope_body->for_each_var_declared_identifier([&](auto const& id) {
  514. // i. If instantiatedVarNames does not contain n, then
  515. if (!parameter_names.contains(id.string()) && instantiated_var_names.set(id.string()) == AK::HashSetResult::InsertedNewEntry) {
  516. // 1. Append n to instantiatedVarNames.
  517. // 2. Perform ! env.CreateMutableBinding(n, false).
  518. // 3. Perform ! env.InitializeBinding(n, undefined).
  519. if (vm.bytecode_interpreter_if_exists() && id.is_local()) {
  520. callee_context.local_variables[id.local_variable_index()] = js_undefined();
  521. } else {
  522. MUST(environment->create_mutable_binding(vm, id.string(), false));
  523. MUST(environment->initialize_binding(vm, id.string(), js_undefined(), Environment::InitializeBindingHint::Normal));
  524. }
  525. }
  526. }));
  527. }
  528. // d.Let varEnv be env
  529. var_environment = environment;
  530. }
  531. // 28. Else,
  532. else {
  533. // a. NOTE: A separate Environment Record is needed to ensure that closures created by expressions in the formal parameter list do not have visibility of declarations in the function body.
  534. // b. Let varEnv be NewDeclarativeEnvironment(env).
  535. var_environment = new_declarative_environment(*environment);
  536. // c. Set the VariableEnvironment of calleeContext to varEnv.
  537. callee_context.variable_environment = var_environment;
  538. // d. Let instantiatedVarNames be a new empty List.
  539. // NOTE: Already done above.
  540. if (scope_body) {
  541. // NOTE: Due to the use of MUST with `create_mutable_binding`, `get_binding_value` and `initialize_binding` below,
  542. // an exception should not result from `for_each_var_declared_name`.
  543. // e. For each element n of varNames, do
  544. MUST(scope_body->for_each_var_declared_identifier([&](auto const& id) {
  545. // i. If instantiatedVarNames does not contain n, then
  546. if (instantiated_var_names.set(id.string()) == AK::HashSetResult::InsertedNewEntry) {
  547. // 1. Append n to instantiatedVarNames.
  548. // 2. Perform ! varEnv.CreateMutableBinding(n, false).
  549. MUST(var_environment->create_mutable_binding(vm, id.string(), false));
  550. Value initial_value;
  551. // 3. If parameterBindings does not contain n, or if functionNames contains n, then
  552. if (!parameter_names.contains(id.string()) || function_names.contains(id.string())) {
  553. // a. Let initialValue be undefined.
  554. initial_value = js_undefined();
  555. }
  556. // 4. Else,
  557. else {
  558. // a. Let initialValue be ! env.GetBindingValue(n, false).
  559. initial_value = MUST(environment->get_binding_value(vm, id.string(), false));
  560. }
  561. // 5. Perform ! varEnv.InitializeBinding(n, initialValue).
  562. if (vm.bytecode_interpreter_if_exists() && id.is_local()) {
  563. // NOTE: Local variables are supported only in bytecode interpreter
  564. callee_context.local_variables[id.local_variable_index()] = initial_value;
  565. } else {
  566. MUST(var_environment->initialize_binding(vm, id.string(), initial_value, Environment::InitializeBindingHint::Normal));
  567. }
  568. // 6. NOTE: A var with the same name as a formal parameter initially has the same value as the corresponding initialized parameter.
  569. }
  570. }));
  571. }
  572. }
  573. // 29. NOTE: Annex B.3.2.1 adds additional steps at this point.
  574. // B.3.2.1 Changes to FunctionDeclarationInstantiation, https://tc39.es/ecma262/#sec-web-compat-functiondeclarationinstantiation
  575. if (!strict && scope_body) {
  576. // NOTE: Due to the use of MUST with `create_mutable_binding` and `initialize_binding` below,
  577. // an exception should not result from `for_each_function_hoistable_with_annexB_extension`.
  578. MUST(scope_body->for_each_function_hoistable_with_annexB_extension([&](FunctionDeclaration& function_declaration) {
  579. auto function_name = function_declaration.name();
  580. if (parameter_names.contains(function_name))
  581. return;
  582. // The spec says 'initializedBindings' here but that does not exist and it then adds it to 'instantiatedVarNames' so it probably means 'instantiatedVarNames'.
  583. if (!instantiated_var_names.contains(function_name) && function_name != vm.names.arguments.as_string()) {
  584. MUST(var_environment->create_mutable_binding(vm, function_name, false));
  585. MUST(var_environment->initialize_binding(vm, function_name, js_undefined(), Environment::InitializeBindingHint::Normal));
  586. instantiated_var_names.set(function_name);
  587. }
  588. function_declaration.set_should_do_additional_annexB_steps();
  589. }));
  590. }
  591. GCPtr<Environment> lex_environment;
  592. // 30. If strict is false, then
  593. if (!strict) {
  594. // Optimization: We avoid creating empty top-level declarative environments in non-strict mode, if both of these conditions are true:
  595. // 1. there is no direct call to eval() within this function
  596. // 2. there are no lexical declarations that would go into the environment
  597. bool can_elide_declarative_environment = !m_contains_direct_call_to_eval && (!scope_body || !scope_body->has_lexical_declarations());
  598. if (can_elide_declarative_environment) {
  599. lex_environment = var_environment;
  600. } else {
  601. // a. Let lexEnv be NewDeclarativeEnvironment(varEnv).
  602. // b. NOTE: Non-strict functions use a separate Environment Record for top-level lexical declarations so that a direct eval
  603. // can determine whether any var scoped declarations introduced by the eval code conflict with pre-existing top-level
  604. // lexically scoped declarations. This is not needed for strict functions because a strict direct eval always places
  605. // all declarations into a new Environment Record.
  606. lex_environment = new_declarative_environment(*var_environment);
  607. }
  608. }
  609. // 31. Else,
  610. else {
  611. // a. let lexEnv be varEnv.
  612. lex_environment = var_environment;
  613. }
  614. // 32. Set the LexicalEnvironment of calleeContext to lexEnv.
  615. callee_context.lexical_environment = lex_environment;
  616. if (!scope_body)
  617. return {};
  618. // 33. Let lexDeclarations be the LexicallyScopedDeclarations of code.
  619. // 34. For each element d of lexDeclarations, do
  620. // NOTE: Due to the use of MUST in the callback, an exception should not result from `for_each_lexically_scoped_declaration`.
  621. MUST(scope_body->for_each_lexically_scoped_declaration([&](Declaration const& declaration) {
  622. // NOTE: Due to the use of MUST with `create_immutable_binding` and `create_mutable_binding` below,
  623. // an exception should not result from `for_each_bound_name`.
  624. // a. NOTE: A lexically declared name cannot be the same as a function/generator declaration, formal parameter, or a var name. Lexically declared names are only instantiated here but not initialized.
  625. // b. For each element dn of the BoundNames of d, do
  626. MUST(declaration.for_each_bound_identifier([&](auto const& id) {
  627. if (vm.bytecode_interpreter_if_exists() && id.is_local()) {
  628. // NOTE: Local variables are supported only in bytecode interpreter
  629. return;
  630. }
  631. // i. If IsConstantDeclaration of d is true, then
  632. if (declaration.is_constant_declaration()) {
  633. // 1. Perform ! lexEnv.CreateImmutableBinding(dn, true).
  634. MUST(lex_environment->create_immutable_binding(vm, id.string(), true));
  635. }
  636. // ii. Else,
  637. else {
  638. // 1. Perform ! lexEnv.CreateMutableBinding(dn, false).
  639. MUST(lex_environment->create_mutable_binding(vm, id.string(), false));
  640. }
  641. }));
  642. }));
  643. // 35. Let privateEnv be the PrivateEnvironment of calleeContext.
  644. auto private_environment = callee_context.private_environment;
  645. // 36. For each Parse Node f of functionsToInitialize, do
  646. for (auto& declaration : functions_to_initialize) {
  647. // a. Let fn be the sole element of the BoundNames of f.
  648. // b. Let fo be InstantiateFunctionObject of f with arguments lexEnv and privateEnv.
  649. auto function = ECMAScriptFunctionObject::create(realm, declaration.name(), declaration.source_text(), declaration.body(), declaration.parameters(), declaration.function_length(), declaration.local_variables_names(), lex_environment, private_environment, declaration.kind(), declaration.is_strict_mode(), declaration.might_need_arguments_object(), declaration.contains_direct_call_to_eval());
  650. // c. Perform ! varEnv.SetMutableBinding(fn, fo, false).
  651. if ((vm.bytecode_interpreter_if_exists() || kind() == FunctionKind::Generator || kind() == FunctionKind::AsyncGenerator) && declaration.name_identifier()->is_local()) {
  652. callee_context.local_variables[declaration.name_identifier()->local_variable_index()] = function;
  653. } else {
  654. MUST(var_environment->set_mutable_binding(vm, declaration.name(), function, false));
  655. }
  656. }
  657. if (is<DeclarativeEnvironment>(*lex_environment))
  658. static_cast<DeclarativeEnvironment*>(lex_environment.ptr())->shrink_to_fit();
  659. if (is<DeclarativeEnvironment>(*var_environment))
  660. static_cast<DeclarativeEnvironment*>(var_environment.ptr())->shrink_to_fit();
  661. // 37. Return unused.
  662. return {};
  663. }
  664. // 10.2.1.1 PrepareForOrdinaryCall ( F, newTarget ), https://tc39.es/ecma262/#sec-prepareforordinarycall
  665. ThrowCompletionOr<void> ECMAScriptFunctionObject::prepare_for_ordinary_call(ExecutionContext& callee_context, Object* new_target)
  666. {
  667. auto& vm = this->vm();
  668. // Non-standard
  669. callee_context.is_strict_mode = m_strict;
  670. // 1. Let callerContext be the running execution context.
  671. // 2. Let calleeContext be a new ECMAScript code execution context.
  672. // NOTE: In the specification, PrepareForOrdinaryCall "returns" a new callee execution context.
  673. // To avoid heap allocations, we put our ExecutionContext objects on the C++ stack instead.
  674. // Whoever calls us should put an ExecutionContext on their stack and pass that as the `callee_context`.
  675. // 3. Set the Function of calleeContext to F.
  676. callee_context.function = this;
  677. callee_context.function_name = m_name;
  678. // 4. Let calleeRealm be F.[[Realm]].
  679. auto callee_realm = m_realm;
  680. // NOTE: This non-standard fallback is needed until we can guarantee that literally
  681. // every function has a realm - especially in LibWeb that's sometimes not the case
  682. // when a function is created while no JS is running, as we currently need to rely on
  683. // that (:acid2:, I know - see set_event_handler_attribute() for an example).
  684. // If there's no 'current realm' either, we can't continue and crash.
  685. if (!callee_realm)
  686. callee_realm = vm.current_realm();
  687. VERIFY(callee_realm);
  688. // 5. Set the Realm of calleeContext to calleeRealm.
  689. callee_context.realm = callee_realm;
  690. // 6. Set the ScriptOrModule of calleeContext to F.[[ScriptOrModule]].
  691. callee_context.script_or_module = m_script_or_module;
  692. // 7. Let localEnv be NewFunctionEnvironment(F, newTarget).
  693. auto local_environment = new_function_environment(*this, new_target);
  694. // 8. Set the LexicalEnvironment of calleeContext to localEnv.
  695. callee_context.lexical_environment = local_environment;
  696. // 9. Set the VariableEnvironment of calleeContext to localEnv.
  697. callee_context.variable_environment = local_environment;
  698. // 10. Set the PrivateEnvironment of calleeContext to F.[[PrivateEnvironment]].
  699. callee_context.private_environment = m_private_environment;
  700. // 11. If callerContext is not already suspended, suspend callerContext.
  701. // FIXME: We don't have this concept yet.
  702. // 12. Push calleeContext onto the execution context stack; calleeContext is now the running execution context.
  703. TRY(vm.push_execution_context(callee_context, {}));
  704. // 13. NOTE: Any exception objects produced after this point are associated with calleeRealm.
  705. // 14. Return calleeContext.
  706. // NOTE: See the comment after step 2 above about how contexts are allocated on the C++ stack.
  707. return {};
  708. }
  709. // 10.2.1.2 OrdinaryCallBindThis ( F, calleeContext, thisArgument ), https://tc39.es/ecma262/#sec-ordinarycallbindthis
  710. void ECMAScriptFunctionObject::ordinary_call_bind_this(ExecutionContext& callee_context, Value this_argument)
  711. {
  712. auto& vm = this->vm();
  713. // 1. Let thisMode be F.[[ThisMode]].
  714. auto this_mode = m_this_mode;
  715. // If thisMode is lexical, return unused.
  716. if (this_mode == ThisMode::Lexical)
  717. return;
  718. // 3. Let calleeRealm be F.[[Realm]].
  719. auto callee_realm = m_realm;
  720. // NOTE: This non-standard fallback is needed until we can guarantee that literally
  721. // every function has a realm - especially in LibWeb that's sometimes not the case
  722. // when a function is created while no JS is running, as we currently need to rely on
  723. // that (:acid2:, I know - see set_event_handler_attribute() for an example).
  724. // If there's no 'current realm' either, we can't continue and crash.
  725. if (!callee_realm)
  726. callee_realm = vm.current_realm();
  727. VERIFY(callee_realm);
  728. // 4. Let localEnv be the LexicalEnvironment of calleeContext.
  729. auto local_env = callee_context.lexical_environment;
  730. Value this_value;
  731. // 5. If thisMode is strict, let thisValue be thisArgument.
  732. if (this_mode == ThisMode::Strict) {
  733. this_value = this_argument;
  734. }
  735. // 6. Else,
  736. else {
  737. // a. If thisArgument is undefined or null, then
  738. if (this_argument.is_nullish()) {
  739. // i. Let globalEnv be calleeRealm.[[GlobalEnv]].
  740. // ii. Assert: globalEnv is a global Environment Record.
  741. auto& global_env = callee_realm->global_environment();
  742. // iii. Let thisValue be globalEnv.[[GlobalThisValue]].
  743. this_value = &global_env.global_this_value();
  744. }
  745. // b. Else,
  746. else {
  747. // i. Let thisValue be ! ToObject(thisArgument).
  748. this_value = MUST(this_argument.to_object(vm));
  749. // ii. NOTE: ToObject produces wrapper objects using calleeRealm.
  750. VERIFY(vm.current_realm() == callee_realm);
  751. }
  752. }
  753. // 7. Assert: localEnv is a function Environment Record.
  754. // 8. Assert: The next step never returns an abrupt completion because localEnv.[[ThisBindingStatus]] is not initialized.
  755. // 9. Perform ! localEnv.BindThisValue(thisValue).
  756. MUST(verify_cast<FunctionEnvironment>(*local_env).bind_this_value(vm, this_value));
  757. // 10. Return unused.
  758. }
  759. // 27.7.5.1 AsyncFunctionStart ( promiseCapability, asyncFunctionBody ), https://tc39.es/ecma262/#sec-async-functions-abstract-operations-async-function-start
  760. template<typename T>
  761. void async_function_start(VM& vm, PromiseCapability const& promise_capability, T const& async_function_body)
  762. {
  763. // 1. Let runningContext be the running execution context.
  764. auto& running_context = vm.running_execution_context();
  765. // 2. Let asyncContext be a copy of runningContext.
  766. auto async_context = running_context.copy();
  767. // 3. NOTE: Copying the execution state is required for AsyncBlockStart to resume its execution. It is ill-defined to resume a currently executing context.
  768. // 4. Perform AsyncBlockStart(promiseCapability, asyncFunctionBody, asyncContext).
  769. async_block_start(vm, async_function_body, promise_capability, async_context);
  770. // 5. Return unused.
  771. }
  772. // 27.7.5.2 AsyncBlockStart ( promiseCapability, asyncBody, asyncContext ), https://tc39.es/ecma262/#sec-asyncblockstart
  773. // 12.7.1.1 AsyncBlockStart ( promiseCapability, asyncBody, asyncContext ), https://tc39.es/proposal-explicit-resource-management/#sec-asyncblockstart
  774. // 1.2.1.1 AsyncBlockStart ( promiseCapability, asyncBody, asyncContext ), https://tc39.es/proposal-array-from-async/#sec-asyncblockstart
  775. template<typename T>
  776. void async_block_start(VM& vm, T const& async_body, PromiseCapability const& promise_capability, ExecutionContext& async_context)
  777. {
  778. // NOTE: This function is a combination between two proposals, so does not exactly match spec steps of either.
  779. auto& realm = *vm.current_realm();
  780. // 1. Assert: promiseCapability is a PromiseCapability Record.
  781. // 2. Let runningContext be the running execution context.
  782. auto& running_context = vm.running_execution_context();
  783. // 3. Set the code evaluation state of asyncContext such that when evaluation is resumed for that execution context the following steps will be performed:
  784. auto execution_steps = NativeFunction::create(realm, "", [&realm, &async_body, &promise_capability, &async_context](auto& vm) -> ThrowCompletionOr<Value> {
  785. Completion result;
  786. // a. If asyncBody is a Parse Node, then
  787. if constexpr (!IsCallableWithArguments<T, Completion>) {
  788. // a. Let result be the result of evaluating asyncBody.
  789. if (auto* bytecode_interpreter = vm.bytecode_interpreter_if_exists()) {
  790. // FIXME: Cache this executable somewhere.
  791. auto maybe_executable = Bytecode::compile(vm, async_body, FunctionKind::Async, "AsyncBlockStart"sv);
  792. if (maybe_executable.is_error())
  793. result = maybe_executable.release_error();
  794. else
  795. result = bytecode_interpreter->run_and_return_frame(realm, *maybe_executable.value(), nullptr).value;
  796. } else {
  797. result = async_body->execute(vm.interpreter());
  798. }
  799. }
  800. // b. Else,
  801. else {
  802. (void)realm;
  803. // i. Assert: asyncBody is an Abstract Closure with no parameters.
  804. static_assert(IsCallableWithArguments<T, Completion>);
  805. // ii. Let result be asyncBody().
  806. result = async_body();
  807. }
  808. // c. Assert: If we return here, the async function either threw an exception or performed an implicit or explicit return; all awaiting is done.
  809. // d. Remove asyncContext from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
  810. vm.pop_execution_context();
  811. // NOTE: This does not work for Array.fromAsync, likely due to conflicts between that proposal and Explicit Resource Management proposal.
  812. if constexpr (!IsCallableWithArguments<T, Completion>) {
  813. // e. Let env be asyncContext's LexicalEnvironment.
  814. auto env = async_context.lexical_environment;
  815. // f. Set result to DisposeResources(env, result).
  816. result = dispose_resources(vm, verify_cast<DeclarativeEnvironment>(env.ptr()), result);
  817. } else {
  818. (void)async_context;
  819. }
  820. // g. If result.[[Type]] is normal, then
  821. if (result.type() == Completion::Type::Normal) {
  822. // i. Perform ! Call(promiseCapability.[[Resolve]], undefined, « undefined »).
  823. MUST(call(vm, *promise_capability.resolve(), js_undefined(), js_undefined()));
  824. }
  825. // h. Else if result.[[Type]] is return, then
  826. else if (result.type() == Completion::Type::Return) {
  827. // i. Perform ! Call(promiseCapability.[[Resolve]], undefined, « result.[[Value]] »).
  828. MUST(call(vm, *promise_capability.resolve(), js_undefined(), *result.value()));
  829. }
  830. // i. Else,
  831. else {
  832. // i. Assert: result.[[Type]] is throw.
  833. VERIFY(result.type() == Completion::Type::Throw);
  834. // ii. Perform ! Call(promiseCapability.[[Reject]], undefined, « result.[[Value]] »).
  835. MUST(call(vm, *promise_capability.reject(), js_undefined(), *result.value()));
  836. }
  837. // j. Return unused.
  838. // NOTE: We don't support returning an empty/optional/unused value here.
  839. return js_undefined();
  840. });
  841. // 4. Push asyncContext onto the execution context stack; asyncContext is now the running execution context.
  842. auto push_result = vm.push_execution_context(async_context, {});
  843. if (push_result.is_error())
  844. return;
  845. // 5. Resume the suspended evaluation of asyncContext. Let result be the value returned by the resumed computation.
  846. auto result = call(vm, *execution_steps, async_context.this_value.is_empty() ? js_undefined() : async_context.this_value);
  847. // 6. Assert: When we return here, asyncContext has already been removed from the execution context stack and runningContext is the currently running execution context.
  848. VERIFY(&vm.running_execution_context() == &running_context);
  849. // 7. Assert: result is a normal completion with a value of unused. The possible sources of this value are Await or, if the async function doesn't await anything, step 3.g above.
  850. VERIFY(result.has_value() && result.value().is_undefined());
  851. // 8. Return unused.
  852. }
  853. template void async_block_start(VM&, NonnullGCPtr<Statement const> const& async_body, PromiseCapability const&, ExecutionContext&);
  854. template void async_function_start(VM&, PromiseCapability const&, NonnullGCPtr<Statement const> const& async_function_body);
  855. template void async_block_start(VM&, SafeFunction<Completion()> const& async_body, PromiseCapability const&, ExecutionContext&);
  856. template void async_function_start(VM&, PromiseCapability const&, SafeFunction<Completion()> const& async_function_body);
  857. // 10.2.1.4 OrdinaryCallEvaluateBody ( F, argumentsList ), https://tc39.es/ecma262/#sec-ordinarycallevaluatebody
  858. // 15.8.4 Runtime Semantics: EvaluateAsyncFunctionBody, https://tc39.es/ecma262/#sec-runtime-semantics-evaluatefunctionbody
  859. Completion ECMAScriptFunctionObject::ordinary_call_evaluate_body()
  860. {
  861. auto& vm = this->vm();
  862. auto& realm = *vm.current_realm();
  863. auto* bytecode_interpreter = vm.bytecode_interpreter_if_exists();
  864. // The bytecode interpreter can execute generator functions while the AST interpreter cannot.
  865. // This simply makes it create a new bytecode interpreter when one doesn't exist when executing a generator function.
  866. // Doing so makes it automatically switch to the bytecode interpreter to execute any future code until it exits the generator. See below.
  867. // This allows us to keep all of the existing functionality that works in AST while adding generator support on top of it.
  868. // However, this does cause an awkward situation with features not supported in bytecode, where features that work outside of generators with AST
  869. // suddenly stop working inside of generators.
  870. // This is a stop gap until bytecode mode becomes the default.
  871. if ((m_kind == FunctionKind::Generator || m_kind == FunctionKind::AsyncGenerator) && !bytecode_interpreter) {
  872. bytecode_interpreter = &vm.bytecode_interpreter();
  873. }
  874. if (bytecode_interpreter) {
  875. // NOTE: There's a subtle ordering issue here:
  876. // - We have to compile the default parameter values before instantiating the function.
  877. // - We have to instantiate the function before compiling the function body.
  878. // This is why FunctionDeclarationInstantiation is invoked in the middle.
  879. // The issue is that FunctionDeclarationInstantiation may mark certain functions as hoisted
  880. // per Annex B. This affects code generation for FunctionDeclaration nodes.
  881. if (!m_bytecode_executable) {
  882. size_t default_parameter_index = 0;
  883. for (auto& parameter : m_formal_parameters) {
  884. if (!parameter.default_value)
  885. continue;
  886. auto executable = TRY(Bytecode::compile(vm, *parameter.default_value, FunctionKind::Normal, DeprecatedString::formatted("default parameter #{} for {}", default_parameter_index, m_name)));
  887. m_default_parameter_bytecode_executables.append(move(executable));
  888. }
  889. }
  890. auto declaration_result = function_declaration_instantiation(nullptr);
  891. if (m_kind == FunctionKind::Normal || m_kind == FunctionKind::Generator || m_kind == FunctionKind::AsyncGenerator) {
  892. if (declaration_result.is_error())
  893. return declaration_result.release_error();
  894. }
  895. if (!m_bytecode_executable)
  896. m_bytecode_executable = TRY(Bytecode::compile(vm, *m_ecmascript_code, m_kind, m_name));
  897. if (m_kind == FunctionKind::Async) {
  898. if (declaration_result.is_throw_completion()) {
  899. auto promise_capability = MUST(new_promise_capability(vm, realm.intrinsics().promise_constructor()));
  900. MUST(call(vm, *promise_capability->reject(), js_undefined(), *declaration_result.throw_completion().value()));
  901. return Completion { Completion::Type::Return, promise_capability->promise(), {} };
  902. }
  903. }
  904. auto result_and_frame = bytecode_interpreter->run_and_return_frame(realm, *m_bytecode_executable, nullptr);
  905. VERIFY(result_and_frame.frame != nullptr);
  906. if (result_and_frame.value.is_error())
  907. return result_and_frame.value.release_error();
  908. auto result = result_and_frame.value.release_value();
  909. // NOTE: Running the bytecode should eventually return a completion.
  910. // Until it does, we assume "return" and include the undefined fallback from the call site.
  911. if (m_kind == FunctionKind::Normal)
  912. return { Completion::Type::Return, result.value_or(js_undefined()), {} };
  913. if (m_kind == FunctionKind::AsyncGenerator) {
  914. auto async_generator_object = TRY(AsyncGenerator::create(realm, result, this, vm.running_execution_context().copy(), move(*result_and_frame.frame)));
  915. return { Completion::Type::Return, async_generator_object, {} };
  916. }
  917. auto generator_object = TRY(GeneratorObject::create(realm, result, this, vm.running_execution_context().copy(), move(*result_and_frame.frame)));
  918. // NOTE: Async functions are entirely transformed to generator functions, and wrapped in a custom driver that returns a promise
  919. // See AwaitExpression::generate_bytecode() for the transformation.
  920. if (m_kind == FunctionKind::Async)
  921. return { Completion::Type::Return, TRY(AsyncFunctionDriverWrapper::create(realm, generator_object)), {} };
  922. VERIFY(m_kind == FunctionKind::Generator);
  923. return { Completion::Type::Return, generator_object, {} };
  924. } else {
  925. if (m_kind == FunctionKind::Generator)
  926. return vm.throw_completion<InternalError>(ErrorType::NotImplemented, "Generator function execution in AST interpreter");
  927. if (m_kind == FunctionKind::AsyncGenerator)
  928. return vm.throw_completion<InternalError>(ErrorType::NotImplemented, "Async generator function execution in AST interpreter");
  929. OwnPtr<Interpreter> local_interpreter;
  930. Interpreter* ast_interpreter = vm.interpreter_if_exists();
  931. if (!ast_interpreter) {
  932. local_interpreter = Interpreter::create_with_existing_realm(realm);
  933. ast_interpreter = local_interpreter.ptr();
  934. }
  935. VM::InterpreterExecutionScope scope(*ast_interpreter);
  936. // FunctionBody : FunctionStatementList
  937. if (m_kind == FunctionKind::Normal) {
  938. // 1. Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
  939. TRY(function_declaration_instantiation(ast_interpreter));
  940. // 2. Let result be result of evaluating FunctionStatementList.
  941. auto result = m_ecmascript_code->execute(*ast_interpreter);
  942. // 3. Let env be the running execution context's LexicalEnvironment.
  943. auto env = vm.running_execution_context().lexical_environment;
  944. VERIFY(is<DeclarativeEnvironment>(*env));
  945. // 4. Return ? DisposeResources(env, result).
  946. return dispose_resources(vm, static_cast<DeclarativeEnvironment*>(env.ptr()), result);
  947. }
  948. // AsyncFunctionBody : FunctionBody
  949. else if (m_kind == FunctionKind::Async) {
  950. // 1. Let promiseCapability be ! NewPromiseCapability(%Promise%).
  951. auto promise_capability = MUST(new_promise_capability(vm, realm.intrinsics().promise_constructor()));
  952. // 2. Let declResult be Completion(FunctionDeclarationInstantiation(functionObject, argumentsList)).
  953. auto declaration_result = function_declaration_instantiation(ast_interpreter);
  954. // 3. If declResult is an abrupt completion, then
  955. if (declaration_result.is_throw_completion()) {
  956. // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « declResult.[[Value]] »).
  957. MUST(call(vm, *promise_capability->reject(), js_undefined(), *declaration_result.throw_completion().value()));
  958. }
  959. // 4. Else,
  960. else {
  961. // a. Perform AsyncFunctionStart(promiseCapability, FunctionBody).
  962. async_function_start(vm, promise_capability, m_ecmascript_code);
  963. }
  964. // 5. Return Completion Record { [[Type]]: return, [[Value]]: promiseCapability.[[Promise]], [[Target]]: empty }.
  965. return Completion { Completion::Type::Return, promise_capability->promise(), {} };
  966. }
  967. }
  968. VERIFY_NOT_REACHED();
  969. }
  970. void ECMAScriptFunctionObject::set_name(DeprecatedFlyString const& name)
  971. {
  972. VERIFY(!name.is_null());
  973. auto& vm = this->vm();
  974. m_name = name;
  975. MUST(define_property_or_throw(vm.names.name, { .value = PrimitiveString::create(vm, m_name), .writable = false, .enumerable = false, .configurable = true }));
  976. }
  977. }