mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 15:48:12 +00:00
LibJS: Bring Reference records a bit closer to the ECMAScript spec
Our Reference class now has the same fields as the spec: - Base (a non-nullish value, an environment record, or `unresolvable`) - Referenced Name (the name of the binding) - Strict (whether the reference originated in strict mode code) - ThisValue (if non-empty, the reference represents a `super` keyword) The main difference from before is that we now resolve the environment record that a reference interacts with. Previously we simply resolved to either "local variable" or "global variable". The associated abstract operations are still largely non-conforming, since we don't yet implement proper variable bindings. But this patch should at least fix a handful of test262 cases. :^) There's one minor regression: some TypeError message strings get a little worse due to doing a RequireObjectCoercible earlier in the evaluation of MemberExpression.
This commit is contained in:
Andreas Kling
parent
6e1932e8b2
commit
bce7fdba81
6 changed files with 193 additions and 123 deletions
|
|
@ -1,9 +1,10 @@
|
|||
/*
|
||||
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
|
||||
* Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#include <LibJS/AST.h>
|
||||
#include <LibJS/Runtime/Error.h>
|
||||
#include <LibJS/Runtime/GlobalObject.h>
|
||||
#include <LibJS/Runtime/Reference.h>
|
||||
|
|
@ -15,39 +16,50 @@ void Reference::put(GlobalObject& global_object, Value value)
|
|||
auto& vm = global_object.vm();
|
||||
|
||||
if (is_unresolvable()) {
|
||||
throw_reference_error(global_object);
|
||||
if (m_strict) {
|
||||
throw_reference_error(global_object);
|
||||
return;
|
||||
}
|
||||
global_object.put(m_name, value);
|
||||
return;
|
||||
}
|
||||
|
||||
if (is_local_variable() || is_global_variable()) {
|
||||
if (is_local_variable())
|
||||
vm.set_variable(m_name.to_string(), value, global_object);
|
||||
else
|
||||
global_object.put(m_name, value);
|
||||
if (is_property_reference()) {
|
||||
// FIXME: This is an ad-hoc hack until we support proper variable bindings.
|
||||
if (!m_base_value.is_object() && vm.in_strict_mode()) {
|
||||
if (m_base_value.is_nullish())
|
||||
vm.throw_exception<TypeError>(global_object, ErrorType::ReferenceNullishSetProperty, m_name.to_value(vm).to_string_without_side_effects(), m_base_value.to_string_without_side_effects());
|
||||
else
|
||||
vm.throw_exception<TypeError>(global_object, ErrorType::ReferencePrimitiveSetProperty, m_name.to_value(vm).to_string_without_side_effects(), m_base_value.typeof(), m_base_value.to_string_without_side_effects());
|
||||
return;
|
||||
}
|
||||
|
||||
auto* base_obj = m_base_value.to_object(global_object);
|
||||
if (!base_obj)
|
||||
return;
|
||||
|
||||
bool succeeded = base_obj->put(m_name, value);
|
||||
if (!succeeded && m_strict) {
|
||||
vm.throw_exception<TypeError>(global_object, ErrorType::ReferenceNullishSetProperty, m_name.to_value(vm).to_string_without_side_effects(), m_base_value.to_string_without_side_effects());
|
||||
return;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
auto base = this->base();
|
||||
VERIFY(m_base_type == BaseType::EnvironmentRecord);
|
||||
auto existing_variable = m_base_environment_record->get_from_environment_record(m_name.as_string());
|
||||
Variable variable {
|
||||
.value = value,
|
||||
.declaration_kind = existing_variable.has_value() ? existing_variable->declaration_kind : DeclarationKind::Var
|
||||
};
|
||||
|
||||
if (!base.is_object() && vm.in_strict_mode()) {
|
||||
if (base.is_nullish())
|
||||
vm.throw_exception<TypeError>(global_object, ErrorType::ReferenceNullishSetProperty, m_name.to_value(vm).to_string_without_side_effects(), base.to_string_without_side_effects());
|
||||
else
|
||||
vm.throw_exception<TypeError>(global_object, ErrorType::ReferencePrimitiveSetProperty, m_name.to_value(vm).to_string_without_side_effects(), base.typeof(), base.to_string_without_side_effects());
|
||||
// FIXME: This is a hack until we support proper variable bindings.
|
||||
if (variable.declaration_kind == DeclarationKind::Const) {
|
||||
vm.throw_exception<TypeError>(global_object, ErrorType::InvalidAssignToConst);
|
||||
return;
|
||||
}
|
||||
|
||||
if (base.is_nullish()) {
|
||||
// This will always fail the to_object() call below, let's throw the TypeError ourselves with a nice message instead.
|
||||
vm.throw_exception<TypeError>(global_object, ErrorType::ReferenceNullishSetProperty, m_name.to_value(vm).to_string_without_side_effects(), base.to_string_without_side_effects());
|
||||
return;
|
||||
}
|
||||
|
||||
auto* object = base.to_object(global_object);
|
||||
if (!object)
|
||||
return;
|
||||
|
||||
object->put(m_name, value);
|
||||
m_base_environment_record->put_into_environment_record(m_name.as_string(), variable);
|
||||
}
|
||||
|
||||
void Reference::throw_reference_error(GlobalObject& global_object)
|
||||
|
|
@ -59,71 +71,92 @@ void Reference::throw_reference_error(GlobalObject& global_object)
|
|||
vm.throw_exception<ReferenceError>(global_object, ErrorType::UnknownIdentifier, m_name.to_string_or_symbol().to_display_string());
|
||||
}
|
||||
|
||||
Value Reference::get(GlobalObject& global_object)
|
||||
Value Reference::get(GlobalObject& global_object, bool throw_if_undefined)
|
||||
{
|
||||
auto& vm = global_object.vm();
|
||||
|
||||
if (is_unresolvable()) {
|
||||
throw_reference_error(global_object);
|
||||
return {};
|
||||
}
|
||||
|
||||
if (is_local_variable() || is_global_variable()) {
|
||||
Value value;
|
||||
if (is_local_variable())
|
||||
value = vm.get_variable(m_name.to_string(), global_object);
|
||||
else
|
||||
value = global_object.get(m_name);
|
||||
if (vm.exception())
|
||||
return {};
|
||||
if (value.is_empty()) {
|
||||
throw_reference_error(global_object);
|
||||
if (is_property_reference()) {
|
||||
auto* base_obj = m_base_value.to_object(global_object);
|
||||
if (!base_obj)
|
||||
return {};
|
||||
return base_obj->get(m_name).value_or(js_undefined());
|
||||
}
|
||||
|
||||
VERIFY(m_base_type == BaseType::EnvironmentRecord);
|
||||
auto value = m_base_environment_record->get_from_environment_record(m_name.as_string());
|
||||
if (!value.has_value()) {
|
||||
if (!throw_if_undefined) {
|
||||
// FIXME: This is an ad-hoc hack for the `typeof` operator until we support proper variable bindings.
|
||||
return js_undefined();
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
auto base = this->base();
|
||||
|
||||
if (base.is_nullish()) {
|
||||
// This will always fail the to_object() call below, let's throw the TypeError ourselves with a nice message instead.
|
||||
vm.throw_exception<TypeError>(global_object, ErrorType::ReferenceNullishGetProperty, m_name.to_value(vm).to_string_without_side_effects(), base.to_string_without_side_effects());
|
||||
throw_reference_error(global_object);
|
||||
return {};
|
||||
}
|
||||
|
||||
auto* object = base.to_object(global_object);
|
||||
if (!object)
|
||||
return {};
|
||||
|
||||
return object->get(m_name).value_or(js_undefined());
|
||||
return value->value;
|
||||
}
|
||||
|
||||
bool Reference::delete_(GlobalObject& global_object)
|
||||
{
|
||||
if (is_unresolvable())
|
||||
if (is_unresolvable()) {
|
||||
VERIFY(!m_strict);
|
||||
return true;
|
||||
}
|
||||
|
||||
auto& vm = global_object.vm();
|
||||
|
||||
if (is_local_variable() || is_global_variable()) {
|
||||
if (is_local_variable())
|
||||
return vm.delete_variable(m_name.to_string());
|
||||
if (is_property_reference()) {
|
||||
auto* base_obj = m_base_value.to_object(global_object);
|
||||
if (!base_obj)
|
||||
return false;
|
||||
bool succeeded = base_obj->delete_property(m_name);
|
||||
if (!succeeded && m_strict) {
|
||||
vm.throw_exception<TypeError>(global_object, ErrorType::ReferenceNullishDeleteProperty, m_name.to_value(vm).to_string_without_side_effects(), m_base_value.to_string_without_side_effects());
|
||||
return false;
|
||||
}
|
||||
return succeeded;
|
||||
}
|
||||
|
||||
VERIFY(m_base_type == BaseType::EnvironmentRecord);
|
||||
return m_base_environment_record->delete_from_environment_record(m_name.as_string());
|
||||
}
|
||||
|
||||
String Reference::to_string() const
|
||||
{
|
||||
StringBuilder builder;
|
||||
builder.append("Reference { Base=");
|
||||
switch (m_base_type) {
|
||||
case BaseType::Unresolvable:
|
||||
builder.append("Unresolvable");
|
||||
break;
|
||||
case BaseType::EnvironmentRecord:
|
||||
builder.appendff("{}", base_environment().class_name());
|
||||
break;
|
||||
case BaseType::Value:
|
||||
if (m_base_value.is_empty())
|
||||
builder.append("<empty>");
|
||||
else
|
||||
return global_object.delete_property(m_name);
|
||||
builder.appendff("{}", m_base_value.to_string_without_side_effects());
|
||||
break;
|
||||
}
|
||||
builder.append(", ReferencedName=");
|
||||
if (!m_name.is_valid())
|
||||
builder.append("<invalid>");
|
||||
else if (m_name.is_symbol())
|
||||
builder.appendff("{}", m_name.as_symbol()->to_string());
|
||||
else
|
||||
builder.appendff("{}", m_name.to_string());
|
||||
builder.appendff(", Strict={}", m_strict);
|
||||
builder.appendff(", ThisValue=");
|
||||
if (m_this_value.is_empty())
|
||||
builder.append("<empty>");
|
||||
else
|
||||
builder.appendff("{}", m_this_value.to_string_without_side_effects());
|
||||
|
||||
auto base = this->base();
|
||||
|
||||
if (base.is_nullish()) {
|
||||
// This will always fail the to_object() call below, let's throw the TypeError ourselves with a nice message instead.
|
||||
vm.throw_exception<TypeError>(global_object, ErrorType::ReferenceNullishDeleteProperty, m_name.to_value(vm).to_string_without_side_effects(), base.to_string_without_side_effects());
|
||||
return false;
|
||||
}
|
||||
|
||||
auto* object = base.to_object(global_object);
|
||||
VERIFY(object);
|
||||
|
||||
return object->delete_property(m_name);
|
||||
builder.append(" }");
|
||||
return builder.to_string();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue