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
@@ -1,94 +1,93 @@
+use fix_runtime::Machine;
 use gc_arena::{Gc, Mutation, RefLock};

 use crate::{BytecodeReader, Step, ThunkState, Value};

-impl<'gc> crate::Vm<'gc> {
-    #[inline(always)]
-    pub(crate) fn op_make_thunk(
-        &mut self,
-        reader: &mut BytecodeReader<'_>,
-        mc: &Mutation<'gc>,
-    ) -> Step {
-        let entry_point = reader.read_u32();
-        let thunk = Gc::new(
-            mc,
-            RefLock::new(ThunkState::Pending {
-                ip: entry_point as usize,
-                env: self.env,
-            }),
-        );
-        self.push(Value::new_gc(thunk));
-        Step::Continue(())
-    }
+#[inline(always)]
+pub(crate) fn op_make_thunk<'gc, M: Machine<'gc>>(
+    m: &mut M,
+    reader: &mut BytecodeReader<'_>,
+    mc: &Mutation<'gc>,
+) -> Step {
+    let entry_point = reader.read_u32();
+    let thunk = Gc::new(
+        mc,
+        RefLock::new(ThunkState::Pending {
+            ip: entry_point as usize,
+            env: m.env(),
+        }),
+    );
+    m.push(Value::new_gc(thunk));
+    Step::Continue(())
+}

-    #[inline(always)]
-    pub(crate) fn op_make_closure(
-        &mut self,
-        reader: &mut BytecodeReader<'_>,
-        mc: &Mutation<'gc>,
-    ) -> Step {
-        let entry_point = reader.read_u32();
-        let n_locals = reader.read_u32();
-        let closure = Gc::new(
-            mc,
-            crate::Closure {
-                ip: entry_point,
-                n_locals,
-                env: self.env,
-                pattern: None,
-            },
-        );
-        self.push(Value::new_gc(closure));
-        Step::Continue(())
-    }
+#[inline(always)]
+pub(crate) fn op_make_closure<'gc, M: Machine<'gc>>(
+    m: &mut M,
+    reader: &mut BytecodeReader<'_>,
+    mc: &Mutation<'gc>,
+) -> Step {
+    let entry_point = reader.read_u32();
+    let n_locals = reader.read_u32();
+    let closure = Gc::new(
+        mc,
+        crate::Closure {
+            ip: entry_point,
+            n_locals,
+            env: m.env(),
+            pattern: None,
+        },
+    );
+    m.push(Value::new_gc(closure));
+    Step::Continue(())
+}

-    #[inline(always)]
-    pub(crate) fn op_make_pattern_closure(
-        &mut self,
-        reader: &mut BytecodeReader<'_>,
-        mc: &Mutation<'gc>,
-    ) -> Step {
-        let entry_point = reader.read_u32();
-        let n_locals = reader.read_u32();
-        let req_count = reader.read_u16() as usize;
-        let opt_count = reader.read_u16() as usize;
-        let has_ellipsis = reader.read_u8() != 0;
+#[inline(always)]
+pub(crate) fn op_make_pattern_closure<'gc, M: Machine<'gc>>(
+    m: &mut M,
+    reader: &mut BytecodeReader<'_>,
+    mc: &Mutation<'gc>,
+) -> Step {
+    let entry_point = reader.read_u32();
+    let n_locals = reader.read_u32();
+    let req_count = reader.read_u16() as usize;
+    let opt_count = reader.read_u16() as usize;
+    let has_ellipsis = reader.read_u8() != 0;

-        let mut required = smallvec::SmallVec::new();
-        for _ in 0..req_count {
-            required.push(reader.read_string_id());
-        }
-        let mut optional = smallvec::SmallVec::new();
-        for _ in 0..opt_count {
-            optional.push(reader.read_string_id());
-        }
-        let total = req_count + opt_count;
-        let mut param_spans = Vec::with_capacity(total);
-        for _ in 0..total {
-            let name = reader.read_string_id();
-            let span_id = reader.read_u32();
-            param_spans.push((name, span_id));
-        }
+    let mut required = smallvec::SmallVec::new();
+    for _ in 0..req_count {
+        required.push(reader.read_string_id());
+    }
+    let mut optional = smallvec::SmallVec::new();
+    for _ in 0..opt_count {
+        optional.push(reader.read_string_id());
+    }
+    let total = req_count + opt_count;
+    let mut param_spans = Vec::with_capacity(total);
+    for _ in 0..total {
+        let name = reader.read_string_id();
+        let span_id = reader.read_u32();
+        param_spans.push((name, span_id));
+    }

-        let pattern = Gc::new(
-            mc,
-            crate::PatternInfo {
-                required,
-                optional,
-                ellipsis: has_ellipsis,
-                param_spans: param_spans.into_boxed_slice(),
-            },
-        );
-        let closure = Gc::new(
-            mc,
-            crate::Closure {
-                ip: entry_point,
-                n_locals,
-                env: self.env,
-                pattern: Some(pattern),
-            },
-        );
-        self.push(Value::new_gc(closure));
-        Step::Continue(())
-    }
+    let pattern = Gc::new(
+        mc,
+        crate::PatternInfo {
+            required,
+            optional,
+            ellipsis: has_ellipsis,
+            param_spans: param_spans.into_boxed_slice(),
+        },
+    );
+    let closure = Gc::new(
+        mc,
+        crate::Closure {
+            ip: entry_point,
+            n_locals,
+            env: m.env(),
+            pattern: Some(pattern),
+        },
+    );
+    m.push(Value::new_gc(closure));
+    Step::Continue(())
 }