Op.cpp 65 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579
  1. /*
  2. * Copyright (c) 2021-2023, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021-2023, Linus Groh <linusg@serenityos.org>
  4. * Copyright (c) 2021, Gunnar Beutner <gbeutner@serenityos.org>
  5. *
  6. * SPDX-License-Identifier: BSD-2-Clause
  7. */
  8. #include <AK/HashTable.h>
  9. #include <LibJS/AST.h>
  10. #include <LibJS/Bytecode/Interpreter.h>
  11. #include <LibJS/Bytecode/Op.h>
  12. #include <LibJS/Runtime/AbstractOperations.h>
  13. #include <LibJS/Runtime/Array.h>
  14. #include <LibJS/Runtime/BigInt.h>
  15. #include <LibJS/Runtime/DeclarativeEnvironment.h>
  16. #include <LibJS/Runtime/ECMAScriptFunctionObject.h>
  17. #include <LibJS/Runtime/Environment.h>
  18. #include <LibJS/Runtime/FunctionEnvironment.h>
  19. #include <LibJS/Runtime/GlobalEnvironment.h>
  20. #include <LibJS/Runtime/GlobalObject.h>
  21. #include <LibJS/Runtime/Iterator.h>
  22. #include <LibJS/Runtime/IteratorOperations.h>
  23. #include <LibJS/Runtime/NativeFunction.h>
  24. #include <LibJS/Runtime/ObjectEnvironment.h>
  25. #include <LibJS/Runtime/Reference.h>
  26. #include <LibJS/Runtime/RegExpObject.h>
  27. #include <LibJS/Runtime/Value.h>
  28. namespace JS::Bytecode {
  29. DeprecatedString Instruction::to_deprecated_string(Bytecode::Executable const& executable) const
  30. {
  31. #define __BYTECODE_OP(op) \
  32. case Instruction::Type::op: \
  33. return static_cast<Bytecode::Op::op const&>(*this).to_deprecated_string_impl(executable);
  34. switch (type()) {
  35. ENUMERATE_BYTECODE_OPS(__BYTECODE_OP)
  36. default:
  37. VERIFY_NOT_REACHED();
  38. }
  39. #undef __BYTECODE_OP
  40. }
  41. }
  42. namespace JS::Bytecode::Op {
  43. static ThrowCompletionOr<void> put_by_property_key(VM& vm, Object* object, Value value, PropertyKey name, PropertyKind kind)
  44. {
  45. if (kind == PropertyKind::Getter || kind == PropertyKind::Setter) {
  46. // The generator should only pass us functions for getters and setters.
  47. VERIFY(value.is_function());
  48. }
  49. switch (kind) {
  50. case PropertyKind::Getter: {
  51. auto& function = value.as_function();
  52. if (function.name().is_empty() && is<ECMAScriptFunctionObject>(function))
  53. static_cast<ECMAScriptFunctionObject*>(&function)->set_name(DeprecatedString::formatted("get {}", name));
  54. object->define_direct_accessor(name, &function, nullptr, Attribute::Configurable | Attribute::Enumerable);
  55. break;
  56. }
  57. case PropertyKind::Setter: {
  58. auto& function = value.as_function();
  59. if (function.name().is_empty() && is<ECMAScriptFunctionObject>(function))
  60. static_cast<ECMAScriptFunctionObject*>(&function)->set_name(DeprecatedString::formatted("set {}", name));
  61. object->define_direct_accessor(name, nullptr, &function, Attribute::Configurable | Attribute::Enumerable);
  62. break;
  63. }
  64. case PropertyKind::KeyValue: {
  65. bool succeeded = TRY(object->internal_set(name, value, object));
  66. if (!succeeded && vm.in_strict_mode())
  67. return vm.throw_completion<TypeError>(ErrorType::ReferenceNullishSetProperty, name, TRY_OR_THROW_OOM(vm, value.to_string_without_side_effects()));
  68. break;
  69. }
  70. case PropertyKind::Spread:
  71. TRY(object->copy_data_properties(vm, value, {}));
  72. break;
  73. case PropertyKind::ProtoSetter:
  74. if (value.is_object() || value.is_null())
  75. MUST(object->internal_set_prototype_of(value.is_object() ? &value.as_object() : nullptr));
  76. break;
  77. }
  78. return {};
  79. }
  80. ThrowCompletionOr<void> Load::execute_impl(Bytecode::Interpreter& interpreter) const
  81. {
  82. interpreter.accumulator() = interpreter.reg(m_src);
  83. return {};
  84. }
  85. ThrowCompletionOr<void> LoadImmediate::execute_impl(Bytecode::Interpreter& interpreter) const
  86. {
  87. interpreter.accumulator() = m_value;
  88. return {};
  89. }
  90. ThrowCompletionOr<void> Store::execute_impl(Bytecode::Interpreter& interpreter) const
  91. {
  92. interpreter.reg(m_dst) = interpreter.accumulator();
  93. return {};
  94. }
  95. static ThrowCompletionOr<Value> abstract_inequals(VM& vm, Value src1, Value src2)
  96. {
  97. return Value(!TRY(is_loosely_equal(vm, src1, src2)));
  98. }
  99. static ThrowCompletionOr<Value> abstract_equals(VM& vm, Value src1, Value src2)
  100. {
  101. return Value(TRY(is_loosely_equal(vm, src1, src2)));
  102. }
  103. static ThrowCompletionOr<Value> typed_inequals(VM&, Value src1, Value src2)
  104. {
  105. return Value(!is_strictly_equal(src1, src2));
  106. }
  107. static ThrowCompletionOr<Value> typed_equals(VM&, Value src1, Value src2)
  108. {
  109. return Value(is_strictly_equal(src1, src2));
  110. }
  111. #define JS_DEFINE_COMMON_BINARY_OP(OpTitleCase, op_snake_case) \
  112. ThrowCompletionOr<void> OpTitleCase::execute_impl(Bytecode::Interpreter& interpreter) const \
  113. { \
  114. auto& vm = interpreter.vm(); \
  115. auto lhs = interpreter.reg(m_lhs_reg); \
  116. auto rhs = interpreter.accumulator(); \
  117. interpreter.accumulator() = TRY(op_snake_case(vm, lhs, rhs)); \
  118. return {}; \
  119. } \
  120. DeprecatedString OpTitleCase::to_deprecated_string_impl(Bytecode::Executable const&) const \
  121. { \
  122. return DeprecatedString::formatted(#OpTitleCase " {}", m_lhs_reg); \
  123. }
  124. JS_ENUMERATE_COMMON_BINARY_OPS(JS_DEFINE_COMMON_BINARY_OP)
  125. static ThrowCompletionOr<Value> not_(VM&, Value value)
  126. {
  127. return Value(!value.to_boolean());
  128. }
  129. static ThrowCompletionOr<Value> typeof_(VM& vm, Value value)
  130. {
  131. return MUST_OR_THROW_OOM(PrimitiveString::create(vm, value.typeof()));
  132. }
  133. #define JS_DEFINE_COMMON_UNARY_OP(OpTitleCase, op_snake_case) \
  134. ThrowCompletionOr<void> OpTitleCase::execute_impl(Bytecode::Interpreter& interpreter) const \
  135. { \
  136. auto& vm = interpreter.vm(); \
  137. interpreter.accumulator() = TRY(op_snake_case(vm, interpreter.accumulator())); \
  138. return {}; \
  139. } \
  140. DeprecatedString OpTitleCase::to_deprecated_string_impl(Bytecode::Executable const&) const \
  141. { \
  142. return #OpTitleCase; \
  143. }
  144. JS_ENUMERATE_COMMON_UNARY_OPS(JS_DEFINE_COMMON_UNARY_OP)
  145. ThrowCompletionOr<void> NewBigInt::execute_impl(Bytecode::Interpreter& interpreter) const
  146. {
  147. auto& vm = interpreter.vm();
  148. interpreter.accumulator() = BigInt::create(vm, m_bigint);
  149. return {};
  150. }
  151. ThrowCompletionOr<void> NewArray::execute_impl(Bytecode::Interpreter& interpreter) const
  152. {
  153. auto array = MUST(Array::create(interpreter.realm(), 0));
  154. for (size_t i = 0; i < m_element_count; i++) {
  155. auto& value = interpreter.reg(Register(m_elements[0].index() + i));
  156. array->indexed_properties().put(i, value, default_attributes);
  157. }
  158. interpreter.accumulator() = array;
  159. return {};
  160. }
  161. ThrowCompletionOr<void> Append::execute_impl(Bytecode::Interpreter& interpreter) const
  162. {
  163. // Note: This OpCode is used to construct array literals and argument arrays for calls,
  164. // containing at least one spread element,
  165. // Iterating over such a spread element to unpack it has to be visible by
  166. // the user courtesy of
  167. // (1) https://tc39.es/ecma262/#sec-runtime-semantics-arrayaccumulation
  168. // SpreadElement : ... AssignmentExpression
  169. // 1. Let spreadRef be ? Evaluation of AssignmentExpression.
  170. // 2. Let spreadObj be ? GetValue(spreadRef).
  171. // 3. Let iteratorRecord be ? GetIterator(spreadObj).
  172. // 4. Repeat,
  173. // a. Let next be ? IteratorStep(iteratorRecord).
  174. // b. If next is false, return nextIndex.
  175. // c. Let nextValue be ? IteratorValue(next).
  176. // d. Perform ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), nextValue).
  177. // e. Set nextIndex to nextIndex + 1.
  178. // (2) https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
  179. // ArgumentList : ... AssignmentExpression
  180. // 1. Let list be a new empty List.
  181. // 2. Let spreadRef be ? Evaluation of AssignmentExpression.
  182. // 3. Let spreadObj be ? GetValue(spreadRef).
  183. // 4. Let iteratorRecord be ? GetIterator(spreadObj).
  184. // 5. Repeat,
  185. // a. Let next be ? IteratorStep(iteratorRecord).
  186. // b. If next is false, return list.
  187. // c. Let nextArg be ? IteratorValue(next).
  188. // d. Append nextArg to list.
  189. // ArgumentList : ArgumentList , ... AssignmentExpression
  190. // 1. Let precedingArgs be ? ArgumentListEvaluation of ArgumentList.
  191. // 2. Let spreadRef be ? Evaluation of AssignmentExpression.
  192. // 3. Let iteratorRecord be ? GetIterator(? GetValue(spreadRef)).
  193. // 4. Repeat,
  194. // a. Let next be ? IteratorStep(iteratorRecord).
  195. // b. If next is false, return precedingArgs.
  196. // c. Let nextArg be ? IteratorValue(next).
  197. // d. Append nextArg to precedingArgs.
  198. auto& vm = interpreter.vm();
  199. // Note: We know from codegen, that lhs is a plain array with only indexed properties
  200. auto& lhs = interpreter.reg(m_lhs).as_array();
  201. auto lhs_size = lhs.indexed_properties().array_like_size();
  202. auto rhs = interpreter.accumulator();
  203. if (m_is_spread) {
  204. // ...rhs
  205. size_t i = lhs_size;
  206. TRY(get_iterator_values(vm, rhs, [&i, &lhs](Value iterator_value) -> Optional<Completion> {
  207. lhs.indexed_properties().put(i, iterator_value, default_attributes);
  208. ++i;
  209. return {};
  210. }));
  211. } else {
  212. lhs.indexed_properties().put(lhs_size, rhs, default_attributes);
  213. }
  214. return {};
  215. }
  216. ThrowCompletionOr<void> ImportCall::execute_impl(Bytecode::Interpreter& interpreter) const
  217. {
  218. auto& vm = interpreter.vm();
  219. auto specifier = interpreter.reg(m_specifier);
  220. auto options_value = interpreter.reg(m_options);
  221. interpreter.accumulator() = TRY(perform_import_call(vm, specifier, options_value));
  222. return {};
  223. }
  224. void ImportCall::replace_references_impl(Register from, Register to)
  225. {
  226. if (m_specifier == from)
  227. m_specifier = to;
  228. if (m_options == from)
  229. m_options = to;
  230. }
  231. // FIXME: Since the accumulator is a Value, we store an object there and have to convert back and forth between that an Iterator records. Not great.
  232. // Make sure to put this into the accumulator before the iterator object disappears from the stack to prevent the members from being GC'd.
  233. static Object* iterator_to_object(VM& vm, Iterator iterator)
  234. {
  235. auto& realm = *vm.current_realm();
  236. auto object = Object::create(realm, nullptr);
  237. object->define_direct_property(vm.names.iterator, iterator.iterator, 0);
  238. object->define_direct_property(vm.names.next, iterator.next_method, 0);
  239. object->define_direct_property(vm.names.done, Value(iterator.done), 0);
  240. return object;
  241. }
  242. static Iterator object_to_iterator(VM& vm, Object& object)
  243. {
  244. return Iterator {
  245. .iterator = &MUST(object.get(vm.names.iterator)).as_object(),
  246. .next_method = MUST(object.get(vm.names.next)),
  247. .done = MUST(object.get(vm.names.done)).as_bool()
  248. };
  249. }
  250. ThrowCompletionOr<void> IteratorToArray::execute_impl(Bytecode::Interpreter& interpreter) const
  251. {
  252. auto& vm = interpreter.vm();
  253. auto iterator_object = TRY(interpreter.accumulator().to_object(vm));
  254. auto iterator = object_to_iterator(vm, iterator_object);
  255. auto array = MUST(Array::create(interpreter.realm(), 0));
  256. size_t index = 0;
  257. while (true) {
  258. auto iterator_result = TRY(iterator_next(vm, iterator));
  259. auto complete = TRY(iterator_complete(vm, iterator_result));
  260. if (complete) {
  261. interpreter.accumulator() = array;
  262. return {};
  263. }
  264. auto value = TRY(iterator_value(vm, iterator_result));
  265. MUST(array->create_data_property_or_throw(index, value));
  266. index++;
  267. }
  268. return {};
  269. }
  270. ThrowCompletionOr<void> NewString::execute_impl(Bytecode::Interpreter& interpreter) const
  271. {
  272. interpreter.accumulator() = PrimitiveString::create(interpreter.vm(), interpreter.current_executable().get_string(m_string));
  273. return {};
  274. }
  275. ThrowCompletionOr<void> NewObject::execute_impl(Bytecode::Interpreter& interpreter) const
  276. {
  277. auto& vm = interpreter.vm();
  278. auto& realm = *vm.current_realm();
  279. interpreter.accumulator() = Object::create(realm, realm.intrinsics().object_prototype());
  280. return {};
  281. }
  282. ThrowCompletionOr<void> NewRegExp::execute_impl(Bytecode::Interpreter& interpreter) const
  283. {
  284. auto& vm = interpreter.vm();
  285. auto source = interpreter.current_executable().get_string(m_source_index);
  286. auto flags = interpreter.current_executable().get_string(m_flags_index);
  287. interpreter.accumulator() = TRY(regexp_create(vm, PrimitiveString::create(vm, source), PrimitiveString::create(vm, flags)));
  288. return {};
  289. }
  290. #define JS_DEFINE_NEW_BUILTIN_ERROR_OP(ErrorName) \
  291. ThrowCompletionOr<void> New##ErrorName::execute_impl(Bytecode::Interpreter& interpreter) const \
  292. { \
  293. auto& vm = interpreter.vm(); \
  294. auto& realm = *vm.current_realm(); \
  295. interpreter.accumulator() = MUST_OR_THROW_OOM(ErrorName::create(realm, interpreter.current_executable().get_string(m_error_string))); \
  296. return {}; \
  297. } \
  298. DeprecatedString New##ErrorName::to_deprecated_string_impl(Bytecode::Executable const& executable) const \
  299. { \
  300. return DeprecatedString::formatted("New" #ErrorName " {} (\"{}\")", m_error_string, executable.string_table->get(m_error_string)); \
  301. }
  302. JS_ENUMERATE_NEW_BUILTIN_ERROR_OPS(JS_DEFINE_NEW_BUILTIN_ERROR_OP)
  303. ThrowCompletionOr<void> CopyObjectExcludingProperties::execute_impl(Bytecode::Interpreter& interpreter) const
  304. {
  305. auto& vm = interpreter.vm();
  306. auto& realm = *vm.current_realm();
  307. auto from_object = TRY(interpreter.reg(m_from_object).to_object(vm));
  308. auto to_object = Object::create(realm, realm.intrinsics().object_prototype());
  309. HashTable<Value, ValueTraits> excluded_names;
  310. for (size_t i = 0; i < m_excluded_names_count; ++i)
  311. excluded_names.set(interpreter.reg(m_excluded_names[i]));
  312. auto own_keys = TRY(from_object->internal_own_property_keys());
  313. for (auto& key : own_keys) {
  314. if (!excluded_names.contains(key)) {
  315. auto property_key = TRY(key.to_property_key(vm));
  316. auto property_value = TRY(from_object->get(property_key));
  317. to_object->define_direct_property(property_key, property_value, JS::default_attributes);
  318. }
  319. }
  320. interpreter.accumulator() = to_object;
  321. return {};
  322. }
  323. ThrowCompletionOr<void> ConcatString::execute_impl(Bytecode::Interpreter& interpreter) const
  324. {
  325. auto& vm = interpreter.vm();
  326. interpreter.reg(m_lhs) = TRY(add(vm, interpreter.reg(m_lhs), interpreter.accumulator()));
  327. return {};
  328. }
  329. ThrowCompletionOr<void> GetVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  330. {
  331. auto& vm = interpreter.vm();
  332. auto get_reference = [&]() -> ThrowCompletionOr<Reference> {
  333. auto const& string = interpreter.current_executable().get_identifier(m_identifier);
  334. if (m_cached_environment_coordinate.has_value()) {
  335. Environment* environment = nullptr;
  336. bool coordinate_screwed_by_delete_in_global_environment = false;
  337. if (m_cached_environment_coordinate->index == EnvironmentCoordinate::global_marker) {
  338. environment = &interpreter.vm().current_realm()->global_environment();
  339. coordinate_screwed_by_delete_in_global_environment = !TRY(environment->has_binding(string));
  340. } else {
  341. environment = vm.running_execution_context().lexical_environment;
  342. for (size_t i = 0; i < m_cached_environment_coordinate->hops; ++i)
  343. environment = environment->outer_environment();
  344. VERIFY(environment);
  345. VERIFY(environment->is_declarative_environment());
  346. }
  347. if (!coordinate_screwed_by_delete_in_global_environment && !environment->is_permanently_screwed_by_eval()) {
  348. return Reference { *environment, string, vm.in_strict_mode(), m_cached_environment_coordinate };
  349. }
  350. m_cached_environment_coordinate = {};
  351. }
  352. auto reference = TRY(vm.resolve_binding(string));
  353. if (reference.environment_coordinate().has_value())
  354. m_cached_environment_coordinate = reference.environment_coordinate();
  355. return reference;
  356. };
  357. auto reference = TRY(get_reference());
  358. interpreter.accumulator() = TRY(reference.get_value(vm));
  359. return {};
  360. }
  361. ThrowCompletionOr<void> DeleteVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  362. {
  363. auto& vm = interpreter.vm();
  364. auto const& string = interpreter.current_executable().get_identifier(m_identifier);
  365. auto reference = TRY(vm.resolve_binding(string));
  366. interpreter.accumulator() = Value(TRY(reference.delete_(vm)));
  367. return {};
  368. }
  369. ThrowCompletionOr<void> CreateLexicalEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  370. {
  371. auto make_and_swap_envs = [&](auto& old_environment) {
  372. GCPtr<Environment> environment = new_declarative_environment(*old_environment).ptr();
  373. swap(old_environment, environment);
  374. return environment;
  375. };
  376. interpreter.saved_lexical_environment_stack().append(make_and_swap_envs(interpreter.vm().running_execution_context().lexical_environment));
  377. return {};
  378. }
  379. ThrowCompletionOr<void> EnterObjectEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  380. {
  381. auto& vm = interpreter.vm();
  382. auto& old_environment = vm.running_execution_context().lexical_environment;
  383. interpreter.saved_lexical_environment_stack().append(old_environment);
  384. auto object = TRY(interpreter.accumulator().to_object(vm));
  385. vm.running_execution_context().lexical_environment = new_object_environment(object, true, old_environment);
  386. return {};
  387. }
  388. ThrowCompletionOr<void> CreateVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  389. {
  390. auto& vm = interpreter.vm();
  391. auto const& name = interpreter.current_executable().get_identifier(m_identifier);
  392. if (m_mode == EnvironmentMode::Lexical) {
  393. VERIFY(!m_is_global);
  394. // Note: This is papering over an issue where "FunctionDeclarationInstantiation" creates these bindings for us.
  395. // Instead of crashing in there, we'll just raise an exception here.
  396. if (TRY(vm.lexical_environment()->has_binding(name)))
  397. return vm.throw_completion<InternalError>(TRY_OR_THROW_OOM(vm, String::formatted("Lexical environment already has binding '{}'", name)));
  398. if (m_is_immutable)
  399. return vm.lexical_environment()->create_immutable_binding(vm, name, vm.in_strict_mode());
  400. else
  401. return vm.lexical_environment()->create_mutable_binding(vm, name, vm.in_strict_mode());
  402. } else {
  403. if (!m_is_global) {
  404. if (m_is_immutable)
  405. return vm.variable_environment()->create_immutable_binding(vm, name, vm.in_strict_mode());
  406. else
  407. return vm.variable_environment()->create_mutable_binding(vm, name, vm.in_strict_mode());
  408. } else {
  409. // NOTE: CreateVariable with m_is_global set to true is expected to only be used in GlobalDeclarationInstantiation currently, which only uses "false" for "can_be_deleted".
  410. // The only area that sets "can_be_deleted" to true is EvalDeclarationInstantiation, which is currently fully implemented in C++ and not in Bytecode.
  411. return verify_cast<GlobalEnvironment>(vm.variable_environment())->create_global_var_binding(name, false);
  412. }
  413. }
  414. return {};
  415. }
  416. ThrowCompletionOr<void> SetVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  417. {
  418. auto& vm = interpreter.vm();
  419. auto const& name = interpreter.current_executable().get_identifier(m_identifier);
  420. auto environment = m_mode == EnvironmentMode::Lexical ? vm.running_execution_context().lexical_environment : vm.running_execution_context().variable_environment;
  421. auto reference = TRY(vm.resolve_binding(name, environment));
  422. switch (m_initialization_mode) {
  423. case InitializationMode::Initialize:
  424. TRY(reference.initialize_referenced_binding(vm, interpreter.accumulator()));
  425. break;
  426. case InitializationMode::Set:
  427. TRY(reference.put_value(vm, interpreter.accumulator()));
  428. break;
  429. case InitializationMode::InitializeOrSet:
  430. VERIFY(reference.is_environment_reference());
  431. VERIFY(reference.base_environment().is_declarative_environment());
  432. TRY(static_cast<DeclarativeEnvironment&>(reference.base_environment()).initialize_or_set_mutable_binding(vm, name, interpreter.accumulator()));
  433. break;
  434. }
  435. return {};
  436. }
  437. ThrowCompletionOr<void> GetById::execute_impl(Bytecode::Interpreter& interpreter) const
  438. {
  439. auto& vm = interpreter.vm();
  440. auto const& name = interpreter.current_executable().get_identifier(m_property);
  441. auto base_value = interpreter.accumulator();
  442. // OPTIMIZATION: For various primitives we can avoid actually creating a new object for them.
  443. GCPtr<Object> base_obj;
  444. if (base_value.is_string()) {
  445. auto string_value = TRY(base_value.as_string().get(vm, name));
  446. if (string_value.has_value()) {
  447. interpreter.accumulator() = *string_value;
  448. return {};
  449. }
  450. base_obj = vm.current_realm()->intrinsics().string_prototype();
  451. } else if (base_value.is_number()) {
  452. base_obj = vm.current_realm()->intrinsics().number_prototype();
  453. } else if (base_value.is_boolean()) {
  454. base_obj = vm.current_realm()->intrinsics().boolean_prototype();
  455. } else {
  456. base_obj = TRY(base_value.to_object(vm));
  457. }
  458. interpreter.accumulator() = TRY(base_obj->internal_get(name, base_value));
  459. return {};
  460. }
  461. ThrowCompletionOr<void> GetPrivateById::execute_impl(Bytecode::Interpreter& interpreter) const
  462. {
  463. auto& vm = interpreter.vm();
  464. auto const& name = interpreter.current_executable().get_identifier(m_property);
  465. auto base_value = interpreter.accumulator();
  466. auto private_reference = make_private_reference(vm, base_value, name);
  467. interpreter.accumulator() = TRY(private_reference.get_value(vm));
  468. return {};
  469. }
  470. ThrowCompletionOr<void> PutById::execute_impl(Bytecode::Interpreter& interpreter) const
  471. {
  472. auto& vm = interpreter.vm();
  473. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  474. auto value = interpreter.accumulator();
  475. auto object = TRY(interpreter.reg(m_base).to_object(vm));
  476. PropertyKey name = interpreter.current_executable().get_identifier(m_property);
  477. return put_by_property_key(vm, object, value, name, m_kind);
  478. }
  479. ThrowCompletionOr<void> PutPrivateById::execute_impl(Bytecode::Interpreter& interpreter) const
  480. {
  481. auto& vm = interpreter.vm();
  482. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  483. auto value = interpreter.accumulator();
  484. auto object = TRY(interpreter.reg(m_base).to_object(vm));
  485. auto name = interpreter.current_executable().get_identifier(m_property);
  486. auto private_reference = make_private_reference(vm, object, name);
  487. return private_reference.put_value(vm, value);
  488. }
  489. ThrowCompletionOr<void> DeleteById::execute_impl(Bytecode::Interpreter& interpreter) const
  490. {
  491. auto& vm = interpreter.vm();
  492. auto object = TRY(interpreter.accumulator().to_object(vm));
  493. auto const& identifier = interpreter.current_executable().get_identifier(m_property);
  494. bool strict = vm.in_strict_mode();
  495. auto reference = Reference { object, identifier, {}, strict };
  496. interpreter.accumulator() = Value(TRY(reference.delete_(vm)));
  497. return {};
  498. };
  499. ThrowCompletionOr<void> Jump::execute_impl(Bytecode::Interpreter& interpreter) const
  500. {
  501. interpreter.jump(*m_true_target);
  502. return {};
  503. }
  504. ThrowCompletionOr<void> ResolveThisBinding::execute_impl(Bytecode::Interpreter& interpreter) const
  505. {
  506. auto& vm = interpreter.vm();
  507. interpreter.accumulator() = TRY(vm.resolve_this_binding());
  508. return {};
  509. }
  510. // https://tc39.es/ecma262/#sec-makesuperpropertyreference
  511. ThrowCompletionOr<void> ResolveSuperBase::execute_impl(Bytecode::Interpreter& interpreter) const
  512. {
  513. auto& vm = interpreter.vm();
  514. // 1. Let env be GetThisEnvironment().
  515. auto& env = verify_cast<FunctionEnvironment>(*get_this_environment(vm));
  516. // 2. Assert: env.HasSuperBinding() is true.
  517. VERIFY(env.has_super_binding());
  518. // 3. Let baseValue be ? env.GetSuperBase().
  519. auto base_value = TRY(env.get_super_base());
  520. // 4. Let bv be ? RequireObjectCoercible(baseValue).
  521. interpreter.accumulator() = TRY(require_object_coercible(vm, base_value));
  522. return {};
  523. }
  524. ThrowCompletionOr<void> GetNewTarget::execute_impl(Bytecode::Interpreter& interpreter) const
  525. {
  526. interpreter.accumulator() = interpreter.vm().get_new_target();
  527. return {};
  528. }
  529. void Jump::replace_references_impl(BasicBlock const& from, BasicBlock const& to)
  530. {
  531. if (m_true_target.has_value() && &m_true_target->block() == &from)
  532. m_true_target = Label { to };
  533. if (m_false_target.has_value() && &m_false_target->block() == &from)
  534. m_false_target = Label { to };
  535. }
  536. ThrowCompletionOr<void> JumpConditional::execute_impl(Bytecode::Interpreter& interpreter) const
  537. {
  538. VERIFY(m_true_target.has_value());
  539. VERIFY(m_false_target.has_value());
  540. auto result = interpreter.accumulator();
  541. if (result.to_boolean())
  542. interpreter.jump(m_true_target.value());
  543. else
  544. interpreter.jump(m_false_target.value());
  545. return {};
  546. }
  547. ThrowCompletionOr<void> JumpNullish::execute_impl(Bytecode::Interpreter& interpreter) const
  548. {
  549. VERIFY(m_true_target.has_value());
  550. VERIFY(m_false_target.has_value());
  551. auto result = interpreter.accumulator();
  552. if (result.is_nullish())
  553. interpreter.jump(m_true_target.value());
  554. else
  555. interpreter.jump(m_false_target.value());
  556. return {};
  557. }
  558. ThrowCompletionOr<void> JumpUndefined::execute_impl(Bytecode::Interpreter& interpreter) const
  559. {
  560. VERIFY(m_true_target.has_value());
  561. VERIFY(m_false_target.has_value());
  562. auto result = interpreter.accumulator();
  563. if (result.is_undefined())
  564. interpreter.jump(m_true_target.value());
  565. else
  566. interpreter.jump(m_false_target.value());
  567. return {};
  568. }
  569. // 13.3.8.1 https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
  570. static MarkedVector<Value> argument_list_evaluation(Bytecode::Interpreter& interpreter)
  571. {
  572. // Note: Any spreading and actual evaluation is handled in preceding opcodes
  573. // Note: The spec uses the concept of a list, while we create a temporary array
  574. // in the preceding opcodes, so we have to convert in a manner that is not
  575. // visible to the user
  576. auto& vm = interpreter.vm();
  577. MarkedVector<Value> argument_values { vm.heap() };
  578. auto arguments = interpreter.accumulator();
  579. if (!(arguments.is_object() && is<Array>(arguments.as_object()))) {
  580. dbgln("[{}] Call arguments are not an array, but: {}", interpreter.debug_position(), MUST(arguments.to_string_without_side_effects()));
  581. interpreter.current_executable().dump();
  582. VERIFY_NOT_REACHED();
  583. }
  584. auto& argument_array = arguments.as_array();
  585. auto array_length = argument_array.indexed_properties().array_like_size();
  586. argument_values.ensure_capacity(array_length);
  587. for (size_t i = 0; i < array_length; ++i) {
  588. if (auto maybe_value = argument_array.indexed_properties().get(i); maybe_value.has_value())
  589. argument_values.append(maybe_value.release_value().value);
  590. else
  591. argument_values.append(js_undefined());
  592. }
  593. return argument_values;
  594. }
  595. Completion Call::throw_type_error_for_callee(Bytecode::Interpreter& interpreter, StringView callee_type) const
  596. {
  597. auto& vm = interpreter.vm();
  598. auto callee = interpreter.reg(m_callee);
  599. if (m_expression_string.has_value())
  600. return vm.throw_completion<TypeError>(ErrorType::IsNotAEvaluatedFrom, TRY_OR_THROW_OOM(vm, callee.to_string_without_side_effects()), callee_type, interpreter.current_executable().get_string(m_expression_string->value()));
  601. return vm.throw_completion<TypeError>(ErrorType::IsNotA, TRY_OR_THROW_OOM(vm, callee.to_string_without_side_effects()), callee_type);
  602. }
  603. ThrowCompletionOr<void> Call::execute_impl(Bytecode::Interpreter& interpreter) const
  604. {
  605. auto& vm = interpreter.vm();
  606. auto callee = interpreter.reg(m_callee);
  607. if (m_type == CallType::Call && !callee.is_function())
  608. return throw_type_error_for_callee(interpreter, "function"sv);
  609. if (m_type == CallType::Construct && !callee.is_constructor())
  610. return throw_type_error_for_callee(interpreter, "constructor"sv);
  611. auto& function = callee.as_function();
  612. auto this_value = interpreter.reg(m_this_value);
  613. auto argument_values = argument_list_evaluation(interpreter);
  614. Value return_value;
  615. if (m_type == CallType::DirectEval) {
  616. if (callee == interpreter.realm().intrinsics().eval_function())
  617. return_value = TRY(perform_eval(vm, argument_values[0].value_or(JS::js_undefined()), vm.in_strict_mode() ? CallerMode::Strict : CallerMode::NonStrict, EvalMode::Direct));
  618. else
  619. return_value = TRY(call(vm, function, this_value, move(argument_values)));
  620. } else if (m_type == CallType::Call)
  621. return_value = TRY(call(vm, function, this_value, move(argument_values)));
  622. else
  623. return_value = TRY(construct(vm, function, move(argument_values)));
  624. interpreter.accumulator() = return_value;
  625. return {};
  626. }
  627. // 13.3.7.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
  628. ThrowCompletionOr<void> SuperCall::execute_impl(Bytecode::Interpreter& interpreter) const
  629. {
  630. auto& vm = interpreter.vm();
  631. // 1. Let newTarget be GetNewTarget().
  632. auto new_target = vm.get_new_target();
  633. // 2. Assert: Type(newTarget) is Object.
  634. VERIFY(new_target.is_object());
  635. // 3. Let func be GetSuperConstructor().
  636. auto* func = get_super_constructor(vm);
  637. // 4. Let argList be ? ArgumentListEvaluation of Arguments.
  638. MarkedVector<Value> arg_list { vm.heap() };
  639. if (m_is_synthetic) {
  640. auto const& value = interpreter.accumulator();
  641. VERIFY(value.is_object() && is<Array>(value.as_object()));
  642. auto const& array_value = static_cast<Array const&>(value.as_object());
  643. auto length = MUST(length_of_array_like(vm, array_value));
  644. for (size_t i = 0; i < length; ++i)
  645. arg_list.append(array_value.get_without_side_effects(PropertyKey { i }));
  646. } else {
  647. arg_list = argument_list_evaluation(interpreter);
  648. }
  649. // 5. If IsConstructor(func) is false, throw a TypeError exception.
  650. if (!Value(func).is_constructor())
  651. return vm.throw_completion<TypeError>(ErrorType::NotAConstructor, "Super constructor");
  652. // 6. Let result be ? Construct(func, argList, newTarget).
  653. auto result = TRY(construct(vm, static_cast<FunctionObject&>(*func), move(arg_list), &new_target.as_function()));
  654. // 7. Let thisER be GetThisEnvironment().
  655. auto& this_environment = verify_cast<FunctionEnvironment>(*get_this_environment(vm));
  656. // 8. Perform ? thisER.BindThisValue(result).
  657. TRY(this_environment.bind_this_value(vm, result));
  658. // 9. Let F be thisER.[[FunctionObject]].
  659. auto& f = this_environment.function_object();
  660. // 10. Assert: F is an ECMAScript function object.
  661. // NOTE: This is implied by the strong C++ type.
  662. // 11. Perform ? InitializeInstanceElements(result, F).
  663. TRY(result->initialize_instance_elements(f));
  664. // 12. Return result.
  665. interpreter.accumulator() = result;
  666. return {};
  667. }
  668. ThrowCompletionOr<void> NewFunction::execute_impl(Bytecode::Interpreter& interpreter) const
  669. {
  670. auto& vm = interpreter.vm();
  671. if (!m_function_node.has_name()) {
  672. interpreter.accumulator() = m_function_node.instantiate_ordinary_function_expression(vm, m_lhs_name.value_or({}));
  673. } else {
  674. interpreter.accumulator() = ECMAScriptFunctionObject::create(interpreter.realm(), m_function_node.name(), m_function_node.source_text(), m_function_node.body(), m_function_node.parameters(), m_function_node.function_length(), vm.lexical_environment(), vm.running_execution_context().private_environment, m_function_node.kind(), m_function_node.is_strict_mode(), m_function_node.might_need_arguments_object(), m_function_node.contains_direct_call_to_eval(), m_function_node.is_arrow_function());
  675. }
  676. if (m_home_object.has_value()) {
  677. auto home_object_value = interpreter.reg(m_home_object.value());
  678. static_cast<ECMAScriptFunctionObject&>(interpreter.accumulator().as_function()).set_home_object(&home_object_value.as_object());
  679. }
  680. return {};
  681. }
  682. ThrowCompletionOr<void> Return::execute_impl(Bytecode::Interpreter& interpreter) const
  683. {
  684. interpreter.do_return(interpreter.accumulator().value_or(js_undefined()));
  685. return {};
  686. }
  687. ThrowCompletionOr<void> Increment::execute_impl(Bytecode::Interpreter& interpreter) const
  688. {
  689. auto& vm = interpreter.vm();
  690. auto old_value = TRY(interpreter.accumulator().to_numeric(vm));
  691. if (old_value.is_number())
  692. interpreter.accumulator() = Value(old_value.as_double() + 1);
  693. else
  694. interpreter.accumulator() = BigInt::create(vm, old_value.as_bigint().big_integer().plus(Crypto::SignedBigInteger { 1 }));
  695. return {};
  696. }
  697. ThrowCompletionOr<void> Decrement::execute_impl(Bytecode::Interpreter& interpreter) const
  698. {
  699. auto& vm = interpreter.vm();
  700. auto old_value = TRY(interpreter.accumulator().to_numeric(vm));
  701. if (old_value.is_number())
  702. interpreter.accumulator() = Value(old_value.as_double() - 1);
  703. else
  704. interpreter.accumulator() = BigInt::create(vm, old_value.as_bigint().big_integer().minus(Crypto::SignedBigInteger { 1 }));
  705. return {};
  706. }
  707. ThrowCompletionOr<void> Throw::execute_impl(Bytecode::Interpreter& interpreter) const
  708. {
  709. return throw_completion(interpreter.accumulator());
  710. }
  711. ThrowCompletionOr<void> ThrowIfNotObject::execute_impl(Bytecode::Interpreter& interpreter) const
  712. {
  713. auto& vm = interpreter.vm();
  714. if (!interpreter.accumulator().is_object())
  715. return vm.throw_completion<TypeError>(ErrorType::NotAnObject, TRY_OR_THROW_OOM(vm, interpreter.accumulator().to_string_without_side_effects()));
  716. return {};
  717. }
  718. ThrowCompletionOr<void> EnterUnwindContext::execute_impl(Bytecode::Interpreter& interpreter) const
  719. {
  720. interpreter.enter_unwind_context(m_handler_target, m_finalizer_target);
  721. interpreter.jump(m_entry_point);
  722. return {};
  723. }
  724. void NewFunction::replace_references_impl(Register from, Register to)
  725. {
  726. if (m_home_object == from)
  727. m_home_object = to;
  728. }
  729. void EnterUnwindContext::replace_references_impl(BasicBlock const& from, BasicBlock const& to)
  730. {
  731. if (&m_entry_point.block() == &from)
  732. m_entry_point = Label { to };
  733. if (m_handler_target.has_value() && &m_handler_target->block() == &from)
  734. m_handler_target = Label { to };
  735. if (m_finalizer_target.has_value() && &m_finalizer_target->block() == &from)
  736. m_finalizer_target = Label { to };
  737. }
  738. void CopyObjectExcludingProperties::replace_references_impl(Register from, Register to)
  739. {
  740. if (m_from_object == from)
  741. m_from_object = to;
  742. for (size_t i = 0; i < m_excluded_names_count; ++i) {
  743. if (m_excluded_names[i] == from)
  744. m_excluded_names[i] = to;
  745. }
  746. }
  747. void Call::replace_references_impl(Register from, Register to)
  748. {
  749. if (m_callee == from)
  750. m_callee = to;
  751. if (m_this_value == from)
  752. m_this_value = to;
  753. }
  754. ThrowCompletionOr<void> ScheduleJump::execute_impl(Bytecode::Interpreter& interpreter) const
  755. {
  756. interpreter.schedule_jump(m_target);
  757. return {};
  758. }
  759. ThrowCompletionOr<void> LeaveLexicalEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  760. {
  761. interpreter.vm().running_execution_context().lexical_environment = interpreter.saved_lexical_environment_stack().take_last();
  762. return {};
  763. }
  764. ThrowCompletionOr<void> LeaveUnwindContext::execute_impl(Bytecode::Interpreter& interpreter) const
  765. {
  766. interpreter.leave_unwind_context();
  767. return {};
  768. }
  769. ThrowCompletionOr<void> ContinuePendingUnwind::execute_impl(Bytecode::Interpreter& interpreter) const
  770. {
  771. return interpreter.continue_pending_unwind(m_resume_target);
  772. }
  773. void ContinuePendingUnwind::replace_references_impl(BasicBlock const& from, BasicBlock const& to)
  774. {
  775. if (&m_resume_target.block() == &from)
  776. m_resume_target = Label { to };
  777. }
  778. ThrowCompletionOr<void> PushDeclarativeEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  779. {
  780. auto environment = interpreter.vm().heap().allocate_without_realm<DeclarativeEnvironment>(interpreter.vm().lexical_environment());
  781. interpreter.vm().running_execution_context().lexical_environment = environment;
  782. interpreter.vm().running_execution_context().variable_environment = environment;
  783. return {};
  784. }
  785. ThrowCompletionOr<void> Yield::execute_impl(Bytecode::Interpreter& interpreter) const
  786. {
  787. auto yielded_value = interpreter.accumulator().value_or(js_undefined());
  788. auto object = Object::create(interpreter.realm(), nullptr);
  789. object->define_direct_property("result", yielded_value, JS::default_attributes);
  790. if (m_continuation_label.has_value())
  791. // FIXME: If we get a pointer, which is not accurately representable as a double
  792. // will cause this to explode
  793. object->define_direct_property("continuation", Value(static_cast<double>(reinterpret_cast<u64>(&m_continuation_label->block()))), JS::default_attributes);
  794. else
  795. object->define_direct_property("continuation", Value(0), JS::default_attributes);
  796. interpreter.do_return(object);
  797. return {};
  798. }
  799. void Yield::replace_references_impl(BasicBlock const& from, BasicBlock const& to)
  800. {
  801. if (m_continuation_label.has_value() && &m_continuation_label->block() == &from)
  802. m_continuation_label = Label { to };
  803. }
  804. ThrowCompletionOr<void> GetByValue::execute_impl(Bytecode::Interpreter& interpreter) const
  805. {
  806. auto& vm = interpreter.vm();
  807. // NOTE: Get the property key from the accumulator before side effects have a chance to overwrite it.
  808. auto property_key_value = interpreter.accumulator();
  809. auto object = TRY(interpreter.reg(m_base).to_object(vm));
  810. auto property_key = TRY(property_key_value.to_property_key(vm));
  811. interpreter.accumulator() = TRY(object->get(property_key));
  812. return {};
  813. }
  814. ThrowCompletionOr<void> PutByValue::execute_impl(Bytecode::Interpreter& interpreter) const
  815. {
  816. auto& vm = interpreter.vm();
  817. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  818. auto value = interpreter.accumulator();
  819. auto object = TRY(interpreter.reg(m_base).to_object(vm));
  820. auto property_key = TRY(interpreter.reg(m_property).to_property_key(vm));
  821. return put_by_property_key(vm, object, value, property_key, m_kind);
  822. }
  823. ThrowCompletionOr<void> DeleteByValue::execute_impl(Bytecode::Interpreter& interpreter) const
  824. {
  825. auto& vm = interpreter.vm();
  826. // NOTE: Get the property key from the accumulator before side effects have a chance to overwrite it.
  827. auto property_key_value = interpreter.accumulator();
  828. auto object = TRY(interpreter.reg(m_base).to_object(vm));
  829. auto property_key = TRY(property_key_value.to_property_key(vm));
  830. bool strict = vm.in_strict_mode();
  831. auto reference = Reference { object, property_key, {}, strict };
  832. interpreter.accumulator() = Value(TRY(reference.delete_(vm)));
  833. return {};
  834. }
  835. ThrowCompletionOr<void> GetIterator::execute_impl(Bytecode::Interpreter& interpreter) const
  836. {
  837. auto& vm = interpreter.vm();
  838. auto iterator = TRY(get_iterator(vm, interpreter.accumulator()));
  839. interpreter.accumulator() = iterator_to_object(vm, iterator);
  840. return {};
  841. }
  842. ThrowCompletionOr<void> GetMethod::execute_impl(Bytecode::Interpreter& interpreter) const
  843. {
  844. auto& vm = interpreter.vm();
  845. auto identifier = interpreter.current_executable().get_identifier(m_property);
  846. auto method = TRY(interpreter.accumulator().get_method(vm, identifier));
  847. interpreter.accumulator() = method ?: js_undefined();
  848. return {};
  849. }
  850. // 14.7.5.9 EnumerateObjectProperties ( O ), https://tc39.es/ecma262/#sec-enumerate-object-properties
  851. ThrowCompletionOr<void> GetObjectPropertyIterator::execute_impl(Bytecode::Interpreter& interpreter) const
  852. {
  853. // While the spec does provide an algorithm, it allows us to implement it ourselves so long as we meet the following invariants:
  854. // 1- Returned property keys do not include keys that are Symbols
  855. // 2- Properties of the target object may be deleted during enumeration. A property that is deleted before it is processed by the iterator's next method is ignored
  856. // 3- If new properties are added to the target object during enumeration, the newly added properties are not guaranteed to be processed in the active enumeration
  857. // 4- A property name will be returned by the iterator's next method at most once in any enumeration.
  858. // 5- Enumerating the properties of the target object includes enumerating properties of its prototype, and the prototype of the prototype, and so on, recursively;
  859. // but a property of a prototype is not processed if it has the same name as a property that has already been processed by the iterator's next method.
  860. // 6- The values of [[Enumerable]] attributes are not considered when determining if a property of a prototype object has already been processed.
  861. // 7- The enumerable property names of prototype objects must be obtained by invoking EnumerateObjectProperties passing the prototype object as the argument.
  862. // 8- EnumerateObjectProperties must obtain the own property keys of the target object by calling its [[OwnPropertyKeys]] internal method.
  863. // 9- Property attributes of the target object must be obtained by calling its [[GetOwnProperty]] internal method
  864. // Invariant 3 effectively allows the implementation to ignore newly added keys, and we do so (similar to other implementations).
  865. // Invariants 1 and 6 through 9 are implemented in `enumerable_own_property_names`, which implements the EnumerableOwnPropertyNames AO.
  866. auto& vm = interpreter.vm();
  867. auto object = TRY(interpreter.accumulator().to_object(vm));
  868. // Note: While the spec doesn't explicitly require these to be ordered, it says that the values should be retrieved via OwnPropertyKeys,
  869. // so we just keep the order consistent anyway.
  870. OrderedHashTable<PropertyKey> properties;
  871. HashTable<NonnullGCPtr<Object>> seen_objects;
  872. // Collect all keys immediately (invariant no. 5)
  873. for (auto object_to_check = GCPtr { object.ptr() }; object_to_check && !seen_objects.contains(*object_to_check); object_to_check = TRY(object_to_check->internal_get_prototype_of())) {
  874. seen_objects.set(*object_to_check);
  875. for (auto& key : TRY(object_to_check->enumerable_own_property_names(Object::PropertyKind::Key))) {
  876. properties.set(TRY(PropertyKey::from_value(vm, key)));
  877. }
  878. }
  879. Iterator iterator {
  880. .iterator = object,
  881. .next_method = NativeFunction::create(
  882. interpreter.realm(),
  883. [seen_items = HashTable<PropertyKey>(), items = move(properties)](VM& vm) mutable -> ThrowCompletionOr<Value> {
  884. auto& realm = *vm.current_realm();
  885. auto iterated_object_value = vm.this_value();
  886. if (!iterated_object_value.is_object())
  887. return vm.throw_completion<InternalError>("Invalid state for GetObjectPropertyIterator.next"sv);
  888. auto& iterated_object = iterated_object_value.as_object();
  889. auto result_object = Object::create(realm, nullptr);
  890. while (true) {
  891. if (items.is_empty()) {
  892. result_object->define_direct_property(vm.names.done, JS::Value(true), default_attributes);
  893. return result_object;
  894. }
  895. auto key = items.take_first();
  896. // If the key was already seen, skip over it (invariant no. 4)
  897. auto result = seen_items.set(key);
  898. if (result != AK::HashSetResult::InsertedNewEntry)
  899. continue;
  900. // If the property is deleted, don't include it (invariant no. 2)
  901. if (!TRY(iterated_object.has_property(key)))
  902. continue;
  903. result_object->define_direct_property(vm.names.done, JS::Value(false), default_attributes);
  904. if (key.is_number())
  905. result_object->define_direct_property(vm.names.value, PrimitiveString::create(vm, TRY_OR_THROW_OOM(vm, String::number(key.as_number()))), default_attributes);
  906. else if (key.is_string())
  907. result_object->define_direct_property(vm.names.value, PrimitiveString::create(vm, key.as_string()), default_attributes);
  908. else
  909. VERIFY_NOT_REACHED(); // We should not have non-string/number keys.
  910. return result_object;
  911. }
  912. },
  913. 1,
  914. vm.names.next),
  915. .done = false,
  916. };
  917. interpreter.accumulator() = iterator_to_object(vm, move(iterator));
  918. return {};
  919. }
  920. ThrowCompletionOr<void> IteratorClose::execute_impl(Bytecode::Interpreter& interpreter) const
  921. {
  922. auto& vm = interpreter.vm();
  923. auto iterator_object = TRY(interpreter.accumulator().to_object(vm));
  924. auto iterator = object_to_iterator(vm, iterator_object);
  925. // FIXME: Return the value of the resulting completion. (Note that m_completion_value can be empty!)
  926. TRY(iterator_close(vm, iterator, Completion { m_completion_type, m_completion_value, {} }));
  927. return {};
  928. }
  929. ThrowCompletionOr<void> IteratorNext::execute_impl(Bytecode::Interpreter& interpreter) const
  930. {
  931. auto& vm = interpreter.vm();
  932. auto iterator_object = TRY(interpreter.accumulator().to_object(vm));
  933. auto iterator = object_to_iterator(vm, iterator_object);
  934. interpreter.accumulator() = TRY(iterator_next(vm, iterator));
  935. return {};
  936. }
  937. ThrowCompletionOr<void> IteratorResultDone::execute_impl(Bytecode::Interpreter& interpreter) const
  938. {
  939. auto& vm = interpreter.vm();
  940. auto iterator_result = TRY(interpreter.accumulator().to_object(vm));
  941. auto complete = TRY(iterator_complete(vm, iterator_result));
  942. interpreter.accumulator() = Value(complete);
  943. return {};
  944. }
  945. ThrowCompletionOr<void> IteratorResultValue::execute_impl(Bytecode::Interpreter& interpreter) const
  946. {
  947. auto& vm = interpreter.vm();
  948. auto iterator_result = TRY(interpreter.accumulator().to_object(vm));
  949. interpreter.accumulator() = TRY(iterator_value(vm, iterator_result));
  950. return {};
  951. }
  952. ThrowCompletionOr<void> NewClass::execute_impl(Bytecode::Interpreter& interpreter) const
  953. {
  954. auto name = m_class_expression.name();
  955. auto scope = interpreter.ast_interpreter_scope(interpreter.realm());
  956. auto& ast_interpreter = scope.interpreter();
  957. ECMAScriptFunctionObject* class_object = nullptr;
  958. if (!m_class_expression.has_name() && m_lhs_name.has_value())
  959. class_object = TRY(m_class_expression.class_definition_evaluation(ast_interpreter, {}, m_lhs_name.value()));
  960. else
  961. class_object = TRY(m_class_expression.class_definition_evaluation(ast_interpreter, name, name.is_null() ? ""sv : name));
  962. class_object->set_source_text(m_class_expression.source_text());
  963. interpreter.accumulator() = class_object;
  964. return {};
  965. }
  966. // 13.5.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-typeof-operator-runtime-semantics-evaluation
  967. ThrowCompletionOr<void> TypeofVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  968. {
  969. auto& vm = interpreter.vm();
  970. // 1. Let val be the result of evaluating UnaryExpression.
  971. auto const& string = interpreter.current_executable().get_identifier(m_identifier);
  972. auto reference = TRY(vm.resolve_binding(string));
  973. // 2. If val is a Reference Record, then
  974. // a. If IsUnresolvableReference(val) is true, return "undefined".
  975. if (reference.is_unresolvable()) {
  976. interpreter.accumulator() = MUST_OR_THROW_OOM(PrimitiveString::create(vm, "undefined"sv));
  977. return {};
  978. }
  979. // 3. Set val to ? GetValue(val).
  980. auto value = TRY(reference.get_value(vm));
  981. // 4. NOTE: This step is replaced in section B.3.6.3.
  982. // 5. Return a String according to Table 41.
  983. interpreter.accumulator() = MUST_OR_THROW_OOM(PrimitiveString::create(vm, value.typeof()));
  984. return {};
  985. }
  986. ThrowCompletionOr<void> ToNumeric::execute_impl(Bytecode::Interpreter& interpreter) const
  987. {
  988. interpreter.accumulator() = TRY(interpreter.accumulator().to_numeric(interpreter.vm()));
  989. return {};
  990. }
  991. ThrowCompletionOr<void> BlockDeclarationInstantiation::execute_impl(Bytecode::Interpreter& interpreter) const
  992. {
  993. auto& vm = interpreter.vm();
  994. auto old_environment = vm.running_execution_context().lexical_environment;
  995. interpreter.saved_lexical_environment_stack().append(old_environment);
  996. vm.running_execution_context().lexical_environment = new_declarative_environment(*old_environment);
  997. m_scope_node.block_declaration_instantiation(vm, vm.running_execution_context().lexical_environment);
  998. return {};
  999. }
  1000. DeprecatedString Load::to_deprecated_string_impl(Bytecode::Executable const&) const
  1001. {
  1002. return DeprecatedString::formatted("Load {}", m_src);
  1003. }
  1004. DeprecatedString LoadImmediate::to_deprecated_string_impl(Bytecode::Executable const&) const
  1005. {
  1006. return DeprecatedString::formatted("LoadImmediate {}", m_value);
  1007. }
  1008. DeprecatedString Store::to_deprecated_string_impl(Bytecode::Executable const&) const
  1009. {
  1010. return DeprecatedString::formatted("Store {}", m_dst);
  1011. }
  1012. DeprecatedString NewBigInt::to_deprecated_string_impl(Bytecode::Executable const&) const
  1013. {
  1014. return DeprecatedString::formatted("NewBigInt \"{}\"", m_bigint.to_base_deprecated(10));
  1015. }
  1016. DeprecatedString NewArray::to_deprecated_string_impl(Bytecode::Executable const&) const
  1017. {
  1018. StringBuilder builder;
  1019. builder.append("NewArray"sv);
  1020. if (m_element_count != 0) {
  1021. builder.appendff(" [{}-{}]", m_elements[0], m_elements[1]);
  1022. }
  1023. return builder.to_deprecated_string();
  1024. }
  1025. DeprecatedString Append::to_deprecated_string_impl(Bytecode::Executable const&) const
  1026. {
  1027. if (m_is_spread)
  1028. return DeprecatedString::formatted("Append lhs: **{}", m_lhs);
  1029. return DeprecatedString::formatted("Append lhs: {}", m_lhs);
  1030. }
  1031. DeprecatedString IteratorToArray::to_deprecated_string_impl(Bytecode::Executable const&) const
  1032. {
  1033. return "IteratorToArray";
  1034. }
  1035. DeprecatedString NewString::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1036. {
  1037. return DeprecatedString::formatted("NewString {} (\"{}\")", m_string, executable.string_table->get(m_string));
  1038. }
  1039. DeprecatedString NewObject::to_deprecated_string_impl(Bytecode::Executable const&) const
  1040. {
  1041. return "NewObject";
  1042. }
  1043. DeprecatedString NewRegExp::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1044. {
  1045. return DeprecatedString::formatted("NewRegExp source:{} (\"{}\") flags:{} (\"{}\")", m_source_index, executable.get_string(m_source_index), m_flags_index, executable.get_string(m_flags_index));
  1046. }
  1047. DeprecatedString CopyObjectExcludingProperties::to_deprecated_string_impl(Bytecode::Executable const&) const
  1048. {
  1049. StringBuilder builder;
  1050. builder.appendff("CopyObjectExcludingProperties from:{}", m_from_object);
  1051. if (m_excluded_names_count != 0) {
  1052. builder.append(" excluding:["sv);
  1053. builder.join(", "sv, ReadonlySpan<Register>(m_excluded_names, m_excluded_names_count));
  1054. builder.append(']');
  1055. }
  1056. return builder.to_deprecated_string();
  1057. }
  1058. DeprecatedString ConcatString::to_deprecated_string_impl(Bytecode::Executable const&) const
  1059. {
  1060. return DeprecatedString::formatted("ConcatString {}", m_lhs);
  1061. }
  1062. DeprecatedString GetVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1063. {
  1064. return DeprecatedString::formatted("GetVariable {} ({})", m_identifier, executable.identifier_table->get(m_identifier));
  1065. }
  1066. DeprecatedString DeleteVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1067. {
  1068. return DeprecatedString::formatted("DeleteVariable {} ({})", m_identifier, executable.identifier_table->get(m_identifier));
  1069. }
  1070. DeprecatedString CreateLexicalEnvironment::to_deprecated_string_impl(Bytecode::Executable const&) const
  1071. {
  1072. return "CreateLexicalEnvironment"sv;
  1073. }
  1074. DeprecatedString CreateVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1075. {
  1076. auto mode_string = m_mode == EnvironmentMode::Lexical ? "Lexical" : "Variable";
  1077. return DeprecatedString::formatted("CreateVariable env:{} immutable:{} global:{} {} ({})", mode_string, m_is_immutable, m_is_global, m_identifier, executable.identifier_table->get(m_identifier));
  1078. }
  1079. DeprecatedString EnterObjectEnvironment::to_deprecated_string_impl(Executable const&) const
  1080. {
  1081. return DeprecatedString::formatted("EnterObjectEnvironment");
  1082. }
  1083. DeprecatedString SetVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1084. {
  1085. auto initialization_mode_name = m_initialization_mode == InitializationMode ::Initialize ? "Initialize"
  1086. : m_initialization_mode == InitializationMode::Set ? "Set"
  1087. : "InitializeOrSet";
  1088. auto mode_string = m_mode == EnvironmentMode::Lexical ? "Lexical" : "Variable";
  1089. return DeprecatedString::formatted("SetVariable env:{} init:{} {} ({})", mode_string, initialization_mode_name, m_identifier, executable.identifier_table->get(m_identifier));
  1090. }
  1091. DeprecatedString PutById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1092. {
  1093. auto kind = m_kind == PropertyKind::Getter
  1094. ? "getter"
  1095. : m_kind == PropertyKind::Setter
  1096. ? "setter"
  1097. : "property";
  1098. return DeprecatedString::formatted("PutById kind:{} base:{}, property:{} ({})", kind, m_base, m_property, executable.identifier_table->get(m_property));
  1099. }
  1100. DeprecatedString PutPrivateById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1101. {
  1102. auto kind = m_kind == PropertyKind::Getter
  1103. ? "getter"
  1104. : m_kind == PropertyKind::Setter
  1105. ? "setter"
  1106. : "property";
  1107. return DeprecatedString::formatted("PutPrivateById kind:{} base:{}, property:{} ({})", kind, m_base, m_property, executable.identifier_table->get(m_property));
  1108. }
  1109. DeprecatedString GetById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1110. {
  1111. return DeprecatedString::formatted("GetById {} ({})", m_property, executable.identifier_table->get(m_property));
  1112. }
  1113. DeprecatedString GetPrivateById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1114. {
  1115. return DeprecatedString::formatted("GetPrivateById {} ({})", m_property, executable.identifier_table->get(m_property));
  1116. }
  1117. DeprecatedString DeleteById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1118. {
  1119. return DeprecatedString::formatted("DeleteById {} ({})", m_property, executable.identifier_table->get(m_property));
  1120. }
  1121. DeprecatedString Jump::to_deprecated_string_impl(Bytecode::Executable const&) const
  1122. {
  1123. if (m_true_target.has_value())
  1124. return DeprecatedString::formatted("Jump {}", *m_true_target);
  1125. return DeprecatedString::formatted("Jump <empty>");
  1126. }
  1127. DeprecatedString JumpConditional::to_deprecated_string_impl(Bytecode::Executable const&) const
  1128. {
  1129. auto true_string = m_true_target.has_value() ? DeprecatedString::formatted("{}", *m_true_target) : "<empty>";
  1130. auto false_string = m_false_target.has_value() ? DeprecatedString::formatted("{}", *m_false_target) : "<empty>";
  1131. return DeprecatedString::formatted("JumpConditional true:{} false:{}", true_string, false_string);
  1132. }
  1133. DeprecatedString JumpNullish::to_deprecated_string_impl(Bytecode::Executable const&) const
  1134. {
  1135. auto true_string = m_true_target.has_value() ? DeprecatedString::formatted("{}", *m_true_target) : "<empty>";
  1136. auto false_string = m_false_target.has_value() ? DeprecatedString::formatted("{}", *m_false_target) : "<empty>";
  1137. return DeprecatedString::formatted("JumpNullish null:{} nonnull:{}", true_string, false_string);
  1138. }
  1139. DeprecatedString JumpUndefined::to_deprecated_string_impl(Bytecode::Executable const&) const
  1140. {
  1141. auto true_string = m_true_target.has_value() ? DeprecatedString::formatted("{}", *m_true_target) : "<empty>";
  1142. auto false_string = m_false_target.has_value() ? DeprecatedString::formatted("{}", *m_false_target) : "<empty>";
  1143. return DeprecatedString::formatted("JumpUndefined undefined:{} not undefined:{}", true_string, false_string);
  1144. }
  1145. DeprecatedString Call::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1146. {
  1147. StringView type;
  1148. switch (m_type) {
  1149. case Call::CallType::Call:
  1150. type = ""sv;
  1151. break;
  1152. case Call::CallType::Construct:
  1153. type = " (Construct)"sv;
  1154. break;
  1155. case Call::CallType::DirectEval:
  1156. type = " (DirectEval)"sv;
  1157. break;
  1158. }
  1159. if (m_expression_string.has_value())
  1160. return DeprecatedString::formatted("Call{} callee:{}, this:{}, arguments:[...acc] ({})", type, m_callee, m_this_value, executable.get_string(m_expression_string.value()));
  1161. return DeprecatedString::formatted("Call{} callee:{}, this:{}, arguments:[...acc]", type, m_callee, m_this_value);
  1162. }
  1163. DeprecatedString SuperCall::to_deprecated_string_impl(Bytecode::Executable const&) const
  1164. {
  1165. return "SuperCall arguments:[...acc]"sv;
  1166. }
  1167. DeprecatedString NewFunction::to_deprecated_string_impl(Bytecode::Executable const&) const
  1168. {
  1169. StringBuilder builder;
  1170. builder.append("NewFunction"sv);
  1171. if (m_function_node.has_name())
  1172. builder.appendff(" name:{}"sv, m_function_node.name());
  1173. if (m_lhs_name.has_value())
  1174. builder.appendff(" lhs_name:{}"sv, m_lhs_name.value());
  1175. if (m_home_object.has_value())
  1176. builder.appendff(" home_object:{}"sv, m_home_object.value());
  1177. return builder.to_deprecated_string();
  1178. }
  1179. DeprecatedString NewClass::to_deprecated_string_impl(Bytecode::Executable const&) const
  1180. {
  1181. StringBuilder builder;
  1182. auto name = m_class_expression.name();
  1183. builder.appendff("NewClass '{}'"sv, name.is_null() ? ""sv : name);
  1184. if (m_lhs_name.has_value())
  1185. builder.appendff(" lhs_name:{}"sv, m_lhs_name.value());
  1186. return builder.to_deprecated_string();
  1187. }
  1188. DeprecatedString Return::to_deprecated_string_impl(Bytecode::Executable const&) const
  1189. {
  1190. return "Return";
  1191. }
  1192. DeprecatedString Increment::to_deprecated_string_impl(Bytecode::Executable const&) const
  1193. {
  1194. return "Increment";
  1195. }
  1196. DeprecatedString Decrement::to_deprecated_string_impl(Bytecode::Executable const&) const
  1197. {
  1198. return "Decrement";
  1199. }
  1200. DeprecatedString Throw::to_deprecated_string_impl(Bytecode::Executable const&) const
  1201. {
  1202. return "Throw";
  1203. }
  1204. DeprecatedString ThrowIfNotObject::to_deprecated_string_impl(Bytecode::Executable const&) const
  1205. {
  1206. return "ThrowIfNotObject";
  1207. }
  1208. DeprecatedString EnterUnwindContext::to_deprecated_string_impl(Bytecode::Executable const&) const
  1209. {
  1210. auto handler_string = m_handler_target.has_value() ? DeprecatedString::formatted("{}", *m_handler_target) : "<empty>";
  1211. auto finalizer_string = m_finalizer_target.has_value() ? DeprecatedString::formatted("{}", *m_finalizer_target) : "<empty>";
  1212. return DeprecatedString::formatted("EnterUnwindContext handler:{} finalizer:{} entry:{}", handler_string, finalizer_string, m_entry_point);
  1213. }
  1214. DeprecatedString ScheduleJump::to_deprecated_string_impl(Bytecode::Executable const&) const
  1215. {
  1216. return DeprecatedString::formatted("ScheduleJump {}", m_target);
  1217. }
  1218. DeprecatedString LeaveLexicalEnvironment::to_deprecated_string_impl(Bytecode::Executable const&) const
  1219. {
  1220. return "LeaveLexicalEnvironment"sv;
  1221. }
  1222. DeprecatedString LeaveUnwindContext::to_deprecated_string_impl(Bytecode::Executable const&) const
  1223. {
  1224. return "LeaveUnwindContext";
  1225. }
  1226. DeprecatedString ContinuePendingUnwind::to_deprecated_string_impl(Bytecode::Executable const&) const
  1227. {
  1228. return DeprecatedString::formatted("ContinuePendingUnwind resume:{}", m_resume_target);
  1229. }
  1230. DeprecatedString PushDeclarativeEnvironment::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1231. {
  1232. StringBuilder builder;
  1233. builder.append("PushDeclarativeEnvironment"sv);
  1234. if (!m_variables.is_empty()) {
  1235. builder.append(" {"sv);
  1236. Vector<DeprecatedString> names;
  1237. for (auto& it : m_variables)
  1238. names.append(executable.get_string(it.key));
  1239. builder.append('}');
  1240. builder.join(", "sv, names);
  1241. }
  1242. return builder.to_deprecated_string();
  1243. }
  1244. DeprecatedString Yield::to_deprecated_string_impl(Bytecode::Executable const&) const
  1245. {
  1246. if (m_continuation_label.has_value())
  1247. return DeprecatedString::formatted("Yield continuation:@{}", m_continuation_label->block().name());
  1248. return DeprecatedString::formatted("Yield return");
  1249. }
  1250. DeprecatedString GetByValue::to_deprecated_string_impl(Bytecode::Executable const&) const
  1251. {
  1252. return DeprecatedString::formatted("GetByValue base:{}", m_base);
  1253. }
  1254. DeprecatedString PutByValue::to_deprecated_string_impl(Bytecode::Executable const&) const
  1255. {
  1256. auto kind = m_kind == PropertyKind::Getter
  1257. ? "getter"
  1258. : m_kind == PropertyKind::Setter
  1259. ? "setter"
  1260. : "property";
  1261. return DeprecatedString::formatted("PutByValue kind:{} base:{}, property:{}", kind, m_base, m_property);
  1262. }
  1263. DeprecatedString DeleteByValue::to_deprecated_string_impl(Bytecode::Executable const&) const
  1264. {
  1265. return DeprecatedString::formatted("DeleteByValue base:{}", m_base);
  1266. }
  1267. DeprecatedString GetIterator::to_deprecated_string_impl(Executable const&) const
  1268. {
  1269. return "GetIterator";
  1270. }
  1271. DeprecatedString GetMethod::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1272. {
  1273. return DeprecatedString::formatted("GetMethod {} ({})", m_property, executable.identifier_table->get(m_property));
  1274. }
  1275. DeprecatedString GetObjectPropertyIterator::to_deprecated_string_impl(Bytecode::Executable const&) const
  1276. {
  1277. return "GetObjectPropertyIterator";
  1278. }
  1279. DeprecatedString IteratorClose::to_deprecated_string_impl(Bytecode::Executable const&) const
  1280. {
  1281. if (!m_completion_value.has_value())
  1282. return DeprecatedString::formatted("IteratorClose completion_type={} completion_value=<empty>", to_underlying(m_completion_type));
  1283. auto completion_value_string = m_completion_value->to_string_without_side_effects().release_value_but_fixme_should_propagate_errors();
  1284. return DeprecatedString::formatted("IteratorClose completion_type={} completion_value={}", to_underlying(m_completion_type), completion_value_string);
  1285. }
  1286. DeprecatedString IteratorNext::to_deprecated_string_impl(Executable const&) const
  1287. {
  1288. return "IteratorNext";
  1289. }
  1290. DeprecatedString IteratorResultDone::to_deprecated_string_impl(Executable const&) const
  1291. {
  1292. return "IteratorResultDone";
  1293. }
  1294. DeprecatedString IteratorResultValue::to_deprecated_string_impl(Executable const&) const
  1295. {
  1296. return "IteratorResultValue";
  1297. }
  1298. DeprecatedString ResolveThisBinding::to_deprecated_string_impl(Bytecode::Executable const&) const
  1299. {
  1300. return "ResolveThisBinding"sv;
  1301. }
  1302. DeprecatedString ResolveSuperBase::to_deprecated_string_impl(Bytecode::Executable const&) const
  1303. {
  1304. return "ResolveSuperBase"sv;
  1305. }
  1306. DeprecatedString GetNewTarget::to_deprecated_string_impl(Bytecode::Executable const&) const
  1307. {
  1308. return "GetNewTarget"sv;
  1309. }
  1310. DeprecatedString TypeofVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1311. {
  1312. return DeprecatedString::formatted("TypeofVariable {} ({})", m_identifier, executable.identifier_table->get(m_identifier));
  1313. }
  1314. DeprecatedString ToNumeric::to_deprecated_string_impl(Bytecode::Executable const&) const
  1315. {
  1316. return "ToNumeric"sv;
  1317. }
  1318. DeprecatedString BlockDeclarationInstantiation::to_deprecated_string_impl(Bytecode::Executable const&) const
  1319. {
  1320. return "BlockDeclarationInstantiation"sv;
  1321. }
  1322. DeprecatedString ImportCall::to_deprecated_string_impl(Bytecode::Executable const&) const
  1323. {
  1324. return DeprecatedString::formatted("ImportCall specifier:{} options:{}"sv, m_specifier, m_options);
  1325. }
  1326. }