mustardscript 0.1.0

package/crates/mustard/src/runtime/compiler/assignments.rs

@@ -0,0 +1,690 @@
+use super::super::{bytecode::Instruction, format_number_key};
+use super::{Compiler, context::CompileContext};
+use crate::{
+    diagnostic::MustardResult,
+    ir::{AssignOp, AssignTarget, Expr, MemberProperty, Pattern, PropertyName, UpdateOp},
+    span::SourceSpan,
+};
+
+use super::bindings::assign_op_to_binary;
+
+impl Compiler {
+    fn declare_internal_binding(&mut self, context: &mut CompileContext, prefix: &str) -> String {
+        let name = self.fresh_internal_name(context, prefix);
+        context.code.push(Instruction::DeclareName {
+            name: name.clone(),
+            mutable: true,
+        });
+        name
+    }
+
+    fn store_internal_binding(
+        &mut self,
+        context: &mut CompileContext,
+        name: &str,
+        span: SourceSpan,
+    ) {
+        context
+            .code
+            .push(Instruction::InitializePattern(Pattern::Identifier {
+                span,
+                name: name.to_string(),
+            }));
+    }
+
+    pub(super) fn compile_pattern_binding(
+        &mut self,
+        context: &mut CompileContext,
+        pattern: &Pattern,
+    ) -> MustardResult<()> {
+        match pattern {
+            Pattern::Identifier { .. } => {
+                context
+                    .code
+                    .push(Instruction::InitializePattern(pattern.clone()));
+            }
+            Pattern::Array {
+                span,
+                elements,
+                rest,
+            } => {
+                let source = self.declare_internal_binding(context, "pattern_array");
+                self.store_internal_binding(context, &source, *span);
+                for (index, element) in elements.iter().enumerate() {
+                    if let Some(element) = element {
+                        context.code.push(Instruction::LoadName(source.clone()));
+                        context.code.push(Instruction::PatternArrayIndex(index));
+                        self.compile_pattern_binding(context, element)?;
+                    }
+                }
+                if let Some(rest) = rest {
+                    context.code.push(Instruction::LoadName(source));
+                    context
+                        .code
+                        .push(Instruction::PatternArrayRest(elements.len()));
+                    self.compile_pattern_binding(context, rest)?;
+                }
+            }
+            Pattern::Object {
+                span,
+                properties,
+                rest,
+            } => {
+                let source = self.declare_internal_binding(context, "pattern_object");
+                self.store_internal_binding(context, &source, *span);
+                for property in properties {
+                    context.code.push(Instruction::LoadName(source.clone()));
+                    match &property.key {
+                        PropertyName::Identifier(name) | PropertyName::String(name) => {
+                            context.code.push(Instruction::GetPropStatic {
+                                name: name.clone(),
+                                optional: false,
+                            });
+                        }
+                        PropertyName::Number(number) => {
+                            context.code.push(Instruction::GetPropStatic {
+                                name: format_number_key(*number),
+                                optional: false,
+                            });
+                        }
+                    }
+                    self.compile_pattern_binding(context, &property.value)?;
+                }
+                if let Some(rest) = rest {
+                    let excluded = properties
+                        .iter()
+                        .map(|property| match &property.key {
+                            PropertyName::Identifier(name) | PropertyName::String(name) => {
+                                name.clone()
+                            }
+                            PropertyName::Number(number) => format_number_key(*number),
+                        })
+                        .collect();
+                    context.code.push(Instruction::LoadName(source));
+                    context.code.push(Instruction::PatternObjectRest(excluded));
+                    self.compile_pattern_binding(context, rest)?;
+                }
+            }
+            Pattern::Default {
+                span,
+                target,
+                default_value,
+            } => {
+                let source = self.declare_internal_binding(context, "pattern_default");
+                self.store_internal_binding(context, &source, *span);
+                context.code.push(Instruction::LoadName(source.clone()));
+                context.code.push(Instruction::PushUndefined);
+                context
+                    .code
+                    .push(Instruction::Binary(crate::ir::BinaryOp::StrictEq));
+                let use_source = self.emit_jump(context, Instruction::JumpIfFalse(usize::MAX));
+                context.code.push(Instruction::Pop);
+                self.compile_expr(context, default_value)?;
+                let end = self.emit_jump(context, Instruction::Jump(usize::MAX));
+                let use_source_ip = context.code.len();
+                self.patch_jump(context, use_source, use_source_ip);
+                context.code.push(Instruction::Pop);
+                context.code.push(Instruction::LoadName(source));
+                let end_ip = context.code.len();
+                self.patch_jump(context, end, end_ip);
+                self.compile_pattern_binding(context, target)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn compile_assign_target_pattern(
+        &mut self,
+        context: &mut CompileContext,
+        target: &AssignTarget,
+    ) -> MustardResult<()> {
+        match target {
+            AssignTarget::Identifier { .. } | AssignTarget::Member { .. } => {
+                let source = self.declare_internal_binding(context, "assign_value");
+                self.store_internal_binding(context, &source, SourceSpan::new(0, 0));
+                self.compile_assignment(
+                    context,
+                    target,
+                    AssignOp::Assign,
+                    &Expr::Identifier {
+                        span: SourceSpan::new(0, 0),
+                        name: source,
+                    },
+                )?;
+                context.code.push(Instruction::Pop);
+            }
+            AssignTarget::Default {
+                span,
+                target,
+                default_value,
+            } => {
+                let source = self.declare_internal_binding(context, "assign_default");
+                self.store_internal_binding(context, &source, *span);
+                context.code.push(Instruction::LoadName(source.clone()));
+                context.code.push(Instruction::PushUndefined);
+                context
+                    .code
+                    .push(Instruction::Binary(crate::ir::BinaryOp::StrictEq));
+                let use_source = self.emit_jump(context, Instruction::JumpIfFalse(usize::MAX));
+                context.code.push(Instruction::Pop);
+                self.compile_expr(context, default_value)?;
+                let end = self.emit_jump(context, Instruction::Jump(usize::MAX));
+                let use_source_ip = context.code.len();
+                self.patch_jump(context, use_source, use_source_ip);
+                context.code.push(Instruction::Pop);
+                context.code.push(Instruction::LoadName(source));
+                let end_ip = context.code.len();
+                self.patch_jump(context, end, end_ip);
+                self.compile_assign_target_pattern(context, target)?;
+            }
+            AssignTarget::Array {
+                span,
+                elements,
+                rest,
+            } => {
+                let source = self.declare_internal_binding(context, "assign_array");
+                self.store_internal_binding(context, &source, *span);
+                for (index, element) in elements.iter().enumerate() {
+                    if let Some(element) = element {
+                        context.code.push(Instruction::LoadName(source.clone()));
+                        context.code.push(Instruction::PatternArrayIndex(index));
+                        self.compile_assign_target_pattern(context, element)?;
+                    }
+                }
+                if let Some(rest) = rest {
+                    context.code.push(Instruction::LoadName(source));
+                    context
+                        .code
+                        .push(Instruction::PatternArrayRest(elements.len()));
+                    self.compile_assign_target_pattern(context, rest)?;
+                }
+            }
+            AssignTarget::Object {
+                span,
+                properties,
+                rest,
+            } => {
+                let source = self.declare_internal_binding(context, "assign_object");
+                self.store_internal_binding(context, &source, *span);
+                for property in properties {
+                    context.code.push(Instruction::LoadName(source.clone()));
+                    match &property.key {
+                        PropertyName::Identifier(name) | PropertyName::String(name) => {
+                            context.code.push(Instruction::GetPropStatic {
+                                name: name.clone(),
+                                optional: false,
+                            });
+                        }
+                        PropertyName::Number(number) => {
+                            context.code.push(Instruction::GetPropStatic {
+                                name: format_number_key(*number),
+                                optional: false,
+                            });
+                        }
+                    }
+                    self.compile_assign_target_pattern(context, &property.value)?;
+                }
+                if let Some(rest) = rest {
+                    let excluded = properties
+                        .iter()
+                        .map(|property| match &property.key {
+                            PropertyName::Identifier(name) | PropertyName::String(name) => {
+                                name.clone()
+                            }
+                            PropertyName::Number(number) => format_number_key(*number),
+                        })
+                        .collect();
+                    context.code.push(Instruction::LoadName(source));
+                    context.code.push(Instruction::PatternObjectRest(excluded));
+                    self.compile_assign_target_pattern(context, rest)?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn compile_short_circuit_assignment_identifier(
+        &mut self,
+        context: &mut CompileContext,
+        name: &str,
+        value: &Expr,
+        jump_if_eval: Instruction,
+    ) -> MustardResult<()> {
+        context.code.push(Instruction::LoadName(name.to_string()));
+        context.code.push(Instruction::Dup);
+        let rhs_jump = self.emit_jump(context, jump_if_eval);
+        context.code.push(Instruction::Pop);
+        let end_jump = self.emit_jump(context, Instruction::Jump(usize::MAX));
+        let rhs_ip = context.code.len();
+        self.patch_jump(context, rhs_jump, rhs_ip);
+        context.code.push(Instruction::Pop);
+        context.code.push(Instruction::Pop);
+        self.compile_expr(context, value)?;
+        context.code.push(Instruction::StoreName(name.to_string()));
+        let end_ip = context.code.len();
+        self.patch_jump(context, end_jump, end_ip);
+        Ok(())
+    }
+
+    fn compile_short_circuit_assignment_static(
+        &mut self,
+        context: &mut CompileContext,
+        object: &Expr,
+        name: String,
+        optional: bool,
+        value: &Expr,
+        jump_if_eval: Instruction,
+    ) -> MustardResult<()> {
+        let object_binding = self.fresh_internal_name(context, "assign_obj");
+        context.code.push(Instruction::DeclareName {
+            name: object_binding.clone(),
+            mutable: false,
+        });
+        self.compile_expr(context, object)?;
+        context
+            .code
+            .push(Instruction::InitializePattern(Pattern::Identifier {
+                span: SourceSpan::new(0, 0),
+                name: object_binding.clone(),
+            }));
+        context
+            .code
+            .push(Instruction::LoadName(object_binding.clone()));
+        context.code.push(Instruction::GetPropStatic {
+            name: name.clone(),
+            optional,
+        });
+        context.code.push(Instruction::Dup);
+        let rhs_jump = self.emit_jump(context, jump_if_eval);
+        context.code.push(Instruction::Pop);
+        let end_jump = self.emit_jump(context, Instruction::Jump(usize::MAX));
+        let rhs_ip = context.code.len();
+        self.patch_jump(context, rhs_jump, rhs_ip);
+        context.code.push(Instruction::Pop);
+        context.code.push(Instruction::Pop);
+        context.code.push(Instruction::LoadName(object_binding));
+        self.compile_expr(context, value)?;
+        context.code.push(Instruction::SetPropStatic { name });
+        let end_ip = context.code.len();
+        self.patch_jump(context, end_jump, end_ip);
+        Ok(())
+    }
+
+    fn compile_short_circuit_assignment_computed(
+        &mut self,
+        context: &mut CompileContext,
+        object: &Expr,
+        property: &Expr,
+        optional: bool,
+        value: &Expr,
+        jump_if_eval: Instruction,
+    ) -> MustardResult<()> {
+        let object_binding = self.fresh_internal_name(context, "assign_obj");
+        let key_binding = self.fresh_internal_name(context, "assign_key");
+        for name in [&object_binding, &key_binding] {
+            context.code.push(Instruction::DeclareName {
+                name: name.clone(),
+                mutable: false,
+            });
+        }
+        self.compile_expr(context, object)?;
+        context
+            .code
+            .push(Instruction::InitializePattern(Pattern::Identifier {
+                span: SourceSpan::new(0, 0),
+                name: object_binding.clone(),
+            }));
+        self.compile_expr(context, property)?;
+        context
+            .code
+            .push(Instruction::InitializePattern(Pattern::Identifier {
+                span: SourceSpan::new(0, 0),
+                name: key_binding.clone(),
+            }));
+        context
+            .code
+            .push(Instruction::LoadName(object_binding.clone()));
+        context
+            .code
+            .push(Instruction::LoadName(key_binding.clone()));
+        context.code.push(Instruction::GetPropComputed { optional });
+        context.code.push(Instruction::Dup);
+        let rhs_jump = self.emit_jump(context, jump_if_eval);
+        context.code.push(Instruction::Pop);
+        let end_jump = self.emit_jump(context, Instruction::Jump(usize::MAX));
+        let rhs_ip = context.code.len();
+        self.patch_jump(context, rhs_jump, rhs_ip);
+        context.code.push(Instruction::Pop);
+        context.code.push(Instruction::Pop);
+        context.code.push(Instruction::LoadName(object_binding));
+        context.code.push(Instruction::LoadName(key_binding));
+        self.compile_expr(context, value)?;
+        context.code.push(Instruction::SetPropComputed);
+        let end_ip = context.code.len();
+        self.patch_jump(context, end_jump, end_ip);
+        Ok(())
+    }
+
+    pub(super) fn compile_assignment(
+        &mut self,
+        context: &mut CompileContext,
+        target: &AssignTarget,
+        operator: AssignOp,
+        value: &Expr,
+    ) -> MustardResult<()> {
+        if matches!(
+            target,
+            AssignTarget::Array { .. } | AssignTarget::Object { .. } | AssignTarget::Default { .. }
+        ) {
+            self.compile_expr(context, value)?;
+            let result = self.declare_internal_binding(context, "assign_result");
+            self.store_internal_binding(context, &result, SourceSpan::new(0, 0));
+            context.code.push(Instruction::LoadName(result.clone()));
+            self.compile_assign_target_pattern(
+                context,
+                match target {
+                    AssignTarget::Array { .. }
+                    | AssignTarget::Object { .. }
+                    | AssignTarget::Default { .. } => target,
+                    _ => unreachable!(),
+                },
+            )?;
+            context.code.push(Instruction::LoadName(result));
+            return Ok(());
+        }
+        match target {
+            AssignTarget::Identifier { name, .. } => {
+                if operator == AssignOp::Assign {
+                    self.compile_expr(context, value)?;
+                    context.code.push(Instruction::StoreName(name.clone()));
+                } else if operator == AssignOp::OrAssign {
+                    self.compile_short_circuit_assignment_identifier(
+                        context,
+                        name,
+                        value,
+                        Instruction::JumpIfFalse(usize::MAX),
+                    )?;
+                } else if operator == AssignOp::AndAssign {
+                    self.compile_short_circuit_assignment_identifier(
+                        context,
+                        name,
+                        value,
+                        Instruction::JumpIfTrue(usize::MAX),
+                    )?;
+                } else if operator == AssignOp::NullishAssign {
+                    self.compile_short_circuit_assignment_identifier(
+                        context,
+                        name,
+                        value,
+                        Instruction::JumpIfNullish(usize::MAX),
+                    )?;
+                } else {
+                    context.code.push(Instruction::LoadName(name.clone()));
+                    self.compile_expr(context, value)?;
+                    context
+                        .code
+                        .push(Instruction::Binary(assign_op_to_binary(operator)?));
+                    context.code.push(Instruction::StoreName(name.clone()));
+                }
+            }
+            AssignTarget::Member {
+                object,
+                property,
+                optional,
+                ..
+            } => match property {
+                MemberProperty::Static(PropertyName::Identifier(name))
+                | MemberProperty::Static(PropertyName::String(name)) => {
+                    if operator == AssignOp::Assign {
+                        self.compile_expr(context, object)?;
+                        self.compile_expr(context, value)?;
+                        context
+                            .code
+                            .push(Instruction::SetPropStatic { name: name.clone() });
+                    } else if operator == AssignOp::OrAssign {
+                        self.compile_short_circuit_assignment_static(
+                            context,
+                            object,
+                            name.clone(),
+                            *optional,
+                            value,
+                            Instruction::JumpIfFalse(usize::MAX),
+                        )?;
+                    } else if operator == AssignOp::AndAssign {
+                        self.compile_short_circuit_assignment_static(
+                            context,
+                            object,
+                            name.clone(),
+                            *optional,
+                            value,
+                            Instruction::JumpIfTrue(usize::MAX),
+                        )?;
+                    } else if operator == AssignOp::NullishAssign {
+                        self.compile_short_circuit_assignment_static(
+                            context,
+                            object,
+                            name.clone(),
+                            *optional,
+                            value,
+                            Instruction::JumpIfNullish(usize::MAX),
+                        )?;
+                    } else {
+                        self.compile_expr(context, object)?;
+                        context.code.push(Instruction::Dup);
+                        context.code.push(Instruction::GetPropStatic {
+                            name: name.clone(),
+                            optional: *optional,
+                        });
+                        self.compile_expr(context, value)?;
+                        context
+                            .code
+                            .push(Instruction::Binary(assign_op_to_binary(operator)?));
+                        context
+                            .code
+                            .push(Instruction::SetPropStatic { name: name.clone() });
+                    }
+                }
+                MemberProperty::Static(PropertyName::Number(number)) => {
+                    let name = format_number_key(*number);
+                    if operator == AssignOp::Assign {
+                        self.compile_expr(context, object)?;
+                        self.compile_expr(context, value)?;
+                        context.code.push(Instruction::SetPropStatic { name });
+                    } else if operator == AssignOp::OrAssign {
+                        self.compile_short_circuit_assignment_static(
+                            context,
+                            object,
+                            name,
+                            *optional,
+                            value,
+                            Instruction::JumpIfFalse(usize::MAX),
+                        )?;
+                    } else if operator == AssignOp::AndAssign {
+                        self.compile_short_circuit_assignment_static(
+                            context,
+                            object,
+                            name,
+                            *optional,
+                            value,
+                            Instruction::JumpIfTrue(usize::MAX),
+                        )?;
+                    } else if operator == AssignOp::NullishAssign {
+                        self.compile_short_circuit_assignment_static(
+                            context,
+                            object,
+                            name,
+                            *optional,
+                            value,
+                            Instruction::JumpIfNullish(usize::MAX),
+                        )?;
+                    } else {
+                        self.compile_expr(context, object)?;
+                        context.code.push(Instruction::Dup);
+                        context.code.push(Instruction::GetPropStatic {
+                            name: name.clone(),
+                            optional: *optional,
+                        });
+                        self.compile_expr(context, value)?;
+                        context
+                            .code
+                            .push(Instruction::Binary(assign_op_to_binary(operator)?));
+                        context.code.push(Instruction::SetPropStatic { name });
+                    }
+                }
+                MemberProperty::Computed(expr) => {
+                    if operator == AssignOp::Assign {
+                        self.compile_expr(context, object)?;
+                        self.compile_expr(context, expr)?;
+                        self.compile_expr(context, value)?;
+                        context.code.push(Instruction::SetPropComputed);
+                    } else if operator == AssignOp::OrAssign {
+                        self.compile_short_circuit_assignment_computed(
+                            context,
+                            object,
+                            expr,
+                            *optional,
+                            value,
+                            Instruction::JumpIfFalse(usize::MAX),
+                        )?;
+                    } else if operator == AssignOp::AndAssign {
+                        self.compile_short_circuit_assignment_computed(
+                            context,
+                            object,
+                            expr,
+                            *optional,
+                            value,
+                            Instruction::JumpIfTrue(usize::MAX),
+                        )?;
+                    } else if operator == AssignOp::NullishAssign {
+                        self.compile_short_circuit_assignment_computed(
+                            context,
+                            object,
+                            expr,
+                            *optional,
+                            value,
+                            Instruction::JumpIfNullish(usize::MAX),
+                        )?;
+                    } else {
+                        self.compile_expr(context, object)?;
+                        self.compile_expr(context, expr)?;
+                        context.code.push(Instruction::Dup2);
+                        context.code.push(Instruction::GetPropComputed {
+                            optional: *optional,
+                        });
+                        self.compile_expr(context, value)?;
+                        context
+                            .code
+                            .push(Instruction::Binary(assign_op_to_binary(operator)?));
+                        context.code.push(Instruction::SetPropComputed);
+                    }
+                }
+            },
+            AssignTarget::Array { .. }
+            | AssignTarget::Object { .. }
+            | AssignTarget::Default { .. } => unreachable!(),
+        }
+        Ok(())
+    }
+
+    pub(super) fn compile_update(
+        &mut self,
+        context: &mut CompileContext,
+        target: &AssignTarget,
+        operator: UpdateOp,
+        prefix: bool,
+    ) -> MustardResult<()> {
+        match target {
+            AssignTarget::Identifier { name, .. } => {
+                context.code.push(Instruction::LoadName(name.clone()));
+                if !prefix {
+                    context.code.push(Instruction::Dup);
+                }
+                context.code.push(Instruction::Update(operator));
+                context.code.push(Instruction::StoreName(name.clone()));
+                if !prefix {
+                    context.code.push(Instruction::Pop);
+                }
+            }
+            AssignTarget::Member {
+                object,
+                property,
+                optional,
+                ..
+            } => {
+                let object_binding = self.declare_internal_binding(context, "update_obj");
+                self.compile_expr(context, object)?;
+                self.store_internal_binding(context, &object_binding, SourceSpan::new(0, 0));
+                let key_binding = if let MemberProperty::Computed(property) = property {
+                    let key_binding = self.declare_internal_binding(context, "update_key");
+                    self.compile_expr(context, property)?;
+                    self.store_internal_binding(context, &key_binding, SourceSpan::new(0, 0));
+                    Some(key_binding)
+                } else {
+                    None
+                };
+                context
+                    .code
+                    .push(Instruction::LoadName(object_binding.clone()));
+                match property {
+                    MemberProperty::Static(PropertyName::Identifier(name))
+                    | MemberProperty::Static(PropertyName::String(name)) => {
+                        context.code.push(Instruction::GetPropStatic {
+                            name: name.clone(),
+                            optional: *optional,
+                        });
+                    }
+                    MemberProperty::Static(PropertyName::Number(number)) => {
+                        context.code.push(Instruction::GetPropStatic {
+                            name: format_number_key(*number),
+                            optional: *optional,
+                        });
+                    }
+                    MemberProperty::Computed(_) => {
+                        context.code.push(Instruction::LoadName(
+                            key_binding.clone().expect("computed update key missing"),
+                        ));
+                        context.code.push(Instruction::GetPropComputed {
+                            optional: *optional,
+                        });
+                    }
+                }
+                if !prefix {
+                    context.code.push(Instruction::Dup);
+                }
+                context.code.push(Instruction::Update(operator));
+                let value_binding = self.declare_internal_binding(context, "update_value");
+                self.store_internal_binding(context, &value_binding, SourceSpan::new(0, 0));
+                context.code.push(Instruction::LoadName(object_binding));
+                match property {
+                    MemberProperty::Static(PropertyName::Identifier(name))
+                    | MemberProperty::Static(PropertyName::String(name)) => {
+                        context.code.push(Instruction::LoadName(value_binding));
+                        context
+                            .code
+                            .push(Instruction::SetPropStatic { name: name.clone() });
+                    }
+                    MemberProperty::Static(PropertyName::Number(number)) => {
+                        context.code.push(Instruction::LoadName(value_binding));
+                        context.code.push(Instruction::SetPropStatic {
+                            name: format_number_key(*number),
+                        });
+                    }
+                    MemberProperty::Computed(_) => {
+                        context.code.push(Instruction::LoadName(
+                            key_binding.expect("computed update key missing"),
+                        ));
+                        context.code.push(Instruction::LoadName(value_binding));
+                        context.code.push(Instruction::SetPropComputed);
+                    }
+                }
+                if !prefix {
+                    context.code.push(Instruction::Pop);
+                }
+            }
+            AssignTarget::Array { .. }
+            | AssignTarget::Object { .. }
+            | AssignTarget::Default { .. } => unreachable!(),
+        }
+        Ok(())
+    }
+}