arrow_vm/

execute.rs

use crate::error::ExecErrorType;
use arrow_parser::symbol::Symbol;
use arrowc::bytecode::BytecodeOp;
use arrowc::compile::Constant;
use arrowc::compile::IdentifierId;
use arrowc::compile::Program;
use itertools::Itertools;
use ordered_float::OrderedFloat;
use rustc_hash::FxHashMap;
use std::io::Write;
use std::rc::Rc;
use std::sync::mpsc::channel;
use std::sync::mpsc::Receiver;
use std::sync::mpsc::Sender;
use std::sync::Arc;

struct OperandStack {
  stack: Vec<Value>,
}

impl OperandStack {
  pub fn new() -> OperandStack {
    OperandStack { stack: Vec::new() }
  }

  pub fn len(&self) -> usize {
    self.stack.len()
  }

  pub fn peek(&self) -> &Value {
    self.stack.last().unwrap()
  }

  pub fn pop(&mut self) -> Value {
    self.stack.pop().unwrap()
  }

  // This will return the top 2 elements in order from least recent to most recent. This is the reverse of repeatedly calling `.pop()`, and makes life easier by not having to declare vars in reverse order.
  pub fn pop_2(&mut self) -> (Value, Value) {
    let right = self.pop();
    let left = self.pop();
    (left, right)
  }

  // This will return the top `n` elements in order from least recent to most recent. This is the reverse of repeatedly calling `.pop()`, and makes life easier by not having to temporarily allocate a Vec and then reverse it in place, or perform logic in reverse order.
  pub fn pop_n(&mut self, n: usize) -> Vec<Value> {
    let len = self.stack.len();
    assert!(len >= n);
    self.stack.split_off(len - n)
  }

  pub fn push(&mut self, v: Value) {
    self.stack.push(v);
  }
}

// This is passed/copied everywhere, so keep this as small as possible. As a rule of thumb, do not exceed 2 * WORD_SIZE.
#[derive(Clone)]
pub enum Value {
  Boolean(bool),
  Closure { closure_id: usize }, // We store closures in a heap as the data is too large to performantly pass around frequently.
  Float(OrderedFloat<f64>),
  Int(i64),
  Native(Rc<dyn NativeValue>), // Unfortunately we cannot avoid the cost of Rc, even if the type doesn't want it or itself uses Rc. A `dyn` cannot be sized so cannot subtype Clone.
  NativeCallable(&'static NativeCallable),
  None,
  Object { object_id: usize, impl_id: i16 }, // If `impl_id` is negative, it's a plain object.
  String(Arc<Vec<u8>>), // We don't need to store strings on the heap as they are immutable. It's Arc and not Rc because Constant::String is Arc.
  Vec { vec_id: usize }, // We store vectors on the heap for cheap shallow pointer-based diffing. This also allows mutability, as we shallow clone but Rc<RefCell<>> won't allow mutating if cloned.
}

struct Frame {
  box_ids: FxHashMap<Symbol, usize>, // Map from a declared variable that is boxed to the index of its latest allocated box on the box heap.
  func_id: usize,
  op_stack: OperandStack,
  pc: usize,
  vars: Vec<Value>,
}

impl Frame {
  fn set_up(program: &Program, func_id: usize) -> Frame {
    let func = &program.funcs[func_id];
    Frame {
      box_ids: FxHashMap::default(),
      func_id,
      op_stack: OperandStack::new(),
      pc: 0,
      vars: vec![Value::None; func.var_ids.len()],
    }
  }
}

struct Closure {
  bound_args: Vec<Value>,
  bound_offset: usize,
  captured_box_ids: FxHashMap<Symbol, usize>,
  func_id: usize,
}

pub type NativeCallable = fn(vm: &mut VM, args: Vec<Value>) -> NativeResult<Value>;

struct Object {
  fields: FxHashMap<Arc<Vec<u8>>, Value>,
}

// 99% of the time, the struct that implements this will need to use RefCell to allow for mutability with &self. However, we define it like this to allow other types where RefCell<> is unnecessary e.g. static, immutable, unsafe, copy-on-write, cell, etc., instead of always forcing it by simply wrapping all NativeValue values with Heap<Rc<RefCell<>>>. Remember that Value is clone because we spray/copy them everywhere (op stack, fields, vars, args, etc.), so we must use RefCell if we want to mutate. Additionally, some native values may want to be async internally and use Arc and Mutex/RwLock/etc. instead.
pub trait NativeValue {
  fn call_method(
    &self,
    vm: &mut VM,
    // `method_id` will always be a std identifier.
    method_id: IdentifierId,
    args: Vec<Value>,
  ) -> NativeResult<Value>;

  #[allow(unused_variables)]
  fn operator_add(&self, vm: &mut VM, other: Value) -> NativeResult<Value> {
    unimplemented!();
  }

  #[allow(unused_variables)]
  fn iterate(&self, vm: &mut VM) -> NativeResult<Value> {
    unimplemented!();
  }

  #[allow(unused_variables)]
  fn iterator_next(&self, vm: &mut VM) -> NativeResult<Option<Value>> {
    unimplemented!();
  }
}

struct Heap<T> {
  // We can't store in Vec, as we don't want to have to search and replace all IDs across everywhere when GCing.
  entries: FxHashMap<usize, T>,
  next_id: usize,
}

impl<T> Heap<T> {
  pub fn new() -> Heap<T> {
    Heap {
      entries: FxHashMap::default(),
      next_id: 0,
    }
  }

  pub fn allocate(&mut self, v: T) -> usize {
    let id = self.next_id;
    self.next_id += 1;
    self.entries.insert(id, v);
    id
  }

  pub fn set(&mut self, id: usize, val: T) {
    self.entries.insert(id, val).unwrap();
  }

  pub fn get(&self, id: usize) -> &T {
    self.entries.get(&id).unwrap()
  }

  pub fn get_mut(&mut self, id: usize) -> &mut T {
    self.entries.get_mut(&id).unwrap()
  }
}

enum CoroutineWaitedOnBy {
  Coroutine(CoroutineId),
  CtlRequest(CtlRequestId),
}

struct Coroutine {
  program: Arc<Program>,
  stack_frames: Vec<Frame>,
  waited_on_by: CoroutineWaitedOnBy,
}

pub type CoroutineId = usize;

// This is separate from Value as native functions can be async which means they'll provide a Value eventually, but Value isn't Send or Sync. We don't want to make Value Send or Sync as that taints everything and causes pointless inefficiency, which means we need a separate type for values sent across threads that owns the data and must be converted to Value on arrival. The same applies for CtlRequest and CtlResponse.
pub enum ThreadSafeValue {
  Boolean(bool),
  Float(OrderedFloat<f64>),
  Int(i64),
  Native(Box<dyn NativeValue + Send + Sync>),
  None,
  String(Arc<Vec<u8>>),
  Vec(Vec<ThreadSafeValue>),
}

impl ThreadSafeValue {
  pub fn into_value(self, vm: &mut VM) -> Value {
    match self {
      ThreadSafeValue::Boolean(v) => Value::Boolean(v),
      ThreadSafeValue::Float(v) => Value::Float(v),
      ThreadSafeValue::Int(v) => Value::Int(v),
      ThreadSafeValue::Native(v) => Value::Native({
        let v: Box<dyn NativeValue> = v;
        let v: Rc<dyn NativeValue> = v.into();
        v
      }),
      ThreadSafeValue::None => Value::None,
      ThreadSafeValue::String(v) => Value::String(v),
      ThreadSafeValue::Vec(v) => {
        let vec = v.into_iter().map(|v| v.into_value(vm)).collect_vec();
        Value::Vec {
          vec_id: vm.vecs.allocate(vec),
        }
      }
    }
  }

  pub fn from_value(vm: &VM, v: Value) -> CtlResponse {
    CtlResponse::Ok(match v {
      Value::Boolean(v) => ThreadSafeValue::Boolean(v),
      Value::Float(v) => ThreadSafeValue::Float(v),
      Value::Int(v) => ThreadSafeValue::Int(v),
      Value::None => ThreadSafeValue::None,
      Value::String(v) => ThreadSafeValue::String(v),
      Value::Vec { vec_id } => {
        let mut vec = vec![];
        for v in vm.vecs.get(vec_id) {
          match ThreadSafeValue::from_value(vm, v.clone()) {
            CtlResponse::Ok(v) => vec.push(v),
            res => return res,
          };
        }
        ThreadSafeValue::Vec(vec)
      }
      _ => return CtlResponse::ValueUnserialisable,
    })
  }
}

enum Event {
  CompletedPromise {
    coroutine_id: CoroutineId,
    value: ThreadSafeValue,
  },
  CtlRequest {
    id: CtlRequestId,
    request: CtlRequest,
  },
}

pub type CtlRequestId = usize;

pub enum CtlRequest {
  Execute {
    program: Arc<Program>,
  },
  Call {
    module_var_name: String,
    args: Vec<ThreadSafeValue>,
  },
}

pub enum CtlResponse {
  ExecError(ExecErrorType),
  Ok(ThreadSafeValue),
  ValueUnserialisable,
}

pub struct Promise {
  coroutine_id: CoroutineId,
  sender: Sender<Event>,
}

impl Promise {
  pub fn complete(self, value: ThreadSafeValue) {
    self
      .sender
      .send(Event::CompletedPromise {
        coroutine_id: self.coroutine_id,
        value,
      })
      .unwrap();
  }
}

pub enum NativeResult<T> {
  ExecError(ExecErrorType),
  Value(T),
  Promise,
}

pub struct VM {
  boxes: Heap<Value>,
  closures: Heap<Closure>,
  suspended_coroutines: FxHashMap<CoroutineId, Coroutine>,
  ctl_sender: Sender<(usize, CtlResponse)>,
  current_coroutine_id: Option<CoroutineId>,
  event_receiver: Receiver<Event>,
  event_sender: Sender<Event>,
  host_vars: FxHashMap<IdentifierId, Value>,
  next_coroutine_id: CoroutineId,
  objects: Heap<Object>,
  #[cfg(feature = "tokio")]
  tokio: tokio::runtime::Handle,
  vecs: Heap<Vec<Value>>,
}

pub struct VMCtl {
  receiver: Receiver<(usize, CtlResponse)>,
  sender: Sender<Event>,
}

impl VM {
  #[cfg(feature = "tokio")]
  pub fn tokio(&self) -> tokio::runtime::Handle {
    self.tokio.clone()
  }

  // WARNING: This function must only be called at most once from a native function when it's called. If it is called, the native function must return NativeResult::Promise. Anything else will lead to corrupted internal state.
  pub fn promise(&mut self) -> Promise {
    Promise {
      coroutine_id: self.current_coroutine_id.unwrap(),
      sender: self.event_sender.clone(),
    }
  }

  fn new_vm_only(
    native_callables: &[(IdentifierId, &'static NativeCallable)],
    ctl_sender: Sender<(usize, CtlResponse)>,
    event_receiver: Receiver<Event>,
    event_sender: Sender<Event>,
    #[cfg(feature = "tokio")] tokio: tokio::runtime::Handle,
  ) -> VM {
    let mut host_vars = FxHashMap::<IdentifierId, Value>::default();

    for (name, func) in native_callables {
      host_vars.insert(*name, Value::NativeCallable(func));
    }

    VM {
      boxes: Heap::new(),
      closures: Heap::new(),
      suspended_coroutines: FxHashMap::default(),
      ctl_sender,
      current_coroutine_id: None,
      event_receiver,
      event_sender,
      host_vars,
      next_coroutine_id: 0,
      objects: Heap::new(),
      #[cfg(feature = "tokio")]
      tokio,
      vecs: Heap::new(),
    }
  }

  // VM is not send, for good reason. If we just return (VM, VMCtl), we allow the user to use them however they want, but it makes it really tricky to start the VM loop in a different thread as it can't be sent/moved to a different thread. This function helps by creating and starting the thread automatically for the user.
  pub fn new_with_background_thread(
    native_callables: &'static [(IdentifierId, &'static NativeCallable)],
    #[cfg(feature = "tokio")] tokio: tokio::runtime::Handle,
  ) -> VMCtl {
    let (event_sender, event_receiver) = channel();
    let (ctl_sender, ctl_receiver) = channel();

    let vm_ctl = VMCtl {
      sender: event_sender.clone(),
      receiver: ctl_receiver,
    };
    std::thread::spawn(move || {
      let mut vm = VM::new_vm_only(
        native_callables,
        ctl_sender,
        event_receiver,
        event_sender,
        #[cfg(feature = "tokio")]
        tokio,
      );
      vm.start_execution_loop();
    });
    vm_ctl
  }

  // NOTE: It's recommended to use `new_with_background_thread` instead; see that method for details.
  pub fn new(
    native_callables: &[(IdentifierId, &'static NativeCallable)],
    #[cfg(feature = "tokio")] tokio: tokio::runtime::Handle,
  ) -> (VM, VMCtl) {
    let (event_sender, event_receiver) = channel();
    let (ctl_sender, ctl_receiver) = channel();

    let vm = VM::new_vm_only(
      native_callables,
      ctl_sender,
      event_receiver,
      event_sender.clone(),
      #[cfg(feature = "tokio")]
      tokio,
    );
    let vm_ctl = VMCtl {
      sender: event_sender.clone(),
      receiver: ctl_receiver,
    };
    (vm, vm_ctl)
  }

  // WARNING: Currently this function never exits as it holds a reference to the event queue sender as it's necessary for `.promise()`.
  pub fn start_execution_loop(&mut self) {
    loop {
      match self.event_receiver.recv().unwrap() {
        Event::CompletedPromise {
          coroutine_id,
          value,
        } => {
          let mut coroutine = self.suspended_coroutines.remove(&coroutine_id).unwrap();
          coroutine
            .stack_frames
            .last_mut()
            .unwrap()
            .op_stack
            .push(value.into_value(self));
          self.execute_coroutine(coroutine_id, coroutine).unwrap();
        }
        Event::CtlRequest { id, request } => {
          match request {
            CtlRequest::Execute { program } => {
              let frame = Frame::set_up(&program, program.funcs.len() - 1);
              let coroutine = Coroutine {
                program,
                stack_frames: vec![frame],
                waited_on_by: CoroutineWaitedOnBy::CtlRequest(id),
              };
              let coroutine_id: CoroutineId = self.next_coroutine_id;
              self.next_coroutine_id += 1;
              self.execute_coroutine(coroutine_id, coroutine).unwrap();
            }
            CtlRequest::Call {
              module_var_name,
              args,
            } => todo!(),
          };
        }
      };
    }
  }

  // This takes ownership of Coroutine (instead of getting mut ref in self.coroutines) to allow mutating it and `self` at the same time.
  // Return scenarios:
  // - All code has executed and stack is empty.
  // - Native function was called and it returned a promise, so the coroutine must be suspended.
  fn execute_coroutine(
    &mut self,
    coroutine_id: CoroutineId,
    mut coroutine: Coroutine,
  ) -> Result<(), ExecErrorType> {
    self.current_coroutine_id = Some(coroutine_id);

    let mut module_vars = FxHashMap::<IdentifierId, Value>::default();
    let program = &coroutine.program;

    // We pop so we can take ownership and therefore mutate it and `coroutine` at the same time.
    let mut f = coroutine.stack_frames.pop().unwrap();
    loop {
      let func = &program.funcs[f.func_id];
      let code = &func.code;
      // If this is Some after the loop breaks, we are entering a new function. If this is None after the loop breaks, we are returning from our current function; there should be exactly one value in the operand stack and that's our return value.
      let mut next_frame = None;
      loop {
        // WARNING: Remember to `break` after calling this!
        let mut call_function =
          |next_func_id: usize, args: Vec<Value>, captured_box_ids: FxHashMap<Symbol, usize>| {
            let mut new_frame = Frame::set_up(program, next_func_id);
            // We must assert expected argc is actual argc, as otherwise the function will not pop the correct amount of args. Note that we can't simply directly place in the new frame's local vars as some may be boxed and require more complex logic, so we just push everything onto its stack and let it deal with them. We will push in reverse order so they pop off in the right order as a convenience.
            assert_eq!(program.funcs[next_func_id].argc, args.len());
            for arg in args.into_iter().rev() {
              new_frame.op_stack.push(arg);
            }
            new_frame.box_ids = captured_box_ids;
            next_frame = Some(new_frame);
          };
        let inst = code[f.pc];
        // Increment now instead of after this giant block in case we break (i.e. return inside the VM).
        f.pc += 1;
        match inst {
          BytecodeOp::Add => {
            let (left, right) = f.op_stack.pop_2();
            let op = match (left, right) {
              (Value::Float(l), Value::Float(r)) => Value::Float(l + r),
              (Value::Int(l), Value::Int(r)) => Value::Int(l + r),
              (Value::String(l), Value::String(r)) => {
                let mut res = l.to_vec();
                res.extend_from_slice(r.as_slice());
                Value::String(Arc::new(res))
              }
              _ => panic!("invalid operands"),
            };
            f.op_stack.push(op);
          }
          BytecodeOp::AllocateBox { symbol } => {
            let box_id = self.boxes.allocate(Value::None);
            f.box_ids.insert(symbol, box_id);
          }
          BytecodeOp::BindImplMethod {
            func_id,
            bound_argc,
          } => {
            let bound_args = f.op_stack.pop_n(bound_argc.into());
            let closure_id = self.closures.allocate(Closure {
              bound_args,
              bound_offset: 1,
              captured_box_ids: FxHashMap::default(),
              func_id,
            });
            f.op_stack.push(Value::Closure { closure_id });
          }
          BytecodeOp::Call { argc } => {
            let mut args = f.op_stack.pop_n(argc.into());
            let callable = f.op_stack.pop();
            match callable {
              Value::Closure { closure_id } => {
                let Closure {
                  bound_args,
                  bound_offset,
                  captured_box_ids,
                  func_id,
                } = self.closures.get(closure_id);
                args.splice(bound_offset..bound_offset, bound_args.iter().cloned());
                call_function(*func_id, args, captured_box_ids.clone());
                break;
              }
              Value::NativeCallable(func) => {
                match func(self, args) {
                  NativeResult::ExecError(_) => todo!(),
                  NativeResult::Value(retval) => f.op_stack.push(retval),
                  NativeResult::Promise => {
                    coroutine.stack_frames.push(f);
                    self.suspended_coroutines.insert(coroutine_id, coroutine);
                    // We don't need to bump the program counter as it has already been incremented.
                    return Ok(());
                  }
                };
              }
              _ => panic!("not a callable"),
            };
          }
          BytecodeOp::CallMethod {
            argc,
            method_identifier_id,
          } => {
            let mut args = f.op_stack.pop_n(argc.into());
            let obj = f.op_stack.pop();
            match obj {
              Value::Object { impl_id, .. } => {
                args.insert(0, obj.clone());
                let impl_ = &program.impls[usize::try_from(impl_id).unwrap()];
                let func_id = impl_.methods.get(&method_identifier_id).unwrap();
                call_function(*func_id, args, FxHashMap::default());
                break;
              }
              Value::Native(nv) => {
                match nv.call_method(self, method_identifier_id.into(), args) {
                  NativeResult::ExecError(_) => todo!(),
                  NativeResult::Value(retval) => f.op_stack.push(retval),
                  NativeResult::Promise => {
                    coroutine.stack_frames.push(f);
                    self.suspended_coroutines.insert(coroutine_id, coroutine);
                    // We don't need to bump the program counter as it has already been incremented.
                    return Ok(());
                  }
                };
              }
              // TODO intrinsics.
              _ => panic!("cannot call method"),
            };
          }
          BytecodeOp::CastObjectToImpl { impl_id } => {
            let obj = f.op_stack.pop();
            let Value::Object { object_id, .. } = obj else {
              panic!("not an object");
            };
            f.op_stack.push(Value::Object {
              object_id,
              impl_id: i16::try_from(impl_id).unwrap(),
            });
          }
          BytecodeOp::CopyTopOfStack => {
            let val = f.op_stack.peek();
            f.op_stack.push(val.clone());
          }
          BytecodeOp::Eq => {
            let (left, right) = f.op_stack.pop_2();
            let op = match (left, right) {
              (Value::Float(l), Value::Float(r)) => Value::Boolean(l == r),
              (Value::Int(l), Value::Int(r)) => Value::Boolean(l == r),
              (Value::String(l), Value::String(r)) => Value::Boolean(l == r),
              _ => panic!("invalid operands"),
            };
            f.op_stack.push(op);
          }
          BytecodeOp::GetIterator => {
            let iterable = f.op_stack.pop();
            let iterator = match iterable {
              Value::Native(v) => match v.iterate(self) {
                NativeResult::ExecError(_) => todo!(),
                NativeResult::Value(next) => next,
                NativeResult::Promise => todo!(),
              },
              _ => panic!("not iterable"),
            };
            f.op_stack.push(iterator);
          }
          BytecodeOp::GetNextOfIteratorOrGoto(pc) => {
            let iterator = f.op_stack.peek();
            let next = match iterator {
              Value::Native(v) => match v.iterator_next(self) {
                NativeResult::ExecError(_) => todo!(),
                NativeResult::Value(next) => next,
                NativeResult::Promise => todo!(),
              },
              _ => panic!("not an iterable"),
            };
            match next {
              Some(v) => f.op_stack.push(v),
              None => f.pc = pc,
            };
          }
          BytecodeOp::Goto(loc) => {
            f.pc = loc;
          }
          BytecodeOp::GotoIfFalse(loc) => {
            let cond = f.op_stack.pop();
            let Value::Boolean(cond) = cond else {
              panic!("condition is not boolean");
            };
            if !cond {
              f.pc = loc;
            };
          }
          BytecodeOp::GotoIfNone(loc) => {
            let val = f.op_stack.peek();
            if let Value::None = val {
              f.op_stack.pop();
              f.pc = loc;
            };
          }
          BytecodeOp::Index => {
            let (obj_val, idx) = f.op_stack.pop_2();
            match (&obj_val, &idx) {
              (Value::Vec { vec_id }, Value::Int(idx)) => {
                let vec = self.vecs.get(*vec_id);
                let Some(val) = usize::try_from(*idx).ok().and_then(|idx| vec.get(idx)) else {
                  panic!("out of bounds");
                };
                f.op_stack.push(val.clone());
              }
              _ => panic!("cannot index"),
            };
          }
          BytecodeOp::IndexAssign => todo!(),
          BytecodeOp::InitialiseObjectField {
            field_name_string_const_id,
          } => {
            let (obj_val, value) = f.op_stack.pop_2();
            let Value::Object { object_id, .. } = obj_val else {
              panic!("not an object");
            };
            let field_name = program
              .constants
              .get(field_name_string_const_id)
              .unwrap()
              .string();
            self
              .objects
              .get_mut(object_id)
              .fields
              .insert(field_name, value);
            f.op_stack.push(obj_val);
          }
          BytecodeOp::LoadBool(v) => {
            f.op_stack.push(Value::Boolean(v));
          }
          BytecodeOp::LoadBox { symbol } => {
            let box_id = *f.box_ids.get(&symbol).unwrap();
            let val = self.boxes.get(box_id).clone();
            f.op_stack.push(val);
          }
          BytecodeOp::LoadClosure(func_id) => {
            let cfg = &program.funcs[func_id];
            let mut captured_box_ids = FxHashMap::default();
            for symbol in cfg.box_captures.iter() {
              captured_box_ids.insert(*symbol, *f.box_ids.get(&symbol).unwrap());
            }
            let closure_id = self.closures.allocate(Closure {
              func_id,
              captured_box_ids,
              bound_args: vec![],
              bound_offset: 0,
            });
            f.op_stack.push(Value::Closure { closure_id });
          }
          BytecodeOp::LoadConstant(constant_id) => {
            f.op_stack
              .push(match program.constants[constant_id].clone() {
                Constant::Float(v) => Value::Float(v),
                Constant::Int(v) => Value::Int(v),
                Constant::String(v) => Value::String(v.clone()),
              });
          }
          BytecodeOp::LoadField {
            field_name_string_const_id,
          } => {
            let Value::Object { object_id, .. } = f.op_stack.pop() else {
              panic!("not an object");
            };
            let obj = self.objects.get(object_id);
            let field_name = program
              .constants
              .get(field_name_string_const_id)
              .unwrap()
              .string();
            let val = obj.fields.get(&field_name).unwrap().clone();
            f.op_stack.push(val);
          }
          BytecodeOp::LoadHostVar(id) => {
            let val = self.host_vars.get(&id).unwrap().clone();
            f.op_stack.push(val);
          }
          BytecodeOp::LoadModuleVar(id) => {
            let val = module_vars.get(&id).unwrap().clone();
            f.op_stack.push(val);
          }
          BytecodeOp::LoadNone => {
            f.op_stack.push(Value::None);
          }
          BytecodeOp::LoadVar(var_id) => {
            f.op_stack.push(f.vars[var_id].clone());
          }
          BytecodeOp::NewArray { argc: _ } => todo!(),
          BytecodeOp::NewObject => {
            let object_id = self.objects.allocate(Object {
              fields: FxHashMap::default(),
            });
            f.op_stack.push(Value::Object {
              object_id,
              impl_id: -1,
            });
          }
          BytecodeOp::NewString { argc } => {
            let mut res = Vec::new();
            for part in f.op_stack.pop_n(argc.into()) {
              match part {
                Value::Boolean(v) => write!(res, "{}", v).unwrap(),
                Value::Float(v) => write!(res, "{}", v).unwrap(),
                Value::None => res.extend_from_slice(b"None"),
                Value::Int(v) => write!(res, "{}", v).unwrap(),
                Value::String(v) => res.extend_from_slice(&v),
                _ => panic!("cannot convert to string"),
              };
            }
            f.op_stack.push(Value::String(Arc::new(res)));
          }
          BytecodeOp::Not => {
            let val = f.op_stack.pop();
            let res = match val {
              Value::Boolean(b) => Value::Boolean(!b),
              _ => panic!("invalid operand"),
            };
            f.op_stack.push(res);
          }
          BytecodeOp::PopStack => {
            f.op_stack.pop();
          }
          BytecodeOp::Return => {
            break;
          }
          BytecodeOp::StoreBox { symbol } => {
            let val = f.op_stack.pop();
            let box_id = *f.box_ids.get(&symbol).unwrap();
            self.boxes.set(box_id, val);
          }
          BytecodeOp::StoreField {
            field_name_string_const_id,
          } => {
            let val = f.op_stack.pop();
            let Value::Object { object_id, .. } = f.op_stack.pop() else {
              panic!("not an object");
            };
            let field_name = program
              .constants
              .get(field_name_string_const_id)
              .unwrap()
              .string();
            self
              .objects
              .get_mut(object_id)
              .fields
              .insert(field_name, val);
          }
          BytecodeOp::StoreModuleVar(id) => {
            let val = f.op_stack.pop();
            module_vars.insert(id, val);
          }
          BytecodeOp::StoreVar(var_id) => {
            let val = f.op_stack.pop();
            f.vars[var_id] = val;
          }
          BytecodeOp::SwapTop2OfStack => {
            let (op0, op1) = f.op_stack.pop_2();
            f.op_stack.push(op1);
            f.op_stack.push(op0);
          }
        };
      }

      match next_frame {
        Some(next_frame) => {
          coroutine
            .stack_frames
            .push(std::mem::replace(&mut f, next_frame));
        }
        None => {
          assert_eq!(f.op_stack.len(), 1);
          let retval = f.op_stack.pop();
          if coroutine.stack_frames.is_empty() {
            match coroutine.waited_on_by {
              CoroutineWaitedOnBy::Coroutine(_) => todo!(),
              CoroutineWaitedOnBy::CtlRequest(request_id) => {
                self
                  .ctl_sender
                  .send((request_id, ThreadSafeValue::from_value(self, retval)))
                  .unwrap();
              }
            };
            self.current_coroutine_id = None;
            return Ok(());
          };
          f = coroutine.stack_frames.pop().unwrap();
          f.op_stack.push(retval);
        }
      };
    }
  }
}

impl VMCtl {
  pub fn request(&self, id: usize, request: CtlRequest) {
    self.sender.send(Event::CtlRequest { id, request }).unwrap();
  }

  pub fn receiver(&self) -> &Receiver<(usize, CtlResponse)> {
    &self.receiver
  }
}