use std::cell::RefCell;
use std::rc::Rc;
use crate::vm::object::JSObject;
use crate::vm::property::{PropertyDescriptor, PropertyKey};
use crate::vm::value::Value;
const MAX_PROTO_DEPTH: usize = 1000;
#[derive(Debug, Clone)]
pub struct GetPrototypeChainOptions {
pub own_only: bool,
pub throw_on_accessor: bool,
}
impl Default for GetPrototypeChainOptions {
fn default() -> Self {
Self {
own_only: false,
throw_on_accessor: false,
}
}
}
pub fn internal_get(
obj: Rc<RefCell<dyn JSObject>>,
key: &PropertyKey,
options: Option<GetPrototypeChainOptions>,
) -> Result<Value, String> {
let opts = options.unwrap_or_default();
let mut current = Some(obj);
let mut depth = 0;
while let Some(obj_ref) = current {
if depth > MAX_PROTO_DEPTH {
return Err("Maximum prototype chain depth exceeded".to_string());
}
let borrowed = obj_ref.borrow();
if let Some(desc) = borrowed.property_get(key) {
return get_property_value(desc, opts.throw_on_accessor);
}
if opts.own_only {
return Ok(Value::Undefined);
}
current = borrowed.get_prototype();
depth += 1;
}
Ok(Value::Undefined)
}
fn get_property_value(desc: PropertyDescriptor, throw_on_accessor: bool) -> Result<Value, String> {
if desc.is_data_descriptor() {
Ok(desc.value)
} else if throw_on_accessor {
Err("Cannot get value of accessor property".to_string())
} else {
Ok(Value::Undefined)
}
}
pub fn find_descriptor(
obj: Rc<RefCell<dyn JSObject>>,
key: &PropertyKey,
) -> Result<Option<(Rc<RefCell<dyn JSObject>>, PropertyDescriptor)>, String> {
let mut current = Some(obj);
let mut depth = 0;
while let Some(owner) = current {
if depth > MAX_PROTO_DEPTH {
return Err("Maximum prototype chain depth exceeded".to_string());
}
let desc = owner.borrow().property_get(key);
if let Some(desc) = desc {
return Ok(Some((Rc::clone(&owner), desc)));
}
current = owner.borrow().get_prototype();
depth += 1;
}
Ok(None)
}
pub fn internal_set(
obj: Rc<RefCell<dyn JSObject>>,
key: PropertyKey,
value: Value,
) -> Result<bool, String> {
let own_desc = {
let borrowed = obj.borrow();
borrowed.property_get(&key)
};
if let Some(desc) = own_desc {
if desc.is_data_descriptor() {
if !desc.writable {
return Ok(false);
}
let mut borrowed = obj.borrow_mut();
return borrowed.property_set(key, value);
} else {
if let Some(setter) = desc.setter {
let mut borrowed = obj.borrow_mut();
return borrowed.property_set(key, value);
}
return Ok(false);
}
}
let mut current = {
let borrowed = obj.borrow();
borrowed.get_prototype()
};
while let Some(proto) = current {
let proto_desc = {
let borrowed = proto.borrow();
borrowed.property_get(&key)
};
if let Some(desc) = proto_desc {
if desc.is_data_descriptor() {
if !desc.writable {
return Ok(false);
}
let mut borrowed = obj.borrow_mut();
return borrowed.property_set(key, value);
}
if let Some(_setter) = desc.setter {
let mut borrowed = obj.borrow_mut();
return borrowed.property_set(key, value);
}
return Ok(false);
}
let borrowed = proto.borrow();
current = borrowed.get_prototype();
}
let mut borrowed = obj.borrow_mut();
borrowed.property_set(key, value)
}
pub fn internal_has_property(
obj: Rc<RefCell<dyn JSObject>>,
key: &PropertyKey,
) -> Result<bool, String> {
let mut current = Some(obj);
let mut depth = 0;
while let Some(obj_ref) = current {
if depth > MAX_PROTO_DEPTH {
return Err("Maximum prototype chain depth exceeded".to_string());
}
let borrowed = obj_ref.borrow();
if borrowed.has_property(key) {
return Ok(true);
}
current = borrowed.get_prototype();
depth += 1;
}
Ok(false)
}
pub fn internal_delete(obj: Rc<RefCell<dyn JSObject>>, key: &PropertyKey) -> Result<bool, String> {
let mut borrowed = obj.borrow_mut();
Ok(borrowed.property_delete(key))
}
pub fn value_to_property_key(val: &Value) -> PropertyKey {
match val {
Value::String(s) => PropertyKey::from_str(s.as_str()),
Value::Symbol(sym_data) => PropertyKey::Symbol(sym_data.id),
other => PropertyKey::from_str(&other.to_string()),
}
}
pub fn str_to_property_key(s: &str) -> PropertyKey {
PropertyKey::from_str(s)
}