VM.cpp 51 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107
  1. /*
  2. * Copyright (c) 2020-2023, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2020-2023, Linus Groh <linusg@serenityos.org>
  4. * Copyright (c) 2021-2022, David Tuin <davidot@serenityos.org>
  5. *
  6. * SPDX-License-Identifier: BSD-2-Clause
  7. */
  8. #include <AK/Array.h>
  9. #include <AK/Debug.h>
  10. #include <AK/LexicalPath.h>
  11. #include <AK/ScopeGuard.h>
  12. #include <AK/String.h>
  13. #include <AK/StringBuilder.h>
  14. #include <LibFileSystem/FileSystem.h>
  15. #include <LibJS/AST.h>
  16. #include <LibJS/Interpreter.h>
  17. #include <LibJS/Runtime/AbstractOperations.h>
  18. #include <LibJS/Runtime/Array.h>
  19. #include <LibJS/Runtime/BoundFunction.h>
  20. #include <LibJS/Runtime/Completion.h>
  21. #include <LibJS/Runtime/ECMAScriptFunctionObject.h>
  22. #include <LibJS/Runtime/Error.h>
  23. #include <LibJS/Runtime/FinalizationRegistry.h>
  24. #include <LibJS/Runtime/FunctionEnvironment.h>
  25. #include <LibJS/Runtime/IteratorOperations.h>
  26. #include <LibJS/Runtime/NativeFunction.h>
  27. #include <LibJS/Runtime/PromiseCapability.h>
  28. #include <LibJS/Runtime/Reference.h>
  29. #include <LibJS/Runtime/Symbol.h>
  30. #include <LibJS/Runtime/VM.h>
  31. #include <LibJS/SourceTextModule.h>
  32. #include <LibJS/SyntheticModule.h>
  33. namespace JS {
  34. ErrorOr<NonnullRefPtr<VM>> VM::create(OwnPtr<CustomData> custom_data)
  35. {
  36. ErrorMessages error_messages {};
  37. error_messages[to_underlying(ErrorMessage::OutOfMemory)] = TRY(String::from_utf8(ErrorType::OutOfMemory.message()));
  38. auto vm = adopt_ref(*new VM(move(custom_data), move(error_messages)));
  39. WellKnownSymbols well_known_symbols {
  40. #define __JS_ENUMERATE(SymbolName, snake_name) \
  41. Symbol::create(*vm, TRY("Symbol." #SymbolName##_string), false),
  42. JS_ENUMERATE_WELL_KNOWN_SYMBOLS
  43. #undef __JS_ENUMERATE
  44. };
  45. vm->set_well_known_symbols(move(well_known_symbols));
  46. return vm;
  47. }
  48. template<u32... code_points>
  49. static constexpr auto make_single_ascii_character_strings(IndexSequence<code_points...>)
  50. {
  51. return AK::Array { (String::from_code_point(code_points))... };
  52. }
  53. static constexpr auto single_ascii_character_strings = make_single_ascii_character_strings(MakeIndexSequence<128>());
  54. VM::VM(OwnPtr<CustomData> custom_data, ErrorMessages error_messages)
  55. : m_heap(*this)
  56. , m_error_messages(move(error_messages))
  57. , m_custom_data(move(custom_data))
  58. {
  59. m_empty_string = m_heap.allocate_without_realm<PrimitiveString>(String {});
  60. for (size_t i = 0; i < single_ascii_character_strings.size(); ++i)
  61. m_single_ascii_character_strings[i] = m_heap.allocate_without_realm<PrimitiveString>(single_ascii_character_strings[i]);
  62. // Default hook implementations. These can be overridden by the host, for example, LibWeb overrides the default hooks to place promise jobs on the microtask queue.
  63. host_promise_rejection_tracker = [this](Promise& promise, Promise::RejectionOperation operation) {
  64. promise_rejection_tracker(promise, operation);
  65. };
  66. host_call_job_callback = [this](JobCallback& job_callback, Value this_value, MarkedVector<Value> arguments) {
  67. return call_job_callback(*this, job_callback, this_value, move(arguments));
  68. };
  69. host_enqueue_finalization_registry_cleanup_job = [this](FinalizationRegistry& finalization_registry) {
  70. enqueue_finalization_registry_cleanup_job(finalization_registry);
  71. };
  72. host_enqueue_promise_job = [this](Function<ThrowCompletionOr<Value>()> job, Realm* realm) {
  73. enqueue_promise_job(move(job), realm);
  74. };
  75. host_make_job_callback = [](FunctionObject& function_object) {
  76. return make_job_callback(function_object);
  77. };
  78. host_resolve_imported_module = [&](ScriptOrModule referencing_script_or_module, ModuleRequest const& specifier) {
  79. return resolve_imported_module(move(referencing_script_or_module), specifier);
  80. };
  81. host_import_module_dynamically = [&](ScriptOrModule, ModuleRequest const&, PromiseCapability const& promise_capability) -> ThrowCompletionOr<void> {
  82. // By default, we throw on dynamic imports this is to prevent arbitrary file access by scripts.
  83. VERIFY(current_realm());
  84. auto& realm = *current_realm();
  85. auto promise = Promise::create(realm);
  86. // If you are here because you want to enable dynamic module importing make sure it won't be a security problem
  87. // by checking the default implementation of HostImportModuleDynamically and creating your own hook or calling
  88. // vm.enable_default_host_import_module_dynamically_hook().
  89. promise->reject(MUST_OR_THROW_OOM(Error::create(realm, ErrorType::DynamicImportNotAllowed.message())));
  90. promise->perform_then(
  91. NativeFunction::create(realm, "", [](auto&) -> ThrowCompletionOr<Value> {
  92. VERIFY_NOT_REACHED();
  93. }),
  94. NativeFunction::create(realm, "", [&promise_capability](auto& vm) -> ThrowCompletionOr<Value> {
  95. auto error = vm.argument(0);
  96. // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « error »).
  97. MUST(call(vm, *promise_capability.reject(), js_undefined(), error));
  98. // b. Return undefined.
  99. return js_undefined();
  100. }),
  101. {});
  102. return {};
  103. };
  104. host_finish_dynamic_import = [&](ScriptOrModule referencing_script_or_module, ModuleRequest const& specifier, PromiseCapability const& promise_capability, Promise* promise) {
  105. return finish_dynamic_import(move(referencing_script_or_module), specifier, promise_capability, promise);
  106. };
  107. host_get_import_meta_properties = [&](SourceTextModule const&) -> HashMap<PropertyKey, Value> {
  108. return {};
  109. };
  110. host_finalize_import_meta = [&](Object*, SourceTextModule const&) {
  111. };
  112. host_get_supported_import_assertions = [&] {
  113. return Vector<DeprecatedString> { "type" };
  114. };
  115. // 19.2.1.2 HostEnsureCanCompileStrings ( callerRealm, calleeRealm ), https://tc39.es/ecma262/#sec-hostensurecancompilestrings
  116. host_ensure_can_compile_strings = [](Realm&) -> ThrowCompletionOr<void> {
  117. // The host-defined abstract operation HostEnsureCanCompileStrings takes argument calleeRealm (a Realm Record)
  118. // and returns either a normal completion containing unused or a throw completion.
  119. // It allows host environments to block certain ECMAScript functions which allow developers to compile strings into ECMAScript code.
  120. // An implementation of HostEnsureCanCompileStrings must conform to the following requirements:
  121. // - If the returned Completion Record is a normal completion, it must be a normal completion containing unused.
  122. // The default implementation of HostEnsureCanCompileStrings is to return NormalCompletion(unused).
  123. return {};
  124. };
  125. host_ensure_can_add_private_element = [](Object&) -> ThrowCompletionOr<void> {
  126. // The host-defined abstract operation HostEnsureCanAddPrivateElement takes argument O (an Object)
  127. // and returns either a normal completion containing unused or a throw completion.
  128. // It allows host environments to prevent the addition of private elements to particular host-defined exotic objects.
  129. // An implementation of HostEnsureCanAddPrivateElement must conform to the following requirements:
  130. // - If O is not a host-defined exotic object, this abstract operation must return NormalCompletion(unused) and perform no other steps.
  131. // - Any two calls of this abstract operation with the same argument must return the same kind of Completion Record.
  132. // The default implementation of HostEnsureCanAddPrivateElement is to return NormalCompletion(unused).
  133. return {};
  134. // This abstract operation is only invoked by ECMAScript hosts that are web browsers.
  135. // NOTE: Since LibJS has no way of knowing whether the current environment is a browser we always
  136. // call HostEnsureCanAddPrivateElement when needed.
  137. };
  138. }
  139. String const& VM::error_message(ErrorMessage type) const
  140. {
  141. VERIFY(type < ErrorMessage::__Count);
  142. auto const& message = m_error_messages[to_underlying(type)];
  143. VERIFY(!message.is_empty());
  144. return message;
  145. }
  146. void VM::enable_default_host_import_module_dynamically_hook()
  147. {
  148. host_import_module_dynamically = [&](ScriptOrModule referencing_script_or_module, ModuleRequest const& specifier, PromiseCapability const& promise_capability) {
  149. return import_module_dynamically(move(referencing_script_or_module), specifier, promise_capability);
  150. };
  151. }
  152. Interpreter& VM::interpreter()
  153. {
  154. VERIFY(!m_interpreters.is_empty());
  155. return *m_interpreters.last();
  156. }
  157. Interpreter* VM::interpreter_if_exists()
  158. {
  159. if (m_interpreters.is_empty())
  160. return nullptr;
  161. return m_interpreters.last();
  162. }
  163. void VM::push_interpreter(Interpreter& interpreter)
  164. {
  165. m_interpreters.append(&interpreter);
  166. }
  167. void VM::pop_interpreter(Interpreter& interpreter)
  168. {
  169. VERIFY(!m_interpreters.is_empty());
  170. auto* popped_interpreter = m_interpreters.take_last();
  171. VERIFY(popped_interpreter == &interpreter);
  172. }
  173. VM::InterpreterExecutionScope::InterpreterExecutionScope(Interpreter& interpreter)
  174. : m_interpreter(interpreter)
  175. {
  176. m_interpreter.vm().push_interpreter(m_interpreter);
  177. }
  178. VM::InterpreterExecutionScope::~InterpreterExecutionScope()
  179. {
  180. m_interpreter.vm().pop_interpreter(m_interpreter);
  181. }
  182. void VM::gather_roots(HashTable<Cell*>& roots)
  183. {
  184. roots.set(m_empty_string);
  185. for (auto string : m_single_ascii_character_strings)
  186. roots.set(string);
  187. auto gather_roots_from_execution_context_stack = [&roots](Vector<ExecutionContext*> const& stack) {
  188. for (auto& execution_context : stack) {
  189. if (execution_context->this_value.is_cell())
  190. roots.set(&execution_context->this_value.as_cell());
  191. for (auto& argument : execution_context->arguments) {
  192. if (argument.is_cell())
  193. roots.set(&argument.as_cell());
  194. }
  195. roots.set(execution_context->lexical_environment);
  196. roots.set(execution_context->variable_environment);
  197. roots.set(execution_context->private_environment);
  198. if (auto context_owner = execution_context->context_owner)
  199. roots.set(context_owner);
  200. execution_context->script_or_module.visit(
  201. [](Empty) {},
  202. [&](auto& script_or_module) {
  203. roots.set(script_or_module.ptr());
  204. });
  205. }
  206. };
  207. gather_roots_from_execution_context_stack(m_execution_context_stack);
  208. for (auto& saved_stack : m_saved_execution_context_stacks)
  209. gather_roots_from_execution_context_stack(saved_stack);
  210. #define __JS_ENUMERATE(SymbolName, snake_name) \
  211. roots.set(m_well_known_symbols.snake_name);
  212. JS_ENUMERATE_WELL_KNOWN_SYMBOLS
  213. #undef __JS_ENUMERATE
  214. for (auto& symbol : m_global_symbol_registry)
  215. roots.set(symbol.value);
  216. for (auto finalization_registry : m_finalization_registry_cleanup_jobs)
  217. roots.set(finalization_registry);
  218. }
  219. ThrowCompletionOr<Value> VM::named_evaluation_if_anonymous_function(ASTNode const& expression, DeprecatedFlyString const& name)
  220. {
  221. // 8.3.3 Static Semantics: IsAnonymousFunctionDefinition ( expr ), https://tc39.es/ecma262/#sec-isanonymousfunctiondefinition
  222. // And 8.3.5 Runtime Semantics: NamedEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-namedevaluation
  223. if (is<FunctionExpression>(expression)) {
  224. auto& function = static_cast<FunctionExpression const&>(expression);
  225. if (!function.has_name()) {
  226. return function.instantiate_ordinary_function_expression(interpreter(), name);
  227. }
  228. } else if (is<ClassExpression>(expression)) {
  229. auto& class_expression = static_cast<ClassExpression const&>(expression);
  230. if (!class_expression.has_name()) {
  231. return TRY(class_expression.class_definition_evaluation(interpreter(), {}, name));
  232. }
  233. }
  234. return TRY(expression.execute(interpreter())).release_value();
  235. }
  236. // 13.15.5.2 Runtime Semantics: DestructuringAssignmentEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-destructuringassignmentevaluation
  237. ThrowCompletionOr<void> VM::destructuring_assignment_evaluation(NonnullRefPtr<BindingPattern const> const& target, Value value)
  238. {
  239. // Note: DestructuringAssignmentEvaluation is just like BindingInitialization without an environment
  240. // And it allows member expressions. We thus trust the parser to disallow member expressions
  241. // in any non assignment binding and just call BindingInitialization with a nullptr environment
  242. return binding_initialization(target, value, nullptr);
  243. }
  244. // 8.5.2 Runtime Semantics: BindingInitialization, https://tc39.es/ecma262/#sec-runtime-semantics-bindinginitialization
  245. ThrowCompletionOr<void> VM::binding_initialization(DeprecatedFlyString const& target, Value value, Environment* environment)
  246. {
  247. // 1. Let name be StringValue of Identifier.
  248. // 2. Return ? InitializeBoundName(name, value, environment).
  249. return initialize_bound_name(*this, target, value, environment);
  250. }
  251. // 8.5.2 Runtime Semantics: BindingInitialization, https://tc39.es/ecma262/#sec-runtime-semantics-bindinginitialization
  252. ThrowCompletionOr<void> VM::binding_initialization(NonnullRefPtr<BindingPattern const> const& target, Value value, Environment* environment)
  253. {
  254. auto& vm = *this;
  255. // BindingPattern : ObjectBindingPattern
  256. if (target->kind == BindingPattern::Kind::Object) {
  257. // 1. Perform ? RequireObjectCoercible(value).
  258. TRY(require_object_coercible(vm, value));
  259. // 2. Return ? BindingInitialization of ObjectBindingPattern with arguments value and environment.
  260. // BindingInitialization of ObjectBindingPattern
  261. // 1. Perform ? PropertyBindingInitialization of BindingPropertyList with arguments value and environment.
  262. TRY(property_binding_initialization(*target, value, environment));
  263. // 2. Return unused.
  264. return {};
  265. }
  266. // BindingPattern : ArrayBindingPattern
  267. else {
  268. // 1. Let iteratorRecord be ? GetIterator(value).
  269. auto iterator_record = TRY(get_iterator(vm, value));
  270. // 2. Let result be Completion(IteratorBindingInitialization of ArrayBindingPattern with arguments iteratorRecord and environment).
  271. auto result = iterator_binding_initialization(*target, iterator_record, environment);
  272. // 3. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, result).
  273. if (!iterator_record.done) {
  274. // iterator_close() always returns a Completion, which ThrowCompletionOr will interpret as a throw
  275. // completion. So only return the result of iterator_close() if it is indeed a throw completion.
  276. auto completion = result.is_throw_completion() ? result.release_error() : normal_completion({});
  277. if (completion = iterator_close(vm, iterator_record, move(completion)); completion.is_error())
  278. return completion.release_error();
  279. }
  280. // 4. Return ? result.
  281. return result;
  282. }
  283. }
  284. // 13.15.5.3 Runtime Semantics: PropertyDestructuringAssignmentEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-propertydestructuringassignmentevaluation
  285. // 14.3.3.1 Runtime Semantics: PropertyBindingInitialization, https://tc39.es/ecma262/#sec-destructuring-binding-patterns-runtime-semantics-propertybindinginitialization
  286. ThrowCompletionOr<void> VM::property_binding_initialization(BindingPattern const& binding, Value value, Environment* environment)
  287. {
  288. auto& vm = *this;
  289. auto& realm = *vm.current_realm();
  290. auto object = TRY(value.to_object(vm));
  291. HashTable<PropertyKey> seen_names;
  292. for (auto& property : binding.entries) {
  293. VERIFY(!property.is_elision());
  294. if (property.is_rest) {
  295. Reference assignment_target;
  296. if (auto identifier_ptr = property.name.get_pointer<NonnullRefPtr<Identifier const>>()) {
  297. assignment_target = TRY(resolve_binding((*identifier_ptr)->string(), environment));
  298. } else if (auto member_ptr = property.alias.get_pointer<NonnullRefPtr<MemberExpression const>>()) {
  299. assignment_target = TRY((*member_ptr)->to_reference(interpreter()));
  300. } else {
  301. VERIFY_NOT_REACHED();
  302. }
  303. auto rest_object = Object::create(realm, realm.intrinsics().object_prototype());
  304. VERIFY(rest_object);
  305. TRY(rest_object->copy_data_properties(vm, object, seen_names));
  306. if (!environment)
  307. return assignment_target.put_value(vm, rest_object);
  308. else
  309. return assignment_target.initialize_referenced_binding(vm, rest_object);
  310. }
  311. auto name = TRY(property.name.visit(
  312. [&](Empty) -> ThrowCompletionOr<PropertyKey> { VERIFY_NOT_REACHED(); },
  313. [&](NonnullRefPtr<Identifier const> const& identifier) -> ThrowCompletionOr<PropertyKey> {
  314. return identifier->string();
  315. },
  316. [&](NonnullRefPtr<Expression const> const& expression) -> ThrowCompletionOr<PropertyKey> {
  317. auto result = TRY(expression->execute(interpreter())).release_value();
  318. return result.to_property_key(vm);
  319. }));
  320. seen_names.set(name);
  321. if (property.name.has<NonnullRefPtr<Identifier const>>() && property.alias.has<Empty>()) {
  322. // FIXME: this branch and not taking this have a lot in common we might want to unify it more (like it was before).
  323. auto& identifier = *property.name.get<NonnullRefPtr<Identifier const>>();
  324. auto reference = TRY(resolve_binding(identifier.string(), environment));
  325. auto value_to_assign = TRY(object->get(name));
  326. if (property.initializer && value_to_assign.is_undefined()) {
  327. value_to_assign = TRY(named_evaluation_if_anonymous_function(*property.initializer, identifier.string()));
  328. }
  329. if (!environment)
  330. TRY(reference.put_value(vm, value_to_assign));
  331. else
  332. TRY(reference.initialize_referenced_binding(vm, value_to_assign));
  333. continue;
  334. }
  335. auto reference_to_assign_to = TRY(property.alias.visit(
  336. [&](Empty) -> ThrowCompletionOr<Optional<Reference>> { return Optional<Reference> {}; },
  337. [&](NonnullRefPtr<Identifier const> const& identifier) -> ThrowCompletionOr<Optional<Reference>> {
  338. return TRY(resolve_binding(identifier->string(), environment));
  339. },
  340. [&](NonnullRefPtr<BindingPattern const> const&) -> ThrowCompletionOr<Optional<Reference>> { return Optional<Reference> {}; },
  341. [&](NonnullRefPtr<MemberExpression const> const& member_expression) -> ThrowCompletionOr<Optional<Reference>> {
  342. return TRY(member_expression->to_reference(interpreter()));
  343. }));
  344. auto value_to_assign = TRY(object->get(name));
  345. if (property.initializer && value_to_assign.is_undefined()) {
  346. if (auto* identifier_ptr = property.alias.get_pointer<NonnullRefPtr<Identifier const>>())
  347. value_to_assign = TRY(named_evaluation_if_anonymous_function(*property.initializer, (*identifier_ptr)->string()));
  348. else
  349. value_to_assign = TRY(property.initializer->execute(interpreter())).release_value();
  350. }
  351. if (auto* binding_ptr = property.alias.get_pointer<NonnullRefPtr<BindingPattern const>>()) {
  352. TRY(binding_initialization(*binding_ptr, value_to_assign, environment));
  353. } else {
  354. VERIFY(reference_to_assign_to.has_value());
  355. if (!environment)
  356. TRY(reference_to_assign_to->put_value(vm, value_to_assign));
  357. else
  358. TRY(reference_to_assign_to->initialize_referenced_binding(vm, value_to_assign));
  359. }
  360. }
  361. return {};
  362. }
  363. // 13.15.5.5 Runtime Semantics: IteratorDestructuringAssignmentEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-iteratordestructuringassignmentevaluation
  364. // 8.5.3 Runtime Semantics: IteratorBindingInitialization, https://tc39.es/ecma262/#sec-runtime-semantics-iteratorbindinginitialization
  365. ThrowCompletionOr<void> VM::iterator_binding_initialization(BindingPattern const& binding, Iterator& iterator_record, Environment* environment)
  366. {
  367. auto& vm = *this;
  368. auto& realm = *vm.current_realm();
  369. // FIXME: this method is nearly identical to destructuring assignment!
  370. for (size_t i = 0; i < binding.entries.size(); i++) {
  371. auto& entry = binding.entries[i];
  372. Value value;
  373. auto assignment_target = TRY(entry.alias.visit(
  374. [&](Empty) -> ThrowCompletionOr<Optional<Reference>> { return Optional<Reference> {}; },
  375. [&](NonnullRefPtr<Identifier const> const& identifier) -> ThrowCompletionOr<Optional<Reference>> {
  376. return TRY(resolve_binding(identifier->string(), environment));
  377. },
  378. [&](NonnullRefPtr<BindingPattern const> const&) -> ThrowCompletionOr<Optional<Reference>> { return Optional<Reference> {}; },
  379. [&](NonnullRefPtr<MemberExpression const> const& member_expression) -> ThrowCompletionOr<Optional<Reference>> {
  380. return TRY(member_expression->to_reference(interpreter()));
  381. }));
  382. // BindingRestElement : ... BindingIdentifier
  383. // BindingRestElement : ... BindingPattern
  384. if (entry.is_rest) {
  385. VERIFY(i == binding.entries.size() - 1);
  386. // 2. Let A be ! ArrayCreate(0).
  387. auto array = MUST(Array::create(realm, 0));
  388. // 3. Let n be 0.
  389. // 4. Repeat,
  390. while (true) {
  391. ThrowCompletionOr<GCPtr<Object>> next { nullptr };
  392. // a. If iteratorRecord.[[Done]] is false, then
  393. if (!iterator_record.done) {
  394. // i. Let next be Completion(IteratorStep(iteratorRecord)).
  395. next = iterator_step(vm, iterator_record);
  396. // ii. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
  397. // iii. ReturnIfAbrupt(next).
  398. if (next.is_error()) {
  399. iterator_record.done = true;
  400. return next.release_error();
  401. }
  402. // iv. If next is false, set iteratorRecord.[[Done]] to true.
  403. if (!next.value())
  404. iterator_record.done = true;
  405. }
  406. // b. If iteratorRecord.[[Done]] is true, then
  407. if (iterator_record.done) {
  408. // NOTE: Step i. and ii. are handled below.
  409. break;
  410. }
  411. // c. Let nextValue be Completion(IteratorValue(next)).
  412. auto next_value = iterator_value(vm, *next.value());
  413. // d. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
  414. // e. ReturnIfAbrupt(nextValue).
  415. if (next_value.is_error()) {
  416. iterator_record.done = true;
  417. return next_value.release_error();
  418. }
  419. // f. Perform ! CreateDataPropertyOrThrow(A, ! ToString(𝔽(n)), nextValue).
  420. array->indexed_properties().append(next_value.value());
  421. // g. Set n to n + 1.
  422. }
  423. value = array;
  424. }
  425. // SingleNameBinding : BindingIdentifier Initializer[opt]
  426. // BindingElement : BindingPattern Initializer[opt]
  427. else {
  428. // 1. Let v be undefined.
  429. value = js_undefined();
  430. // 2. If iteratorRecord.[[Done]] is false, then
  431. if (!iterator_record.done) {
  432. // a. Let next be Completion(IteratorStep(iteratorRecord)).
  433. auto next = iterator_step(vm, iterator_record);
  434. // b. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
  435. // c. ReturnIfAbrupt(next).
  436. if (next.is_error()) {
  437. iterator_record.done = true;
  438. return next.release_error();
  439. }
  440. // d. If next is false, set iteratorRecord.[[Done]] to true.
  441. if (!next.value()) {
  442. iterator_record.done = true;
  443. }
  444. // e. Else,
  445. else {
  446. // i. Set v to Completion(IteratorValue(next)).
  447. auto value_or_error = iterator_value(vm, *next.value());
  448. // ii. If v is an abrupt completion, set iteratorRecord.[[Done]] to true.
  449. // iii. ReturnIfAbrupt(v).
  450. if (value_or_error.is_throw_completion()) {
  451. iterator_record.done = true;
  452. return value_or_error.release_error();
  453. }
  454. value = value_or_error.release_value();
  455. }
  456. }
  457. // NOTE: Step 3. and 4. are handled below.
  458. }
  459. if (value.is_undefined() && entry.initializer) {
  460. VERIFY(!entry.is_rest);
  461. if (auto* identifier_ptr = entry.alias.get_pointer<NonnullRefPtr<Identifier const>>())
  462. value = TRY(named_evaluation_if_anonymous_function(*entry.initializer, (*identifier_ptr)->string()));
  463. else
  464. value = TRY(entry.initializer->execute(interpreter())).release_value();
  465. }
  466. if (auto* binding_ptr = entry.alias.get_pointer<NonnullRefPtr<BindingPattern const>>()) {
  467. TRY(binding_initialization(*binding_ptr, value, environment));
  468. } else if (!entry.alias.has<Empty>()) {
  469. VERIFY(assignment_target.has_value());
  470. if (!environment)
  471. TRY(assignment_target->put_value(vm, value));
  472. else
  473. TRY(assignment_target->initialize_referenced_binding(vm, value));
  474. }
  475. }
  476. return {};
  477. }
  478. // 9.1.2.1 GetIdentifierReference ( env, name, strict ), https://tc39.es/ecma262/#sec-getidentifierreference
  479. ThrowCompletionOr<Reference> VM::get_identifier_reference(Environment* environment, DeprecatedFlyString name, bool strict, size_t hops)
  480. {
  481. // 1. If env is the value null, then
  482. if (!environment) {
  483. // a. Return the Reference Record { [[Base]]: unresolvable, [[ReferencedName]]: name, [[Strict]]: strict, [[ThisValue]]: empty }.
  484. return Reference { Reference::BaseType::Unresolvable, move(name), strict };
  485. }
  486. // 2. Let exists be ? env.HasBinding(name).
  487. Optional<size_t> index;
  488. auto exists = TRY(environment->has_binding(name, &index));
  489. // Note: This is an optimization for looking up the same reference.
  490. Optional<EnvironmentCoordinate> environment_coordinate;
  491. if (index.has_value()) {
  492. VERIFY(hops <= NumericLimits<u32>::max());
  493. VERIFY(index.value() <= NumericLimits<u32>::max());
  494. environment_coordinate = EnvironmentCoordinate { .hops = static_cast<u32>(hops), .index = static_cast<u32>(index.value()) };
  495. }
  496. // 3. If exists is true, then
  497. if (exists) {
  498. // a. Return the Reference Record { [[Base]]: env, [[ReferencedName]]: name, [[Strict]]: strict, [[ThisValue]]: empty }.
  499. return Reference { *environment, move(name), strict, environment_coordinate };
  500. }
  501. // 4. Else,
  502. else {
  503. // a. Let outer be env.[[OuterEnv]].
  504. // b. Return ? GetIdentifierReference(outer, name, strict).
  505. return get_identifier_reference(environment->outer_environment(), move(name), strict, hops + 1);
  506. }
  507. }
  508. // 9.4.2 ResolveBinding ( name [ , env ] ), https://tc39.es/ecma262/#sec-resolvebinding
  509. ThrowCompletionOr<Reference> VM::resolve_binding(DeprecatedFlyString const& name, Environment* environment)
  510. {
  511. // 1. If env is not present or if env is undefined, then
  512. if (!environment) {
  513. // a. Set env to the running execution context's LexicalEnvironment.
  514. environment = running_execution_context().lexical_environment;
  515. }
  516. // 2. Assert: env is an Environment Record.
  517. VERIFY(environment);
  518. // 3. If the source text matched by the syntactic production that is being evaluated is contained in strict mode code, let strict be true; else let strict be false.
  519. bool strict = in_strict_mode();
  520. // 4. Return ? GetIdentifierReference(env, name, strict).
  521. return get_identifier_reference(environment, name, strict);
  522. // NOTE: The spec says:
  523. // Note: The result of ResolveBinding is always a Reference Record whose [[ReferencedName]] field is name.
  524. // But this is not actually correct as GetIdentifierReference (or really the methods it calls) can throw.
  525. }
  526. // 9.4.4 ResolveThisBinding ( ), https://tc39.es/ecma262/#sec-resolvethisbinding
  527. ThrowCompletionOr<Value> VM::resolve_this_binding()
  528. {
  529. auto& vm = *this;
  530. // 1. Let envRec be GetThisEnvironment().
  531. auto environment = get_this_environment(vm);
  532. // 2. Return ? envRec.GetThisBinding().
  533. return TRY(environment->get_this_binding(vm));
  534. }
  535. // 9.4.5 GetNewTarget ( ), https://tc39.es/ecma262/#sec-getnewtarget
  536. Value VM::get_new_target()
  537. {
  538. // 1. Let envRec be GetThisEnvironment().
  539. auto env = get_this_environment(*this);
  540. // 2. Assert: envRec has a [[NewTarget]] field.
  541. // 3. Return envRec.[[NewTarget]].
  542. return verify_cast<FunctionEnvironment>(*env).new_target();
  543. }
  544. // 9.4.5 GetGlobalObject ( ), https://tc39.es/ecma262/#sec-getglobalobject
  545. Object& VM::get_global_object()
  546. {
  547. // 1. Let currentRealm be the current Realm Record.
  548. auto& current_realm = *this->current_realm();
  549. // 2. Return currentRealm.[[GlobalObject]].
  550. return current_realm.global_object();
  551. }
  552. bool VM::in_strict_mode() const
  553. {
  554. if (execution_context_stack().is_empty())
  555. return false;
  556. return running_execution_context().is_strict_mode;
  557. }
  558. void VM::run_queued_promise_jobs()
  559. {
  560. dbgln_if(PROMISE_DEBUG, "Running queued promise jobs");
  561. while (!m_promise_jobs.is_empty()) {
  562. auto job = m_promise_jobs.take_first();
  563. dbgln_if(PROMISE_DEBUG, "Calling promise job function");
  564. [[maybe_unused]] auto result = job();
  565. }
  566. }
  567. // 9.5.4 HostEnqueuePromiseJob ( job, realm ), https://tc39.es/ecma262/#sec-hostenqueuepromisejob
  568. void VM::enqueue_promise_job(Function<ThrowCompletionOr<Value>()> job, Realm*)
  569. {
  570. // An implementation of HostEnqueuePromiseJob must conform to the requirements in 9.5 as well as the following:
  571. // - FIXME: If realm is not null, each time job is invoked the implementation must perform implementation-defined steps such that execution is prepared to evaluate ECMAScript code at the time of job's invocation.
  572. // - FIXME: Let scriptOrModule be GetActiveScriptOrModule() at the time HostEnqueuePromiseJob is invoked. If realm is not null, each time job is invoked the implementation must perform implementation-defined steps
  573. // such that scriptOrModule is the active script or module at the time of job's invocation.
  574. // - Jobs must run in the same order as the HostEnqueuePromiseJob invocations that scheduled them.
  575. m_promise_jobs.append(move(job));
  576. }
  577. void VM::run_queued_finalization_registry_cleanup_jobs()
  578. {
  579. while (!m_finalization_registry_cleanup_jobs.is_empty()) {
  580. auto registry = m_finalization_registry_cleanup_jobs.take_first();
  581. // FIXME: Handle any uncatched exceptions here.
  582. (void)registry->cleanup();
  583. }
  584. }
  585. // 9.10.4.1 HostEnqueueFinalizationRegistryCleanupJob ( finalizationRegistry ), https://tc39.es/ecma262/#sec-host-cleanup-finalization-registry
  586. void VM::enqueue_finalization_registry_cleanup_job(FinalizationRegistry& registry)
  587. {
  588. m_finalization_registry_cleanup_jobs.append(&registry);
  589. }
  590. // 27.2.1.9 HostPromiseRejectionTracker ( promise, operation ), https://tc39.es/ecma262/#sec-host-promise-rejection-tracker
  591. void VM::promise_rejection_tracker(Promise& promise, Promise::RejectionOperation operation) const
  592. {
  593. switch (operation) {
  594. case Promise::RejectionOperation::Reject:
  595. // A promise was rejected without any handlers
  596. if (on_promise_unhandled_rejection)
  597. on_promise_unhandled_rejection(promise);
  598. break;
  599. case Promise::RejectionOperation::Handle:
  600. // A handler was added to an already rejected promise
  601. if (on_promise_rejection_handled)
  602. on_promise_rejection_handled(promise);
  603. break;
  604. default:
  605. VERIFY_NOT_REACHED();
  606. }
  607. }
  608. void VM::dump_backtrace() const
  609. {
  610. for (ssize_t i = m_execution_context_stack.size() - 1; i >= 0; --i) {
  611. auto& frame = m_execution_context_stack[i];
  612. if (frame->current_node) {
  613. auto source_range = frame->current_node->source_range();
  614. dbgln("-> {} @ {}:{},{}", frame->function_name, source_range.filename(), source_range.start.line, source_range.start.column);
  615. } else {
  616. dbgln("-> {}", frame->function_name);
  617. }
  618. }
  619. }
  620. void VM::save_execution_context_stack()
  621. {
  622. m_saved_execution_context_stacks.append(move(m_execution_context_stack));
  623. }
  624. void VM::restore_execution_context_stack()
  625. {
  626. m_execution_context_stack = m_saved_execution_context_stacks.take_last();
  627. }
  628. // 9.4.1 GetActiveScriptOrModule ( ), https://tc39.es/ecma262/#sec-getactivescriptormodule
  629. ScriptOrModule VM::get_active_script_or_module() const
  630. {
  631. // 1. If the execution context stack is empty, return null.
  632. if (m_execution_context_stack.is_empty())
  633. return Empty {};
  634. // 2. Let ec be the topmost execution context on the execution context stack whose ScriptOrModule component is not null.
  635. for (auto i = m_execution_context_stack.size() - 1; i > 0; i--) {
  636. if (!m_execution_context_stack[i]->script_or_module.has<Empty>())
  637. return m_execution_context_stack[i]->script_or_module;
  638. }
  639. // 3. If no such execution context exists, return null. Otherwise, return ec's ScriptOrModule.
  640. // Note: Since it is not empty we have 0 and since we got here all the
  641. // above contexts don't have a non-null ScriptOrModule
  642. return m_execution_context_stack[0]->script_or_module;
  643. }
  644. VM::StoredModule* VM::get_stored_module(ScriptOrModule const&, DeprecatedString const& filename, DeprecatedString const&)
  645. {
  646. // Note the spec says:
  647. // Each time this operation is called with a specific referencingScriptOrModule, specifier pair as arguments
  648. // it must return the same Module Record instance if it completes normally.
  649. // Currently, we ignore the referencing script or module but this might not be correct in all cases.
  650. // Editor's Note from https://tc39.es/proposal-json-modules/#sec-hostresolveimportedmodule
  651. // The above text implies that is recommended but not required that hosts do not use moduleRequest.[[Assertions]]
  652. // as part of the module cache key. In either case, an exception thrown from an import with a given assertion list
  653. // does not rule out success of another import with the same specifier but a different assertion list.
  654. auto end_or_module = m_loaded_modules.find_if([&](StoredModule const& stored_module) {
  655. return stored_module.filename == filename;
  656. });
  657. if (end_or_module.is_end())
  658. return nullptr;
  659. return &(*end_or_module);
  660. }
  661. ThrowCompletionOr<void> VM::link_and_eval_module(Badge<Interpreter>, SourceTextModule& module)
  662. {
  663. return link_and_eval_module(module);
  664. }
  665. ThrowCompletionOr<void> VM::link_and_eval_module(Module& module)
  666. {
  667. auto filename = module.filename();
  668. auto module_or_end = m_loaded_modules.find_if([&](StoredModule const& stored_module) {
  669. return stored_module.module.ptr() == &module;
  670. });
  671. StoredModule* stored_module;
  672. if (module_or_end.is_end()) {
  673. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] Warning introducing module via link_and_eval_module {}", module.filename());
  674. if (m_loaded_modules.size() > 0)
  675. dbgln("Warning: Using multiple modules as entry point can lead to unexpected results");
  676. m_loaded_modules.empend(
  677. NonnullGCPtr(module),
  678. module.filename(),
  679. DeprecatedString {}, // Null type
  680. module,
  681. true);
  682. stored_module = &m_loaded_modules.last();
  683. } else {
  684. stored_module = module_or_end.operator->();
  685. if (stored_module->has_once_started_linking) {
  686. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] Module already has started linking once {}", module.filename());
  687. return {};
  688. }
  689. stored_module->has_once_started_linking = true;
  690. }
  691. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] Linking module {}", filename);
  692. auto linked_or_error = module.link(*this);
  693. if (linked_or_error.is_error())
  694. return linked_or_error.throw_completion();
  695. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] Linking passed, now evaluating module {}", filename);
  696. auto evaluated_or_error = module.evaluate(*this);
  697. if (evaluated_or_error.is_error())
  698. return evaluated_or_error.throw_completion();
  699. auto* evaluated_value = evaluated_or_error.value();
  700. run_queued_promise_jobs();
  701. VERIFY(m_promise_jobs.is_empty());
  702. // FIXME: This will break if we start doing promises actually asynchronously.
  703. VERIFY(evaluated_value->state() != Promise::State::Pending);
  704. if (evaluated_value->state() == Promise::State::Rejected)
  705. return JS::throw_completion(evaluated_value->result());
  706. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] Evaluating passed for module {}", module.filename());
  707. return {};
  708. }
  709. static DeprecatedString resolve_module_filename(StringView filename, StringView module_type)
  710. {
  711. auto extensions = Vector<StringView, 2> { "js"sv, "mjs"sv };
  712. if (module_type == "json"sv)
  713. extensions = { "json"sv };
  714. if (!FileSystem::exists(filename)) {
  715. for (auto extension : extensions) {
  716. // import "./foo" -> import "./foo.ext"
  717. auto resolved_filepath = DeprecatedString::formatted("{}.{}", filename, extension);
  718. if (FileSystem::exists(resolved_filepath))
  719. return resolved_filepath;
  720. }
  721. } else if (FileSystem::is_directory(filename)) {
  722. for (auto extension : extensions) {
  723. // import "./foo" -> import "./foo/index.ext"
  724. auto resolved_filepath = LexicalPath::join(filename, DeprecatedString::formatted("index.{}", extension)).string();
  725. if (FileSystem::exists(resolved_filepath))
  726. return resolved_filepath;
  727. }
  728. }
  729. return filename;
  730. }
  731. // 16.2.1.7 HostResolveImportedModule ( referencingScriptOrModule, specifier ), https://tc39.es/ecma262/#sec-hostresolveimportedmodule
  732. ThrowCompletionOr<NonnullGCPtr<Module>> VM::resolve_imported_module(ScriptOrModule referencing_script_or_module, ModuleRequest const& module_request)
  733. {
  734. // An implementation of HostResolveImportedModule must conform to the following requirements:
  735. // - If it completes normally, the [[Value]] slot of the completion must contain an instance of a concrete subclass of Module Record.
  736. // - If a Module Record corresponding to the pair referencingScriptOrModule, moduleRequest does not exist or cannot be created, an exception must be thrown.
  737. // - Each time this operation is called with a specific referencingScriptOrModule, moduleRequest.[[Specifier]], moduleRequest.[[Assertions]] triple
  738. // as arguments it must return the same Module Record instance if it completes normally.
  739. // * It is recommended but not required that implementations additionally conform to the following stronger constraint:
  740. // each time this operation is called with a specific referencingScriptOrModule, moduleRequest.[[Specifier]] pair as arguments it must return the same Module Record instance if it completes normally.
  741. // - moduleRequest.[[Assertions]] must not influence the interpretation of the module or the module specifier;
  742. // instead, it may be used to determine whether the algorithm completes normally or with an abrupt completion.
  743. // Multiple different referencingScriptOrModule, moduleRequest.[[Specifier]] pairs may map to the same Module Record instance.
  744. // The actual mapping semantic is host-defined but typically a normalization process is applied to specifier as part of the mapping process.
  745. // A typical normalization process would include actions such as alphabetic case folding and expansion of relative and abbreviated path specifiers.
  746. // We only allow "type" as a supported assertion so it is the only valid key that should ever arrive here.
  747. VERIFY(module_request.assertions.is_empty() || (module_request.assertions.size() == 1 && module_request.assertions.first().key == "type"));
  748. auto module_type = module_request.assertions.is_empty() ? DeprecatedString {} : module_request.assertions.first().value;
  749. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] module at {} has type {} [is_null={}]", module_request.module_specifier, module_type, module_type.is_null());
  750. StringView base_filename = referencing_script_or_module.visit(
  751. [&](Empty) {
  752. return "."sv;
  753. },
  754. [&](auto& script_or_module) {
  755. return script_or_module->filename();
  756. });
  757. LexicalPath base_path { base_filename };
  758. auto filename = LexicalPath::absolute_path(base_path.dirname(), module_request.module_specifier);
  759. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] base path: '{}'", base_path);
  760. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] initial filename: '{}'", filename);
  761. filename = resolve_module_filename(filename, module_type);
  762. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] resolved filename: '{}'", filename);
  763. #if JS_MODULE_DEBUG
  764. DeprecatedString referencing_module_string = referencing_script_or_module.visit(
  765. [&](Empty) -> DeprecatedString {
  766. return ".";
  767. },
  768. [&](auto& script_or_module) {
  769. if constexpr (IsSame<Script*, decltype(script_or_module)>) {
  770. return DeprecatedString::formatted("Script @ {}", script_or_module.ptr());
  771. }
  772. return DeprecatedString::formatted("Module @ {}", script_or_module.ptr());
  773. });
  774. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] resolve_imported_module({}, {})", referencing_module_string, filename);
  775. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] resolved {} + {} -> {}", base_path, module_request.module_specifier, filename);
  776. #endif
  777. auto* loaded_module_or_end = get_stored_module(referencing_script_or_module, filename, module_type);
  778. if (loaded_module_or_end != nullptr) {
  779. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] resolve_imported_module({}) already loaded at {}", filename, loaded_module_or_end->module.ptr());
  780. return NonnullGCPtr(*loaded_module_or_end->module);
  781. }
  782. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] reading and parsing module {}", filename);
  783. auto file_or_error = Core::File::open(filename, Core::File::OpenMode::Read);
  784. if (file_or_error.is_error()) {
  785. return throw_completion<SyntaxError>(ErrorType::ModuleNotFound, module_request.module_specifier);
  786. }
  787. // FIXME: Don't read the file in one go.
  788. auto file_content_or_error = file_or_error.value()->read_until_eof();
  789. if (file_content_or_error.is_error()) {
  790. if (file_content_or_error.error().code() == ENOMEM)
  791. return throw_completion<JS::InternalError>(error_message(::JS::VM::ErrorMessage::OutOfMemory));
  792. return throw_completion<SyntaxError>(ErrorType::ModuleNotFound, module_request.module_specifier);
  793. }
  794. StringView const content_view { file_content_or_error.value().bytes() };
  795. auto module = TRY([&]() -> ThrowCompletionOr<NonnullGCPtr<Module>> {
  796. // If assertions has an entry entry such that entry.[[Key]] is "type", let type be entry.[[Value]]. The following requirements apply:
  797. // If type is "json", then this algorithm must either invoke ParseJSONModule and return the resulting Completion Record, or throw an exception.
  798. if (module_type == "json"sv) {
  799. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] reading and parsing JSON module {}", filename);
  800. return parse_json_module(content_view, *current_realm(), filename);
  801. }
  802. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] reading and parsing as SourceTextModule module {}", filename);
  803. // Note: We treat all files as module, so if a script does not have exports it just runs it.
  804. auto module_or_errors = SourceTextModule::parse(content_view, *current_realm(), filename);
  805. if (module_or_errors.is_error()) {
  806. VERIFY(module_or_errors.error().size() > 0);
  807. return throw_completion<SyntaxError>(module_or_errors.error().first().to_deprecated_string());
  808. }
  809. return module_or_errors.release_value();
  810. }());
  811. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] resolve_imported_module(...) parsed {} to {}", filename, module.ptr());
  812. // We have to set it here already in case it references itself.
  813. m_loaded_modules.empend(
  814. referencing_script_or_module,
  815. filename,
  816. module_type,
  817. *module,
  818. false);
  819. return module;
  820. }
  821. // 16.2.1.8 HostImportModuleDynamically ( referencingScriptOrModule, specifier, promiseCapability ), https://tc39.es/ecma262/#sec-hostimportmoduledynamically
  822. ThrowCompletionOr<void> VM::import_module_dynamically(ScriptOrModule referencing_script_or_module, ModuleRequest module_request, PromiseCapability const& promise_capability)
  823. {
  824. auto& realm = *current_realm();
  825. // Success path:
  826. // - At some future time, the host environment must perform FinishDynamicImport(referencingScriptOrModule, moduleRequest, promiseCapability, promise),
  827. // where promise is a Promise resolved with undefined.
  828. // - Any subsequent call to HostResolveImportedModule after FinishDynamicImport has completed,
  829. // given the arguments referencingScriptOrModule and specifier, must return a normal completion
  830. // containing a module which has already been evaluated, i.e. whose Evaluate concrete method has
  831. // already been called and returned a normal completion.
  832. // Failure path:
  833. // - At some future time, the host environment must perform
  834. // FinishDynamicImport(referencingScriptOrModule, moduleRequest, promiseCapability, promise),
  835. // where promise is a Promise rejected with an error representing the cause of failure.
  836. auto promise = Promise::create(realm);
  837. ScopeGuard finish_dynamic_import = [&] {
  838. host_finish_dynamic_import(referencing_script_or_module, module_request, promise_capability, promise);
  839. };
  840. // Generally within ECMA262 we always get a referencing_script_or_moulde. However, ShadowRealm gives an explicit null.
  841. // To get around this is we attempt to get the active script_or_module otherwise we might start loading "random" files from the working directory.
  842. if (referencing_script_or_module.has<Empty>()) {
  843. referencing_script_or_module = get_active_script_or_module();
  844. // If there is no ScriptOrModule in any of the execution contexts
  845. if (referencing_script_or_module.has<Empty>()) {
  846. // Throw an error for now
  847. promise->reject(InternalError::create(realm, TRY_OR_THROW_OOM(*this, String::formatted(ErrorType::ModuleNotFoundNoReferencingScript.message(), module_request.module_specifier))));
  848. return {};
  849. }
  850. }
  851. // Note: If host_resolve_imported_module returns a module it has been loaded successfully and the next call in finish_dynamic_import will retrieve it again.
  852. auto module_or_error = host_resolve_imported_module(referencing_script_or_module, module_request);
  853. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] HostImportModuleDynamically(..., {}) -> {}", module_request.module_specifier, module_or_error.is_error() ? "failed" : "passed");
  854. if (module_or_error.is_throw_completion()) {
  855. promise->reject(*module_or_error.throw_completion().value());
  856. } else {
  857. auto module = module_or_error.release_value();
  858. auto& source_text_module = static_cast<Module&>(*module);
  859. auto evaluated_or_error = link_and_eval_module(source_text_module);
  860. if (evaluated_or_error.is_throw_completion()) {
  861. promise->reject(*evaluated_or_error.throw_completion().value());
  862. } else {
  863. promise->fulfill(js_undefined());
  864. }
  865. }
  866. // It must return unused.
  867. // Note: Just return void always since the resulting value cannot be accessed by user code.
  868. return {};
  869. }
  870. // 16.2.1.9 FinishDynamicImport ( referencingScriptOrModule, specifier, promiseCapability, innerPromise ), https://tc39.es/ecma262/#sec-finishdynamicimport
  871. void VM::finish_dynamic_import(ScriptOrModule referencing_script_or_module, ModuleRequest module_request, PromiseCapability const& promise_capability, Promise* inner_promise)
  872. {
  873. dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] finish_dynamic_import on {}", module_request.module_specifier);
  874. auto& realm = *current_realm();
  875. // 1. Let fulfilledClosure be a new Abstract Closure with parameters (result) that captures referencingScriptOrModule, specifier, and promiseCapability and performs the following steps when called:
  876. auto fulfilled_closure = [referencing_script_or_module = move(referencing_script_or_module), module_request = move(module_request), &promise_capability](VM& vm) -> ThrowCompletionOr<Value> {
  877. auto result = vm.argument(0);
  878. // a. Assert: result is undefined.
  879. VERIFY(result.is_undefined());
  880. // b. Let moduleRecord be ! HostResolveImportedModule(referencingScriptOrModule, specifier).
  881. auto module_record = MUST(vm.host_resolve_imported_module(referencing_script_or_module, module_request));
  882. // c. Assert: Evaluate has already been invoked on moduleRecord and successfully completed.
  883. // Note: If HostResolveImportedModule returns a module evaluate will have been called on it.
  884. // d. Let namespace be Completion(GetModuleNamespace(moduleRecord)).
  885. auto namespace_ = module_record->get_module_namespace(vm);
  886. // e. If namespace is an abrupt completion, then
  887. if (namespace_.is_throw_completion()) {
  888. // i. Perform ! Call(promiseCapability.[[Reject]], undefined, « namespace.[[Value]] »).
  889. MUST(call(vm, *promise_capability.reject(), js_undefined(), *namespace_.throw_completion().value()));
  890. }
  891. // f. Else,
  892. else {
  893. // i. Perform ! Call(promiseCapability.[[Resolve]], undefined, « namespace.[[Value]] »).
  894. MUST(call(vm, *promise_capability.resolve(), js_undefined(), namespace_.release_value()));
  895. }
  896. // g. Return unused.
  897. // NOTE: We don't support returning an empty/optional/unused value here.
  898. return js_undefined();
  899. };
  900. // 2. Let onFulfilled be CreateBuiltinFunction(fulfilledClosure, 0, "", « »).
  901. auto on_fulfilled = NativeFunction::create(realm, move(fulfilled_closure), 0, "");
  902. // 3. Let rejectedClosure be a new Abstract Closure with parameters (error) that captures promiseCapability and performs the following steps when called:
  903. auto rejected_closure = [&promise_capability](VM& vm) -> ThrowCompletionOr<Value> {
  904. auto error = vm.argument(0);
  905. // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « error »).
  906. MUST(call(vm, *promise_capability.reject(), js_undefined(), error));
  907. // b. Return unused.
  908. // NOTE: We don't support returning an empty/optional/unused value here.
  909. return js_undefined();
  910. };
  911. // 4. Let onRejected be CreateBuiltinFunction(rejectedClosure, 0, "", « »).
  912. auto on_rejected = NativeFunction::create(realm, move(rejected_closure), 0, "");
  913. // 5. Perform PerformPromiseThen(innerPromise, onFulfilled, onRejected).
  914. inner_promise->perform_then(on_fulfilled, on_rejected, {});
  915. // 6. Return unused.
  916. }
  917. }