Method generate_stmt

aiscript-vm/src/compiler/codegen.rs:244–592

(&mut self, stmt: S)

    }

    fn generate_stmt<S: Into<Stmt<'gc>>>(&mut self, stmt: S) -> Result<(), VmError> {
        let stmt = stmt.into();
        self.current_line = stmt.line();
        match stmt {
            Stmt::Use { path, .. } => {
                // Load the module name as a constant
                let module_name = self.identifier_constant(path.lexeme);
                self.emit(OpCode::ImportModule(module_name as u8));
            }
            Stmt::Break { .. } => {
                let exit_jump = self.emit_jump(OpCode::Jump(0));
                // Get the last scope's index
                let last_idx = self.loop_scopes.len() - 1;
                // Add the break jump to the current loop scope
                self.loop_scopes[last_idx].breaks.push(exit_jump);
            }
            Stmt::Continue { .. } => {
                while self.local_count > 0
                    && self.locals[self.local_count - 1].depth > self.scope_depth
                {
                    self.emit(OpCode::Pop(1));
                    self.local_count -= 1;
                }

                if let Some(loop_scope) = self.loop_scopes.last() {
                    self.emit_loop(loop_scope.increment);
                }
            }
            Stmt::Expression { expression, .. } => {
                self.generate_expr(expression)?;
                // an expression statement evaluates the expression and discards the result
                // since the result already exists in the stack, we can just pop it
                self.emit(OpCode::Pop(1));
            }
            Stmt::Let(VariableDecl {
                name,
                initializer,
                visibility,
                ..
            }) => {
                self.declare_variable(name, Mutability::Mutable);
                if let Some(initial_value) = initializer {
                    self.generate_expr(initial_value)?;
                } else {
                    self.emit(OpCode::Nil);
                }
                if self.scope_depth > 0 {
                    self.mark_initialized();
                } else {
                    let global = self.identifier_constant(name.lexeme);
                    self.emit(OpCode::DefineGlobal {
                        name_constant: global as u8,
                        visibility,
                    });
                }
            }
            Stmt::Const {
                name,