Object and test refactoring

crates/compiler/Cargo.toml

@@ -10,8 +10,9 @@ edition = "2021"
 lexer = { path = "../lexer" }
 parser = { path = "../parser" }
 interpreter = { path = "../interpreter" }
+object = { path = "../object" }
+
 # External crates
 byteorder = "1.4.3"
 num-derive = "0.4.0"
 num-traits = "0.2.15"
-

crates/compiler/src/compiler.rs

@@ -1,8 +1,8 @@
 use crate::code::{Instructions, Opcode};
 use crate::symbol_table::SymbolTable;
-use interpreter::object::Object;
 use lexer::token::Token;
 use num_traits::FromPrimitive;
+use object::object::Object;
 use parser::ast::Program;
 use parser::ast::{BlockStatement, Conditional, Expression, InfixOperator, Primitive, Statement};
 
@@ -312,10 +312,11 @@ pub mod tests {
 
     use std::rc::Rc;
 
-    use crate::{
-        code::Opcode,
-        test_utils::{check_constants, check_instructions, parse},
-    };
+    use object::test_utils::check_constants;
+    use parser::parser::parse;
+
+    use crate::code::Opcode;
+    use crate::test_utils::check_instructions;
 
     use super::*;
 

crates/compiler/src/lib.rs

@@ -1,4 +1,4 @@
 pub mod code;
 pub mod compiler;
 pub mod symbol_table;
-pub mod test_utils;
+mod test_utils;

crates/compiler/src/test_utils.rs

@@ -1,15 +1,6 @@
 use crate::code::Instructions;
-use interpreter::object::Object;
-use lexer::lexer::Lexer;
-use parser::{ast::Program, parser::Parser};
-use std::rc::Rc;
-
-pub fn parse(input: &str) -> Program {
-    let lexer = Lexer::new(input);
-    let mut parser = Parser::new(lexer);
-    parser.parse_program()
-}
 
+#[allow(dead_code)]
 pub fn check_instructions(instructions: &Instructions, expected: &Instructions) {
     assert_eq!(
         instructions.data.len(),
@@ -21,20 +12,3 @@ pub fn check_instructions(instructions: &Instructions, expected: &Instructions)
         "wrong instructions. want={expected:?}, got={instructions:?}"
     );
 }
-
-pub fn check_constants(constants: &Vec<Object>, expected: &Vec<Rc<Object>>) {
-    assert_eq!(
-        constants.len(),
-        expected.len(),
-        "wrong number of constants. got={:?}, want={:?}",
-        constants.len(),
-        expected.len()
-    );
-
-    for (expected_constant, constant) in expected.iter().zip(constants.iter()) {
-        assert_eq!(
-            **expected_constant, *constant,
-            "constant not equal. got={constant:?}, want={expected_constant:?}"
-        );
-    }
-}

crates/interpreter/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+
 lexer = { path = "../lexer" }
 parser = { path = "../parser" }
-
+object = { path = "../object" }

crates/interpreter/src/evaluator.rs

@@ -1,18 +1,14 @@
-use crate::{
+use lexer::token::Token;
+use object::{
     enviroment::Environment,
-    object::{BuiltinFunction, Function, Object},
+    object::{Object, FALSE, NULL, TRUE, Function, BuiltinFunction},
 };
-use lexer::token::Token;
 use parser::ast::{
     BlockStatement, Conditional, Expression, HashMapLiteral, Identifier, IndexExpression,
     Primitive, Program, Statement,
 };
 use std::{cell::RefCell, collections::HashMap, rc::Rc};
 
-const TRUE: Object = Object::BOOLEAN(true);
-const FALSE: Object = Object::BOOLEAN(false);
-pub const NULL: Object = Object::NULL;
-
 pub struct Evaluator {
     env: Rc<RefCell<Environment>>,
 }
@@ -102,7 +98,7 @@ impl Evaluator {
             Expression::FunctionLiteral(x) => {
                 let parameters = x.parameters;
                 let body = x.body;
-                Object::FUNCTION(Function {
+                Object::FUNCTION(Function{
                     parameters,
                     body,
                     environment: Rc::clone(&self.env),

crates/interpreter/src/lib.rs

@@ -1,3 +1 @@
-mod enviroment;
 pub mod evaluator;
-pub mod object;

crates/object/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "object"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+
+parser = { path = "../parser" }
+
+

crates/interpreter/src/enviroment.rs → crates/object/src/enviroment.rs

@@ -1,6 +1,7 @@
-use super::object::Object;
 use std::{cell::RefCell, collections::HashMap, rc::Rc};
 
+use crate::object::Object;
+
 #[derive(Debug, PartialEq, Clone)]
 pub struct Environment {
     store: HashMap<String, Object>,

crates/object/src/lib.rs

@@ -0,0 +1,3 @@
+pub mod object;
+pub mod enviroment;
+pub mod test_utils;

crates/interpreter/src/object.rs → crates/object/src/object.rs

@@ -1,8 +1,13 @@
-use super::enviroment::Environment;
-use crate::evaluator::NULL;
-use parser::ast::{BlockStatement, Identifier};
 use std::{cell::RefCell, cmp::Ordering, collections::HashMap, fmt::Display, hash::Hash, rc::Rc};
 
+use parser::ast::{BlockStatement, Identifier};
+
+use crate::enviroment::Environment;
+
+pub const TRUE: Object = Object::BOOLEAN(true);
+pub const FALSE: Object = Object::BOOLEAN(false);
+pub const NULL: Object = Object::NULL;
+
 #[derive(Debug, PartialEq, Clone)]
 pub enum Object {
     INTEGER(i64),
@@ -123,19 +128,6 @@ impl Display for BuiltinFunction {
 
 #[allow(clippy::needless_pass_by_value)] // false positive
 impl BuiltinFunction {
-    pub fn get_builtins() -> Environment {
-        let mut env = Environment::new();
-        env.set(String::from("len"), Object::BUILTIN(BuiltinFunction::LEN));
-        env.set(
-            String::from("first"),
-            Object::BUILTIN(BuiltinFunction::FIRST),
-        );
-        env.set(String::from("last"), Object::BUILTIN(BuiltinFunction::LAST));
-        env.set(String::from("rest"), Object::BUILTIN(BuiltinFunction::REST));
-        env.set(String::from("push"), Object::BUILTIN(BuiltinFunction::PUSH));
-        env
-    }
-
     pub fn get_builtin(name: &str) -> Option<Object> {
         match name {
             "len" => Some(Object::BUILTIN(BuiltinFunction::LEN)),

crates/object/src/test_utils.rs

@@ -0,0 +1,20 @@
+use std::rc::Rc;
+
+use crate::object::Object;
+
+pub fn check_constants(constants: &Vec<Object>, expected: &Vec<Rc<Object>>) {
+    assert_eq!(
+        constants.len(),
+        expected.len(),
+        "wrong number of constants. got={:?}, want={:?}",
+        constants.len(),
+        expected.len()
+    );
+
+    for (expected_constant, constant) in expected.iter().zip(constants.iter()) {
+        assert_eq!(
+            **expected_constant, *constant,
+            "constant not equal. got={constant:?}, want={expected_constant:?}"
+        );
+    }
+}

crates/parser/src/parser.rs

@@ -220,6 +220,12 @@ impl Parser {
     }
 }
 
+pub fn parse(input: &str) -> Program {
+    let lexer = Lexer::new(input);
+    let mut parser = Parser::new(lexer);
+    parser.parse_program()
+}
+
 #[cfg(test)]
 mod tests {
     use lexer::token::Token;

crates/repl/Cargo.toml

@@ -8,12 +8,11 @@ edition = "2021"
 [dependencies]
 lexer = { path = "../lexer" }
 parser = { path = "../parser" }
+object = { path = "../object" }
 interpreter = { path = "../interpreter" }
 compiler = { path = "../compiler" }
 vm = { path = "../vm" }
 
 # External crates
 clap = "4.3.11"
 clap_derive = "4.3.2"
-
-

crates/repl/src/repl.rs

@@ -2,14 +2,14 @@ use clap_derive::{Parser, ValueEnum};
 use compiler::compiler::{Bytecode, Compiler};
 use compiler::symbol_table::SymbolTable;
 use interpreter::evaluator::Evaluator;
-use interpreter::object::Object;
 use lexer::lexer::Lexer;
 use lexer::token::Token;
+use object::object::{Object, NULL};
 use parser::parser::{Parser, ParserErrors};
 use std::io::{self, Write};
 use std::rc::Rc;
 use std::{error::Error, fs};
-use vm::vm::{GLOBALS_SIZE, NULL, VM};
+use vm::vm::{GLOBALS_SIZE, VM};
 
 use crate::errors::{CompilerError, LexerErrors, RuntimeError};
 

crates/vm/Cargo.toml

@@ -8,8 +8,10 @@ edition = "2021"
 [dependencies]
 # Internal crates
 
+parser = { path = "../parser" }
 compiler = { path = "../compiler" }
 interpreter = { path = "../interpreter" }
+object = { path = "../object" }
 
 # External crates
 num-traits = "0.2.15"