refactor: 清除旧代码并展开 crate

crates/oxide_compiler/src/stmt/iteration/do_while.rs

@@ -0,0 +1,36 @@
+use crate::compiler::{CompileCtx, Compiler, Label};
+use oxide_bytecode::opcode;
+use oxide_parser::Statement;
+
+impl Compiler {
+    pub(crate) fn count_do_while_statement(&self, stmt: &oxide_parser::DoWhileStatement<'_>, ctx: &mut CompileCtx) {
+        let id = ctx.next_label_id();
+        let start_label = Label::DoWhileStart(id);
+        let end_label = Label::DoWhileEnd(id);
+        ctx.labels.label_map.insert(start_label, ctx.projected_pc);
+        self.count_statement(&stmt.body, ctx);
+        self.count_expression(&stmt.test, ctx);
+        ctx.projected_pc += 1;
+        ctx.labels.label_map.insert(end_label, ctx.projected_pc);
+    }
+
+    pub(crate) fn emit_do_while_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        let Statement::DoWhileStatement(dw) = stmt else {
+            return Ok(None);
+        };
+        let id = ctx.next_label_id();
+        let start_label = Label::DoWhileStart(id);
+        let end_label = Label::DoWhileEnd(id);
+        ctx.push_loop(end_label, start_label);
+        let n_labeled = ctx.take_pending_loop_labels(end_label, start_label);
+        self.emit_statement(&dw.body, ctx)?;
+        let test_reg = self.emit_expression(&dw.test, ctx)?;
+        let start_pos = ctx.resolve_label(start_label)?;
+        let offset = (start_pos as isize) - (ctx.bytecode.len() as isize);
+        let offset = ctx.checked_jump_offset(offset);
+        ctx.emit(opcode::encode_jmp_if_true(test_reg, offset));
+        ctx.pop_label_scopes(n_labeled);
+        ctx.pop_loop();
+        Ok(None)
+    }
+}

crates/oxide_compiler/src/stmt/iteration/for_.rs

@@ -0,0 +1,94 @@
+use crate::compiler::{CompileCtx, Compiler, Label};
+use oxide_bytecode::{
+    module::Constant,
+    opcode::{self, OpCode},
+};
+use oxide_parser::{BindingPattern, ForStatementInit, Statement, VariableDeclarationKind};
+
+impl Compiler {
+    pub(crate) fn count_for_statement(&self, stmt: &oxide_parser::ForStatement<'_>, ctx: &mut CompileCtx) {
+        let id = ctx.next_label_id();
+        let start_label = Label::ForStart(id);
+        let update_label = Label::ForUpdate(id);
+        let end_label = Label::ForEnd(id);
+        if let Some(init) = &stmt.init {
+            if let Some(expr) = init.as_expression() {
+                self.count_expression(expr, ctx);
+            } else if let ForStatementInit::VariableDeclaration(decl) = init {
+                for d in &decl.declarations {
+                    if let Some(init_expr) = &d.init {
+                        self.count_expression(init_expr, ctx);
+                        self.count_binding_pattern(&d.id, ctx);
+                    } else {
+                        ctx.alloc_reg();
+                        ctx.alloc_reg();
+                        ctx.count_words(2);
+                    }
+                }
+            }
+        }
+        ctx.labels.label_map.insert(start_label, ctx.projected_pc);
+        if let Some(test) = &stmt.test {
+            self.count_expression(test, ctx);
+            ctx.projected_pc += 1;
+        }
+        self.count_statement(&stmt.body, ctx);
+        ctx.labels.label_map.insert(update_label, ctx.projected_pc);
+        if let Some(update) = &stmt.update {
+            self.count_expression(update, ctx);
+        }
+        ctx.projected_pc += 1;
+        ctx.labels.label_map.insert(end_label, ctx.projected_pc);
+    }
+
+    pub(crate) fn emit_for_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        let Statement::ForStatement(fr) = stmt else {
+            return Ok(None);
+        };
+        let id = ctx.next_label_id();
+        let start_label = Label::ForStart(id);
+        let update_label = Label::ForUpdate(id);
+        let end_label = Label::ForEnd(id);
+        ctx.push_loop(end_label, update_label);
+        let n_labeled = ctx.take_pending_loop_labels(end_label, update_label);
+        if let Some(init) = &fr.init {
+            if let Some(expr) = init.as_expression() {
+                self.emit_expression(expr, ctx)?;
+            } else if let ForStatementInit::VariableDeclaration(decl) = init {
+                for d in &decl.declarations {
+                    let is_const = matches!(decl.kind, VariableDeclarationKind::Const);
+                    if let Some(init_expr) = &d.init {
+                        let val_reg = self.emit_expression(init_expr, ctx)?;
+                        self.emit_binding_pattern(&d.id, val_reg, decl.kind, is_const, ctx)?;
+                    } else if let BindingPattern::BindingIdentifier(bi) = &d.id {
+                        let idx = ctx.add_constant(Constant::Undefined);
+                        let tmp = ctx.alloc_reg();
+                        ctx.emit_load_const(tmp, idx);
+                        let var_reg = ctx.alloc_reg();
+                        ctx.declare(bi.name.as_str(), var_reg, decl.kind, is_const)?;
+                        ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, tmp, 0));
+                        ctx.init_var(bi.name.as_str());
+                    }
+                }
+            }
+        }
+        if let Some(test) = &fr.test {
+            let test_reg = self.emit_expression(test, ctx)?;
+            let end_pos = ctx.resolve_label(end_label)?;
+            let offset = (end_pos as isize) - (ctx.bytecode.len() as isize);
+            let offset = ctx.checked_jump_offset(offset);
+            ctx.emit(opcode::encode_jmp_if_false(test_reg, offset));
+        }
+        self.emit_statement(&fr.body, ctx)?;
+        if let Some(update) = &fr.update {
+            self.emit_expression(update, ctx)?;
+        }
+        let start_pos = ctx.resolve_label(start_label)?;
+        let offset = (start_pos as isize) - (ctx.bytecode.len() as isize);
+        let offset = ctx.checked_jump_offset(offset);
+        ctx.emit(opcode::encode_jmp(offset));
+        ctx.pop_label_scopes(n_labeled);
+        ctx.pop_loop();
+        Ok(None)
+    }
+}

crates/oxide_compiler/src/stmt/iteration/for_in.rs

@@ -0,0 +1,86 @@
+use crate::compiler::{CompileCtx, Compiler, Label};
+use oxide_bytecode::opcode::{self, OpCode};
+use oxide_parser::{ForStatementLeft, Statement, VariableDeclarationKind};
+
+impl Compiler {
+    pub(crate) fn count_for_in_statement(&self, stmt: &oxide_parser::ForInStatement<'_>, ctx: &mut CompileCtx) {
+        let id = ctx.next_label_id();
+        let start_label = Label::ForInStart(id);
+        let end_label = Label::ForInEnd(id);
+        self.count_expression(&stmt.right, ctx);
+        ctx.count_instr();
+        ctx.labels.label_map.insert(start_label, ctx.projected_pc);
+        ctx.count_instr();
+        ctx.count_jump();
+        ctx.count_jump();
+        ctx.count_instr();
+        match &stmt.left {
+            oxide_parser::ForStatementLeft::VariableDeclaration(decl) => {
+                for _d in &decl.declarations {
+                    ctx.alloc_reg();
+                    ctx.count_instr();
+                }
+            }
+            oxide_parser::ForStatementLeft::AssignmentTargetIdentifier(_) => {
+                ctx.alloc_reg();
+                ctx.count_instr();
+            }
+            _ => {}
+        }
+        self.count_statement(&stmt.body, ctx);
+        ctx.count_jump();
+        ctx.labels.label_map.insert(end_label, ctx.projected_pc);
+        ctx.count_instr();
+    }
+
+    pub(crate) fn emit_for_in_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        let Statement::ForInStatement(fi) = stmt else {
+            return Ok(None);
+        };
+        let id = ctx.next_label_id();
+        let start_label = Label::ForInStart(id);
+        let end_label = Label::ForInEnd(id);
+        let obj_reg = self.emit_expression(&fi.right, ctx)?;
+        ctx.emit(opcode::encode(OpCode::FOR_IN_INIT, 0, obj_reg, 0));
+        ctx.push_loop(end_label, start_label);
+        let n_labeled = ctx.take_pending_loop_labels(end_label, start_label);
+        let done_reg = ctx.alloc_reg();
+        ctx.emit(opcode::encode(OpCode::FOR_IN_DONE, done_reg, 0, 0));
+        let end_pos = ctx.resolve_label(end_label)?;
+        let cleanup_jmp_offset = (end_pos as isize) - (ctx.bytecode.len() as isize);
+        ctx.emit(opcode::encode_jmp_if_false(done_reg, 2));
+        let cleanup_jmp_offset = ctx.checked_jump_offset(cleanup_jmp_offset);
+        ctx.emit(opcode::encode_jmp(cleanup_jmp_offset));
+        let key_reg = ctx.alloc_reg();
+        ctx.emit(opcode::encode(OpCode::FOR_IN_NEXT, key_reg, 0, 0));
+        match &fi.left {
+            ForStatementLeft::VariableDeclaration(decl) => {
+                for d in &decl.declarations {
+                    let name = match &d.id {
+                        oxide_parser::BindingPattern::BindingIdentifier(bi) => bi.name.as_str(),
+                        _ => return Err("destructuring not supported".into()),
+                    };
+                    let var_reg = ctx.alloc_reg();
+                    ctx.declare(name, var_reg, decl.kind, matches!(decl.kind, VariableDeclarationKind::Const))?;
+                    ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, key_reg, 0));
+                    ctx.init_var(name);
+                }
+            }
+            ForStatementLeft::AssignmentTargetIdentifier(id_ref) => {
+                let name = id_ref.name.as_str();
+                let var_reg = ctx.lookup_or_global(name);
+                ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, key_reg, 0));
+            }
+            _ => return Err("unsupported for-in left-hand side".into()),
+        }
+        self.emit_statement(&fi.body, ctx)?;
+        let start_pos = ctx.resolve_label(start_label)?;
+        let offset = (start_pos as isize) - (ctx.bytecode.len() as isize);
+        let offset = ctx.checked_jump_offset(offset);
+        ctx.emit(opcode::encode_jmp(offset));
+        ctx.emit(opcode::encode(OpCode::FOR_IN_CLEANUP, 0, 0, 0));
+        ctx.pop_label_scopes(n_labeled);
+        ctx.pop_loop();
+        Ok(None)
+    }
+}

crates/oxide_compiler/src/stmt/iteration/for_of.rs

@@ -0,0 +1,90 @@
+use crate::compiler::{CompileCtx, Compiler, Label};
+use oxide_bytecode::opcode::{self, OpCode};
+use oxide_parser::{ForStatementLeft, Statement};
+
+impl Compiler {
+    pub(crate) fn count_for_of_statement(&self, stmt: &oxide_parser::ForOfStatement<'_>, ctx: &mut CompileCtx) {
+        let id = ctx.next_label_id();
+        let start_label = Label::ForOfStart(id);
+        let end_label = Label::ForOfEnd(id);
+        self.count_expression(&stmt.right, ctx);
+        ctx.count_instr();
+        ctx.labels.label_map.insert(start_label, ctx.projected_pc);
+        ctx.alloc_reg();
+        ctx.count_instr();
+        ctx.count_jump();
+        ctx.alloc_reg();
+        ctx.count_instr();
+        match &stmt.left {
+            oxide_parser::ForStatementLeft::VariableDeclaration(decl) => {
+                for d in &decl.declarations {
+                    self.count_binding_pattern(&d.id, ctx);
+                }
+            }
+            oxide_parser::ForStatementLeft::AssignmentTargetIdentifier(_) => {
+                ctx.alloc_reg();
+                ctx.count_instr();
+            }
+            oxide_parser::ForStatementLeft::ArrayAssignmentTarget(ap) => {
+                self.count_array_assignment(ap, ctx);
+            }
+            oxide_parser::ForStatementLeft::ObjectAssignmentTarget(op) => {
+                self.count_object_assignment(op, ctx);
+            }
+            _ => {}
+        }
+        self.count_statement(&stmt.body, ctx);
+        ctx.count_jump();
+        ctx.labels.label_map.insert(end_label, ctx.projected_pc);
+        ctx.count_instr();
+    }
+
+    pub(crate) fn emit_for_of_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        let Statement::ForOfStatement(fo) = stmt else {
+            return Ok(None);
+        };
+        let id = ctx.next_label_id();
+        let start_label = Label::ForOfStart(id);
+        let end_label = Label::ForOfEnd(id);
+        let iter_src_reg = self.emit_expression(&fo.right, ctx)?;
+        ctx.emit(opcode::encode(OpCode::FOR_OF_INIT, 0, iter_src_reg, 0));
+        ctx.push_loop(end_label, start_label);
+        let n_labeled = ctx.take_pending_loop_labels(end_label, start_label);
+        let has_reg = ctx.alloc_reg();
+        ctx.emit(opcode::encode(OpCode::FOR_OF_DONE, has_reg, 0, 0));
+        let end_pos = ctx.resolve_label(end_label)?;
+        let offset = (end_pos as isize) - (ctx.bytecode.len() as isize);
+        let offset = ctx.checked_jump_offset(offset);
+        ctx.emit(opcode::encode_jmp_if_false(has_reg, offset));
+        let val_reg = ctx.alloc_reg();
+        ctx.emit(opcode::encode(OpCode::FOR_OF_NEXT, val_reg, 0, 0));
+        match &fo.left {
+            ForStatementLeft::VariableDeclaration(decl) => {
+                for d in &decl.declarations {
+                    self.emit_binding_pattern(&d.id, val_reg, decl.kind, false, ctx)?;
+                }
+            }
+            ForStatementLeft::AssignmentTargetIdentifier(id_ref) => {
+                let name = id_ref.name.as_str();
+                let var_reg = ctx.lookup_or_global(name);
+                ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, val_reg, 0));
+            }
+            ForStatementLeft::ArrayAssignmentTarget(ap) => {
+                self.emit_array_assignment(ap, val_reg, ctx)?;
+            }
+            ForStatementLeft::ObjectAssignmentTarget(op) => {
+                self.emit_object_assignment(op, val_reg, ctx)?;
+            }
+            _ => return Err("unsupported for-of left-hand side".into()),
+        }
+        self.emit_statement(&fo.body, ctx)?;
+        let start_pos = ctx.resolve_label(start_label)?;
+        let offset = (start_pos as isize) - (ctx.bytecode.len() as isize);
+        let offset = ctx.checked_jump_offset(offset);
+        ctx.emit(opcode::encode_jmp(offset));
+        ctx.emit(opcode::encode(OpCode::FOR_OF_CLOSE, 0, 0, 0));
+        ctx.pop_label_scopes(n_labeled);
+        ctx.pop_loop();
+        Ok(None)
+    }
+}

crates/oxide_compiler/src/stmt/iteration/mod.rs

@@ -0,0 +1,32 @@
+use crate::compiler::{CompileCtx, Compiler};
+use oxide_parser::Statement;
+
+mod do_while;
+mod for_;
+mod for_in;
+mod for_of;
+mod while_loop;
+
+impl Compiler {
+    pub(crate) fn count_iteration_domain(&self, stmt: &Statement, ctx: &mut CompileCtx) {
+        match stmt {
+            Statement::WhileStatement(wh) => self.count_while_statement(wh, ctx),
+            Statement::DoWhileStatement(dw) => self.count_do_while_statement(dw, ctx),
+            Statement::ForStatement(fr) => self.count_for_statement(fr, ctx),
+            Statement::ForInStatement(fi) => self.count_for_in_statement(fi, ctx),
+            Statement::ForOfStatement(fo) => self.count_for_of_statement(fo, ctx),
+            _ => {}
+        }
+    }
+
+    pub(crate) fn emit_iteration_domain(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        match stmt {
+            Statement::WhileStatement(_) => self.emit_while_statement(stmt, ctx),
+            Statement::DoWhileStatement(_) => self.emit_do_while_statement(stmt, ctx),
+            Statement::ForStatement(_) => self.emit_for_statement(stmt, ctx),
+            Statement::ForInStatement(_) => self.emit_for_in_statement(stmt, ctx),
+            Statement::ForOfStatement(_) => self.emit_for_of_statement(stmt, ctx),
+            _ => Ok(None),
+        }
+    }
+}

crates/oxide_compiler/src/stmt/iteration/while_loop.rs

@@ -0,0 +1,41 @@
+use crate::compiler::{CompileCtx, Compiler, Label};
+use oxide_bytecode::opcode;
+use oxide_parser::Statement;
+
+impl Compiler {
+    pub(crate) fn count_while_statement(&self, stmt: &oxide_parser::WhileStatement<'_>, ctx: &mut CompileCtx) {
+        let id = ctx.next_label_id();
+        let start_label = Label::WhileStart(id);
+        let end_label = Label::WhileEnd(id);
+        ctx.labels.label_map.insert(start_label, ctx.projected_pc);
+        self.count_expression(&stmt.test, ctx);
+        ctx.projected_pc += 1;
+        self.count_statement(&stmt.body, ctx);
+        ctx.projected_pc += 1;
+        ctx.labels.label_map.insert(end_label, ctx.projected_pc);
+    }
+
+    pub(crate) fn emit_while_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        let Statement::WhileStatement(wh) = stmt else {
+            return Ok(None);
+        };
+        let id = ctx.next_label_id();
+        let start_label = Label::WhileStart(id);
+        let end_label = Label::WhileEnd(id);
+        ctx.push_loop(end_label, start_label);
+        let n_labeled = ctx.take_pending_loop_labels(end_label, start_label);
+        let test_reg = self.emit_expression(&wh.test, ctx)?;
+        let end_pos = ctx.resolve_label(end_label)?;
+        let offset = (end_pos as isize) - (ctx.bytecode.len() as isize);
+        let offset = ctx.checked_jump_offset(offset);
+        ctx.emit(opcode::encode_jmp_if_false(test_reg, offset));
+        self.emit_statement(&wh.body, ctx)?;
+        let start_pos = ctx.resolve_label(start_label)?;
+        let offset = (start_pos as isize) - (ctx.bytecode.len() as isize);
+        let offset = ctx.checked_jump_offset(offset);
+        ctx.emit(opcode::encode_jmp(offset));
+        ctx.pop_label_scopes(n_labeled);
+        ctx.pop_loop();
+        Ok(None)
+    }
+}