mustardscript 0.1.0

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

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

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

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

@@ -0,0 +1,107 @@
+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),
+        }
+    }
+}