Merge pull request #10679 from Luukdegram/wasm-unions

Stage2: wasm - Implement unions

18 files changed, 81 insertions, 18 deletions

diff --git a/test/behavior.zig b/test/behavior.zig
index 03e1c635f3..15fbe8038b 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -3,18 +3,34 @@ const builtin = @import("builtin");
 test {
     // Tests that pass for stage1, llvm backend, C backend, wasm backend, arm backend and x86_64 backend.
     _ = @import("behavior/align.zig");
+    _ = @import("behavior/alignof.zig");
     _ = @import("behavior/array.zig");
+    _ = @import("behavior/bit_shifting.zig");
     _ = @import("behavior/bool.zig");
+    _ = @import("behavior/bugs/394.zig");
     _ = @import("behavior/bugs/655.zig");
+    _ = @import("behavior/bugs/656.zig");
     _ = @import("behavior/bugs/679.zig");
     _ = @import("behavior/bugs/1111.zig");
+    _ = @import("behavior/bugs/1277.zig");
+    _ = @import("behavior/bugs/1310.zig");
+    _ = @import("behavior/bugs/1381.zig");
+    _ = @import("behavior/bugs/1500.zig");
+    _ = @import("behavior/bugs/1735.zig");
+    _ = @import("behavior/bugs/2006.zig");
     _ = @import("behavior/bugs/2346.zig");
+    _ = @import("behavior/bugs/3112.zig");
+    _ = @import("behavior/bugs/3367.zig");
     _ = @import("behavior/bugs/6850.zig");
+    _ = @import("behavior/bugs/7250.zig");
     _ = @import("behavior/cast.zig");
     _ = @import("behavior/comptime_memory.zig");
     _ = @import("behavior/fn_in_struct_in_comptime.zig");
+    _ = @import("behavior/generics_llvm.zig");
     _ = @import("behavior/hasdecl.zig");
     _ = @import("behavior/hasfield.zig");
+    _ = @import("behavior/namespace_depends_on_compile_var.zig");
+    _ = @import("behavior/optional_llvm.zig");
     _ = @import("behavior/prefetch.zig");
     _ = @import("behavior/pub_enum.zig");
     _ = @import("behavior/slice_sentinel_comptime.zig");
@@ -60,6 +76,7 @@ test {
         _ = @import("behavior/type_info.zig");
         _ = @import("behavior/undefined.zig");
         _ = @import("behavior/underscore.zig");
+        _ = @import("behavior/union.zig");
         _ = @import("behavior/usingnamespace.zig");
         _ = @import("behavior/void.zig");
         _ = @import("behavior/while.zig");
@@ -68,30 +85,16 @@ test {
             // Tests that pass for stage1, llvm backend, C backend
             _ = @import("behavior/cast_int.zig");
             _ = @import("behavior/int128.zig");
-            _ = @import("behavior/union.zig");
             _ = @import("behavior/translate_c_macros.zig");
 
             if (builtin.zig_backend != .stage2_c) {
                 // Tests that pass for stage1 and the llvm backend.
-                _ = @import("behavior/alignof.zig");
                 _ = @import("behavior/array_llvm.zig");
                 _ = @import("behavior/atomics.zig");
                 _ = @import("behavior/basic_llvm.zig");
-                _ = @import("behavior/bit_shifting.zig");
-                _ = @import("behavior/bugs/394.zig");
-                _ = @import("behavior/bugs/656.zig");
-                _ = @import("behavior/bugs/1277.zig");
-                _ = @import("behavior/bugs/1310.zig");
-                _ = @import("behavior/bugs/1381.zig");
-                _ = @import("behavior/bugs/1500.zig");
-                _ = @import("behavior/bugs/1735.zig");
                 _ = @import("behavior/bugs/1741.zig");
-                _ = @import("behavior/bugs/2006.zig");
                 _ = @import("behavior/bugs/2578.zig");
                 _ = @import("behavior/bugs/3007.zig");
-                _ = @import("behavior/bugs/3112.zig");
-                _ = @import("behavior/bugs/3367.zig");
-                _ = @import("behavior/bugs/7250.zig");
                 _ = @import("behavior/bugs/9584.zig");
                 _ = @import("behavior/cast_llvm.zig");
                 _ = @import("behavior/enum_llvm.zig");
@@ -99,13 +102,10 @@ test {
                 _ = @import("behavior/eval.zig");
                 _ = @import("behavior/floatop.zig");
                 _ = @import("behavior/fn.zig");
-                _ = @import("behavior/generics_llvm.zig");
                 _ = @import("behavior/math.zig");
                 _ = @import("behavior/maximum_minimum.zig");
                 _ = @import("behavior/merge_error_sets.zig");
-                _ = @import("behavior/namespace_depends_on_compile_var.zig");
                 _ = @import("behavior/null_llvm.zig");
-                _ = @import("behavior/optional_llvm.zig");
                 _ = @import("behavior/popcount.zig");
                 _ = @import("behavior/saturating_arithmetic.zig");
                 _ = @import("behavior/sizeof_and_typeof.zig");
diff --git a/test/behavior/alignof.zig b/test/behavior/alignof.zig
index 6109d84fe2..54e09877e1 100644
--- a/test/behavior/alignof.zig
+++ b/test/behavior/alignof.zig
@@ -11,6 +11,9 @@ const Foo = struct {
 };
 
 test "@alignOf(T) before referencing T" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     comptime try expect(@alignOf(Foo) != maxInt(usize));
     if (native_arch == .x86_64) {
         comptime try expect(@alignOf(Foo) == 4);
@@ -18,6 +21,9 @@ test "@alignOf(T) before referencing T" {
 }
 
 test "comparison of @alignOf(T) against zero" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     {
         const T = struct { x: u32 };
         try expect(!(@alignOf(T) == 0));
diff --git a/test/behavior/bit_shifting.zig b/test/behavior/bit_shifting.zig
index 0ac0ab965e..c0b2729bdf 100644
--- a/test/behavior/bit_shifting.zig
+++ b/test/behavior/bit_shifting.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const expect = std.testing.expect;
+const builtin = @import("builtin");
 
 fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime V: type) type {
     const key_bits = @typeInfo(Key).Int.bits;
@@ -60,6 +61,9 @@ fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, compt
 }
 
 test "sharded table" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     // realistic 16-way sharding
     try testShardedTable(u32, 4, 8);
 
diff --git a/test/behavior/bugs/1277.zig b/test/behavior/bugs/1277.zig
index 18e3592a80..f6d7b91928 100644
--- a/test/behavior/bugs/1277.zig
+++ b/test/behavior/bugs/1277.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
 const S = struct {
     f: ?fn () i32,
@@ -11,5 +12,7 @@ fn f() i32 {
 }
 
 test "don't emit an LLVM global for a const function when it's in an optional in a struct" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     try std.testing.expect(s.f.?() == 1234);
 }
diff --git a/test/behavior/bugs/1310.zig b/test/behavior/bugs/1310.zig
index 31911d5014..40845ddb03 100644
--- a/test/behavior/bugs/1310.zig
+++ b/test/behavior/bugs/1310.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const expect = std.testing.expect;
+const builtin = @import("builtin");
 
 pub const VM = ?[*]const struct_InvocationTable_;
 pub const struct_InvocationTable_ = extern struct {
@@ -22,5 +23,7 @@ fn agent_callback(_vm: [*]VM, options: [*]u8) callconv(.C) i32 {
 }
 
 test "fixed" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     try expect(agent_callback(undefined, undefined) == 11);
 }
diff --git a/test/behavior/bugs/1381.zig b/test/behavior/bugs/1381.zig
index 6a63e8cc5b..91a253af24 100644
--- a/test/behavior/bugs/1381.zig
+++ b/test/behavior/bugs/1381.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
 const B = union(enum) {
     D: u8,
@@ -11,6 +12,8 @@ const A = union(enum) {
 };
 
 test "union that needs padding bytes inside an array" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     var as = [_]A{
         A{ .B = B{ .D = 1 } },
         A{ .B = B{ .D = 1 } },
diff --git a/test/behavior/bugs/1500.zig b/test/behavior/bugs/1500.zig
index 18fd40cef2..d224bfcc4a 100644
--- a/test/behavior/bugs/1500.zig
+++ b/test/behavior/bugs/1500.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const A = struct {
     b: B,
 };
@@ -5,6 +6,9 @@ const A = struct {
 const B = *const fn (A) void;
 
 test "allow these dependencies" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     var a: A = undefined;
     var b: B = undefined;
     if (false) {
diff --git a/test/behavior/bugs/1735.zig b/test/behavior/bugs/1735.zig
index 1f6e3c99f4..c07bd9472b 100644
--- a/test/behavior/bugs/1735.zig
+++ b/test/behavior/bugs/1735.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
 const mystruct = struct {
     pending: ?listofstructs,
@@ -41,6 +42,9 @@ const a = struct {
 };
 
 test "initialization" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     var t = a.init();
     try std.testing.expect(t.foo.len == 0);
 }
diff --git a/test/behavior/bugs/2006.zig b/test/behavior/bugs/2006.zig
index bf9849abb2..15f74b4485 100644
--- a/test/behavior/bugs/2006.zig
+++ b/test/behavior/bugs/2006.zig
@@ -1,10 +1,14 @@
 const std = @import("std");
 const expect = std.testing.expect;
+const builtin = @import("builtin");
 
 const S = struct {
     p: *S,
 };
 test "bug 2006" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     var a: S = undefined;
     a = S{ .p = undefined };
     try expect(@sizeOf(S) != 0);
diff --git a/test/behavior/bugs/3112.zig b/test/behavior/bugs/3112.zig
index ea2197eef1..089f3e59f6 100644
--- a/test/behavior/bugs/3112.zig
+++ b/test/behavior/bugs/3112.zig
@@ -13,7 +13,9 @@ fn prev(p: ?State) void {
 
 test "zig test crash" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
-
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     var global: State = undefined;
     global.enter = prev;
     global.enter(null);
diff --git a/test/behavior/bugs/3367.zig b/test/behavior/bugs/3367.zig
index b77b979b8a..0607263f9a 100644
--- a/test/behavior/bugs/3367.zig
+++ b/test/behavior/bugs/3367.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const Foo = struct {
     usingnamespace Mixin;
 };
@@ -9,6 +10,9 @@ const Mixin = struct {
 };
 
 test "container member access usingnamespace decls" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     var foo = Foo{};
     foo.two();
 }
diff --git a/test/behavior/bugs/394.zig b/test/behavior/bugs/394.zig
index 55fec53ea1..ec1bd5cc9f 100644
--- a/test/behavior/bugs/394.zig
+++ b/test/behavior/bugs/394.zig
@@ -8,8 +8,11 @@ const S = struct {
 };
 
 const expect = @import("std").testing.expect;
+const builtin = @import("builtin");
 
 test "bug 394 fixed" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     const x = S{
         .x = 3,
         .y = E{ .B = 1 },
diff --git a/test/behavior/bugs/656.zig b/test/behavior/bugs/656.zig
index 178d655f93..bd93c2b88c 100644
--- a/test/behavior/bugs/656.zig
+++ b/test/behavior/bugs/656.zig
@@ -1,4 +1,5 @@
 const expect = @import("std").testing.expect;
+const builtin = @import("builtin");
 
 const PrefixOp = union(enum) {
     Return,
@@ -10,6 +11,8 @@ const Value = struct {
 };
 
 test "optional if after an if in a switch prong of a switch with 2 prongs in an else" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     try foo(false, true);
 }
 
diff --git a/test/behavior/bugs/7250.zig b/test/behavior/bugs/7250.zig
index 862b75f851..27810acea4 100644
--- a/test/behavior/bugs/7250.zig
+++ b/test/behavior/bugs/7250.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const nrfx_uart_t = extern struct {
     p_reg: [*c]u32,
     drv_inst_idx: u8,
@@ -13,5 +14,8 @@ threadlocal var g_uart0 = nrfx_uart_t{
 };
 
 test "reference a global threadlocal variable" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     _ = nrfx_uart_rx(&g_uart0);
 }
diff --git a/test/behavior/generics_llvm.zig b/test/behavior/generics_llvm.zig
index bb4c1b2ef4..b8a63d7dd0 100644
--- a/test/behavior/generics_llvm.zig
+++ b/test/behavior/generics_llvm.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const expect = std.testing.expect;
+const builtin = @import("builtin");
 
 const foos = [_]fn (anytype) bool{
     foo1,
@@ -14,11 +15,17 @@ fn foo2(arg: anytype) bool {
 }
 
 test "array of generic fns" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     try expect(foos[0](true));
     try expect(!foos[1](true));
 }
 
 test "generic struct" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     var a1 = GenNode(i32){
         .value = 13,
         .next = null,
diff --git a/test/behavior/namespace_depends_on_compile_var.zig b/test/behavior/namespace_depends_on_compile_var.zig
index 84b7e21d38..6b79df1a81 100644
--- a/test/behavior/namespace_depends_on_compile_var.zig
+++ b/test/behavior/namespace_depends_on_compile_var.zig
@@ -3,6 +3,9 @@ const builtin = @import("builtin");
 const expect = std.testing.expect;
 
 test "namespace depends on compile var" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (some_namespace.a_bool) {
         try expect(some_namespace.a_bool);
     } else {
diff --git a/test/behavior/optional_llvm.zig b/test/behavior/optional_llvm.zig
index d27c72dd1d..9fdf703a42 100644
--- a/test/behavior/optional_llvm.zig
+++ b/test/behavior/optional_llvm.zig
@@ -2,8 +2,12 @@ const std = @import("std");
 const testing = std.testing;
 const expect = testing.expect;
 const expectEqual = testing.expectEqual;
+const builtin = @import("builtin");
 
 test "self-referential struct through a slice of optional" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     const S = struct {
         const Node = struct {
             children: []?Node,
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 3136646df5..1b6d0ff9cb 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -362,6 +362,8 @@ pub const FooUnion = union(enum) {
 var glbl_array: [2]FooUnion = undefined;
 
 test "initialize global array of union" {
+    if (@import("builtin").zig_backend == .stage2_wasm) return error.SkipZigTest;
+
     glbl_array[1] = FooUnion{ .U1 = 2 };
     glbl_array[0] = FooUnion{ .U0 = 1 };
     try expect(glbl_array[0].U0 == 1);