RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 09:27:35 +00:00
Code Issues Activity Actions

LibJS: Convert the PutValue AO to ThrowCompletionOr

Browse source
This commit is contained in:
Idan Horowitz 2021-11-02 19:20:21 +02:00 • committed by Linus Groh
parent 390a04a985
commit 1aaaf521b8
6 changed files with 58 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

31
Userland/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.cpp
View file

@ -398,22 +398,22 @@ ThrowCompletionOr<void> ECMAScriptFunctionObject::function_declaration_instantia
for (size_t i = 0; i < m_formal_parameters.size(); ++i) {
auto& parameter = m_formal_parameters[i];
parameter.binding.visit(
[&](auto const& param) {
TRY(parameter.binding.visit(
[&](auto const& param) -> ThrowCompletionOr<void> {
Value argument_value;
if (parameter.is_rest) {
auto* array = MUST(Array::create(global_object(), 0));
for (size_t rest_index = i; rest_index < execution_context_arguments.size(); ++rest_index)
array->indexed_properties().append(execution_context_arguments[rest_index]);
argument_value = move(array);
argument_value = array;
} else if (i < execution_context_arguments.size() && !execution_context_arguments[i].is_undefined()) {
argument_value = execution_context_arguments[i];
} else if (parameter.default_value) {
// FIXME: Support default arguments in the bytecode world!
if (interpreter)
argument_value = parameter.default_value->execute(*interpreter, global_object());
if (vm.exception())
return;
if (auto* exception = vm.exception())
return throw_completion(exception->value());
} else {
argument_value = js_undefined();
}
@ -422,26 +422,21 @@ ThrowCompletionOr<void> ECMAScriptFunctionObject::function_declaration_instantia
if constexpr (IsSame<FlyString const&, decltype(param)>) {
Reference reference = vm.resolve_binding(param, used_environment);
if (vm.exception())
return;
if (auto* exception = vm.exception())
return throw_completion(exception->value());
// Here the difference from hasDuplicates is important
if (has_duplicates)
reference.put_value(global_object(), argument_value);
TRY(reference.put_value(global_object(), argument_value));
else
reference.initialize_referenced_binding(global_object(), argument_value);
if (auto* exception = vm.exception())
return throw_completion(exception->value());
return {};
} else if (IsSame<NonnullRefPtr<BindingPattern> const&, decltype(param)>) {
// Here the difference from hasDuplicates is important
auto result = vm.binding_initialization(param, argument_value, used_environment, global_object());
if (result.is_error())
return;
return vm.binding_initialization(param, argument_value, used_environment, global_object());
}
if (vm.exception())
return;
});
if (auto* exception = vm.exception())
return throw_completion(exception->value());
}));
}
Environment* var_environment;

47
Userland/Libraries/LibJS/Runtime/Reference.cpp
View file

@ -13,53 +13,38 @@
namespace JS {
// 6.2.4.6 PutValue ( V, W ), https://tc39.es/ecma262/#sec-putvalue
void Reference::put_value(GlobalObject& global_object, Value value)
ThrowCompletionOr<void> Reference::put_value(GlobalObject& global_object, Value value)
{
auto& vm = global_object.vm();
if (!is_valid_reference()) {
vm.throw_exception<ReferenceError>(global_object, ErrorType::InvalidLeftHandAssignment);
return;
}
if (!is_valid_reference())
return vm.throw_completion<ReferenceError>(global_object, ErrorType::InvalidLeftHandAssignment);
if (is_unresolvable()) {
if (m_strict) {
(void)throw_reference_error(global_object);
return;
}
MUST(global_object.set(m_name, value, Object::ShouldThrowExceptions::No));
return;
if (m_strict)
return throw_reference_error(global_object);
TRY(global_object.set(m_name, value, Object::ShouldThrowExceptions::No));
return {};
}
if (is_property_reference()) {
auto base_obj_or_error = m_base_value.to_object(global_object);
if (base_obj_or_error.is_error())
return;
auto* base_obj = base_obj_or_error.release_value();
auto* base_obj = TRY(m_base_value.to_object(global_object));
if (is_private_reference()) {
base_obj->private_set(m_private_name, value);
return;
}
if (is_private_reference())
return base_obj->private_set(m_private_name, value);
auto succeeded_or_error = base_obj->internal_set(m_name, value, get_this_value());
if (succeeded_or_error.is_error())
return;
auto succeeded = succeeded_or_error.release_value();
if (!succeeded && m_strict) {
vm.throw_exception<TypeError>(global_object, ErrorType::ReferenceNullishSetProperty, m_name, m_base_value.to_string_without_side_effects());
return;
}
return;
auto succeeded = TRY(base_obj->internal_set(m_name, value, get_this_value()));
if (!succeeded && m_strict)
return vm.throw_completion<TypeError>(global_object, ErrorType::ReferenceNullishSetProperty, m_name, m_base_value.to_string_without_side_effects());
return {};
}
VERIFY(m_base_type == BaseType::Environment);
VERIFY(m_base_environment);
// These can throw, TRY() when converting put_value() to ThrowCompletionOr
if (m_environment_coordinate.has_value())
(void)static_cast<DeclarativeEnvironment*>(m_base_environment)->set_mutable_binding_direct(global_object, m_environment_coordinate->index, value, m_strict);
return static_cast<DeclarativeEnvironment*>(m_base_environment)->set_mutable_binding_direct(global_object, m_environment_coordinate->index, value, m_strict);
else
(void)m_base_environment->set_mutable_binding(global_object, m_name.as_string(), value, m_strict);
return m_base_environment->set_mutable_binding(global_object, m_name.as_string(), value, m_strict);
}
Completion Reference::throw_reference_error(GlobalObject& global_object) const

2
Userland/Libraries/LibJS/Runtime/Reference.h
View file

@ -129,7 +129,7 @@ public:
(void)m_base_environment->initialize_binding(global_object, m_name.as_string(), value);
}
void put_value(GlobalObject&, Value);
ThrowCompletionOr<void> put_value(GlobalObject&, Value);
ThrowCompletionOr<Value> get_value(GlobalObject&) const;
ThrowCompletionOr<bool> delete_(GlobalObject&);

13
Userland/Libraries/LibJS/Runtime/VM.cpp
View file

@ -182,10 +182,7 @@ ThrowCompletionOr<void> VM::binding_initialization(FlyString const& target, Valu
return {};
}
auto reference = resolve_binding(target);
reference.put_value(global_object, value);
if (auto* thrown_exception = exception())
return JS::throw_completion(thrown_exception->value());
return {};
return reference.put_value(global_object, value);
}
// 8.5.2 Runtime Semantics: BindingInitialization, https://tc39.es/ecma262/#sec-runtime-semantics-bindinginitialization
@ -242,7 +239,7 @@ ThrowCompletionOr<void> VM::property_binding_initialization(BindingPattern const
TRY(rest_object->copy_data_properties(object, seen_names, global_object));
if (!environment)
assignment_target.put_value(global_object, rest_object);
TRY(assignment_target.put_value(global_object, rest_object));
else
assignment_target.initialize_referenced_binding(global_object, rest_object);
@ -284,7 +281,7 @@ ThrowCompletionOr<void> VM::property_binding_initialization(BindingPattern const
}
if (!environment)
reference.put_value(global_object, value_to_assign);
TRY(reference.put_value(global_object, value_to_assign));
else
reference.initialize_referenced_binding(global_object, value_to_assign);
continue;
@ -321,7 +318,7 @@ ThrowCompletionOr<void> VM::property_binding_initialization(BindingPattern const
} else {
VERIFY(reference_to_assign_to.has_value());
if (!environment)
reference_to_assign_to->put_value(global_object, value_to_assign);
TRY(reference_to_assign_to->put_value(global_object, value_to_assign));
else
reference_to_assign_to->initialize_referenced_binding(global_object, value_to_assign);
@ -419,7 +416,7 @@ ThrowCompletionOr<void> VM::iterator_binding_initialization(BindingPattern const
} else if (!entry.alias.has<Empty>()) {
VERIFY(assignment_target.has_value());
if (!environment)
assignment_target->put_value(global_object, value);
TRY(assignment_target->put_value(global_object, value));
else
assignment_target->initialize_referenced_binding(global_object, value);