mustardscript 0.1.0

package/crates/mustard/src/parser/statements.rs

@@ -0,0 +1,298 @@
+use super::*;
+
+impl<'a> Lowerer<'a> {
+    pub(super) fn lower_block_stmt(&mut self, block: &BlockStatement<'a>) -> Stmt {
+        self.push_scope();
+        self.predeclare_block(&block.body);
+        let body = block
+            .body
+            .iter()
+            .filter_map(|statement| self.lower_stmt(statement))
+            .collect();
+        self.pop_scope();
+        Stmt::Block {
+            span: block.span.into(),
+            body,
+        }
+    }
+
+    pub(super) fn lower_stmt(&mut self, statement: &Statement<'a>) -> Option<Stmt> {
+        match statement {
+            Statement::BlockStatement(block) => Some(self.lower_block_stmt(block)),
+            Statement::BreakStatement(statement) => Some(Stmt::Break {
+                span: statement.span.into(),
+            }),
+            Statement::ContinueStatement(statement) => Some(Stmt::Continue {
+                span: statement.span.into(),
+            }),
+            Statement::EmptyStatement(statement) => Some(Stmt::Empty {
+                span: statement.span.into(),
+            }),
+            Statement::ExpressionStatement(statement) => Some(Stmt::Expression {
+                span: statement.span.into(),
+                expression: self.lower_expr(&statement.expression)?,
+            }),
+            Statement::ForStatement(statement) => {
+                let init = match &statement.init {
+                    Some(ForStatementInit::VariableDeclaration(decl)) => {
+                        Some(ForInit::VariableDecl {
+                            kind: self.lower_binding_kind(decl.kind, decl.span)?,
+                            declarators: decl
+                                .declarations
+                                .iter()
+                                .filter_map(|declarator| self.lower_declarator(declarator))
+                                .collect(),
+                        })
+                    }
+                    Some(init) => Some(ForInit::Expression(self.lower_for_init_expr(init)?)),
+                    None => None,
+                };
+                Some(Stmt::For {
+                    span: statement.span.into(),
+                    init,
+                    test: statement
+                        .test
+                        .as_ref()
+                        .and_then(|test| self.lower_expr(test)),
+                    update: statement
+                        .update
+                        .as_ref()
+                        .and_then(|expr| self.lower_expr(expr)),
+                    body: Box::new(self.lower_stmt(&statement.body)?),
+                })
+            }
+            Statement::ForOfStatement(statement) => {
+                let head = self.lower_for_loop_head(&statement.left, "for...of")?;
+
+                let iterable = self.lower_expr(&statement.right)?;
+                let body = match &head {
+                    crate::ir::ForOfHead::Binding { pattern, .. } => {
+                        self.push_scope();
+                        self.collect_ir_pattern_bindings(pattern);
+                        let body = self.lower_stmt(&statement.body);
+                        self.pop_scope();
+                        Box::new(body?)
+                    }
+                    crate::ir::ForOfHead::Assignment { .. } => {
+                        Box::new(self.lower_stmt(&statement.body)?)
+                    }
+                };
+
+                Some(Stmt::ForOf {
+                    span: statement.span.into(),
+                    await_each: statement.r#await,
+                    head,
+                    iterable,
+                    body,
+                })
+            }
+            Statement::ForInStatement(statement) => {
+                let head = self.lower_for_loop_head(&statement.left, "for...in")?;
+                let iterable = self.lower_expr(&statement.right)?;
+                let body = match &head {
+                    crate::ir::ForOfHead::Binding { pattern, .. } => {
+                        self.push_scope();
+                        self.collect_ir_pattern_bindings(pattern);
+                        let body = self.lower_stmt(&statement.body);
+                        self.pop_scope();
+                        Box::new(body?)
+                    }
+                    crate::ir::ForOfHead::Assignment { .. } => {
+                        Box::new(self.lower_stmt(&statement.body)?)
+                    }
+                };
+
+                Some(Stmt::ForIn {
+                    span: statement.span.into(),
+                    head,
+                    object: iterable,
+                    body,
+                })
+            }
+            Statement::IfStatement(statement) => Some(Stmt::If {
+                span: statement.span.into(),
+                test: self.lower_expr(&statement.test)?,
+                consequent: Box::new(self.lower_stmt(&statement.consequent)?),
+                alternate: statement
+                    .alternate
+                    .as_ref()
+                    .and_then(|alternate| self.lower_stmt(alternate))
+                    .map(Box::new),
+            }),
+            Statement::ReturnStatement(statement) => Some(Stmt::Return {
+                span: statement.span.into(),
+                value: statement
+                    .argument
+                    .as_ref()
+                    .and_then(|expr| self.lower_expr(expr)),
+            }),
+            Statement::SwitchStatement(statement) => Some(Stmt::Switch {
+                span: statement.span.into(),
+                discriminant: self.lower_expr(&statement.discriminant)?,
+                cases: statement
+                    .cases
+                    .iter()
+                    .map(|case| crate::ir::SwitchCase {
+                        span: case.span.into(),
+                        test: case.test.as_ref().and_then(|expr| self.lower_expr(expr)),
+                        consequent: case
+                            .consequent
+                            .iter()
+                            .filter_map(|statement| self.lower_stmt(statement))
+                            .collect(),
+                    })
+                    .collect(),
+            }),
+            Statement::ThrowStatement(statement) => Some(Stmt::Throw {
+                span: statement.span.into(),
+                value: self.lower_expr(&statement.argument)?,
+            }),
+            Statement::TryStatement(statement) => Some(Stmt::Try {
+                span: statement.span.into(),
+                body: Box::new(self.lower_block_stmt(&statement.block)),
+                catch: statement.handler.as_ref().map(|handler| {
+                    self.push_scope();
+                    if let Some(param) = &handler.param {
+                        self.collect_pattern_bindings(&param.pattern);
+                    }
+                    self.predeclare_block(&handler.body.body);
+                    let clause = crate::ir::CatchClause {
+                        span: handler.span.into(),
+                        parameter: handler
+                            .param
+                            .as_ref()
+                            .and_then(|param| self.lower_pattern(&param.pattern)),
+                        body: Box::new(self.lower_block_stmt(&handler.body)),
+                    };
+                    self.pop_scope();
+                    clause
+                }),
+                finally: statement
+                    .finalizer
+                    .as_ref()
+                    .map(|block| Box::new(self.lower_block_stmt(block))),
+            }),
+            Statement::VariableDeclaration(decl) => Some(Stmt::VariableDecl {
+                span: decl.span.into(),
+                kind: self.lower_binding_kind(decl.kind, decl.span)?,
+                declarators: decl
+                    .declarations
+                    .iter()
+                    .filter_map(|declarator| self.lower_declarator(declarator))
+                    .collect(),
+            }),
+            Statement::WhileStatement(statement) => Some(Stmt::While {
+                span: statement.span.into(),
+                test: self.lower_expr(&statement.test)?,
+                body: Box::new(self.lower_stmt(&statement.body)?),
+            }),
+            Statement::DoWhileStatement(statement) => Some(Stmt::DoWhile {
+                span: statement.span.into(),
+                body: Box::new(self.lower_stmt(&statement.body)?),
+                test: self.lower_expr(&statement.test)?,
+            }),
+            Statement::FunctionDeclaration(function) => Some(Stmt::FunctionDecl {
+                span: function.span.into(),
+                function: self.lower_function(function, false)?,
+            }),
+            Statement::DebuggerStatement(statement) => {
+                self.unsupported(
+                    "debugger statements are not supported",
+                    Some(statement.span.into()),
+                );
+                None
+            }
+            Statement::LabeledStatement(statement) => {
+                self.unsupported(
+                    "labeled statements are not supported in v1",
+                    Some(statement.span.into()),
+                );
+                None
+            }
+            statement if statement.is_module_declaration() => {
+                self.unsupported(
+                    "module syntax is not supported",
+                    Some(statement.span().into()),
+                );
+                None
+            }
+            Statement::WithStatement(statement) => {
+                self.unsupported("with is not supported", Some(statement.span.into()));
+                None
+            }
+            Statement::ClassDeclaration(class) => {
+                self.unsupported("classes are not supported in v1", Some(class.span.into()));
+                None
+            }
+            statement => {
+                self.unsupported(
+                    format!("unsupported statement form: {statement:?}"),
+                    Some(statement.span().into()),
+                );
+                None
+            }
+        }
+    }
+
+    fn lower_for_loop_head(
+        &mut self,
+        left: &ForStatementLeft<'a>,
+        loop_name: &str,
+    ) -> Option<crate::ir::ForOfHead> {
+        match left {
+            ForStatementLeft::VariableDeclaration(decl) => {
+                if decl.declarations.len() != 1 {
+                    self.unsupported(
+                        format!("{loop_name} currently requires exactly one let or const binding"),
+                        Some(decl.span.into()),
+                    );
+                    return None;
+                }
+                let declarator = &decl.declarations[0];
+                if declarator.init.is_some() {
+                    self.unsupported(
+                        format!("{loop_name} binding initializers are not supported"),
+                        Some(declarator.span.into()),
+                    );
+                    return None;
+                }
+                Some(crate::ir::ForOfHead::Binding {
+                    kind: self.lower_binding_kind(decl.kind, decl.span)?,
+                    pattern: self.lower_pattern(&declarator.id)?,
+                })
+            }
+            _ => Some(crate::ir::ForOfHead::Assignment {
+                target: self.lower_for_of_assignment_target(left)?,
+            }),
+        }
+    }
+
+    pub(super) fn lower_binding_kind(
+        &mut self,
+        kind: VariableDeclarationKind,
+        span: oxc_span::Span,
+    ) -> Option<BindingKind> {
+        match kind {
+            VariableDeclarationKind::Let => Some(BindingKind::Let),
+            VariableDeclarationKind::Const => Some(BindingKind::Const),
+            _ => {
+                self.unsupported("only let and const are supported", Some(span.into()));
+                None
+            }
+        }
+    }
+
+    pub(super) fn lower_declarator(
+        &mut self,
+        declarator: &VariableDeclarator<'a>,
+    ) -> Option<Declarator> {
+        Some(Declarator {
+            span: declarator.span.into(),
+            pattern: self.lower_pattern(&declarator.id)?,
+            initializer: declarator
+                .init
+                .as_ref()
+                .and_then(|expr| self.lower_expr(expr)),
+        })
+    }
+}

package/crates/mustard/src/parser/tests/acceptance.rs

@@ -0,0 +1,339 @@
+use crate::{
+    compile,
+    ir::{ArrayElement, AssignOp, CallArgument, Expr, Stmt},
+};
+
+#[test]
+fn parses_basic_function_and_if() {
+    let program = compile(
+        r#"
+        const add = (a, b) => {
+          if (a > b) {
+            return a + b;
+          }
+          return a ?? b;
+        };
+        "#,
+    )
+    .expect("program should compile");
+
+    assert_eq!(program.script.body.len(), 1);
+    match &program.script.body[0] {
+        Stmt::VariableDecl { declarators, .. } => {
+            assert_eq!(declarators.len(), 1);
+        }
+        other => panic!("unexpected stmt: {other:?}"),
+    }
+}
+
+#[test]
+fn allows_shadowed_require() {
+    compile("const require = () => 1; require();").expect("shadowed require should compile");
+}
+
+#[test]
+fn allows_shadowed_function_identifier() {
+    compile("const Function = (value) => value; Function(1);")
+        .expect("shadowed Function should compile");
+}
+
+#[test]
+fn allows_shadowed_arguments_identifier() {
+    compile("const arguments = [1]; arguments[0];").expect("shadowed arguments should compile");
+}
+
+#[test]
+fn parses_array_for_of_with_const_binding() {
+    let program = compile(
+        r#"
+        let total = 0;
+        for (const value of [1, 2, 3]) {
+          total += value;
+        }
+        total;
+        "#,
+    )
+    .expect("for...of over arrays should compile");
+
+    assert!(matches!(program.script.body[1], Stmt::ForOf { .. }));
+}
+
+#[test]
+fn parses_for_of_with_assignment_targets() {
+    let program = compile(
+        r#"
+        let value = 0;
+        const boxes = [{ current: 0 }, { current: 0 }];
+        let index = 0;
+        for (value of [1, 2]) {
+          index += value;
+        }
+        for (boxes[index - 3].current of [3, 4]) {
+          index += 1;
+        }
+        value + boxes[0].current + boxes[1].current + index;
+        "#,
+    )
+    .expect("for...of assignment-target headers should compile");
+
+    assert!(matches!(program.script.body[3], Stmt::ForOf { .. }));
+    assert!(matches!(program.script.body[4], Stmt::ForOf { .. }));
+}
+
+#[test]
+fn parses_for_in_with_binding_and_assignment_targets() {
+    let program = compile(
+        r#"
+        let total = 0;
+        const boxes = [{ current: 0 }, { current: 0 }];
+        let index = 0;
+        for (const key in { beta: 2, alpha: 1 }) {
+          total += key.length;
+        }
+        for (boxes[index].current in [3, 4]) {
+          index += 1;
+        }
+        total + boxes[0].current + boxes[1].current + index;
+        "#,
+    )
+    .expect("for...in should compile");
+
+    assert!(matches!(program.script.body[3], Stmt::ForIn { .. }));
+    assert!(matches!(program.script.body[4], Stmt::ForIn { .. }));
+}
+
+#[test]
+fn parses_for_await_of_inside_async_functions() {
+    compile(
+        r#"
+        async function run(values, boxRef) {
+          for await (const value of values) {
+            boxRef.total += value;
+          }
+          for await (boxRef.current of values) {
+            boxRef.total += boxRef.current;
+          }
+          return boxRef.total;
+        }
+        "#,
+    )
+    .expect("for await...of should compile inside async functions");
+}
+
+#[test]
+fn parses_default_parameters_and_default_destructuring() {
+    compile(
+        r#"
+        function wrap(value = 1, { label = "ok" } = {}) {
+          return [value, label];
+        }
+        wrap();
+        "#,
+    )
+    .expect("default parameters and destructuring should compile");
+}
+
+#[test]
+fn parses_destructuring_assignment_targets_and_update_expressions() {
+    compile(
+        r#"
+        let value = 0;
+        let boxRef = { current: 1 };
+        [value, boxRef.current] = [2, 3];
+        ({ value, current: boxRef.current = 4 } = { value: 5 });
+        ++value;
+        boxRef.current--;
+        "#,
+    )
+    .expect("destructuring assignment and update expressions should compile");
+}
+
+#[test]
+fn parses_sequence_and_exponentiation_expressions() {
+    compile(
+        r#"
+        let total = 0;
+        const value = (total = total + 1, total = total + 2, 2 ** 3 ** 2);
+        [value, total];
+        "#,
+    )
+    .expect("sequence expressions and exponentiation should compile");
+}
+
+#[test]
+fn parses_remainder_and_exponent_assignment_expressions() {
+    compile(
+        r#"
+        let left = 10;
+        let right = 2;
+        left %= 3;
+        right **= 3;
+        [left, right];
+        "#,
+    )
+    .expect("compound remainder and exponent assignments should compile");
+}
+
+#[test]
+fn parses_in_operator_expressions() {
+    compile(
+        r#"
+        const object = { alpha: undefined };
+        const array = [1, 2];
+        ["alpha" in object, 1 in array, "push" in array];
+        "#,
+    )
+    .expect("in operator expressions should compile");
+}
+
+#[test]
+fn parses_instanceof_expressions() {
+    compile(
+        r#"
+        function Box() {}
+        [([] instanceof Array), (new Map() instanceof Object), ({} instanceof Box)];
+        "#,
+    )
+    .expect("instanceof should compile for the documented constructor surface");
+}
+
+#[test]
+fn parses_object_literals_with_computed_keys_methods_and_spread() {
+    compile(
+        r#"
+        const key = "value";
+        const extra = [3];
+        extra.label = "ok";
+        ({
+          [key]: 1,
+          total(step) {
+            return this[key] + step;
+          },
+          ...null,
+          ...extra,
+          beta: 4,
+        });
+        "#,
+    )
+    .expect("object literal computed keys, methods, and spread should compile");
+}
+
+#[test]
+fn parses_sparse_array_literals() {
+    compile(
+        r#"
+        const values = [1, , 3];
+        [values.length, values[1], 1 in values];
+        "#,
+    )
+    .expect("sparse array literals should compile");
+}
+
+#[test]
+fn lowers_array_spread_into_ir() {
+    let program = compile("[1, ...values, 3];").expect("array spread should compile");
+
+    let Stmt::Expression { expression, .. } = &program.script.body[0] else {
+        panic!("unexpected stmt: {:?}", program.script.body[0]);
+    };
+    let Expr::Array { elements, .. } = expression else {
+        panic!("unexpected expr: {expression:?}");
+    };
+
+    assert!(matches!(elements[0], ArrayElement::Value(_)));
+    assert!(matches!(elements[1], ArrayElement::Spread { .. }));
+    assert!(matches!(elements[2], ArrayElement::Value(_)));
+}
+
+#[test]
+fn lowers_spread_call_arguments_into_ir() {
+    let program = compile("run(1, ...values, 3);").expect("spread call arguments should compile");
+
+    let Stmt::Expression { expression, .. } = &program.script.body[0] else {
+        panic!("unexpected stmt: {:?}", program.script.body[0]);
+    };
+    let Expr::Call { arguments, .. } = expression else {
+        panic!("unexpected expr: {expression:?}");
+    };
+
+    assert!(matches!(arguments[0], CallArgument::Value(_)));
+    assert!(matches!(arguments[1], CallArgument::Spread { .. }));
+    assert!(matches!(arguments[2], CallArgument::Value(_)));
+}
+
+#[test]
+fn lowers_spread_constructor_arguments_into_ir() {
+    let program =
+        compile("new Box(1, ...values, 3);").expect("spread constructor arguments should compile");
+
+    let Stmt::Expression { expression, .. } = &program.script.body[0] else {
+        panic!("unexpected stmt: {:?}", program.script.body[0]);
+    };
+    let Expr::New { arguments, .. } = expression else {
+        panic!("unexpected expr: {expression:?}");
+    };
+
+    assert!(matches!(arguments[0], CallArgument::Value(_)));
+    assert!(matches!(arguments[1], CallArgument::Spread { .. }));
+    assert!(matches!(arguments[2], CallArgument::Value(_)));
+}
+
+#[test]
+fn lowers_spread_optional_call_arguments_into_ir() {
+    let program =
+        compile("maybeRun?.(1, ...values, 3);").expect("optional spread call should compile");
+
+    let Stmt::Expression { expression, .. } = &program.script.body[0] else {
+        panic!("unexpected stmt: {:?}", program.script.body[0]);
+    };
+    let Expr::Call {
+        arguments,
+        optional,
+        ..
+    } = expression
+    else {
+        panic!("unexpected expr: {expression:?}");
+    };
+
+    assert!(*optional);
+    assert!(matches!(arguments[0], CallArgument::Value(_)));
+    assert!(matches!(arguments[1], CallArgument::Spread { .. }));
+    assert!(matches!(arguments[2], CallArgument::Value(_)));
+}
+
+#[test]
+fn parses_logical_assignment_operators_into_ir() {
+    let program = compile(
+        r#"
+        let truthy = 1;
+        let falsy = 0;
+        truthy ||= 2;
+        falsy &&= 3;
+        "#,
+    )
+    .expect("logical assignment operators should parse");
+
+    match &program.script.body[2] {
+        Stmt::Expression {
+            expression:
+                Expr::Assignment {
+                    operator: AssignOp::OrAssign,
+                    ..
+                },
+            ..
+        } => {}
+        other => panic!("expected ||= assignment expression, got {other:?}"),
+    }
+
+    match &program.script.body[3] {
+        Stmt::Expression {
+            expression:
+                Expr::Assignment {
+                    operator: AssignOp::AndAssign,
+                    ..
+                },
+            ..
+        } => {}
+        other => panic!("expected &&= assignment expression, got {other:?}"),
+    }
+}

package/crates/mustard/src/parser/tests/mod.rs

@@ -0,0 +1,2 @@
+mod acceptance;
+mod rejections;