mustardscript 0.1.0 → 0.1.1

package/crates/mustard/src/runtime/async_runtime/reactions.rs

@@ -1,400 +0,0 @@
-use super::*;
-
-impl Runtime {
-    fn promise_combinator_slot_len(
-        promise: &PromiseObject,
-        kind: PromiseCombinatorKind,
-    ) -> MustardResult<Option<usize>> {
-        match (kind, promise.driver.as_ref()) {
-            (PromiseCombinatorKind::Race, _) => Ok(None),
-            (PromiseCombinatorKind::All, Some(PromiseDriver::All { values, .. })) => {
-                Ok(Some(values.len()))
-            }
-            (
-                PromiseCombinatorKind::AllSettled,
-                Some(PromiseDriver::AllSettled { results, .. }),
-            ) => Ok(Some(results.len())),
-            (PromiseCombinatorKind::Any, Some(PromiseDriver::Any { reasons, .. })) => {
-                Ok(Some(reasons.len()))
-            }
-            (_, Some(_)) => Err(MustardError::runtime("promise combinator kind mismatch")),
-            (_, None) => Err(MustardError::runtime("promise combinator state missing")),
-        }
-    }
-
-    pub(in crate::runtime) fn promise_reaction_target(
-        &self,
-        reaction: &PromiseReaction,
-    ) -> PromiseKey {
-        match reaction {
-            PromiseReaction::Then { target, .. }
-            | PromiseReaction::Finally { target, .. }
-            | PromiseReaction::FinallyPassThrough { target, .. }
-            | PromiseReaction::Combinator { target, .. } => *target,
-        }
-    }
-
-    pub(in crate::runtime) fn invoke_promise_handler(
-        &mut self,
-        handler: Value,
-        args: &[Value],
-        target: PromiseKey,
-    ) -> MustardResult<()> {
-        match handler {
-            Value::Closure(closure) => {
-                let closure = self
-                    .closures
-                    .get(closure)
-                    .cloned()
-                    .ok_or_else(|| MustardError::runtime("closure not found"))?;
-                let env = self.new_env(Some(closure.env))?;
-                let (is_async, function_id) = self
-                    .program
-                    .functions
-                    .get(closure.function_id)
-                    .map(|function| (function.is_async, closure.function_id))
-                    .ok_or_else(|| MustardError::runtime("function not found"))?;
-                if is_async {
-                    let bridge = self.insert_promise(PromiseState::Pending)?;
-                    self.attach_dependent(bridge, target)?;
-                    self.push_frame(function_id, env, args, Value::Undefined, Some(bridge))?;
-                } else {
-                    self.push_frame(function_id, env, args, Value::Undefined, Some(target))?;
-                }
-                Ok(())
-            }
-            Value::BuiltinFunction(function)
-                if matches!(
-                    function,
-                    BuiltinFunction::FunctionCall
-                        | BuiltinFunction::FunctionApply
-                        | BuiltinFunction::FunctionBind
-                ) =>
-            {
-                match self.call_callable(
-                    Value::BuiltinFunction(function),
-                    Value::Undefined,
-                    args,
-                )? {
-                    RunState::Completed(value) => self.resolve_promise(target, value),
-                    RunState::PushedFrame => Ok(()),
-                    RunState::StartedAsync(value) => {
-                        let promise = self.coerce_to_promise(value)?;
-                        self.attach_dependent(promise, target)
-                    }
-                    RunState::Suspended { .. } => Err(MustardError::runtime(
-                        "promise reactions do not support synchronous host suspensions",
-                    )),
-                }
-            }
-            Value::BuiltinFunction(function) => {
-                let value = self.call_builtin(function, Value::Undefined, args)?;
-                self.resolve_promise(target, value)
-            }
-            Value::Object(object)
-                if self
-                    .objects
-                    .get(object)
-                    .is_some_and(|object| matches!(object.kind, ObjectKind::BoundFunction(_))) =>
-            {
-                match self.call_callable(Value::Object(object), Value::Undefined, args)? {
-                    RunState::Completed(value) => self.resolve_promise(target, value),
-                    RunState::PushedFrame => Ok(()),
-                    RunState::StartedAsync(value) => {
-                        let promise = self.coerce_to_promise(value)?;
-                        self.attach_dependent(promise, target)
-                    }
-                    RunState::Suspended { .. } => Err(MustardError::runtime(
-                        "promise reactions do not support synchronous host suspensions",
-                    )),
-                }
-            }
-            Value::HostFunction(capability) => {
-                let outstanding =
-                    self.pending_host_calls.len() + usize::from(self.suspended_host_call.is_some());
-                if outstanding >= self.limits.max_outstanding_host_calls {
-                    return Err(limit_error("outstanding host-call limit exhausted"));
-                }
-                let args = args
-                    .iter()
-                    .cloned()
-                    .map(|value| self.value_to_structured(value))
-                    .collect::<MustardResult<Vec<_>>>()?;
-                let promise = self.insert_promise(PromiseState::Pending)?;
-                self.attach_dependent(promise, target)?;
-                self.pending_host_calls.push_back(PendingHostCall {
-                    capability,
-                    args,
-                    promise: Some(promise),
-                    resume_behavior: ResumeBehavior::Value,
-                    traceback: self.traceback_snapshots(),
-                });
-                Ok(())
-            }
-            _ => Err(MustardError::runtime("value is not callable")),
-        }
-    }
-
-    pub(in crate::runtime) fn make_promise_all_settled_result(
-        &mut self,
-        result: PromiseSettledResult,
-    ) -> MustardResult<Value> {
-        let properties = match result {
-            PromiseSettledResult::Fulfilled(value) => IndexMap::from([
-                ("status".to_string(), Value::String("fulfilled".to_string())),
-                ("value".to_string(), value),
-            ]),
-            PromiseSettledResult::Rejected(reason) => IndexMap::from([
-                ("status".to_string(), Value::String("rejected".to_string())),
-                ("reason".to_string(), reason),
-            ]),
-        };
-        Ok(Value::Object(
-            self.insert_object(properties, ObjectKind::Plain)?,
-        ))
-    }
-
-    pub(in crate::runtime) fn make_aggregate_error(
-        &mut self,
-        reasons: Vec<Value>,
-    ) -> MustardResult<Value> {
-        let error = self.make_error_object(
-            "AggregateError",
-            &[Value::String("All promises were rejected".to_string())],
-            None,
-            None,
-            None,
-        )?;
-        let errors = Value::Array(self.insert_array(reasons, IndexMap::new())?);
-        self.set_property(error.clone(), Value::String("errors".to_string()), errors)?;
-        Ok(error)
-    }
-
-    pub(in crate::runtime) fn activate_promise_combinator(
-        &mut self,
-        target: PromiseKey,
-        index: usize,
-        kind: PromiseCombinatorKind,
-        outcome: PromiseOutcome,
-    ) -> MustardResult<()> {
-        if self.promise_outcome(target)?.is_some() {
-            return Ok(());
-        }
-        let promise = self
-            .promises
-            .get(target)
-            .ok_or_else(|| MustardError::runtime("promise missing"))?;
-        if let Some(len) = Self::promise_combinator_slot_len(promise, kind)?
-            && index >= len
-        {
-            return Err(serialization_error(
-                "snapshot validation failed: promise combinator index out of range",
-            ));
-        }
-        match kind {
-            PromiseCombinatorKind::Race => self.resolve_promise_with_outcome(target, outcome),
-            PromiseCombinatorKind::All => {
-                let mut resolved_values = None;
-                let mut rejection = None;
-                {
-                    let promise = self
-                        .promises
-                        .get_mut(target)
-                        .ok_or_else(|| MustardError::runtime("promise missing"))?;
-                    let PromiseState::Pending = promise.state else {
-                        return Ok(());
-                    };
-                    let PromiseDriver::All { remaining, values } = promise
-                        .driver
-                        .as_mut()
-                        .ok_or_else(|| MustardError::runtime("promise combinator state missing"))?
-                    else {
-                        return Err(MustardError::runtime("promise combinator kind mismatch"));
-                    };
-                    match outcome {
-                        PromiseOutcome::Fulfilled(value) => {
-                            values[index] = Some(value);
-                            *remaining = remaining.saturating_sub(1);
-                            if *remaining == 0 {
-                                resolved_values = Some(
-                                    values
-                                        .iter()
-                                        .map(|value| value.clone().unwrap_or(Value::Undefined))
-                                        .collect::<Vec<_>>(),
-                                );
-                            }
-                        }
-                        PromiseOutcome::Rejected(reason) => rejection = Some(reason),
-                    }
-                }
-                self.refresh_promise_accounting(target)?;
-                if let Some(rejection) = rejection {
-                    self.reject_promise(target, rejection)?;
-                } else if let Some(values) = resolved_values {
-                    let array = Value::Array(self.insert_array(values, IndexMap::new())?);
-                    self.resolve_promise(target, array)?;
-                }
-                Ok(())
-            }
-            PromiseCombinatorKind::AllSettled => {
-                let mut settled_results = None;
-                {
-                    let promise = self
-                        .promises
-                        .get_mut(target)
-                        .ok_or_else(|| MustardError::runtime("promise missing"))?;
-                    let PromiseState::Pending = promise.state else {
-                        return Ok(());
-                    };
-                    let PromiseDriver::AllSettled { remaining, results } = promise
-                        .driver
-                        .as_mut()
-                        .ok_or_else(|| MustardError::runtime("promise combinator state missing"))?
-                    else {
-                        return Err(MustardError::runtime("promise combinator kind mismatch"));
-                    };
-                    results[index] = Some(match outcome {
-                        PromiseOutcome::Fulfilled(value) => PromiseSettledResult::Fulfilled(value),
-                        PromiseOutcome::Rejected(reason) => {
-                            PromiseSettledResult::Rejected(reason.value)
-                        }
-                    });
-                    *remaining = remaining.saturating_sub(1);
-                    if *remaining == 0 {
-                        settled_results = Some(
-                            results
-                                .iter()
-                                .map(|result| {
-                                    result.clone().unwrap_or(PromiseSettledResult::Fulfilled(
-                                        Value::Undefined,
-                                    ))
-                                })
-                                .collect::<Vec<_>>(),
-                        );
-                    }
-                }
-                self.refresh_promise_accounting(target)?;
-                if let Some(results) = settled_results {
-                    let mut values = Vec::with_capacity(results.len());
-                    for result in results {
-                        values.push(self.make_promise_all_settled_result(result)?);
-                    }
-                    let array = Value::Array(self.insert_array(values, IndexMap::new())?);
-                    self.resolve_promise(target, array)?;
-                }
-                Ok(())
-            }
-            PromiseCombinatorKind::Any => {
-                let mut rejection_values = None;
-                let mut fulfillment = None;
-                {
-                    let promise = self
-                        .promises
-                        .get_mut(target)
-                        .ok_or_else(|| MustardError::runtime("promise missing"))?;
-                    let PromiseState::Pending = promise.state else {
-                        return Ok(());
-                    };
-                    let PromiseDriver::Any { remaining, reasons } = promise
-                        .driver
-                        .as_mut()
-                        .ok_or_else(|| MustardError::runtime("promise combinator state missing"))?
-                    else {
-                        return Err(MustardError::runtime("promise combinator kind mismatch"));
-                    };
-                    match outcome {
-                        PromiseOutcome::Fulfilled(value) => fulfillment = Some(value),
-                        PromiseOutcome::Rejected(reason) => {
-                            reasons[index] = Some(reason.value);
-                            *remaining = remaining.saturating_sub(1);
-                            if *remaining == 0 {
-                                rejection_values = Some(
-                                    reasons
-                                        .iter()
-                                        .map(|value| value.clone().unwrap_or(Value::Undefined))
-                                        .collect::<Vec<_>>(),
-                                );
-                            }
-                        }
-                    }
-                }
-                self.refresh_promise_accounting(target)?;
-                if let Some(value) = fulfillment {
-                    self.resolve_promise(target, value)?;
-                } else if let Some(reasons) = rejection_values {
-                    let rejection = PromiseRejection {
-                        value: self.make_aggregate_error(reasons)?,
-                        span: None,
-                        traceback: self.traceback_snapshots(),
-                    };
-                    self.reject_promise(target, rejection)?;
-                }
-                Ok(())
-            }
-        }
-    }
-
-    pub(in crate::runtime) fn activate_promise_reaction(
-        &mut self,
-        reaction: PromiseReaction,
-        outcome: PromiseOutcome,
-    ) -> MustardResult<()> {
-        let target = self.promise_reaction_target(&reaction);
-        let result = (|| match reaction {
-            PromiseReaction::Then {
-                target,
-                on_fulfilled,
-                on_rejected,
-            } => match outcome {
-                PromiseOutcome::Fulfilled(value) => {
-                    if let Some(handler) = on_fulfilled {
-                        self.invoke_promise_handler(handler, &[value], target)
-                    } else {
-                        self.resolve_promise(target, value)
-                    }
-                }
-                PromiseOutcome::Rejected(rejection) => {
-                    if let Some(handler) = on_rejected {
-                        self.invoke_promise_handler(handler, &[rejection.value], target)
-                    } else {
-                        self.reject_promise(target, rejection)
-                    }
-                }
-            },
-            PromiseReaction::Finally { target, callback } => {
-                if let Some(callback) = callback {
-                    let bridge = self.insert_promise(PromiseState::Pending)?;
-                    self.attach_promise_reaction(
-                        bridge,
-                        PromiseReaction::FinallyPassThrough {
-                            target,
-                            original_outcome: outcome,
-                        },
-                    )?;
-                    self.invoke_promise_handler(callback, &[], bridge)
-                } else {
-                    self.resolve_promise_with_outcome(target, outcome)
-                }
-            }
-            PromiseReaction::FinallyPassThrough {
-                target,
-                original_outcome,
-            } => match outcome {
-                PromiseOutcome::Fulfilled(_) => {
-                    self.resolve_promise_with_outcome(target, original_outcome)
-                }
-                PromiseOutcome::Rejected(rejection) => self.reject_promise(target, rejection),
-            },
-            PromiseReaction::Combinator {
-                target,
-                index,
-                kind,
-            } => self.activate_promise_combinator(target, index, kind, outcome),
-        })();
-
-        match result {
-            Ok(()) => Ok(()),
-            Err(error) => self.reject_promise_from_error(target, error),
-        }
-    }
-}

package/crates/mustard/src/runtime/async_runtime/scheduler.rs

@@ -1,224 +0,0 @@
-use super::*;
-
-impl Runtime {
-    pub(in crate::runtime) fn activate_microtask(
-        &mut self,
-        job: MicrotaskJob,
-    ) -> MustardResult<()> {
-        if !self.frames.is_empty() {
-            return Err(MustardError::runtime(
-                "microtask checkpoint ran while frames were still active",
-            ));
-        }
-        match job {
-            MicrotaskJob::ResumeAsync {
-                continuation,
-                outcome,
-            } => {
-                self.frames = continuation.frames;
-                match outcome {
-                    PromiseOutcome::Fulfilled(value) => {
-                        let frame = self.frames.last_mut().ok_or_else(|| {
-                            MustardError::runtime("async continuation resumed without frames")
-                        })?;
-                        frame.stack.push(value);
-                    }
-                    PromiseOutcome::Rejected(rejection) => {
-                        match self.raise_exception_with_origin(
-                            rejection.value,
-                            rejection.span,
-                            Some(rejection.traceback),
-                        )? {
-                            StepAction::Continue => {}
-                            StepAction::Return(_) => {}
-                        }
-                    }
-                }
-            }
-            MicrotaskJob::PromiseReaction { reaction, outcome } => {
-                self.activate_promise_reaction(reaction, outcome)?;
-            }
-        }
-        Ok(())
-    }
-
-    pub(in crate::runtime) fn has_pending_async_work(&self) -> bool {
-        self.suspended_host_call.is_some()
-            || !self.pending_host_calls.is_empty()
-            || !self.microtasks.is_empty()
-            || self.promises.values().any(|promise| {
-                matches!(promise.state, PromiseState::Pending)
-                    && (!promise.awaiters.is_empty()
-                        || !promise.dependents.is_empty()
-                        || !promise.reactions.is_empty())
-            })
-    }
-
-    pub(in crate::runtime) fn suspend_host_request(
-        &mut self,
-        request: PendingHostCall,
-    ) -> ExecutionStep {
-        let capability = request.capability.clone();
-        let args = request.args.clone();
-        self.suspended_host_call = Some(request);
-        self.snapshot_nonce = next_snapshot_nonce();
-        ExecutionStep::Suspended(Box::new(Suspension {
-            capability,
-            args,
-            snapshot: ExecutionSnapshot {
-                runtime: self.clone(),
-            },
-        }))
-    }
-
-    pub(in crate::runtime) fn process_idle_state(
-        &mut self,
-    ) -> MustardResult<Option<ExecutionStep>> {
-        if let Some(job) = self.microtasks.pop_front() {
-            self.activate_microtask(job)?;
-            return Ok(None);
-        }
-        if let Some(request) = self.pending_host_calls.pop_front() {
-            return Ok(Some(self.suspend_host_request(request)));
-        }
-        if let Some(root_result) = self.root_result.clone() {
-            return match root_result {
-                Value::Promise(promise) => match self.promise_outcome(promise)? {
-                    Some(PromiseOutcome::Fulfilled(value)) => Ok(Some(ExecutionStep::Completed(
-                        self.value_to_structured(value)?,
-                    ))),
-                    Some(PromiseOutcome::Rejected(rejection)) => {
-                        Err(self.root_error_from_rejection(rejection)?)
-                    }
-                    None => Err(MustardError::runtime(
-                        "async root promise could not make progress",
-                    )),
-                },
-                value => {
-                    if self.has_pending_async_work() {
-                        return Err(MustardError::runtime(
-                            "async execution became idle with pending work",
-                        ));
-                    }
-                    Ok(Some(ExecutionStep::Completed(
-                        self.value_to_structured(value)?,
-                    )))
-                }
-            };
-        }
-        if self.has_pending_async_work() {
-            return Err(MustardError::runtime(
-                "async execution became idle before producing a root result",
-            ));
-        }
-        Err(MustardError::runtime("vm lost all frames"))
-    }
-
-    pub(in crate::runtime) fn resume(
-        &mut self,
-        payload: ResumePayload,
-    ) -> MustardResult<ExecutionStep> {
-        if let Err(error) = self.check_cancellation() {
-            if let Some(request) = self.suspended_host_call.as_ref() {
-                return Err(error.with_traceback(self.compose_traceback(&request.traceback)));
-            }
-            return Err(self.annotate_runtime_error(error));
-        }
-        self.collect_garbage()
-            .map_err(|error| self.annotate_runtime_error(error))?;
-        if let Some(request) = self.suspended_host_call.take() {
-            if let Some(promise) = request.promise {
-                let outcome = match payload {
-                    ResumePayload::Value(value) => {
-                        let value = match request.resume_behavior {
-                            ResumeBehavior::Value => self
-                                .value_from_structured(value)
-                                .map_err(|error| self.annotate_runtime_error(error))?,
-                            ResumeBehavior::Undefined => Value::Undefined,
-                        };
-                        PromiseOutcome::Fulfilled(value)
-                    }
-                    ResumePayload::Error(error) => PromiseOutcome::Rejected(PromiseRejection {
-                        value: self
-                            .value_from_host_error(error)
-                            .map_err(|error| self.annotate_runtime_error(error))?,
-                        span: None,
-                        traceback: Vec::new(),
-                    }),
-                    ResumePayload::Cancelled => {
-                        return Err(limit_error("execution cancelled")
-                            .with_traceback(self.compose_traceback(&request.traceback)));
-                    }
-                };
-                self.resolve_promise_with_outcome(promise, outcome)
-                    .map_err(|error| self.annotate_runtime_error(error))?;
-                return self.run();
-            }
-
-            return match payload {
-                ResumePayload::Value(value) => {
-                    let value = match request.resume_behavior {
-                        ResumeBehavior::Value => self
-                            .value_from_structured(value)
-                            .map_err(|error| self.annotate_runtime_error(error))?,
-                        ResumeBehavior::Undefined => Value::Undefined,
-                    };
-                    self.pending_resume_behavior = ResumeBehavior::Value;
-                    let Some(frame) = self.frames.last_mut() else {
-                        return Err(self.annotate_runtime_error(MustardError::runtime(
-                            "no suspended frame available",
-                        )));
-                    };
-                    frame.stack.push(value);
-                    self.run()
-                }
-                ResumePayload::Error(error) => {
-                    self.pending_resume_behavior = ResumeBehavior::Value;
-                    let value = self
-                        .value_from_host_error(error)
-                        .map_err(|error| self.annotate_runtime_error(error))?;
-                    match self.raise_exception(value, None) {
-                        Ok(StepAction::Continue) => self.run(),
-                        Ok(StepAction::Return(step)) => Ok(step),
-                        Err(error) => Err(self.annotate_runtime_error(error)),
-                    }
-                }
-                ResumePayload::Cancelled => {
-                    Err(self.annotate_runtime_error(limit_error("execution cancelled")))
-                }
-            };
-        }
-        match payload {
-            ResumePayload::Value(value) => {
-                let value = match self.pending_resume_behavior {
-                    ResumeBehavior::Value => self
-                        .value_from_structured(value)
-                        .map_err(|error| self.annotate_runtime_error(error))?,
-                    ResumeBehavior::Undefined => Value::Undefined,
-                };
-                self.pending_resume_behavior = ResumeBehavior::Value;
-                let Some(frame) = self.frames.last_mut() else {
-                    return Err(self.annotate_runtime_error(MustardError::runtime(
-                        "no suspended frame available",
-                    )));
-                };
-                frame.stack.push(value);
-            }
-            ResumePayload::Error(error) => {
-                self.pending_resume_behavior = ResumeBehavior::Value;
-                let value = self
-                    .value_from_host_error(error)
-                    .map_err(|error| self.annotate_runtime_error(error))?;
-                match self.raise_exception(value, None) {
-                    Ok(StepAction::Continue) => return self.run(),
-                    Ok(StepAction::Return(step)) => return Ok(step),
-                    Err(error) => return Err(self.annotate_runtime_error(error)),
-                }
-            }
-            ResumePayload::Cancelled => {
-                return Err(self.annotate_runtime_error(limit_error("execution cancelled")));
-            }
-        }
-        self.run()
-    }
-}