mustardscript 0.1.0

package/crates/mustard/src/runtime/builtins/collections.rs

@@ -0,0 +1,573 @@
+use crate::runtime::properties::canonicalize_collection_key;
+
+use super::*;
+
+impl Runtime {
+    pub(crate) fn construct_map(&mut self, args: &[Value]) -> MustardResult<Value> {
+        let map = self.insert_map(Vec::new())?;
+        let iterable = args.first().cloned().unwrap_or(Value::Undefined);
+        if matches!(iterable, Value::Null | Value::Undefined) {
+            return Ok(Value::Map(map));
+        }
+
+        let iterator = self.create_iterator(iterable)?;
+        loop {
+            let (entry, done) = self.iterator_next(iterator.clone())?;
+            if done {
+                break;
+            }
+            let items: Vec<Value> = match entry {
+                Value::Array(array) => self
+                    .arrays
+                    .get(array)
+                    .ok_or_else(|| MustardError::runtime("array missing"))?
+                    .elements
+                    .iter()
+                    .map(|value| value.clone().unwrap_or(Value::Undefined))
+                    .collect(),
+                _ => {
+                    return Err(MustardError::runtime(
+                        "TypeError: Map constructor expects an iterable of [key, value] pairs",
+                    ));
+                }
+            };
+            let key = items.first().cloned().unwrap_or(Value::Undefined);
+            let value = items.get(1).cloned().unwrap_or(Value::Undefined);
+            self.map_set(map, key, value)?;
+        }
+
+        Ok(Value::Map(map))
+    }
+
+    pub(crate) fn construct_set(&mut self, args: &[Value]) -> MustardResult<Value> {
+        let set = self.insert_set(Vec::new())?;
+        let iterable = args.first().cloned().unwrap_or(Value::Undefined);
+        if matches!(iterable, Value::Null | Value::Undefined) {
+            return Ok(Value::Set(set));
+        }
+
+        let iterator = self.create_iterator(iterable)?;
+        loop {
+            let (value, done) = self.iterator_next(iterator.clone())?;
+            if done {
+                break;
+            }
+            self.set_add(set, value)?;
+        }
+
+        Ok(Value::Set(set))
+    }
+
+    fn map_receiver(&self, value: Value, method: &str) -> MustardResult<MapKey> {
+        match value {
+            Value::Map(key) => Ok(key),
+            _ => Err(MustardError::runtime(format!(
+                "TypeError: Map.prototype.{method} called on incompatible receiver",
+            ))),
+        }
+    }
+
+    fn set_receiver(&self, value: Value, method: &str) -> MustardResult<SetKey> {
+        match value {
+            Value::Set(key) => Ok(key),
+            _ => Err(MustardError::runtime(format!(
+                "TypeError: Set.prototype.{method} called on incompatible receiver",
+            ))),
+        }
+    }
+
+    fn iterator_receiver(&self, value: Value, method: &str) -> MustardResult<IteratorKey> {
+        match value {
+            Value::Iterator(key) => Ok(key),
+            _ => Err(MustardError::runtime(format!(
+                "TypeError: iterator.{method} called on incompatible receiver",
+            ))),
+        }
+    }
+
+    fn collection_callback(&self, method: &str, args: &[Value]) -> MustardResult<(Value, Value)> {
+        let callback = args.first().cloned().unwrap_or(Value::Undefined);
+        if !is_callable(&callback) {
+            return Err(MustardError::runtime(format!(
+                "TypeError: {method} expects a callable callback",
+            )));
+        }
+        let this_arg = args.get(1).cloned().unwrap_or(Value::Undefined);
+        Ok((callback, this_arg))
+    }
+
+    fn call_collection_callback(
+        &mut self,
+        method: &str,
+        callback: Value,
+        this_arg: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let host_suspension_message =
+            format!("TypeError: {method} does not support synchronous host suspensions");
+        let unsettled_message = format!("synchronous {method} callback did not settle");
+        self.call_callback(
+            callback,
+            this_arg,
+            args,
+            CallbackCallOptions {
+                non_callable_message: "TypeError: collection callback is not callable",
+                host_suspension_message: &host_suspension_message,
+                unsettled_message: &unsettled_message,
+                allow_host_suspension: false,
+                allow_pending_promise_result: false,
+            },
+        )
+    }
+
+    pub(crate) fn call_iterator_next(&mut self, this_value: Value) -> MustardResult<Value> {
+        let iterator = self.iterator_receiver(this_value, "next")?;
+        let (value, done) = self.iterator_next(Value::Iterator(iterator))?;
+        let result = self.insert_object(
+            IndexMap::from([
+                ("value".to_string(), value),
+                ("done".to_string(), Value::Bool(done)),
+            ]),
+            ObjectKind::Plain,
+        )?;
+        Ok(Value::Object(result))
+    }
+
+    fn map_get(&self, map: MapKey, key: &Value) -> MustardResult<Option<MapEntry>> {
+        let normalized = canonicalize_collection_key(key.clone());
+        Ok(self
+            .maps
+            .get(map)
+            .ok_or_else(|| MustardError::runtime("map missing"))?
+            .entries
+            .iter()
+            .find(|entry| same_value_zero(&entry.key, &normalized))
+            .cloned())
+    }
+
+    fn map_set(&mut self, map: MapKey, key: Value, value: Value) -> MustardResult<()> {
+        let key = canonicalize_collection_key(key);
+        {
+            let entries = &mut self
+                .maps
+                .get_mut(map)
+                .ok_or_else(|| MustardError::runtime("map missing"))?
+                .entries;
+            if let Some(entry) = entries
+                .iter_mut()
+                .find(|entry| same_value_zero(&entry.key, &key))
+            {
+                entry.value = value;
+            } else {
+                entries.push(MapEntry { key, value });
+            }
+        }
+        self.refresh_map_accounting(map)
+    }
+
+    fn adjust_map_iterators_after_delete(&mut self, map: MapKey, removed_index: usize) {
+        let iterator_keys: Vec<_> = self
+            .iterators
+            .iter()
+            .filter_map(|(key, iterator)| match &iterator.state {
+                IteratorState::MapEntries(state)
+                | IteratorState::MapKeys(state)
+                | IteratorState::MapValues(state)
+                    if state.map == map && removed_index < state.next_index =>
+                {
+                    Some(key)
+                }
+                _ => None,
+            })
+            .collect();
+        for key in iterator_keys {
+            if let Some(iterator) = self.iterators.get_mut(key) {
+                match &mut iterator.state {
+                    IteratorState::MapEntries(state)
+                    | IteratorState::MapKeys(state)
+                    | IteratorState::MapValues(state) => state.next_index -= 1,
+                    _ => unreachable!("filtered iterator kind changed unexpectedly"),
+                }
+            }
+        }
+    }
+
+    fn reset_map_iterators_after_clear(&mut self, map: MapKey) {
+        let iterator_keys: Vec<_> = self
+            .iterators
+            .iter()
+            .filter_map(|(key, iterator)| match &iterator.state {
+                IteratorState::MapEntries(state)
+                | IteratorState::MapKeys(state)
+                | IteratorState::MapValues(state)
+                    if state.map == map =>
+                {
+                    Some(key)
+                }
+                _ => None,
+            })
+            .collect();
+        for key in iterator_keys {
+            if let Some(iterator) = self.iterators.get_mut(key) {
+                match &mut iterator.state {
+                    IteratorState::MapEntries(state)
+                    | IteratorState::MapKeys(state)
+                    | IteratorState::MapValues(state) => state.next_index = 0,
+                    _ => unreachable!("filtered iterator kind changed unexpectedly"),
+                }
+            }
+        }
+    }
+
+    fn map_delete(&mut self, map: MapKey, key: &Value) -> MustardResult<bool> {
+        let normalized = canonicalize_collection_key(key.clone());
+        let removed_index = {
+            let entries = &mut self
+                .maps
+                .get_mut(map)
+                .ok_or_else(|| MustardError::runtime("map missing"))?
+                .entries;
+            if let Some(index) = entries
+                .iter()
+                .position(|entry| same_value_zero(&entry.key, &normalized))
+            {
+                entries.remove(index);
+                Some(index)
+            } else {
+                None
+            }
+        };
+        if let Some(index) = removed_index {
+            self.adjust_map_iterators_after_delete(map, index);
+            self.refresh_map_accounting(map)?;
+            return Ok(true);
+        }
+        Ok(false)
+    }
+
+    fn map_clear(&mut self, map: MapKey) -> MustardResult<()> {
+        self.maps
+            .get_mut(map)
+            .ok_or_else(|| MustardError::runtime("map missing"))?
+            .entries
+            .clear();
+        self.reset_map_iterators_after_clear(map);
+        self.refresh_map_accounting(map)
+    }
+
+    fn set_add(&mut self, set: SetKey, value: Value) -> MustardResult<()> {
+        let value = canonicalize_collection_key(value);
+        {
+            let entries = &mut self
+                .sets
+                .get_mut(set)
+                .ok_or_else(|| MustardError::runtime("set missing"))?
+                .entries;
+            if !entries.iter().any(|entry| same_value_zero(entry, &value)) {
+                entries.push(value);
+            }
+        }
+        self.refresh_set_accounting(set)
+    }
+
+    fn adjust_set_iterators_after_delete(&mut self, set: SetKey, removed_index: usize) {
+        let iterator_keys: Vec<_> = self
+            .iterators
+            .iter()
+            .filter_map(|(key, iterator)| match &iterator.state {
+                IteratorState::SetEntries(state) | IteratorState::SetValues(state)
+                    if state.set == set && removed_index < state.next_index =>
+                {
+                    Some(key)
+                }
+                _ => None,
+            })
+            .collect();
+        for key in iterator_keys {
+            if let Some(iterator) = self.iterators.get_mut(key) {
+                match &mut iterator.state {
+                    IteratorState::SetEntries(state) | IteratorState::SetValues(state) => {
+                        state.next_index -= 1
+                    }
+                    _ => unreachable!("filtered iterator kind changed unexpectedly"),
+                }
+            }
+        }
+    }
+
+    fn reset_set_iterators_after_clear(&mut self, set: SetKey) {
+        let iterator_keys: Vec<_> = self
+            .iterators
+            .iter()
+            .filter_map(|(key, iterator)| match &iterator.state {
+                IteratorState::SetEntries(state) | IteratorState::SetValues(state)
+                    if state.set == set =>
+                {
+                    Some(key)
+                }
+                _ => None,
+            })
+            .collect();
+        for key in iterator_keys {
+            if let Some(iterator) = self.iterators.get_mut(key) {
+                match &mut iterator.state {
+                    IteratorState::SetEntries(state) | IteratorState::SetValues(state) => {
+                        state.next_index = 0
+                    }
+                    _ => unreachable!("filtered iterator kind changed unexpectedly"),
+                }
+            }
+        }
+    }
+
+    fn set_contains(&self, set: SetKey, value: &Value) -> MustardResult<bool> {
+        let normalized = canonicalize_collection_key(value.clone());
+        Ok(self
+            .sets
+            .get(set)
+            .ok_or_else(|| MustardError::runtime("set missing"))?
+            .entries
+            .iter()
+            .any(|entry| same_value_zero(entry, &normalized)))
+    }
+
+    fn set_delete(&mut self, set: SetKey, value: &Value) -> MustardResult<bool> {
+        let normalized = canonicalize_collection_key(value.clone());
+        let removed_index = {
+            let entries = &mut self
+                .sets
+                .get_mut(set)
+                .ok_or_else(|| MustardError::runtime("set missing"))?
+                .entries;
+            if let Some(index) = entries
+                .iter()
+                .position(|entry| same_value_zero(entry, &normalized))
+            {
+                entries.remove(index);
+                Some(index)
+            } else {
+                None
+            }
+        };
+        if let Some(index) = removed_index {
+            self.adjust_set_iterators_after_delete(set, index);
+            self.refresh_set_accounting(set)?;
+            return Ok(true);
+        }
+        Ok(false)
+    }
+
+    fn set_clear(&mut self, set: SetKey) -> MustardResult<()> {
+        self.sets
+            .get_mut(set)
+            .ok_or_else(|| MustardError::runtime("set missing"))?
+            .entries
+            .clear();
+        self.reset_set_iterators_after_clear(set);
+        self.refresh_set_accounting(set)
+    }
+
+    pub(crate) fn call_map_get(&self, this_value: Value, args: &[Value]) -> MustardResult<Value> {
+        let key = args.first().cloned().unwrap_or(Value::Undefined);
+        let map = self.map_receiver(this_value, "get")?;
+        Ok(self
+            .map_get(map, &key)?
+            .map(|entry| entry.value)
+            .unwrap_or(Value::Undefined))
+    }
+
+    pub(crate) fn call_map_set(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let map = self.map_receiver(this_value, "set")?;
+        let key = args.first().cloned().unwrap_or(Value::Undefined);
+        let value = args.get(1).cloned().unwrap_or(Value::Undefined);
+        self.map_set(map, key, value)?;
+        Ok(Value::Map(map))
+    }
+
+    pub(crate) fn call_map_has(&self, this_value: Value, args: &[Value]) -> MustardResult<Value> {
+        let key = args.first().cloned().unwrap_or(Value::Undefined);
+        let map = self.map_receiver(this_value, "has")?;
+        Ok(Value::Bool(self.map_get(map, &key)?.is_some()))
+    }
+
+    pub(crate) fn call_map_delete(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let key = args.first().cloned().unwrap_or(Value::Undefined);
+        let map = self.map_receiver(this_value, "delete")?;
+        Ok(Value::Bool(self.map_delete(map, &key)?))
+    }
+
+    pub(crate) fn call_map_clear(&mut self, this_value: Value) -> MustardResult<Value> {
+        let map = self.map_receiver(this_value, "clear")?;
+        self.map_clear(map)?;
+        Ok(Value::Undefined)
+    }
+
+    pub(crate) fn call_map_entries(&mut self, this_value: Value) -> MustardResult<Value> {
+        let map = self.map_receiver(this_value, "entries")?;
+        Ok(Value::Iterator(self.insert_iterator(
+            IteratorState::MapEntries(MapIteratorState { map, next_index: 0 }),
+        )?))
+    }
+
+    pub(crate) fn call_map_keys(&mut self, this_value: Value) -> MustardResult<Value> {
+        let map = self.map_receiver(this_value, "keys")?;
+        Ok(Value::Iterator(self.insert_iterator(
+            IteratorState::MapKeys(MapIteratorState { map, next_index: 0 }),
+        )?))
+    }
+
+    pub(crate) fn call_map_values(&mut self, this_value: Value) -> MustardResult<Value> {
+        let map = self.map_receiver(this_value, "values")?;
+        Ok(Value::Iterator(self.insert_iterator(
+            IteratorState::MapValues(MapIteratorState { map, next_index: 0 }),
+        )?))
+    }
+
+    pub(crate) fn call_map_for_each(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let map = self.map_receiver(this_value, "forEach")?;
+        let (callback, this_arg) = self.collection_callback("Map.prototype.forEach", args)?;
+        let mut index = 0usize;
+        while index
+            < self
+                .maps
+                .get(map)
+                .ok_or_else(|| MustardError::runtime("map missing"))?
+                .entries
+                .len()
+        {
+            self.charge_native_helper_work(1)?;
+            if let Some(entry) = self
+                .maps
+                .get(map)
+                .ok_or_else(|| MustardError::runtime("map missing"))?
+                .entries
+                .get(index)
+                .cloned()
+            {
+                self.with_temporary_roots(
+                    &[Value::Map(map), callback.clone(), this_arg.clone()],
+                    |runtime| {
+                        runtime.call_collection_callback(
+                            "Map.prototype.forEach",
+                            callback.clone(),
+                            this_arg.clone(),
+                            &[entry.value, entry.key, Value::Map(map)],
+                        )?;
+                        Ok(())
+                    },
+                )?;
+            }
+            index += 1;
+        }
+        Ok(Value::Undefined)
+    }
+
+    pub(crate) fn call_set_add(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let set = self.set_receiver(this_value, "add")?;
+        let value = args.first().cloned().unwrap_or(Value::Undefined);
+        self.set_add(set, value)?;
+        Ok(Value::Set(set))
+    }
+
+    pub(crate) fn call_set_has(&self, this_value: Value, args: &[Value]) -> MustardResult<Value> {
+        let value = args.first().cloned().unwrap_or(Value::Undefined);
+        let set = self.set_receiver(this_value, "has")?;
+        Ok(Value::Bool(self.set_contains(set, &value)?))
+    }
+
+    pub(crate) fn call_set_delete(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let value = args.first().cloned().unwrap_or(Value::Undefined);
+        let set = self.set_receiver(this_value, "delete")?;
+        Ok(Value::Bool(self.set_delete(set, &value)?))
+    }
+
+    pub(crate) fn call_set_clear(&mut self, this_value: Value) -> MustardResult<Value> {
+        let set = self.set_receiver(this_value, "clear")?;
+        self.set_clear(set)?;
+        Ok(Value::Undefined)
+    }
+
+    pub(crate) fn call_set_entries(&mut self, this_value: Value) -> MustardResult<Value> {
+        let set = self.set_receiver(this_value, "entries")?;
+        Ok(Value::Iterator(self.insert_iterator(
+            IteratorState::SetEntries(SetIteratorState { set, next_index: 0 }),
+        )?))
+    }
+
+    pub(crate) fn call_set_keys(&mut self, this_value: Value) -> MustardResult<Value> {
+        let set = self.set_receiver(this_value, "keys")?;
+        Ok(Value::Iterator(self.insert_iterator(
+            IteratorState::SetValues(SetIteratorState { set, next_index: 0 }),
+        )?))
+    }
+
+    pub(crate) fn call_set_values(&mut self, this_value: Value) -> MustardResult<Value> {
+        let set = self.set_receiver(this_value, "values")?;
+        Ok(Value::Iterator(self.insert_iterator(
+            IteratorState::SetValues(SetIteratorState { set, next_index: 0 }),
+        )?))
+    }
+
+    pub(crate) fn call_set_for_each(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let set = self.set_receiver(this_value, "forEach")?;
+        let (callback, this_arg) = self.collection_callback("Set.prototype.forEach", args)?;
+        let mut index = 0usize;
+        while index
+            < self
+                .sets
+                .get(set)
+                .ok_or_else(|| MustardError::runtime("set missing"))?
+                .entries
+                .len()
+        {
+            self.charge_native_helper_work(1)?;
+            if let Some(value) = self
+                .sets
+                .get(set)
+                .ok_or_else(|| MustardError::runtime("set missing"))?
+                .entries
+                .get(index)
+                .cloned()
+            {
+                self.with_temporary_roots(
+                    &[Value::Set(set), callback.clone(), this_arg.clone()],
+                    |runtime| {
+                        runtime.call_collection_callback(
+                            "Set.prototype.forEach",
+                            callback.clone(),
+                            this_arg.clone(),
+                            &[value.clone(), value, Value::Set(set)],
+                        )?;
+                        Ok(())
+                    },
+                )?;
+            }
+            index += 1;
+        }
+        Ok(Value::Undefined)
+    }
+}