mustardscript 0.1.0

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

@@ -0,0 +1,372 @@
+use super::super::{bytecode::Instruction, format_number_key};
+use super::{Compiler, context::CompileContext};
+use crate::{
+    diagnostic::MustardResult,
+    ir::{
+        ArrayElement, BinaryOp, CallArgument, Expr, MemberProperty, ObjectProperty,
+        ObjectPropertyKey, PropertyName,
+    },
+    span::SourceSpan,
+};
+
+impl Compiler {
+    pub(super) fn compile_expr(
+        &mut self,
+        context: &mut CompileContext,
+        expression: &Expr,
+    ) -> MustardResult<()> {
+        match expression {
+            Expr::Undefined { .. } => context.code.push(Instruction::PushUndefined),
+            Expr::Null { .. } => context.code.push(Instruction::PushNull),
+            Expr::Bool { value, .. } => context.code.push(Instruction::PushBool(*value)),
+            Expr::Number { value, .. } => context.code.push(Instruction::PushNumber(*value)),
+            Expr::BigInt { value, .. } => context.code.push(Instruction::PushBigInt(value.clone())),
+            Expr::String { value, .. } => context.code.push(Instruction::PushString(value.clone())),
+            Expr::RegExp { pattern, flags, .. } => context.code.push(Instruction::PushRegExp {
+                pattern: pattern.clone(),
+                flags: flags.clone(),
+            }),
+            Expr::Identifier { name, .. } => context.code.push(Instruction::LoadName(name.clone())),
+            Expr::This { .. } => context.code.push(Instruction::LoadName("this".to_string())),
+            Expr::Array { elements, .. } => {
+                if elements
+                    .iter()
+                    .all(|element| matches!(element, ArrayElement::Value(_)))
+                {
+                    for element in elements {
+                        let ArrayElement::Value(element) = element else {
+                            unreachable!("dense array fast-path should only see value entries");
+                        };
+                        self.compile_expr(context, element)?;
+                    }
+                    context.code.push(Instruction::MakeArray {
+                        count: elements.len(),
+                    });
+                } else {
+                    context.code.push(Instruction::MakeArray { count: 0 });
+                    for element in elements {
+                        match element {
+                            ArrayElement::Value(element) => {
+                                self.compile_expr(context, element)?;
+                                context.code.push(Instruction::ArrayPush);
+                            }
+                            ArrayElement::Hole { .. } => {
+                                context.code.push(Instruction::ArrayPushHole);
+                            }
+                            ArrayElement::Spread { value, .. } => {
+                                self.compile_expr(context, value)?;
+                                context.code.push(Instruction::ArrayExtend);
+                            }
+                        }
+                    }
+                }
+            }
+            Expr::Object { properties, .. } => {
+                context
+                    .code
+                    .push(Instruction::MakeObject { keys: Vec::new() });
+                for property in properties {
+                    context.code.push(Instruction::Dup);
+                    match property {
+                        ObjectProperty::Property { key, value, .. } => match key {
+                            ObjectPropertyKey::Static(PropertyName::Identifier(name))
+                            | ObjectPropertyKey::Static(PropertyName::String(name)) => {
+                                self.compile_expr(context, value)?;
+                                context
+                                    .code
+                                    .push(Instruction::SetPropStatic { name: name.clone() });
+                            }
+                            ObjectPropertyKey::Static(PropertyName::Number(number)) => {
+                                self.compile_expr(context, value)?;
+                                context.code.push(Instruction::SetPropStatic {
+                                    name: format_number_key(*number),
+                                });
+                            }
+                            ObjectPropertyKey::Computed(expression) => {
+                                self.compile_expr(context, expression)?;
+                                self.compile_expr(context, value)?;
+                                context.code.push(Instruction::SetPropComputed);
+                            }
+                        },
+                        ObjectProperty::Spread { value, .. } => {
+                            self.compile_expr(context, value)?;
+                            context.code.push(Instruction::CopyDataProperties);
+                        }
+                    }
+                    context.code.push(Instruction::Pop);
+                }
+            }
+            Expr::Function(function) => {
+                context.code.push(Instruction::MakeClosure {
+                    function_id: self.compile_function(function)?,
+                });
+            }
+            Expr::Unary {
+                operator, argument, ..
+            } => {
+                self.compile_expr(context, argument)?;
+                context.code.push(Instruction::Unary(*operator));
+            }
+            Expr::Binary {
+                operator,
+                left,
+                right,
+                ..
+            } => {
+                self.compile_expr(context, left)?;
+                self.compile_expr(context, right)?;
+                context.code.push(Instruction::Binary(*operator));
+            }
+            Expr::Sequence { expressions, .. } => {
+                if expressions.is_empty() {
+                    context.code.push(Instruction::PushUndefined);
+                } else {
+                    for (index, expression) in expressions.iter().enumerate() {
+                        self.compile_expr(context, expression)?;
+                        if index + 1 != expressions.len() {
+                            context.code.push(Instruction::Pop);
+                        }
+                    }
+                }
+            }
+            Expr::Logical {
+                operator,
+                left,
+                right,
+                ..
+            } => {
+                self.compile_expr(context, left)?;
+                match operator {
+                    crate::ir::LogicalOp::And => {
+                        let jump = self.emit_jump(context, Instruction::JumpIfFalse(usize::MAX));
+                        context.code.push(Instruction::Pop);
+                        self.compile_expr(context, right)?;
+                        let end_ip = context.code.len();
+                        self.patch_jump(context, jump, end_ip);
+                    }
+                    crate::ir::LogicalOp::Or => {
+                        let jump = self.emit_jump(context, Instruction::JumpIfTrue(usize::MAX));
+                        context.code.push(Instruction::Pop);
+                        self.compile_expr(context, right)?;
+                        let end_ip = context.code.len();
+                        self.patch_jump(context, jump, end_ip);
+                    }
+                    crate::ir::LogicalOp::NullishCoalesce => {
+                        let jump = self.emit_jump(context, Instruction::JumpIfNullish(usize::MAX));
+                        let end = self.emit_jump(context, Instruction::Jump(usize::MAX));
+                        let rhs = context.code.len();
+                        self.patch_jump(context, jump, rhs);
+                        context.code.push(Instruction::Pop);
+                        self.compile_expr(context, right)?;
+                        let end_ip = context.code.len();
+                        self.patch_jump(context, end, end_ip);
+                    }
+                }
+            }
+            Expr::Conditional {
+                test,
+                consequent,
+                alternate,
+                ..
+            } => {
+                self.compile_expr(context, test)?;
+                let else_jump = self.emit_jump(context, Instruction::JumpIfFalse(usize::MAX));
+                context.code.push(Instruction::Pop);
+                self.compile_expr(context, consequent)?;
+                let end_jump = self.emit_jump(context, Instruction::Jump(usize::MAX));
+                let else_ip = context.code.len();
+                self.patch_jump(context, else_jump, else_ip);
+                context.code.push(Instruction::Pop);
+                self.compile_expr(context, alternate)?;
+                let end_ip = context.code.len();
+                self.patch_jump(context, end_jump, end_ip);
+            }
+            Expr::Assignment {
+                target,
+                operator,
+                value,
+                ..
+            } => self.compile_assignment(context, target.as_ref(), *operator, value)?,
+            Expr::Update {
+                target,
+                operator,
+                prefix,
+                ..
+            } => self.compile_update(context, target.as_ref(), *operator, *prefix)?,
+            Expr::Member {
+                object,
+                property,
+                optional,
+                ..
+            } => {
+                self.compile_expr(context, object)?;
+                match property {
+                    MemberProperty::Static(PropertyName::Identifier(name))
+                    | MemberProperty::Static(PropertyName::String(name)) => {
+                        context.code.push(Instruction::GetPropStatic {
+                            name: name.clone(),
+                            optional: *optional,
+                        })
+                    }
+                    MemberProperty::Static(PropertyName::Number(number)) => {
+                        context.code.push(Instruction::GetPropStatic {
+                            name: format_number_key(*number),
+                            optional: *optional,
+                        })
+                    }
+                    MemberProperty::Computed(expression) => {
+                        self.compile_expr(context, expression)?;
+                        context.code.push(Instruction::GetPropComputed {
+                            optional: *optional,
+                        });
+                    }
+                }
+            }
+            Expr::Call {
+                callee,
+                arguments,
+                optional,
+                ..
+            } => {
+                let with_this = matches!(callee.as_ref(), Expr::Member { .. });
+                if let Expr::Member {
+                    object,
+                    property,
+                    optional: member_optional,
+                    ..
+                } = callee.as_ref()
+                {
+                    self.compile_expr(context, object)?;
+                    context.code.push(Instruction::Dup);
+                    match property {
+                        MemberProperty::Static(PropertyName::Identifier(name))
+                        | MemberProperty::Static(PropertyName::String(name)) => {
+                            context.code.push(Instruction::GetPropStatic {
+                                name: name.clone(),
+                                optional: *member_optional,
+                            })
+                        }
+                        MemberProperty::Static(PropertyName::Number(number)) => {
+                            context.code.push(Instruction::GetPropStatic {
+                                name: format_number_key(*number),
+                                optional: *member_optional,
+                            })
+                        }
+                        MemberProperty::Computed(expression) => {
+                            self.compile_expr(context, expression)?;
+                            context.code.push(Instruction::GetPropComputed {
+                                optional: *member_optional,
+                            });
+                        }
+                    }
+                } else {
+                    self.compile_expr(context, callee)?;
+                }
+                if arguments
+                    .iter()
+                    .all(|argument| matches!(argument, CallArgument::Value(_)))
+                {
+                    for argument in arguments {
+                        let CallArgument::Value(argument) = argument else {
+                            unreachable!(
+                                "non-spread call fast-path should only see value arguments"
+                            );
+                        };
+                        self.compile_expr(context, argument)?;
+                    }
+                    context.code.push(Instruction::Call {
+                        argc: arguments.len(),
+                        with_this,
+                        optional: *optional,
+                    });
+                } else {
+                    context.code.push(Instruction::MakeArray { count: 0 });
+                    for argument in arguments {
+                        match argument {
+                            CallArgument::Value(argument) => {
+                                self.compile_expr(context, argument)?;
+                                context.code.push(Instruction::ArrayPush);
+                            }
+                            CallArgument::Spread { value, .. } => {
+                                self.compile_expr(context, value)?;
+                                context.code.push(Instruction::ArrayExtend);
+                            }
+                        }
+                    }
+                    context.code.push(Instruction::CallWithArray {
+                        with_this,
+                        optional: *optional,
+                    });
+                }
+            }
+            Expr::New {
+                callee, arguments, ..
+            } => {
+                self.compile_expr(context, callee)?;
+                if arguments
+                    .iter()
+                    .all(|argument| matches!(argument, CallArgument::Value(_)))
+                {
+                    for argument in arguments {
+                        let CallArgument::Value(argument) = argument else {
+                            unreachable!(
+                                "non-spread constructor fast-path should only see value arguments"
+                            );
+                        };
+                        self.compile_expr(context, argument)?;
+                    }
+                    context.code.push(Instruction::Construct {
+                        argc: arguments.len(),
+                    });
+                } else {
+                    context.code.push(Instruction::MakeArray { count: 0 });
+                    for argument in arguments {
+                        match argument {
+                            CallArgument::Value(argument) => {
+                                self.compile_expr(context, argument)?;
+                                context.code.push(Instruction::ArrayPush);
+                            }
+                            CallArgument::Spread { value, .. } => {
+                                self.compile_expr(context, value)?;
+                                context.code.push(Instruction::ArrayExtend);
+                            }
+                        }
+                    }
+                    context.code.push(Instruction::ConstructWithArray);
+                }
+            }
+            Expr::Template {
+                quasis,
+                expressions,
+                ..
+            } => {
+                let mut parts = Vec::new();
+                for (index, quasi) in quasis.iter().enumerate() {
+                    if !quasi.is_empty() {
+                        parts.push(Expr::String {
+                            span: SourceSpan::new(0, 0),
+                            value: quasi.clone(),
+                        });
+                    }
+                    if let Some(expression) = expressions.get(index) {
+                        parts.push(expression.clone());
+                    }
+                }
+                if parts.is_empty() {
+                    context.code.push(Instruction::PushString(String::new()));
+                } else {
+                    self.compile_expr(context, &parts[0])?;
+                    for part in parts.iter().skip(1) {
+                        self.compile_expr(context, part)?;
+                        context.code.push(Instruction::Binary(BinaryOp::Add));
+                    }
+                }
+            }
+            Expr::Await { value, .. } => {
+                self.compile_expr(context, value)?;
+                context.code.push(Instruction::Await);
+            }
+        }
+        Ok(())
+    }
+}

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

@@ -0,0 +1,173 @@
+mod assignments;
+mod bindings;
+mod context;
+mod control;
+mod expressions;
+mod statements;
+
+use std::collections::HashSet;
+
+use bindings::collect_block_bindings;
+use context::CompileContext;
+
+use crate::{
+    diagnostic::MustardResult,
+    ir::{CompiledProgram, FunctionExpr, Pattern, Stmt},
+    span::SourceSpan,
+};
+
+use super::{
+    bytecode::{BytecodeProgram, FunctionPrototype, Instruction},
+    validation::validate_bytecode_program,
+};
+
+pub(super) fn pattern_bindings(pattern: &Pattern) -> Vec<(String, bool)> {
+    bindings::pattern_bindings(pattern)
+}
+
+pub fn lower_to_bytecode(program: &CompiledProgram) -> MustardResult<BytecodeProgram> {
+    let mut compiler = Compiler::default();
+    let root = compiler.compile_root(&program.script.body, program.script.span)?;
+    let program = BytecodeProgram {
+        functions: compiler.functions,
+        root,
+    };
+    validate_bytecode_program(&program)?;
+    Ok(program)
+}
+
+#[derive(Debug, Default)]
+struct Compiler {
+    functions: Vec<FunctionPrototype>,
+}
+
+impl Compiler {
+    fn compile_root(&mut self, statements: &[Stmt], span: SourceSpan) -> MustardResult<usize> {
+        let mut context = CompileContext::default();
+        self.emit_block_prologue(&mut context, statements, true)?;
+        let mut produced_result = false;
+        for (index, statement) in statements.iter().enumerate() {
+            let is_last = index + 1 == statements.len();
+            if is_last && let Stmt::Expression { expression, .. } = statement {
+                self.compile_expr(&mut context, expression)?;
+                produced_result = true;
+                continue;
+            }
+            self.compile_stmt(&mut context, statement)?;
+        }
+        if !produced_result {
+            context.code.push(Instruction::PushUndefined);
+        }
+        context.code.push(Instruction::Return);
+        let id = self.functions.len();
+        self.functions.push(FunctionPrototype {
+            name: None,
+            length: 0,
+            display_source: String::new(),
+            params: Vec::new(),
+            rest: None,
+            code: context.code,
+            is_async: false,
+            is_arrow: false,
+            span,
+        });
+        Ok(id)
+    }
+
+    fn compile_function(&mut self, function: &FunctionExpr) -> MustardResult<usize> {
+        self.compile_function_body(function)
+    }
+
+    fn compile_function_body(&mut self, function: &FunctionExpr) -> MustardResult<usize> {
+        let mut context = CompileContext::default();
+        for statement in &function.param_init {
+            if let Stmt::VariableDecl { declarators, .. } = statement {
+                for declarator in declarators {
+                    for (name, _) in pattern_bindings(&declarator.pattern) {
+                        context.code.push(Instruction::DeclareName {
+                            name,
+                            mutable: true,
+                        });
+                    }
+                    if let Some(initializer) = &declarator.initializer {
+                        self.compile_expr(&mut context, initializer)?;
+                    } else {
+                        context.code.push(Instruction::PushUndefined);
+                    }
+                    self.compile_pattern_binding(&mut context, &declarator.pattern)?;
+                }
+            }
+        }
+        self.emit_block_prologue(&mut context, &function.body, false)?;
+        for statement in &function.body {
+            self.compile_stmt(&mut context, statement)?;
+        }
+        context.code.push(Instruction::PushUndefined);
+        context.code.push(Instruction::Return);
+        let id = self.functions.len();
+        self.functions.push(FunctionPrototype {
+            name: function.name.clone(),
+            length: function.length,
+            display_source: function.display_source.clone(),
+            params: function.params.clone(),
+            rest: function.rest.clone(),
+            code: context.code,
+            is_async: function.is_async,
+            is_arrow: function.is_arrow,
+            span: function.span,
+        });
+        Ok(id)
+    }
+
+    fn emit_block_prologue(
+        &mut self,
+        context: &mut CompileContext,
+        statements: &[Stmt],
+        root_scope: bool,
+    ) -> MustardResult<()> {
+        let mut declared = HashSet::new();
+        let bindings = collect_block_bindings(statements);
+        for (name, mutable) in bindings.lexicals {
+            if declared.insert(name.clone()) {
+                context
+                    .code
+                    .push(Instruction::DeclareName { name, mutable });
+            }
+        }
+        for function in bindings.functions {
+            let function_name = function.name.clone();
+            if declared.insert(function_name.clone()) {
+                context.code.push(Instruction::DeclareName {
+                    name: function_name.clone(),
+                    mutable: false,
+                });
+            }
+            context.code.push(Instruction::MakeClosure {
+                function_id: self.compile_function(&function.expr)?,
+            });
+            context
+                .code
+                .push(Instruction::InitializePattern(Pattern::Identifier {
+                    span: function.expr.span,
+                    name: function_name.clone(),
+                }));
+            if root_scope {
+                context.code.push(Instruction::LoadGlobalObject);
+                context
+                    .code
+                    .push(Instruction::LoadName(function_name.clone()));
+                context.code.push(Instruction::SetPropStatic {
+                    name: function_name,
+                });
+                context.code.push(Instruction::Pop);
+            }
+        }
+        Ok(())
+    }
+
+    fn fresh_internal_name(&self, context: &mut CompileContext, prefix: &str) -> String {
+        let name = format!("\0mustard_{prefix}_{}", context.internal_name_counter);
+        context.internal_name_counter += 1;
+        name
+    }
+}