CommonImplementations.cpp 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750
  1. /*
  2. * Copyright (c) 2021-2023, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <LibJS/Bytecode/CommonImplementations.h>
  7. #include <LibJS/Bytecode/Interpreter.h>
  8. #include <LibJS/Bytecode/Op.h>
  9. #include <LibJS/Runtime/Array.h>
  10. #include <LibJS/Runtime/DeclarativeEnvironment.h>
  11. #include <LibJS/Runtime/ECMAScriptFunctionObject.h>
  12. #include <LibJS/Runtime/FunctionEnvironment.h>
  13. #include <LibJS/Runtime/GlobalEnvironment.h>
  14. #include <LibJS/Runtime/NativeFunction.h>
  15. #include <LibJS/Runtime/ObjectEnvironment.h>
  16. #include <LibJS/Runtime/RegExpObject.h>
  17. namespace JS::Bytecode {
  18. ThrowCompletionOr<NonnullGCPtr<Object>> base_object_for_get(Bytecode::Interpreter& interpreter, Value base_value)
  19. {
  20. auto& vm = interpreter.vm();
  21. if (base_value.is_object())
  22. return base_value.as_object();
  23. // OPTIMIZATION: For various primitives we can avoid actually creating a new object for them.
  24. if (base_value.is_string())
  25. return vm.current_realm()->intrinsics().string_prototype();
  26. if (base_value.is_number())
  27. return vm.current_realm()->intrinsics().number_prototype();
  28. if (base_value.is_boolean())
  29. return vm.current_realm()->intrinsics().boolean_prototype();
  30. return base_value.to_object(vm);
  31. }
  32. ThrowCompletionOr<Value> get_by_id(Bytecode::Interpreter& interpreter, DeprecatedFlyString const& property, Value base_value, Value this_value, u32 cache_index)
  33. {
  34. auto& vm = interpreter.vm();
  35. auto& cache = interpreter.current_executable().property_lookup_caches[cache_index];
  36. if (base_value.is_string()) {
  37. auto string_value = TRY(base_value.as_string().get(vm, property));
  38. if (string_value.has_value())
  39. return *string_value;
  40. }
  41. auto base_obj = TRY(base_object_for_get(interpreter, base_value));
  42. // OPTIMIZATION: If the shape of the object hasn't changed, we can use the cached property offset.
  43. // NOTE: Unique shapes don't change identity, so we compare their serial numbers instead.
  44. auto& shape = base_obj->shape();
  45. if (&shape == cache.shape
  46. && (!shape.is_unique() || shape.unique_shape_serial_number() == cache.unique_shape_serial_number)) {
  47. return base_obj->get_direct(cache.property_offset.value());
  48. }
  49. CacheablePropertyMetadata cacheable_metadata;
  50. auto value = TRY(base_obj->internal_get(property, this_value, &cacheable_metadata));
  51. if (cacheable_metadata.type == CacheablePropertyMetadata::Type::OwnProperty) {
  52. cache.shape = shape;
  53. cache.property_offset = cacheable_metadata.property_offset.value();
  54. cache.unique_shape_serial_number = shape.unique_shape_serial_number();
  55. }
  56. return value;
  57. }
  58. ThrowCompletionOr<Value> get_by_value(Bytecode::Interpreter& interpreter, Value base_value, Value property_key_value)
  59. {
  60. auto& vm = interpreter.vm();
  61. auto object = TRY(base_object_for_get(interpreter, base_value));
  62. // OPTIMIZATION: Fast path for simple Int32 indexes in array-like objects.
  63. if (property_key_value.is_int32()
  64. && property_key_value.as_i32() >= 0
  65. && !object->may_interfere_with_indexed_property_access()
  66. && object->indexed_properties().has_index(property_key_value.as_i32())) {
  67. auto value = object->indexed_properties().get(property_key_value.as_i32())->value;
  68. if (!value.is_accessor())
  69. return value;
  70. }
  71. auto property_key = TRY(property_key_value.to_property_key(vm));
  72. if (base_value.is_string()) {
  73. auto string_value = TRY(base_value.as_string().get(vm, property_key));
  74. if (string_value.has_value())
  75. return *string_value;
  76. }
  77. return TRY(object->internal_get(property_key, base_value));
  78. }
  79. ThrowCompletionOr<Value> get_global(Bytecode::Interpreter& interpreter, IdentifierTableIndex identifier, u32 cache_index)
  80. {
  81. auto& vm = interpreter.vm();
  82. auto& realm = *vm.current_realm();
  83. auto& cache = interpreter.current_executable().global_variable_caches[cache_index];
  84. auto& binding_object = realm.global_environment().object_record().binding_object();
  85. auto& declarative_record = realm.global_environment().declarative_record();
  86. // OPTIMIZATION: If the shape of the object hasn't changed, we can use the cached property offset.
  87. // NOTE: Unique shapes don't change identity, so we compare their serial numbers instead.
  88. auto& shape = binding_object.shape();
  89. if (cache.environment_serial_number == declarative_record.environment_serial_number()
  90. && &shape == cache.shape
  91. && (!shape.is_unique() || shape.unique_shape_serial_number() == cache.unique_shape_serial_number)) {
  92. return binding_object.get_direct(cache.property_offset.value());
  93. }
  94. cache.environment_serial_number = declarative_record.environment_serial_number();
  95. auto const& name = interpreter.current_executable().get_identifier(identifier);
  96. if (vm.running_execution_context().script_or_module.has<NonnullGCPtr<Module>>()) {
  97. // NOTE: GetGlobal is used to access variables stored in the module environment and global environment.
  98. // The module environment is checked first since it precedes the global environment in the environment chain.
  99. auto& module_environment = *vm.running_execution_context().script_or_module.get<NonnullGCPtr<Module>>()->environment();
  100. if (TRY(module_environment.has_binding(name))) {
  101. // TODO: Cache offset of binding value
  102. return TRY(module_environment.get_binding_value(vm, name, vm.in_strict_mode()));
  103. }
  104. }
  105. if (TRY(declarative_record.has_binding(name))) {
  106. // TODO: Cache offset of binding value
  107. return TRY(declarative_record.get_binding_value(vm, name, vm.in_strict_mode()));
  108. }
  109. if (TRY(binding_object.has_property(name))) {
  110. CacheablePropertyMetadata cacheable_metadata;
  111. auto value = TRY(binding_object.internal_get(name, js_undefined(), &cacheable_metadata));
  112. if (cacheable_metadata.type == CacheablePropertyMetadata::Type::OwnProperty) {
  113. cache.shape = shape;
  114. cache.property_offset = cacheable_metadata.property_offset.value();
  115. cache.unique_shape_serial_number = shape.unique_shape_serial_number();
  116. }
  117. return value;
  118. }
  119. return vm.throw_completion<ReferenceError>(ErrorType::UnknownIdentifier, name);
  120. }
  121. ThrowCompletionOr<void> put_by_property_key(VM& vm, Value base, Value this_value, Value value, PropertyKey name, Op::PropertyKind kind)
  122. {
  123. // Better error message than to_object would give
  124. if (vm.in_strict_mode() && base.is_nullish())
  125. return vm.throw_completion<TypeError>(ErrorType::ReferenceNullishSetProperty, name, base.to_string_without_side_effects());
  126. // a. Let baseObj be ? ToObject(V.[[Base]]).
  127. auto object = TRY(base.to_object(vm));
  128. if (kind == Op::PropertyKind::Getter || kind == Op::PropertyKind::Setter) {
  129. // The generator should only pass us functions for getters and setters.
  130. VERIFY(value.is_function());
  131. }
  132. switch (kind) {
  133. case Op::PropertyKind::Getter: {
  134. auto& function = value.as_function();
  135. if (function.name().is_empty() && is<ECMAScriptFunctionObject>(function))
  136. static_cast<ECMAScriptFunctionObject*>(&function)->set_name(DeprecatedString::formatted("get {}", name));
  137. object->define_direct_accessor(name, &function, nullptr, Attribute::Configurable | Attribute::Enumerable);
  138. break;
  139. }
  140. case Op::PropertyKind::Setter: {
  141. auto& function = value.as_function();
  142. if (function.name().is_empty() && is<ECMAScriptFunctionObject>(function))
  143. static_cast<ECMAScriptFunctionObject*>(&function)->set_name(DeprecatedString::formatted("set {}", name));
  144. object->define_direct_accessor(name, nullptr, &function, Attribute::Configurable | Attribute::Enumerable);
  145. break;
  146. }
  147. case Op::PropertyKind::KeyValue: {
  148. bool succeeded = TRY(object->internal_set(name, value, this_value));
  149. if (!succeeded && vm.in_strict_mode()) {
  150. if (base.is_object())
  151. return vm.throw_completion<TypeError>(ErrorType::ReferenceNullishSetProperty, name, base.to_string_without_side_effects());
  152. return vm.throw_completion<TypeError>(ErrorType::ReferencePrimitiveSetProperty, name, base.typeof(), base.to_string_without_side_effects());
  153. }
  154. break;
  155. }
  156. case Op::PropertyKind::DirectKeyValue:
  157. object->define_direct_property(name, value, Attribute::Enumerable | Attribute::Writable | Attribute::Configurable);
  158. break;
  159. case Op::PropertyKind::Spread:
  160. TRY(object->copy_data_properties(vm, value, {}));
  161. break;
  162. case Op::PropertyKind::ProtoSetter:
  163. if (value.is_object() || value.is_null())
  164. MUST(object->internal_set_prototype_of(value.is_object() ? &value.as_object() : nullptr));
  165. break;
  166. }
  167. return {};
  168. }
  169. ThrowCompletionOr<Value> perform_call(Interpreter& interpreter, Value this_value, Op::CallType call_type, Value callee, MarkedVector<Value> argument_values)
  170. {
  171. auto& vm = interpreter.vm();
  172. auto& function = callee.as_function();
  173. Value return_value;
  174. if (call_type == Op::CallType::DirectEval) {
  175. if (callee == interpreter.realm().intrinsics().eval_function())
  176. return_value = TRY(perform_eval(vm, !argument_values.is_empty() ? argument_values[0].value_or(JS::js_undefined()) : js_undefined(), vm.in_strict_mode() ? CallerMode::Strict : CallerMode::NonStrict, EvalMode::Direct));
  177. else
  178. return_value = TRY(JS::call(vm, function, this_value, move(argument_values)));
  179. } else if (call_type == Op::CallType::Call)
  180. return_value = TRY(JS::call(vm, function, this_value, move(argument_values)));
  181. else
  182. return_value = TRY(construct(vm, function, move(argument_values)));
  183. return return_value;
  184. }
  185. static Completion throw_type_error_for_callee(Bytecode::Interpreter& interpreter, Value callee, StringView callee_type, Optional<StringTableIndex> const& expression_string)
  186. {
  187. auto& vm = interpreter.vm();
  188. if (expression_string.has_value())
  189. return vm.throw_completion<TypeError>(ErrorType::IsNotAEvaluatedFrom, callee.to_string_without_side_effects(), callee_type, interpreter.current_executable().get_string(expression_string->value()));
  190. return vm.throw_completion<TypeError>(ErrorType::IsNotA, callee.to_string_without_side_effects(), callee_type);
  191. }
  192. ThrowCompletionOr<void> throw_if_needed_for_call(Interpreter& interpreter, Value callee, Op::CallType call_type, Optional<StringTableIndex> const& expression_string)
  193. {
  194. if (call_type == Op::CallType::Call && !callee.is_function())
  195. return throw_type_error_for_callee(interpreter, callee, "function"sv, expression_string);
  196. if (call_type == Op::CallType::Construct && !callee.is_constructor())
  197. return throw_type_error_for_callee(interpreter, callee, "constructor"sv, expression_string);
  198. return {};
  199. }
  200. ThrowCompletionOr<Value> typeof_variable(VM& vm, DeprecatedFlyString const& string)
  201. {
  202. // 1. Let val be the result of evaluating UnaryExpression.
  203. auto reference = TRY(vm.resolve_binding(string));
  204. // 2. If val is a Reference Record, then
  205. // a. If IsUnresolvableReference(val) is true, return "undefined".
  206. if (reference.is_unresolvable())
  207. return PrimitiveString::create(vm, "undefined"_string);
  208. // 3. Set val to ? GetValue(val).
  209. auto value = TRY(reference.get_value(vm));
  210. // 4. NOTE: This step is replaced in section B.3.6.3.
  211. // 5. Return a String according to Table 41.
  212. return PrimitiveString::create(vm, value.typeof());
  213. }
  214. ThrowCompletionOr<void> set_variable(
  215. VM& vm,
  216. DeprecatedFlyString const& name,
  217. Value value,
  218. Op::EnvironmentMode mode,
  219. Op::SetVariable::InitializationMode initialization_mode)
  220. {
  221. auto environment = mode == Op::EnvironmentMode::Lexical ? vm.running_execution_context().lexical_environment : vm.running_execution_context().variable_environment;
  222. auto reference = TRY(vm.resolve_binding(name, environment));
  223. switch (initialization_mode) {
  224. case Op::SetVariable::InitializationMode::Initialize:
  225. TRY(reference.initialize_referenced_binding(vm, value));
  226. break;
  227. case Op::SetVariable::InitializationMode::Set:
  228. TRY(reference.put_value(vm, value));
  229. break;
  230. }
  231. return {};
  232. }
  233. Value new_function(VM& vm, FunctionExpression const& function_node, Optional<IdentifierTableIndex> const& lhs_name, Optional<Register> const& home_object)
  234. {
  235. Value value;
  236. if (!function_node.has_name()) {
  237. DeprecatedFlyString name = {};
  238. if (lhs_name.has_value())
  239. name = vm.bytecode_interpreter().current_executable().get_identifier(lhs_name.value());
  240. value = function_node.instantiate_ordinary_function_expression(vm, name);
  241. } else {
  242. value = ECMAScriptFunctionObject::create(*vm.current_realm(), function_node.name(), function_node.source_text(), function_node.body(), function_node.parameters(), function_node.function_length(), function_node.local_variables_names(), vm.lexical_environment(), vm.running_execution_context().private_environment, function_node.kind(), function_node.is_strict_mode(), function_node.might_need_arguments_object(), function_node.contains_direct_call_to_eval(), function_node.is_arrow_function());
  243. }
  244. if (home_object.has_value()) {
  245. auto home_object_value = vm.bytecode_interpreter().reg(home_object.value());
  246. static_cast<ECMAScriptFunctionObject&>(value.as_function()).set_home_object(&home_object_value.as_object());
  247. }
  248. return value;
  249. }
  250. ThrowCompletionOr<void> put_by_value(VM& vm, Value base, Value property_key_value, Value value, Op::PropertyKind kind)
  251. {
  252. // OPTIMIZATION: Fast path for simple Int32 indexes in array-like objects.
  253. if (base.is_object() && property_key_value.is_int32() && property_key_value.as_i32() >= 0) {
  254. auto& object = base.as_object();
  255. auto* storage = object.indexed_properties().storage();
  256. auto index = static_cast<u32>(property_key_value.as_i32());
  257. if (storage
  258. && storage->is_simple_storage()
  259. && !object.may_interfere_with_indexed_property_access()
  260. && storage->has_index(index)) {
  261. auto existing_value = storage->get(index)->value;
  262. if (!existing_value.is_accessor()) {
  263. storage->put(index, value);
  264. return {};
  265. }
  266. }
  267. }
  268. auto property_key = kind != Op::PropertyKind::Spread ? TRY(property_key_value.to_property_key(vm)) : PropertyKey {};
  269. TRY(put_by_property_key(vm, base, base, value, property_key, kind));
  270. return {};
  271. }
  272. ThrowCompletionOr<Value> get_variable(Bytecode::Interpreter& interpreter, DeprecatedFlyString const& name, u32 cache_index)
  273. {
  274. auto& vm = interpreter.vm();
  275. auto& cached_environment_coordinate = interpreter.current_executable().environment_variable_caches[cache_index];
  276. if (cached_environment_coordinate.has_value()) {
  277. auto environment = vm.running_execution_context().lexical_environment;
  278. for (size_t i = 0; i < cached_environment_coordinate->hops; ++i)
  279. environment = environment->outer_environment();
  280. VERIFY(environment);
  281. VERIFY(environment->is_declarative_environment());
  282. if (!environment->is_permanently_screwed_by_eval()) {
  283. return TRY(verify_cast<DeclarativeEnvironment>(*environment).get_binding_value_direct(vm, cached_environment_coordinate.value().index, vm.in_strict_mode()));
  284. }
  285. cached_environment_coordinate = {};
  286. }
  287. auto reference = TRY(vm.resolve_binding(name));
  288. if (reference.environment_coordinate().has_value())
  289. cached_environment_coordinate = reference.environment_coordinate();
  290. return TRY(reference.get_value(vm));
  291. }
  292. ThrowCompletionOr<CalleeAndThis> get_callee_and_this_from_environment(Bytecode::Interpreter& interpreter, DeprecatedFlyString const& name, u32 cache_index)
  293. {
  294. auto& vm = interpreter.vm();
  295. Value callee = js_undefined();
  296. Value this_value = js_undefined();
  297. auto& cached_environment_coordinate = interpreter.current_executable().environment_variable_caches[cache_index];
  298. if (cached_environment_coordinate.has_value()) {
  299. auto environment = vm.running_execution_context().lexical_environment;
  300. for (size_t i = 0; i < cached_environment_coordinate->hops; ++i)
  301. environment = environment->outer_environment();
  302. VERIFY(environment);
  303. VERIFY(environment->is_declarative_environment());
  304. if (!environment->is_permanently_screwed_by_eval()) {
  305. callee = TRY(verify_cast<DeclarativeEnvironment>(*environment).get_binding_value_direct(vm, cached_environment_coordinate.value().index, vm.in_strict_mode()));
  306. this_value = js_undefined();
  307. if (auto base_object = environment->with_base_object())
  308. this_value = base_object;
  309. return CalleeAndThis {
  310. .callee = callee,
  311. .this_value = this_value,
  312. };
  313. }
  314. cached_environment_coordinate = {};
  315. }
  316. auto reference = TRY(vm.resolve_binding(name));
  317. if (reference.environment_coordinate().has_value())
  318. cached_environment_coordinate = reference.environment_coordinate();
  319. callee = TRY(reference.get_value(vm));
  320. if (reference.is_property_reference()) {
  321. this_value = reference.get_this_value();
  322. } else {
  323. if (reference.is_environment_reference()) {
  324. if (auto base_object = reference.base_environment().with_base_object(); base_object != nullptr)
  325. this_value = base_object;
  326. }
  327. }
  328. return CalleeAndThis {
  329. .callee = callee,
  330. .this_value = this_value,
  331. };
  332. }
  333. // 13.2.7.3 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-regular-expression-literals-runtime-semantics-evaluation
  334. Value new_regexp(VM& vm, ParsedRegex const& parsed_regex, DeprecatedString const& pattern, DeprecatedString const& flags)
  335. {
  336. // 1. Let pattern be CodePointsToString(BodyText of RegularExpressionLiteral).
  337. // 2. Let flags be CodePointsToString(FlagText of RegularExpressionLiteral).
  338. // 3. Return ! RegExpCreate(pattern, flags).
  339. auto& realm = *vm.current_realm();
  340. Regex<ECMA262> regex(parsed_regex.regex, parsed_regex.pattern, parsed_regex.flags);
  341. // NOTE: We bypass RegExpCreate and subsequently RegExpAlloc as an optimization to use the already parsed values.
  342. auto regexp_object = RegExpObject::create(realm, move(regex), pattern, flags);
  343. // RegExpAlloc has these two steps from the 'Legacy RegExp features' proposal.
  344. regexp_object->set_realm(realm);
  345. // We don't need to check 'If SameValue(newTarget, thisRealm.[[Intrinsics]].[[%RegExp%]]) is true'
  346. // here as we know RegExpCreate calls RegExpAlloc with %RegExp% for newTarget.
  347. regexp_object->set_legacy_features_enabled(true);
  348. return regexp_object;
  349. }
  350. // 13.3.8.1 https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
  351. MarkedVector<Value> argument_list_evaluation(VM& vm, Value arguments)
  352. {
  353. // Note: Any spreading and actual evaluation is handled in preceding opcodes
  354. // Note: The spec uses the concept of a list, while we create a temporary array
  355. // in the preceding opcodes, so we have to convert in a manner that is not
  356. // visible to the user
  357. MarkedVector<Value> argument_values { vm.heap() };
  358. auto& argument_array = arguments.as_array();
  359. auto array_length = argument_array.indexed_properties().array_like_size();
  360. argument_values.ensure_capacity(array_length);
  361. for (size_t i = 0; i < array_length; ++i) {
  362. if (auto maybe_value = argument_array.indexed_properties().get(i); maybe_value.has_value())
  363. argument_values.append(maybe_value.release_value().value);
  364. else
  365. argument_values.append(js_undefined());
  366. }
  367. return argument_values;
  368. }
  369. ThrowCompletionOr<void> create_variable(VM& vm, DeprecatedFlyString const& name, Op::EnvironmentMode mode, bool is_global, bool is_immutable, bool is_strict)
  370. {
  371. if (mode == Op::EnvironmentMode::Lexical) {
  372. VERIFY(!is_global);
  373. // Note: This is papering over an issue where "FunctionDeclarationInstantiation" creates these bindings for us.
  374. // Instead of crashing in there, we'll just raise an exception here.
  375. if (TRY(vm.lexical_environment()->has_binding(name)))
  376. return vm.throw_completion<InternalError>(TRY_OR_THROW_OOM(vm, String::formatted("Lexical environment already has binding '{}'", name)));
  377. if (is_immutable)
  378. return vm.lexical_environment()->create_immutable_binding(vm, name, is_strict);
  379. return vm.lexical_environment()->create_mutable_binding(vm, name, is_strict);
  380. }
  381. if (!is_global) {
  382. if (is_immutable)
  383. return vm.variable_environment()->create_immutable_binding(vm, name, is_strict);
  384. return vm.variable_environment()->create_mutable_binding(vm, name, is_strict);
  385. }
  386. // 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".
  387. // The only area that sets "can_be_deleted" to true is EvalDeclarationInstantiation, which is currently fully implemented in C++ and not in Bytecode.
  388. return verify_cast<GlobalEnvironment>(vm.variable_environment())->create_global_var_binding(name, false);
  389. }
  390. ThrowCompletionOr<ECMAScriptFunctionObject*> new_class(VM& vm, Value super_class, ClassExpression const& class_expression, Optional<IdentifierTableIndex> const& lhs_name)
  391. {
  392. auto& interpreter = vm.bytecode_interpreter();
  393. auto name = class_expression.name();
  394. // NOTE: NewClass expects classEnv to be active lexical environment
  395. auto* class_environment = vm.lexical_environment();
  396. vm.running_execution_context().lexical_environment = interpreter.saved_lexical_environment_stack().take_last();
  397. DeprecatedFlyString binding_name;
  398. DeprecatedFlyString class_name;
  399. if (!class_expression.has_name() && lhs_name.has_value()) {
  400. class_name = interpreter.current_executable().get_identifier(lhs_name.value());
  401. } else {
  402. binding_name = name;
  403. class_name = name.is_null() ? ""sv : name;
  404. }
  405. return TRY(class_expression.create_class_constructor(vm, class_environment, vm.lexical_environment(), super_class, binding_name, class_name));
  406. }
  407. // 13.3.7.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
  408. ThrowCompletionOr<NonnullGCPtr<Object>> super_call_with_argument_array(VM& vm, Value argument_array, bool is_synthetic)
  409. {
  410. // 1. Let newTarget be GetNewTarget().
  411. auto new_target = vm.get_new_target();
  412. // 2. Assert: Type(newTarget) is Object.
  413. VERIFY(new_target.is_object());
  414. // 3. Let func be GetSuperConstructor().
  415. auto* func = get_super_constructor(vm);
  416. // 4. Let argList be ? ArgumentListEvaluation of Arguments.
  417. MarkedVector<Value> arg_list { vm.heap() };
  418. if (is_synthetic) {
  419. VERIFY(argument_array.is_object() && is<Array>(argument_array.as_object()));
  420. auto const& array_value = static_cast<Array const&>(argument_array.as_object());
  421. auto length = MUST(length_of_array_like(vm, array_value));
  422. for (size_t i = 0; i < length; ++i)
  423. arg_list.append(array_value.get_without_side_effects(PropertyKey { i }));
  424. } else {
  425. arg_list = argument_list_evaluation(vm, argument_array);
  426. }
  427. // 5. If IsConstructor(func) is false, throw a TypeError exception.
  428. if (!Value(func).is_constructor())
  429. return vm.throw_completion<TypeError>(ErrorType::NotAConstructor, "Super constructor");
  430. // 6. Let result be ? Construct(func, argList, newTarget).
  431. auto result = TRY(construct(vm, static_cast<FunctionObject&>(*func), move(arg_list), &new_target.as_function()));
  432. // 7. Let thisER be GetThisEnvironment().
  433. auto& this_environment = verify_cast<FunctionEnvironment>(*get_this_environment(vm));
  434. // 8. Perform ? thisER.BindThisValue(result).
  435. TRY(this_environment.bind_this_value(vm, result));
  436. // 9. Let F be thisER.[[FunctionObject]].
  437. auto& f = this_environment.function_object();
  438. // 10. Assert: F is an ECMAScript function object.
  439. // NOTE: This is implied by the strong C++ type.
  440. // 11. Perform ? InitializeInstanceElements(result, F).
  441. TRY(result->initialize_instance_elements(f));
  442. // 12. Return result.
  443. return result;
  444. }
  445. // 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.
  446. // Make sure to put this into the accumulator before the iterator object disappears from the stack to prevent the members from being GC'd.
  447. Object* iterator_to_object(VM& vm, IteratorRecord iterator)
  448. {
  449. auto& realm = *vm.current_realm();
  450. auto object = Object::create(realm, nullptr);
  451. object->define_direct_property(vm.names.iterator, iterator.iterator, 0);
  452. object->define_direct_property(vm.names.next, iterator.next_method, 0);
  453. object->define_direct_property(vm.names.done, Value(iterator.done), 0);
  454. return object;
  455. }
  456. IteratorRecord object_to_iterator(VM& vm, Object& object)
  457. {
  458. return IteratorRecord {
  459. .iterator = &MUST(object.get(vm.names.iterator)).as_object(),
  460. .next_method = MUST(object.get(vm.names.next)),
  461. .done = MUST(object.get(vm.names.done)).as_bool()
  462. };
  463. }
  464. ThrowCompletionOr<NonnullGCPtr<Array>> iterator_to_array(VM& vm, Value iterator)
  465. {
  466. auto iterator_object = TRY(iterator.to_object(vm));
  467. auto iterator_record = object_to_iterator(vm, iterator_object);
  468. auto array = MUST(Array::create(*vm.current_realm(), 0));
  469. size_t index = 0;
  470. while (true) {
  471. auto iterator_result = TRY(iterator_next(vm, iterator_record));
  472. auto complete = TRY(iterator_complete(vm, iterator_result));
  473. if (complete)
  474. return array;
  475. auto value = TRY(iterator_value(vm, iterator_result));
  476. MUST(array->create_data_property_or_throw(index, value));
  477. index++;
  478. }
  479. }
  480. ThrowCompletionOr<void> append(VM& vm, Value lhs, Value rhs, bool is_spread)
  481. {
  482. // Note: This OpCode is used to construct array literals and argument arrays for calls,
  483. // containing at least one spread element,
  484. // Iterating over such a spread element to unpack it has to be visible by
  485. // the user courtesy of
  486. // (1) https://tc39.es/ecma262/#sec-runtime-semantics-arrayaccumulation
  487. // SpreadElement : ... AssignmentExpression
  488. // 1. Let spreadRef be ? Evaluation of AssignmentExpression.
  489. // 2. Let spreadObj be ? GetValue(spreadRef).
  490. // 3. Let iteratorRecord be ? GetIterator(spreadObj).
  491. // 4. Repeat,
  492. // a. Let next be ? IteratorStep(iteratorRecord).
  493. // b. If next is false, return nextIndex.
  494. // c. Let nextValue be ? IteratorValue(next).
  495. // d. Perform ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), nextValue).
  496. // e. Set nextIndex to nextIndex + 1.
  497. // (2) https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
  498. // ArgumentList : ... AssignmentExpression
  499. // 1. Let list be a new empty List.
  500. // 2. Let spreadRef be ? Evaluation of AssignmentExpression.
  501. // 3. Let spreadObj be ? GetValue(spreadRef).
  502. // 4. Let iteratorRecord be ? GetIterator(spreadObj).
  503. // 5. Repeat,
  504. // a. Let next be ? IteratorStep(iteratorRecord).
  505. // b. If next is false, return list.
  506. // c. Let nextArg be ? IteratorValue(next).
  507. // d. Append nextArg to list.
  508. // ArgumentList : ArgumentList , ... AssignmentExpression
  509. // 1. Let precedingArgs be ? ArgumentListEvaluation of ArgumentList.
  510. // 2. Let spreadRef be ? Evaluation of AssignmentExpression.
  511. // 3. Let iteratorRecord be ? GetIterator(? GetValue(spreadRef)).
  512. // 4. Repeat,
  513. // a. Let next be ? IteratorStep(iteratorRecord).
  514. // b. If next is false, return precedingArgs.
  515. // c. Let nextArg be ? IteratorValue(next).
  516. // d. Append nextArg to precedingArgs.
  517. // Note: We know from codegen, that lhs is a plain array with only indexed properties
  518. auto& lhs_array = lhs.as_array();
  519. auto lhs_size = lhs_array.indexed_properties().array_like_size();
  520. if (is_spread) {
  521. // ...rhs
  522. size_t i = lhs_size;
  523. TRY(get_iterator_values(vm, rhs, [&i, &lhs_array](Value iterator_value) -> Optional<Completion> {
  524. lhs_array.indexed_properties().put(i, iterator_value, default_attributes);
  525. ++i;
  526. return {};
  527. }));
  528. } else {
  529. lhs_array.indexed_properties().put(lhs_size, rhs, default_attributes);
  530. }
  531. return {};
  532. }
  533. ThrowCompletionOr<Value> delete_by_id(Bytecode::Interpreter& interpreter, Value base, IdentifierTableIndex property)
  534. {
  535. auto& vm = interpreter.vm();
  536. auto const& identifier = interpreter.current_executable().get_identifier(property);
  537. bool strict = vm.in_strict_mode();
  538. auto reference = Reference { base, identifier, {}, strict };
  539. return TRY(reference.delete_(vm));
  540. }
  541. ThrowCompletionOr<Value> delete_by_value(Bytecode::Interpreter& interpreter, Value base, Value property_key_value)
  542. {
  543. auto& vm = interpreter.vm();
  544. auto property_key = TRY(property_key_value.to_property_key(vm));
  545. bool strict = vm.in_strict_mode();
  546. auto reference = Reference { base, property_key, {}, strict };
  547. return Value(TRY(reference.delete_(vm)));
  548. }
  549. ThrowCompletionOr<Value> delete_by_value_with_this(Bytecode::Interpreter& interpreter, Value base, Value property_key_value, Value this_value)
  550. {
  551. auto& vm = interpreter.vm();
  552. auto property_key = TRY(property_key_value.to_property_key(vm));
  553. bool strict = vm.in_strict_mode();
  554. auto reference = Reference { base, property_key, this_value, strict };
  555. return Value(TRY(reference.delete_(vm)));
  556. }
  557. // 14.7.5.9 EnumerateObjectProperties ( O ), https://tc39.es/ecma262/#sec-enumerate-object-properties
  558. ThrowCompletionOr<Object*> get_object_property_iterator(VM& vm, Value value)
  559. {
  560. // While the spec does provide an algorithm, it allows us to implement it ourselves so long as we meet the following invariants:
  561. // 1- Returned property keys do not include keys that are Symbols
  562. // 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
  563. // 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
  564. // 4- A property name will be returned by the iterator's next method at most once in any enumeration.
  565. // 5- Enumerating the properties of the target object includes enumerating properties of its prototype, and the prototype of the prototype, and so on, recursively;
  566. // 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.
  567. // 6- The values of [[Enumerable]] attributes are not considered when determining if a property of a prototype object has already been processed.
  568. // 7- The enumerable property names of prototype objects must be obtained by invoking EnumerateObjectProperties passing the prototype object as the argument.
  569. // 8- EnumerateObjectProperties must obtain the own property keys of the target object by calling its [[OwnPropertyKeys]] internal method.
  570. // 9- Property attributes of the target object must be obtained by calling its [[GetOwnProperty]] internal method
  571. // Invariant 3 effectively allows the implementation to ignore newly added keys, and we do so (similar to other implementations).
  572. auto object = TRY(value.to_object(vm));
  573. // Note: While the spec doesn't explicitly require these to be ordered, it says that the values should be retrieved via OwnPropertyKeys,
  574. // so we just keep the order consistent anyway.
  575. OrderedHashTable<PropertyKey> properties;
  576. OrderedHashTable<PropertyKey> non_enumerable_properties;
  577. HashTable<NonnullGCPtr<Object>> seen_objects;
  578. // Collect all keys immediately (invariant no. 5)
  579. 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())) {
  580. seen_objects.set(*object_to_check);
  581. for (auto& key : TRY(object_to_check->internal_own_property_keys())) {
  582. if (key.is_symbol())
  583. continue;
  584. auto property_key = TRY(PropertyKey::from_value(vm, key));
  585. // If there is a non-enumerable property higher up the prototype chain with the same key,
  586. // we mustn't include this property even if it's enumerable (invariant no. 5 and 6)
  587. if (non_enumerable_properties.contains(property_key))
  588. continue;
  589. if (properties.contains(property_key))
  590. continue;
  591. auto descriptor = TRY(object_to_check->internal_get_own_property(property_key));
  592. if (!*descriptor->enumerable)
  593. non_enumerable_properties.set(move(property_key));
  594. else
  595. properties.set(move(property_key));
  596. }
  597. }
  598. IteratorRecord iterator {
  599. .iterator = object,
  600. .next_method = NativeFunction::create(
  601. *vm.current_realm(),
  602. [items = move(properties)](VM& vm) mutable -> ThrowCompletionOr<Value> {
  603. auto& realm = *vm.current_realm();
  604. auto iterated_object_value = vm.this_value();
  605. if (!iterated_object_value.is_object())
  606. return vm.throw_completion<InternalError>("Invalid state for GetObjectPropertyIterator.next"sv);
  607. auto& iterated_object = iterated_object_value.as_object();
  608. auto result_object = Object::create(realm, nullptr);
  609. while (true) {
  610. if (items.is_empty()) {
  611. result_object->define_direct_property(vm.names.done, JS::Value(true), default_attributes);
  612. return result_object;
  613. }
  614. auto key = items.take_first();
  615. // If the property is deleted, don't include it (invariant no. 2)
  616. if (!TRY(iterated_object.has_property(key)))
  617. continue;
  618. result_object->define_direct_property(vm.names.done, JS::Value(false), default_attributes);
  619. if (key.is_number())
  620. result_object->define_direct_property(vm.names.value, PrimitiveString::create(vm, TRY_OR_THROW_OOM(vm, String::number(key.as_number()))), default_attributes);
  621. else if (key.is_string())
  622. result_object->define_direct_property(vm.names.value, PrimitiveString::create(vm, key.as_string()), default_attributes);
  623. else
  624. VERIFY_NOT_REACHED(); // We should not have non-string/number keys.
  625. return result_object;
  626. }
  627. },
  628. 1,
  629. vm.names.next),
  630. .done = false,
  631. };
  632. return iterator_to_object(vm, move(iterator));
  633. }
  634. }