mustardscript 0.1.0 → 0.1.1

package/crates/mustard/src/runtime/compiler/bindings.rs

@@ -1,92 +0,0 @@
-use crate::{
-    diagnostic::{MustardError, MustardResult},
-    ir::{AssignOp, BinaryOp, BindingKind, FunctionExpr, Pattern, Stmt},
-};
-
-#[derive(Debug)]
-pub(super) struct BlockBindings {
-    pub(super) lexicals: Vec<(String, bool)>,
-    pub(super) functions: Vec<FunctionBinding>,
-}
-
-#[derive(Debug)]
-pub(super) struct FunctionBinding {
-    pub(super) name: String,
-    pub(super) expr: FunctionExpr,
-}
-
-pub(super) fn collect_block_bindings(statements: &[Stmt]) -> BlockBindings {
-    let mut lexicals = Vec::new();
-    let mut functions = Vec::new();
-    for statement in statements {
-        match statement {
-            Stmt::VariableDecl {
-                kind, declarators, ..
-            } => {
-                for declarator in declarators {
-                    for (name, _) in pattern_bindings(&declarator.pattern) {
-                        lexicals.push((name, *kind == BindingKind::Let));
-                    }
-                }
-            }
-            Stmt::FunctionDecl { function, .. } => {
-                if let Some(name) = &function.name {
-                    functions.push(FunctionBinding {
-                        name: name.clone(),
-                        expr: function.clone(),
-                    });
-                }
-            }
-            _ => {}
-        }
-    }
-    BlockBindings {
-        lexicals,
-        functions,
-    }
-}
-
-pub(super) fn pattern_bindings(pattern: &Pattern) -> Vec<(String, bool)> {
-    let mut bindings = Vec::new();
-    collect_pattern_bindings(pattern, &mut bindings);
-    bindings
-}
-
-fn collect_pattern_bindings(pattern: &Pattern, bindings: &mut Vec<(String, bool)>) {
-    match pattern {
-        Pattern::Identifier { name, .. } => bindings.push((name.clone(), true)),
-        Pattern::Object {
-            properties, rest, ..
-        } => {
-            for property in properties {
-                collect_pattern_bindings(&property.value, bindings);
-            }
-            if let Some(rest) = rest {
-                collect_pattern_bindings(rest, bindings);
-            }
-        }
-        Pattern::Array { elements, rest, .. } => {
-            for element in elements.iter().flatten() {
-                collect_pattern_bindings(element, bindings);
-            }
-            if let Some(rest) = rest {
-                collect_pattern_bindings(rest, bindings);
-            }
-        }
-        Pattern::Default { target, .. } => collect_pattern_bindings(target, bindings),
-    }
-}
-
-pub(super) fn assign_op_to_binary(operator: AssignOp) -> MustardResult<BinaryOp> {
-    match operator {
-        AssignOp::Assign | AssignOp::OrAssign | AssignOp::AndAssign | AssignOp::NullishAssign => {
-            Err(MustardError::runtime("invalid compound assignment"))
-        }
-        AssignOp::AddAssign => Ok(BinaryOp::Add),
-        AssignOp::SubAssign => Ok(BinaryOp::Sub),
-        AssignOp::MulAssign => Ok(BinaryOp::Mul),
-        AssignOp::DivAssign => Ok(BinaryOp::Div),
-        AssignOp::RemAssign => Ok(BinaryOp::Rem),
-        AssignOp::PowAssign => Ok(BinaryOp::Pow),
-    }
-}

package/crates/mustard/src/runtime/compiler/context.rs

@@ -1,46 +0,0 @@
-use super::super::bytecode::Instruction;
-
-#[derive(Debug, Default)]
-pub(super) struct CompileContext {
-    pub(super) code: Vec<Instruction>,
-    pub(super) loop_stack: Vec<LoopContext>,
-    pub(super) active_handlers: Vec<ActiveHandlerContext>,
-    pub(super) active_finally: Vec<ActiveFinallyContext>,
-    pub(super) finally_regions: Vec<FinallyRegionContext>,
-    pub(super) scope_depth: usize,
-    pub(super) internal_name_counter: usize,
-}
-
-#[derive(Debug, Default)]
-pub(super) struct LoopContext {
-    pub(super) break_jumps: Vec<ControlTransferPatch>,
-    pub(super) continue_jumps: Vec<ControlTransferPatch>,
-    pub(super) continue_target: Option<usize>,
-    pub(super) handler_depth: usize,
-    pub(super) scope_depth: usize,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub(super) struct ActiveHandlerContext {
-    pub(super) finally_region: Option<usize>,
-    pub(super) scope_depth: usize,
-}
-
-#[derive(Debug, Default)]
-pub(super) struct FinallyRegionContext {
-    pub(super) handler_sites: Vec<usize>,
-    pub(super) jump_sites: Vec<usize>,
-}
-
-#[derive(Debug, Default)]
-pub(super) struct ActiveFinallyContext {
-    pub(super) exit_patch_site: usize,
-    pub(super) jump_sites: Vec<usize>,
-    pub(super) scope_depth: usize,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub(super) enum ControlTransferPatch {
-    DirectJump(usize),
-    PendingJump(usize),
-}

package/crates/mustard/src/runtime/compiler/control.rs

@@ -1,342 +0,0 @@
-use super::super::bytecode::Instruction;
-use super::{
-    Compiler,
-    context::{
-        ActiveFinallyContext, ActiveHandlerContext, CompileContext, ControlTransferPatch,
-        FinallyRegionContext,
-    },
-    pattern_bindings,
-};
-use crate::{diagnostic::MustardResult, ir::Stmt};
-
-impl Compiler {
-    pub(super) fn compile_try(
-        &mut self,
-        context: &mut CompileContext,
-        body: &Stmt,
-        catch: Option<&crate::ir::CatchClause>,
-        finally: Option<&Stmt>,
-    ) -> MustardResult<()> {
-        let finally_region = finally.map(|_| {
-            context
-                .finally_regions
-                .push(FinallyRegionContext::default());
-            context.finally_regions.len() - 1
-        });
-
-        let try_handler_site = context.code.len();
-        context.code.push(Instruction::PushHandler {
-            catch: catch.map(|_| usize::MAX),
-            finally: finally_region.map(|_| usize::MAX),
-        });
-        if let Some(region) = finally_region {
-            context.finally_regions[region]
-                .handler_sites
-                .push(try_handler_site);
-        }
-
-        context.active_handlers.push(ActiveHandlerContext {
-            finally_region,
-            scope_depth: context.scope_depth,
-        });
-        self.compile_stmt(context, body)?;
-        context.active_handlers.pop();
-        context.code.push(Instruction::PopHandler);
-
-        let mut skip_catch_jump = None;
-        let mut after_finally_patches = Vec::new();
-        let outer_handler_depth = context.active_handlers.len();
-
-        if let Some(region) = finally_region {
-            let patch = context.code.len();
-            context.code.push(Instruction::PushPendingJump {
-                target: usize::MAX,
-                target_handler_depth: outer_handler_depth,
-                target_scope_depth: context.scope_depth,
-            });
-            after_finally_patches.push(patch);
-            self.emit_jump_to_finally(context, region);
-        } else if catch.is_some() {
-            skip_catch_jump = Some(self.emit_jump(context, Instruction::Jump(usize::MAX)));
-        }
-
-        if let Some(catch_clause) = catch {
-            self.patch_handler_catch(context, try_handler_site, context.code.len());
-
-            if let Some(region) = finally_region {
-                let catch_handler_site = context.code.len();
-                context.code.push(Instruction::PushHandler {
-                    catch: None,
-                    finally: Some(usize::MAX),
-                });
-                context.finally_regions[region]
-                    .handler_sites
-                    .push(catch_handler_site);
-                context.active_handlers.push(ActiveHandlerContext {
-                    finally_region: Some(region),
-                    scope_depth: context.scope_depth,
-                });
-            }
-
-            context.code.push(Instruction::PushEnv);
-            context.scope_depth += 1;
-            if let Some(parameter) = &catch_clause.parameter {
-                for (name, mutable) in pattern_bindings(parameter) {
-                    context
-                        .code
-                        .push(Instruction::DeclareName { name, mutable });
-                }
-            }
-            context.code.push(Instruction::BeginCatch);
-            if let Some(parameter) = &catch_clause.parameter {
-                self.compile_pattern_binding(context, parameter)?;
-            } else {
-                context.code.push(Instruction::Pop);
-            }
-            self.compile_stmt(context, catch_clause.body.as_ref())?;
-            context.scope_depth -= 1;
-            context.code.push(Instruction::PopEnv);
-
-            if let Some(region) = finally_region {
-                context.active_handlers.pop();
-                context.code.push(Instruction::PopHandler);
-                let patch = context.code.len();
-                context.code.push(Instruction::PushPendingJump {
-                    target: usize::MAX,
-                    target_handler_depth: outer_handler_depth,
-                    target_scope_depth: context.scope_depth,
-                });
-                after_finally_patches.push(patch);
-                self.emit_jump_to_finally(context, region);
-            }
-        }
-
-        if let Some(finally_stmt) = finally {
-            let finally_ip = context.code.len();
-            self.patch_finally_region(
-                context,
-                finally_region.expect("finally region should exist"),
-                finally_ip,
-            );
-            let enter_finally = context.code.len();
-            context
-                .code
-                .push(Instruction::EnterFinally { exit: usize::MAX });
-            context.active_finally.push(ActiveFinallyContext {
-                exit_patch_site: enter_finally,
-                jump_sites: Vec::new(),
-                scope_depth: context.scope_depth,
-            });
-            self.compile_stmt(context, finally_stmt)?;
-            let continue_ip = context.code.len();
-            let active_finally = context
-                .active_finally
-                .pop()
-                .expect("finally context should exist");
-            self.patch_finally_exit(context, active_finally, continue_ip);
-            context.code.push(Instruction::ContinuePending);
-            let after_finally = context.code.len();
-            for patch in after_finally_patches {
-                self.patch_pending_jump(context, patch, after_finally);
-            }
-            if let Some(skip_catch_jump) = skip_catch_jump {
-                self.patch_jump(context, skip_catch_jump, after_finally);
-            }
-        } else if let Some(skip_catch_jump) = skip_catch_jump {
-            let after_catch = context.code.len();
-            self.patch_jump(context, skip_catch_jump, after_catch);
-        }
-
-        Ok(())
-    }
-
-    pub(super) fn emit_return(&self, context: &mut CompileContext) {
-        if let Some(active_finally) = context.active_finally.last() {
-            self.emit_scope_cleanup(context, active_finally.scope_depth);
-            context.code.push(Instruction::PushPendingReturn);
-            self.emit_jump_to_active_finally_exit(context);
-            return;
-        }
-        if let Some((handler_depth, region)) = self.nearest_finally_region(context, 0) {
-            self.emit_scope_cleanup(context, context.active_handlers[handler_depth].scope_depth);
-            self.emit_handler_cleanup(context, handler_depth);
-            context.code.push(Instruction::PushPendingReturn);
-            self.emit_jump_to_finally(context, region);
-        } else {
-            context.code.push(Instruction::Return);
-        }
-    }
-
-    pub(super) fn emit_jump_transfer(
-        &self,
-        context: &mut CompileContext,
-        target_handler_depth: usize,
-        target_scope_depth: usize,
-    ) -> ControlTransferPatch {
-        if let Some(active_finally) = context.active_finally.last() {
-            self.emit_scope_cleanup(context, active_finally.scope_depth);
-            let patch = context.code.len();
-            context.code.push(Instruction::PushPendingJump {
-                target: usize::MAX,
-                target_handler_depth,
-                target_scope_depth,
-            });
-            self.emit_jump_to_active_finally_exit(context);
-            return ControlTransferPatch::PendingJump(patch);
-        }
-        if let Some((handler_depth, region)) =
-            self.nearest_finally_region(context, target_handler_depth)
-        {
-            self.emit_scope_cleanup(context, context.active_handlers[handler_depth].scope_depth);
-            self.emit_handler_cleanup(context, handler_depth);
-            let patch = context.code.len();
-            context.code.push(Instruction::PushPendingJump {
-                target: usize::MAX,
-                target_handler_depth,
-                target_scope_depth,
-            });
-            self.emit_jump_to_finally(context, region);
-            ControlTransferPatch::PendingJump(patch)
-        } else {
-            self.emit_scope_cleanup(context, target_scope_depth);
-            self.emit_handler_cleanup(context, target_handler_depth);
-            ControlTransferPatch::DirectJump(self.emit_jump(context, Instruction::Jump(usize::MAX)))
-        }
-    }
-
-    pub(super) fn emit_scope_cleanup(
-        &self,
-        context: &mut CompileContext,
-        target_scope_depth: usize,
-    ) {
-        for _ in target_scope_depth..context.scope_depth {
-            context.code.push(Instruction::PopEnv);
-        }
-    }
-
-    pub(super) fn emit_handler_cleanup(
-        &self,
-        context: &mut CompileContext,
-        target_handler_depth: usize,
-    ) {
-        for _ in target_handler_depth..context.active_handlers.len() {
-            context.code.push(Instruction::PopHandler);
-        }
-    }
-
-    pub(super) fn nearest_finally_region(
-        &self,
-        context: &CompileContext,
-        target_handler_depth: usize,
-    ) -> Option<(usize, usize)> {
-        for handler_depth in (target_handler_depth..context.active_handlers.len()).rev() {
-            if let Some(region) = context.active_handlers[handler_depth].finally_region {
-                return Some((handler_depth, region));
-            }
-        }
-        None
-    }
-
-    pub(super) fn emit_jump_to_finally(&self, context: &mut CompileContext, region: usize) {
-        let jump_site = self.emit_jump(context, Instruction::Jump(usize::MAX));
-        context.finally_regions[region].jump_sites.push(jump_site);
-    }
-
-    pub(super) fn emit_jump_to_active_finally_exit(&self, context: &mut CompileContext) {
-        let jump_site = self.emit_jump(context, Instruction::Jump(usize::MAX));
-        context
-            .active_finally
-            .last_mut()
-            .expect("finally context should exist")
-            .jump_sites
-            .push(jump_site);
-    }
-
-    pub(super) fn patch_handler_catch(
-        &self,
-        context: &mut CompileContext,
-        index: usize,
-        target: usize,
-    ) {
-        if let Instruction::PushHandler { catch, .. } = &mut context.code[index] {
-            *catch = Some(target);
-        }
-    }
-
-    pub(super) fn patch_finally_region(
-        &self,
-        context: &mut CompileContext,
-        region: usize,
-        target: usize,
-    ) {
-        let handler_sites = context.finally_regions[region].handler_sites.clone();
-        let jump_sites = context.finally_regions[region].jump_sites.clone();
-        for site in handler_sites {
-            if let Instruction::PushHandler { finally, .. } = &mut context.code[site] {
-                *finally = Some(target);
-            }
-        }
-        for site in jump_sites {
-            self.patch_jump(context, site, target);
-        }
-    }
-
-    pub(super) fn patch_finally_exit(
-        &self,
-        context: &mut CompileContext,
-        finally: ActiveFinallyContext,
-        target: usize,
-    ) {
-        if let Instruction::EnterFinally { exit } = &mut context.code[finally.exit_patch_site] {
-            *exit = target;
-        }
-        for jump_site in finally.jump_sites {
-            self.patch_jump(context, jump_site, target);
-        }
-    }
-
-    pub(super) fn patch_pending_jump(
-        &self,
-        context: &mut CompileContext,
-        index: usize,
-        target: usize,
-    ) {
-        if let Instruction::PushPendingJump { target: jump, .. } = &mut context.code[index] {
-            *jump = target;
-        }
-    }
-
-    pub(super) fn patch_control_transfer(
-        &self,
-        context: &mut CompileContext,
-        patch: ControlTransferPatch,
-        target: usize,
-    ) {
-        match patch {
-            ControlTransferPatch::DirectJump(index) => self.patch_jump(context, index, target),
-            ControlTransferPatch::PendingJump(index) => {
-                self.patch_pending_jump(context, index, target)
-            }
-        }
-    }
-
-    pub(super) fn emit_jump(
-        &self,
-        context: &mut CompileContext,
-        instruction: Instruction,
-    ) -> usize {
-        let index = context.code.len();
-        context.code.push(instruction);
-        index
-    }
-
-    pub(super) fn patch_jump(&self, context: &mut CompileContext, index: usize, target: usize) {
-        match &mut context.code[index] {
-            Instruction::Jump(address)
-            | Instruction::JumpIfFalse(address)
-            | Instruction::JumpIfTrue(address)
-            | Instruction::JumpIfNullish(address) => *address = target,
-            _ => {}
-        }
-    }
-}