mustardscript 0.1.0 → 0.1.2

package/crates/mustard/src/runtime/validation/policy.rs

@@ -1,94 +0,0 @@
-use super::*;
-
-pub(in crate::runtime) fn validate_snapshot_policy(
-    runtime: &Runtime,
-    policy: &SnapshotPolicy,
-) -> MustardResult<()> {
-    let allowed = policy
-        .capabilities
-        .iter()
-        .cloned()
-        .collect::<HashSet<String>>();
-
-    walk::walk_heap_values(runtime, &mut |value| {
-        validate_runtime_host_capability(value, &allowed)
-    })?;
-    for frame in &runtime.frames {
-        validate_frame_host_capabilities(frame, &allowed)?;
-    }
-    if let Some(root_result) = &runtime.root_result {
-        validate_runtime_host_capability(root_result, &allowed)?;
-    }
-    for request in &runtime.pending_host_calls {
-        validate_pending_host_call_capability(request, &allowed)?;
-    }
-    if let Some(request) = &runtime.suspended_host_call {
-        validate_pending_host_call_capability(request, &allowed)?;
-    }
-    for promise in runtime.promises.values() {
-        walk::walk_promise_values(promise, &mut |value| {
-            validate_runtime_host_capability(value, &allowed)
-        })?;
-        for continuation in &promise.awaiters {
-            walk::walk_continuation_frames(continuation, &mut |frame| {
-                validate_frame_host_capabilities(frame, &allowed)
-            })?;
-        }
-    }
-    for microtask in &runtime.microtasks {
-        walk::walk_microtask_values(
-            microtask,
-            &mut |frame| validate_frame_host_capabilities(frame, &allowed),
-            &mut |value| validate_runtime_host_capability(value, &allowed),
-        )?;
-    }
-    if let Some(exception) = &runtime.pending_internal_exception {
-        validate_promise_rejection_host_capabilities(exception, &allowed)?;
-    }
-    Ok(())
-}
-
-fn validate_runtime_host_capability(value: &Value, allowed: &HashSet<String>) -> MustardResult<()> {
-    match value {
-        Value::HostFunction(capability) if !allowed.contains(capability) => {
-            Err(MustardError::Message {
-                kind: DiagnosticKind::Serialization,
-                message: format!("snapshot policy rejected unauthorized capability `{capability}`"),
-                span: None,
-                traceback: Vec::new(),
-            })
-        }
-        _ => Ok(()),
-    }
-}
-
-fn validate_pending_host_call_capability(
-    request: &PendingHostCall,
-    allowed: &HashSet<String>,
-) -> MustardResult<()> {
-    if !allowed.contains(&request.capability) {
-        return Err(MustardError::Message {
-            kind: DiagnosticKind::Serialization,
-            message: format!(
-                "snapshot policy rejected unauthorized capability `{}`",
-                request.capability
-            ),
-            span: None,
-            traceback: Vec::new(),
-        });
-    }
-    Ok(())
-}
-
-fn validate_frame_host_capabilities(frame: &Frame, allowed: &HashSet<String>) -> MustardResult<()> {
-    walk::walk_frame_values(frame, &mut |value| {
-        validate_runtime_host_capability(value, allowed)
-    })
-}
-
-fn validate_promise_rejection_host_capabilities(
-    rejection: &PromiseRejection,
-    allowed: &HashSet<String>,
-) -> MustardResult<()> {
-    validate_runtime_host_capability(&rejection.value, allowed)
-}

package/crates/mustard/src/runtime/validation/snapshot.rs

@@ -1,406 +0,0 @@
-use super::*;
-
-pub(in crate::runtime) fn validate_snapshot(snapshot: &ExecutionSnapshot) -> MustardResult<()> {
-    let runtime = &snapshot.runtime;
-    validate_bytecode_program(&runtime.program)?;
-    if runtime.envs.get(runtime.globals).is_none() {
-        return Err(snapshot_error("missing globals environment"));
-    }
-    if runtime.frames.len() > runtime.limits.call_depth_limit {
-        return Err(limit_error("call depth limit exceeded"));
-    }
-    if runtime.frames.is_empty()
-        && runtime.suspended_host_call.is_none()
-        && runtime.root_result.is_none()
-        && runtime.microtasks.is_empty()
-    {
-        return Err(snapshot_error(
-            "suspended runtime has no frames or async state",
-        ));
-    }
-
-    validate_envs(runtime)?;
-    validate_closures(runtime)?;
-    validate_builtin_function_objects(runtime)?;
-    for frame in &runtime.frames {
-        validate_frame(runtime, frame)?;
-        walk::walk_frame_values(frame, &mut |value| validate_runtime_value(runtime, value))?;
-    }
-    walk::walk_heap_values(runtime, &mut |value| validate_runtime_value(runtime, value))?;
-    validate_iterators(runtime)?;
-    if let Some(root_result) = &runtime.root_result {
-        validate_runtime_value(runtime, root_result)?;
-    }
-    for request in &runtime.pending_host_calls {
-        validate_pending_host_call_snapshot(runtime, request)?;
-    }
-    if let Some(request) = &runtime.suspended_host_call {
-        validate_pending_host_call_snapshot(runtime, request)?;
-    }
-    for (promise_key, promise) in &runtime.promises {
-        validate_promise_snapshot(runtime, promise_key, promise)?;
-        walk::walk_promise_values(promise, &mut |value| validate_runtime_value(runtime, value))?;
-        for continuation in &promise.awaiters {
-            walk::walk_continuation_frames(continuation, &mut |frame| {
-                validate_frame(runtime, frame)?;
-                walk::walk_frame_values(frame, &mut |value| validate_runtime_value(runtime, value))
-            })?;
-        }
-    }
-    for microtask in &runtime.microtasks {
-        walk::walk_microtask_values(
-            microtask,
-            &mut |frame| {
-                validate_frame(runtime, frame)?;
-                walk::walk_frame_values(frame, &mut |value| validate_runtime_value(runtime, value))
-            },
-            &mut |value| validate_runtime_value(runtime, value),
-        )?;
-    }
-    if let Some(exception) = &runtime.pending_internal_exception {
-        validate_runtime_value(runtime, &exception.value)?;
-    }
-
-    Ok(())
-}
-
-fn snapshot_error(message: impl Into<String>) -> MustardError {
-    MustardError::Message {
-        kind: DiagnosticKind::Serialization,
-        message: format!("snapshot validation failed: {}", message.into()),
-        span: None,
-        traceback: Vec::new(),
-    }
-}
-
-fn validate_envs(runtime: &Runtime) -> MustardResult<()> {
-    for (env_key, env) in &runtime.envs {
-        if let Some(parent) = env.parent
-            && runtime.envs.get(parent).is_none()
-        {
-            return Err(snapshot_error(format!(
-                "environment {:?} references missing parent {:?}",
-                env_key, parent
-            )));
-        }
-        for cell in env.bindings.values() {
-            if runtime.cells.get(*cell).is_none() {
-                return Err(snapshot_error(format!(
-                    "environment {:?} references missing cell {:?}",
-                    env_key, cell
-                )));
-            }
-        }
-    }
-    Ok(())
-}
-
-fn validate_closures(runtime: &Runtime) -> MustardResult<()> {
-    for (closure_key, closure) in &runtime.closures {
-        if closure.function_id >= runtime.program.functions.len() {
-            return Err(snapshot_error(format!(
-                "closure {:?} references missing function {}",
-                closure_key, closure.function_id
-            )));
-        }
-        if runtime.envs.get(closure.env).is_none() {
-            return Err(snapshot_error(format!(
-                "closure {:?} references missing environment {:?}",
-                closure_key, closure.env
-            )));
-        }
-    }
-    Ok(())
-}
-
-fn validate_builtin_function_objects(runtime: &Runtime) -> MustardResult<()> {
-    for (function, object) in &runtime.builtin_prototypes {
-        if runtime.objects.get(*object).is_none() {
-            return Err(snapshot_error(format!(
-                "builtin prototype {:?} references missing object {:?}",
-                function, object
-            )));
-        }
-    }
-    for (function, object) in &runtime.builtin_function_objects {
-        if runtime.objects.get(*object).is_none() {
-            return Err(snapshot_error(format!(
-                "builtin function object {:?} references missing object {:?}",
-                function, object
-            )));
-        }
-    }
-    for (capability, object) in &runtime.host_function_objects {
-        if runtime.objects.get(*object).is_none() {
-            return Err(snapshot_error(format!(
-                "host function object `{capability}` references missing object {:?}",
-                object
-            )));
-        }
-    }
-    Ok(())
-}
-
-fn validate_frame(runtime: &Runtime, frame: &Frame) -> MustardResult<()> {
-    let Some(function) = runtime.program.functions.get(frame.function_id) else {
-        return Err(snapshot_error(format!(
-            "frame references missing function {}",
-            frame.function_id
-        )));
-    };
-    if frame.ip >= function.code.len() {
-        return Err(snapshot_error(format!(
-            "frame instruction pointer {} is out of range for function {}",
-            frame.ip, frame.function_id
-        )));
-    }
-    if runtime.envs.get(frame.env).is_none() {
-        return Err(snapshot_error(format!(
-            "frame references missing environment {:?}",
-            frame.env
-        )));
-    }
-    for env in &frame.scope_stack {
-        if runtime.envs.get(*env).is_none() {
-            return Err(snapshot_error(format!(
-                "frame scope stack references missing environment {:?}",
-                env
-            )));
-        }
-    }
-    for handler in &frame.handlers {
-        if let Some(catch) = handler.catch
-            && catch >= function.code.len()
-        {
-            return Err(snapshot_error(format!(
-                "frame handler catch target {} is out of range for function {}",
-                catch, frame.function_id
-            )));
-        }
-        if let Some(finally) = handler.finally
-            && finally >= function.code.len()
-        {
-            return Err(snapshot_error(format!(
-                "frame handler finally target {} is out of range for function {}",
-                finally, frame.function_id
-            )));
-        }
-        if runtime.envs.get(handler.env).is_none() {
-            return Err(snapshot_error(format!(
-                "frame handler references missing environment {:?}",
-                handler.env
-            )));
-        }
-        if handler.scope_stack_len > frame.scope_stack.len()
-            || handler.stack_len > frame.stack.len()
-        {
-            return Err(snapshot_error(
-                "frame handler restore state exceeds the current frame state",
-            ));
-        }
-    }
-    for completion in &frame.pending_completions {
-        match completion {
-            CompletionRecord::Jump {
-                target,
-                target_handler_depth,
-                target_scope_depth,
-            } => {
-                if *target >= function.code.len() {
-                    return Err(snapshot_error(format!(
-                        "pending jump target {} is out of range for function {}",
-                        target, frame.function_id
-                    )));
-                }
-                if *target_handler_depth > frame.handlers.len() {
-                    return Err(snapshot_error(format!(
-                        "pending jump targets handler depth {} but only {} handlers are active",
-                        target_handler_depth,
-                        frame.handlers.len()
-                    )));
-                }
-                if *target_scope_depth > frame.scope_stack.len() {
-                    return Err(snapshot_error(format!(
-                        "pending jump targets scope depth {} but only {} scopes are active",
-                        target_scope_depth,
-                        frame.scope_stack.len()
-                    )));
-                }
-            }
-            CompletionRecord::Return(value) | CompletionRecord::Throw(value) => {
-                validate_runtime_value(runtime, value)?;
-            }
-        }
-    }
-    for active in &frame.active_finally {
-        if active.completion_index >= frame.pending_completions.len() {
-            return Err(snapshot_error(
-                "active finally references a missing completion",
-            ));
-        }
-        if active.exit >= function.code.len() {
-            return Err(snapshot_error(format!(
-                "active finally exit target {} is out of range for function {}",
-                active.exit, frame.function_id
-            )));
-        }
-    }
-    Ok(())
-}
-
-fn validate_iterators(runtime: &Runtime) -> MustardResult<()> {
-    for iterator in runtime.iterators.values() {
-        match iterator.state {
-            IteratorState::Array(ref state)
-            | IteratorState::ArrayKeys(ref state)
-            | IteratorState::ArrayEntries(ref state) => {
-                if runtime.arrays.get(state.array).is_none() {
-                    return Err(snapshot_error(format!(
-                        "iterator references missing array {:?}",
-                        state.array
-                    )));
-                }
-            }
-            IteratorState::String(_) => {}
-            IteratorState::MapEntries(ref state)
-            | IteratorState::MapKeys(ref state)
-            | IteratorState::MapValues(ref state) => {
-                if runtime.maps.get(state.map).is_none() {
-                    return Err(snapshot_error(format!(
-                        "iterator references missing map {:?}",
-                        state.map
-                    )));
-                }
-            }
-            IteratorState::SetEntries(ref state) | IteratorState::SetValues(ref state) => {
-                if runtime.sets.get(state.set).is_none() {
-                    return Err(snapshot_error(format!(
-                        "iterator references missing set {:?}",
-                        state.set
-                    )));
-                }
-            }
-        }
-    }
-    Ok(())
-}
-
-fn validate_pending_host_call_snapshot(
-    runtime: &Runtime,
-    request: &PendingHostCall,
-) -> MustardResult<()> {
-    if let Some(promise) = request.promise
-        && runtime.promises.get(promise).is_none()
-    {
-        return Err(snapshot_error(
-            "pending host call references a missing promise",
-        ));
-    }
-    Ok(())
-}
-
-fn validate_promise_snapshot(
-    runtime: &Runtime,
-    promise_key: PromiseKey,
-    promise: &PromiseObject,
-) -> MustardResult<()> {
-    for dependent in &promise.dependents {
-        if runtime.promises.get(*dependent).is_none() {
-            return Err(snapshot_error(format!(
-                "promise {:?} references missing dependent {:?}",
-                promise_key, dependent
-            )));
-        }
-    }
-    for reaction in &promise.reactions {
-        match reaction {
-            PromiseReaction::Then { target, .. }
-            | PromiseReaction::Finally { target, .. }
-            | PromiseReaction::FinallyPassThrough { target, .. }
-            | PromiseReaction::Combinator { target, .. } => {
-                if runtime.promises.get(*target).is_none() {
-                    return Err(snapshot_error(format!(
-                        "promise {:?} reaction references missing target {:?}",
-                        promise_key, target
-                    )));
-                }
-            }
-        }
-
-        if let PromiseReaction::Combinator {
-            target,
-            index,
-            kind,
-        } = reaction
-        {
-            let target_promise = runtime.promises.get(*target).ok_or_else(|| {
-                snapshot_error(format!(
-                    "promise {:?} combinator reaction references missing target {:?}",
-                    promise_key, target
-                ))
-            })?;
-            let Some(driver) = target_promise.driver.as_ref() else {
-                return Err(snapshot_error(format!(
-                    "promise {:?} combinator target {:?} is missing driver state",
-                    promise_key, target
-                )));
-            };
-            let len = match (kind, driver) {
-                (PromiseCombinatorKind::Race, _) => None,
-                (PromiseCombinatorKind::All, PromiseDriver::All { values, .. }) => {
-                    Some(values.len())
-                }
-                (PromiseCombinatorKind::AllSettled, PromiseDriver::AllSettled { results, .. }) => {
-                    Some(results.len())
-                }
-                (PromiseCombinatorKind::Any, PromiseDriver::Any { reasons, .. }) => {
-                    Some(reasons.len())
-                }
-                _ => {
-                    return Err(snapshot_error(format!(
-                        "promise {:?} combinator reaction kind does not match target {:?} driver",
-                        promise_key, target
-                    )));
-                }
-            };
-            if let Some(len) = len
-                && *index >= len
-            {
-                return Err(snapshot_error(format!(
-                    "promise {:?} combinator index {} is out of range for target {:?}",
-                    promise_key, index, target
-                )));
-            }
-        }
-    }
-    Ok(())
-}
-
-fn validate_runtime_value(runtime: &Runtime, value: &Value) -> MustardResult<()> {
-    match value {
-        Value::Object(object) if runtime.objects.get(*object).is_none() => Err(snapshot_error(
-            format!("value references missing object {:?}", object),
-        )),
-        Value::Array(array) if runtime.arrays.get(*array).is_none() => Err(snapshot_error(
-            format!("value references missing array {:?}", array),
-        )),
-        Value::Map(map) if runtime.maps.get(*map).is_none() => Err(snapshot_error(format!(
-            "value references missing map {:?}",
-            map
-        ))),
-        Value::Set(set) if runtime.sets.get(*set).is_none() => Err(snapshot_error(format!(
-            "value references missing set {:?}",
-            set
-        ))),
-        Value::Iterator(iterator) if runtime.iterators.get(*iterator).is_none() => Err(
-            snapshot_error(format!("value references missing iterator {:?}", iterator)),
-        ),
-        Value::Closure(closure) if runtime.closures.get(*closure).is_none() => Err(snapshot_error(
-            format!("value references missing closure {:?}", closure),
-        )),
-        Value::Promise(promise) if runtime.promises.get(*promise).is_none() => Err(snapshot_error(
-            format!("value references missing promise {:?}", promise),
-        )),
-        _ => Ok(()),
-    }
-}

package/crates/mustard/src/runtime/validation/walk.rs

@@ -1,206 +0,0 @@
-use super::*;
-
-pub(super) fn walk_heap_values<F>(runtime: &Runtime, visit: &mut F) -> MustardResult<()>
-where
-    F: FnMut(&Value) -> MustardResult<()>,
-{
-    for cell in runtime.cells.values() {
-        visit(&cell.value)?;
-    }
-    for object in runtime.objects.values() {
-        match &object.kind {
-            ObjectKind::FunctionPrototype(constructor) => visit(constructor)?,
-            ObjectKind::BoundFunction(bound) => {
-                visit(&bound.target)?;
-                visit(&bound.this_value)?;
-                for value in &bound.args {
-                    visit(value)?;
-                }
-            }
-            _ => {}
-        }
-        for value in object.properties.values() {
-            visit(value)?;
-        }
-    }
-    for array in runtime.arrays.values() {
-        for value in array.elements.iter().flatten() {
-            visit(value)?;
-        }
-        for value in array.properties.values() {
-            visit(value)?;
-        }
-    }
-    for map in runtime.maps.values() {
-        for entry in &map.entries {
-            visit(&entry.key)?;
-            visit(&entry.value)?;
-        }
-    }
-    for set in runtime.sets.values() {
-        for value in &set.entries {
-            visit(value)?;
-        }
-    }
-    for closure in runtime.closures.values() {
-        visit(&closure.this_value)?;
-        if let Some(prototype) = closure.prototype {
-            visit(&Value::Object(prototype))?;
-        }
-        for value in closure.properties.values() {
-            visit(value)?;
-        }
-    }
-    Ok(())
-}
-
-pub(super) fn walk_frame_values<F>(frame: &Frame, visit: &mut F) -> MustardResult<()>
-where
-    F: FnMut(&Value) -> MustardResult<()>,
-{
-    for value in &frame.stack {
-        visit(value)?;
-    }
-    if let Some(value) = &frame.pending_exception {
-        visit(value)?;
-    }
-    for completion in &frame.pending_completions {
-        match completion {
-            CompletionRecord::Return(value) | CompletionRecord::Throw(value) => visit(value)?,
-            CompletionRecord::Jump { .. } => {}
-        }
-    }
-    Ok(())
-}
-
-pub(super) fn walk_promise_values<F>(promise: &PromiseObject, visit: &mut F) -> MustardResult<()>
-where
-    F: FnMut(&Value) -> MustardResult<()>,
-{
-    match &promise.state {
-        PromiseState::Pending => {}
-        PromiseState::Fulfilled(value) => visit(value)?,
-        PromiseState::Rejected(rejection) => visit(&rejection.value)?,
-    }
-    for reaction in &promise.reactions {
-        match reaction {
-            PromiseReaction::Then {
-                on_fulfilled,
-                on_rejected,
-                ..
-            } => {
-                if let Some(handler) = on_fulfilled {
-                    visit(handler)?;
-                }
-                if let Some(handler) = on_rejected {
-                    visit(handler)?;
-                }
-            }
-            PromiseReaction::Finally { callback, .. } => {
-                if let Some(callback) = callback {
-                    visit(callback)?;
-                }
-            }
-            PromiseReaction::FinallyPassThrough {
-                original_outcome, ..
-            } => match original_outcome {
-                PromiseOutcome::Fulfilled(value) => visit(value)?,
-                PromiseOutcome::Rejected(rejection) => visit(&rejection.value)?,
-            },
-            PromiseReaction::Combinator { .. } => {}
-        }
-    }
-    if let Some(driver) = &promise.driver {
-        match driver {
-            PromiseDriver::Thenable { value } => visit(value)?,
-            PromiseDriver::All { values, .. } => {
-                for value in values.iter().flatten() {
-                    visit(value)?;
-                }
-            }
-            PromiseDriver::AllSettled { results, .. } => {
-                for result in results.iter().flatten() {
-                    match result {
-                        PromiseSettledResult::Fulfilled(value)
-                        | PromiseSettledResult::Rejected(value) => visit(value)?,
-                    }
-                }
-            }
-            PromiseDriver::Any { reasons, .. } => {
-                for value in reasons.iter().flatten() {
-                    visit(value)?;
-                }
-            }
-        }
-    }
-    Ok(())
-}
-
-pub(super) fn walk_continuation_frames<F>(
-    continuation: &AsyncContinuation,
-    visit_frame: &mut F,
-) -> MustardResult<()>
-where
-    F: FnMut(&Frame) -> MustardResult<()>,
-{
-    for frame in &continuation.frames {
-        visit_frame(frame)?;
-    }
-    Ok(())
-}
-
-pub(super) fn walk_microtask_values<F, G>(
-    microtask: &MicrotaskJob,
-    visit_frame: &mut F,
-    visit_value: &mut G,
-) -> MustardResult<()>
-where
-    F: FnMut(&Frame) -> MustardResult<()>,
-    G: FnMut(&Value) -> MustardResult<()>,
-{
-    match microtask {
-        MicrotaskJob::ResumeAsync {
-            continuation,
-            outcome,
-        } => {
-            walk_continuation_frames(continuation, visit_frame)?;
-            match outcome {
-                PromiseOutcome::Fulfilled(value) => visit_value(value)?,
-                PromiseOutcome::Rejected(rejection) => visit_value(&rejection.value)?,
-            }
-        }
-        MicrotaskJob::PromiseReaction { reaction, outcome } => {
-            match reaction {
-                PromiseReaction::Then {
-                    on_fulfilled,
-                    on_rejected,
-                    ..
-                } => {
-                    if let Some(handler) = on_fulfilled {
-                        visit_value(handler)?;
-                    }
-                    if let Some(handler) = on_rejected {
-                        visit_value(handler)?;
-                    }
-                }
-                PromiseReaction::Finally { callback, .. } => {
-                    if let Some(callback) = callback {
-                        visit_value(callback)?;
-                    }
-                }
-                PromiseReaction::FinallyPassThrough {
-                    original_outcome, ..
-                } => match original_outcome {
-                    PromiseOutcome::Fulfilled(value) => visit_value(value)?,
-                    PromiseOutcome::Rejected(rejection) => visit_value(&rejection.value)?,
-                },
-                PromiseReaction::Combinator { .. } => {}
-            }
-            match outcome {
-                PromiseOutcome::Fulfilled(value) => visit_value(value)?,
-                PromiseOutcome::Rejected(rejection) => visit_value(&rejection.value)?,
-            }
-        }
-    }
-    Ok(())
-}