fix-vm: use Machine trait exclusively

2026-06-19 22:37:29 +08:00
parent afbc471e40
commit f0e3f1eeca
13 changed files with 1240 additions and 1326 deletions
@@ -5,74 +5,71 @@ use smallvec::SmallVec;

 use crate::{Break, BytecodeReader, CallFrame, Step, VmRuntimeCtx};

-impl<'gc> crate::Vm<'gc> {
-    #[inline(always)]
-    pub(crate) fn op_lookup_with(
-        &mut self,
-        ctx: &mut impl VmRuntimeCtx,
-        reader: &mut BytecodeReader<'_>,
-        mc: &gc_arena::Mutation<'gc>,
-    ) -> Step {
-        #[allow(clippy::unwrap_used)]
-        let counter = self.peek_forced(0).as_inline::<i32>().unwrap();
+#[inline(always)]
+pub(crate) fn op_lookup_with<'gc, M: Machine<'gc>>(
+    m: &mut M,
+    ctx: &mut impl VmRuntimeCtx,
+    reader: &mut BytecodeReader<'_>,
+    mc: &gc_arena::Mutation<'gc>,
+) -> Step {
+    #[allow(clippy::unwrap_used)]
+    let counter = m.peek_forced(0).as_inline::<i32>().unwrap();

-        let name = reader.read_string_id();
-        let n = reader.read_u8();
-        let mut namespaces = SmallVec::<[_; 2]>::new();
-        for _ in 0..n {
-            namespaces.push(resolve_operand(&reader.read_operand_data(), mc, ctx, self));
-        }
+    let name = reader.read_string_id();
+    let n = reader.read_u8();
+    let mut namespaces = SmallVec::<[_; 2]>::new();
+    for _ in 0..n {
+        namespaces.push(resolve_operand(&reader.read_operand_data(), mc, ctx, m));
+    }

-        let resume_pc = reader.inst_start_pc();
-        let namespace = match namespaces[counter as usize].restrict() {
-            Ok(val) => val,
-            Err(thunk) => {
-                let mut state = thunk.borrow_mut(mc);
-                match *state {
-                    ThunkState::Pending { ip, env } => {
-                        *state = ThunkState::Blackhole;
-                        self.call_stack.push(CallFrame {
-                            thunk: Some(thunk),
-                            pc: resume_pc,
-                            env: self.env,
-                        });
-                        self.env = env;
-                        reader.set_pc(ip);
-                        return Step::Break(Break::Force);
-                    }
-                    ThunkState::Evaluated(v) => v,
-                    ThunkState::Apply { func, arg } => {
-                        self.call_stack.push(CallFrame {
-                            thunk: Some(thunk),
-                            pc: resume_pc,
-                            env: self.env,
-                        });
-                        self.push(func);
-                        return self.call(reader, mc, arg, resume_pc);
-                    }
-                    ThunkState::Blackhole => {
-                        return self
-                            .finish_err(Error::eval_error("infinite recursion encountered"));
-                    }
+    let resume_pc = reader.inst_start_pc();
+    let namespace = match namespaces[counter as usize].restrict() {
+        Ok(val) => val,
+        Err(thunk) => {
+            let mut state = thunk.borrow_mut(mc);
+            match *state {
+                ThunkState::Pending { ip, env } => {
+                    *state = ThunkState::Blackhole;
+                    m.push_call_frame(CallFrame {
+                        thunk: Some(thunk),
+                        pc: resume_pc,
+                        env: m.env(),
+                    });
+                    m.set_env(env);
+                    reader.set_pc(ip);
+                    return Step::Break(Break::Force);
+                }
+                ThunkState::Evaluated(v) => v,
+                ThunkState::Apply { func, arg } => {
+                    m.push_call_frame(CallFrame {
+                        thunk: Some(thunk),
+                        pc: resume_pc,
+                        env: m.env(),
+                    });
+                    m.push(func);
+                    return m.call(reader, mc, arg, resume_pc);
+                }
+                ThunkState::Blackhole => {
+                    return m.finish_err(Error::eval_error("infinite recursion encountered"));
                }
            }
-        };
-
-        if let Some(val) = namespace
-            .as_gc::<AttrSet>()
-            .and_then(|attrs| attrs.lookup(name))
-        {
-            self.replace(0, val);
-        } else if counter + 1 == n as i32 {
-            return self.finish_err(Error::eval_error(format!(
-                "undefined variable '{}'",
-                Symbol::from(ctx.resolve_string(name))
-            )));
-        } else {
-            self.replace(0, Value::new_inline(counter + 1));
-            reader.set_pc(resume_pc);
        }
+    };

-        Step::Continue(())
+    if let Some(val) = namespace
+        .as_gc::<AttrSet>()
+        .and_then(|attrs| attrs.lookup(name))
+    {
+        m.replace(0, val);
+    } else if counter + 1 == n as i32 {
+        return m.finish_err(Error::eval_error(format!(
+            "undefined variable '{}'",
+            Symbol::from(ctx.resolve_string(name))
+        )));
+    } else {
+        m.replace(0, Value::new_inline(counter + 1));
+        reader.set_pc(resume_pc);
    }
+
+    Step::Continue(())
 }