use super::define_method;
use super::object::{defined, this_object};
use crate::heap::{Heap, NativeCall, PropertyDescriptor, PropertyKind};
use crate::realm::Realm;
use crate::value::{Abrupt, Completion, Value};
use crate::vm::Vm;
#[derive(Clone, Copy)]
enum Half {
Getter,
Setter,
}
fn define(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>, half: Half) -> Completion<Value> {
let object = this_object(call, "this method requires an object")?;
let function = call.argument(1);
if !heap.is_callable(function) {
return Err(Abrupt::type_error(match half {
Half::Getter => "the getter is not a function",
Half::Setter => "the setter is not a function",
}));
}
let key = vm.to_property_key(call.argument(0), heap)?;
let (getter, setter) = match half {
Half::Getter => (Some(function), None),
Half::Setter => (None, Some(function)),
};
let descriptor = PropertyDescriptor {
getter,
setter,
enumerable: Some(true),
configurable: Some(true),
..PropertyDescriptor::EMPTY
};
defined(vm.define_through(object, key, &descriptor, heap)?)?;
Ok(Value::Undefined)
}
fn look_up(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>, half: Half) -> Completion<Value> {
let object = this_object(call, "this method requires an object")?;
let key = vm.to_property_key(call.argument(0), heap)?;
let mut walk = object;
loop {
if let Some(property) = vm.own_property_through(walk, key, heap)? {
return Ok(match (property.kind, half) {
(PropertyKind::Accessor { getter, .. }, Half::Getter) => getter,
(PropertyKind::Accessor { setter, .. }, Half::Setter) => setter,
_ => Value::Undefined,
});
}
let Some(next) = vm.prototype_through(walk, heap)? else {
return Ok(Value::Undefined);
};
walk = next;
}
}
fn define_getter(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
define(vm, heap, call, Half::Getter)
}
fn define_setter(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
define(vm, heap, call, Half::Setter)
}
fn lookup_getter(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
look_up(vm, heap, call, Half::Getter)
}
fn lookup_setter(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
look_up(vm, heap, call, Half::Setter)
}
fn get_proto(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
let object = super::object::coerced(vm, heap, call.this_value)?;
Ok(match vm.prototype_through(object, heap)? {
Some(prototype) => Value::Object(prototype),
None => Value::Null,
})
}
fn set_proto(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
if matches!(call.this_value, Value::Undefined | Value::Null) {
return Err(Abrupt::type_error(
"undefined and null have no prototype to set",
));
}
let prototype = match call.argument(0) {
Value::Object(prototype) => Some(prototype),
Value::Null => None,
_ => return Ok(Value::Undefined),
};
let Value::Object(object) = call.this_value else {
return Ok(Value::Undefined);
};
if !vm.set_prototype_through(object, prototype, heap)? {
return Err(Abrupt::type_error(
"this object's prototype may not be changed",
));
}
Ok(Value::Undefined)
}
pub fn install(heap: &mut Heap, realm: &Realm) {
let prototype = realm.object_prototype();
for (name, length, native) in [
("__defineGetter__", 2, define_getter as crate::heap::Native),
("__defineSetter__", 2, define_setter),
("__lookupGetter__", 1, lookup_getter),
("__lookupSetter__", 1, lookup_setter),
] {
define_method(heap, realm, prototype, name, length, native);
}
let getter = heap.new_native_function(realm.function_prototype(), get_proto, realm.id());
super::define_function_metadata(heap, getter, "get __proto__", 0);
let setter = heap.new_native_function(realm.function_prototype(), set_proto, realm.id());
super::define_function_metadata(heap, setter, "set __proto__", 1);
let slot = super::key(heap, "__proto__");
let _ = heap.define_own_property(
prototype,
slot,
&PropertyDescriptor {
getter: Some(Value::Object(getter)),
setter: Some(Value::Object(setter)),
enumerable: Some(false),
configurable: Some(true),
..PropertyDescriptor::EMPTY
},
);
}