/* * Copyright (c) 2021-2025, Andreas Kling * * SPDX-License-Identifier: BSD-2-Clause */ #include #include #include #include namespace JS { GC_DEFINE_ALLOCATOR(ArgumentsObject); ArgumentsObject::ArgumentsObject(Realm& realm, Environment& environment, bool parameter_list_is_empty) : Object(realm.intrinsics().mapped_arguments_object_shape(), parameter_list_is_empty ? MayInterfereWithIndexedPropertyAccess::No : MayInterfereWithIndexedPropertyAccess::Yes) , m_environment(environment) { } void ArgumentsObject::initialize(Realm& realm) { Base::initialize(realm); } void ArgumentsObject::visit_edges(Cell::Visitor& visitor) { Base::visit_edges(visitor); visitor.visit(m_environment); } size_t ArgumentsObject::external_memory_size() const { return Object::external_memory_size() + vector_external_memory_size(m_mapped_names); } bool ArgumentsObject::parameter_map_has(PropertyKey const& key) const { return key.is_number() && key.as_number() < m_mapped_names.size() && !m_mapped_names[key.as_number()].is_empty(); } // 10.4.4.3 [[Get]] ( P, Receiver ), https://tc39.es/ecma262/#sec-arguments-exotic-objects-get-p-receiver ThrowCompletionOr ArgumentsObject::internal_get(PropertyKey const& property_key, Value receiver, CacheableGetPropertyMetadata* cacheable_metadata, PropertyLookupPhase phase) const { // 1. Let map be args.[[ParameterMap]]. // 2. Let isMapped be ! HasOwnProperty(map, P). bool is_mapped = parameter_map_has(property_key); // 3. If isMapped is false, then if (!is_mapped) { // a. Return ? OrdinaryGet(args, P, Receiver). return Object::internal_get(property_key, receiver, cacheable_metadata, phase); } // a. Assert: map contains a formal parameter mapping for P. // b. Return ! Get(map, P). return get_from_parameter_map(property_key); } // 10.4.4.4 [[Set]] ( P, V, Receiver ), https://tc39.es/ecma262/#sec-arguments-exotic-objects-set-p-v-receiver ThrowCompletionOr ArgumentsObject::internal_set(PropertyKey const& property_key, Value value, Value receiver, CacheableSetPropertyMetadata*, PropertyLookupPhase) { bool is_mapped = false; // 1. If SameValue(args, Receiver) is false, then if (!same_value(this, receiver)) { // a. Let isMapped be false. is_mapped = false; } else { // a. Let map be args.[[ParameterMap]]. // b. Let isMapped be ! HasOwnProperty(map, P). is_mapped = parameter_map_has(property_key); } // 3. If isMapped is true, then if (is_mapped) { // a. Assert: The following Set will succeed, since formal parameters mapped by arguments objects are always writable. // b. Perform ! Set(map, P, V, false). set_in_parameter_map(property_key, value); } // 4. Return ? OrdinarySet(args, P, V, Receiver). return Object::internal_set(property_key, value, receiver); } // 10.4.4.5 [[Delete]] ( P ), https://tc39.es/ecma262/#sec-arguments-exotic-objects-delete-p ThrowCompletionOr ArgumentsObject::internal_delete(PropertyKey const& property_key) { // 1. Let map be args.[[ParameterMap]]. // 2. Let isMapped be ! HasOwnProperty(map, P). bool is_mapped = parameter_map_has(property_key); // 3. Let result be ? OrdinaryDelete(args, P). bool result = TRY(Object::internal_delete(property_key)); // 4. If result is true and isMapped is true, then if (result && is_mapped) { // a. Perform ! map.[[Delete]](P). delete_from_parameter_map(property_key); } // 5. Return result. return result; } // 10.4.4.1 [[GetOwnProperty]] ( P ), https://tc39.es/ecma262/#sec-arguments-exotic-objects-getownproperty-p ThrowCompletionOr> ArgumentsObject::internal_get_own_property(PropertyKey const& property_key) const { // 1. Let desc be OrdinaryGetOwnProperty(args, P). auto desc = MUST(Object::internal_get_own_property(property_key)); // 2. If desc is undefined, return desc. if (!desc.has_value()) return desc; // 3. Let map be args.[[ParameterMap]]. // 4. Let isMapped be ! HasOwnProperty(map, P). bool is_mapped = parameter_map_has(property_key); // 5. If isMapped is true, then if (is_mapped) { // a. Set desc.[[Value]] to ! Get(map, P). desc->value = get_from_parameter_map(property_key); } // 6. Return desc. return desc; } // 10.4.4.2 [[DefineOwnProperty]] ( P, Desc ), https://tc39.es/ecma262/#sec-arguments-exotic-objects-defineownproperty-p-desc ThrowCompletionOr ArgumentsObject::internal_define_own_property(PropertyKey const& property_key, PropertyDescriptor& descriptor, Optional* precomputed_get_own_property) { // 1. Let map be args.[[ParameterMap]]. // 2. Let isMapped be ! HasOwnProperty(map, P). bool is_mapped = parameter_map_has(property_key); // 3. Let newArgDesc be Desc. auto new_arg_desc = descriptor; // 4. If isMapped is true and IsDataDescriptor(Desc) is true, then if (is_mapped && descriptor.is_data_descriptor()) { // a. If Desc does not have a [[Value]] field and Desc has a [[Writable]] field, and Desc.[[Writable]] is false, then if (!descriptor.value.has_value() && descriptor.writable.has_value() && descriptor.writable == false) { // i. Set newArgDesc to a copy of Desc. new_arg_desc = descriptor; // ii. Set newArgDesc.[[Value]] to ! Get(map, P). new_arg_desc.value = get_from_parameter_map(property_key); } } // 5. Let allowed be ! OrdinaryDefineOwnProperty(args, P, newArgDesc). bool allowed = MUST(Object::internal_define_own_property(property_key, new_arg_desc, precomputed_get_own_property)); // 6. If allowed is false, return false. if (!allowed) return false; // 7. If isMapped is true, then if (is_mapped) { // a. If IsAccessorDescriptor(Desc) is true, then if (descriptor.is_accessor_descriptor()) { // i. Perform ! map.[[Delete]](P). delete_from_parameter_map(property_key); } else { // i. If Desc has a [[Value]] field, then if (descriptor.value.has_value()) { // 1. Assert: The following Set will succeed, since formal parameters mapped by arguments objects are always writable. // 2. Perform ! Set(map, P, Desc.[[Value]], false). set_in_parameter_map(property_key, descriptor.value.value()); } // ii. If Desc has a [[Writable]] field and Desc.[[Writable]] is false, then if (descriptor.writable == false) { // 1. Perform ! map.[[Delete]](P). delete_from_parameter_map(property_key); } } } // 8. Return true. return true; } void ArgumentsObject::delete_from_parameter_map(PropertyKey const& property_key) { m_mapped_names[property_key.as_number()] = Utf16FlyString {}; } Value ArgumentsObject::get_from_parameter_map(PropertyKey const& property_key) const { return MUST(m_environment->get_binding_value(vm(), m_mapped_names[property_key.as_number()], false)); } void ArgumentsObject::set_in_parameter_map(PropertyKey const& property_key, Value value) { MUST(m_environment->set_mutable_binding(vm(), m_mapped_names[property_key.as_number()], value, false)); } }