Refine function call codegen, add a bit of vm

src/compile.rs

@@ -170,13 +170,19 @@ impl Expression {
             Expression::BinOp(binary_operator, node, node1) => todo!(),
             Expression::FunctionDefinition(nodes, block) => todo!(),
             Expression::FunctionCall(expr, params) => {
-                let function_register = scope.register_counter.next();
+                let mut instructions = Vec::new();
+                let (instr, registers) = expr.kind.compile(state, scope, 1);
+                instructions.extend(instr);
+
+                let function_register = registers.first().unwrap();
 
                 let mut param_regs = Vec::new();
-                for _ in 0..params.kind.0.len() {
+                for param in params.kind.0.iter() {
-                    param_regs.push(scope.register_counter.next());
+                    let (instr, registers) = param.kind.compile(state, scope, 1);
+                    instructions.extend(instr);
+                    param_regs.extend(registers);
                 }
-                let first_param_reg = param_regs.first().unwrap();
+
                 let last_param_reg = param_regs.last().unwrap();
 
                 let mut return_regs = Vec::new();
@@ -189,26 +195,12 @@ impl Expression {
                     }
                 }
 
-                let mut instructions = Vec::new();
+                let last_return_reg = return_regs.last().unwrap();
-                let (instr, registers) = expr.kind.compile(state, scope, 1);
+                scope.register_counter.0 = *last_return_reg + 1;
-                instructions.extend(instr);
-                instructions.push(Instruction::Move(
-                    function_register,
-                    *registers.first().unwrap(),
-                ));
-
-                for (i, param) in params.kind.0.iter().enumerate() {
-                    let (instr, registers) = param.kind.compile(state, scope, 1);
-                    instructions.extend(instr);
-                    instructions.push(Instruction::Move(
-                        *first_param_reg + i as u16,
-                        *registers.first().unwrap(),
-                    ));
-                }
 
                 instructions.push(Instruction::Call(
-                    function_register,
+                    *function_register,
-                    params.kind.0.len() as u16,
+                    param_regs.len() as u16,
                     return_regs.len() as u16 + 1,
                 ));
 

src/vm.rs

@@ -1,4 +1,4 @@
-use std::fmt::Debug;
+use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};
 
 use crate::ast::LuaNumber;
 
@@ -48,3 +48,23 @@ impl Debug for Instruction {
         }
     }
 }
+
+#[derive(Debug, Clone)]
+pub struct Environment {
+    pub globals: HashMap<Constant, Value>,
+}
+
+#[derive(Debug, Clone)]
+pub enum Value {
+    Number(VMNumber),
+    RustFunction(Rc<RefCell<dyn RustFunction>>),
+}
+
+pub trait RustFunction: Debug {
+    fn execute(&self, parameters: Vec<Value>) -> Vec<Value>;
+}
+
+pub struct ClosureRunner {
+    pub environment: Rc<RefCell<Environment>>,
+    pub constants: Vec<Constant>,
+}