Made the tests compile

The entire compiler is now compiling, tests are still failing though

Author: Marwes

compiler.rs

@@ -1054,7 +1054,7 @@ pub fn compile(contents: &str) -> Assembly {
     compile_with_type_env(&mut type_env, &[], contents)
 }
 #[allow(dead_code)]
-pub fn compile_with_type_env<'a>(type_env: &'a mut TypeEnvironment<'a>, assemblies: &[&'a Assembly], contents: &str) -> Assembly {
+pub fn compile_with_type_env<'a>(type_env: &mut TypeEnvironment<'a>, assemblies: &[&'a Assembly], contents: &str) -> Assembly {
     use parser::Parser;
 
     let mut parser = Parser::new(contents.as_slice().chars()); 
@@ -1110,6 +1110,7 @@ mod tests {
 
 use interner::*;
 use compiler::*;
+use compiler::Instruction::*;
 use typecheck::TypeEnvironment;
 use std::io::File;
 use test::Bencher;
@@ -1212,17 +1213,17 @@ instance Test Int where
 main x = primIntAdd (test x) 6";
     let assembly = compile(file);
 
-    let main = assembly.superCombinators[0];
+    let main = &assembly.superCombinators[0];
     assert_eq!(main.name.name, intern("main"));
     assert_eq!(main.instructions, vec![PushInt(6), Push(1), PushDictionaryMember(0), Mkap, Eval, Add, Update(0), Pop(2), Unwind]);
 }
 
 #[test]
 fn compile_prelude() {
     let mut type_env = TypeEnvironment::new();
-    let prelude = compile_with_type_env(&mut type_env, [], File::open(&Path::new("Prelude.hs")).read_to_str().unwrap().as_slice());
+    let prelude = compile_with_type_env(&mut type_env, &[], File::open(&Path::new("Prelude.hs")).read_to_string().unwrap().as_slice());
 
-    let assembly = compile_with_type_env(&mut type_env, [&prelude], r"main = id (primIntAdd 2 0)");
+    let assembly = compile_with_type_env(&mut type_env, &[&prelude], r"main = id (primIntAdd 2 0)");
 
     let sc = &assembly.superCombinators[0];
     let id_index = prelude.superCombinators.iter().position(|sc| sc.name.name == intern("id")).unwrap();
@@ -1272,7 +1273,7 @@ newtype Test a = Test [a]
 test = Test [1::Int]";
     let assembly = compile(file);
 
-    let test = assembly.superCombinators[0];
+    let test = &assembly.superCombinators[0];
     assert_eq!(test.instructions, vec![Pack(0, 0), PushInt(1), Pack(1, 2), Update(0), Unwind]);
 }
 
@@ -1284,7 +1285,7 @@ fn bench_prelude(b: &mut Bencher) {
     use parser::Parser;
 
     let path = &Path::new("Prelude.hs");
-    let contents = File::open(path).read_to_str().unwrap();
+    let contents = File::open(path).read_to_string().unwrap();
     let mut parser = Parser::new(contents.as_slice().chars());
     let mut module = rename_module(parser.module());
     let mut type_env = TypeEnvironment::new();

core.rs

@@ -196,7 +196,7 @@ impl <T> Typed for Id<T> {
 }
 
 
-mod ref_ {
+pub mod ref_ {
     use super::*;
     use super::Expr::*;
     ///Visitor for the types in the core language.

infix.rs

@@ -130,7 +130,7 @@ test = 3 * 4 - 5 * 6").unwrap();
         for module in modules.iter_mut() {
             v.visit_module(module);
         }
-        assert_eq!(modules.last().unwrap().bindings[0].matches, Simple(rename_expr(op_apply(
+        assert_eq!(modules.last().unwrap().bindings[0].matches, Match::Simple(rename_expr(op_apply(
             op_apply(number(3), intern("*"), number(4)),
             intern("-"),
             op_apply(number(5), intern("*"), number(6))))));
@@ -146,7 +146,7 @@ test = 3 * 4 * (5 - 6)").unwrap();
         for module in modules.iter_mut() {
             v.visit_module(module);
         }
-        assert_eq!(modules.last().unwrap().bindings[0].matches, Simple(rename_expr(op_apply(
+        assert_eq!(modules.last().unwrap().bindings[0].matches, Match::Simple(rename_expr(op_apply(
             op_apply(number(3), intern("*"), number(4)),
             intern("*"),
             paren(op_apply(number(5), intern("-"), number(6)))))));

lambda_lift.rs

@@ -208,9 +208,11 @@ mod tests {
     use test::Bencher;
     use interner::*;
     use lambda_lift::*;
-    use collections::hashmap::HashSet;
+    use std::collections::HashSet;
     use parser::Parser;
     use core::*;
+    use core::Expr::*;
+    use core::ref_::*;
     use core::translate::translate_module;
     use renamer::rename_module;
     use typecheck::TypeEnvironment;
@@ -249,12 +251,12 @@ test2 x =
             in add x test
     in f x".chars());
         let module = translate_module(rename_module(parser.module()));
-        (&mut visitor as &mut Visitor<Id>).visit_module(&module);
+        visitor.visit_module(&module);
     }
 
     fn check_args(expr: &Expr<Id>, args: &[InternedStr]) -> bool {
         match expr {
-            &Lambda(ref arg, ref body) => arg.name.name == args[0] && check_args(*body, args.slice_from(1)),
+            &Lambda(ref arg, ref body) => arg.name.name == args[0] && check_args(&**body, args.slice_from(1)),
             _ => args.len() == 0
         }
     }
@@ -266,12 +268,11 @@ test2 x =
     fn get_let<'a>(expr: &'a Expr<Id>, args: &mut Vec<InternedStr>) -> &'a Expr<Id> {
         match expr {
             &Apply(ref f, ref arg) => {
-                let a: &Expr<Id> = *arg;
-                match a {
-                    &Identifier(ref i) => args.push(i.name.name),
+                match **arg {
+                    Identifier(ref i) => args.push(i.name.name),
                     _ => panic!("Expected identifier as argument")
                 }
-                get_let(*f, args)
+                get_let(&**f, args)
             }
             _ => expr
         }
@@ -325,7 +326,7 @@ test2 x =
 	TypeEnvironment::new().typecheck_module(&mut module);
         let m = translate_module(module);
         let module = abstract_module(m);
-        (&mut visitor as &mut Visitor<Id>).visit_module(&module);
+        visitor.visit_module(&module);
         assert_eq!(visitor.count, 2);
     }
 
@@ -342,9 +343,9 @@ test2 x =
     }
     #[test]
     fn no_local_lambdas() {
-        fn skip_lambdas<'a, T>(expr: &'a Expr<T>) -> &'a Expr<T> {
+        fn skip_lambdas<T>(expr: &Expr<T>) -> &Expr<T> {
             match expr {
-                &Lambda(_, ref body) => skip_lambdas(*body),
+                &Lambda(_, ref body) => skip_lambdas(&**body),
                 _ => expr
             }
         }
@@ -363,7 +364,7 @@ test2 x =
         let m = translate_module(rename_module(parser.module()));
         let module = lift_lambdas(m);
         for bind in module.bindings.iter() {
-            (&mut visitor as &mut Visitor<TypeAndStr>).visit_expr(skip_lambdas(&bind.expression));
+            visitor.visit_expr(skip_lambdas(&bind.expression));
         }
     }
 
@@ -373,7 +374,7 @@ test2 x =
         use typecheck::test::do_typecheck;
 
         let path = &Path::new("Prelude.hs");
-        let contents = File::open(path).read_to_str().unwrap();
+        let contents = File::open(path).read_to_string().unwrap();
         let module = do_typecheck(contents.as_slice());
         b.iter(|| {
             do_lambda_lift(translate_module(module.clone()))

lexer.rs

@@ -587,6 +587,7 @@ impl <Stream : Iterator<Item=char>> Lexer<Stream> {
 mod tests {
 
 use lexer::*;
+use lexer::TokenEnum::*;
 
 #[test]
 fn simple() {

parser.rs

@@ -1093,8 +1093,10 @@ fn parse_modules_(visited: &mut HashSet<InternedStr>, modules: &mut Vec<Module>,
 mod tests {
 
 use interner::*;
+use lexer::{Location, Located };
 use parser::*;
 use module::*;
+use module::Expr::*;
 use typecheck::{identifier, apply, op_apply, number, rational, lambda, let_, case, if_else};
 use std::io::File;
 use test::Bencher;
@@ -1266,7 +1268,7 @@ r"class Eq a => Ord a where_bindings
 ".chars());
     let module = parser.module();
 
-    let cls = module.classes[0];
+    let cls = &module.classes[0];
     let a = Type::new_var(intern("a")).var().clone();
     assert_eq!(cls.name, intern("Ord"));
     assert_eq!(cls.variable, a);
@@ -1356,9 +1358,9 @@ infixr 6 `test2`, |<
 test2 x y = 1
 ".chars());
     let module = parser.module();
-    assert_eq!(module.fixity_declarations.as_slice(), &[
-        FixityDeclaration { assoc: RightAssoc, precedence: 5, operators: vec![intern("test")] },
-        FixityDeclaration { assoc: RightAssoc, precedence: 6, operators: vec![intern("test2"), intern("|<")] },
+    assert_eq!(module.fixity_declarations, [
+        FixityDeclaration { assoc: Assoc::Right, precedence: 5, operators: vec![intern("test")] },
+        FixityDeclaration { assoc: Assoc::Right, precedence: 6, operators: vec![intern("test2"), intern("|<")] },
     ]);
 }
 
@@ -1373,7 +1375,7 @@ dummy = 1
     let module = parser.module();
     let data = &module.dataDefinitions[0];
     assert_eq!(data.typ, qualified(Vec::new(), Type::new_op(intern("Test"), Vec::new())));
-    assert_eq!(data.deriving.as_slice(), &[intern("Eq"), intern("Show")]);
+    assert_eq!(data.deriving, [intern("Eq"), intern("Show")]);
 }
 
 #[test]

typecheck.rs

@@ -12,9 +12,6 @@ use builtins::builtins;
 use renamer::*;
 use interner::*;
 
-#[cfg(test)]
-use module::Alternative;
-
 ///Trait which can be implemented by types where types can be looked up by name
 pub trait Types {
     fn find_type<'a>(&'a self, name: &Name) -> Option<&'a Qualified<Type, Name>>;
@@ -1621,6 +1618,7 @@ fn typecheck_modules_common(modules: Vec<Module>) -> Vec<Module<Name>> {
 pub mod test {
 use interner::*;
 use module::*;
+use module::Expr::*;
 use typecheck::*;
 use renamer::*;
 
@@ -1630,7 +1628,7 @@ use std::io::File;
 use test::Bencher;
 
 pub fn do_typecheck(input: &str) -> Module<Name> {
-    do_typecheck_with(input, [])
+    do_typecheck_with(input, &[])
 }
 pub fn do_typecheck_with(input: &str, types: &[&DataTypes]) -> Module<Name> {
     let mut parser = ::parser::Parser::new(input.chars());
@@ -1684,7 +1682,7 @@ fn typecheck_let() {
 
     //let test x = add x in test
     let unary_bind = lambda("x", apply(apply(identifier("primIntAdd"), identifier("x")), number(1)));
-    let e = let_(vec![Binding { arguments: vec![], name: intern("test"), matches: Simple(unary_bind), typ: Default::default() , where: None }], identifier("test"));
+    let e = let_(vec![Binding { arguments: vec![], name: intern("test"), matches: Match::Simple(unary_bind), typ: Default::default() , where_bindings: None }], identifier("test"));
     let mut expr = rename_expr(e);
     env.typecheck_expr(&mut expr);
 
@@ -1746,16 +1744,15 @@ fn typecheck_tuple() {
 }
 
 #[test]
-fn typecheck_module() {
+fn typecheck_module_() {
 
     let file =
 r"data Bool = True | False
 test x = True";
     let module = do_typecheck(file);
 
     let typ = function_type_(Type::new_var(intern("a")), bool_type());
-    let bind_type0 = module.bindings[0].typ.value;
-    assert_eq!(bind_type0, typ);
+    assert_eq!(module.bindings[0].typ.value, typ);
 }
 
 
@@ -1954,8 +1951,7 @@ r"test x = primDoubleAdd 0 x";
     let module = do_typecheck(file);
 
     let typ = function_type_(double_type(), double_type());
-    let bind_type0 = module.bindings[0].typ.value;
-    assert_eq!(bind_type0, typ);
+    assert_eq!(module.bindings[0].typ.value, typ);
 }
 
 #[test]
@@ -2000,7 +1996,7 @@ main = fmap add2 3");
 #[test]
 fn typecheck_prelude() {
     let path = &Path::new("Prelude.hs");
-    let contents = File::open(path).read_to_str().unwrap();
+    let contents = File::open(path).read_to_string().unwrap();
     let module = do_typecheck(contents.as_slice());
 
     let id = module.bindings.iter().find(|bind| bind.name.as_slice() == "id");
@@ -2014,15 +2010,15 @@ fn typecheck_import() {
 
     let prelude = {
         let path = &Path::new("Prelude.hs");
-        let contents = File::open(path).read_to_str().unwrap();
+        let contents = File::open(path).read_to_string().unwrap();
         do_typecheck(contents.as_slice())
     };
 
     let file = 
 r"
 test1 = map not [True, False]
 test2 = id (primIntAdd 2 0)";
-    let module = do_typecheck_with(file, [&prelude as &DataTypes]);
+    let module = do_typecheck_with(file, &[&prelude as &DataTypes]);
 
     assert_eq!(module.bindings[0].name.as_slice(), "test1");
     assert_eq!(module.bindings[0].typ.value, list_type(bool_type()));
@@ -2053,7 +2049,7 @@ fn do_expr_simple() {
 
     let prelude = {
         let path = &Path::new("Prelude.hs");
-        let contents = File::open(path).read_to_str().unwrap();
+        let contents = File::open(path).read_to_string().unwrap();
         do_typecheck(contents.as_slice())
     };
 
@@ -2065,7 +2061,7 @@ test x = do
         t = [2::Int]
     putStrLn y
 ";
-    let module = do_typecheck_with(file, [&prelude as &DataTypes]);
+    let module = do_typecheck_with(file, &[&prelude as &DataTypes]);
 
     assert_eq!(module.bindings[0].typ.value, function_type_(list_type(char_type()), io(unit())));
 }
@@ -2075,7 +2071,7 @@ fn do_expr_pattern() {
 
     let prelude = {
         let path = &Path::new("Prelude.hs");
-        let contents = File::open(path).read_to_str().unwrap();
+        let contents = File::open(path).read_to_string().unwrap();
         do_typecheck(contents.as_slice())
     };
 
@@ -2085,7 +2081,7 @@ test x = do
     y:ys <- x
     return y
 ";
-    let module = do_typecheck_with(file, [&prelude as &DataTypes]);
+    let module = do_typecheck_with(file, &[&prelude as &DataTypes]);
 
     let var = Type::new_var(intern("a"));
     let t = function_type_(Type::new_var_args(intern("c"), vec![list_type(var.clone())]), Type::new_var_args(intern("c"), vec![var.clone()]));
@@ -2193,7 +2189,7 @@ fn do_expr_wrong_monad() {
 
     let prelude = {
         let path = &Path::new("Prelude.hs");
-        let contents = File::open(path).read_to_str().unwrap();
+        let contents = File::open(path).read_to_string().unwrap();
         do_typecheck(contents.as_slice())
     };
 
@@ -2202,7 +2198,7 @@ r"
 test x = do
     putStrLn x
     reverse [primIntAdd 0 0, 1, 2]";
-    do_typecheck_with(file, [&prelude as &DataTypes]);
+    do_typecheck_with(file, &[&prelude as &DataTypes]);
 }
 
 #[test]
@@ -2285,7 +2281,7 @@ test = IntPair (True, False)
 #[bench]
 fn bench_prelude(b: &mut Bencher) {
     let path = &Path::new("Prelude.hs");
-    let contents = File::open(path).read_to_str().unwrap();
+    let contents = File::open(path).read_to_string().unwrap();
     let mut parser = Parser::new(contents.as_slice().chars());
     let module = rename_module(parser.module());