mustardscript 0.1.0 → 0.1.1

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

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

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