mustardscript 0.1.0 → 0.1.2

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

@@ -1,334 +0,0 @@
-use super::*;
-use crate::ir::UpdateOp;
-
-impl Runtime {
-    pub(in crate::runtime) fn apply_update(
-        &mut self,
-        operator: UpdateOp,
-        value: Value,
-    ) -> MustardResult<Value> {
-        let delta = match operator {
-            UpdateOp::Increment => 1.0,
-            UpdateOp::Decrement => -1.0,
-        };
-        match value {
-            Value::BigInt(value) => Ok(Value::BigInt(match operator {
-                UpdateOp::Increment => value + BigInt::from(1u8),
-                UpdateOp::Decrement => value - BigInt::from(1u8),
-            })),
-            other => Ok(Value::Number(self.to_number(other)? + delta)),
-        }
-    }
-
-    pub(in crate::runtime) fn apply_unary(
-        &mut self,
-        operator: UnaryOp,
-        value: Value,
-    ) -> MustardResult<Value> {
-        match operator {
-            UnaryOp::Plus => match value {
-                Value::BigInt(_) => Err(MustardError::runtime(
-                    "TypeError: unary plus is not supported for BigInt values",
-                )),
-                other => Ok(Value::Number(self.to_number(other)?)),
-            },
-            UnaryOp::Minus => match value {
-                Value::BigInt(value) => Ok(Value::BigInt(-value)),
-                other => Ok(Value::Number(-self.to_number(other)?)),
-            },
-            UnaryOp::Not => Ok(Value::Bool(!is_truthy(&value))),
-            UnaryOp::Typeof => Ok(Value::String(
-                match value {
-                    Value::Undefined => "undefined",
-                    Value::Null => "object",
-                    Value::Bool(_) => "boolean",
-                    Value::Number(_) => "number",
-                    Value::BigInt(_) => "bigint",
-                    Value::String(_) => "string",
-                    Value::Closure(_) | Value::BuiltinFunction(_) | Value::HostFunction(_) => {
-                        "function"
-                    }
-                    Value::Object(object) => {
-                        if self.objects.get(object).is_some_and(|object| {
-                            matches!(object.kind, ObjectKind::BoundFunction(_))
-                        }) {
-                            "function"
-                        } else {
-                            "object"
-                        }
-                    }
-                    Value::Array(_)
-                    | Value::Map(_)
-                    | Value::Set(_)
-                    | Value::Iterator(_)
-                    | Value::Promise(_) => "object",
-                }
-                .to_string(),
-            )),
-            UnaryOp::Void => Ok(Value::Undefined),
-        }
-    }
-
-    pub(in crate::runtime) fn apply_binary(
-        &mut self,
-        operator: BinaryOp,
-        left: Value,
-        right: Value,
-    ) -> MustardResult<Value> {
-        match operator {
-            BinaryOp::Add => {
-                if matches!(left, Value::String(_)) || matches!(right, Value::String(_)) {
-                    Ok(Value::String(format!(
-                        "{}{}",
-                        self.to_string(left)?,
-                        self.to_string(right)?
-                    )))
-                } else if matches!(left, Value::BigInt(_)) || matches!(right, Value::BigInt(_)) {
-                    self.apply_bigint_binary(BinaryOp::Add, left, right)
-                } else {
-                    Ok(Value::Number(
-                        self.to_number(left)? + self.to_number(right)?,
-                    ))
-                }
-            }
-            BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div | BinaryOp::Rem | BinaryOp::Pow
-                if matches!(left, Value::BigInt(_)) || matches!(right, Value::BigInt(_)) =>
-            {
-                self.apply_bigint_binary(operator, left, right)
-            }
-            BinaryOp::Sub => Ok(Value::Number(
-                self.to_number(left)? - self.to_number(right)?,
-            )),
-            BinaryOp::Mul => Ok(Value::Number(
-                self.to_number(left)? * self.to_number(right)?,
-            )),
-            BinaryOp::Div => Ok(Value::Number(
-                self.to_number(left)? / self.to_number(right)?,
-            )),
-            BinaryOp::Rem => Ok(Value::Number(
-                self.to_number(left)? % self.to_number(right)?,
-            )),
-            BinaryOp::Pow => Ok(Value::Number(
-                self.to_number(left)?.powf(self.to_number(right)?),
-            )),
-            BinaryOp::In => Ok(Value::Bool(
-                self.has_property_in_supported_surface(right, left)?,
-            )),
-            BinaryOp::Instanceof => {
-                Ok(Value::Bool(self.instanceof_supported_surface(left, right)?))
-            }
-            BinaryOp::Eq | BinaryOp::StrictEq => Ok(Value::Bool(strict_equal(&left, &right))),
-            BinaryOp::NotEq | BinaryOp::StrictNotEq => {
-                Ok(Value::Bool(!strict_equal(&left, &right)))
-            }
-            BinaryOp::LessThan
-            | BinaryOp::LessThanEq
-            | BinaryOp::GreaterThan
-            | BinaryOp::GreaterThanEq
-                if matches!(left, Value::BigInt(_)) || matches!(right, Value::BigInt(_)) =>
-            {
-                let (left, right) = bigint_operands(left, right, mixed_bigint_comparison_error)?;
-                Ok(Value::Bool(match operator {
-                    BinaryOp::LessThan => left < right,
-                    BinaryOp::LessThanEq => left <= right,
-                    BinaryOp::GreaterThan => left > right,
-                    BinaryOp::GreaterThanEq => left >= right,
-                    _ => unreachable!(),
-                }))
-            }
-            BinaryOp::LessThan
-            | BinaryOp::LessThanEq
-            | BinaryOp::GreaterThan
-            | BinaryOp::GreaterThanEq
-                if matches!((&left, &right), (Value::String(_), Value::String(_))) =>
-            {
-                let (Value::String(left), Value::String(right)) = (left, right) else {
-                    unreachable!()
-                };
-                Ok(Value::Bool(match operator {
-                    BinaryOp::LessThan => left < right,
-                    BinaryOp::LessThanEq => left <= right,
-                    BinaryOp::GreaterThan => left > right,
-                    BinaryOp::GreaterThanEq => left >= right,
-                    _ => unreachable!(),
-                }))
-            }
-            BinaryOp::LessThan => Ok(Value::Bool(self.to_number(left)? < self.to_number(right)?)),
-            BinaryOp::LessThanEq => {
-                Ok(Value::Bool(self.to_number(left)? <= self.to_number(right)?))
-            }
-            BinaryOp::GreaterThan => {
-                Ok(Value::Bool(self.to_number(left)? > self.to_number(right)?))
-            }
-            BinaryOp::GreaterThanEq => {
-                Ok(Value::Bool(self.to_number(left)? >= self.to_number(right)?))
-            }
-        }
-    }
-}
-
-impl Runtime {
-    fn instanceof_supported_surface(&self, left: Value, right: Value) -> MustardResult<bool> {
-        match right {
-            Value::BuiltinFunction(function) => match function {
-                BuiltinFunction::FunctionCtor => Ok(match left {
-                    Value::Closure(_) | Value::BuiltinFunction(_) | Value::HostFunction(_) => true,
-                    Value::Object(object) => self
-                        .objects
-                        .get(object)
-                        .is_some_and(|object| matches!(object.kind, ObjectKind::BoundFunction(_))),
-                    _ => false,
-                }),
-                BuiltinFunction::ArrayCtor => Ok(matches!(left, Value::Array(_))),
-                BuiltinFunction::ObjectCtor => Ok(matches!(
-                    left,
-                    Value::Object(_)
-                        | Value::Array(_)
-                        | Value::Map(_)
-                        | Value::Set(_)
-                        | Value::Iterator(_)
-                        | Value::Promise(_)
-                        | Value::Closure(_)
-                        | Value::BuiltinFunction(_)
-                        | Value::HostFunction(_)
-                )),
-                BuiltinFunction::MapCtor => Ok(matches!(left, Value::Map(_))),
-                BuiltinFunction::SetCtor => Ok(matches!(left, Value::Set(_))),
-                BuiltinFunction::PromiseCtor => Ok(matches!(left, Value::Promise(_))),
-                BuiltinFunction::NumberCtor => Ok(matches!(
-                    left,
-                    Value::Object(object)
-                        if self.objects.get(object).is_some_and(
-                            |object| matches!(object.kind, ObjectKind::NumberObject(_))
-                        )
-                )),
-                BuiltinFunction::DateCtor => Ok(matches!(
-                    left,
-                    Value::Object(object)
-                        if self
-                            .objects
-                            .get(object)
-                            .is_some_and(|object| matches!(object.kind, ObjectKind::Date(_)))
-                )),
-                BuiltinFunction::RegExpCtor => Ok(matches!(
-                    left,
-                    Value::Object(object)
-                        if self
-                            .objects
-                            .get(object)
-                            .is_some_and(|object| matches!(object.kind, ObjectKind::RegExp(_)))
-                )),
-                BuiltinFunction::StringCtor => Ok(matches!(
-                    left,
-                    Value::Object(object)
-                        if self.objects.get(object).is_some_and(
-                            |object| matches!(object.kind, ObjectKind::StringObject(_))
-                        )
-                )),
-                BuiltinFunction::BooleanCtor => Ok(matches!(
-                    left,
-                    Value::Object(object)
-                        if self.objects.get(object).is_some_and(
-                            |object| matches!(object.kind, ObjectKind::BooleanObject(_))
-                        )
-                )),
-                BuiltinFunction::ErrorCtor => Ok(matches!(
-                    left,
-                    Value::Object(object)
-                        if self
-                            .objects
-                            .get(object)
-                            .is_some_and(|object| matches!(object.kind, ObjectKind::Error(_)))
-                )),
-                BuiltinFunction::TypeErrorCtor => Ok(self.error_kind_matches(left, "TypeError")),
-                BuiltinFunction::ReferenceErrorCtor => {
-                    Ok(self.error_kind_matches(left, "ReferenceError"))
-                }
-                BuiltinFunction::RangeErrorCtor => Ok(self.error_kind_matches(left, "RangeError")),
-                BuiltinFunction::SyntaxErrorCtor => {
-                    Ok(self.error_kind_matches(left, "SyntaxError"))
-                }
-                _ => Err(MustardError::runtime(
-                    "TypeError: right-hand side of instanceof must be a supported constructor",
-                )),
-            },
-            Value::Closure(_) => Ok(false),
-            _ => Err(MustardError::runtime(
-                "TypeError: right-hand side of instanceof must be a supported constructor",
-            )),
-        }
-    }
-
-    fn error_kind_matches(&self, value: Value, expected: &str) -> bool {
-        matches!(
-            value,
-            Value::Object(object)
-                if self
-                    .objects
-                    .get(object)
-                    .is_some_and(|object| matches!(&object.kind, ObjectKind::Error(name) if name == expected))
-        )
-    }
-}
-
-impl Runtime {
-    fn apply_bigint_binary(
-        &self,
-        operator: BinaryOp,
-        left: Value,
-        right: Value,
-    ) -> MustardResult<Value> {
-        let (left, right) = bigint_operands(left, right, mixed_bigint_number_error)?;
-        match operator {
-            BinaryOp::Add => Ok(Value::BigInt(left + right)),
-            BinaryOp::Sub => Ok(Value::BigInt(left - right)),
-            BinaryOp::Mul => Ok(Value::BigInt(left * right)),
-            BinaryOp::Div => {
-                if right.is_zero() {
-                    Err(MustardError::runtime("RangeError: BigInt division by zero"))
-                } else {
-                    Ok(Value::BigInt(left / right))
-                }
-            }
-            BinaryOp::Rem => {
-                if right.is_zero() {
-                    Err(MustardError::runtime("RangeError: BigInt division by zero"))
-                } else {
-                    Ok(Value::BigInt(left % right))
-                }
-            }
-            BinaryOp::Pow => {
-                if right < BigInt::zero() {
-                    return Err(MustardError::runtime(
-                        "RangeError: BigInt exponent must be non-negative",
-                    ));
-                }
-                let exponent = right.to_u32().ok_or_else(|| {
-                    MustardError::runtime("RangeError: BigInt exponent is too large")
-                })?;
-                Ok(Value::BigInt(left.pow(exponent)))
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-
-fn bigint_operands(
-    left: Value,
-    right: Value,
-    mixed_error: fn() -> MustardError,
-) -> MustardResult<(BigInt, BigInt)> {
-    match (left, right) {
-        (Value::BigInt(left), Value::BigInt(right)) => Ok((left, right)),
-        (Value::BigInt(_), _) | (_, Value::BigInt(_)) => Err(mixed_error()),
-        _ => unreachable!(),
-    }
-}
-
-fn mixed_bigint_number_error() -> MustardError {
-    MustardError::runtime("TypeError: cannot mix BigInt and Number values in arithmetic")
-}
-
-fn mixed_bigint_comparison_error() -> MustardError {
-    MustardError::runtime("TypeError: cannot compare BigInt and Number values")
-}

package/crates/mustard/src/runtime/env.rs

@@ -1,355 +0,0 @@
-use super::*;
-
-impl Runtime {
-    pub(super) fn global_object_key(&self) -> Option<ObjectKey> {
-        let cell = self
-            .envs
-            .get(self.globals)?
-            .bindings
-            .get("globalThis")
-            .copied()?;
-        match self.cells.get(cell)?.value {
-            Value::Object(object) => Some(object),
-            _ => None,
-        }
-    }
-
-    fn global_property_value(&self, name: &str) -> Option<Value> {
-        let global_object = self.global_object_key()?;
-        self.objects
-            .get(global_object)?
-            .properties
-            .get(name)
-            .cloned()
-    }
-
-    fn set_global_property_value(&mut self, name: String, value: Value) -> MustardResult<()> {
-        let Some(global_object) = self.global_object_key() else {
-            return Ok(());
-        };
-        self.objects
-            .get_mut(global_object)
-            .ok_or_else(|| MustardError::runtime("global object missing"))?
-            .properties
-            .insert(name, value);
-        self.refresh_object_accounting(global_object)?;
-        Ok(())
-    }
-
-    pub(super) fn infer_closure_name(&mut self, value: &Value, name: &str) -> MustardResult<()> {
-        let Value::Closure(closure) = value else {
-            return Ok(());
-        };
-        let needs_name = self
-            .closures
-            .get(*closure)
-            .ok_or_else(|| MustardError::runtime("closure missing"))?
-            .name
-            .is_none();
-        if !needs_name {
-            return Ok(());
-        }
-        self.closures
-            .get_mut(*closure)
-            .ok_or_else(|| MustardError::runtime("closure missing"))?
-            .name = Some(name.to_string());
-        self.refresh_closure_accounting(*closure)?;
-        Ok(())
-    }
-
-    pub(super) fn new_env(&mut self, parent: Option<EnvKey>) -> MustardResult<EnvKey> {
-        self.insert_env(parent)
-    }
-
-    pub(super) fn define_global(
-        &mut self,
-        name: String,
-        value: Value,
-        mutable: bool,
-    ) -> MustardResult<()> {
-        let binding_name = name.clone();
-        let cell = self.insert_cell(value, mutable, true)?;
-        self.envs
-            .get_mut(self.globals)
-            .ok_or_else(|| MustardError::runtime("missing globals environment"))?
-            .bindings
-            .insert(name, cell);
-        self.refresh_env_accounting(self.globals)?;
-        let value = self
-            .cells
-            .get(cell)
-            .ok_or_else(|| MustardError::runtime("binding cell missing"))?
-            .value
-            .clone();
-        self.set_global_property_value(binding_name, value)?;
-        Ok(())
-    }
-
-    pub(super) fn declare_name(
-        &mut self,
-        env: EnvKey,
-        name: String,
-        mutable: bool,
-    ) -> MustardResult<()> {
-        if self
-            .envs
-            .get(env)
-            .ok_or_else(|| MustardError::runtime("environment missing"))?
-            .bindings
-            .contains_key(&name)
-        {
-            return Ok(());
-        }
-        let cell = self.insert_cell(Value::Undefined, mutable, false)?;
-        self.envs
-            .get_mut(env)
-            .ok_or_else(|| MustardError::runtime("environment missing"))?
-            .bindings
-            .insert(name, cell);
-        self.refresh_env_accounting(env)?;
-        Ok(())
-    }
-
-    pub(super) fn lookup_name(&self, env: EnvKey, name: &str) -> MustardResult<Value> {
-        let Some(cell) = self.find_cell(env, name) else {
-            if let Some(value) = self.global_property_value(name) {
-                return Ok(value);
-            }
-            return Err(MustardError::Message {
-                kind: DiagnosticKind::Runtime,
-                message: format!("ReferenceError: `{name}` is not defined"),
-                span: None,
-                traceback: Vec::new(),
-            });
-        };
-        let cell = self
-            .cells
-            .get(cell)
-            .ok_or_else(|| MustardError::runtime("binding cell missing"))?;
-        if !cell.initialized {
-            return Err(MustardError::runtime(format!(
-                "ReferenceError: `{name}` accessed before initialization"
-            )));
-        }
-        Ok(cell.value.clone())
-    }
-
-    pub(super) fn assign_name(
-        &mut self,
-        env: EnvKey,
-        name: &str,
-        value: Value,
-    ) -> MustardResult<()> {
-        self.infer_closure_name(&value, name)?;
-        let Some(cell_key) = self.find_cell(env, name) else {
-            if self.global_property_value(name).is_some() {
-                return self.set_global_property_value(name.to_string(), value);
-            }
-            return Err(MustardError::runtime(format!(
-                "ReferenceError: `{name}` is not defined"
-            )));
-        };
-        {
-            let cell = self
-                .cells
-                .get_mut(cell_key)
-                .ok_or_else(|| MustardError::runtime("binding cell missing"))?;
-            if !cell.initialized {
-                return Err(MustardError::runtime(format!(
-                    "ReferenceError: `{name}` accessed before initialization"
-                )));
-            }
-            if !cell.mutable {
-                return Err(MustardError::runtime(format!(
-                    "TypeError: assignment to constant variable `{name}`"
-                )));
-            }
-            cell.value = value;
-        }
-        self.refresh_cell_accounting(cell_key)?;
-        if self
-            .envs
-            .get(self.globals)
-            .and_then(|globals| globals.bindings.get(name))
-            .is_some_and(|bound| *bound == cell_key)
-        {
-            let value = self
-                .cells
-                .get(cell_key)
-                .ok_or_else(|| MustardError::runtime("binding cell missing"))?
-                .value
-                .clone();
-            self.set_global_property_value(name.to_string(), value)?;
-        }
-        Ok(())
-    }
-
-    pub(super) fn initialize_name_in_env(
-        &mut self,
-        env: EnvKey,
-        name: &str,
-        value: Value,
-    ) -> MustardResult<()> {
-        self.infer_closure_name(&value, name)?;
-        let cell_key = self
-            .envs
-            .get(env)
-            .and_then(|env| env.bindings.get(name).copied())
-            .ok_or_else(|| {
-                MustardError::runtime(format!("binding `{name}` missing in current scope"))
-            })?;
-        let mut was_initialized = false;
-        {
-            let cell = self
-                .cells
-                .get_mut(cell_key)
-                .ok_or_else(|| MustardError::runtime("binding cell missing"))?;
-            if cell.initialized {
-                if !cell.mutable {
-                    return Err(MustardError::runtime(format!(
-                        "TypeError: binding `{name}` was already initialized"
-                    )));
-                }
-                cell.value = value;
-                was_initialized = true;
-            } else {
-                cell.value = value;
-                cell.initialized = true;
-            }
-        }
-        self.refresh_cell_accounting(cell_key)?;
-        if env == self.globals {
-            let value = self
-                .cells
-                .get(cell_key)
-                .ok_or_else(|| MustardError::runtime("binding cell missing"))?
-                .value
-                .clone();
-            self.set_global_property_value(name.to_string(), value)?;
-        }
-        if was_initialized {
-            return Ok(());
-        }
-        Ok(())
-    }
-
-    pub(super) fn find_cell(&self, env: EnvKey, name: &str) -> Option<CellKey> {
-        let mut current = Some(env);
-        while let Some(key) = current {
-            let env = self.envs.get(key)?;
-            if let Some(cell) = env.bindings.get(name) {
-                return Some(*cell);
-            }
-            current = env.parent;
-        }
-        None
-    }
-
-    pub(super) fn initialize_pattern(
-        &mut self,
-        env: EnvKey,
-        pattern: &Pattern,
-        value: Value,
-    ) -> MustardResult<()> {
-        match pattern {
-            Pattern::Identifier { name, .. } => self.initialize_name_in_env(env, name, value),
-            Pattern::Default {
-                target,
-                default_value,
-                ..
-            } => {
-                let value = if matches!(value, Value::Undefined) {
-                    let bytecode = BytecodeProgram {
-                        functions: vec![FunctionPrototype {
-                            name: None,
-                            length: 0,
-                            display_source: String::new(),
-                            params: Vec::new(),
-                            rest: None,
-                            code: Vec::new(),
-                            is_async: false,
-                            is_arrow: false,
-                            span: SourceSpan::new(0, 0),
-                        }],
-                        root: 0,
-                    };
-                    drop(bytecode);
-                    return Err(MustardError::runtime(format!(
-                        "default pattern initialization at runtime requires compiled evaluation support: {:?}",
-                        default_value
-                    )));
-                } else {
-                    value
-                };
-                self.initialize_pattern(env, target, value)
-            }
-            Pattern::Array { elements, rest, .. } => {
-                let items = self.to_array_items(value)?;
-                for (index, pattern) in elements.iter().enumerate() {
-                    if let Some(pattern) = pattern {
-                        self.initialize_pattern(
-                            env,
-                            pattern,
-                            items.get(index).cloned().unwrap_or(Value::Undefined),
-                        )?;
-                    }
-                }
-                if let Some(rest) = rest {
-                    let array = self.insert_array(
-                        items.into_iter().skip(elements.len()).collect(),
-                        IndexMap::new(),
-                    )?;
-                    self.initialize_pattern(env, rest, Value::Array(array))?;
-                }
-                Ok(())
-            }
-            Pattern::Object {
-                properties, rest, ..
-            } => {
-                let mut seen = HashSet::new();
-                for property in properties {
-                    let key = property_name_to_key(&property.key);
-                    let prop_value =
-                        self.get_property(value.clone(), Value::String(key.clone()), false)?;
-                    seen.insert(key);
-                    self.initialize_pattern(env, &property.value, prop_value)?;
-                }
-                if let Some(rest_pattern) = rest {
-                    let mut rest_object = IndexMap::new();
-                    match value {
-                        Value::Object(object) => {
-                            if let Some(object) = self.objects.get(object) {
-                                for (key, value) in &object.properties {
-                                    if !seen.contains(key) {
-                                        rest_object.insert(key.clone(), value.clone());
-                                    }
-                                }
-                            }
-                        }
-                        Value::Null | Value::Undefined => {
-                            return Err(MustardError::runtime(
-                                "cannot destructure object pattern from nullish value",
-                            ));
-                        }
-                        _ => {}
-                    }
-                    let rest = self.insert_object(rest_object, ObjectKind::Plain)?;
-                    self.initialize_pattern(env, rest_pattern, Value::Object(rest))?;
-                }
-                Ok(())
-            }
-        }
-    }
-
-    pub(super) fn capability_value(&self, name: &str) -> Option<Value> {
-        let cell = self.find_cell(self.globals, name)?;
-        let cell = self.cells.get(cell)?;
-        if !cell.initialized {
-            return None;
-        }
-        match &cell.value {
-            Value::HostFunction(_) => Some(cell.value.clone()),
-            _ => None,
-        }
-    }
-}