Commit c4df9bf56f

@@ -1605,7 +1605,15 @@ pub const FuncGen = struct {
         self.builder.positionBuilderAtEnd(loop_block);
         try self.genBody(body);
 
-        _ = self.builder.buildBr(loop_block);
+        // TODO instead of this logic, change AIR to have the property that
+        // every block is guaranteed to end with a noreturn instruction.
+        // Then we can simply rely on the fact that a repeat or break instruction
+        // would have been emitted already. Also the main loop in genBody can
+        // be while(true) instead of for(body), which will eliminate 1 branch on
+        // a hot path.
+        if (body.len == 0 or !self.air.typeOfIndex(body[body.len - 1]).isNoReturn()) {
+            _ = self.builder.buildBr(loop_block);
+        }
         return null;
     }
 

@@ -5537,8 +5537,10 @@ fn whileExpr(
         });
     }
 
-    loop_scope.break_count += 1;
     const then_result = try expr(&then_scope, then_sub_scope, loop_scope.break_result_loc, while_full.ast.then_expr);
+    if (!then_scope.endsWithNoReturn()) {
+        loop_scope.break_count += 1;
+    }
     try checkUsed(parent_gz, &then_scope.base, then_sub_scope);
 
     var else_scope = parent_gz.makeSubBlock(&continue_scope.base);
@@ -5549,7 +5551,6 @@ fn whileExpr(
         src: Ast.Node.Index,
         result: Zir.Inst.Ref,
     } = if (else_node != 0) blk: {
-        loop_scope.break_count += 1;
         const sub_scope = s: {
             if (while_full.error_token) |error_token| {
                 const tag: Zir.Inst.Tag = if (payload_is_ref)
@@ -5576,6 +5577,9 @@ fn whileExpr(
             }
         };
         const e = try expr(&else_scope, sub_scope, loop_scope.break_result_loc, else_node);
+        if (!else_scope.endsWithNoReturn()) {
+            loop_scope.break_count += 1;
+        }
         try checkUsed(parent_gz, &else_scope.base, sub_scope);
         break :blk .{
             .src = else_node,
@@ -5746,8 +5750,10 @@ fn forExpr(
         break :blk &index_scope.base;
     };
 
-    loop_scope.break_count += 1;
     const then_result = try expr(&then_scope, then_sub_scope, loop_scope.break_result_loc, for_full.ast.then_expr);
+    if (!then_scope.endsWithNoReturn()) {
+        loop_scope.break_count += 1;
+    }
     try checkUsed(parent_gz, &then_scope.base, then_sub_scope);
 
     var else_scope = parent_gz.makeSubBlock(&cond_scope.base);
@@ -5758,11 +5764,14 @@ fn forExpr(
         src: Ast.Node.Index,
         result: Zir.Inst.Ref,
     } = if (else_node != 0) blk: {
-        loop_scope.break_count += 1;
         const sub_scope = &else_scope.base;
+        const else_result = try expr(&else_scope, sub_scope, loop_scope.break_result_loc, else_node);
+        if (!else_scope.endsWithNoReturn()) {
+            loop_scope.break_count += 1;
+        }
         break :blk .{
             .src = else_node,
-            .result = try expr(&else_scope, sub_scope, loop_scope.break_result_loc, else_node),
+            .result = else_result,
         };
     } else .{
         .src = for_full.ast.then_expr,

@@ -1,74 +1,3 @@
 const std = @import("std");
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
-
-test "basic invocations" {
-    const foo = struct {
-        fn foo() i32 {
-            return 1234;
-        }
-    }.foo;
-    try expect(@call(.{}, foo, .{}) == 1234);
-    comptime {
-        // modifiers that allow comptime calls
-        try expect(@call(.{}, foo, .{}) == 1234);
-        try expect(@call(.{ .modifier = .no_async }, foo, .{}) == 1234);
-        try expect(@call(.{ .modifier = .always_tail }, foo, .{}) == 1234);
-        try expect(@call(.{ .modifier = .always_inline }, foo, .{}) == 1234);
-    }
-    {
-        // comptime call without comptime keyword
-        const result = @call(.{ .modifier = .compile_time }, foo, .{}) == 1234;
-        comptime try expect(result);
-    }
-    {
-        // call of non comptime-known function
-        var alias_foo = foo;
-        try expect(@call(.{ .modifier = .no_async }, alias_foo, .{}) == 1234);
-        try expect(@call(.{ .modifier = .never_tail }, alias_foo, .{}) == 1234);
-        try expect(@call(.{ .modifier = .never_inline }, alias_foo, .{}) == 1234);
-    }
-}
-
-test "tuple parameters" {
-    const add = struct {
-        fn add(a: i32, b: i32) i32 {
-            return a + b;
-        }
-    }.add;
-    var a: i32 = 12;
-    var b: i32 = 34;
-    try expect(@call(.{}, add, .{ a, 34 }) == 46);
-    try expect(@call(.{}, add, .{ 12, b }) == 46);
-    try expect(@call(.{}, add, .{ a, b }) == 46);
-    try expect(@call(.{}, add, .{ 12, 34 }) == 46);
-    comptime try expect(@call(.{}, add, .{ 12, 34 }) == 46);
-    {
-        const separate_args0 = .{ a, b };
-        const separate_args1 = .{ a, 34 };
-        const separate_args2 = .{ 12, 34 };
-        const separate_args3 = .{ 12, b };
-        try expect(@call(.{ .modifier = .always_inline }, add, separate_args0) == 46);
-        try expect(@call(.{ .modifier = .always_inline }, add, separate_args1) == 46);
-        try expect(@call(.{ .modifier = .always_inline }, add, separate_args2) == 46);
-        try expect(@call(.{ .modifier = .always_inline }, add, separate_args3) == 46);
-    }
-}
-
-test "comptime call with bound function as parameter" {
-    const S = struct {
-        fn ReturnType(func: anytype) type {
-            return switch (@typeInfo(@TypeOf(func))) {
-                .BoundFn => |info| info,
-                else => unreachable,
-            }.return_type orelse void;
-        }
-
-        fn call_me_maybe() ?i32 {
-            return 123;
-        }
-    };
-
-    var inst: S = undefined;
-    try expectEqual(?i32, S.ReturnType(inst.call_me_maybe));
-}

@@ -0,0 +1,74 @@
+const std = @import("std");
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+
+test "basic invocations" {
+    const foo = struct {
+        fn foo() i32 {
+            return 1234;
+        }
+    }.foo;
+    try expect(@call(.{}, foo, .{}) == 1234);
+    comptime {
+        // modifiers that allow comptime calls
+        try expect(@call(.{}, foo, .{}) == 1234);
+        try expect(@call(.{ .modifier = .no_async }, foo, .{}) == 1234);
+        try expect(@call(.{ .modifier = .always_tail }, foo, .{}) == 1234);
+        try expect(@call(.{ .modifier = .always_inline }, foo, .{}) == 1234);
+    }
+    {
+        // comptime call without comptime keyword
+        const result = @call(.{ .modifier = .compile_time }, foo, .{}) == 1234;
+        comptime try expect(result);
+    }
+    {
+        // call of non comptime-known function
+        var alias_foo = foo;
+        try expect(@call(.{ .modifier = .no_async }, alias_foo, .{}) == 1234);
+        try expect(@call(.{ .modifier = .never_tail }, alias_foo, .{}) == 1234);
+        try expect(@call(.{ .modifier = .never_inline }, alias_foo, .{}) == 1234);
+    }
+}
+
+test "tuple parameters" {
+    const add = struct {
+        fn add(a: i32, b: i32) i32 {
+            return a + b;
+        }
+    }.add;
+    var a: i32 = 12;
+    var b: i32 = 34;
+    try expect(@call(.{}, add, .{ a, 34 }) == 46);
+    try expect(@call(.{}, add, .{ 12, b }) == 46);
+    try expect(@call(.{}, add, .{ a, b }) == 46);
+    try expect(@call(.{}, add, .{ 12, 34 }) == 46);
+    comptime try expect(@call(.{}, add, .{ 12, 34 }) == 46);
+    {
+        const separate_args0 = .{ a, b };
+        const separate_args1 = .{ a, 34 };
+        const separate_args2 = .{ 12, 34 };
+        const separate_args3 = .{ 12, b };
+        try expect(@call(.{ .modifier = .always_inline }, add, separate_args0) == 46);
+        try expect(@call(.{ .modifier = .always_inline }, add, separate_args1) == 46);
+        try expect(@call(.{ .modifier = .always_inline }, add, separate_args2) == 46);
+        try expect(@call(.{ .modifier = .always_inline }, add, separate_args3) == 46);
+    }
+}
+
+test "comptime call with bound function as parameter" {
+    const S = struct {
+        fn ReturnType(func: anytype) type {
+            return switch (@typeInfo(@TypeOf(func))) {
+                .BoundFn => |info| info,
+                else => unreachable,
+            }.return_type orelse void;
+        }
+
+        fn call_me_maybe() ?i32 {
+            return 123;
+        }
+    };
+
+    var inst: S = undefined;
+    try expectEqual(?i32, S.ReturnType(inst.call_me_maybe));
+}

@@ -16,3 +16,52 @@ test "integer literal to pointer cast" {
     const vga_mem = @intToPtr(*u16, 0xB8000);
     try expect(@ptrToInt(vga_mem) == 0xB8000);
 }
+
+test "peer type resolution: ?T and T" {
+    try expect(peerTypeTAndOptionalT(true, false).? == 0);
+    try expect(peerTypeTAndOptionalT(false, false).? == 3);
+    comptime {
+        try expect(peerTypeTAndOptionalT(true, false).? == 0);
+        try expect(peerTypeTAndOptionalT(false, false).? == 3);
+    }
+}
+fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
+    if (c) {
+        return if (b) null else @as(usize, 0);
+    }
+
+    return @as(usize, 3);
+}
+
+test "resolve undefined with integer" {
+    try testResolveUndefWithInt(true, 1234);
+    comptime try testResolveUndefWithInt(true, 1234);
+}
+fn testResolveUndefWithInt(b: bool, x: i32) !void {
+    const value = if (b) x else undefined;
+    if (b) {
+        try expect(value == x);
+    }
+}
+
+test "@intCast i32 to u7" {
+    var x: u128 = maxInt(u128);
+    var y: i32 = 120;
+    var z = x >> @intCast(u7, y);
+    try expect(z == 0xff);
+}
+
+test "@intCast to comptime_int" {
+    try expect(@intCast(comptime_int, 0) == 0);
+}
+
+test "implicit cast comptime numbers to any type when the value fits" {
+    const a: u64 = 255;
+    var b: u8 = a;
+    try expect(b == 255);
+}
+
+test "implicit cast comptime_int to comptime_float" {
+    comptime try expect(@as(comptime_float, 10) == @as(f32, 10));
+    try expect(2 == 2.0);
+}

@@ -121,22 +121,6 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A {
     return null;
 }
 
-test "peer type resolution: ?T and T" {
-    try expect(peerTypeTAndOptionalT(true, false).? == 0);
-    try expect(peerTypeTAndOptionalT(false, false).? == 3);
-    comptime {
-        try expect(peerTypeTAndOptionalT(true, false).? == 0);
-        try expect(peerTypeTAndOptionalT(false, false).? == 3);
-    }
-}
-fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
-    if (c) {
-        return if (b) null else @as(usize, 0);
-    }
-
-    return @as(usize, 3);
-}
-
 test "peer type resolution: [0]u8 and []const u8" {
     try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
     try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
@@ -203,17 +187,6 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
     return slice[0..1];
 }
 
-test "resolve undefined with integer" {
-    try testResolveUndefWithInt(true, 1234);
-    comptime try testResolveUndefWithInt(true, 1234);
-}
-fn testResolveUndefWithInt(b: bool, x: i32) !void {
-    const value = if (b) x else undefined;
-    if (b) {
-        try expect(value == x);
-    }
-}
-
 test "implicit cast from &const [N]T to []const T" {
     try testCastConstArrayRefToConstSlice();
     comptime try testCastConstArrayRefToConstSlice();
@@ -424,13 +397,6 @@ test "comptime_int @intToFloat" {
     }
 }
 
-test "@intCast i32 to u7" {
-    var x: u128 = maxInt(u128);
-    var y: i32 = 120;
-    var z = x >> @intCast(u7, y);
-    try expect(z == 0xff);
-}
-
 test "@floatCast cast down" {
     {
         var double: f64 = 0.001534;
@@ -533,20 +499,8 @@ test "implicit ptr to *c_void" {
     try expect(c.* == 1);
 }
 
-test "@intCast to comptime_int" {
-    try expect(@intCast(comptime_int, 0) == 0);
-}
-
-test "implicit cast comptime numbers to any type when the value fits" {
-    const a: u64 = 255;
-    var b: u8 = a;
-    try expect(b == 255);
-}
-
 test "@intToEnum passed a comptime_int to an enum with one item" {
-    const E = enum {
-        A,
-    };
+    const E = enum { A };
     const x = @intToEnum(E, 0);
     try expect(x == E.A);
 }
@@ -599,11 +553,6 @@ test "peer type resolution: unreachable, error set, unreachable" {
     try expect(transformed_err == error.SystemResources);
 }
 
-test "implicit cast comptime_int to comptime_float" {
-    comptime try expect(@as(comptime_float, 10) == @as(f32, 10));
-    try expect(2 == 2.0);
-}
-
 test "implicit cast *[0]T to E![]const u8" {
     var x = @as(anyerror![]const u8, &[0]u8{});
     try expect((x catch unreachable).len == 0);
@@ -645,12 +594,7 @@ test "*const [N]null u8 to ?[]const u8" {
 
 test "peer resolution of string literals" {
     const S = struct {
-        const E = enum {
-            a,
-            b,
-            c,
-            d,
-        };
+        const E = enum { a, b, c, d };
 
         fn doTheTest(e: E) !void {
             const cmd = switch (e) {

@@ -6,11 +6,7 @@ const expect = testing.expect;
 var argv: [*]const [*]const u8 = undefined;
 
 test "const slice child" {
-    const strs = [_][*]const u8{
-        "one",
-        "two",
-        "three",
-    };
+    const strs = [_][*]const u8{ "one", "two", "three" };
     argv = &strs;
     try bar(strs.len);
 }

@@ -2,113 +2,3 @@ const std = @import("std");
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 const expectError = std.testing.expectError;
-
-var result: [3]u8 = undefined;
-var index: usize = undefined;
-
-fn runSomeErrorDefers(x: bool) !bool {
-    index = 0;
-    defer {
-        result[index] = 'a';
-        index += 1;
-    }
-    errdefer {
-        result[index] = 'b';
-        index += 1;
-    }
-    defer {
-        result[index] = 'c';
-        index += 1;
-    }
-    return if (x) x else error.FalseNotAllowed;
-}
-
-test "mixing normal and error defers" {
-    try expect(runSomeErrorDefers(true) catch unreachable);
-    try expect(result[0] == 'c');
-    try expect(result[1] == 'a');
-
-    const ok = runSomeErrorDefers(false) catch |err| x: {
-        try expect(err == error.FalseNotAllowed);
-        break :x true;
-    };
-    try expect(ok);
-    try expect(result[0] == 'c');
-    try expect(result[1] == 'b');
-    try expect(result[2] == 'a');
-}
-
-test "break and continue inside loop inside defer expression" {
-    testBreakContInDefer(10);
-    comptime testBreakContInDefer(10);
-}
-
-fn testBreakContInDefer(x: usize) void {
-    defer {
-        var i: usize = 0;
-        while (i < x) : (i += 1) {
-            if (i < 5) continue;
-            if (i == 5) break;
-        }
-        expect(i == 5) catch @panic("test failure");
-    }
-}
-
-test "defer and labeled break" {
-    var i = @as(usize, 0);
-
-    blk: {
-        defer i += 1;
-        break :blk;
-    }
-
-    try expect(i == 1);
-}
-
-test "errdefer does not apply to fn inside fn" {
-    if (testNestedFnErrDefer()) |_| @panic("expected error") else |e| try expect(e == error.Bad);
-}
-
-fn testNestedFnErrDefer() anyerror!void {
-    var a: i32 = 0;
-    errdefer a += 1;
-    const S = struct {
-        fn baz() anyerror {
-            return error.Bad;
-        }
-    };
-    return S.baz();
-}
-
-test "return variable while defer expression in scope to modify it" {
-    const S = struct {
-        fn doTheTest() !void {
-            try expect(notNull().? == 1);
-        }
-
-        fn notNull() ?u8 {
-            var res: ?u8 = 1;
-            defer res = null;
-            return res;
-        }
-    };
-
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}
-
-test "errdefer with payload" {
-    const S = struct {
-        fn foo() !i32 {
-            errdefer |a| {
-                expectEqual(error.One, a) catch @panic("test failure");
-            }
-            return error.One;
-        }
-        fn doTheTest() !void {
-            try expectError(error.One, foo());
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}

@@ -0,0 +1,114 @@
+const std = @import("std");
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const expectError = std.testing.expectError;
+
+var result: [3]u8 = undefined;
+var index: usize = undefined;
+
+fn runSomeErrorDefers(x: bool) !bool {
+    index = 0;
+    defer {
+        result[index] = 'a';
+        index += 1;
+    }
+    errdefer {
+        result[index] = 'b';
+        index += 1;
+    }
+    defer {
+        result[index] = 'c';
+        index += 1;
+    }
+    return if (x) x else error.FalseNotAllowed;
+}
+
+test "mixing normal and error defers" {
+    try expect(runSomeErrorDefers(true) catch unreachable);
+    try expect(result[0] == 'c');
+    try expect(result[1] == 'a');
+
+    const ok = runSomeErrorDefers(false) catch |err| x: {
+        try expect(err == error.FalseNotAllowed);
+        break :x true;
+    };
+    try expect(ok);
+    try expect(result[0] == 'c');
+    try expect(result[1] == 'b');
+    try expect(result[2] == 'a');
+}
+
+test "break and continue inside loop inside defer expression" {
+    testBreakContInDefer(10);
+    comptime testBreakContInDefer(10);
+}
+
+fn testBreakContInDefer(x: usize) void {
+    defer {
+        var i: usize = 0;
+        while (i < x) : (i += 1) {
+            if (i < 5) continue;
+            if (i == 5) break;
+        }
+        expect(i == 5) catch @panic("test failure");
+    }
+}
+
+test "defer and labeled break" {
+    var i = @as(usize, 0);
+
+    blk: {
+        defer i += 1;
+        break :blk;
+    }
+
+    try expect(i == 1);
+}
+
+test "errdefer does not apply to fn inside fn" {
+    if (testNestedFnErrDefer()) |_| @panic("expected error") else |e| try expect(e == error.Bad);
+}
+
+fn testNestedFnErrDefer() anyerror!void {
+    var a: i32 = 0;
+    errdefer a += 1;
+    const S = struct {
+        fn baz() anyerror {
+            return error.Bad;
+        }
+    };
+    return S.baz();
+}
+
+test "return variable while defer expression in scope to modify it" {
+    const S = struct {
+        fn doTheTest() !void {
+            try expect(notNull().? == 1);
+        }
+
+        fn notNull() ?u8 {
+            var res: ?u8 = 1;
+            defer res = null;
+            return res;
+        }
+    };
+
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}
+
+test "errdefer with payload" {
+    const S = struct {
+        fn foo() !i32 {
+            errdefer |a| {
+                expectEqual(error.One, a) catch @panic("test failure");
+            }
+            return error.One;
+        }
+        fn doTheTest() !void {
+            try expectError(error.One, foo());
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}

@@ -1,133 +1,7 @@
-const expect = @import("std").testing.expect;
-const mem = @import("std").mem;
-const Tag = @import("std").meta.Tag;
-
-test "non-exhaustive enum" {
-    const S = struct {
-        const E = enum(u8) {
-            a,
-            b,
-            _,
-        };
-        fn doTheTest(y: u8) !void {
-            var e: E = .b;
-            try expect(switch (e) {
-                .a => false,
-                .b => true,
-                _ => false,
-            });
-            e = @intToEnum(E, 12);
-            try expect(switch (e) {
-                .a => false,
-                .b => false,
-                _ => true,
-            });
-
-            try expect(switch (e) {
-                .a => false,
-                .b => false,
-                else => true,
-            });
-            e = .b;
-            try expect(switch (e) {
-                .a => false,
-                else => true,
-            });
-
-            try expect(@typeInfo(E).Enum.fields.len == 2);
-            e = @intToEnum(E, 12);
-            try expect(@enumToInt(e) == 12);
-            e = @intToEnum(E, y);
-            try expect(@enumToInt(e) == 52);
-            try expect(@typeInfo(E).Enum.is_exhaustive == false);
-        }
-    };
-    try S.doTheTest(52);
-    comptime try S.doTheTest(52);
-}
-
-test "empty non-exhaustive enum" {
-    const S = struct {
-        const E = enum(u8) {
-            _,
-        };
-        fn doTheTest(y: u8) !void {
-            var e = @intToEnum(E, y);
-            try expect(switch (e) {
-                _ => true,
-            });
-            try expect(@enumToInt(e) == y);
-
-            try expect(@typeInfo(E).Enum.fields.len == 0);
-            try expect(@typeInfo(E).Enum.is_exhaustive == false);
-        }
-    };
-    try S.doTheTest(42);
-    comptime try S.doTheTest(42);
-}
-
-test "single field non-exhaustive enum" {
-    const S = struct {
-        const E = enum(u8) {
-            a,
-            _,
-        };
-        fn doTheTest(y: u8) !void {
-            var e: E = .a;
-            try expect(switch (e) {
-                .a => true,
-                _ => false,
-            });
-            e = @intToEnum(E, 12);
-            try expect(switch (e) {
-                .a => false,
-                _ => true,
-            });
-
-            try expect(switch (e) {
-                .a => false,
-                else => true,
-            });
-            e = .a;
-            try expect(switch (e) {
-                .a => true,
-                else => false,
-            });
-
-            try expect(@enumToInt(@intToEnum(E, y)) == y);
-            try expect(@typeInfo(E).Enum.fields.len == 1);
-            try expect(@typeInfo(E).Enum.is_exhaustive == false);
-        }
-    };
-    try S.doTheTest(23);
-    comptime try S.doTheTest(23);
-}
-
-test "enum type" {
-    const foo1 = Foo{ .One = 13 };
-    const foo2 = Foo{
-        .Two = Point{
-            .x = 1234,
-            .y = 5678,
-        },
-    };
-    try expect(foo1.One == 13);
-    try expect(foo2.Two.x == 1234 and foo2.Two.y == 5678);
-    const bar = Bar.B;
-
-    try expect(bar == Bar.B);
-    try expect(@typeInfo(Foo).Union.fields.len == 3);
-    try expect(@typeInfo(Bar).Enum.fields.len == 4);
-    try expect(@sizeOf(Foo) == @sizeOf(FooNoVoid));
-    try expect(@sizeOf(Bar) == 1);
-}
-
-test "enum as return value" {
-    switch (returnAnInt(13)) {
-        Foo.One => |value| try expect(value == 13),
-        else => unreachable,
-    }
-}
+const std = @import("std");
+const expect = std.testing.expect;
+const mem = std.mem;
+const Tag = std.meta.Tag;
 
 const Point = struct {
     x: u64,
@@ -153,13 +27,6 @@ fn returnAnInt(x: i32) Foo {
     return Foo{ .One = x };
 }
 
-test "constant enum with payload" {
-    var empty = AnEnumWithPayload{ .Empty = {} };
-    var full = AnEnumWithPayload{ .Full = 13 };
-    shouldBeEmpty(empty);
-    shouldBeNotEmpty(full);
-}
-
 fn shouldBeEmpty(x: AnEnumWithPayload) void {
     switch (x) {
         AnEnumWithPayload.Empty => {},
@@ -179,72 +46,19 @@ const AnEnumWithPayload = union(enum) {
     Full: i32,
 };
 
-const Number = enum {
-    Zero,
-    One,
-    Two,
-    Three,
-    Four,
-};
-
-test "enum to int" {
-    try shouldEqual(Number.Zero, 0);
-    try shouldEqual(Number.One, 1);
-    try shouldEqual(Number.Two, 2);
-    try shouldEqual(Number.Three, 3);
-    try shouldEqual(Number.Four, 4);
-}
+const Number = enum { Zero, One, Two, Three, Four };
 
 fn shouldEqual(n: Number, expected: u3) !void {
     try expect(@enumToInt(n) == expected);
 }
 
-test "int to enum" {
-    try testIntToEnumEval(3);
-}
-fn testIntToEnumEval(x: i32) !void {
-    try expect(@intToEnum(IntToEnumNumber, x) == IntToEnumNumber.Three);
-}
-const IntToEnumNumber = enum {
-    Zero,
-    One,
-    Two,
-    Three,
-    Four,
-};
-
-test "@tagName" {
-    try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
-    comptime try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
-}
-
-test "@tagName non-exhaustive enum" {
-    try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
-    comptime try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
-}
-
 fn testEnumTagNameBare(n: anytype) []const u8 {
     return @tagName(n);
 }
 
-const BareNumber = enum {
-    One,
-    Two,
-    Three,
-};
-
-const NonExhaustive = enum(u8) {
-    A,
-    B,
-    _,
-};
+const BareNumber = enum { One, Two, Three };
 
-test "enum alignment" {
-    comptime {
-        try expect(@alignOf(AlignTestEnum) >= @alignOf([9]u8));
-        try expect(@alignOf(AlignTestEnum) >= @alignOf(u64));
-    }
-}
+const NonExhaustive = enum(u8) { A, B, _ };
 
 const AlignTestEnum = union(enum) {
     A: [9]u8,
@@ -776,67 +590,12 @@ const ValueCount257 = enum {
     I256,
 };
 
-test "enum sizes" {
-    comptime {
-        try expect(@sizeOf(ValueCount1) == 0);
-        try expect(@sizeOf(ValueCount2) == 1);
-        try expect(@sizeOf(ValueCount256) == 1);
-        try expect(@sizeOf(ValueCount257) == 2);
-    }
-}
+const Small2 = enum(u2) { One, Two };
+const Small = enum(u2) { One, Two, Three, Four };
 
-const Small2 = enum(u2) {
-    One,
-    Two,
-};
-const Small = enum(u2) {
-    One,
-    Two,
-    Three,
-    Four,
-};
-
-test "set enum tag type" {
-    {
-        var x = Small.One;
-        x = Small.Two;
-        comptime try expect(Tag(Small) == u2);
-    }
-    {
-        var x = Small2.One;
-        x = Small2.Two;
-        comptime try expect(Tag(Small2) == u2);
-    }
-}
-
-const A = enum(u3) {
-    One,
-    Two,
-    Three,
-    Four,
-    One2,
-    Two2,
-    Three2,
-    Four2,
-};
-
-const B = enum(u3) {
-    One3,
-    Two3,
-    Three3,
-    Four3,
-    One23,
-    Two23,
-    Three23,
-    Four23,
-};
-
-const C = enum(u2) {
-    One4,
-    Two4,
-    Three4,
-    Four4,
-};
+const A = enum(u3) { One, Two, Three, Four, One2, Two2, Three2, Four2 };
+const B = enum(u3) { One3, Two3, Three3, Four3, One23, Two23, Three23, Four23 };
+const C = enum(u2) { One4, Two4, Three4, Four4 };
 
 const BitFieldOfEnums = packed struct {
     a: A,
@@ -850,21 +609,6 @@ const bit_field_1 = BitFieldOfEnums{
     .c = C.Four4,
 };
 
-test "bit field access with enum fields" {
-    var data = bit_field_1;
-    try expect(getA(&data) == A.Two);
-    try expect(getB(&data) == B.Three3);
-    try expect(getC(&data) == C.Four4);
-    comptime try expect(@sizeOf(BitFieldOfEnums) == 1);
-
-    data.b = B.Four3;
-    try expect(data.b == B.Four3);
-
-    data.a = A.Three;
-    try expect(data.a == A.Three);
-    try expect(data.b == B.Four3);
-}
-
 fn getA(data: *const BitFieldOfEnums) A {
     return data.a;
 }
@@ -877,15 +621,6 @@ fn getC(data: *const BitFieldOfEnums) C {
     return data.c;
 }
 
-test "casting enum to its tag type" {
-    try testCastEnumTag(Small2.Two);
-    comptime try testCastEnumTag(Small2.Two);
-}
-
-fn testCastEnumTag(value: Small2) !void {
-    try expect(@enumToInt(value) == 1);
-}
-
 const MultipleChoice = enum(u32) {
     A = 20,
     B = 40,
@@ -893,21 +628,6 @@ const MultipleChoice = enum(u32) {
     D = 1000,
 };
 
-test "enum with specified tag values" {
-    try testEnumWithSpecifiedTagValues(MultipleChoice.C);
-    comptime try testEnumWithSpecifiedTagValues(MultipleChoice.C);
-}
-
-fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void {
-    try expect(@enumToInt(x) == 60);
-    try expect(1234 == switch (x) {
-        MultipleChoice.A => 1,
-        MultipleChoice.B => 2,
-        MultipleChoice.C => @as(u32, 1234),
-        MultipleChoice.D => 4,
-    });
-}
-
 const MultipleChoice2 = enum(u32) {
     Unspecified1,
     A = 20,
@@ -920,34 +640,7 @@ const MultipleChoice2 = enum(u32) {
     Unspecified5,
 };
 
-test "enum with specified and unspecified tag values" {
-    try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);
-    comptime try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);
-}
-
-fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void {
-    try expect(@enumToInt(x) == 1000);
-    try expect(1234 == switch (x) {
-        MultipleChoice2.A => 1,
-        MultipleChoice2.B => 2,
-        MultipleChoice2.C => 3,
-        MultipleChoice2.D => @as(u32, 1234),
-        MultipleChoice2.Unspecified1 => 5,
-        MultipleChoice2.Unspecified2 => 6,
-        MultipleChoice2.Unspecified3 => 7,
-        MultipleChoice2.Unspecified4 => 8,
-        MultipleChoice2.Unspecified5 => 9,
-    });
-}
-
-test "cast integer literal to enum" {
-    try expect(@intToEnum(MultipleChoice2, 0) == MultipleChoice2.Unspecified1);
-    try expect(@intToEnum(MultipleChoice2, 40) == MultipleChoice2.B);
-}
-
-const EnumWithOneMember = enum {
-    Eof,
-};
+const EnumWithOneMember = enum { Eof };
 
 fn doALoopThing(id: EnumWithOneMember) void {
     while (true) {
@@ -958,20 +651,7 @@ fn doALoopThing(id: EnumWithOneMember) void {
     }
 }
 
-test "comparison operator on enum with one member is comptime known" {
-    doALoopThing(EnumWithOneMember.Eof);
-}
-
-const State = enum {
-    Start,
-};
-test "switch on enum with one member is comptime known" {
-    var state = State.Start;
-    switch (state) {
-        State.Start => return,
-    }
-    @compileError("analysis should not reach here");
-}
+const State = enum { Start };
 
 const EnumWithTagValues = enum(u4) {
     A = 1 << 0,
@@ -979,24 +659,22 @@ const EnumWithTagValues = enum(u4) {
     C = 1 << 2,
     D = 1 << 3,
 };
-test "enum with tag values don't require parens" {
-    try expect(@enumToInt(EnumWithTagValues.C) == 0b0100);
-}
 
-test "enum with 1 field but explicit tag type should still have the tag type" {
-    const Enum = enum(u8) {
-        B = 2,
-    };
-    comptime try expect(@sizeOf(Enum) == @sizeOf(u8));
+test "enum to int" {
+    try shouldEqual(Number.Zero, 0);
+    try shouldEqual(Number.One, 1);
+    try shouldEqual(Number.Two, 2);
+    try shouldEqual(Number.Three, 3);
+    try shouldEqual(Number.Four, 4);
 }
 
-test "tag name with assigned enum values" {
-    const LocalFoo = enum(u8) {
-        A = 1,
-        B = 0,
-    };
-    var b = LocalFoo.B;
-    try expect(mem.eql(u8, @tagName(b), "B"));
+test "enum sizes" {
+    comptime {
+        try expect(@sizeOf(ValueCount1) == 0);
+        try expect(@sizeOf(ValueCount2) == 1);
+        try expect(@sizeOf(ValueCount256) == 1);
+        try expect(@sizeOf(ValueCount257) == 2);
+    }
 }
 
 test "enum literal equality" {
@@ -1009,11 +687,7 @@ test "enum literal equality" {
 }
 
 test "enum literal cast to enum" {
-    const Color = enum {
-        Auto,
-        Off,
-        On,
-    };
+    const Color = enum { Auto, Off, On };
 
     var color1: Color = .Auto;
     var color2 = Color.Auto;
@@ -1021,147 +695,8 @@ test "enum literal cast to enum" {
 }
 
 test "peer type resolution with enum literal" {
-    const Items = enum {
-        one,
-        two,
-    };
+    const Items = enum { one, two };
 
     try expect(Items.two == .two);
     try expect(.two == Items.two);
 }
-
-test "enum literal in array literal" {
-    const Items = enum {
-        one,
-        two,
-    };
-
-    const array = [_]Items{
-        .one,
-        .two,
-    };
-
-    try expect(array[0] == .one);
-    try expect(array[1] == .two);
-}
-
-test "signed integer as enum tag" {
-    const SignedEnum = enum(i2) {
-        A0 = -1,
-        A1 = 0,
-        A2 = 1,
-    };
-
-    try expect(@enumToInt(SignedEnum.A0) == -1);
-    try expect(@enumToInt(SignedEnum.A1) == 0);
-    try expect(@enumToInt(SignedEnum.A2) == 1);
-}
-
-test "enum value allocation" {
-    const LargeEnum = enum(u32) {
-        A0 = 0x80000000,
-        A1,
-        A2,
-    };
-
-    try expect(@enumToInt(LargeEnum.A0) == 0x80000000);
-    try expect(@enumToInt(LargeEnum.A1) == 0x80000001);
-    try expect(@enumToInt(LargeEnum.A2) == 0x80000002);
-}
-
-test "enum literal casting to tagged union" {
-    const Arch = union(enum) {
-        x86_64,
-        arm: Arm32,
-
-        const Arm32 = enum {
-            v8_5a,
-            v8_4a,
-        };
-    };
-
-    var t = true;
-    var x: Arch = .x86_64;
-    var y = if (t) x else .x86_64;
-    switch (y) {
-        .x86_64 => {},
-        else => @panic("fail"),
-    }
-}
-
-test "enum with one member and custom tag type" {
-    const E = enum(u2) {
-        One,
-    };
-    try expect(@enumToInt(E.One) == 0);
-    const E2 = enum(u2) {
-        One = 2,
-    };
-    try expect(@enumToInt(E2.One) == 2);
-}
-
-test "enum literal casting to optional" {
-    var bar: ?Bar = undefined;
-    bar = .B;
-
-    try expect(bar.? == Bar.B);
-}
-
-test "enum literal casting to error union with payload enum" {
-    var bar: error{B}!Bar = undefined;
-    bar = .B; // should never cast to the error set
-
-    try expect((try bar) == Bar.B);
-}
-
-test "enum with one member and u1 tag type @enumToInt" {
-    const Enum = enum(u1) {
-        Test,
-    };
-    try expect(@enumToInt(Enum.Test) == 0);
-}
-
-test "enum with comptime_int tag type" {
-    const Enum = enum(comptime_int) {
-        One = 3,
-        Two = 2,
-        Three = 1,
-    };
-    comptime try expect(Tag(Enum) == comptime_int);
-}
-
-test "enum with one member default to u0 tag type" {
-    const E0 = enum {
-        X,
-    };
-    comptime try expect(Tag(E0) == u0);
-}
-
-test "tagName on enum literals" {
-    try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
-    comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
-}
-
-test "method call on an enum" {
-    const S = struct {
-        const E = enum {
-            one,
-            two,
-
-            fn method(self: *E) bool {
-                return self.* == .two;
-            }
-
-            fn generic_method(self: *E, foo: anytype) bool {
-                return self.* == .two and foo == bool;
-            }
-        };
-        fn doTheTest() !void {
-            var e = E.two;
-            try expect(e.method());
-            try expect(e.generic_method(bool));
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}

@@ -0,0 +1,1058 @@
+const expect = @import("std").testing.expect;
+const mem = @import("std").mem;
+const Tag = @import("std").meta.Tag;
+
+test "non-exhaustive enum" {
+    const S = struct {
+        const E = enum(u8) {
+            a,
+            b,
+            _,
+        };
+        fn doTheTest(y: u8) !void {
+            var e: E = .b;
+            try expect(switch (e) {
+                .a => false,
+                .b => true,
+                _ => false,
+            });
+            e = @intToEnum(E, 12);
+            try expect(switch (e) {
+                .a => false,
+                .b => false,
+                _ => true,
+            });
+
+            try expect(switch (e) {
+                .a => false,
+                .b => false,
+                else => true,
+            });
+            e = .b;
+            try expect(switch (e) {
+                .a => false,
+                else => true,
+            });
+
+            try expect(@typeInfo(E).Enum.fields.len == 2);
+            e = @intToEnum(E, 12);
+            try expect(@enumToInt(e) == 12);
+            e = @intToEnum(E, y);
+            try expect(@enumToInt(e) == 52);
+            try expect(@typeInfo(E).Enum.is_exhaustive == false);
+        }
+    };
+    try S.doTheTest(52);
+    comptime try S.doTheTest(52);
+}
+
+test "empty non-exhaustive enum" {
+    const S = struct {
+        const E = enum(u8) {
+            _,
+        };
+        fn doTheTest(y: u8) !void {
+            var e = @intToEnum(E, y);
+            try expect(switch (e) {
+                _ => true,
+            });
+            try expect(@enumToInt(e) == y);
+
+            try expect(@typeInfo(E).Enum.fields.len == 0);
+            try expect(@typeInfo(E).Enum.is_exhaustive == false);
+        }
+    };
+    try S.doTheTest(42);
+    comptime try S.doTheTest(42);
+}
+
+test "single field non-exhaustive enum" {
+    const S = struct {
+        const E = enum(u8) { a, _ };
+        fn doTheTest(y: u8) !void {
+            var e: E = .a;
+            try expect(switch (e) {
+                .a => true,
+                _ => false,
+            });
+            e = @intToEnum(E, 12);
+            try expect(switch (e) {
+                .a => false,
+                _ => true,
+            });
+
+            try expect(switch (e) {
+                .a => false,
+                else => true,
+            });
+            e = .a;
+            try expect(switch (e) {
+                .a => true,
+                else => false,
+            });
+
+            try expect(@enumToInt(@intToEnum(E, y)) == y);
+            try expect(@typeInfo(E).Enum.fields.len == 1);
+            try expect(@typeInfo(E).Enum.is_exhaustive == false);
+        }
+    };
+    try S.doTheTest(23);
+    comptime try S.doTheTest(23);
+}
+
+test "enum type" {
+    const foo1 = Foo{ .One = 13 };
+    const foo2 = Foo{
+        .Two = Point{
+            .x = 1234,
+            .y = 5678,
+        },
+    };
+    try expect(foo1.One == 13);
+    try expect(foo2.Two.x == 1234 and foo2.Two.y == 5678);
+    const bar = Bar.B;
+
+    try expect(bar == Bar.B);
+    try expect(@typeInfo(Foo).Union.fields.len == 3);
+    try expect(@typeInfo(Bar).Enum.fields.len == 4);
+    try expect(@sizeOf(Foo) == @sizeOf(FooNoVoid));
+    try expect(@sizeOf(Bar) == 1);
+}
+
+test "enum as return value" {
+    switch (returnAnInt(13)) {
+        Foo.One => |value| try expect(value == 13),
+        else => unreachable,
+    }
+}
+
+const Point = struct {
+    x: u64,
+    y: u64,
+};
+const Foo = union(enum) {
+    One: i32,
+    Two: Point,
+    Three: void,
+};
+const FooNoVoid = union(enum) {
+    One: i32,
+    Two: Point,
+};
+const Bar = enum {
+    A,
+    B,
+    C,
+    D,
+};
+
+fn returnAnInt(x: i32) Foo {
+    return Foo{ .One = x };
+}
+
+test "constant enum with payload" {
+    var empty = AnEnumWithPayload{ .Empty = {} };
+    var full = AnEnumWithPayload{ .Full = 13 };
+    shouldBeEmpty(empty);
+    shouldBeNotEmpty(full);
+}
+
+fn shouldBeEmpty(x: AnEnumWithPayload) void {
+    switch (x) {
+        AnEnumWithPayload.Empty => {},
+        else => unreachable,
+    }
+}
+
+fn shouldBeNotEmpty(x: AnEnumWithPayload) void {
+    switch (x) {
+        AnEnumWithPayload.Empty => unreachable,
+        else => {},
+    }
+}
+
+const AnEnumWithPayload = union(enum) {
+    Empty: void,
+    Full: i32,
+};
+
+const Number = enum { Zero, One, Two, Three, Four };
+
+fn shouldEqual(n: Number, expected: u3) !void {
+    try expect(@enumToInt(n) == expected);
+}
+
+test "int to enum" {
+    try testIntToEnumEval(3);
+}
+fn testIntToEnumEval(x: i32) !void {
+    try expect(@intToEnum(IntToEnumNumber, x) == IntToEnumNumber.Three);
+}
+const IntToEnumNumber = enum { Zero, One, Two, Three, Four };
+
+test "@tagName" {
+    try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
+    comptime try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
+}
+
+test "@tagName non-exhaustive enum" {
+    try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
+    comptime try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
+}
+
+fn testEnumTagNameBare(n: anytype) []const u8 {
+    return @tagName(n);
+}
+
+const BareNumber = enum { One, Two, Three };
+
+const NonExhaustive = enum(u8) { A, B, _ };
+
+test "enum alignment" {
+    comptime {
+        try expect(@alignOf(AlignTestEnum) >= @alignOf([9]u8));
+        try expect(@alignOf(AlignTestEnum) >= @alignOf(u64));
+    }
+}
+
+const AlignTestEnum = union(enum) {
+    A: [9]u8,
+    B: u64,
+};
+
+const ValueCount1 = enum {
+    I0,
+};
+const ValueCount2 = enum {
+    I0,
+    I1,
+};
+const ValueCount256 = enum {
+    I0,
+    I1,
+    I2,
+    I3,
+    I4,
+    I5,
+    I6,
+    I7,
+    I8,
+    I9,
+    I10,
+    I11,
+    I12,
+    I13,
+    I14,
+    I15,
+    I16,
+    I17,
+    I18,
+    I19,
+    I20,
+    I21,
+    I22,
+    I23,
+    I24,
+    I25,
+    I26,
+    I27,
+    I28,
+    I29,
+    I30,
+    I31,
+    I32,
+    I33,
+    I34,
+    I35,
+    I36,
+    I37,
+    I38,
+    I39,
+    I40,
+    I41,
+    I42,
+    I43,
+    I44,
+    I45,
+    I46,
+    I47,
+    I48,
+    I49,
+    I50,
+    I51,
+    I52,
+    I53,
+    I54,
+    I55,
+    I56,
+    I57,
+    I58,
+    I59,
+    I60,
+    I61,
+    I62,
+    I63,
+    I64,
+    I65,
+    I66,
+    I67,
+    I68,
+    I69,
+    I70,
+    I71,
+    I72,
+    I73,
+    I74,
+    I75,
+    I76,
+    I77,
+    I78,
+    I79,
+    I80,
+    I81,
+    I82,
+    I83,
+    I84,
+    I85,
+    I86,
+    I87,
+    I88,
+    I89,
+    I90,
+    I91,
+    I92,
+    I93,
+    I94,
+    I95,
+    I96,
+    I97,
+    I98,
+    I99,
+    I100,
+    I101,
+    I102,
+    I103,
+    I104,
+    I105,
+    I106,
+    I107,
+    I108,
+    I109,
+    I110,
+    I111,
+    I112,
+    I113,
+    I114,
+    I115,
+    I116,
+    I117,
+    I118,
+    I119,
+    I120,
+    I121,
+    I122,
+    I123,
+    I124,
+    I125,
+    I126,
+    I127,
+    I128,
+    I129,
+    I130,
+    I131,
+    I132,
+    I133,
+    I134,
+    I135,
+    I136,
+    I137,
+    I138,
+    I139,
+    I140,
+    I141,
+    I142,
+    I143,
+    I144,
+    I145,
+    I146,
+    I147,
+    I148,
+    I149,
+    I150,
+    I151,
+    I152,
+    I153,
+    I154,
+    I155,
+    I156,
+    I157,
+    I158,
+    I159,
+    I160,
+    I161,
+    I162,
+    I163,
+    I164,
+    I165,
+    I166,
+    I167,
+    I168,
+    I169,
+    I170,
+    I171,
+    I172,
+    I173,
+    I174,
+    I175,
+    I176,
+    I177,
+    I178,
+    I179,
+    I180,
+    I181,
+    I182,
+    I183,
+    I184,
+    I185,
+    I186,
+    I187,
+    I188,
+    I189,
+    I190,
+    I191,
+    I192,
+    I193,
+    I194,
+    I195,
+    I196,
+    I197,
+    I198,
+    I199,
+    I200,
+    I201,
+    I202,
+    I203,
+    I204,
+    I205,
+    I206,
+    I207,
+    I208,
+    I209,
+    I210,
+    I211,
+    I212,
+    I213,
+    I214,
+    I215,
+    I216,
+    I217,
+    I218,
+    I219,
+    I220,
+    I221,
+    I222,
+    I223,
+    I224,
+    I225,
+    I226,
+    I227,
+    I228,
+    I229,
+    I230,
+    I231,
+    I232,
+    I233,
+    I234,
+    I235,
+    I236,
+    I237,
+    I238,
+    I239,
+    I240,
+    I241,
+    I242,
+    I243,
+    I244,
+    I245,
+    I246,
+    I247,
+    I248,
+    I249,
+    I250,
+    I251,
+    I252,
+    I253,
+    I254,
+    I255,
+};
+const ValueCount257 = enum {
+    I0,
+    I1,
+    I2,
+    I3,
+    I4,
+    I5,
+    I6,
+    I7,
+    I8,
+    I9,
+    I10,
+    I11,
+    I12,
+    I13,
+    I14,
+    I15,
+    I16,
+    I17,
+    I18,
+    I19,
+    I20,
+    I21,
+    I22,
+    I23,
+    I24,
+    I25,
+    I26,
+    I27,
+    I28,
+    I29,
+    I30,
+    I31,
+    I32,
+    I33,
+    I34,
+    I35,
+    I36,
+    I37,
+    I38,
+    I39,
+    I40,
+    I41,
+    I42,
+    I43,
+    I44,
+    I45,
+    I46,
+    I47,
+    I48,
+    I49,
+    I50,
+    I51,
+    I52,
+    I53,
+    I54,
+    I55,
+    I56,
+    I57,
+    I58,
+    I59,
+    I60,
+    I61,
+    I62,
+    I63,
+    I64,
+    I65,
+    I66,
+    I67,
+    I68,
+    I69,
+    I70,
+    I71,
+    I72,
+    I73,
+    I74,
+    I75,
+    I76,
+    I77,
+    I78,
+    I79,
+    I80,
+    I81,
+    I82,
+    I83,
+    I84,
+    I85,
+    I86,
+    I87,
+    I88,
+    I89,
+    I90,
+    I91,
+    I92,
+    I93,
+    I94,
+    I95,
+    I96,
+    I97,
+    I98,
+    I99,
+    I100,
+    I101,
+    I102,
+    I103,
+    I104,
+    I105,
+    I106,
+    I107,
+    I108,
+    I109,
+    I110,
+    I111,
+    I112,
+    I113,
+    I114,
+    I115,
+    I116,
+    I117,
+    I118,
+    I119,
+    I120,
+    I121,
+    I122,
+    I123,
+    I124,
+    I125,
+    I126,
+    I127,
+    I128,
+    I129,
+    I130,
+    I131,
+    I132,
+    I133,
+    I134,
+    I135,
+    I136,
+    I137,
+    I138,
+    I139,
+    I140,
+    I141,
+    I142,
+    I143,
+    I144,
+    I145,
+    I146,
+    I147,
+    I148,
+    I149,
+    I150,
+    I151,
+    I152,
+    I153,
+    I154,
+    I155,
+    I156,
+    I157,
+    I158,
+    I159,
+    I160,
+    I161,
+    I162,
+    I163,
+    I164,
+    I165,
+    I166,
+    I167,
+    I168,
+    I169,
+    I170,
+    I171,
+    I172,
+    I173,
+    I174,
+    I175,
+    I176,
+    I177,
+    I178,
+    I179,
+    I180,
+    I181,
+    I182,
+    I183,
+    I184,
+    I185,
+    I186,
+    I187,
+    I188,
+    I189,
+    I190,
+    I191,
+    I192,
+    I193,
+    I194,
+    I195,
+    I196,
+    I197,
+    I198,
+    I199,
+    I200,
+    I201,
+    I202,
+    I203,
+    I204,
+    I205,
+    I206,
+    I207,
+    I208,
+    I209,
+    I210,
+    I211,
+    I212,
+    I213,
+    I214,
+    I215,
+    I216,
+    I217,
+    I218,
+    I219,
+    I220,
+    I221,
+    I222,
+    I223,
+    I224,
+    I225,
+    I226,
+    I227,
+    I228,
+    I229,
+    I230,
+    I231,
+    I232,
+    I233,
+    I234,
+    I235,
+    I236,
+    I237,
+    I238,
+    I239,
+    I240,
+    I241,
+    I242,
+    I243,
+    I244,
+    I245,
+    I246,
+    I247,
+    I248,
+    I249,
+    I250,
+    I251,
+    I252,
+    I253,
+    I254,
+    I255,
+    I256,
+};
+
+const Small2 = enum(u2) {
+    One,
+    Two,
+};
+const Small = enum(u2) {
+    One,
+    Two,
+    Three,
+    Four,
+};
+
+test "set enum tag type" {
+    {
+        var x = Small.One;
+        x = Small.Two;
+        comptime try expect(Tag(Small) == u2);
+    }
+    {
+        var x = Small2.One;
+        x = Small2.Two;
+        comptime try expect(Tag(Small2) == u2);
+    }
+}
+
+const A = enum(u3) { One, Two, Three, Four, One2, Two2, Three2, Four2 };
+const B = enum(u3) { One3, Two3, Three3, Four3, One23, Two23, Three23, Four23 };
+const C = enum(u2) { One4, Two4, Three4, Four4 };
+
+const BitFieldOfEnums = packed struct {
+    a: A,
+    b: B,
+    c: C,
+};
+
+const bit_field_1 = BitFieldOfEnums{
+    .a = A.Two,
+    .b = B.Three3,
+    .c = C.Four4,
+};
+
+test "bit field access with enum fields" {
+    var data = bit_field_1;
+    try expect(getA(&data) == A.Two);
+    try expect(getB(&data) == B.Three3);
+    try expect(getC(&data) == C.Four4);
+    comptime try expect(@sizeOf(BitFieldOfEnums) == 1);
+
+    data.b = B.Four3;
+    try expect(data.b == B.Four3);
+
+    data.a = A.Three;
+    try expect(data.a == A.Three);
+    try expect(data.b == B.Four3);
+}
+
+fn getA(data: *const BitFieldOfEnums) A {
+    return data.a;
+}
+
+fn getB(data: *const BitFieldOfEnums) B {
+    return data.b;
+}
+
+fn getC(data: *const BitFieldOfEnums) C {
+    return data.c;
+}
+
+test "casting enum to its tag type" {
+    try testCastEnumTag(Small2.Two);
+    comptime try testCastEnumTag(Small2.Two);
+}
+
+fn testCastEnumTag(value: Small2) !void {
+    try expect(@enumToInt(value) == 1);
+}
+
+const MultipleChoice = enum(u32) {
+    A = 20,
+    B = 40,
+    C = 60,
+    D = 1000,
+};
+
+test "enum with specified tag values" {
+    try testEnumWithSpecifiedTagValues(MultipleChoice.C);
+    comptime try testEnumWithSpecifiedTagValues(MultipleChoice.C);
+}
+
+fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void {
+    try expect(@enumToInt(x) == 60);
+    try expect(1234 == switch (x) {
+        MultipleChoice.A => 1,
+        MultipleChoice.B => 2,
+        MultipleChoice.C => @as(u32, 1234),
+        MultipleChoice.D => 4,
+    });
+}
+
+const MultipleChoice2 = enum(u32) {
+    Unspecified1,
+    A = 20,
+    Unspecified2,
+    B = 40,
+    Unspecified3,
+    C = 60,
+    Unspecified4,
+    D = 1000,
+    Unspecified5,
+};
+
+test "enum with specified and unspecified tag values" {
+    try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);
+    comptime try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);
+}
+
+fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void {
+    try expect(@enumToInt(x) == 1000);
+    try expect(1234 == switch (x) {
+        MultipleChoice2.A => 1,
+        MultipleChoice2.B => 2,
+        MultipleChoice2.C => 3,
+        MultipleChoice2.D => @as(u32, 1234),
+        MultipleChoice2.Unspecified1 => 5,
+        MultipleChoice2.Unspecified2 => 6,
+        MultipleChoice2.Unspecified3 => 7,
+        MultipleChoice2.Unspecified4 => 8,
+        MultipleChoice2.Unspecified5 => 9,
+    });
+}
+
+test "cast integer literal to enum" {
+    try expect(@intToEnum(MultipleChoice2, 0) == MultipleChoice2.Unspecified1);
+    try expect(@intToEnum(MultipleChoice2, 40) == MultipleChoice2.B);
+}
+
+const EnumWithOneMember = enum { Eof };
+
+fn doALoopThing(id: EnumWithOneMember) void {
+    while (true) {
+        if (id == EnumWithOneMember.Eof) {
+            break;
+        }
+        @compileError("above if condition should be comptime");
+    }
+}
+
+test "comparison operator on enum with one member is comptime known" {
+    doALoopThing(EnumWithOneMember.Eof);
+}
+
+const State = enum { Start };
+test "switch on enum with one member is comptime known" {
+    var state = State.Start;
+    switch (state) {
+        State.Start => return,
+    }
+    @compileError("analysis should not reach here");
+}
+
+const EnumWithTagValues = enum(u4) {
+    A = 1 << 0,
+    B = 1 << 1,
+    C = 1 << 2,
+    D = 1 << 3,
+};
+test "enum with tag values don't require parens" {
+    try expect(@enumToInt(EnumWithTagValues.C) == 0b0100);
+}
+
+test "enum with 1 field but explicit tag type should still have the tag type" {
+    const Enum = enum(u8) {
+        B = 2,
+    };
+    comptime try expect(@sizeOf(Enum) == @sizeOf(u8));
+}
+
+test "tag name with assigned enum values" {
+    const LocalFoo = enum(u8) {
+        A = 1,
+        B = 0,
+    };
+    var b = LocalFoo.B;
+    try expect(mem.eql(u8, @tagName(b), "B"));
+}
+
+test "enum literal in array literal" {
+    const Items = enum { one, two };
+    const array = [_]Items{ .one, .two };
+
+    try expect(array[0] == .one);
+    try expect(array[1] == .two);
+}
+
+test "signed integer as enum tag" {
+    const SignedEnum = enum(i2) {
+        A0 = -1,
+        A1 = 0,
+        A2 = 1,
+    };
+
+    try expect(@enumToInt(SignedEnum.A0) == -1);
+    try expect(@enumToInt(SignedEnum.A1) == 0);
+    try expect(@enumToInt(SignedEnum.A2) == 1);
+}
+
+test "enum value allocation" {
+    const LargeEnum = enum(u32) {
+        A0 = 0x80000000,
+        A1,
+        A2,
+    };
+
+    try expect(@enumToInt(LargeEnum.A0) == 0x80000000);
+    try expect(@enumToInt(LargeEnum.A1) == 0x80000001);
+    try expect(@enumToInt(LargeEnum.A2) == 0x80000002);
+}
+
+test "enum literal casting to tagged union" {
+    const Arch = union(enum) {
+        x86_64,
+        arm: Arm32,
+
+        const Arm32 = enum {
+            v8_5a,
+            v8_4a,
+        };
+    };
+
+    var t = true;
+    var x: Arch = .x86_64;
+    var y = if (t) x else .x86_64;
+    switch (y) {
+        .x86_64 => {},
+        else => @panic("fail"),
+    }
+}
+
+test "enum with one member and custom tag type" {
+    const E = enum(u2) {
+        One,
+    };
+    try expect(@enumToInt(E.One) == 0);
+    const E2 = enum(u2) {
+        One = 2,
+    };
+    try expect(@enumToInt(E2.One) == 2);
+}
+
+test "enum literal casting to optional" {
+    var bar: ?Bar = undefined;
+    bar = .B;
+
+    try expect(bar.? == Bar.B);
+}
+
+test "enum literal casting to error union with payload enum" {
+    var bar: error{B}!Bar = undefined;
+    bar = .B; // should never cast to the error set
+
+    try expect((try bar) == Bar.B);
+}
+
+test "enum with one member and u1 tag type @enumToInt" {
+    const Enum = enum(u1) {
+        Test,
+    };
+    try expect(@enumToInt(Enum.Test) == 0);
+}
+
+test "enum with comptime_int tag type" {
+    const Enum = enum(comptime_int) {
+        One = 3,
+        Two = 2,
+        Three = 1,
+    };
+    comptime try expect(Tag(Enum) == comptime_int);
+}
+
+test "enum with one member default to u0 tag type" {
+    const E0 = enum { X };
+    comptime try expect(Tag(E0) == u0);
+}
+
+test "tagName on enum literals" {
+    try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
+    comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
+}
+
+test "method call on an enum" {
+    const S = struct {
+        const E = enum {
+            one,
+            two,
+
+            fn method(self: *E) bool {
+                return self.* == .two;
+            }
+
+            fn generic_method(self: *E, foo: anytype) bool {
+                return self.* == .two and foo == bool;
+            }
+        };
+        fn doTheTest() !void {
+            var e = E.two;
+            try expect(e.method());
+            try expect(e.generic_method(bool));
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}