Fixed the last failing test, caused by a underflow in tuple_name

Author: Marwes

lambda_lift.rs

@@ -39,10 +39,7 @@ fn free_variables(&mut self, variables: &mut HashMap<Name, isize>, free_vars: &m
         Identifier(ref mut i) => {
             //If the identifier is a local, add it to the free variables
             if variables.get(&i.name).map(|x| *x > 0).unwrap_or(false) {
-                match variables.entry(i.name.clone()) {
-                    Entry::Vacant(entry) => { entry.insert(1); }
-                    Entry::Occupied(mut entry) => *entry.get_mut() += 1
-                }
+                free_vars.insert(i.name.clone(), i.clone());
             }
         }
         Apply(ref mut func, ref mut arg) => {

parser.rs

@@ -743,7 +743,8 @@ fn type_declaration(&mut self) -> TypeDeclaration {
 }
 
 fn constrained_type(&mut self) -> (Vec<Constraint>, Type) {
-    let mut maybeConstraints = if self.lexer.next().token == LPARENS {
+    debug!("Parse constrained type");
+    let mut maybe_constraints = if self.lexer.next().token == LPARENS {
         if self.lexer.peek().token == RPARENS {
             self.lexer.next();
             vec![]
@@ -758,27 +759,28 @@ fn constrained_type(&mut self) -> (Vec<Constraint>, Type) {
         self.lexer.backtrack();
         vec![self.parse_type()]
     };
-    let maybeContextArrow = self.lexer.next().token;
+    debug!("{:?}", maybe_constraints);
     //If there is => arrow we proceed to parse the type
-    let typ = if maybeContextArrow == CONTEXTARROW {
-        self.parse_type()
-    }
-    else if maybeContextArrow == ARROW {
-	    self.lexer.backtrack();
-        let mut args = Vec::new();
-        swap(&mut args, &mut maybeConstraints);
-        self.parse_return_type(make_tuple_type(args))
-    }
-    else {//If no => was found, translate the constraint list into a type
-	    self.lexer.backtrack();
-        let mut args = Vec::new();
-        swap(&mut args, &mut maybeConstraints);
-        make_tuple_type(args)
+    let typ = match self.lexer.next().token {
+        CONTEXTARROW => self.parse_type(),
+        ARROW => {
+            self.lexer.backtrack();
+            let mut args = Vec::new();
+            swap(&mut args, &mut maybe_constraints);
+            self.parse_return_type(make_tuple_type(args))
+        }
+        _ => {//If no => was found, translate the constraint list into a type
+            self.lexer.backtrack();
+            let mut args = Vec::new();
+            swap(&mut args, &mut maybe_constraints);
+            make_tuple_type(args)
+        }
     };
-	(make_constraints(maybeConstraints), typ)
+	(make_constraints(maybe_constraints), typ)
 }
 
 fn constructor_type(&mut self, arity : &mut isize, dataDef: &DataDefinition) -> Type {
+    debug!("Parse constructor type");
 	let token = self.lexer.next().token;
 	if token == NAME {
 		*arity += 1;

types.rs

@@ -142,8 +142,9 @@ impl <S: ::std::hash::Hasher + ::std::hash::Writer> ::std::hash::Hash<S> for Typ
 
 ///Constructs a string which holds the name of an n-tuple
 pub fn tuple_name(n: usize) -> String {
+    let commas = if n == 0 { 0 } else { n - 1 };
     Some('(').into_iter()
-        .chain(iter::repeat(',').take(n - 1))
+        .chain(iter::repeat(',').take(commas))
         .chain(Some(')').into_iter())
         .collect()
 }