mustardscript 0.1.0 → 0.1.1

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

@@ -1,115 +0,0 @@
-mod expressions;
-mod operators;
-mod patterns;
-mod scope;
-mod statements;
-
-#[cfg(test)]
-mod tests;
-
-use std::collections::HashSet;
-
-use oxc_allocator::Allocator;
-use oxc_ast::ast::*;
-use oxc_parser::{ParseOptions, Parser};
-use oxc_span::{GetSpan, SourceType};
-
-use crate::{
-    diagnostic::{Diagnostic, MustardError, MustardResult},
-    ir::*,
-    span::SourceSpan,
-};
-
-const FORBIDDEN_AMBIENT_GLOBALS: &[&str] = &[
-    "arguments",
-    "eval",
-    "process",
-    "module",
-    "exports",
-    "global",
-    "require",
-    "Function",
-    "setTimeout",
-    "setInterval",
-    "queueMicrotask",
-    "fetch",
-];
-
-pub fn compile(source: &str) -> MustardResult<CompiledProgram> {
-    let allocator = Allocator::default();
-    let parser = Parser::new(&allocator, source, SourceType::default().with_script(true))
-        .with_options(ParseOptions {
-            allow_return_outside_function: false,
-            ..ParseOptions::default()
-        });
-    let parsed = parser.parse();
-    let mut diagnostics = Vec::new();
-    diagnostics.extend(
-        parsed
-            .errors
-            .into_iter()
-            .map(|error| Diagnostic::parse(error.to_string(), None)),
-    );
-    if parsed.panicked {
-        return Err(MustardError::Diagnostics(diagnostics));
-    }
-
-    let mut lowerer = Lowerer::new(source);
-    let script = lowerer.lower_program(&parsed.program);
-    diagnostics.extend(lowerer.diagnostics);
-    if !diagnostics.is_empty() {
-        return Err(MustardError::Diagnostics(diagnostics));
-    }
-    Ok(CompiledProgram {
-        source: source.to_string(),
-        script,
-    })
-}
-
-struct Lowerer<'a> {
-    diagnostics: Vec<Diagnostic>,
-    _source: &'a str,
-    scopes: Vec<HashSet<String>>,
-    internal_name_counter: usize,
-}
-
-impl<'a> Lowerer<'a> {
-    fn new(source: &'a str) -> Self {
-        Self {
-            diagnostics: Vec::new(),
-            _source: source,
-            scopes: vec![HashSet::new()],
-            internal_name_counter: 0,
-        }
-    }
-
-    fn lower_program(&mut self, program: &Program<'a>) -> Script {
-        self.predeclare_block(&program.body);
-        let body = program
-            .body
-            .iter()
-            .filter_map(|statement| self.lower_stmt(statement))
-            .collect();
-        Script {
-            span: program.span.into(),
-            body,
-        }
-    }
-
-    fn unsupported(&mut self, message: impl Into<String>, span: Option<SourceSpan>) {
-        self.diagnostics
-            .push(Diagnostic::validation(message.into(), span));
-    }
-
-    fn fresh_internal_name(&mut self, prefix: &str) -> String {
-        let name = format!("\0mustard_{prefix}_{}", self.internal_name_counter);
-        self.internal_name_counter += 1;
-        name
-    }
-
-    fn source_snippet(&self, span: SourceSpan) -> String {
-        let start = span.start as usize;
-        let end = span.end as usize;
-        self._source.get(start..end).unwrap_or_default().to_string()
-    }
-}

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

@@ -1,105 +0,0 @@
-use super::*;
-
-impl<'a> Lowerer<'a> {
-    pub(super) fn lower_property_name(&mut self, key: &PropertyKey<'a>) -> Option<PropertyName> {
-        match key {
-            PropertyKey::StaticIdentifier(identifier) => Some(PropertyName::Identifier(
-                identifier.name.as_str().to_string(),
-            )),
-            PropertyKey::StringLiteral(literal) => {
-                Some(PropertyName::String(literal.value.as_str().to_string()))
-            }
-            PropertyKey::NumericLiteral(literal) => Some(PropertyName::Number(literal.value)),
-            _ => {
-                self.unsupported("unsupported property key in v1", Some(key.span().into()));
-                None
-            }
-        }
-    }
-
-    pub(super) fn lower_unary_op(
-        &mut self,
-        op: UnaryOperator,
-        span: oxc_span::Span,
-    ) -> Option<UnaryOp> {
-        match op {
-            UnaryOperator::UnaryPlus => Some(UnaryOp::Plus),
-            UnaryOperator::UnaryNegation => Some(UnaryOp::Minus),
-            UnaryOperator::LogicalNot => Some(UnaryOp::Not),
-            UnaryOperator::Typeof => Some(UnaryOp::Typeof),
-            UnaryOperator::Void => Some(UnaryOp::Void),
-            UnaryOperator::Delete => {
-                self.unsupported("delete is not supported in v1", Some(span.into()));
-                None
-            }
-            _ => {
-                self.unsupported("unsupported unary operator in v1", Some(span.into()));
-                None
-            }
-        }
-    }
-
-    pub(super) fn lower_binary_op(
-        &mut self,
-        op: BinaryOperator,
-        span: oxc_span::Span,
-    ) -> Option<BinaryOp> {
-        match op {
-            BinaryOperator::Addition => Some(BinaryOp::Add),
-            BinaryOperator::Subtraction => Some(BinaryOp::Sub),
-            BinaryOperator::Multiplication => Some(BinaryOp::Mul),
-            BinaryOperator::Division => Some(BinaryOp::Div),
-            BinaryOperator::Remainder => Some(BinaryOp::Rem),
-            BinaryOperator::Exponential => Some(BinaryOp::Pow),
-            BinaryOperator::In => Some(BinaryOp::In),
-            BinaryOperator::Instanceof => Some(BinaryOp::Instanceof),
-            BinaryOperator::Equality => Some(BinaryOp::Eq),
-            BinaryOperator::Inequality => Some(BinaryOp::NotEq),
-            BinaryOperator::StrictEquality => Some(BinaryOp::StrictEq),
-            BinaryOperator::StrictInequality => Some(BinaryOp::StrictNotEq),
-            BinaryOperator::LessThan => Some(BinaryOp::LessThan),
-            BinaryOperator::LessEqualThan => Some(BinaryOp::LessThanEq),
-            BinaryOperator::GreaterThan => Some(BinaryOp::GreaterThan),
-            BinaryOperator::GreaterEqualThan => Some(BinaryOp::GreaterThanEq),
-            _ => {
-                self.unsupported("unsupported binary operator in v1", Some(span.into()));
-                None
-            }
-        }
-    }
-
-    pub(super) fn lower_logical_op(
-        &mut self,
-        op: LogicalOperator,
-        _span: oxc_span::Span,
-    ) -> Option<LogicalOp> {
-        match op {
-            LogicalOperator::And => Some(LogicalOp::And),
-            LogicalOperator::Or => Some(LogicalOp::Or),
-            LogicalOperator::Coalesce => Some(LogicalOp::NullishCoalesce),
-        }
-    }
-
-    pub(super) fn lower_assign_op(
-        &mut self,
-        op: AssignmentOperator,
-        span: oxc_span::Span,
-    ) -> Option<AssignOp> {
-        match op {
-            AssignmentOperator::Assign => Some(AssignOp::Assign),
-            AssignmentOperator::Addition => Some(AssignOp::AddAssign),
-            AssignmentOperator::Subtraction => Some(AssignOp::SubAssign),
-            AssignmentOperator::Multiplication => Some(AssignOp::MulAssign),
-            AssignmentOperator::Division => Some(AssignOp::DivAssign),
-            AssignmentOperator::Remainder => Some(AssignOp::RemAssign),
-            AssignmentOperator::Exponential => Some(AssignOp::PowAssign),
-            AssignmentOperator::LogicalOr => Some(AssignOp::OrAssign),
-            AssignmentOperator::LogicalAnd => Some(AssignOp::AndAssign),
-            AssignmentOperator::LogicalNullish => Some(AssignOp::NullishAssign),
-            _ => {
-                self.unsupported("unsupported assignment operator in v1", Some(span.into()));
-                None
-            }
-        }
-    }
-}

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

@@ -1,123 +0,0 @@
-use super::*;
-
-type LoweredFunctionParams = (Vec<Pattern>, Option<Pattern>, Vec<Stmt>, usize);
-
-impl<'a> Lowerer<'a> {
-    pub(super) fn lower_pattern(&mut self, pattern: &BindingPattern<'a>) -> Option<Pattern> {
-        match pattern {
-            BindingPattern::BindingIdentifier(identifier) => Some(Pattern::Identifier {
-                span: identifier.span.into(),
-                name: identifier.name.as_str().to_string(),
-            }),
-            BindingPattern::ObjectPattern(pattern) => Some(Pattern::Object {
-                span: pattern.span.into(),
-                properties: pattern
-                    .properties
-                    .iter()
-                    .filter_map(|property| {
-                        Some(ObjectPatternProperty {
-                            span: property.span.into(),
-                            key: self.lower_property_name(&property.key)?,
-                            value: self.lower_pattern(&property.value)?,
-                        })
-                    })
-                    .collect(),
-                rest: pattern
-                    .rest
-                    .as_ref()
-                    .and_then(|rest| self.lower_pattern(&rest.argument))
-                    .map(Box::new),
-            }),
-            BindingPattern::ArrayPattern(pattern) => Some(Pattern::Array {
-                span: pattern.span.into(),
-                elements: pattern
-                    .elements
-                    .iter()
-                    .map(|element| {
-                        element
-                            .as_ref()
-                            .and_then(|pattern| self.lower_pattern(pattern))
-                    })
-                    .collect(),
-                rest: pattern
-                    .rest
-                    .as_ref()
-                    .and_then(|rest| self.lower_pattern(&rest.argument))
-                    .map(Box::new),
-            }),
-            BindingPattern::AssignmentPattern(pattern) => Some(Pattern::Default {
-                span: pattern.span.into(),
-                target: Box::new(self.lower_pattern(&pattern.left)?),
-                default_value: self.lower_expr(&pattern.right)?,
-            }),
-        }
-    }
-
-    pub(super) fn lower_function_params(
-        &mut self,
-        params: &FormalParameters<'a>,
-    ) -> Option<LoweredFunctionParams> {
-        let mut lowered = Vec::with_capacity(params.items.len());
-        let mut param_init = Vec::new();
-        let mut function_length = 0usize;
-        let mut counted_default = false;
-        for param in &params.items {
-            if !counted_default {
-                let has_default = param.initializer.is_some()
-                    || matches!(param.pattern, BindingPattern::AssignmentPattern(_));
-                if has_default {
-                    counted_default = true;
-                } else {
-                    function_length += 1;
-                }
-            }
-            let temp_name = self.fresh_internal_name("param");
-            lowered.push(Pattern::Identifier {
-                span: param.span.into(),
-                name: temp_name.clone(),
-            });
-            let mut pattern = self.lower_pattern(&param.pattern)?;
-            if let Some(initializer) = &param.initializer {
-                pattern = Pattern::Default {
-                    span: param.span.into(),
-                    target: Box::new(pattern),
-                    default_value: self.lower_expr(initializer)?,
-                };
-            }
-            param_init.push(Stmt::VariableDecl {
-                span: param.span.into(),
-                kind: BindingKind::Let,
-                declarators: vec![Declarator {
-                    span: param.span.into(),
-                    pattern,
-                    initializer: Some(Expr::Identifier {
-                        span: param.span.into(),
-                        name: temp_name,
-                    }),
-                }],
-            });
-        }
-        let rest = if let Some(rest) = &params.rest {
-            let temp_name = self.fresh_internal_name("rest");
-            param_init.push(Stmt::VariableDecl {
-                span: rest.span.into(),
-                kind: BindingKind::Let,
-                declarators: vec![Declarator {
-                    span: rest.span.into(),
-                    pattern: self.lower_pattern(&rest.rest.argument)?,
-                    initializer: Some(Expr::Identifier {
-                        span: rest.span.into(),
-                        name: temp_name.clone(),
-                    }),
-                }],
-            });
-            Some(Pattern::Identifier {
-                span: rest.span.into(),
-                name: temp_name,
-            })
-        } else {
-            None
-        };
-        Some((lowered, rest, param_init, function_length))
-    }
-}

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

@@ -1,107 +0,0 @@
-use super::*;
-
-impl<'a> Lowerer<'a> {
-    fn declare_name_in_current_scope(&mut self, name: &str, span: SourceSpan) {
-        if let Some(scope) = self.scopes.last_mut()
-            && !scope.insert(name.to_string())
-        {
-            self.unsupported(
-                format!("SyntaxError: Identifier `{name}` has already been declared"),
-                Some(span),
-            );
-        }
-    }
-
-    pub(super) fn push_scope(&mut self) {
-        self.scopes.push(HashSet::new());
-    }
-
-    pub(super) fn pop_scope(&mut self) {
-        self.scopes.pop();
-    }
-
-    pub(super) fn is_bound(&self, name: &str) -> bool {
-        self.scopes.iter().rev().any(|scope| scope.contains(name))
-    }
-
-    pub(super) fn predeclare_block(&mut self, statements: &[Statement<'a>]) {
-        for statement in statements {
-            self.predeclare_stmt(statement);
-        }
-    }
-
-    pub(super) fn predeclare_stmt(&mut self, statement: &Statement<'a>) {
-        match statement {
-            Statement::FunctionDeclaration(function) => {
-                if let Some(id) = &function.id {
-                    self.declare_name_in_current_scope(id.name.as_str(), id.span.into());
-                }
-            }
-            Statement::VariableDeclaration(decl) => {
-                if decl.kind == VariableDeclarationKind::Var
-                    || decl.kind == VariableDeclarationKind::Using
-                    || decl.kind == VariableDeclarationKind::AwaitUsing
-                {
-                    self.unsupported("only let and const are supported", Some(decl.span.into()));
-                    return;
-                }
-                for declarator in &decl.declarations {
-                    self.collect_pattern_bindings(&declarator.id);
-                }
-            }
-            _ => {}
-        }
-    }
-
-    pub(super) fn collect_pattern_bindings(&mut self, pattern: &BindingPattern<'a>) {
-        match pattern {
-            BindingPattern::BindingIdentifier(identifier) => {
-                self.declare_name_in_current_scope(identifier.name.as_str(), identifier.span.into())
-            }
-            BindingPattern::ObjectPattern(pattern) => {
-                for property in &pattern.properties {
-                    self.collect_pattern_bindings(&property.value);
-                }
-                if let Some(rest) = &pattern.rest {
-                    self.collect_pattern_bindings(&rest.argument);
-                }
-            }
-            BindingPattern::ArrayPattern(pattern) => {
-                for element in pattern.elements.iter().flatten() {
-                    self.collect_pattern_bindings(element);
-                }
-                if let Some(rest) = &pattern.rest {
-                    self.collect_pattern_bindings(&rest.argument);
-                }
-            }
-            BindingPattern::AssignmentPattern(pattern) => {
-                self.collect_pattern_bindings(&pattern.left);
-            }
-        }
-    }
-
-    pub(super) fn collect_ir_pattern_bindings(&mut self, pattern: &Pattern) {
-        match pattern {
-            Pattern::Identifier { name, span } => self.declare_name_in_current_scope(name, *span),
-            Pattern::Object {
-                properties, rest, ..
-            } => {
-                for property in properties {
-                    self.collect_ir_pattern_bindings(&property.value);
-                }
-                if let Some(rest) = rest {
-                    self.collect_ir_pattern_bindings(rest);
-                }
-            }
-            Pattern::Array { elements, rest, .. } => {
-                for element in elements.iter().flatten() {
-                    self.collect_ir_pattern_bindings(element);
-                }
-                if let Some(rest) = rest {
-                    self.collect_ir_pattern_bindings(rest);
-                }
-            }
-            Pattern::Default { target, .. } => self.collect_ir_pattern_bindings(target),
-        }
-    }
-}