mustardscript 0.1.0

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

@@ -0,0 +1,335 @@
+use super::*;
+
+pub(crate) struct PromiseSetupPolicy<'a> {
+    pub(crate) non_callable_message: &'a str,
+    pub(crate) host_suspension_message: &'a str,
+    pub(crate) async_message: &'a str,
+}
+
+impl Runtime {
+    fn reject_promise_from_setup_error(
+        &mut self,
+        target: PromiseKey,
+        error: MustardError,
+    ) -> MustardResult<()> {
+        match error {
+            MustardError::Message {
+                kind: DiagnosticKind::Runtime,
+                message,
+                ..
+            } if message == super::super::INTERNAL_CALLBACK_THROW_MARKER => {
+                let rejection = self.pending_internal_exception.take().ok_or_else(|| {
+                    MustardError::runtime("missing internal callback exception state")
+                })?;
+                self.reject_promise(target, rejection)
+            }
+            other => self.reject_promise_from_error(target, other),
+        }
+    }
+
+    pub(crate) fn promise_settler(&self, target: PromiseKey, rejected: bool) -> Value {
+        Value::BuiltinFunction(if rejected {
+            BuiltinFunction::PromiseRejectFunction(target)
+        } else {
+            BuiltinFunction::PromiseResolveFunction(target)
+        })
+    }
+
+    pub(crate) fn promise_thenable_handler(&self, value: &Value) -> MustardResult<Option<Value>> {
+        match value {
+            Value::Object(_) | Value::Array(_) => {
+                let then =
+                    self.get_property(value.clone(), Value::String("then".to_string()), false)?;
+                if is_callable(&then) {
+                    Ok(Some(then))
+                } else {
+                    Ok(None)
+                }
+            }
+            _ => Ok(None),
+        }
+    }
+
+    pub(crate) fn call_promise_setup_callback(
+        &mut self,
+        target: PromiseKey,
+        callback: Value,
+        this_arg: Value,
+        args: &[Value],
+        policy: PromiseSetupPolicy<'_>,
+    ) -> MustardResult<()> {
+        let result = match callback {
+            Value::Closure(closure) => {
+                let closure = self
+                    .closures
+                    .get(closure)
+                    .cloned()
+                    .ok_or_else(|| MustardError::runtime("closure not found"))?;
+                let function = self
+                    .program
+                    .functions
+                    .get(closure.function_id)
+                    .ok_or_else(|| MustardError::runtime("function not found"))?;
+                if function.is_async {
+                    Err(MustardError::runtime(policy.async_message))
+                } else {
+                    let env = self.new_env(Some(closure.env))?;
+                    let outcome = self.insert_promise(PromiseState::Pending)?;
+                    let base_depth = self.frames.len();
+                    self.push_frame(closure.function_id, env, args, this_arg, Some(outcome))?;
+                    if let Err(error) =
+                        self.run_until_frame_depth(base_depth, policy.host_suspension_message)
+                    {
+                        self.frames.truncate(base_depth);
+                        self.suspended_host_call = None;
+                        self.pending_resume_behavior = ResumeBehavior::Value;
+                        return self.reject_promise_from_setup_error(target, error);
+                    }
+                    match self.promise_outcome(outcome)? {
+                        Some(PromiseOutcome::Rejected(rejection)) => {
+                            self.reject_promise(target, rejection)
+                        }
+                        Some(PromiseOutcome::Fulfilled(_)) | None => Ok(()),
+                    }
+                }
+            }
+            Value::BuiltinFunction(function) => {
+                self.call_builtin(function, this_arg, args).map(|_| ())
+            }
+            Value::HostFunction(capability) => {
+                match self.call_callable(Value::HostFunction(capability), this_arg, args) {
+                    Ok(RunState::Completed(_) | RunState::StartedAsync(_)) => Ok(()),
+                    Ok(RunState::PushedFrame) => Err(MustardError::runtime(
+                        "promise setup callback unexpectedly pushed a frame",
+                    )),
+                    Ok(RunState::Suspended { .. }) => {
+                        Err(MustardError::runtime(policy.host_suspension_message))
+                    }
+                    Err(error) => Err(error),
+                }
+            }
+            _ => Err(MustardError::runtime(policy.non_callable_message)),
+        };
+        match result {
+            Ok(()) => Ok(()),
+            Err(error) => self.reject_promise_from_setup_error(target, error),
+        }
+    }
+
+    pub(crate) fn construct_promise(&mut self, args: &[Value]) -> MustardResult<Value> {
+        let executor = args.first().cloned().unwrap_or(Value::Undefined);
+        if !is_callable(&executor) {
+            return Err(MustardError::runtime(
+                "TypeError: Promise constructor expects a callable executor",
+            ));
+        }
+        let target = self.insert_promise(PromiseState::Pending)?;
+        let resolve = self.promise_settler(target, false);
+        let reject = self.promise_settler(target, true);
+        self.call_promise_setup_callback(
+            target,
+            executor,
+            Value::Undefined,
+            &[resolve, reject],
+            PromiseSetupPolicy {
+                non_callable_message: "TypeError: Promise constructor expects a callable executor",
+                host_suspension_message:
+                    "TypeError: Promise executors do not support synchronous host suspensions",
+                async_message:
+                    "TypeError: Promise executors must be synchronous in the supported surface",
+            },
+        )?;
+        Ok(Value::Promise(target))
+    }
+
+    fn promise_receiver(&self, value: Value, method: &str) -> MustardResult<PromiseKey> {
+        match value {
+            Value::Promise(key) => Ok(key),
+            _ => Err(MustardError::runtime(format!(
+                "TypeError: Promise.prototype.{method} called on incompatible receiver",
+            ))),
+        }
+    }
+
+    fn collect_iterable_values(&mut self, iterable: Value) -> MustardResult<Vec<Value>> {
+        let iterator = self.create_iterator(iterable)?;
+        let mut values = Vec::new();
+        loop {
+            let (value, done) = self.iterator_next(iterator.clone())?;
+            if done {
+                break;
+            }
+            values.push(value);
+        }
+        Ok(values)
+    }
+
+    pub(crate) fn call_promise_then(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let promise = self.promise_receiver(this_value, "then")?;
+        let target = self.insert_promise(PromiseState::Pending)?;
+        let on_fulfilled = args.first().cloned().filter(is_callable);
+        let on_rejected = args.get(1).cloned().filter(is_callable);
+        self.attach_promise_reaction(
+            promise,
+            PromiseReaction::Then {
+                target,
+                on_fulfilled,
+                on_rejected,
+            },
+        )?;
+        Ok(Value::Promise(target))
+    }
+
+    pub(crate) fn call_promise_catch(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let promise = self.promise_receiver(this_value, "catch")?;
+        let target = self.insert_promise(PromiseState::Pending)?;
+        let on_rejected = args.first().cloned().filter(is_callable);
+        self.attach_promise_reaction(
+            promise,
+            PromiseReaction::Then {
+                target,
+                on_fulfilled: None,
+                on_rejected,
+            },
+        )?;
+        Ok(Value::Promise(target))
+    }
+
+    pub(crate) fn call_promise_finally(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let promise = self.promise_receiver(this_value, "finally")?;
+        let target = self.insert_promise(PromiseState::Pending)?;
+        let callback = args.first().cloned().filter(is_callable);
+        self.attach_promise_reaction(promise, PromiseReaction::Finally { target, callback })?;
+        Ok(Value::Promise(target))
+    }
+
+    pub(crate) fn call_promise_all(&mut self, args: &[Value]) -> MustardResult<Value> {
+        let target = self.insert_promise(PromiseState::Pending)?;
+        let values =
+            self.collect_iterable_values(args.first().cloned().unwrap_or(Value::Undefined))?;
+        if values.is_empty() {
+            let array = Value::Array(self.insert_array(Vec::new(), IndexMap::new())?);
+            self.resolve_promise(target, array)?;
+            return Ok(Value::Promise(target));
+        }
+        self.promises
+            .get_mut(target)
+            .ok_or_else(|| MustardError::runtime("promise missing"))?
+            .driver = Some(PromiseDriver::All {
+            remaining: values.len(),
+            values: vec![None; values.len()],
+        });
+        self.refresh_promise_accounting(target)?;
+        for (index, value) in values.into_iter().enumerate() {
+            let promise = self.coerce_to_promise(value)?;
+            self.attach_promise_reaction(
+                promise,
+                PromiseReaction::Combinator {
+                    target,
+                    index,
+                    kind: PromiseCombinatorKind::All,
+                },
+            )?;
+        }
+        Ok(Value::Promise(target))
+    }
+
+    pub(crate) fn call_promise_race(&mut self, args: &[Value]) -> MustardResult<Value> {
+        let target = self.insert_promise(PromiseState::Pending)?;
+        for value in
+            self.collect_iterable_values(args.first().cloned().unwrap_or(Value::Undefined))?
+        {
+            let promise = self.coerce_to_promise(value)?;
+            self.attach_promise_reaction(
+                promise,
+                PromiseReaction::Combinator {
+                    target,
+                    index: 0,
+                    kind: PromiseCombinatorKind::Race,
+                },
+            )?;
+        }
+        Ok(Value::Promise(target))
+    }
+
+    pub(crate) fn call_promise_any(&mut self, args: &[Value]) -> MustardResult<Value> {
+        let target = self.insert_promise(PromiseState::Pending)?;
+        let values =
+            self.collect_iterable_values(args.first().cloned().unwrap_or(Value::Undefined))?;
+        if values.is_empty() {
+            let error = self.make_aggregate_error(Vec::new())?;
+            self.reject_promise(
+                target,
+                PromiseRejection {
+                    value: error,
+                    span: None,
+                    traceback: self.traceback_snapshots(),
+                },
+            )?;
+            return Ok(Value::Promise(target));
+        }
+        self.promises
+            .get_mut(target)
+            .ok_or_else(|| MustardError::runtime("promise missing"))?
+            .driver = Some(PromiseDriver::Any {
+            remaining: values.len(),
+            reasons: vec![None; values.len()],
+        });
+        self.refresh_promise_accounting(target)?;
+        for (index, value) in values.into_iter().enumerate() {
+            let promise = self.coerce_to_promise(value)?;
+            self.attach_promise_reaction(
+                promise,
+                PromiseReaction::Combinator {
+                    target,
+                    index,
+                    kind: PromiseCombinatorKind::Any,
+                },
+            )?;
+        }
+        Ok(Value::Promise(target))
+    }
+
+    pub(crate) fn call_promise_all_settled(&mut self, args: &[Value]) -> MustardResult<Value> {
+        let target = self.insert_promise(PromiseState::Pending)?;
+        let values =
+            self.collect_iterable_values(args.first().cloned().unwrap_or(Value::Undefined))?;
+        if values.is_empty() {
+            let array = Value::Array(self.insert_array(Vec::new(), IndexMap::new())?);
+            self.resolve_promise(target, array)?;
+            return Ok(Value::Promise(target));
+        }
+        self.promises
+            .get_mut(target)
+            .ok_or_else(|| MustardError::runtime("promise missing"))?
+            .driver = Some(PromiseDriver::AllSettled {
+            remaining: values.len(),
+            results: vec![None; values.len()],
+        });
+        self.refresh_promise_accounting(target)?;
+        for (index, value) in values.into_iter().enumerate() {
+            let promise = self.coerce_to_promise(value)?;
+            self.attach_promise_reaction(
+                promise,
+                PromiseReaction::Combinator {
+                    target,
+                    index,
+                    kind: PromiseCombinatorKind::AllSettled,
+                },
+            )?;
+        }
+        Ok(Value::Promise(target))
+    }
+}

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

@@ -0,0 +1,356 @@
+use super::*;
+use regex::{Captures, Regex, RegexBuilder};
+
+struct CompiledRegExp {
+    flags: RegExpFlagsState,
+    regex: Regex,
+}
+
+impl Runtime {
+    pub(crate) fn construct_regexp(&mut self, args: &[Value]) -> MustardResult<Value> {
+        let pattern_arg = args.first().cloned().unwrap_or(Value::Undefined);
+        let flags_arg = args.get(1).cloned().unwrap_or(Value::Undefined);
+        let (pattern, flags) = match pattern_arg {
+            Value::Object(object) if self.is_regexp_object(object) => {
+                let regex = self.regexp_object(object)?.clone();
+                if matches!(flags_arg, Value::Undefined) {
+                    (regex.pattern, regex.flags)
+                } else {
+                    (regex.pattern, self.to_string(flags_arg)?)
+                }
+            }
+            value => {
+                let pattern = if matches!(value, Value::Undefined) {
+                    String::new()
+                } else {
+                    self.to_string(value)?
+                };
+                let flags = if matches!(flags_arg, Value::Undefined) {
+                    String::new()
+                } else {
+                    self.to_string(flags_arg)?
+                };
+                (pattern, flags)
+            }
+        };
+        self.make_regexp_value(pattern, flags)
+    }
+
+    fn regexp_receiver(&self, value: Value, method: &str) -> MustardResult<ObjectKey> {
+        match value {
+            Value::Object(key) if self.is_regexp_object(key) => Ok(key),
+            _ => Err(MustardError::runtime(format!(
+                "TypeError: RegExp.prototype.{method} called on incompatible receiver",
+            ))),
+        }
+    }
+
+    pub(crate) fn regexp_match_array_value(
+        &mut self,
+        input: &str,
+        matched: &RegExpMatchData,
+    ) -> MustardResult<Value> {
+        let mut groups = IndexMap::new();
+        for (name, value) in &matched.named_groups {
+            groups.insert(
+                name.clone(),
+                value.clone().map_or(Value::Undefined, Value::String),
+            );
+        }
+        let mut properties = IndexMap::from([
+            (
+                "index".to_string(),
+                Value::Number(matched.start_index as f64),
+            ),
+            ("input".to_string(), Value::String(input.to_string())),
+        ]);
+        if !groups.is_empty() {
+            properties.insert(
+                "groups".to_string(),
+                Value::Object(self.insert_object(groups, ObjectKind::Plain)?),
+            );
+        }
+        let mut elements = Vec::with_capacity(matched.captures.len() + 1);
+        elements.push(Value::String(
+            input[matched.start_byte..matched.end_byte].to_string(),
+        ));
+        elements.extend(
+            matched
+                .captures
+                .iter()
+                .map(|value| value.clone().map_or(Value::Undefined, Value::String)),
+        );
+        Ok(Value::Array(self.insert_array(elements, properties)?))
+    }
+
+    pub(crate) fn call_regexp_exec(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let regex = self.regexp_receiver(this_value, "exec")?;
+        let input = self.to_string(args.first().cloned().unwrap_or(Value::Undefined))?;
+        let Some(matched) = self.first_regexp_match(regex, &input)? else {
+            return Ok(Value::Null);
+        };
+        self.regexp_match_array_value(&input, &matched)
+    }
+
+    pub(crate) fn call_regexp_test(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let regex = self.regexp_receiver(this_value, "test")?;
+        let input = self.to_string(args.first().cloned().unwrap_or(Value::Undefined))?;
+        Ok(Value::Bool(
+            self.first_regexp_match(regex, &input)?.is_some(),
+        ))
+    }
+
+    pub(crate) fn make_regexp_value(
+        &mut self,
+        pattern: String,
+        flags: String,
+    ) -> MustardResult<Value> {
+        self.validate_regexp_flags(&flags)?;
+        self.compile_regexp(&pattern, &flags)?;
+        let object = self.insert_object(
+            IndexMap::new(),
+            ObjectKind::RegExp(RegExpObject {
+                pattern,
+                flags,
+                last_index: 0,
+            }),
+        )?;
+        Ok(Value::Object(object))
+    }
+
+    fn validate_regexp_flags(&self, flags: &str) -> MustardResult<RegExpFlagsState> {
+        let mut state = RegExpFlagsState {
+            global: false,
+            ignore_case: false,
+            multiline: false,
+            dot_all: false,
+            unicode: false,
+            sticky: false,
+        };
+        let mut seen = HashSet::new();
+        for flag in flags.chars() {
+            if !seen.insert(flag) {
+                return Err(MustardError::runtime(format!(
+                    "SyntaxError: duplicate regular expression flag `{flag}`",
+                )));
+            }
+            match flag {
+                'g' => state.global = true,
+                'i' => state.ignore_case = true,
+                'm' => state.multiline = true,
+                's' => state.dot_all = true,
+                'u' => state.unicode = true,
+                'y' => state.sticky = true,
+                _ => {
+                    return Err(MustardError::runtime(format!(
+                        "SyntaxError: unsupported regular expression flag `{flag}`",
+                    )));
+                }
+            }
+        }
+        Ok(state)
+    }
+
+    fn compile_regexp(&self, pattern: &str, flags: &str) -> MustardResult<CompiledRegExp> {
+        let flags = self.validate_regexp_flags(flags)?;
+        let mut builder = RegexBuilder::new(pattern);
+        builder.case_insensitive(flags.ignore_case);
+        builder.multi_line(flags.multiline);
+        builder.dot_matches_new_line(flags.dot_all);
+        // The Rust engine operates over UTF-8 strings, so keep Unicode mode
+        // enabled even without the JS `u` flag. This preserves the supported
+        // text-regexp subset while avoiding non-UTF-8 byte classes.
+        builder.unicode(true);
+        let regex = builder.build().map_err(|error| {
+            MustardError::runtime(format!("SyntaxError: invalid regular expression: {error}"))
+        })?;
+        Ok(CompiledRegExp { flags, regex })
+    }
+
+    pub(crate) fn is_regexp_object(&self, key: ObjectKey) -> bool {
+        self.objects
+            .get(key)
+            .is_some_and(|object| matches!(object.kind, ObjectKind::RegExp(_)))
+    }
+
+    pub(crate) fn is_date_object(&self, key: ObjectKey) -> bool {
+        self.objects
+            .get(key)
+            .is_some_and(|object| matches!(object.kind, ObjectKind::Date(_)))
+    }
+
+    pub(crate) fn date_object(&self, key: ObjectKey) -> MustardResult<&DateObject> {
+        match &self
+            .objects
+            .get(key)
+            .ok_or_else(|| MustardError::runtime("object missing"))?
+            .kind
+        {
+            ObjectKind::Date(date) => Ok(date),
+            _ => Err(MustardError::runtime("date missing")),
+        }
+    }
+
+    pub(crate) fn regexp_object(&self, key: ObjectKey) -> MustardResult<&RegExpObject> {
+        match &self
+            .objects
+            .get(key)
+            .ok_or_else(|| MustardError::runtime("object missing"))?
+            .kind
+        {
+            ObjectKind::RegExp(regex) => Ok(regex),
+            _ => Err(MustardError::runtime("regexp missing")),
+        }
+    }
+
+    pub(crate) fn regexp_object_mut(&mut self, key: ObjectKey) -> MustardResult<&mut RegExpObject> {
+        match &mut self
+            .objects
+            .get_mut(key)
+            .ok_or_else(|| MustardError::runtime("object missing"))?
+            .kind
+        {
+            ObjectKind::RegExp(regex) => Ok(regex),
+            _ => Err(MustardError::runtime("regexp missing")),
+        }
+    }
+
+    fn regexp_match_data_from_captures(
+        &self,
+        compiled: &CompiledRegExp,
+        text: &str,
+        captures: &Captures<'_>,
+    ) -> MustardResult<RegExpMatchData> {
+        let matched = captures
+            .get(0)
+            .ok_or_else(|| MustardError::runtime("regex match missing full capture"))?;
+        let named_groups = compiled
+            .regex
+            .capture_names()
+            .enumerate()
+            .skip(1)
+            .filter_map(|(index, name)| {
+                name.map(|name| {
+                    (
+                        name.to_string(),
+                        captures
+                            .get(index)
+                            .map(|capture| capture.as_str().to_string()),
+                    )
+                })
+            })
+            .collect::<IndexMap<_, _>>();
+        Ok(RegExpMatchData {
+            start_byte: matched.start(),
+            end_byte: matched.end(),
+            start_index: byte_index_to_char_index(text, matched.start()),
+            end_index: byte_index_to_char_index(text, matched.end()),
+            captures: (1..captures.len())
+                .map(|index| {
+                    captures
+                        .get(index)
+                        .map(|capture| capture.as_str().to_string())
+                })
+                .collect(),
+            named_groups,
+        })
+    }
+
+    fn first_regexp_match_with_compiled(
+        &self,
+        compiled: &CompiledRegExp,
+        text: &str,
+        start_index: usize,
+    ) -> MustardResult<Option<RegExpMatchData>> {
+        self.check_cancellation()?;
+        let start_byte = char_index_to_byte_index(text, start_index);
+        let Some(captures) = compiled.regex.captures_at(text, start_byte) else {
+            return Ok(None);
+        };
+        let matched = captures
+            .get(0)
+            .ok_or_else(|| MustardError::runtime("regex match missing full capture"))?;
+        if compiled.flags.sticky && matched.start() != start_byte {
+            return Ok(None);
+        }
+        self.regexp_match_data_from_captures(compiled, text, &captures)
+            .map(Some)
+    }
+
+    pub(crate) fn first_regexp_match_from_state(
+        &self,
+        regex: &RegExpObject,
+        text: &str,
+        start_index: usize,
+    ) -> MustardResult<Option<RegExpMatchData>> {
+        let compiled = self.compile_regexp(&regex.pattern, &regex.flags)?;
+        self.first_regexp_match_with_compiled(&compiled, text, start_index)
+    }
+
+    fn first_regexp_match(
+        &mut self,
+        regex_key: ObjectKey,
+        text: &str,
+    ) -> MustardResult<Option<RegExpMatchData>> {
+        let regex = self.regexp_object(regex_key)?.clone();
+        let flags = self.validate_regexp_flags(&regex.flags)?;
+        let start_index = if flags.global || flags.sticky {
+            regex.last_index
+        } else {
+            0
+        };
+        let matched = self.first_regexp_match_from_state(&regex, text, start_index)?;
+        if flags.global || flags.sticky {
+            let next_index = matched.as_ref().map_or(0, |matched| {
+                if matched.start_byte == matched.end_byte {
+                    advance_char_index(text, matched.start_index)
+                } else {
+                    matched.end_index
+                }
+            });
+            self.regexp_object_mut(regex_key)?.last_index = next_index;
+            self.refresh_object_accounting(regex_key)?;
+        }
+        Ok(matched)
+    }
+
+    pub(crate) fn collect_regexp_matches_from_state(
+        &self,
+        regex: &RegExpObject,
+        text: &str,
+        all: bool,
+    ) -> MustardResult<Vec<RegExpMatchData>> {
+        let compiled = self.compile_regexp(&regex.pattern, &regex.flags)?;
+        let mut matches = Vec::new();
+        let mut start_index = 0usize;
+        loop {
+            let Some(matched) =
+                self.first_regexp_match_with_compiled(&compiled, text, start_index)?
+            else {
+                break;
+            };
+            let next_index = if matched.start_byte == matched.end_byte {
+                advance_char_index(text, matched.start_index)
+            } else {
+                matched.end_index
+            };
+            matches.push(matched);
+            if !all {
+                break;
+            }
+            if next_index < start_index {
+                break;
+            }
+            start_index = next_index;
+        }
+        Ok(matches)
+    }
+}