use std::any::Any;
use std::cell::RefCell;
use std::collections::BTreeMap;
use std::fmt;
use std::rc::Rc;
use crate::vm::property::{ObjectKind, PropertyDescriptor, PropertyKey};
use crate::vm::value::Value;
pub type ValueRef = Rc<RefCell<Value>>;
pub const MAX_DENSE_ELEMENTS: usize = 1 << 20;
pub trait JSObject: fmt::Debug + Any {
fn kind(&self) -> ObjectKind;
fn as_any(&self) -> &dyn Any;
fn as_any_mut(&mut self) -> &mut dyn Any;
fn property_get(&self, key: &PropertyKey) -> Option<PropertyDescriptor>;
fn property_set(&mut self, key: PropertyKey, value: Value) -> Result<bool, String>;
fn define_property(
&mut self,
key: PropertyKey,
desc: PropertyDescriptor,
) -> Result<bool, String>;
fn property_delete(&mut self, key: &PropertyKey) -> bool;
fn has_property(&self, key: &PropertyKey) -> bool;
fn own_keys(&self) -> Vec<PropertyKey>;
fn get_prototype(&self) -> Option<Rc<RefCell<dyn JSObject>>>;
fn set_prototype(&mut self, proto: Option<Rc<RefCell<dyn JSObject>>>);
fn is_extensible(&self) -> bool;
fn prevent_extensions(&mut self);
fn is_frozen(&self) -> bool;
fn freeze(&mut self);
fn is_sealed(&self) -> bool;
fn seal(&mut self);
fn type_of(&self) -> &'static str {
"object"
}
fn class_name(&self) -> &'static str {
"Object"
}
fn to_primitive(&self, _hint: &str) -> Result<Value, String> {
Err("ToPrimitive: function calls not available".to_string())
}
}
fn array_index_of(key: &str) -> Option<u32> {
if key.is_empty() || key.len() > 10 {
return None;
}
let index: u32 = key.parse().ok()?;
if index == u32::MAX {
return None;
}
(index.to_string() == key).then_some(index)
}
#[derive(Debug, Clone, Default)]
pub(crate) struct PropertyTable {
values: BTreeMap<PropertyKey, PropertyDescriptor>,
creation_order: Vec<PropertyKey>,
}
impl PropertyTable {
pub(crate) fn new() -> Self {
Self::default()
}
}
impl FromIterator<(PropertyKey, PropertyDescriptor)> for PropertyTable {
fn from_iter<I: IntoIterator<Item = (PropertyKey, PropertyDescriptor)>>(iter: I) -> Self {
let mut table = PropertyTable::new();
for (key, desc) in iter {
table.insert(key, desc);
}
table
}
}
impl PropertyTable {
pub(crate) fn get(&self, key: &PropertyKey) -> Option<&PropertyDescriptor> {
self.values.get(key)
}
pub(crate) fn get_mut(&mut self, key: &PropertyKey) -> Option<&mut PropertyDescriptor> {
self.values.get_mut(key)
}
pub(crate) fn contains_key(&self, key: &PropertyKey) -> bool {
self.values.contains_key(key)
}
pub(crate) fn insert(&mut self, key: PropertyKey, desc: PropertyDescriptor) {
if self.values.insert(key.clone(), desc).is_none() {
self.creation_order.push(key);
}
}
pub(crate) fn remove(&mut self, key: &PropertyKey) -> Option<PropertyDescriptor> {
let removed = self.values.remove(key);
if removed.is_some() {
self.creation_order.retain(|existing| existing != key);
}
removed
}
pub(crate) fn keys(&self) -> Vec<PropertyKey> {
let mut indices: Vec<(u32, PropertyKey)> = Vec::new();
let mut strings: Vec<PropertyKey> = Vec::new();
let mut symbols: Vec<PropertyKey> = Vec::new();
for key in &self.creation_order {
match key {
PropertyKey::Str(s) => match array_index_of(s.as_str()) {
Some(index) => indices.push((index, key.clone())),
None => strings.push(key.clone()),
},
PropertyKey::Symbol(_) => symbols.push(key.clone()),
}
}
indices.sort_by_key(|(index, _)| *index);
let mut ordered: Vec<PropertyKey> = indices.into_iter().map(|(_, key)| key).collect();
ordered.extend(strings);
ordered.extend(symbols);
ordered
}
}
pub(crate) fn same_value(a: &Value, b: &Value) -> bool {
match (a, b) {
(Value::Number(x), Value::Number(y)) => {
if x.is_nan() && y.is_nan() {
true
} else if *x == 0.0 && *y == 0.0 {
x.is_sign_positive() == y.is_sign_positive()
} else {
x == y
}
}
_ => a.strict_eq(b),
}
}
pub(crate) fn validate_property_redefinition(
current: &PropertyDescriptor,
desc: &PropertyDescriptor,
) -> Result<(), String> {
if current.configurable {
return Ok(());
}
if desc.configurable {
return Err("Cannot redefine non-configurable property".to_string());
}
if desc.enumerable != current.enumerable {
return Err("Cannot redefine non-configurable property".to_string());
}
if desc.is_accessor_descriptor() {
if current.is_data_descriptor() {
return Err(
"Cannot redefine non-configurable property: accessor over data".to_string(),
);
}
if let (Some(d), Some(c)) = (&desc.getter, ¤t.getter) {
if !same_value(d, c) {
return Err("Cannot redefine non-configurable property: different getter"
.to_string());
}
}
if let (Some(d), Some(c)) = (&desc.setter, ¤t.setter) {
if !same_value(d, c) {
return Err("Cannot redefine non-configurable property: different setter"
.to_string());
}
}
if desc.getter.is_some() && current.getter.is_none() {
return Err("Cannot redefine non-configurable property: added getter".to_string());
}
if desc.setter.is_some() && current.setter.is_none() {
return Err("Cannot redefine non-configurable property: added setter".to_string());
}
return Ok(());
}
if current.is_accessor_descriptor() {
return Err(
"Cannot redefine non-configurable property: data over accessor".to_string(),
);
}
if !current.writable {
if !same_value(&desc.value, ¤t.value) {
return Err(
"Cannot redefine the value of a non-writable property".to_string(),
);
}
if desc.writable {
return Err("Cannot make a non-writable property writable".to_string());
}
}
Ok(())
}
#[derive(Debug, Clone)]
pub struct OrdinaryObject {
properties: PropertyTable,
prototype: Option<Rc<RefCell<dyn JSObject>>>,
extensible: bool,
frozen: bool,
sealed: bool,
class_name: &'static str,
}
impl OrdinaryObject {
pub fn new() -> Self {
Self {
properties: PropertyTable::new(),
prototype: None,
extensible: true,
frozen: false,
sealed: false,
class_name: "Object",
}
}
pub fn with_class_name(class_name: &'static str) -> Self {
Self {
class_name,
..Self::new()
}
}
pub fn with_prototype(proto: Rc<RefCell<dyn JSObject>>) -> Self {
Self {
properties: PropertyTable::new(),
prototype: Some(proto),
extensible: true,
frozen: false,
sealed: false,
class_name: "Object",
}
}
pub fn from_map(map: BTreeMap<PropertyKey, Value>) -> Self {
let properties = map
.into_iter()
.map(|(k, v)| (k, PropertyDescriptor::data_descriptor(v)))
.collect();
Self {
properties,
prototype: None,
extensible: true,
frozen: false,
sealed: false,
class_name: "Object",
}
}
pub fn define_property(
&mut self,
key: PropertyKey,
desc: PropertyDescriptor,
) -> Result<bool, String> {
let current = self.properties.get(&key).cloned();
match current {
None => {
if !self.extensible {
return Err("Cannot add property to non-extensible object".to_string());
}
}
Some(current) => validate_property_redefinition(¤t, &desc)?,
}
self.properties.insert(key, desc);
Ok(true)
}
}
impl JSObject for OrdinaryObject {
fn kind(&self) -> ObjectKind {
ObjectKind::Ordinary
}
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
fn property_get(&self, key: &PropertyKey) -> Option<PropertyDescriptor> {
self.properties.get(key).cloned()
}
fn property_set(&mut self, key: PropertyKey, value: Value) -> Result<bool, String> {
if self.frozen {
return Err("Cannot set property on frozen object".to_string());
}
if let Some(desc) = self.properties.get_mut(&key) {
if !desc.writable {
return Err("Cannot assign to read-only property".to_string());
}
desc.value = value;
Ok(true)
} else {
if !self.extensible {
return Err("Cannot add property to non-extensible object".to_string());
}
self.properties
.insert(key, PropertyDescriptor::data_descriptor(value));
Ok(true)
}
}
fn define_property(
&mut self,
key: PropertyKey,
desc: PropertyDescriptor,
) -> Result<bool, String> {
OrdinaryObject::define_property(self, key, desc)
}
fn property_delete(&mut self, key: &PropertyKey) -> bool {
if self.frozen || self.sealed {
return false;
}
if let Some(desc) = self.properties.get(key) {
if !desc.configurable {
return false;
}
}
self.properties.remove(key).is_some()
}
fn has_property(&self, key: &PropertyKey) -> bool {
self.properties.contains_key(key)
}
fn own_keys(&self) -> Vec<PropertyKey> {
self.properties.keys()
}
fn get_prototype(&self) -> Option<Rc<RefCell<dyn JSObject>>> {
self.prototype.clone()
}
fn set_prototype(&mut self, proto: Option<Rc<RefCell<dyn JSObject>>>) {
if !self.frozen {
self.prototype = proto;
}
}
fn is_extensible(&self) -> bool {
self.extensible
}
fn prevent_extensions(&mut self) {
self.extensible = false;
}
fn is_frozen(&self) -> bool {
self.frozen
}
fn freeze(&mut self) {
self.frozen = true;
self.extensible = false;
self.sealed = true;
for key in self.properties.keys() {
if let Some(desc) = self.properties.get_mut(&key) {
desc.configurable = false;
if desc.is_data_descriptor() {
desc.writable = false;
}
}
}
}
fn is_sealed(&self) -> bool {
self.sealed
}
fn seal(&mut self) {
self.sealed = true;
self.extensible = false;
for key in self.properties.keys() {
if let Some(desc) = self.properties.get_mut(&key) {
desc.configurable = false;
}
}
}
fn class_name(&self) -> &'static str {
self.class_name
}
}
impl Default for OrdinaryObject {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone)]
pub struct ArrayObject {
elements: Vec<Value>,
properties: PropertyTable,
holes: std::collections::BTreeSet<usize>,
length_writable: bool,
prototype: Option<Rc<RefCell<dyn JSObject>>>,
extensible: bool,
frozen: bool,
sealed: bool,
}
impl ArrayObject {
pub fn new() -> Self {
Self {
elements: Vec::new(),
properties: PropertyTable::new(),
holes: std::collections::BTreeSet::new(),
length_writable: true,
prototype: crate::builtins::wrapper_prototype("Array"),
extensible: true,
frozen: false,
sealed: false,
}
}
pub fn length_is_writable(&self) -> bool {
self.length_writable && !self.frozen
}
pub fn with_capacity(cap: usize) -> Self {
Self {
elements: Vec::with_capacity(cap),
properties: PropertyTable::new(),
holes: std::collections::BTreeSet::new(),
length_writable: true,
prototype: crate::builtins::wrapper_prototype("Array"),
extensible: true,
frozen: false,
sealed: false,
}
}
pub fn from_vec(vec: Vec<Value>) -> Self {
Self {
elements: vec,
properties: PropertyTable::new(),
holes: std::collections::BTreeSet::new(),
length_writable: true,
prototype: crate::builtins::wrapper_prototype("Array"),
extensible: true,
frozen: false,
sealed: false,
}
}
pub fn push(&mut self, value: Value) {
self.elements.push(value);
}
pub fn len(&self) -> usize {
self.elements.len()
}
pub fn get(&self, index: usize) -> Option<&Value> {
self.elements.get(index)
}
pub fn get_mut(&mut self, index: usize) -> Option<&mut Value> {
self.elements.get_mut(index)
}
pub fn join_elements(&self) -> String {
self.join(",")
}
pub fn mark_hole(&mut self, index: usize) {
if index < self.elements.len() {
self.elements[index] = Value::Undefined;
}
self.properties.remove(&Self::index_key(index));
self.holes.insert(index);
}
fn drop_index_property_entries(&mut self) {
self.holes.clear();
let index_keys: Vec<PropertyKey> = self
.properties
.keys()
.into_iter()
.filter(|k| {
k.as_str()
.map(|s| s.parse::<usize>().is_ok())
.unwrap_or(false)
})
.collect();
for key in index_keys {
self.properties.remove(&key);
}
}
pub fn pop(&mut self) -> Value {
self.elements.pop().unwrap_or(Value::Undefined)
}
pub fn shift(&mut self) -> Value {
if self.elements.is_empty() {
return Value::Undefined;
}
let value = Some(self.elements.remove(0)).unwrap_or(Value::Undefined);
self.drop_index_property_entries();
value
}
pub fn unshift(&mut self, value: Value) -> f64 {
self.elements.insert(0, value);
self.drop_index_property_entries();
self.elements.len() as f64
}
pub fn index_of(&self, needle: &Value, from_index: usize) -> isize {
for i in from_index..self.elements.len() {
if self.elements[i].strict_eq(needle) {
return i as isize;
}
}
-1
}
pub fn includes(&self, needle: &Value) -> bool {
self.elements.iter().any(|v| v.strict_eq(needle))
}
pub fn reverse(&mut self) {
self.elements.reverse();
self.drop_index_property_entries();
}
pub fn replace_elements(&mut self, elements: Vec<Value>) {
self.elements = elements;
self.drop_index_property_entries();
}
pub fn join(&self, separator: &str) -> String {
self.elements
.iter()
.map(|v| match v {
Value::Undefined | Value::Null => String::new(),
other => other.to_js_string(),
})
.collect::<Vec<_>>()
.join(separator)
}
pub fn slice(&self, start: usize, end: usize) -> Self {
if start >= self.elements.len() {
return Self::new();
}
let end = end.min(self.elements.len());
if end <= start {
return Self::new();
}
Self::from_vec(self.elements[start..end].to_vec())
}
pub fn concat(&self, other: &[Value]) -> Self {
let mut new_elements = self.elements.clone();
new_elements.extend_from_slice(other);
Self::from_vec(new_elements)
}
pub fn splice(
&mut self,
start: usize,
delete_count: usize,
insert_items: &[Value],
) -> Vec<Value> {
let end = (start + delete_count).min(self.elements.len());
let removed: Vec<Value> = self.elements.drain(start..end).collect();
let mut pos = start;
for item in insert_items {
self.elements.insert(pos, item.clone());
pos += 1;
}
self.drop_index_property_entries();
removed
}
pub fn is_empty(&self) -> bool {
self.elements.is_empty()
}
fn index_key(index: usize) -> PropertyKey {
PropertyKey::Str(std::rc::Rc::new(index.to_string()))
}
}
impl JSObject for ArrayObject {
fn kind(&self) -> ObjectKind {
ObjectKind::Array
}
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
fn property_get(&self, key: &PropertyKey) -> Option<PropertyDescriptor> {
match key {
PropertyKey::Str(s) if s.as_str() == "length" => {
Some(PropertyDescriptor {
value: Value::Number(self.elements.len() as f64),
writable: self.length_writable,
enumerable: false,
configurable: false,
getter: None,
setter: None,
})
}
PropertyKey::Str(_) if self.properties.contains_key(key) => {
self.properties.get(key).cloned()
}
PropertyKey::Str(s) => {
if let Ok(idx) = s.parse::<usize>() {
if self.holes.contains(&idx) {
return None;
}
self.elements
.get(idx)
.map(|v| PropertyDescriptor::data_descriptor(v.clone()))
} else {
self.properties.get(key).cloned()
}
}
_ => self.properties.get(key).cloned(),
}
}
fn property_set(&mut self, key: PropertyKey, value: Value) -> Result<bool, String> {
if self.frozen {
return Err("Cannot set property on frozen array".to_string());
}
match &key {
PropertyKey::Str(s) if s.as_str() == "length" => {
if !self.length_writable {
return Err("Cannot assign to read-only property 'length'".to_string());
}
let n = value.to_number();
let new_len = crate::builtins::validate_array_length(n)
.map_err(|_| "Invalid array length".to_string())?;
self.elements.resize(new_len, Value::Undefined);
Ok(true)
}
PropertyKey::Str(s) if self.properties.contains_key(&key) => {
let idx = s.parse::<usize>().ok();
let desc = self.properties.get_mut(&key).expect("checked above");
if desc.is_accessor_descriptor() {
return Err("Cannot assign to accessor property".to_string());
}
if !desc.writable {
return Err("Cannot assign to read-only property".to_string());
}
desc.value = value.clone();
if let Some(idx) = idx {
if let Some(slot) = self.elements.get_mut(idx) {
*slot = value;
}
}
Ok(true)
}
PropertyKey::Str(s) => {
if let Ok(idx) = s.parse::<usize>() {
if idx >= MAX_DENSE_ELEMENTS {
return Err(format!(
"Array index {idx} is out of the supported range"
));
}
if idx >= self.elements.len() {
self.elements.resize(idx + 1, Value::Undefined);
}
self.holes.remove(&idx);
self.elements[idx] = value;
Ok(true)
} else if let Some(existing) = self.properties.get(&key) {
if !existing.writable {
return Err("Cannot assign to read-only property".to_string());
}
self.properties
.insert(key, PropertyDescriptor::data_descriptor(value));
Ok(true)
} else if !self.extensible {
Err("Cannot add property to non-extensible array".to_string())
} else {
self.properties
.insert(key, PropertyDescriptor::data_descriptor(value));
Ok(true)
}
}
_ => {
if let Some(existing) = self.properties.get(&key) {
if !existing.writable {
return Err("Cannot assign to read-only property".to_string());
}
} else if !self.extensible {
return Err("Cannot add property to non-extensible array".to_string());
}
self.properties
.insert(key, PropertyDescriptor::data_descriptor(value));
Ok(true)
}
}
}
fn define_property(
&mut self,
key: PropertyKey,
desc: PropertyDescriptor,
) -> Result<bool, String> {
if self.frozen {
return Err("Cannot define property on frozen array".to_string());
}
match &key {
PropertyKey::Str(s) if s.as_str() == "length" => {
if desc.is_accessor_descriptor() {
return Err("Cannot redefine property: length".to_string());
}
if desc.configurable {
return Err("Cannot redefine property: length is non-configurable".to_string());
}
let n = desc.value.to_number();
let new_len = crate::builtins::validate_array_length(n)
.map_err(|_| "Invalid array length".to_string())?;
if !self.length_writable && new_len != self.elements.len() {
return Err("Cannot redefine property: length is non-writable".to_string());
}
self.length_writable = desc.writable;
self.elements.resize(new_len, Value::Undefined);
self.holes.retain(|&i| i < new_len);
let stale: Vec<PropertyKey> = self
.properties
.keys()
.into_iter()
.filter(|k| {
k.as_str()
.and_then(|s| s.parse::<usize>().ok())
.is_some_and(|i| i >= new_len)
})
.collect();
for k in stale {
self.properties.remove(&k);
}
Ok(true)
}
PropertyKey::Str(s) => {
if let Ok(idx) = s.parse::<usize>() {
if idx >= MAX_DENSE_ELEMENTS {
return Err(format!(
"Array index {idx} is out of the supported range"
));
}
let current = self.property_get(&key);
match current {
Some(current) => validate_property_redefinition(¤t, &desc)?,
None if !self.extensible => {
return Err("Cannot add property to non-extensible array".to_string());
}
None => {}
}
if desc.is_accessor_descriptor() {
if idx >= self.elements.len() {
self.elements.resize(idx + 1, Value::Undefined);
}
self.elements[idx] = Value::Undefined;
self.holes.insert(idx);
self.properties.insert(key, desc);
return Ok(true);
}
if idx >= self.elements.len() {
self.elements.resize(idx + 1, Value::Undefined);
}
self.elements[idx] = desc.value.clone();
if desc.writable && desc.enumerable && desc.configurable {
self.properties.remove(&key);
self.holes.remove(&idx);
} else {
self.properties.insert(key, desc);
}
Ok(true)
} else {
let current = self.property_get(&key);
match current {
Some(current) => validate_property_redefinition(¤t, &desc)?,
None if !self.extensible => {
return Err("Cannot add property to non-extensible array".to_string());
}
None => {}
}
self.properties.insert(key, desc);
Ok(true)
}
}
_ => {
let current = self.property_get(&key);
match current {
Some(current) => validate_property_redefinition(¤t, &desc)?,
None if !self.extensible => {
return Err("Cannot add property to non-extensible array".to_string());
}
None => {}
}
self.properties.insert(key, desc);
Ok(true)
}
}
}
fn property_delete(&mut self, key: &PropertyKey) -> bool {
if self.frozen || self.sealed {
return false;
}
if let PropertyKey::Str(s) = key {
if s.as_str() == "length" {
return false;
}
if let Ok(idx) = s.parse::<usize>() {
if let Some(desc) = self.properties.get(key) {
if !desc.configurable {
return false;
}
}
if idx < self.elements.len() {
self.properties.remove(key);
self.elements[idx] = Value::Undefined;
self.holes.insert(idx);
return true;
}
return self.properties.remove(key).is_some();
}
}
if let Some(desc) = self.properties.get(key) {
if !desc.configurable {
return false;
}
}
self.properties.remove(key).is_some()
}
fn has_property(&self, key: &PropertyKey) -> bool {
match key {
PropertyKey::Str(s) if s.as_str() == "length" => true,
PropertyKey::Str(s) => {
if self.properties.contains_key(key) {
return true;
}
s.parse::<usize>().is_ok_and(|i| {
i < self.elements.len() && !self.holes.contains(&i)
})
}
_ => self.properties.contains_key(key),
}
}
fn own_keys(&self) -> Vec<PropertyKey> {
let mut keys: Vec<PropertyKey> = self
.elements
.iter()
.enumerate()
.filter(|(i, _)| {
!self.holes.contains(i)
&& !self.properties.contains_key(&Self::index_key(*i))
})
.map(|(i, _)| Self::index_key(i))
.collect();
keys.push(PropertyKey::from_str("length"));
keys.extend(self.properties.keys());
keys
}
fn get_prototype(&self) -> Option<Rc<RefCell<dyn JSObject>>> {
self.prototype.clone()
}
fn set_prototype(&mut self, proto: Option<Rc<RefCell<dyn JSObject>>>) {
if !self.frozen {
self.prototype = proto;
}
}
fn is_extensible(&self) -> bool {
self.extensible
}
fn prevent_extensions(&mut self) {
self.extensible = false;
}
fn is_frozen(&self) -> bool {
self.frozen
}
fn freeze(&mut self) {
self.frozen = true;
self.extensible = false;
self.sealed = true;
for key in self.properties.keys() {
if let Some(desc) = self.properties.get_mut(&key) {
desc.configurable = false;
if desc.is_data_descriptor() {
desc.writable = false;
}
}
}
for i in 0..self.elements.len() {
if self.holes.contains(&i) || self.properties.contains_key(&Self::index_key(i)) {
continue;
}
let desc = PropertyDescriptor {
value: self.elements[i].clone(),
writable: false,
enumerable: true,
configurable: false,
getter: None,
setter: None,
};
self.properties.insert(Self::index_key(i), desc);
}
self.length_writable = false;
}
fn is_sealed(&self) -> bool {
self.sealed
}
fn seal(&mut self) {
self.sealed = true;
self.extensible = false;
for key in self.properties.keys() {
if let Some(desc) = self.properties.get_mut(&key) {
desc.configurable = false;
}
}
}
fn type_of(&self) -> &'static str {
"object"
}
fn class_name(&self) -> &'static str {
"Array"
}
fn to_primitive(&self, _hint: &str) -> Result<Value, String> {
Ok(Value::string(&self.join_elements()))
}
}
impl Default for ArrayObject {
fn default() -> Self {
Self::new()
}
}
pub fn new_ordinary_object() -> Value {
Value::Object(Rc::new(RefCell::new(OrdinaryObject::new())))
}
pub fn new_ordinary_object_with_prototype(proto: Rc<RefCell<dyn JSObject>>) -> Value {
Value::Object(Rc::new(RefCell::new(OrdinaryObject::with_prototype(proto))))
}
pub fn new_array_object() -> Value {
Value::Object(Rc::new(RefCell::new(ArrayObject::new())))
}
pub fn new_array_object_from_vec(vec: Vec<Value>) -> Value {
Value::Object(Rc::new(RefCell::new(ArrayObject::from_vec(vec))))
}
#[derive(Debug)]
pub struct FunctionObject {
pub func_id: u32,
pub name: String,
properties: PropertyTable,
prototype: Option<Rc<RefCell<dyn JSObject>>>,
pub captured_this: Option<Value>,
pub captured_new_target: Option<Value>,
pub captured_vars: Vec<(String, Value)>,
}
impl FunctionObject {
pub fn new(func_id: u32, name: &str) -> Self {
Self {
func_id,
name: name.to_string(),
properties: PropertyTable::new(),
prototype: None,
captured_this: None,
captured_new_target: None,
captured_vars: Vec::new(),
}
}
pub fn new_arrow(
func_id: u32,
name: &str,
captured_this: Value,
captured_vars: Vec<(String, Value)>,
) -> Self {
Self {
func_id,
name: name.to_string(),
properties: PropertyTable::new(),
prototype: None,
captured_this: Some(captured_this),
captured_new_target: None,
captured_vars,
}
}
}
impl JSObject for FunctionObject {
fn kind(&self) -> ObjectKind {
ObjectKind::Function
}
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
fn property_get(&self, key: &PropertyKey) -> Option<PropertyDescriptor> {
self.properties.get(key).cloned()
}
fn property_set(&mut self, key: PropertyKey, value: Value) -> Result<bool, String> {
self.properties
.insert(key, PropertyDescriptor::data_descriptor(value));
Ok(true)
}
fn define_property(
&mut self,
key: PropertyKey,
desc: PropertyDescriptor,
) -> Result<bool, String> {
self.properties.insert(key, desc);
Ok(true)
}
fn property_delete(&mut self, key: &PropertyKey) -> bool {
self.properties.remove(key).is_some()
}
fn has_property(&self, key: &PropertyKey) -> bool {
self.properties.contains_key(key)
}
fn own_keys(&self) -> Vec<PropertyKey> {
self.properties.keys()
}
fn get_prototype(&self) -> Option<Rc<RefCell<dyn JSObject>>> {
self.prototype.clone()
}
fn set_prototype(&mut self, proto: Option<Rc<RefCell<dyn JSObject>>>) {
self.prototype = proto;
}
fn is_extensible(&self) -> bool {
true
}
fn prevent_extensions(&mut self) {}
fn is_frozen(&self) -> bool {
false
}
fn freeze(&mut self) {}
fn is_sealed(&self) -> bool {
false
}
fn seal(&mut self) {}
fn type_of(&self) -> &'static str {
"function"
}
fn class_name(&self) -> &'static str {
"Function"
}
}
pub fn new_function_object(func_id: u32, name: &str, arity: usize) -> Value {
let func_obj = FunctionObject::new(func_id, name);
let obj_ref: Rc<RefCell<dyn JSObject>> = Rc::new(RefCell::new(func_obj));
fn fn_meta(value: Value) -> PropertyDescriptor {
PropertyDescriptor {
value,
writable: false,
enumerable: false,
configurable: true,
getter: None,
setter: None,
}
}
obj_ref.borrow_mut().define_property(
crate::vm::property::PropertyKey::from_str("length"),
fn_meta(Value::Number(arity as f64)),
)
.ok();
obj_ref.borrow_mut().define_property(
crate::vm::property::PropertyKey::from_str("name"),
fn_meta(Value::string(name)),
)
.ok();
let proto_obj = match crate::builtins::wrapper_prototype("Object") {
Some(object_proto) => new_ordinary_object_with_prototype(object_proto),
None => new_ordinary_object(),
};
if let Value::Object(ref proto_ref) = proto_obj {
proto_ref.borrow_mut().define_property(
crate::vm::property::PropertyKey::from_str("constructor"),
PropertyDescriptor {
value: Value::Function(func_id),
writable: true,
enumerable: false,
configurable: true,
getter: None,
setter: None,
},
)
.ok();
obj_ref
.borrow_mut()
.define_property(
crate::vm::property::PropertyKey::from("prototype"),
PropertyDescriptor {
value: proto_obj.clone(),
writable: true,
enumerable: false,
configurable: false,
getter: None,
setter: None,
},
)
.ok();
}
Value::Object(obj_ref)
}
pub fn new_arrow_function_object(
func_id: u32,
name: &str,
arity: usize,
captured_this: Value,
captured_new_target: Value,
captured_vars: Vec<(String, Value)>,
) -> Value {
let mut func_obj = FunctionObject::new_arrow(func_id, name, captured_this, captured_vars);
func_obj.captured_new_target = Some(captured_new_target);
let obj_ref: Rc<RefCell<dyn JSObject>> = Rc::new(RefCell::new(func_obj));
let mut borrowed = obj_ref.borrow_mut();
borrowed
.define_property(
PropertyKey::from_str("length"),
function_metadata_descriptor(Value::Number(arity as f64)),
)
.ok();
borrowed
.define_property(
PropertyKey::from_str("name"),
function_metadata_descriptor(Value::string(name)),
)
.ok();
drop(borrowed);
Value::Object(obj_ref)
}
#[derive(Debug)]
pub struct NativeFunctionObject {
pub name: String,
prototype: Option<Rc<RefCell<dyn JSObject>>>,
properties: PropertyTable,
}
impl NativeFunctionObject {
pub fn new(name: &str) -> Self {
let mut obj = Self {
name: name.to_string(),
prototype: crate::builtins::wrapper_prototype("Function"),
properties: PropertyTable::new(),
};
obj.install_metadata();
obj
}
fn install_metadata(&mut self) {
let display = if let Some(method) = self.name.strip_prefix(crate::builtins::PROTO_METHOD_PREFIX)
{
method.to_string()
} else if self.name == crate::vm::iterator::ITERATOR_NATIVE_NAME {
"[Symbol.iterator]".to_string()
} else if self.name == crate::builtins::ARRAY_SPECIES_NATIVE {
"get [Symbol.species]".to_string()
} else {
self.name
.rsplit('.')
.next()
.unwrap_or(&self.name)
.to_string()
};
self.set_length(crate::builtins::builtin_arity(&self.name));
self.properties.insert(
PropertyKey::from_str("name"),
function_metadata_descriptor(Value::string(&display)),
);
}
pub fn set_length(&mut self, length: usize) {
self.properties.insert(
PropertyKey::from_str("length"),
function_metadata_descriptor(Value::Number(length as f64)),
);
}
}
pub(crate) fn function_metadata_descriptor(value: Value) -> PropertyDescriptor {
PropertyDescriptor {
value,
writable: false,
enumerable: false,
configurable: true,
getter: None,
setter: None,
}
}
impl JSObject for NativeFunctionObject {
fn kind(&self) -> ObjectKind {
ObjectKind::NativeFunction
}
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
fn property_get(&self, key: &PropertyKey) -> Option<PropertyDescriptor> {
self.properties.get(key).cloned()
}
fn property_set(&mut self, key: PropertyKey, value: Value) -> Result<bool, String> {
self.properties
.insert(key, PropertyDescriptor::data_descriptor(value));
Ok(true)
}
fn define_property(
&mut self,
key: PropertyKey,
desc: PropertyDescriptor,
) -> Result<bool, String> {
self.properties.insert(key, desc);
Ok(true)
}
fn property_delete(&mut self, key: &PropertyKey) -> bool {
self.properties.remove(key).is_some()
}
fn has_property(&self, key: &PropertyKey) -> bool {
self.properties.contains_key(key)
}
fn own_keys(&self) -> Vec<PropertyKey> {
self.properties.keys()
}
fn get_prototype(&self) -> Option<Rc<RefCell<dyn JSObject>>> {
self.prototype.clone()
}
fn set_prototype(&mut self, proto: Option<Rc<RefCell<dyn JSObject>>>) {
self.prototype = proto;
}
fn is_extensible(&self) -> bool {
false
}
fn prevent_extensions(&mut self) {}
fn is_frozen(&self) -> bool {
false
}
fn freeze(&mut self) {}
fn is_sealed(&self) -> bool {
false
}
fn seal(&mut self) {}
fn type_of(&self) -> &'static str {
"function"
}
fn class_name(&self) -> &'static str {
"Function"
}
}
#[derive(Debug)]
pub struct PrimitiveWrapperObject {
primitive: Value,
properties: PropertyTable,
prototype: Option<Rc<RefCell<dyn JSObject>>>,
extensible: bool,
}
impl PrimitiveWrapperObject {
pub fn new(primitive: Value, prototype: Option<Rc<RefCell<dyn JSObject>>>) -> Self {
Self {
primitive,
properties: PropertyTable::new(),
prototype,
extensible: true,
}
}
fn string_len(&self) -> usize {
match &self.primitive {
Value::String(s) => s.chars().count(),
_ => 0,
}
}
}
impl JSObject for PrimitiveWrapperObject {
fn kind(&self) -> ObjectKind {
match &self.primitive {
Value::String(_) => ObjectKind::String,
Value::Number(_) => ObjectKind::Number,
Value::Bool(_) => ObjectKind::Boolean,
Value::Symbol(_) => ObjectKind::Symbol,
_ => ObjectKind::Ordinary,
}
}
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
fn property_get(&self, key: &PropertyKey) -> Option<PropertyDescriptor> {
if let Value::String(s) = &self.primitive {
if let PropertyKey::Str(k) = key {
if k.as_str() == "length" {
return Some(PropertyDescriptor {
value: Value::Number(s.chars().count() as f64),
writable: false,
enumerable: false,
configurable: false,
getter: None,
setter: None,
});
}
if let Ok(idx) = k.parse::<usize>() {
return s.chars().nth(idx).map(|c| PropertyDescriptor {
value: Value::string(&c.to_string()),
writable: false,
enumerable: true,
configurable: false,
getter: None,
setter: None,
});
}
}
}
self.properties.get(key).cloned()
}
fn property_set(&mut self, key: PropertyKey, value: Value) -> Result<bool, String> {
if matches!(self.primitive, Value::String(_)) {
if let PropertyKey::Str(s) = &key {
if s.as_str() == "length" || s.parse::<usize>().is_ok() {
return Err(
"Cannot assign to read-only property of a String wrapper".to_string()
);
}
}
}
self.properties
.insert(key, PropertyDescriptor::data_descriptor(value));
Ok(true)
}
fn define_property(
&mut self,
key: PropertyKey,
desc: PropertyDescriptor,
) -> Result<bool, String> {
self.properties.insert(key, desc);
Ok(true)
}
fn property_delete(&mut self, key: &PropertyKey) -> bool {
if matches!(self.primitive, Value::String(_)) {
if let PropertyKey::Str(s) = key {
if s.as_str() == "length" || s.parse::<usize>().is_ok() {
return false;
}
}
}
self.properties.remove(key).is_some()
}
fn has_property(&self, key: &PropertyKey) -> bool {
if let PropertyKey::Str(s) = key {
if matches!(self.primitive, Value::String(_)) {
if s.as_str() == "length" {
return true;
}
if let Ok(idx) = s.parse::<usize>() {
return idx < self.string_len();
}
}
}
self.properties.contains_key(key)
}
fn own_keys(&self) -> Vec<PropertyKey> {
let mut keys: Vec<PropertyKey> = Vec::new();
if let Value::String(s) = &self.primitive {
for i in 0..s.chars().count() {
keys.push(PropertyKey::Str(Rc::new(i.to_string())));
}
}
keys.extend(self.properties.keys());
if matches!(self.primitive, Value::String(_)) {
keys.push(PropertyKey::from_str("length"));
}
keys
}
fn get_prototype(&self) -> Option<Rc<RefCell<dyn JSObject>>> {
self.prototype.clone()
}
fn set_prototype(&mut self, proto: Option<Rc<RefCell<dyn JSObject>>>) {
self.prototype = proto;
}
fn is_extensible(&self) -> bool {
self.extensible
}
fn prevent_extensions(&mut self) {
self.extensible = false;
}
fn is_frozen(&self) -> bool {
false
}
fn freeze(&mut self) {
self.extensible = false;
}
fn is_sealed(&self) -> bool {
false
}
fn seal(&mut self) {
self.extensible = false;
}
fn class_name(&self) -> &'static str {
match &self.primitive {
Value::String(_) => "String",
Value::Number(_) => "Number",
Value::Bool(_) => "Boolean",
Value::Symbol(_) => "Symbol",
_ => "Object",
}
}
fn to_primitive(&self, _hint: &str) -> Result<Value, String> {
Ok(self.primitive.clone())
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum GeneratorState {
SuspendedStart,
SuspendedYield,
Executing,
Completed,
}
#[derive(Debug, Clone)]
pub struct SuspendedFrame {
pub data: Vec<Value>,
pub argc: usize,
pub bp_offset: usize,
pub pc: usize,
pub this: Value,
pub function_val: Value,
pub closure_maps: Vec<std::collections::HashMap<String, Value>>,
pub registers: [Value; 19],
}
#[derive(Debug)]
pub struct GeneratorObject {
pub id: u64,
pub func_id: u32,
pub state: GeneratorState,
pub args: Vec<Value>,
pub this: Value,
pub captured_new_target: Option<Value>,
pub captured_vars: Vec<(String, Value)>,
pub suspended: Option<SuspendedFrame>,
prototype: Option<Rc<RefCell<dyn JSObject>>>,
}
impl GeneratorObject {
pub fn new(id: u64, func_id: u32, args: Vec<Value>, this: Value) -> Self {
Self {
id,
func_id,
state: GeneratorState::SuspendedStart,
args,
this,
captured_new_target: None,
captured_vars: Vec::new(),
suspended: None,
prototype: None,
}
}
}
impl JSObject for GeneratorObject {
fn kind(&self) -> ObjectKind {
ObjectKind::Generator
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
self
}
fn property_get(&self, key: &PropertyKey) -> Option<PropertyDescriptor> {
if *key == crate::vm::iterator::iterator_symbol_key() {
return Some(PropertyDescriptor::data_descriptor(Value::Object(
Rc::new(RefCell::new(NativeFunctionObject::new(&format!(
"{}{}",
crate::vm::iterator::GENERATOR_ITERATOR_PREFIX,
self.id
)))),
)));
}
let native_name = match key.as_str() {
Some("next") => format!(
"{}{}",
crate::vm::iterator::GENERATOR_NEXT_PREFIX,
self.id
),
_ => return None,
};
Some(PropertyDescriptor::data_descriptor(Value::Object(
Rc::new(RefCell::new(NativeFunctionObject::new(&native_name))),
)))
}
fn property_set(&mut self, _key: PropertyKey, _value: Value) -> Result<bool, String> {
Ok(true)
}
fn define_property(
&mut self,
_key: PropertyKey,
_desc: PropertyDescriptor,
) -> Result<bool, String> {
Ok(true)
}
fn property_delete(&mut self, _key: &PropertyKey) -> bool {
true
}
fn has_property(&self, key: &PropertyKey) -> bool {
*key == crate::vm::iterator::iterator_symbol_key()
|| matches!(key.as_str(), Some("next"))
}
fn own_keys(&self) -> Vec<PropertyKey> {
vec![PropertyKey::from_str("next")]
}
fn get_prototype(&self) -> Option<Rc<RefCell<dyn JSObject>>> {
self.prototype.clone()
}
fn set_prototype(&mut self, proto: Option<Rc<RefCell<dyn JSObject>>>) {
self.prototype = proto;
}
fn is_extensible(&self) -> bool {
true
}
fn prevent_extensions(&mut self) {}
fn is_frozen(&self) -> bool {
false
}
fn freeze(&mut self) {}
fn is_sealed(&self) -> bool {
false
}
fn seal(&mut self) {}
fn class_name(&self) -> &'static str {
"Generator"
}
fn to_primitive(&self, _hint: &str) -> Result<Value, String> {
Ok(Value::string("[object Generator]"))
}
}