mustardscript 0.1.0 → 0.1.1

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

@@ -1,723 +0,0 @@
-use super::*;
-
-impl<'a> Lowerer<'a> {
-    pub(super) fn lower_function(
-        &mut self,
-        function: &Function<'a>,
-        is_arrow: bool,
-    ) -> Option<FunctionExpr> {
-        if function.generator {
-            self.unsupported(
-                "generators are not supported in v1",
-                Some(function.span.into()),
-            );
-            return None;
-        }
-        let Some(body) = function.body.as_ref() else {
-            self.unsupported(
-                "functions without bodies are not supported",
-                Some(function.span.into()),
-            );
-            return None;
-        };
-        let (params, rest, param_init, length) = self.lower_function_params(&function.params)?;
-        self.push_scope();
-        for statement in &param_init {
-            if let Stmt::VariableDecl { declarators, .. } = statement {
-                for declarator in declarators {
-                    self.collect_ir_pattern_bindings(&declarator.pattern);
-                }
-            }
-        }
-        self.predeclare_block(&body.statements);
-        let lowered = body
-            .statements
-            .iter()
-            .filter_map(|statement| self.lower_stmt(statement))
-            .collect();
-        self.pop_scope();
-        Some(FunctionExpr {
-            span: function.span.into(),
-            name: function.id.as_ref().map(|id| id.name.as_str().to_string()),
-            length,
-            display_source: self.source_snippet(function.span.into()),
-            params,
-            rest,
-            param_init,
-            body: lowered,
-            is_async: function.r#async,
-            is_arrow,
-        })
-    }
-
-    pub(super) fn lower_arrow_function(
-        &mut self,
-        function: &ArrowFunctionExpression<'a>,
-    ) -> Option<FunctionExpr> {
-        let (params, rest, param_init, length) = self.lower_function_params(&function.params)?;
-        self.push_scope();
-        for statement in &param_init {
-            if let Stmt::VariableDecl { declarators, .. } = statement {
-                for declarator in declarators {
-                    self.collect_ir_pattern_bindings(&declarator.pattern);
-                }
-            }
-        }
-        self.predeclare_block(&function.body.statements);
-        let body = if function.expression {
-            if function.body.statements.len() == 1 {
-                match &function.body.statements[0] {
-                    Statement::ExpressionStatement(statement) => vec![Stmt::Return {
-                        span: statement.span.into(),
-                        value: Some(self.lower_expr(&statement.expression)?),
-                    }],
-                    statement => vec![self.lower_stmt(statement)?],
-                }
-            } else {
-                function
-                    .body
-                    .statements
-                    .iter()
-                    .filter_map(|statement| self.lower_stmt(statement))
-                    .collect()
-            }
-        } else {
-            function
-                .body
-                .statements
-                .iter()
-                .filter_map(|statement| self.lower_stmt(statement))
-                .collect()
-        };
-        self.pop_scope();
-        Some(FunctionExpr {
-            span: function.span.into(),
-            name: None,
-            length,
-            display_source: self.source_snippet(function.span.into()),
-            params,
-            rest,
-            param_init,
-            body,
-            is_async: function.r#async,
-            is_arrow: true,
-        })
-    }
-
-    pub(super) fn lower_for_init_expr(&mut self, init: &ForStatementInit<'a>) -> Option<Expr> {
-        match init {
-            ForStatementInit::VariableDeclaration(_) => None,
-            expression => self.lower_expr(expression.to_expression()),
-        }
-    }
-
-    fn lower_object_property_key(
-        &mut self,
-        key: &PropertyKey<'a>,
-        computed: bool,
-    ) -> Option<crate::ir::ObjectPropertyKey> {
-        if computed {
-            return Some(crate::ir::ObjectPropertyKey::Computed(Box::new(
-                self.lower_expr(key.to_expression())?,
-            )));
-        }
-
-        Some(crate::ir::ObjectPropertyKey::Static(
-            self.lower_property_name(key)?,
-        ))
-    }
-
-    fn object_method_name(key: &crate::ir::ObjectPropertyKey) -> Option<String> {
-        match key {
-            crate::ir::ObjectPropertyKey::Static(PropertyName::Identifier(name))
-            | crate::ir::ObjectPropertyKey::Static(PropertyName::String(name)) => {
-                Some(name.clone())
-            }
-            crate::ir::ObjectPropertyKey::Static(PropertyName::Number(number)) => {
-                Some(number.to_string())
-            }
-            crate::ir::ObjectPropertyKey::Computed(_) => None,
-        }
-    }
-
-    fn lower_object_literal_property(
-        &mut self,
-        property: &oxc_ast::ast::ObjectProperty<'a>,
-    ) -> Option<crate::ir::ObjectProperty> {
-        if property.kind != PropertyKind::Init {
-            self.unsupported(
-                "object literal accessors are not supported in v1",
-                Some(property.span.into()),
-            );
-            return None;
-        }
-
-        let key = self.lower_object_property_key(&property.key, property.computed)?;
-        let mut value = self.lower_expr(&property.value)?;
-        if let (Some(name), Expr::Function(function)) = (Self::object_method_name(&key), &mut value)
-            && function.name.is_none()
-        {
-            function.name = Some(name);
-        }
-
-        Some(crate::ir::ObjectProperty::Property {
-            span: property.span.into(),
-            key,
-            value,
-        })
-    }
-
-    pub(super) fn lower_expr(&mut self, expression: &Expression<'a>) -> Option<Expr> {
-        match expression {
-            Expression::BooleanLiteral(literal) => Some(Expr::Bool {
-                span: literal.span.into(),
-                value: literal.value,
-            }),
-            Expression::NullLiteral(literal) => Some(Expr::Null {
-                span: literal.span.into(),
-            }),
-            Expression::NumericLiteral(literal) => Some(Expr::Number {
-                span: literal.span.into(),
-                value: literal.value,
-            }),
-            Expression::BigIntLiteral(literal) => Some(Expr::BigInt {
-                span: literal.span.into(),
-                value: literal.value.as_str().to_string(),
-            }),
-            Expression::StringLiteral(literal) => Some(Expr::String {
-                span: literal.span.into(),
-                value: literal.value.as_str().to_string(),
-            }),
-            Expression::TemplateLiteral(literal) => Some(Expr::Template {
-                span: literal.span.into(),
-                quasis: literal
-                    .quasis
-                    .iter()
-                    .map(|quasi| {
-                        quasi
-                            .value
-                            .cooked
-                            .as_ref()
-                            .unwrap_or(&quasi.value.raw)
-                            .as_str()
-                            .to_string()
-                    })
-                    .collect(),
-                expressions: literal
-                    .expressions
-                    .iter()
-                    .filter_map(|expr| self.lower_expr(expr))
-                    .collect(),
-            }),
-            Expression::Identifier(identifier) => {
-                let name = identifier.name.as_str();
-                if !self.is_bound(name) && FORBIDDEN_AMBIENT_GLOBALS.contains(&name) {
-                    self.unsupported(
-                        format!("free reference to forbidden ambient global `{name}`"),
-                        Some(identifier.span.into()),
-                    );
-                    return None;
-                }
-                if name == "undefined" {
-                    return Some(Expr::Undefined {
-                        span: identifier.span.into(),
-                    });
-                }
-                Some(Expr::Identifier {
-                    span: identifier.span.into(),
-                    name: name.to_string(),
-                })
-            }
-            Expression::ThisExpression(this) => Some(Expr::This {
-                span: this.span.into(),
-            }),
-            Expression::ArrayExpression(array) => {
-                let mut elements = Vec::with_capacity(array.elements.len());
-                for element in &array.elements {
-                    match element {
-                        ArrayExpressionElement::SpreadElement(spread) => {
-                            elements.push(crate::ir::ArrayElement::Spread {
-                                span: spread.span.into(),
-                                value: self.lower_expr(&spread.argument)?,
-                            });
-                        }
-                        ArrayExpressionElement::Elision(elision) => {
-                            elements.push(crate::ir::ArrayElement::Hole {
-                                span: elision.span.into(),
-                            });
-                        }
-                        element => elements.push(crate::ir::ArrayElement::Value(
-                            self.lower_expr(element.to_expression())?,
-                        )),
-                    }
-                }
-                Some(Expr::Array {
-                    span: array.span.into(),
-                    elements,
-                })
-            }
-            Expression::ObjectExpression(object) => Some(Expr::Object {
-                span: object.span.into(),
-                properties: object
-                    .properties
-                    .iter()
-                    .filter_map(|property| match property {
-                        ObjectPropertyKind::ObjectProperty(property) => {
-                            self.lower_object_literal_property(property)
-                        }
-                        ObjectPropertyKind::SpreadProperty(property) => {
-                            Some(crate::ir::ObjectProperty::Spread {
-                                span: property.span.into(),
-                                value: self.lower_expr(&property.argument)?,
-                            })
-                        }
-                    })
-                    .collect(),
-            }),
-            Expression::ArrowFunctionExpression(function) => Some(Expr::Function(Box::new(
-                self.lower_arrow_function(function)?,
-            ))),
-            Expression::FunctionExpression(function) => Some(Expr::Function(Box::new(
-                self.lower_function(function, false)?,
-            ))),
-            Expression::UnaryExpression(expression) => Some(Expr::Unary {
-                span: expression.span.into(),
-                operator: self.lower_unary_op(expression.operator, expression.span)?,
-                argument: Box::new(self.lower_expr(&expression.argument)?),
-            }),
-            Expression::BinaryExpression(expression) => Some(Expr::Binary {
-                span: expression.span.into(),
-                operator: self.lower_binary_op(expression.operator, expression.span)?,
-                left: Box::new(self.lower_expr(&expression.left)?),
-                right: Box::new(self.lower_expr(&expression.right)?),
-            }),
-            Expression::SequenceExpression(expression) => {
-                let mut expressions = Vec::with_capacity(expression.expressions.len());
-                for entry in &expression.expressions {
-                    expressions.push(self.lower_expr(entry)?);
-                }
-                Some(Expr::Sequence {
-                    span: expression.span.into(),
-                    expressions,
-                })
-            }
-            Expression::LogicalExpression(expression) => Some(Expr::Logical {
-                span: expression.span.into(),
-                operator: self.lower_logical_op(expression.operator, expression.span)?,
-                left: Box::new(self.lower_expr(&expression.left)?),
-                right: Box::new(self.lower_expr(&expression.right)?),
-            }),
-            Expression::ConditionalExpression(expression) => Some(Expr::Conditional {
-                span: expression.span.into(),
-                test: Box::new(self.lower_expr(&expression.test)?),
-                consequent: Box::new(self.lower_expr(&expression.consequent)?),
-                alternate: Box::new(self.lower_expr(&expression.alternate)?),
-            }),
-            Expression::AssignmentExpression(expression) => Some(Expr::Assignment {
-                span: expression.span.into(),
-                target: Box::new(self.lower_assignment_target(&expression.left)?),
-                operator: self.lower_assign_op(expression.operator, expression.span)?,
-                value: Box::new(self.lower_expr(&expression.right)?),
-            }),
-            Expression::CallExpression(expression) => Some(Expr::Call {
-                span: expression.span.into(),
-                callee: Box::new(self.lower_expr(&expression.callee)?),
-                arguments: self.lower_call_args(&expression.arguments)?,
-                optional: expression.optional,
-            }),
-            Expression::ChainExpression(expression) => match &expression.expression {
-                ChainElement::CallExpression(call) => Some(Expr::Call {
-                    span: call.span.into(),
-                    callee: Box::new(self.lower_expr(&call.callee)?),
-                    arguments: self.lower_call_args(&call.arguments)?,
-                    optional: true,
-                }),
-                ChainElement::ComputedMemberExpression(member) => Some(Expr::Member {
-                    span: member.span.into(),
-                    object: Box::new(self.lower_expr(&member.object)?),
-                    property: MemberProperty::Computed(Box::new(
-                        self.lower_expr(&member.expression)?,
-                    )),
-                    optional: true,
-                }),
-                ChainElement::StaticMemberExpression(member) => Some(Expr::Member {
-                    span: member.span.into(),
-                    object: Box::new(self.lower_expr(&member.object)?),
-                    property: MemberProperty::Static(PropertyName::Identifier(
-                        member.property.name.as_str().to_string(),
-                    )),
-                    optional: true,
-                }),
-                ChainElement::PrivateFieldExpression(member) => {
-                    self.unsupported(
-                        "private fields are not supported in v1",
-                        Some(member.span.into()),
-                    );
-                    None
-                }
-                ChainElement::TSNonNullExpression(expression) => {
-                    self.lower_expr(&expression.expression)
-                }
-            },
-            Expression::ComputedMemberExpression(member) => Some(Expr::Member {
-                span: member.span.into(),
-                object: Box::new(self.lower_expr(&member.object)?),
-                property: MemberProperty::Computed(Box::new(self.lower_expr(&member.expression)?)),
-                optional: member.optional,
-            }),
-            Expression::StaticMemberExpression(member) => Some(Expr::Member {
-                span: member.span.into(),
-                object: Box::new(self.lower_expr(&member.object)?),
-                property: MemberProperty::Static(PropertyName::Identifier(
-                    member.property.name.as_str().to_string(),
-                )),
-                optional: member.optional,
-            }),
-            Expression::AwaitExpression(expression) => Some(Expr::Await {
-                span: expression.span.into(),
-                value: Box::new(self.lower_expr(&expression.argument)?),
-            }),
-            Expression::NewExpression(expression) => Some(Expr::New {
-                span: expression.span.into(),
-                callee: Box::new(self.lower_expr(&expression.callee)?),
-                arguments: self.lower_call_args(&expression.arguments)?,
-            }),
-            Expression::ParenthesizedExpression(expression) => {
-                self.lower_expr(&expression.expression)
-            }
-            Expression::MetaProperty(property) => {
-                self.unsupported(
-                    "meta properties are not supported",
-                    Some(property.span.into()),
-                );
-                None
-            }
-            Expression::ImportExpression(expression) => {
-                self.unsupported(
-                    "dynamic import() is not supported",
-                    Some(expression.span.into()),
-                );
-                None
-            }
-            Expression::RegExpLiteral(expression) => Some(Expr::RegExp {
-                span: expression.span.into(),
-                pattern: expression.regex.pattern.text.as_str().to_string(),
-                flags: expression.regex.flags.to_inline_string().to_string(),
-            }),
-            Expression::Super(expression) => {
-                self.unsupported("super is not supported in v1", Some(expression.span.into()));
-                None
-            }
-            Expression::PrivateFieldExpression(expression) => {
-                self.unsupported(
-                    "private fields are not supported in v1",
-                    Some(expression.span.into()),
-                );
-                None
-            }
-            Expression::UpdateExpression(expression) => Some(Expr::Update {
-                span: expression.span.into(),
-                target: Box::new(self.lower_simple_assignment_target(&expression.argument)?),
-                operator: match expression.operator {
-                    UpdateOperator::Increment => UpdateOp::Increment,
-                    UpdateOperator::Decrement => UpdateOp::Decrement,
-                },
-                prefix: expression.prefix,
-            }),
-            Expression::YieldExpression(expression) => {
-                self.unsupported("yield is not supported in v1", Some(expression.span.into()));
-                None
-            }
-            Expression::TaggedTemplateExpression(expression) => {
-                self.unsupported(
-                    "tagged templates are not supported in v1",
-                    Some(expression.span.into()),
-                );
-                None
-            }
-            Expression::ClassExpression(expression) => {
-                self.unsupported(
-                    "classes are not supported in v1",
-                    Some(expression.span.into()),
-                );
-                None
-            }
-            Expression::JSXElement(_)
-            | Expression::JSXFragment(_)
-            | Expression::TSAsExpression(_)
-            | Expression::TSSatisfiesExpression(_)
-            | Expression::TSInstantiationExpression(_)
-            | Expression::TSNonNullExpression(_)
-            | Expression::TSTypeAssertion(_)
-            | Expression::PrivateInExpression(_) => {
-                self.unsupported(
-                    "unsupported expression form in v1",
-                    Some(expression.span().into()),
-                );
-                None
-            }
-            _ => {
-                self.unsupported(
-                    "unsupported expression form in v1",
-                    Some(expression.span().into()),
-                );
-                None
-            }
-        }
-    }
-
-    pub(super) fn lower_call_args(
-        &mut self,
-        args: &[Argument<'a>],
-    ) -> Option<Vec<crate::ir::CallArgument>> {
-        let mut lowered = Vec::with_capacity(args.len());
-        for arg in args {
-            match arg {
-                Argument::SpreadElement(spread) => {
-                    lowered.push(crate::ir::CallArgument::Spread {
-                        span: spread.span.into(),
-                        value: self.lower_expr(&spread.argument)?,
-                    });
-                }
-                expression => lowered.push(crate::ir::CallArgument::Value(
-                    self.lower_expr(expression.to_expression())?,
-                )),
-            }
-        }
-        Some(lowered)
-    }
-
-    pub(super) fn lower_assignment_target(
-        &mut self,
-        target: &AssignmentTarget<'a>,
-    ) -> Option<AssignTarget> {
-        match target {
-            AssignmentTarget::AssignmentTargetIdentifier(identifier) => {
-                Some(AssignTarget::Identifier {
-                    span: identifier.span.into(),
-                    name: identifier.name.as_str().to_string(),
-                })
-            }
-            AssignmentTarget::ComputedMemberExpression(member) => Some(AssignTarget::Member {
-                span: member.span.into(),
-                object: Box::new(self.lower_expr(&member.object)?),
-                property: MemberProperty::Computed(Box::new(self.lower_expr(&member.expression)?)),
-                optional: member.optional,
-            }),
-            AssignmentTarget::StaticMemberExpression(member) => Some(AssignTarget::Member {
-                span: member.span.into(),
-                object: Box::new(self.lower_expr(&member.object)?),
-                property: MemberProperty::Static(PropertyName::Identifier(
-                    member.property.name.as_str().to_string(),
-                )),
-                optional: member.optional,
-            }),
-            AssignmentTarget::PrivateFieldExpression(expression) => {
-                self.unsupported(
-                    "private fields are not supported in v1",
-                    Some(expression.span.into()),
-                );
-                None
-            }
-            AssignmentTarget::ArrayAssignmentTarget(target) => {
-                self.lower_array_assignment_target(target)
-            }
-            AssignmentTarget::ObjectAssignmentTarget(target) => {
-                self.lower_object_assignment_target(target)
-            }
-            _ => {
-                self.unsupported(
-                    "unsupported assignment target in v1",
-                    Some(target.span().into()),
-                );
-                None
-            }
-        }
-    }
-
-    pub(super) fn lower_for_of_assignment_target(
-        &mut self,
-        target: &ForStatementLeft<'a>,
-    ) -> Option<AssignTarget> {
-        match target {
-            ForStatementLeft::AssignmentTargetIdentifier(identifier) => {
-                Some(AssignTarget::Identifier {
-                    span: identifier.span.into(),
-                    name: identifier.name.as_str().to_string(),
-                })
-            }
-            ForStatementLeft::ComputedMemberExpression(member) => Some(AssignTarget::Member {
-                span: member.span.into(),
-                object: Box::new(self.lower_expr(&member.object)?),
-                property: MemberProperty::Computed(Box::new(self.lower_expr(&member.expression)?)),
-                optional: member.optional,
-            }),
-            ForStatementLeft::StaticMemberExpression(member) => Some(AssignTarget::Member {
-                span: member.span.into(),
-                object: Box::new(self.lower_expr(&member.object)?),
-                property: MemberProperty::Static(PropertyName::Identifier(
-                    member.property.name.as_str().to_string(),
-                )),
-                optional: member.optional,
-            }),
-            ForStatementLeft::PrivateFieldExpression(expression) => {
-                self.unsupported(
-                    "private fields are not supported in v1",
-                    Some(expression.span.into()),
-                );
-                None
-            }
-            ForStatementLeft::ArrayAssignmentTarget(target) => {
-                self.lower_array_assignment_target(target)
-            }
-            ForStatementLeft::ObjectAssignmentTarget(target) => {
-                self.lower_object_assignment_target(target)
-            }
-            _ => {
-                self.unsupported(
-                    "unsupported assignment target in v1",
-                    Some(target.span().into()),
-                );
-                None
-            }
-        }
-    }
-
-    fn lower_simple_assignment_target(
-        &mut self,
-        target: &SimpleAssignmentTarget<'a>,
-    ) -> Option<AssignTarget> {
-        match target {
-            SimpleAssignmentTarget::AssignmentTargetIdentifier(identifier) => {
-                Some(AssignTarget::Identifier {
-                    span: identifier.span.into(),
-                    name: identifier.name.as_str().to_string(),
-                })
-            }
-            SimpleAssignmentTarget::ComputedMemberExpression(member) => {
-                Some(AssignTarget::Member {
-                    span: member.span.into(),
-                    object: Box::new(self.lower_expr(&member.object)?),
-                    property: MemberProperty::Computed(Box::new(
-                        self.lower_expr(&member.expression)?,
-                    )),
-                    optional: member.optional,
-                })
-            }
-            SimpleAssignmentTarget::StaticMemberExpression(member) => Some(AssignTarget::Member {
-                span: member.span.into(),
-                object: Box::new(self.lower_expr(&member.object)?),
-                property: MemberProperty::Static(PropertyName::Identifier(
-                    member.property.name.as_str().to_string(),
-                )),
-                optional: member.optional,
-            }),
-            SimpleAssignmentTarget::PrivateFieldExpression(expression) => {
-                self.unsupported(
-                    "private fields are not supported in v1",
-                    Some(expression.span.into()),
-                );
-                None
-            }
-            _ => {
-                self.unsupported(
-                    "unsupported assignment target in v1",
-                    Some(target.span().into()),
-                );
-                None
-            }
-        }
-    }
-
-    fn lower_assignment_target_maybe_default(
-        &mut self,
-        target: &AssignmentTargetMaybeDefault<'a>,
-    ) -> Option<AssignTarget> {
-        match target {
-            AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(target) => {
-                Some(AssignTarget::Default {
-                    span: target.span.into(),
-                    target: Box::new(self.lower_assignment_target(&target.binding)?),
-                    default_value: Box::new(self.lower_expr(&target.init)?),
-                })
-            }
-            _ => self.lower_assignment_target(target.to_assignment_target()),
-        }
-    }
-
-    fn lower_array_assignment_target(
-        &mut self,
-        target: &ArrayAssignmentTarget<'a>,
-    ) -> Option<AssignTarget> {
-        Some(AssignTarget::Array {
-            span: target.span.into(),
-            elements: target
-                .elements
-                .iter()
-                .map(|element| {
-                    element
-                        .as_ref()
-                        .and_then(|element| self.lower_assignment_target_maybe_default(element))
-                })
-                .collect(),
-            rest: target
-                .rest
-                .as_ref()
-                .and_then(|rest| self.lower_assignment_target(&rest.target))
-                .map(Box::new),
-        })
-    }
-
-    fn lower_object_assignment_target(
-        &mut self,
-        target: &ObjectAssignmentTarget<'a>,
-    ) -> Option<AssignTarget> {
-        Some(AssignTarget::Object {
-            span: target.span.into(),
-            properties: target
-                .properties
-                .iter()
-                .filter_map(|property| {
-                    Some(match property {
-                        AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(property) => {
-                            crate::ir::AssignTargetProperty {
-                                span: property.span.into(),
-                                key: PropertyName::Identifier(
-                                    property.binding.name.as_str().to_string(),
-                                ),
-                                value: if let Some(init) = &property.init {
-                                    AssignTarget::Default {
-                                        span: property.span.into(),
-                                        target: Box::new(AssignTarget::Identifier {
-                                            span: property.span.into(),
-                                            name: property.binding.name.as_str().to_string(),
-                                        }),
-                                        default_value: Box::new(self.lower_expr(init)?),
-                                    }
-                                } else {
-                                    AssignTarget::Identifier {
-                                        span: property.span.into(),
-                                        name: property.binding.name.as_str().to_string(),
-                                    }
-                                },
-                            }
-                        }
-                        AssignmentTargetProperty::AssignmentTargetPropertyProperty(property) => {
-                            crate::ir::AssignTargetProperty {
-                                span: property.span.into(),
-                                key: self.lower_property_name(&property.name)?,
-                                value: self
-                                    .lower_assignment_target_maybe_default(&property.binding)?,
-                            }
-                        }
-                    })
-                })
-                .collect(),
-            rest: target
-                .rest
-                .as_ref()
-                .and_then(|rest| self.lower_assignment_target(&rest.target))
-                .map(Box::new),
-        })
-    }
-}