all types are now expressions

See #22

1 files changed, 209 insertions, 209 deletions

diff --git a/test/run_tests.cpp b/test/run_tests.cpp
index 445433a863..04cf942c37 100644
--- a/test/run_tests.cpp
+++ b/test/run_tests.cpp
@@ -96,50 +96,50 @@ static TestCase *add_compile_fail_case(const char *case_name, const char *source
 
 static void add_compiling_test_cases(void) {
     add_simple_case("hello world with libc", R"SOURCE(
-        #link("c")
-        extern {
-            fn puts(s: &const u8) -> i32;
-        }
+#link("c")
+extern {
+    fn puts(s: &const u8) i32;
+}
 
-        export fn main(argc: i32, argv: &&u8, env: &&u8) -> i32 {
-            puts(c"Hello, world!");
-            return 0;
-        }
+export fn main(argc: i32, argv: &&u8, env: &&u8) i32 => {
+    puts(c"Hello, world!");
+    return 0;
+}
     )SOURCE", "Hello, world!\n");
 
     add_simple_case("function call", R"SOURCE(
-        use "std.zig";
-        use "syscall.zig";
+use "std.zig";
+use "syscall.zig";
 
-        fn empty_function_1() {}
-        fn empty_function_2() { return; }
+fn empty_function_1() => {}
+fn empty_function_2() => { return; }
 
-        pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
-            empty_function_1();
-            empty_function_2();
-            this_is_a_function();
-        }
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
+    empty_function_1();
+    empty_function_2();
+    this_is_a_function();
+}
 
-        fn this_is_a_function() -> unreachable {
-            print_str("OK\n");
-            exit(0);
-        }
+fn this_is_a_function() unreachable => {
+    print_str("OK\n");
+    exit(0);
+}
     )SOURCE", "OK\n");
 
     add_simple_case("comments", R"SOURCE(
-        use "std.zig";
-
-        /**
-         * multi line doc comment
-         */
-        fn another_function() {}
-
-        /// this is a documentation comment
-        /// doc comment line 2
-        pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
-            print_str(/* mid-line comment /* nested */ */ "OK\n");
-            return 0;
-        }
+use "std.zig";
+
+/**
+    * multi line doc comment
+    */
+fn another_function() => {}
+
+/// this is a documentation comment
+/// doc comment line 2
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
+    print_str(/* mid-line comment /* nested */ */ "OK\n");
+    return 0;
+}
     )SOURCE", "OK\n");
 
     {
@@ -147,13 +147,13 @@ static void add_compiling_test_cases(void) {
 use "std.zig";
 use "foo.zig";
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     private_function();
     print_str("OK 2\n");
     return 0;
 }
 
-fn private_function() {
+fn private_function() => {
     print_text();
 }
         )SOURCE", "OK 1\nOK 2\n");
@@ -163,11 +163,11 @@ use "std.zig";
 
 // purposefully conflicting function with main.zig
 // but it's private so it should be OK
-fn private_function() {
+fn private_function() => {
     print_str("OK 1\n");
 }
 
-pub fn print_text() {
+pub fn print_text() => {
     private_function();
 }
         )SOURCE");
@@ -178,7 +178,7 @@ pub fn print_text() {
 use "foo.zig";
 use "bar.zig";
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     foo_function();
     bar_function();
     return 0;
@@ -187,7 +187,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
 
         add_source_file(tc, "foo.zig", R"SOURCE(
 use "std.zig";
-pub fn foo_function() {
+pub fn foo_function() => {
     print_str("OK\n");
 }
         )SOURCE");
@@ -196,7 +196,7 @@ pub fn foo_function() {
 use "other.zig";
 use "std.zig";
 
-pub fn bar_function() {
+pub fn bar_function() => {
     if (foo_function()) {
         print_str("OK\n");
     }
@@ -204,7 +204,7 @@ pub fn bar_function() {
         )SOURCE");
 
         add_source_file(tc, "other.zig", R"SOURCE(
-pub fn foo_function() -> bool {
+pub fn foo_function() bool => {
     // this one conflicts with the one from foo
     return true;
 }
@@ -212,65 +212,65 @@ pub fn foo_function() -> bool {
     }
 
     add_simple_case("if statements", R"SOURCE(
-        use "std.zig";
+use "std.zig";
 
-        pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
-            if (1 != 0) {
-                print_str("1 is true\n");
-            } else {
-                print_str("1 is false\n");
-            }
-            if (0 != 0) {
-                print_str("0 is true\n");
-            } else if (1 - 1 != 0) {
-                print_str("1 - 1 is true\n");
-            }
-            if (!(0 != 0)) {
-                print_str("!0 is true\n");
-            }
-            return 0;
-        }
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
+    if (1 != 0) {
+        print_str("1 is true\n");
+    } else {
+        print_str("1 is false\n");
+    }
+    if (0 != 0) {
+        print_str("0 is true\n");
+    } else if (1 - 1 != 0) {
+        print_str("1 - 1 is true\n");
+    }
+    if (!(0 != 0)) {
+        print_str("!0 is true\n");
+    }
+    return 0;
+}
     )SOURCE", "1 is true\n!0 is true\n");
 
     add_simple_case("params", R"SOURCE(
-        use "std.zig";
+use "std.zig";
 
-        fn add(a: i32, b: i32) -> i32 {
-            a + b
-        }
+fn add(a: i32, b: i32) i32 => {
+    a + b
+}
 
-        pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
-            if (add(22, 11) == 33) {
-                print_str("pass\n");
-            }
-            return 0;
-        }
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
+    if (add(22, 11) == 33) {
+        print_str("pass\n");
+    }
+    return 0;
+}
     )SOURCE", "pass\n");
 
     add_simple_case("goto", R"SOURCE(
-        use "std.zig";
+use "std.zig";
 
-        fn loop(a : i32) {
-            if (a == 0) {
-                goto done;
-            }
-            print_str("loop\n");
-            loop(a - 1);
+fn loop(a : i32) => {
+    if (a == 0) {
+        goto done;
+    }
+    print_str("loop\n");
+    loop(a - 1);
 
-        done:
-            return;
-        }
+done:
+    return;
+}
 
-        pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
-            loop(3);
-            return 0;
-        }
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
+    loop(3);
+    return 0;
+}
     )SOURCE", "loop\nloop\nloop\n");
 
     add_simple_case("local variables", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     const a : i32 = 1;
     const b = 2 as i32;
     if (a + b == 3) {
@@ -283,7 +283,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
     add_simple_case("bool literals", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     if (true)   { print_str("OK 1\n"); }
     if (false)  { print_str("BAD 1\n"); }
     if (!true)  { print_str("BAD 2\n"); }
@@ -295,7 +295,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
     add_simple_case("separate block scopes", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     if (true) {
         const no_conflict : i32 = 5;
         if (no_conflict == 5) { print_str("OK 1\n"); }
@@ -313,12 +313,12 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
     add_simple_case("void parameters", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
-    void_fun(1, void, 2);
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
+    void_fun(1, void{}, 2);
     return 0;
 }
 
-fn void_fun(a : i32, b : void, c : i32) {
+fn void_fun(a : i32, b : void, c : i32) => {
     const v = b;
     const vv : void = if (a == 1) {v} else {};
     if (a + c == 3) { print_str("OK\n"); }
@@ -333,16 +333,16 @@ struct Foo {
     b : i32,
     c : void,
 }
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     const foo = Foo {
-        .a = void,
+        .a = void{},
         .b = 1,
-        .c = void,
+        .c = void{},
     };
     if (foo.b != 1) {
         print_str("BAD\n");
     }
-    if (#sizeof(Foo) != 4) {
+    if (@sizeof(Foo) != 4) {
         print_str("BAD\n");
     }
     print_str("OK\n");
@@ -354,7 +354,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
     add_simple_case("mutable local variables", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     var zero : i32 = 0;
     if (zero == 0) { print_str("zero\n"); }
 
@@ -374,7 +374,7 @@ done:
     add_simple_case("arrays", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     var array : [5]u32;
 
     var i : u32 = 0;
@@ -401,7 +401,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
 
     return 0;
 }
-fn get_array_len(a: []u32) -> usize {
+fn get_array_len(a: []u32) usize => {
     a.len
 }
     )SOURCE", "OK\n");
@@ -410,7 +410,7 @@ fn get_array_len(a: []u32) -> usize {
     add_simple_case("hello world without libc", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     print_str("Hello, world!\n");
     return 0;
 }
@@ -420,7 +420,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     add_simple_case("a + b + c", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     if (false || false || false) { print_str("BAD 1\n"); }
     if (true && true && false)   { print_str("BAD 2\n"); }
     if (1 | 2 | 4 != 7)          { print_str("BAD 3\n"); }
@@ -442,7 +442,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     add_simple_case("short circuit", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     if (true || { print_str("BAD 1\n"); false }) {
       print_str("OK 1\n");
     }
@@ -465,7 +465,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     add_simple_case("modify operators", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     var i : i32 = 0;
     i += 5;  if (i != 5)  { print_str("BAD +=\n"); }
     i -= 2;  if (i != 3)  { print_str("BAD -=\n"); }
@@ -488,10 +488,10 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     add_simple_case("number literals", R"SOURCE(
 #link("c")
 extern {
-    fn printf(__format: &const u8, ...) -> i32;
+    fn printf(__format: &const u8, ...) i32;
 }
 
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+export fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     printf(c"\n");
 
     printf(c"0: %llu\n",
@@ -617,9 +617,9 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     add_simple_case("structs", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     var foo : Foo;
-    @memset(&foo, 0, #sizeof(Foo));
+    @memset(&foo, 0, @sizeof(Foo));
     foo.a += 1;
     foo.b = foo.a == 1;
     test_foo(foo);
@@ -638,12 +638,12 @@ struct Foo {
     b : bool,
     c : f32,
 }
-fn test_foo(foo : Foo) {
+fn test_foo(foo : Foo) => {
     if (!foo.b) {
         print_str("BAD\n");
     }
 }
-fn test_mutation(foo : &Foo) {
+fn test_mutation(foo : &Foo) => {
     foo.c = 100;
 }
 struct Node {
@@ -654,7 +654,7 @@ struct Node {
 struct Val {
     x: i32,
 }
-fn test_point_to_self() {
+fn test_point_to_self() => {
     var root : Node;
     root.val.x = 1;
 
@@ -668,7 +668,7 @@ fn test_point_to_self() {
         print_str("BAD\n");
     }
 }
-fn test_byval_assign() {
+fn test_byval_assign() => {
     var foo1 : Foo;
     var foo2 : Foo;
 
@@ -680,7 +680,7 @@ fn test_byval_assign() {
 
     if (foo2.a != 1234) { print_str("BAD - byval assignment failed\n"); }
 }
-fn test_initializer() {
+fn test_initializer() => {
     const val = Val { .x = 42 };
     if (val.x != 42) { print_str("BAD\n"); }
 }
@@ -692,7 +692,7 @@ use "std.zig";
 const g1 : i32 = 1233 + 1;
 var g2 : i32 = 0;
 
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     if (g2 != 0) { print_str("BAD\n"); }
     g2 = g1;
     if (g2 != 1234) { print_str("BAD\n"); }
@@ -703,7 +703,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
 
     add_simple_case("while loop", R"SOURCE(
 use "std.zig";
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     var i : i32 = 0;
     while (i < 4) {
         print_str("loop\n");
@@ -711,7 +711,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     }
     return f();
 }
-fn f() -> i32 {
+fn f() i32 => {
     while (true) {
         return 0;
     }
@@ -720,7 +720,7 @@ fn f() -> i32 {
 
     add_simple_case("continue and break", R"SOURCE(
 use "std.zig";
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     var i : i32 = 0;
     while (true) {
         print_str("loop\n");
@@ -736,7 +736,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
 
     add_simple_case("maybe type", R"SOURCE(
 use "std.zig";
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     const x : ?bool = true;
 
     if (const y ?= x) {
@@ -759,7 +759,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
 
     const final_x : ?i32 = 13;
 
-    const num = final_x ?? unreachable;
+    const num = final_x ?? unreachable{};
 
     if (num != 13) {
         print_str("BAD\n");
@@ -771,26 +771,26 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
 
     add_simple_case("implicit cast after unreachable", R"SOURCE(
 use "std.zig";
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     const x = outer();
     if (x == 1234) {
         print_str("OK\n");
     }
     return 0;
 }
-fn inner() -> i32 { 1234 }
-fn outer() -> isize {
+fn inner() i32 => { 1234 }
+fn outer() isize => {
     return inner();
 }
     )SOURCE", "OK\n");
 
-    add_simple_case("#sizeof() and #typeof()", R"SOURCE(
+    add_simple_case("@sizeof() and @typeof()", R"SOURCE(
 use "std.zig";
 const x: u16 = 13;
-const z: #typeof(x) = 19;
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
-    const y: #typeof(x) = 120;
-    print_u64(#sizeof(#typeof(y)));
+const z: @typeof(x) = 19;
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
+    const y: @typeof(x) = 120;
+    print_u64(@sizeof(@typeof(y)));
     print_str("\n");
     return 0;
 }
@@ -800,11 +800,11 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
 use "std.zig";
 struct Rand {
     seed: u32,
-    pub fn get_seed(r: Rand) -> u32 {
+    pub fn get_seed(r: Rand) u32 => {
         r.seed
     }
 }
-pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
     const r = Rand {.seed = 1234};
     if (r.get_seed() != 1234) {
         print_str("BAD seed\n");
@@ -817,7 +817,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     add_simple_case("pointer dereferencing", R"SOURCE(
 use "std.zig";
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     var x = 3 as i32;
     const y = &x;
 
@@ -839,9 +839,9 @@ use "std.zig";
 
 const ARRAY_SIZE : u8 = 20;
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     var array : [ARRAY_SIZE]u8;
-    print_u64(#sizeof(#typeof(array)));
+    print_u64(@sizeof(@typeof(array)));
     print_str("\n");
     return 0;
 }
@@ -849,69 +849,69 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
 
     add_simple_case("#min_value() and #max_value()", R"SOURCE(
 use "std.zig";
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     print_str("max u8: ");
-    print_u64(#max_value(u8));
+    print_u64(@max_value(u8));
     print_str("\n");
 
     print_str("max u16: ");
-    print_u64(#max_value(u16));
+    print_u64(@max_value(u16));
     print_str("\n");
 
     print_str("max u32: ");
-    print_u64(#max_value(u32));
+    print_u64(@max_value(u32));
     print_str("\n");
 
     print_str("max u64: ");
-    print_u64(#max_value(u64));
+    print_u64(@max_value(u64));
     print_str("\n");
 
     print_str("max i8: ");
-    print_i64(#max_value(i8));
+    print_i64(@max_value(i8));
     print_str("\n");
 
     print_str("max i16: ");
-    print_i64(#max_value(i16));
+    print_i64(@max_value(i16));
     print_str("\n");
 
     print_str("max i32: ");
-    print_i64(#max_value(i32));
+    print_i64(@max_value(i32));
     print_str("\n");
 
     print_str("max i64: ");
-    print_i64(#max_value(i64));
+    print_i64(@max_value(i64));
     print_str("\n");
 
     print_str("min u8: ");
-    print_u64(#min_value(u8));
+    print_u64(@min_value(u8));
     print_str("\n");
 
     print_str("min u16: ");
-    print_u64(#min_value(u16));
+    print_u64(@min_value(u16));
     print_str("\n");
 
     print_str("min u32: ");
-    print_u64(#min_value(u32));
+    print_u64(@min_value(u32));
     print_str("\n");
 
     print_str("min u64: ");
-    print_u64(#min_value(u64));
+    print_u64(@min_value(u64));
     print_str("\n");
 
     print_str("min i8: ");
-    print_i64(#min_value(i8));
+    print_i64(@min_value(i8));
     print_str("\n");
 
     print_str("min i16: ");
-    print_i64(#min_value(i16));
+    print_i64(@min_value(i16));
     print_str("\n");
 
     print_str("min i32: ");
-    print_i64(#min_value(i32));
+    print_i64(@min_value(i32));
     print_str("\n");
 
     print_str("min i64: ");
-    print_i64(#min_value(i64));
+    print_i64(@min_value(i64));
     print_str("\n");
 
     return 0;
@@ -937,7 +937,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
 
     add_simple_case("slicing", R"SOURCE(
 use "std.zig";
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     var array : [20]i32;
 
     array[5] = 1234;
@@ -965,13 +965,13 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
 
     add_simple_case("else if expression", R"SOURCE(
 use "std.zig";
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     if (f(1) == 1) {
         print_str("OK\n");
     }
     return 0;
 }
-fn f(c: u8) -> u8 {
+fn f(c: u8) u8 => {
     if (c == 0) {
         0
     } else if (c == 1) {
@@ -984,7 +984,7 @@ fn f(c: u8) -> u8 {
 
     add_simple_case("overflow intrinsics", R"SOURCE(
 use "std.zig";
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     var result: u8;
     if (!@add_with_overflow_u8(250, 100, &result)) {
         print_str("BAD\n");
@@ -1002,7 +1002,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
 
     add_simple_case("memcpy and memset intrinsics", R"SOURCE(
 use "std.zig";
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     var foo : [20]u8;
     var bar : [20]u8;
 
@@ -1020,13 +1020,13 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
 
     add_simple_case("order-independent declarations", R"SOURCE(
 use "std.zig";
-const z : #typeof(stdin_fileno) = 0;
-const x : #typeof(y) = 1234;
+const z : @typeof(stdin_fileno) = 0;
+const x : @typeof(y) = 1234;
 const y : u16 = 5678;
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     print_ok(x)
 }
-fn print_ok(val: #typeof(x)) -> #typeof(foo) {
+fn print_ok(val: @typeof(x)) @typeof(foo) => {
     print_str("OK\n");
     return 0;
 }
@@ -1054,7 +1054,7 @@ enum Bar {
     D,
 }
 
-pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
+pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
     const foo1 = Foo.One(13);
     const foo2 = Foo.Two(Point { .x = 1234, .y = 5678, });
     const bar = Bar.B;
@@ -1063,18 +1063,18 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
         print_str("BAD\n");
     }
 
-    if (#value_count(Foo) != 3) {
+    if (@value_count(Foo) != 3) {
         print_str("BAD\n");
     }
 
-    if (#value_count(Bar) != 4) {
+    if (@value_count(Bar) != 4) {
         print_str("BAD\n");
     }
 
-    if (#sizeof(Foo) != 17) {
+    if (@sizeof(Foo) != 17) {
         print_str("BAD\n");
     }
-    if (#sizeof(Bar) != 1) {
+    if (@sizeof(Bar) != 1) {
         print_str("BAD\n");
     }
 
@@ -1090,8 +1090,8 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
 
 static void add_compile_failure_test_cases(void) {
     add_compile_fail_case("multiple function definitions", R"SOURCE(
-fn a() {}
-fn a() {}
+fn a() => {}
+fn a() => {}
     )SOURCE", 1, ".tmp_source.zig:3:1: error: redefinition of 'a'");
 
     add_compile_fail_case("bad directive", R"SOURCE(
@@ -1100,46 +1100,46 @@ extern {
     fn b();
 }
 #bogus2("")
-fn a() {}
+fn a() => {}
     )SOURCE", 2, ".tmp_source.zig:2:1: error: invalid directive: 'bogus1'",
                  ".tmp_source.zig:6:1: error: invalid directive: 'bogus2'");
 
     add_compile_fail_case("unreachable with return", R"SOURCE(
-fn a() -> unreachable {return;}
+fn a() unreachable => {return;}
     )SOURCE", 1, ".tmp_source.zig:2:24: error: expected type 'unreachable', got 'void'");
 
     add_compile_fail_case("control reaches end of non-void function", R"SOURCE(
-fn a() -> i32 {}
+fn a() i32 => {}
     )SOURCE", 1, ".tmp_source.zig:2:15: error: expected type 'i32', got 'void'");
 
     add_compile_fail_case("undefined function call", R"SOURCE(
-fn a() {
+fn a() => {
     b();
 }
     )SOURCE", 1, ".tmp_source.zig:3:5: error: undefined function: 'b'");
 
     add_compile_fail_case("wrong number of arguments", R"SOURCE(
-fn a() {
+fn a() => {
     b(1);
 }
-fn b(a: i32, b: i32, c: i32) { }
+fn b(a: i32, b: i32, c: i32) => { }
     )SOURCE", 1, ".tmp_source.zig:3:6: error: expected 3 arguments, got 1");
 
     add_compile_fail_case("invalid type", R"SOURCE(
-fn a() -> bogus {}
-    )SOURCE", 1, ".tmp_source.zig:2:11: error: invalid type name: 'bogus'");
+fn a() bogus => {}
+    )SOURCE", 1, ".tmp_source.zig:2:8: error: use of undeclared identifier 'bogus'");
 
     add_compile_fail_case("pointer to unreachable", R"SOURCE(
-fn a() -> &unreachable {}
-    )SOURCE", 1, ".tmp_source.zig:2:11: error: pointer to unreachable not allowed");
+fn a() &unreachable => {}
+    )SOURCE", 1, ".tmp_source.zig:2:8: error: pointer to unreachable not allowed");
 
     add_compile_fail_case("unreachable code", R"SOURCE(
-fn a() {
+fn a() => {
     return;
     b();
 }
 
-fn b() {}
+fn b() => {}
     )SOURCE", 1, ".tmp_source.zig:4:5: error: unreachable code");
 
     add_compile_fail_case("bad version string", R"SOURCE(
@@ -1152,7 +1152,7 @@ use "bogus-does-not-exist.zig";
     )SOURCE", 1, ".tmp_source.zig:2:1: error: unable to find 'bogus-does-not-exist.zig'");
 
     add_compile_fail_case("undeclared identifier", R"SOURCE(
-fn a() {
+fn a() => {
     b +
     c
 }
@@ -1161,99 +1161,99 @@ fn a() {
             ".tmp_source.zig:4:5: error: use of undeclared identifier 'c'");
 
     add_compile_fail_case("goto cause unreachable code", R"SOURCE(
-fn a() {
+fn a() => {
     goto done;
     b();
 done:
     return;
 }
-fn b() {}
+fn b() => {}
     )SOURCE", 1, ".tmp_source.zig:4:5: error: unreachable code");
 
     add_compile_fail_case("parameter redeclaration", R"SOURCE(
-fn f(a : i32, a : i32) {
+fn f(a : i32, a : i32) => {
 }
     )SOURCE", 1, ".tmp_source.zig:2:1: error: redeclaration of parameter 'a'");
 
     add_compile_fail_case("local variable redeclaration", R"SOURCE(
-fn f() {
+fn f() => {
     const a : i32 = 0;
     const a = 0;
 }
     )SOURCE", 1, ".tmp_source.zig:4:5: error: redeclaration of variable 'a'");
 
     add_compile_fail_case("local variable redeclares parameter", R"SOURCE(
-fn f(a : i32) {
+fn f(a : i32) => {
     const a = 0;
 }
     )SOURCE", 1, ".tmp_source.zig:3:5: error: redeclaration of variable 'a'");
 
     add_compile_fail_case("variable has wrong type", R"SOURCE(
-fn f() -> i32 {
+fn f() i32 => {
     const a = c"a";
     a
 }
     )SOURCE", 1, ".tmp_source.zig:2:15: error: expected type 'i32', got '&const u8'");
 
     add_compile_fail_case("if condition is bool, not int", R"SOURCE(
-fn f() {
+fn f() => {
     if (0) {}
 }
     )SOURCE", 1, ".tmp_source.zig:3:9: error: expected type 'bool', got '(u8 literal)'");
 
     add_compile_fail_case("assign unreachable", R"SOURCE(
-fn f() {
+fn f() => {
     const a = return;
 }
     )SOURCE", 1, ".tmp_source.zig:3:5: error: variable initialization is unreachable");
 
     add_compile_fail_case("unreachable variable", R"SOURCE(
-fn f() {
+fn f() => {
     const a : unreachable = return;
 }
     )SOURCE", 1, ".tmp_source.zig:3:15: error: variable of type 'unreachable' not allowed");
 
     add_compile_fail_case("unreachable parameter", R"SOURCE(
-fn f(a : unreachable) {}
+fn f(a : unreachable) => {}
     )SOURCE", 1, ".tmp_source.zig:2:10: error: parameter of type 'unreachable' not allowed");
 
     add_compile_fail_case("exporting a void parameter", R"SOURCE(
-export fn f(a : void) {}
+export fn f(a : void) => {}
     )SOURCE", 1, ".tmp_source.zig:2:17: error: parameter of type 'void' not allowed on exported functions");
 
     add_compile_fail_case("unused label", R"SOURCE(
-fn f() {
+fn f() => {
 a_label:
 }
     )SOURCE", 1, ".tmp_source.zig:3:1: error: label 'a_label' defined but not used");
 
     add_compile_fail_case("bad assignment target", R"SOURCE(
-fn f() {
+fn f() => {
     3 = 3;
 }
     )SOURCE", 1, ".tmp_source.zig:3:5: error: invalid assignment target");
 
     add_compile_fail_case("assign to constant variable", R"SOURCE(
-fn f() {
+fn f() => {
     const a = 3;
     a = 4;
 }
     )SOURCE", 1, ".tmp_source.zig:4:5: error: cannot assign to constant");
 
     add_compile_fail_case("use of undeclared identifier", R"SOURCE(
-fn f() {
+fn f() => {
     b = 3;
 }
     )SOURCE", 1, ".tmp_source.zig:3:5: error: use of undeclared identifier 'b'");
 
     add_compile_fail_case("const is a statement, not an expression", R"SOURCE(
-fn f() {
+fn f() => {
     (const a = 0);
 }
     )SOURCE", 1, ".tmp_source.zig:3:6: error: invalid token: 'const'");
 
     add_compile_fail_case("array access errors", R"SOURCE(
-fn f() {
+fn f() => {
     var bad : bool;
     i[i] = i[i];
     bad[bad] = bad[bad];
@@ -1268,19 +1268,19 @@ fn f() {
                  ".tmp_source.zig:5:20: error: expected type 'usize', got 'bool'");
 
     add_compile_fail_case("variadic functions only allowed in extern", R"SOURCE(
-fn f(...) {}
+fn f(...) => {}
     )SOURCE", 1, ".tmp_source.zig:2:1: error: variadic arguments only allowed in extern functions");
 
     add_compile_fail_case("write to const global variable", R"SOURCE(
 const x : i32 = 99;
-fn f() {
+fn f() => {
     x = 1;
 }
     )SOURCE", 1, ".tmp_source.zig:4:5: error: cannot assign to constant");
 
 
     add_compile_fail_case("missing else clause", R"SOURCE(
-fn f() {
+fn f() => {
     const x : i32 = if (true) { 1 };
     const y = if (true) { 1 as i32 };
 }
@@ -1299,7 +1299,7 @@ struct C { a : A, }
 
     add_compile_fail_case("invalid struct field", R"SOURCE(
 struct A { x : i32, }
-fn f() {
+fn f() => {
     var a : A;
     a.foo = 1;
     const y = a.bar;
@@ -1315,7 +1315,7 @@ struct A { y : i32, }
 
     add_compile_fail_case("byvalue struct on exported functions", R"SOURCE(
 struct A { x : i32, }
-export fn f(a : A) {}
+export fn f(a : A) => {}
     )SOURCE", 1, ".tmp_source.zig:3:13: error: byvalue struct parameters not yet supported on exported functions");
 
     add_compile_fail_case("duplicate field in struct value expression", R"SOURCE(
@@ -1324,7 +1324,7 @@ struct A {
     y : i32,
     z : i32,
 }
-fn f() {
+fn f() => {
     const a = A {
         .z = 1,
         .y = 2,
@@ -1340,13 +1340,13 @@ struct A {
     y : i32,
     z : i32,
 }
-fn f() {
+fn f() => {
     const a = A {
         .z = 4,
         .y = 2,
     };
 }
-    )SOURCE", 1, ".tmp_source.zig:8:15: error: missing field: 'x'");
+    )SOURCE", 1, ".tmp_source.zig:8:17: error: missing field: 'x'");
 
     add_compile_fail_case("invalid field in struct value expression", R"SOURCE(
 struct A {
@@ -1354,7 +1354,7 @@ struct A {
     y : i32,
     z : i32,
 }
-fn f() {
+fn f() => {
     const a = A {
         .z = 4,
         .y = 2,
@@ -1364,37 +1364,37 @@ fn f() {
     )SOURCE", 1, ".tmp_source.zig:11:9: error: no member named 'foo' in 'A'");
 
     add_compile_fail_case("invalid break expression", R"SOURCE(
-fn f() {
+fn f() => {
     break;
 }
     )SOURCE", 1, ".tmp_source.zig:3:5: error: 'break' expression outside loop");
 
     add_compile_fail_case("invalid continue expression", R"SOURCE(
-fn f() {
+fn f() => {
     continue;
 }
     )SOURCE", 1, ".tmp_source.zig:3:5: error: 'continue' expression outside loop");
 
     add_compile_fail_case("invalid maybe type", R"SOURCE(
-fn f() {
+fn f() => {
     if (const x ?= true) { }
 }
     )SOURCE", 1, ".tmp_source.zig:3:20: error: expected maybe type");
 
     add_compile_fail_case("cast unreachable", R"SOURCE(
-fn f() -> i32 {
+fn f() i32 => {
     (return 1) as i32
 }
     )SOURCE", 1, ".tmp_source.zig:3:16: error: invalid cast from type 'unreachable' to 'i32'");
 
-    add_compile_fail_case("invalid compiler fn", R"SOURCE(
-fn f() -> #bogus(foo) {
+    add_compile_fail_case("invalid builtin fn", R"SOURCE(
+fn f() @bogus(foo) => {
 }
-    )SOURCE", 1, ".tmp_source.zig:2:11: error: invalid compiler function: 'bogus'");
+    )SOURCE", 1, ".tmp_source.zig:2:8: error: invalid builtin function: 'bogus'");
 
     add_compile_fail_case("top level decl dependency loop", R"SOURCE(
-const a : #typeof(b) = 0;
-const b : #typeof(a) = 0;
+const a : @typeof(b) = 0;
+const b : @typeof(a) = 0;
     )SOURCE", 1, ".tmp_source.zig:3:19: error: use of undeclared identifier 'a'");
 }