refactor: 拆分 oxide_emit 为独立 emit pass crate（依赖倒置）

crates/oxide_emit/src/stmt/basic/break_continue.rs

@@ -0,0 +1,42 @@
+use crate::{CompileCtx, Emitter};
+use oxide_ir::inst::Inst;
+
+impl Emitter {
+    pub(crate) fn emit_break_statement(
+        &self, stmt: &oxide_parser::BreakStatement, ctx: &mut CompileCtx,
+    ) -> Result<Option<u8>, String> {
+        let break_label = if let Some(label) = &stmt.label {
+            let name = label.name.as_str();
+            let scope = ctx
+                .find_label(name)
+                .ok_or_else(|| format!("SyntaxError: Undefined label '{name}'"))?;
+            scope.break_label
+        } else if let Some(sw_label) = ctx.current_switch() {
+            *sw_label
+        } else {
+            let (bl, _) = ctx.current_loop().ok_or("break outside switch or loop".to_string())?;
+            *bl
+        };
+        ctx.inst(Inst::jmp(break_label));
+        Ok(None)
+    }
+
+    pub(crate) fn emit_continue_statement(
+        &self, stmt: &oxide_parser::ContinueStatement, ctx: &mut CompileCtx,
+    ) -> Result<Option<u8>, String> {
+        let continue_label = if let Some(label) = &stmt.label {
+            let name = label.name.as_str();
+            let scope = ctx
+                .find_label(name)
+                .ok_or_else(|| format!("SyntaxError: Undefined label '{name}'"))?;
+            scope.continue_label.ok_or_else(|| {
+                format!("SyntaxError: Illegal continue statement: '{name}' does not denote an iteration statement")
+            })?
+        } else {
+            let (_, cl) = ctx.current_loop().ok_or("continue outside loop".to_string())?;
+            *cl
+        };
+        ctx.inst(Inst::jmp(continue_label));
+        Ok(None)
+    }
+}

crates/oxide_emit/src/stmt/basic/expression.rs

@@ -0,0 +1,15 @@
+use crate::{CompileCtx, Emitter};
+use oxide_parser::Statement;
+
+impl Emitter {
+    fn emit_expression_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        let Statement::ExpressionStatement(es) = stmt else {
+            return Ok(None);
+        };
+        Ok(Some(self.emit_expression(&es.expression, ctx)?))
+    }
+
+    pub(crate) fn emit_basic_expression(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        self.emit_expression_statement(stmt, ctx)
+    }
+}

crates/oxide_emit/src/stmt/basic/labeled.rs

@@ -0,0 +1,32 @@
+use crate::{CompileCtx, Emitter};
+use oxide_parser::Statement;
+
+impl Emitter {
+    fn is_iteration_statement(stmt: &Statement) -> bool {
+        matches!(
+            stmt,
+            Statement::WhileStatement(_)
+                | Statement::DoWhileStatement(_)
+                | Statement::ForStatement(_)
+                | Statement::ForInStatement(_)
+                | Statement::ForOfStatement(_)
+        )
+    }
+
+    pub(crate) fn emit_labeled_statement(
+        &self, stmt: &oxide_parser::LabeledStatement, ctx: &mut CompileCtx,
+    ) -> Result<Option<u8>, String> {
+        let name = stmt.label.name.as_str();
+        if Self::is_iteration_statement(&stmt.body) {
+            ctx.queue_loop_label(name)?;
+            self.emit_statement(&stmt.body, ctx)?;
+        } else {
+            let id = ctx.next_label_id();
+            ctx.push_label_scope(name, id, None)?;
+            self.emit_statement(&stmt.body, ctx)?;
+            ctx.labels.set_label_pos(id, ctx.insts.len());
+            ctx.pop_label_scope();
+        }
+        Ok(None)
+    }
+}

crates/oxide_emit/src/stmt/basic/mod.rs

@@ -0,0 +1,18 @@
+use crate::{CompileCtx, Emitter};
+use oxide_parser::Statement;
+
+mod break_continue;
+mod expression;
+mod labeled;
+mod return_stmt;
+
+impl Emitter {
+    pub(crate) fn emit_basic_domain(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        match stmt {
+            Statement::ExpressionStatement(_) => self.emit_basic_expression(stmt, ctx),
+            Statement::ReturnStatement(_) => self.emit_basic_return(stmt, ctx),
+            Statement::EmptyStatement(_) => Ok(None),
+            _ => Ok(None),
+        }
+    }
+}

crates/oxide_emit/src/stmt/basic/return_stmt.rs

@@ -0,0 +1,27 @@
+use crate::{CompileCtx, Emitter};
+use oxide_ir::inst::Inst;
+use oxide_ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
+use oxide_parser::Statement;
+
+impl Emitter {
+    fn emit_return_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        let Statement::ReturnStatement(ret) = stmt else {
+            return Ok(None);
+        };
+        match &ret.argument {
+            Some(expr) => {
+                let r = self.emit_expression(expr, ctx)?;
+                ctx.inst(Inst::new(OpCode::RETURN, Operand::Reg(r as u32), Operand::None, Operand::None));
+            }
+            None => {
+                ctx.inst(Inst::new(OpCode::RETURN, Operand::None, Operand::None, Operand::None));
+            }
+        }
+        Ok(None)
+    }
+
+    pub(crate) fn emit_basic_return(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
+        self.emit_return_statement(stmt, ctx)
+    }
+}