Updated tests and fixed grammar

mist-test/src/common/decl_test.mist

@@ -1,44 +1,44 @@
 pub module decl_test;
 
-pub fn void test_let_basic() {
+pub void test_let_basic() {
     let x = 42;
     assert_eq!(x, 42);
 }
 
-pub fn void test_let_typed() {
-    let x i32 = 42;
+pub void test_let_typed() {
+    i32 x = 42;
     assert_eq!(x, 42);
 
-    let s *str = "hello";
+    str& s = "hello";
     assert_eq!(s, "hello");
 
-    let b bool = true;
+    bool b = true;
     assert_eq!(b, true);
 
-    let f f64 = 3.14;
+    f64 f = 3.14;
     assert_eq!(f, 3.14);
 }
 
-pub fn void test_let_mut() {
+pub void test_let_mut() {
     let mut _x = 42;
     _x = 100;
     assert_eq!(_x, 100);
 }
 
-pub fn void test_let_tuple_destructure() {
+pub void test_let_tuple_destructure() {
     let (a, b) = (10, "hello");
     assert_eq!(a, 10);
     assert_eq!(b, "hello");
 }
 
-pub fn void test_let_nested_tuple() {
+pub void test_let_nested_tuple() {
     let (a, (b, c)) = (1, (2, 3));
     assert_eq!(a, 1);
     assert_eq!(b, 2);
     assert_eq!(c, 3);
 }
 
-pub fn void test_let_pattern_irrefutable() {
+pub void test_let_pattern_irrefutable() {
     let x = 5;
     let (y, z) = (1, 2);
     assert_eq!(x, 5);
@@ -46,30 +46,30 @@ pub fn void test_let_pattern_irrefutable() {
     assert_eq!(z, 2);
 }
 
-pub fn void test_multiple_decls() {
+pub void test_multiple_decls() {
     let a = 1;
     let b = 2;
     let c = 3;
     assert_eq!(a + b + c, 6);
 }
 
-pub fn void test_let_with_type_and_init() {
-    let x f64 = 10.0;
+pub void test_let_with_type_and_init() {
+    f64 x = 10.0;
     assert_eq!(x, 10.0);
 }
 
-pub fn void test_string_literal() {
+pub void test_string_literal() {
     let s = "hello, world!";
     assert_eq!(s.len(), 13);
 }
 
-pub fn void test_let_bool() {
+pub void test_let_bool() {
     let t = true;
     let f = false;
     assert_eq!(t, !f);
 }
 
-pub fn void run_tests() {
+pub void run_tests() {
     test_let_basic();
     test_let_typed();
     test_let_mut();

mist-test/src/common/expr_test.mist

@@ -1,6 +1,6 @@
 pub module expr_test;
 
-pub fn void test_literals() {
+pub void test_literals() {
     assert_eq!(42, 42);
     assert_eq!(3.14, 3.14);
     assert_eq!(true, true);
@@ -8,28 +8,28 @@ pub fn void test_literals() {
     assert_eq!("hello", "hello");
 }
 
-pub fn void test_tuples() {
+pub void test_tuples() {
     let t = (1, true, "three");
     assert_eq!(t.0, 1);
     assert_eq!(t.1, true);
     assert_eq!(t.2, "three");
 }
 
-pub fn void test_arrays() {
+pub void test_arrays() {
     let arr = [1, 2, 3];
     assert_eq!(arr[0], 1);
     assert_eq!(arr[1], 2);
     assert_eq!(arr[2], 3);
 }
 
-pub fn void test_array_repeat() {
+pub void test_array_repeat() {
     let arr = [0; 5];
     assert_eq!(arr[0], 0);
     assert_eq!(arr[4], 0);
     assert_eq!(arr.len(), 5);
 }
 
-pub fn void test_binary_arith() {
+pub void test_binary_arith() {
     assert_eq!(10 + 5, 15);
     assert_eq!(10 - 5, 5);
     assert_eq!(10 * 5, 50);
@@ -37,7 +37,7 @@ pub fn void test_binary_arith() {
     assert_eq!(10 % 3, 1);
 }
 
-pub fn void test_binary_cmp() {
+pub void test_binary_cmp() {
     assert_eq!(5 < 10, true);
     assert_eq!(10 <= 10, true);
     assert_eq!(10 > 5, true);
@@ -46,14 +46,14 @@ pub fn void test_binary_cmp() {
     assert_eq!(5 != 10, true);
 }
 
-pub fn void test_binary_logic() {
+pub void test_binary_logic() {
     assert_eq!(true && true, true);
     assert_eq!(true && false, false);
     assert_eq!(true || false, true);
     assert_eq!(false || false, false);
 }
 
-pub fn void test_binary_bit() {
+pub void test_binary_bit() {
     assert_eq!(5 & 3, 1);
     assert_eq!(5 | 3, 7);
     assert_eq!(5 ^ 3, 6);
@@ -61,20 +61,20 @@ pub fn void test_binary_bit() {
     assert_eq!(4 >> 1, 2);
 }
 
-pub fn void test_prefix() {
+pub void test_prefix() {
     let x = 42;
     assert_eq!(-x, -42);
     assert_eq!(!true, false);
     assert_eq!(!false, true);
 }
 
-pub fn void test_ref_deref() {
+pub void test_ref_deref() {
     let x = 42;
     let r = &x;
     assert_eq!(*r, 42);
 }
 
-pub fn void test_postfix_inc_dec() {
+pub void test_postfix_inc_dec() {
     let mut x = 5;
     x++;
     assert_eq!(x, 6);
@@ -82,17 +82,17 @@ pub fn void test_postfix_inc_dec() {
     assert_eq!(x, 5);
 }
 
-pub fn void test_as_cast() {
+pub void test_as_cast() {
     let x = 42;
     assert_eq!(x as f64, 42.0);
 }
 
-pub fn void test_closure() {
+pub void test_closure() {
     let add = fn(a, b) -> a + b;
     assert_eq!(add(2, 3), 5);
 }
 
-pub fn void test_block_expr() {
+pub void test_block_expr() {
     let x = {
         let y = 10;
         y + 5
@@ -100,7 +100,7 @@ pub fn void test_block_expr() {
     assert_eq!(x, 15);
 }
 
-pub fn void test_if_expr() {
+pub void test_if_expr() {
     let x = if true { 1 } else { 2 };
     assert_eq!(x, 1);
 
@@ -108,7 +108,7 @@ pub fn void test_if_expr() {
     assert_eq!(y, 2);
 }
 
-pub fn void test_range_expr() {
+pub void test_range_expr() {
     let r = 0..5;
     let mut count = 0;
     for i in r {
@@ -117,7 +117,7 @@ pub fn void test_range_expr() {
     assert_eq!(count, 5);
 }
 
-pub fn void test_binary_assign() {
+pub void test_binary_assign() {
     let mut x = 10;
     x += 5;
     assert_eq!(x, 15);
@@ -131,7 +131,7 @@ pub fn void test_binary_assign() {
     assert_eq!(x, 2);
 }
 
-pub fn void run_tests() {
+pub void run_tests() {
     test_literals();
     test_tuples();
     test_arrays();

mist-test/src/common/package.mist

@@ -1,3 +1,3 @@
 pub module common;
 
-pub fn void test_package() {}
+pub void test_package() {}

mist-test/src/common/statement_test.mist

@@ -1,23 +1,23 @@
 pub module statement_test;
 
-pub fn void test_var_decl() {
+pub void test_var_decl() {
     let x = 42;
     assert_eq!(x, 42);
 
-    let y i32 = 10;
+    i32 y = 10;
     assert_eq!(y, 10);
 
-    let name *str = "mist";
+    str& name = "mist";
     assert_eq!(name, "mist");
 }
 
-pub fn void test_var_decl_with_init() {
+pub void test_var_decl_with_init() {
     let mut x = 0;
     x = 5;
     assert_eq!(x, 5);
 }
 
-pub fn void test_if_statement() {
+pub void test_if_statement() {
     let mut x = 0;
 
     if true {
@@ -33,7 +33,7 @@ pub fn void test_if_statement() {
     assert_eq!(x, 3);
 }
 
-pub fn void test_if_else_if() {
+pub void test_if_else_if() {
     let mut x = 0;
 
     if x == 1 {
@@ -46,7 +46,7 @@ pub fn void test_if_else_if() {
     assert_eq!(x, 20);
 }
 
-pub fn void test_while_loop() {
+pub void test_while_loop() {
     let mut count = 0;
 
     while count < 5 {
@@ -55,7 +55,7 @@ pub fn void test_while_loop() {
     assert_eq!(count, 5);
 }
 
-pub fn void test_for_loop() {
+pub void test_for_loop() {
     let mut sum = 0;
 
     for i in 0..4 {
@@ -64,7 +64,7 @@ pub fn void test_for_loop() {
     assert_eq!(sum, 6);
 }
 
-pub fn void test_loop_stmt() {
+pub void test_loop_stmt() {
     let mut count = 0;
 
     loop {
@@ -76,7 +76,7 @@ pub fn void test_loop_stmt() {
     assert_eq!(count, 3);
 }
 
-pub fn void test_break_continue() {
+pub void test_break_continue() {
     let mut sum = 0;
 
     for i in 0..10 {
@@ -91,11 +91,11 @@ pub fn void test_break_continue() {
     assert_eq!(sum, 1 + 3 + 5);
 }
 
-pub fn i32 test_return() {
+pub i32 test_return() {
     return 42;
 }
 
-pub fn void test_block_scope() {
+pub void test_block_scope() {
     let x = {
         let inner = 10;
         inner + 5
@@ -103,7 +103,7 @@ pub fn void test_block_scope() {
     assert_eq!(x, 15);
 }
 
-pub fn void test_match_literal() {
+pub void test_match_literal() {
     let x = 2;
     let result;
 
@@ -116,9 +116,9 @@ pub fn void test_match_literal() {
     assert_eq!(result, 20);
 }
 
-pub fn void test_match_or_pattern() {
+pub void test_match_or_pattern() {
     let x = 1;
-    let result i32;
+    i32 result;
 
     match x {
         1 | 2 => { result = 100; }
@@ -128,7 +128,7 @@ pub fn void test_match_or_pattern() {
     assert_eq!(result, 100);
 }
 
-pub fn void test_match_default() {
+pub void test_match_default() {
     let x = 99;
     let result;
 
@@ -139,7 +139,7 @@ pub fn void test_match_default() {
     assert_eq!(result, 99);
 }
 
-pub fn void test_for_with_pattern_destructure() {
+pub void test_for_with_pattern_destructure() {
     let pairs = [(1, "a"), (2, "b")];
     let mut keys = 0;
 
@@ -149,7 +149,7 @@ pub fn void test_for_with_pattern_destructure() {
     assert_eq!(keys, 3);
 }
 
-pub fn void run_tests() {
+pub void run_tests() {
     test_var_decl();
     test_var_decl_with_init();
     test_if_statement();

mist-test/src/common/types_test.mist

@@ -1,58 +1,58 @@
 pub module types_test;
 
-pub fn void test_integer_type() {
-    let x i32 = 42;
+pub void test_integer_type() {
+    i32 x = 42;
     assert_eq!(x, 42);
 }
 
-pub fn void test_float_type() {
-    let x f64 = 3.14;
+pub void test_float_type() {
+    f64 x = 3.14;
     assert_eq!(x, 3.14);
 }
 
-pub fn void test_bool_type() {
-    let x bool = true;
+pub void test_bool_type() {
+    bool x = true;
     assert_eq!(x, true);
 
-    let y bool = false;
+    bool y = false;
     assert_eq!(y, false);
 }
 
-pub fn void test_string_type() {
-    let s *str = "hello";
+pub void test_string_type() {
+    str& s = "hello";
     assert_eq!(s, "hello");
 }
 
-pub fn void test_tuple_type() {
-    let t (i32, *str) = (42, "answer");
+pub void test_tuple_type() {
+    (i32, str&) t = (42, "answer");
     assert_eq!(t.0, 42);
     assert_eq!(t.1, "answer");
 }
 
-pub fn void test_ref_type() {
-    let x i32 = 42;
-    let r *i32 = &x;
+pub void test_ref_type() {
+    i32 x = 42;
+    i32& r = &x;
     assert_eq!(*r, 42);
 }
 
-pub fn void test_mut_ref_type() {
+pub void test_mut_ref_type() {
     let mut x = 42;
-    let r *mut i32 = &mut x;
+    i32 mut& r = &mut x;
     *r = 100;
     assert_eq!(x, 100);
 }
 
-pub fn void test_void_type() {}
+pub void test_void_type() {}
 
-fn i32 add(a i32, b i32) {
+i32 add(i32 a, i32 b) {
     a + b
 }
 
-pub fn void test_fn_return_type() {
+pub void test_fn_return_type() {
     assert_eq!(add(3, 4), 7);
 }
 
-pub fn void run_tests() {
+pub void run_tests() {
     test_integer_type();
     test_float_type();
     test_bool_type();