mustardscript 0.1.0

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

@@ -0,0 +1,334 @@
+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

@@ -0,0 +1,355 @@
+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,
+        }
+    }
+}