mustardscript 0.1.0

package/crates/mustard/src/runtime/conversions/boundary.rs

@@ -0,0 +1,293 @@
+use super::*;
+
+const STRUCTURED_BOUNDARY_MAX_DEPTH: usize = 128;
+
+#[derive(Default)]
+struct StructuredTraversalState {
+    active_arrays: HashSet<ArrayKey>,
+    active_objects: HashSet<ObjectKey>,
+    seen_arrays: HashSet<ArrayKey>,
+    seen_objects: HashSet<ObjectKey>,
+}
+
+impl Runtime {
+    pub(in crate::runtime) fn value_from_structured(
+        &mut self,
+        value: StructuredValue,
+    ) -> MustardResult<Value> {
+        self.value_from_structured_inner(value, 1)
+    }
+
+    fn value_from_structured_inner(
+        &mut self,
+        value: StructuredValue,
+        depth: usize,
+    ) -> MustardResult<Value> {
+        ensure_nested_depth(depth, structured_boundary_depth_error)?;
+        self.charge_native_helper_work(1)?;
+        Ok(match value {
+            StructuredValue::Undefined => Value::Undefined,
+            StructuredValue::Null => Value::Null,
+            StructuredValue::Hole => {
+                return Err(MustardError::runtime(
+                    "array holes can only appear inside structured arrays",
+                ));
+            }
+            StructuredValue::Bool(value) => Value::Bool(value),
+            StructuredValue::String(value) => {
+                self.ensure_heap_capacity(value.len())?;
+                Value::String(value)
+            }
+            StructuredValue::Number(number) => Value::Number(number.to_f64()),
+            StructuredValue::Array(items) => {
+                let mut values = Vec::with_capacity(items.len());
+                for item in items {
+                    values.push(match item {
+                        StructuredValue::Hole => None,
+                        other => Some(self.value_from_structured_inner(other, depth + 1)?),
+                    });
+                }
+                let array = self.insert_sparse_array(values, IndexMap::new())?;
+                Value::Array(array)
+            }
+            StructuredValue::Object(object) => {
+                let mut properties = IndexMap::new();
+                for (key, value) in object {
+                    properties.insert(key, self.value_from_structured_inner(value, depth + 1)?);
+                }
+                let object = self.insert_object(properties, ObjectKind::Plain)?;
+                Value::Object(object)
+            }
+        })
+    }
+
+    pub(in crate::runtime) fn value_to_structured(
+        &mut self,
+        value: Value,
+    ) -> MustardResult<StructuredValue> {
+        let mut traversal = StructuredTraversalState::default();
+        self.value_to_structured_inner(value, &mut traversal, 1)
+    }
+
+    fn value_to_structured_inner(
+        &mut self,
+        value: Value,
+        traversal: &mut StructuredTraversalState,
+        depth: usize,
+    ) -> MustardResult<StructuredValue> {
+        ensure_nested_depth(depth, structured_boundary_depth_error)?;
+        self.charge_native_helper_work(1)?;
+        Ok(match value {
+            Value::Undefined => StructuredValue::Undefined,
+            Value::Null => StructuredValue::Null,
+            Value::Bool(value) => StructuredValue::Bool(value),
+            Value::Number(value) => StructuredValue::Number(StructuredNumber::from_f64(value)),
+            Value::BigInt(_) => {
+                return Err(MustardError::runtime(
+                    "BigInt values cannot cross the structured host boundary",
+                ));
+            }
+            Value::String(value) => {
+                self.ensure_heap_capacity(value.len())?;
+                StructuredValue::String(value)
+            }
+            Value::Array(array) => {
+                if !traversal.active_arrays.insert(array) {
+                    return Err(structured_boundary_cycle_error());
+                }
+                if !traversal.seen_arrays.insert(array) {
+                    traversal.active_arrays.remove(&array);
+                    return Err(structured_boundary_shared_reference_error());
+                }
+                let elements = self
+                    .arrays
+                    .get(array)
+                    .ok_or_else(|| MustardError::runtime("array missing"))?
+                    .elements
+                    .clone();
+                let result = (|| {
+                    Ok(StructuredValue::Array(
+                        elements
+                            .iter()
+                            .map(|value| match value {
+                                Some(value) => self.value_to_structured_inner(
+                                    value.clone(),
+                                    traversal,
+                                    depth + 1,
+                                ),
+                                None => Ok(StructuredValue::Hole),
+                            })
+                            .collect::<MustardResult<Vec<_>>>()?,
+                    ))
+                })();
+                traversal.active_arrays.remove(&array);
+                result?
+            }
+            Value::Object(object) => {
+                let object_ref = self
+                    .objects
+                    .get(object)
+                    .ok_or_else(|| MustardError::runtime("object missing"))?;
+                match &object_ref.kind {
+                    ObjectKind::Plain => {}
+                    ObjectKind::Date(_) => {
+                        return Err(MustardError::runtime(
+                            "Date values cannot cross the structured host boundary",
+                        ));
+                    }
+                    _ => {
+                        return Err(MustardError::runtime(
+                            "only plain objects can cross the structured host boundary",
+                        ));
+                    }
+                }
+                if !traversal.active_objects.insert(object) {
+                    return Err(structured_boundary_cycle_error());
+                }
+                if !traversal.seen_objects.insert(object) {
+                    traversal.active_objects.remove(&object);
+                    return Err(structured_boundary_shared_reference_error());
+                }
+                let properties = object_ref.properties.clone();
+                let result = (|| {
+                    Ok(StructuredValue::Object(
+                        properties
+                            .iter()
+                            .map(|(key, value)| {
+                                Ok((
+                                    key.clone(),
+                                    self.value_to_structured_inner(
+                                        value.clone(),
+                                        traversal,
+                                        depth + 1,
+                                    )?,
+                                ))
+                            })
+                            .collect::<MustardResult<IndexMap<_, _>>>()?,
+                    ))
+                })();
+                traversal.active_objects.remove(&object);
+                result?
+            }
+            Value::Map(_) | Value::Set(_) => {
+                return Err(MustardError::runtime(
+                    "Map and Set values cannot cross the structured host boundary",
+                ));
+            }
+            Value::Iterator(_)
+            | Value::Promise(_)
+            | Value::Closure(_)
+            | Value::BuiltinFunction(_)
+            | Value::HostFunction(_) => {
+                return Err(MustardError::runtime(
+                    "functions cannot cross the structured host boundary",
+                ));
+            }
+        })
+    }
+
+    pub(in crate::runtime) fn value_from_json(
+        &mut self,
+        value: serde_json::Value,
+    ) -> MustardResult<Value> {
+        self.value_from_json_inner(value, 1)
+    }
+
+    fn value_from_json_inner(
+        &mut self,
+        value: serde_json::Value,
+        depth: usize,
+    ) -> MustardResult<Value> {
+        ensure_nested_depth(depth, json_value_depth_error)?;
+        self.charge_native_helper_work(1)?;
+        match value {
+            serde_json::Value::Null => Ok(Value::Null),
+            serde_json::Value::Bool(value) => Ok(Value::Bool(value)),
+            serde_json::Value::Number(number) => Ok(Value::Number(number.as_f64().unwrap_or(0.0))),
+            serde_json::Value::String(value) => {
+                self.ensure_heap_capacity(value.len())?;
+                Ok(Value::String(value))
+            }
+            serde_json::Value::Array(items) => {
+                let mut values = Vec::with_capacity(items.len());
+                for item in items {
+                    values.push(self.value_from_json_inner(item, depth + 1)?);
+                }
+                let array = self.insert_array(values, IndexMap::new())?;
+                Ok(Value::Array(array))
+            }
+            serde_json::Value::Object(object) => {
+                let mut properties = IndexMap::new();
+                for (key, value) in object {
+                    properties.insert(key, self.value_from_json_inner(value, depth + 1)?);
+                }
+                let object = self.insert_object(properties, ObjectKind::Plain)?;
+                Ok(Value::Object(object))
+            }
+        }
+    }
+}
+
+#[allow(dead_code)]
+pub(in crate::runtime) fn structured_to_json(
+    value: StructuredValue,
+) -> MustardResult<serde_json::Value> {
+    Ok(match value {
+        StructuredValue::Undefined => serde_json::Value::Null,
+        StructuredValue::Null => serde_json::Value::Null,
+        StructuredValue::Hole => {
+            return Err(MustardError::runtime(
+                "array holes cannot appear outside structured arrays",
+            ));
+        }
+        StructuredValue::Bool(value) => serde_json::Value::Bool(value),
+        StructuredValue::String(value) => serde_json::Value::String(value),
+        StructuredValue::Number(number) => match number {
+            StructuredNumber::Finite(value) => serde_json::Number::from_f64(value)
+                .map(serde_json::Value::Number)
+                .unwrap_or(serde_json::Value::Null),
+            StructuredNumber::NaN
+            | StructuredNumber::Infinity
+            | StructuredNumber::NegInfinity
+            | StructuredNumber::NegZero => serde_json::Value::Null,
+        },
+        StructuredValue::Array(values) => serde_json::Value::Array(
+            values
+                .into_iter()
+                .map(structured_to_json)
+                .collect::<MustardResult<Vec<_>>>()?,
+        ),
+        StructuredValue::Object(values) => serde_json::Value::Object(
+            values
+                .into_iter()
+                .map(|(key, value)| Ok((key, structured_to_json(value)?)))
+                .collect::<MustardResult<serde_json::Map<_, _>>>()?,
+        ),
+    })
+}
+
+fn structured_boundary_cycle_error() -> MustardError {
+    MustardError::runtime("cyclic values cannot cross the structured host boundary")
+}
+
+fn structured_boundary_shared_reference_error() -> MustardError {
+    MustardError::runtime("shared references cannot cross the structured host boundary")
+}
+
+fn structured_boundary_depth_error() -> MustardError {
+    MustardError::runtime("structured host boundary nesting limit exceeded")
+}
+
+fn json_value_depth_error() -> MustardError {
+    MustardError::runtime("JSON value nesting limit exceeded")
+}
+
+fn ensure_nested_depth(
+    depth: usize,
+    make_error: impl FnOnce() -> MustardError,
+) -> MustardResult<()> {
+    if depth > STRUCTURED_BOUNDARY_MAX_DEPTH {
+        return Err(make_error());
+    }
+    Ok(())
+}

package/crates/mustard/src/runtime/conversions/coercions.rs

@@ -0,0 +1,217 @@
+use super::*;
+
+impl Runtime {
+    pub(in crate::runtime) fn to_number(&self, value: Value) -> MustardResult<f64> {
+        Ok(match value {
+            Value::Undefined => f64::NAN,
+            Value::Null => 0.0,
+            Value::Bool(value) => {
+                if value {
+                    1.0
+                } else {
+                    0.0
+                }
+            }
+            Value::Number(value) => value,
+            Value::BigInt(_) => {
+                return Err(MustardError::runtime(
+                    "TypeError: cannot coerce BigInt values to numbers",
+                ));
+            }
+            Value::String(value) => value.parse::<f64>().unwrap_or(f64::NAN),
+            Value::Object(object) => match &self
+                .objects
+                .get(object)
+                .ok_or_else(|| MustardError::runtime("object missing"))?
+                .kind
+            {
+                ObjectKind::NumberObject(value) => *value,
+                ObjectKind::StringObject(value) => value.parse::<f64>().unwrap_or(f64::NAN),
+                ObjectKind::BooleanObject(value) => {
+                    if *value {
+                        1.0
+                    } else {
+                        0.0
+                    }
+                }
+                _ => {
+                    return Err(MustardError::runtime(
+                        "cannot coerce complex value to number",
+                    ));
+                }
+            },
+            Value::Array(_)
+            | Value::Map(_)
+            | Value::Set(_)
+            | Value::Iterator(_)
+            | Value::Promise(_)
+            | Value::Closure(_)
+            | Value::BuiltinFunction(_)
+            | Value::HostFunction(_) => {
+                return Err(MustardError::runtime(
+                    "cannot coerce complex value to number",
+                ));
+            }
+        })
+    }
+
+    pub(in crate::runtime) fn to_integer(&self, value: Value) -> MustardResult<i64> {
+        let number = self.to_number(value)?;
+        if number.is_nan() || number == 0.0 {
+            Ok(0)
+        } else if number.is_infinite() {
+            Ok(if number.is_sign_positive() {
+                i64::MAX
+            } else {
+                i64::MIN
+            })
+        } else {
+            let truncated = number.trunc();
+            if truncated >= i64::MAX as f64 {
+                Ok(i64::MAX)
+            } else if truncated <= i64::MIN as f64 {
+                Ok(i64::MIN)
+            } else {
+                Ok(truncated as i64)
+            }
+        }
+    }
+
+    pub(in crate::runtime) fn to_string(&self, value: Value) -> MustardResult<String> {
+        Ok(match value {
+            Value::Undefined => "undefined".to_string(),
+            Value::Null => "null".to_string(),
+            Value::Bool(value) => value.to_string(),
+            Value::Number(value) => {
+                if value.fract() == 0.0 {
+                    format!("{}", value as i64)
+                } else {
+                    value.to_string()
+                }
+            }
+            Value::BigInt(value) => value.to_string(),
+            Value::String(value) => value,
+            Value::Array(array) => {
+                let array = self
+                    .arrays
+                    .get(array)
+                    .ok_or_else(|| MustardError::runtime("array missing"))?;
+                let mut parts = Vec::new();
+                for value in &array.elements {
+                    parts.push(match value {
+                        None | Some(Value::Undefined) | Some(Value::Null) => String::new(),
+                        Some(value) => self.to_string(value.clone())?,
+                    });
+                }
+                parts.join(",")
+            }
+            Value::Map(_) => "[object Map]".to_string(),
+            Value::Set(_) => "[object Set]".to_string(),
+            Value::Object(object) => match &self
+                .objects
+                .get(object)
+                .ok_or_else(|| MustardError::runtime("object missing"))?
+                .kind
+            {
+                ObjectKind::Date(_) => "[object Date]".to_string(),
+                ObjectKind::RegExp(regex) => format!("/{}/{}", regex.pattern, regex.flags),
+                ObjectKind::NumberObject(value) => {
+                    if value.fract() == 0.0 {
+                        format!("{}", *value as i64)
+                    } else {
+                        value.to_string()
+                    }
+                }
+                ObjectKind::StringObject(value) => value.clone(),
+                ObjectKind::BooleanObject(value) => value.to_string(),
+                ObjectKind::BoundFunction(_) => {
+                    self.callable_display_string(&Value::Object(object))?
+                }
+                _ => self
+                    .error_summary(object)?
+                    .unwrap_or_else(|| "[object Object]".to_string()),
+            },
+            Value::Iterator(_) => "[object Iterator]".to_string(),
+            Value::Promise(_) => "[object Promise]".to_string(),
+            callable @ (Value::Closure(_) | Value::BuiltinFunction(_) | Value::HostFunction(_)) => {
+                self.callable_display_string(&callable)?
+            }
+        })
+    }
+
+    pub(in crate::runtime) fn to_property_key(&self, value: Value) -> MustardResult<String> {
+        match value {
+            Value::String(value) => Ok(value),
+            Value::Number(value) => Ok(format_number_key(value)),
+            Value::BigInt(value) => Ok(value.to_string()),
+            Value::Bool(value) => Ok(value.to_string()),
+            Value::Null => Ok("null".to_string()),
+            Value::Undefined => Ok("undefined".to_string()),
+            _ => self.to_string(value),
+        }
+    }
+
+    pub(in crate::runtime) fn to_array_items(&self, value: Value) -> MustardResult<Vec<Value>> {
+        match value {
+            Value::Array(array) => self
+                .arrays
+                .get(array)
+                .map(|array| {
+                    array
+                        .elements
+                        .iter()
+                        .map(|value| value.clone().unwrap_or(Value::Undefined))
+                        .collect()
+                })
+                .ok_or_else(|| MustardError::runtime("array missing")),
+            Value::Undefined | Value::Null => Ok(Vec::new()),
+            _ => Err(MustardError::runtime(
+                "value is not destructurable as an array",
+            )),
+        }
+    }
+
+    fn callable_display_string(&self, value: &Value) -> MustardResult<String> {
+        Ok(match value {
+            Value::Closure(closure) => {
+                let closure = self
+                    .closures
+                    .get(*closure)
+                    .ok_or_else(|| MustardError::runtime("closure missing"))?;
+                let function = self
+                    .program
+                    .functions
+                    .get(closure.function_id)
+                    .ok_or_else(|| MustardError::runtime("function not found"))?;
+                if function.display_source.is_empty() {
+                    let name = self.callable_name(value)?;
+                    if name.is_empty() {
+                        "function () { [mustard code] }".to_string()
+                    } else {
+                        format!("function {name}() {{ [mustard code] }}")
+                    }
+                } else {
+                    function.display_source.clone()
+                }
+            }
+            Value::BuiltinFunction(function) => {
+                format!(
+                    "function {}() {{ [native code] }}",
+                    self.callable_name(&Value::BuiltinFunction(*function))?
+                )
+            }
+            Value::HostFunction(_) => "function () { [host code] }".to_string(),
+            Value::Object(object) => {
+                let object = self
+                    .objects
+                    .get(*object)
+                    .ok_or_else(|| MustardError::runtime("object missing"))?;
+                match object.kind {
+                    ObjectKind::BoundFunction(_) => "function () { [native code] }".to_string(),
+                    _ => "[object Object]".to_string(),
+                }
+            }
+            _ => self.to_string(value.clone())?,
+        })
+    }
+}

package/crates/mustard/src/runtime/conversions/errors.rs

@@ -0,0 +1,118 @@
+use super::*;
+
+impl Runtime {
+    pub(in crate::runtime) fn make_error_object(
+        &mut self,
+        name: &str,
+        args: &[Value],
+        code: Option<String>,
+        details: Option<Value>,
+        cause: Option<Option<Value>>,
+    ) -> MustardResult<Value> {
+        let message = match args.first() {
+            Some(Value::Undefined) | None => String::new(),
+            Some(value) => self.to_string(value.clone())?,
+        };
+        let mut properties = IndexMap::from([
+            ("name".to_string(), Value::String(name.to_string())),
+            ("message".to_string(), Value::String(message)),
+        ]);
+        if let Some(code) = code {
+            properties.insert("code".to_string(), Value::String(code));
+        }
+        if let Some(details) = details {
+            properties.insert("details".to_string(), details);
+        }
+        if let Some(cause) = cause {
+            properties.insert("cause".to_string(), cause.unwrap_or(Value::Undefined));
+        }
+        let object = self.insert_object(properties, ObjectKind::Error(name.to_string()))?;
+        Ok(Value::Object(object))
+    }
+
+    pub(in crate::runtime) fn value_from_runtime_message(
+        &mut self,
+        message: &str,
+    ) -> MustardResult<Value> {
+        let (name, detail) = match message.split_once(": ") {
+            Some((name, detail)) if name == "Error" || name.ends_with("Error") => {
+                (name.to_string(), detail.to_string())
+            }
+            _ => ("Error".to_string(), message.to_string()),
+        };
+        self.make_error_object(&name, &[Value::String(detail)], None, None, None)
+    }
+
+    pub(in crate::runtime) fn value_from_host_error(
+        &mut self,
+        error: HostError,
+    ) -> MustardResult<Value> {
+        let details = match error.details {
+            Some(details) => Some(self.value_from_structured(details)?),
+            None => None,
+        };
+        self.make_error_object(
+            &error.name,
+            &[Value::String(error.message)],
+            error.code,
+            details,
+            None,
+        )
+    }
+
+    pub(in crate::runtime) fn render_exception(&self, value: &Value) -> MustardResult<String> {
+        match value {
+            Value::Object(object) => {
+                if let Some(summary) = self.error_summary(*object)? {
+                    Ok(summary)
+                } else {
+                    self.to_string(value.clone())
+                }
+            }
+            _ => self.to_string(value.clone()),
+        }
+    }
+
+    pub(in crate::runtime) fn error_summary(
+        &self,
+        object: ObjectKey,
+    ) -> MustardResult<Option<String>> {
+        let object = self
+            .objects
+            .get(object)
+            .ok_or_else(|| MustardError::runtime("object missing"))?;
+        let details = object.properties.get("details").cloned();
+        let name = object.properties.get("name").and_then(|value| match value {
+            Value::String(value) => Some(value.as_str()),
+            _ => None,
+        });
+        let message = object
+            .properties
+            .get("message")
+            .and_then(|value| match value {
+                Value::String(value) => Some(value.as_str()),
+                _ => None,
+            });
+
+        if !matches!(object.kind, ObjectKind::Error(_)) && name.is_none() && message.is_none() {
+            return Ok(None);
+        }
+
+        let mut summary = match (name, message) {
+            (Some(name), Some("")) => name.to_string(),
+            (Some(name), Some(message)) => format!("{name}: {message}"),
+            (Some(name), None) => name.to_string(),
+            (None, Some(message)) => message.to_string(),
+            (None, None) => "Error".to_string(),
+        };
+
+        if let Some(Value::String(code)) = object.properties.get("code") {
+            summary.push_str(&format!(" [code={code}]"));
+        }
+        if let Some(details) = details {
+            summary.push_str(&format!(" [details={}]", self.to_string(details)?));
+        }
+
+        Ok(Some(summary))
+    }
+}

package/crates/mustard/src/runtime/conversions/mod.rs

@@ -0,0 +1,14 @@
+use std::collections::HashSet;
+
+use num_bigint::BigInt;
+use num_traits::{ToPrimitive, Zero};
+
+use super::*;
+
+mod boundary;
+mod coercions;
+mod errors;
+mod operators;
+
+#[allow(unused_imports)]
+pub(super) use boundary::structured_to_json;