io_trait: Add JkStdReader and fix tests

JkStdReader is the default JkReader implementation. This way is the user
does not gives a custom reader, we can use this one

Cargo.toml

@@ -24,9 +24,10 @@ libloading = { version = "0.7", optional = true }
 lazy_static = "1.4"
 
 [features]
-default = ["repl", "ffi"]
+default = ["repl", "ffi", "std"]
 repl = ["linefeed"]
 ffi = ["libloading", "libffi"]
+std = []
 
 [dev-dependencies]
 libc = "0.2"

examples/simple-repl.rs

@@ -1,11 +1,12 @@
 use jinko::context::Context;
+use jinko::io_trait::JkStdReader;
 use std::io::{self, Result, Write};
 
 fn main() -> Result<()> {
     let stdin = io::stdin();
     let mut stdout = io::stdout();
 
-    let mut ctx = Context::new();
+    let mut ctx = Context::new(Box::new(JkStdReader {}));
     let mut input = String::new();
 
     let mut prompt = "> ";

interpreter/jinko.rs

@@ -9,7 +9,6 @@ use colored::Colorize;
 use jinko::context::Context;
 use jinko::error::{ErrKind, Error};
 use jinko::instance::{FromObjectInstance, ObjectInstance};
-use jinko::io_trait::JkReader;
 use jinko::typechecker::CheckedType;
 use jinko::value::{JkBool, JkFloat, JkInt};
 
@@ -18,14 +17,6 @@ use args::Args;
 use repl::Repl;
 use std::{fs, path::Path};
 
-#[derive(Clone)]
-struct InterpreterReader {}
-impl JkReader for InterpreterReader {
-    fn read_to_string(&self, path: &str) -> Result<String, Error> {
-        unimplemented!("POV t\'as pas implem");
-    }
-}
-
 // FIXME: Add documentation
 pub type InteractResult = Result<(Option<ObjectInstance>, Context), Error>;
 
@@ -102,7 +93,7 @@ fn run_tests(ctx: &mut Context) -> Result<Option<ObjectInstance>, Error> {
 fn handle_input(args: &Args, file: &Path) -> InteractResult {
     let input = fs::read_to_string(file)?;
 
-    let mut ctx = Context::new(Box::new(InterpreterReader {}));
+    let mut ctx = Context::new(Box::new(jinko::io_trait::JkStdReader {}));
 
     if !args.nostdlib() {
         ctx.init_stdlib()?;

interpreter/repl.rs

@@ -7,10 +7,8 @@ use std::path::PathBuf;
 
 use jinko::{
     context::Context,
-    error::Error,
     instance::{FromObjectInstance, ObjectInstance},
     instruction::Instruction,
-    io_trait::JkReader,
     typechecker::CheckedType,
     value::JkConstant,
 };
@@ -41,14 +39,6 @@ impl std::fmt::Display for ReplInstance {
     }
 }
 
-#[derive(Clone)]
-pub struct ReplReader {}
-impl JkReader for ReplReader {
-    fn read_to_string(&self, path: &str) -> Result<String, Error> {
-        unimplemented!("POV t\'as pas implem");
-    }
-}
-
 pub struct Repl {
     ctx: Option<Context>,
     reader: Interface<DefaultTerminal>,
@@ -82,7 +72,7 @@ impl Repl {
     pub fn launch(self) -> InteractResult {
         let mut ctx = match self.ctx {
             Some(ctx) => ctx,
-            None => Context::new(Box::new(ReplReader {})),
+            None => Context::new(Box::new(jinko::io_trait::JkStdReader {})),
         };
 
         Repl::setup_context(&mut ctx);

src/context.rs

@@ -61,8 +61,6 @@ pub struct Context {
     pub entry_point: FunctionDec,
     /// Errors being kept by the context
     pub error_handler: ErrorHandler,
-
-    reader: Box<dyn JkReader>,
 }
 
 impl Context {
@@ -86,12 +84,11 @@ impl Context {
             #[cfg(feature = "ffi")]
             external_libs: Vec::new(),
             scope_map: ScopeMap::new(),
-            typechecker: TypeCtx::new(reader.clone()),
+            typechecker: TypeCtx::new(reader),
             debug_mode: false,
             code: None,
             entry_point: Self::new_entry(),
             error_handler: ErrorHandler::default(),
-            reader,
         };
 
         ctx.scope_enter();
@@ -424,7 +421,7 @@ mod tests {
         let f0 = FunctionDec::new("f0".to_owned(), None, vec![], vec![]);
         let f0_copy = FunctionDec::new("f0".to_owned(), None, vec![], vec![]);
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(i.add_function(f0), Ok(()));
         assert!(i.add_function(f0_copy).is_err());
@@ -435,15 +432,15 @@ mod tests {
         let v0 = Var::new("v0".to_owned());
         let v0_copy = Var::new("v0".to_owned());
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(i.add_variable(v0), Ok(()));
         assert!(i.add_variable(v0_copy).is_err());
     }
 
     #[test]
     fn t_print_scopemap() {
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
         ctx.init_stdlib().unwrap();
         ctx.execute().unwrap();
 
@@ -456,7 +453,7 @@ mod tests {
 
     #[test]
     fn t_print_eb() {
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         ctx.add_variable(Var::new(String::from("a_var_named_a")))
             .unwrap();
@@ -478,7 +475,7 @@ mod tests {
 
     #[test]
     fn t_eval() {
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
         let input = String::from("my_var = 1");
 
         ctx.eval(&input).unwrap();
@@ -489,7 +486,7 @@ mod tests {
 
     #[test]
     fn t_double_eval() {
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         let mut input = String::from("my_var = 1");
         ctx.eval(&input).unwrap();

src/generics.rs

@@ -184,7 +184,8 @@ mod tests {
 
     #[test]
     fn create_map_different_size() {
-        let mut ctx = TypeCtx::new();
+        use crate::io_trait::JkStdReader;
+        let mut ctx = TypeCtx::new(Box::new(JkStdReader {}));
 
         assert!(GenericMap::create(&[ty!("int"), ty!("float")], &[ty!("T")], &mut ctx).is_err());
     }

src/instance/mod.rs

@@ -176,7 +176,7 @@ mod tests {
     use crate::value::JkInt;
 
     fn setup() -> Context {
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         let inst = constructs::expr(span!("type Point(x: int, y: int);"))
             .unwrap()

src/instruction/binary_op.rs

@@ -203,7 +203,7 @@ mod tests {
             Operator::new("-"),
         );
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(
             binary_op.rhs().execute(&mut i).unwrap(),
@@ -225,7 +225,7 @@ mod tests {
             Operator::new("-"),
         );
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(binary_op.operator(), Operator::Sub);
 
@@ -243,7 +243,7 @@ mod tests {
         let boxed_output = crate::parser::constructs::expr(input).unwrap().1;
         let output = boxed_output.downcast_ref::<BinaryOp>().unwrap();
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(
             output.execute(&mut i).unwrap(),
@@ -305,7 +305,7 @@ mod tests {
 
     macro_rules! binop_assert {
         ($expr:expr) => {{
-            let mut ctx = Context::new();
+            let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
             let expr = crate::parser::constructs::expr(nom_locate::LocatedSpan::new_extra(
                 stringify!($expr),
                 None,

src/instruction/block.rs

@@ -212,7 +212,7 @@ mod tests {
     fn block_execute_empty() {
         let b = Block::new();
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(b.execute(&mut i), None);
         assert!(!i.error_handler.has_errors());
@@ -233,7 +233,7 @@ mod tests {
         ];
         b.set_instructions(instr);
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(b.execute(&mut i), None);
         assert!(!i.error_handler.has_errors());
@@ -253,7 +253,7 @@ mod tests {
         b.add_instruction(last);
         b.set_statement(false);
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(b.execute(&mut i).unwrap(), JkInt::from(18).to_instance());
         assert!(!i.error_handler.has_errors());
@@ -269,7 +269,7 @@ mod tests {
             .unwrap()
             .1;
 
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(ctx.type_check(b.as_mut()).unwrap(), CheckedType::Void)
     }

src/instruction/field_access.rs

@@ -191,7 +191,7 @@ mod tests {
     #[test]
     #[ignore] // FIXME: Do not ignore once we can type instance fields
     fn t_valid_multi_field_access() {
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         let inst = constructs::expr(span!("type Pair1(x: int, y: int)"))
             .unwrap()

src/instruction/function_call.rs

@@ -448,7 +448,7 @@ mod tests {
         use crate::instance::ToObjectInstance;
         use crate::value::JkInt;
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
         let func_dec = constructs::expr(span!("func __second(f: int, s: int) -> int { s }"))
             .unwrap()
             .1;
@@ -467,7 +467,7 @@ mod tests {
         use crate::instance::ToObjectInstance;
         use crate::value::JkInt;
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
         let func_dec = constructs::expr(span!("func add(a: int, b: int) -> int { a + b }"))
             .unwrap()
             .1;
@@ -486,7 +486,7 @@ mod tests {
         use crate::instance::ToObjectInstance;
         use crate::value::JkInt;
 
-        let mut i = Context::new();
+        let mut i = Context::new(Box::new(crate::io_trait::JkStdReader {}));
         let func_dec = constructs::expr(span!("func one() -> int { one = 1; one }"))
             .unwrap()
             .1;

src/instruction/function_declaration.rs

@@ -426,7 +426,7 @@ mod tests {
             FunctionDec::new("fn".to_owned(), Some(TypeId::from("int")), vec![], vec![]);
         function.set_kind(FunctionKind::Ext);
 
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(ctx.type_check(&mut function).unwrap(), CheckedType::Void);
         assert!(!ctx.error_handler.has_errors());
@@ -441,7 +441,7 @@ mod tests {
         let block = constructs::block(span!("{ 15 }")).unwrap().1;
         function.set_block(block);
 
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert_eq!(ctx.type_check(&mut function).unwrap(), CheckedType::Void);
         assert!(!ctx.error_handler.has_errors());
@@ -460,7 +460,7 @@ mod tests {
         let block = constructs::block(span!("{ 15 }")).unwrap().1;
         function.set_block(block);
 
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         assert!(ctx.type_check(&mut function).is_err());
         assert!(ctx.error_handler.has_errors());

src/instruction/if_else.rs

@@ -203,7 +203,7 @@ mod tests {
         use crate::instance::ToObjectInstance;
         use crate::value::{JkBool, JkInt};
 
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         let mut if_block = Block::new();
         let mut else_block = Block::new();
@@ -225,7 +225,7 @@ mod tests {
         use crate::instance::ToObjectInstance;
         use crate::value::{JkBool, JkInt};
 
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
 
         let mut if_block = Block::new();
         let mut else_block = Block::new();

src/instruction/incl.rs

@@ -10,6 +10,7 @@ use crate::error::{ErrKind, Error};
 use crate::generics::GenericUser;
 use crate::instance::ObjectInstance;
 use crate::instruction::{InstrKind, Instruction};
+use crate::io_trait::JkReader;
 use crate::location::SpanTuple;
 use crate::parser::constructs;
 use crate::typechecker::{CheckedType, TypeCheck, TypeCtx};
@@ -42,8 +43,12 @@ impl Incl {
         }
     }
 
-    fn fetch_instructions(&self, formatted: &Path) -> Result<Vec<Box<dyn Instruction>>, Error> {
-        let input = std::fs::read_to_string(&formatted)?;
+    fn fetch_instructions(
+        &self,
+        formatted: &Path,
+        reader: &dyn JkReader,
+    ) -> Result<Vec<Box<dyn Instruction>>, Error> {
+        let input = reader.read_to_string(formatted.to_str().unwrap())?;
 
         // We can't just parse the input, since it adds the instructions
         // to an entry block in order to execute them. What we can do, is
@@ -192,7 +197,7 @@ impl TypeCheck for Incl {
             return CheckedType::Void;
         }
 
-        let instructions = match self.fetch_instructions(&final_path) {
+        let instructions = match self.fetch_instructions(&final_path, ctx.reader()) {
             Ok(instructions) => instructions,
             Err(e) => {
                 ctx.error(e);
@@ -239,7 +244,7 @@ mod tests {
 
     #[test]
     fn tc_typecheck_stdlib() {
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
         ctx.execute().unwrap();
     }
 

src/instruction/method_call.rs

@@ -113,7 +113,7 @@ mod tests {
 
     #[test]
     fn t_execute() {
-        let mut ctx = Context::new();
+        let mut ctx = Context::new(Box::new(crate::io_trait::JkStdReader {}));
         let mut func_dec = constructs::expr(span!("func __first(a: int, b: int) -> int { a }"))
             .unwrap()
             .1;