Testing

Author: lazear

crates/sml-core/src/pretty_print/core.rs

@@ -156,14 +156,13 @@ impl<'a> Type<'a> {
             }
             Type::Record(fields) => {
                 if let Symbol::Tuple(_) = fields[0].label {
-                    pp.text("(");
                     for (idx, row) in fields.iter().enumerate() {
                         row.data.print_rename(pp, map);
                         if idx != fields.rows.len() - 1 {
-                            pp.text(", ");
+                            pp.text(" * ");
                         }
                     }
-                    pp.text(")")
+                    pp
                 } else {
                     pp.text("{");
                     for (idx, row) in fields.iter().enumerate() {
@@ -222,6 +221,9 @@ impl<'a> Print for Decl<'a> {
                             vec![lam.ty, lam.body.ty],
                         ))
                         .text(" = ")
+                        .text("fn ")
+                        .print(&lam.arg)
+                        .text(" => ")
                         .print(&lam.body);
                 }
                 pp

tests/match_compile/merge.sml

@@ -1,23 +1,24 @@
-(* test pattern matching
+(* test pattern match compilation to decision trees
+
 -- args: --vv
 -- expected stdout:
--- val merge: 'a list -> 'a list -> 'a list = fn b => 
+-- val merge: 'a list -> 'a list -> 'a list = fn a => fn b => 
 --   let
---     val e: 'a list -> 'a list = 
+--     val e: 'a list -> 'a list = fn d => 
 --       let
 --         val xs: 'a list = d
 --       in 
 --         xs
 --       end
---     val g: 'a list -> 'a list = 
+--     val g: 'a list -> 'a list = fn f => 
 --       let
 --         val ys: 'a list = f
 --       in 
 --         ys
 --       end
---     val i: ('a, 'a list, 'a, 'a list) -> 'a list = 
+--     val i: 'a * 'a list * 'a * 'a list -> 'a list = fn h => 
 --       let
---         val (x, xs, y, ys): ('a, 'a list, 'a, 'a list) = h
+--         val (x, xs, y, ys): 'a * 'a list * 'a * 'a list = h
 --       in 
 --         :: (x, :: (y, merge xs ys))
 --       end
@@ -30,19 +31,20 @@
 --              | _ => g b
 --          | :: l => 
 --              let
---                val (m, n): ('a, 'a list) = l
+--                val (m, n): 'a * 'a list = l
 --              in 
 --                
 --                  case b
 --                    of nil => e a
 --                     | :: p => 
 --                         let
---                           val (q, r): ('a, 'a list) = p
+--                           val (q, r): 'a * 'a list = p
 --                         in 
 --                           i (m, n, q, r)
 --                         end
 --              end
 --   end
+
 *)
 
 fun merge xs [] = xs 

tests/parser/empty.sml

@@ -1,8 +1,10 @@
 (* parser throws an error on empty file, or no declaration
+
 -- expected stdout:
 -- 0 warnings, 1 errors 
 
 -- expected stderr:
 -- Error
 -- 1,1 expected declaration, but encountered EOF
+
 *)

tests/parser/toplevel.sml

@@ -1,4 +1,5 @@
 (* Test that the parser will issue a warning on top-level expression 
+
 -- args: --v
 -- expected stdout:
 -- val _: int
@@ -7,7 +8,8 @@
 
 -- expected stderr:
 -- Warn
--- 13,1 top level expressions are not supported! emitting `val _ = ...`
+-- 15,1 top level expressions are not supported! emitting `val _ = ...`
+
 *)
 
 if true then 1 else 0

tests/typecheck/cantunify.sml

@@ -0,0 +1,22 @@
+(* Check that type unification will fail in obvious cases
+
+-- args: --v
+-- expected stdout:
+-- val +: int * int -> int
+-- val add: int -> int -> int
+-- val _: int
+-- 
+-- 0 warnings, 1 errors
+
+-- expected stderr:
+-- Error
+-- 22,9 Can't unify type constructors interned symbol and interned symbol
+
+*)
+
+val + = primitive "Int.add" : int * int -> int 
+infix 3 +
+
+fun add x y = x + y
+
+val _ = add 3 true

tests/typecheck/cyclic.sml

@@ -1,13 +1,15 @@
 (* create a cyclic type 
+
 -- expected stderr:
 -- Error
--- 16,21 Cyclic type detected: 'i#1 interned symbol
+-- 18,21 Cyclic type detected: 'i#1 interned symbol
 -- 
 -- Error
--- 16,5 Cyclic type detected: 'i#1 interned symbol
+-- 18,5 Cyclic type detected: 'i#1 interned symbol
 
 -- expected stdout:
 -- 0 warnings, 2 errors
+
 *) 
 
 

tests/typecheck/escape.sml

@@ -0,0 +1,17 @@
+(* catch escaping datatypes
+
+-- expected stdout:
+-- 0 warnings, 1 errors
+
+-- expected stderr:
+-- Error
+-- 16,5 type interned symbol escapes inner scope!
+
+*)
+
+val _ = 
+  let
+    datatype t = T of int
+  in
+    T 10
+  end

tests/typecheck/exception.sml

@@ -0,0 +1,15 @@
+(* check elaboration of exceptions 
+
+-- args: --v
+-- expected stdout:
+-- val try: int -> int
+-- val x: int
+
+*)
+
+exception EX of int;
+
+fun try 0 = raise (EX 0)
+  | try n = n
+
+val x = try 1 handle EX x => x;

tests/typecheck/records.sml

@@ -1,9 +1,11 @@
 (* record types are sorted in unspecified, but fixed order
+
 -- args: --v
 -- expected stdout:
 -- val x: {a: int, b: int, c: bool}
 -- val y: {a: int, b: int, c: bool}
--- val test: {a: int, b: int, c: bool} -> (int, int)
+-- val test: {a: int, b: int, c: bool} -> int * int
+
 *)
 
 val x = {a = 10, b = 12, c = true}