mustardscript 0.1.0 → 0.1.1

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

@@ -1,298 +0,0 @@
-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

@@ -1,339 +0,0 @@
-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

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