behavior tests: disable failing stage1 test

My previous commit added a new behavior test that passes for stage2 but
I forgot to check whether it passes for stage1. Since it does not, it
has to be disabled.

Additionally, this commit organizes behavior tests; there is no longer a
section of tests only passing for stage1. Instead, tests are disabled on
an individual basis. There is an except for the file which has global
assembly in it.

test/behavior.zig

@@ -4,16 +4,17 @@ test {
     _ = @import("behavior/align.zig");
     _ = @import("behavior/alignof.zig");
     _ = @import("behavior/array.zig");
+    _ = @import("behavior/async_fn.zig");
     _ = @import("behavior/atomics.zig");
+    _ = @import("behavior/await_struct.zig");
     _ = @import("behavior/basic.zig");
     _ = @import("behavior/bit_shifting.zig");
     _ = @import("behavior/bitcast.zig");
     _ = @import("behavior/bitreverse.zig");
-    _ = @import("behavior/byteswap.zig");
-    _ = @import("behavior/byval_arg_var.zig");
     _ = @import("behavior/bool.zig");
     _ = @import("behavior/bugs/394.zig");
     _ = @import("behavior/bugs/421.zig");
+    _ = @import("behavior/bugs/529.zig");
     _ = @import("behavior/bugs/624.zig");
     _ = @import("behavior/bugs/655.zig");
     _ = @import("behavior/bugs/656.zig");
@@ -22,9 +23,11 @@ test {
     _ = @import("behavior/bugs/718.zig");
     _ = @import("behavior/bugs/726.zig");
     _ = @import("behavior/bugs/828.zig");
+    _ = @import("behavior/bugs/920.zig");
     _ = @import("behavior/bugs/1025.zig");
     _ = @import("behavior/bugs/1076.zig");
     _ = @import("behavior/bugs/1111.zig");
+    _ = @import("behavior/bugs/1120.zig");
     _ = @import("behavior/bugs/1277.zig");
     _ = @import("behavior/bugs/1310.zig");
     _ = @import("behavior/bugs/1381.zig");
@@ -61,8 +64,10 @@ test {
     _ = @import("behavior/bugs/5474.zig");
     _ = @import("behavior/bugs/5487.zig");
     _ = @import("behavior/bugs/6456.zig");
+    _ = @import("behavior/bugs/6781.zig");
     _ = @import("behavior/bugs/6850.zig");
     _ = @import("behavior/bugs/7003.zig");
+    _ = @import("behavior/bugs/7027.zig");
     _ = @import("behavior/bugs/7047.zig");
     _ = @import("behavior/bugs/7250.zig");
     _ = @import("behavior/bugs/9584.zig");
@@ -77,6 +82,8 @@ test {
     _ = @import("behavior/bugs/11181.zig");
     _ = @import("behavior/bugs/11182.zig");
     _ = @import("behavior/bugs/11213.zig");
+    _ = @import("behavior/byteswap.zig");
+    _ = @import("behavior/byval_arg_var.zig");
     _ = @import("behavior/call.zig");
     _ = @import("behavior/cast.zig");
     _ = @import("behavior/cast_int.zig");
@@ -88,9 +95,9 @@ test {
     _ = @import("behavior/eval.zig");
     _ = @import("behavior/field_parent_ptr.zig");
     _ = @import("behavior/floatop.zig");
+    _ = @import("behavior/fn.zig");
     _ = @import("behavior/fn_delegation.zig");
     _ = @import("behavior/fn_in_struct_in_comptime.zig");
-    _ = @import("behavior/fn.zig");
     _ = @import("behavior/for.zig");
     _ = @import("behavior/generics.zig");
     _ = @import("behavior/hasdecl.zig");
@@ -118,6 +125,7 @@ test {
     _ = @import("behavior/ref_var_in_if_after_if_2nd_switch_prong.zig");
     _ = @import("behavior/reflection.zig");
     _ = @import("behavior/saturating_arithmetic.zig");
+    _ = @import("behavior/select.zig");
     _ = @import("behavior/shuffle.zig");
     _ = @import("behavior/sizeof_and_typeof.zig");
     _ = @import("behavior/slice.zig");
@@ -156,6 +164,13 @@ test {
         _ = @import("behavior/decltest.zig");
     }
 
+    if (builtin.os.tag != .wasi) {
+        if (builtin.zig_backend == .stage1) {
+            // TODO get these tests passing with stage2
+            _ = @import("behavior/asm.zig");
+        }
+    }
+
     if (builtin.zig_backend != .stage2_arm and
         builtin.zig_backend != .stage2_x86_64 and
         builtin.zig_backend != .stage2_aarch64 and
@@ -166,19 +181,4 @@ test {
         _ = @import("behavior/export.zig");
         _ = @import("behavior/export_self_referential_type_info.zig");
     }
-
-    if (builtin.zig_backend == .stage1) {
-        // TODO get these tests passing with stage2
-        if (builtin.os.tag != .wasi) {
-            _ = @import("behavior/asm.zig");
-            _ = @import("behavior/async_fn.zig");
-        }
-        _ = @import("behavior/await_struct.zig");
-        _ = @import("behavior/bugs/529.zig");
-        _ = @import("behavior/bugs/920.zig");
-        _ = @import("behavior/bugs/1120.zig");
-        _ = @import("behavior/bugs/6781.zig");
-        _ = @import("behavior/bugs/7027.zig");
-        _ = @import("behavior/select.zig");
-    }
 }

test/behavior/async_fn.zig

@@ -8,6 +8,9 @@ const expectError = std.testing.expectError;
 var global_x: i32 = 1;
 
 test "simple coroutine suspend and resume" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     var frame = async simpleAsyncFn();
     try expect(global_x == 2);
     resume frame;
@@ -28,6 +31,9 @@ fn simpleAsyncFn() void {
 var global_y: i32 = 1;
 
 test "pass parameter to coroutine" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     var p = async simpleAsyncFnWithArg(2);
     try expect(global_y == 3);
     resume p;
@@ -40,6 +46,9 @@ fn simpleAsyncFnWithArg(delta: i32) void {
 }
 
 test "suspend at end of function" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var x: i32 = 1;
 
@@ -59,6 +68,9 @@ test "suspend at end of function" {
 }
 
 test "local variable in async function" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var x: i32 = 0;
 
@@ -88,6 +100,9 @@ test "local variable in async function" {
 }
 
 test "calling an inferred async function" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var x: i32 = 1;
         var other_frame: *@Frame(other) = undefined;
@@ -112,6 +127,9 @@ test "calling an inferred async function" {
 }
 
 test "@frameSize" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     if (builtin.target.cpu.arch == .thumb or builtin.target.cpu.arch == .thumbeb)
         return error.SkipZigTest;
 
@@ -143,6 +161,9 @@ test "@frameSize" {
 }
 
 test "coroutine suspend, resume" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var frame: anyframe = undefined;
 
@@ -184,6 +205,9 @@ test "coroutine suspend, resume" {
 }
 
 test "coroutine suspend with block" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const p = async testSuspendBlock();
     _ = p;
     try expect(!global_result);
@@ -210,6 +234,9 @@ var await_a_promise: anyframe = undefined;
 var await_final_result: i32 = 0;
 
 test "coroutine await" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     await_seq('a');
     var p = async await_amain();
     _ = p;
@@ -247,6 +274,9 @@ fn await_seq(c: u8) void {
 var early_final_result: i32 = 0;
 
 test "coroutine await early return" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     early_seq('a');
     var p = async early_amain();
     _ = p;
@@ -275,6 +305,9 @@ fn early_seq(c: u8) void {
 }
 
 test "async function with dot syntax" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var y: i32 = 1;
         fn foo() callconv(.Async) void {
@@ -288,6 +321,9 @@ test "async function with dot syntax" {
 }
 
 test "async fn pointer in a struct field" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     var data: i32 = 1;
     const Foo = struct {
         bar: fn (*i32) callconv(.Async) void,
@@ -313,6 +349,9 @@ fn simpleAsyncFn2(y: *i32) callconv(.Async) void {
 }
 
 test "@asyncCall with return type" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const Foo = struct {
         bar: fn () callconv(.Async) i32,
 
@@ -337,6 +376,9 @@ test "@asyncCall with return type" {
 }
 
 test "async fn with inferred error set" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
 
@@ -367,6 +409,9 @@ test "async fn with inferred error set" {
 }
 
 test "error return trace across suspend points - early return" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const p = nonFailing();
     resume p;
     const p2 = async printTrace(p);
@@ -374,6 +419,9 @@ test "error return trace across suspend points - early return" {
 }
 
 test "error return trace across suspend points - async return" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const p = nonFailing();
     const p2 = async printTrace(p);
     _ = p2;
@@ -404,6 +452,9 @@ fn printTrace(p: anyframe->(anyerror!void)) callconv(.Async) void {
 }
 
 test "break from suspend" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     var my_result: i32 = 1;
     const p = async testBreakFromSuspend(&my_result);
     _ = p;
@@ -419,6 +470,9 @@ fn testBreakFromSuspend(my_result: *i32) callconv(.Async) void {
 }
 
 test "heap allocated async function frame" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var x: i32 = 42;
 
@@ -443,6 +497,9 @@ test "heap allocated async function frame" {
 }
 
 test "async function call return value" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var frame: anyframe = undefined;
         var pt = Point{ .x = 10, .y = 11 };
@@ -484,6 +541,9 @@ test "async function call return value" {
 }
 
 test "suspension points inside branching control flow" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var result: i32 = 10;
 
@@ -510,6 +570,9 @@ test "suspension points inside branching control flow" {
 }
 
 test "call async function which has struct return type" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var frame: anyframe = undefined;
 
@@ -543,6 +606,9 @@ test "call async function which has struct return type" {
 }
 
 test "pass string literal to async function" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var frame: anyframe = undefined;
         var ok: bool = false;
@@ -564,6 +630,9 @@ test "pass string literal to async function" {
 }
 
 test "await inside an errdefer" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var frame: anyframe = undefined;
 
@@ -587,6 +656,9 @@ test "await inside an errdefer" {
 }
 
 test "try in an async function with error union and non-zero-bit payload" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var frame: anyframe = undefined;
         var ok = false;
@@ -617,6 +689,9 @@ test "try in an async function with error union and non-zero-bit payload" {
 }
 
 test "returning a const error from async function" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var frame: anyframe = undefined;
         var ok = false;
@@ -648,6 +723,9 @@ test "returning a const error from async function" {
 }
 
 test "async/await typical usage" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     inline for ([_]bool{ false, true }) |b1| {
         inline for ([_]bool{ false, true }) |b2| {
             inline for ([_]bool{ false, true }) |b3| {
@@ -743,6 +821,9 @@ fn testAsyncAwaitTypicalUsage(
 }
 
 test "alignment of local variables in async functions" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var y: u8 = 123;
@@ -755,6 +836,9 @@ test "alignment of local variables in async functions" {
 }
 
 test "no reason to resolve frame still works" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     _ = async simpleNothing();
 }
 fn simpleNothing() void {
@@ -763,6 +847,9 @@ fn simpleNothing() void {
 }
 
 test "async call a generic function" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var f = async func(i32, 2);
@@ -783,6 +870,9 @@ test "async call a generic function" {
 }
 
 test "return from suspend block" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             expect(func() == 1234) catch @panic("test failure");
@@ -797,6 +887,9 @@ test "return from suspend block" {
 }
 
 test "struct parameter to async function is copied to the frame" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         const Point = struct {
             x: i32,
@@ -841,6 +934,9 @@ test "struct parameter to async function is copied to the frame" {
 }
 
 test "cast fn to async fn when it is inferred to be async" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var frame: anyframe = undefined;
         var ok = false;
@@ -869,6 +965,9 @@ test "cast fn to async fn when it is inferred to be async" {
 }
 
 test "cast fn to async fn when it is inferred to be async, awaited directly" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var frame: anyframe = undefined;
         var ok = false;
@@ -896,6 +995,9 @@ test "cast fn to async fn when it is inferred to be async, awaited directly" {
 }
 
 test "await does not force async if callee is blocking" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn simple() i32 {
             return 1234;
@@ -906,6 +1008,9 @@ test "await does not force async if callee is blocking" {
 }
 
 test "recursive async function" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     try expect(recursiveAsyncFunctionTest(false).doTheTest() == 55);
     try expect(recursiveAsyncFunctionTest(true).doTheTest() == 55);
 }
@@ -968,6 +1073,9 @@ fn recursiveAsyncFunctionTest(comptime suspending_implementation: bool) type {
 }
 
 test "@asyncCall with comptime-known function, but not awaited directly" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
 
@@ -997,6 +1105,9 @@ test "@asyncCall with comptime-known function, but not awaited directly" {
 }
 
 test "@asyncCall with actual frame instead of byte buffer" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn func() i32 {
             suspend {}
@@ -1011,6 +1122,9 @@ test "@asyncCall with actual frame instead of byte buffer" {
 }
 
 test "@asyncCall using the result location inside the frame" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn simple2(y: *i32) callconv(.Async) i32 {
             defer y.* += 2;
@@ -1038,6 +1152,9 @@ test "@asyncCall using the result location inside the frame" {
 }
 
 test "@TypeOf an async function call of generic fn with error union type" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn func(comptime x: anytype) anyerror!i32 {
             const T = @TypeOf(async func(x));
@@ -1049,6 +1166,9 @@ test "@TypeOf an async function call of generic fn with error union type" {
 }
 
 test "using @TypeOf on a generic function call" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
         var global_ok = false;
@@ -1074,6 +1194,9 @@ test "using @TypeOf on a generic function call" {
 }
 
 test "recursive call of await @asyncCall with struct return type" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
         var global_ok = false;
@@ -1110,6 +1233,9 @@ test "recursive call of await @asyncCall with struct return type" {
 }
 
 test "nosuspend function call" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             const result = nosuspend add(50, 100);
@@ -1126,6 +1252,9 @@ test "nosuspend function call" {
 }
 
 test "await used in expression and awaiting fn with no suspend but async calling convention" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn atest() void {
             var f1 = async add(1, 2);
@@ -1142,6 +1271,9 @@ test "await used in expression and awaiting fn with no suspend but async calling
 }
 
 test "await used in expression after a fn call" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn atest() void {
             var f1 = async add(3, 4);
@@ -1160,6 +1292,9 @@ test "await used in expression after a fn call" {
 }
 
 test "async fn call used in expression after a fn call" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn atest() void {
             var sum: i32 = 0;
@@ -1177,6 +1312,9 @@ test "async fn call used in expression after a fn call" {
 }
 
 test "suspend in for loop" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: ?anyframe = null;
 
@@ -1203,6 +1341,9 @@ test "suspend in for loop" {
 }
 
 test "suspend in while loop" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: ?anyframe = null;
 
@@ -1240,6 +1381,9 @@ test "suspend in while loop" {
 }
 
 test "correctly spill when returning the error union result of another async fn" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
 
@@ -1263,6 +1407,9 @@ test "correctly spill when returning the error union result of another async fn"
 }
 
 test "spill target expr in a for loop" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
 
@@ -1294,6 +1441,9 @@ test "spill target expr in a for loop" {
 }
 
 test "spill target expr in a for loop, with a var decl in the loop body" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
 
@@ -1330,6 +1480,9 @@ test "spill target expr in a for loop, with a var decl in the loop body" {
 }
 
 test "async call with @call" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
         fn doTheTest() void {
@@ -1352,6 +1505,9 @@ test "async call with @call" {
 }
 
 test "async function passed 0-bit arg after non-0-bit arg" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
         var global_int: i32 = 0;
@@ -1373,6 +1529,9 @@ test "async function passed 0-bit arg after non-0-bit arg" {
 }
 
 test "async function passed align(16) arg after align(8) arg" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
         var global_int: u128 = 0;
@@ -1395,6 +1554,9 @@ test "async function passed align(16) arg after align(8) arg" {
 }
 
 test "async function call resolves target fn frame, comptime func" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
         var global_int: i32 = 9;
@@ -1417,6 +1579,9 @@ test "async function call resolves target fn frame, comptime func" {
 }
 
 test "async function call resolves target fn frame, runtime func" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
         var global_int: i32 = 9;
@@ -1440,6 +1605,9 @@ test "async function call resolves target fn frame, runtime func" {
 }
 
 test "properly spill optional payload capture value" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
         var global_int: usize = 2;
@@ -1464,6 +1632,9 @@ test "properly spill optional payload capture value" {
 }
 
 test "handle defer interfering with return value spill" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame1: anyframe = undefined;
         var global_frame2: anyframe = undefined;
@@ -1504,6 +1675,9 @@ test "handle defer interfering with return value spill" {
 }
 
 test "take address of temporary async frame" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var global_frame: anyframe = undefined;
         var finished = false;
@@ -1533,6 +1707,9 @@ test "take address of temporary async frame" {
 }
 
 test "nosuspend await" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var finished = false;
 
@@ -1554,6 +1731,9 @@ test "nosuspend await" {
 }
 
 test "nosuspend on function calls" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S0 = struct {
         b: i32 = 42,
     };
@@ -1570,6 +1750,9 @@ test "nosuspend on function calls" {
 }
 
 test "nosuspend on async function calls" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S0 = struct {
         b: i32 = 42,
     };
@@ -1588,6 +1771,7 @@ test "nosuspend on async function calls" {
 }
 
 // test "resume nosuspend async function calls" {
+// if (builtin.zig_backend != .stage1) return error.SkipZigTest; // if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
 //     const S0 = struct {
 //         b: i32 = 42,
 //     };
@@ -1610,6 +1794,9 @@ test "nosuspend on async function calls" {
 // }
 
 test "nosuspend resume async function calls" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S0 = struct {
         b: i32 = 42,
     };
@@ -1632,6 +1819,9 @@ test "nosuspend resume async function calls" {
 }
 
 test "avoid forcing frame alignment resolution implicit cast to *anyopaque" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const S = struct {
         var x: ?*anyopaque = null;
 
@@ -1648,6 +1838,9 @@ test "avoid forcing frame alignment resolution implicit cast to *anyopaque" {
 }
 
 test "@asyncCall with pass-by-value arguments" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const F0: u64 = 0xbeefbeefbeefbeef;
     const F1: u64 = 0xf00df00df00df00d;
     const F2: u64 = 0xcafecafecafecafe;
@@ -1681,6 +1874,9 @@ test "@asyncCall with pass-by-value arguments" {
 }
 
 test "@asyncCall with arguments having non-standard alignment" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest; // TODO
+
     const F0: u64 = 0xbeefbeef;
     const F1: u64 = 0xf00df00df00df00d;
 

test/behavior/await_struct.zig

@@ -10,6 +10,8 @@ var await_a_promise: anyframe = undefined;
 var await_final_result = Foo{ .x = 0 };
 
 test "coroutine await struct" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+
     await_seq('a');
     var p = async await_amain();
     _ = p;

test/behavior/bugs/1120.zig

@@ -11,6 +11,8 @@ const B = packed struct {
     b: u6,
 };
 test "bug 1120" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
+
     var a = A{ .a = 2, .b = 2 };
     var b = B{ .q = 22, .a = 3, .b = 2 };
     var t: usize = 0;

test/behavior/bugs/529.zig

@@ -9,6 +9,8 @@ comptime {
 }
 
 test "issue 529 fixed" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
+
     @import("529_other_file.zig").issue529(null);
     issue529(null);
 }

test/behavior/bugs/6781.zig

@@ -61,6 +61,8 @@ pub const JournalHeader = packed struct {
 };
 
 test "fixed" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
+
     var buffer = [_]u8{0} ** 65536;
     var entry = std.mem.bytesAsValue(JournalHeader, buffer[0..@sizeOf(JournalHeader)]);
     entry.* = .{

test/behavior/bugs/7027.zig

@@ -13,7 +13,9 @@ fn foo(arg: anytype) void {
     _ = arg;
 }
 
-test "" {
+test {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
+
     comptime var foobar = Foobar.foo();
     foo(foobar.str[0..10]);
 }

test/behavior/bugs/920.zig

@@ -57,6 +57,8 @@ const NormalDist = blk: {
 };
 
 test "bug 920 fixed" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
+
     const NormalDist1 = blk: {
         break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);
     };

test/behavior/eval.zig

@@ -833,6 +833,8 @@ test "const type-annotated local initialized with function call has correct type
 }
 
 test "comptime pointer load through elem_ptr" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 fails this test
+
     const S = struct {
         x: usize,
     };

test/behavior/select.zig

@@ -2,20 +2,21 @@ const std = @import("std");
 const builtin = @import("builtin");
 const mem = std.mem;
 const expect = std.testing.expect;
-const Vector = std.meta.Vector;
 
 test "@select" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
-            var a: Vector(4, bool) = [4]bool{ true, false, true, false };
-            var b: Vector(4, i32) = [4]i32{ -1, 4, 999, -31 };
-            var c: Vector(4, i32) = [4]i32{ -5, 1, 0, 1234 };
+            var a: @Vector(4, bool) = [4]bool{ true, false, true, false };
+            var b: @Vector(4, i32) = [4]i32{ -1, 4, 999, -31 };
+            var c: @Vector(4, i32) = [4]i32{ -5, 1, 0, 1234 };
             var abc = @select(i32, a, b, c);
             try expect(mem.eql(i32, &@as([4]i32, abc), &[4]i32{ -1, 1, 999, 1234 }));
 
-            var x: Vector(4, bool) = [4]bool{ false, false, false, true };
-            var y: Vector(4, f32) = [4]f32{ 0.001, 33.4, 836, -3381.233 };
-            var z: Vector(4, f32) = [4]f32{ 0.0, 312.1, -145.9, 9993.55 };
+            var x: @Vector(4, bool) = [4]bool{ false, false, false, true };
+            var y: @Vector(4, f32) = [4]f32{ 0.001, 33.4, 836, -3381.233 };
+            var z: @Vector(4, f32) = [4]f32{ 0.0, 312.1, -145.9, 9993.55 };
             var xyz = @select(f32, x, y, z);
             try expect(mem.eql(f32, &@as([4]f32, xyz), &[4]f32{ 0.0, 312.1, -145.9, -3381.233 }));
         }