Sema: implement array coercion

4 files changed, 89 insertions, 89 deletions

diff --git a/test/behavior/array.zig b/test/behavior/array.zig
index 3ff339b140..c9c376be87 100644
--- a/test/behavior/array.zig
+++ b/test/behavior/array.zig
@@ -164,3 +164,53 @@ test "read/write through global variable array of struct fields initialized via
     };
     try S.doTheTest();
 }
+
+test "single-item pointer to array indexing and slicing" {
+    try testSingleItemPtrArrayIndexSlice();
+    comptime try testSingleItemPtrArrayIndexSlice();
+}
+
+fn testSingleItemPtrArrayIndexSlice() !void {
+    {
+        var array: [4]u8 = "aaaa".*;
+        doSomeMangling(&array);
+        try expect(mem.eql(u8, "azya", &array));
+    }
+    {
+        var array = "aaaa".*;
+        doSomeMangling(&array);
+        try expect(mem.eql(u8, "azya", &array));
+    }
+}
+
+fn doSomeMangling(array: *[4]u8) void {
+    array[1] = 'z';
+    array[2..3][0] = 'y';
+}
+
+test "implicit cast zero sized array ptr to slice" {
+    {
+        var b = "".*;
+        const c: []const u8 = &b;
+        try expect(c.len == 0);
+    }
+    {
+        var b: [0]u8 = "".*;
+        const c: []const u8 = &b;
+        try expect(c.len == 0);
+    }
+}
+
+test "anonymous list literal syntax" {
+    const S = struct {
+        fn doTheTest() !void {
+            var array: [4]u8 = .{ 1, 2, 3, 4 };
+            try expect(array[0] == 1);
+            try expect(array[1] == 2);
+            try expect(array[2] == 3);
+            try expect(array[3] == 4);
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}
diff --git a/test/behavior/array_stage1.zig b/test/behavior/array_stage1.zig
index b374c9dd06..771f08acb3 100644
--- a/test/behavior/array_stage1.zig
+++ b/test/behavior/array_stage1.zig
@@ -4,29 +4,6 @@ const mem = std.mem;
 const expect = testing.expect;
 const expectEqual = testing.expectEqual;
 
-test "single-item pointer to array indexing and slicing" {
-    try testSingleItemPtrArrayIndexSlice();
-    comptime try testSingleItemPtrArrayIndexSlice();
-}
-
-fn testSingleItemPtrArrayIndexSlice() !void {
-    {
-        var array: [4]u8 = "aaaa".*;
-        doSomeMangling(&array);
-        try expect(mem.eql(u8, "azya", &array));
-    }
-    {
-        var array = "aaaa".*;
-        doSomeMangling(&array);
-        try expect(mem.eql(u8, "azya", &array));
-    }
-}
-
-fn doSomeMangling(array: *[4]u8) void {
-    array[1] = 'z';
-    array[2..3][0] = 'y';
-}
-
 test "implicit cast single-item pointer" {
     try testImplicitCastSingleItemPtr();
     comptime try testImplicitCastSingleItemPtr();
@@ -136,33 +113,6 @@ test "double nested array to const slice cast in array literal" {
     comptime try S.entry(2);
 }
 
-test "implicit cast zero sized array ptr to slice" {
-    {
-        var b = "".*;
-        const c: []const u8 = &b;
-        try expect(c.len == 0);
-    }
-    {
-        var b: [0]u8 = "".*;
-        const c: []const u8 = &b;
-        try expect(c.len == 0);
-    }
-}
-
-test "anonymous list literal syntax" {
-    const S = struct {
-        fn doTheTest() !void {
-            var array: [4]u8 = .{ 1, 2, 3, 4 };
-            try expect(array[0] == 1);
-            try expect(array[1] == 2);
-            try expect(array[2] == 3);
-            try expect(array[3] == 4);
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}
-
 test "anonymous literal in array" {
     const S = struct {
         const Foo = struct {
diff --git a/test/behavior/struct_llvm.zig b/test/behavior/struct_llvm.zig
index 9b19abf030..36310d797b 100644
--- a/test/behavior/struct_llvm.zig
+++ b/test/behavior/struct_llvm.zig
@@ -246,3 +246,42 @@ test "packed struct with non-ABI-aligned field" {
     try expect(s.x == 1);
     try expect(s.y == 42);
 }
+
+const BitField1 = packed struct {
+    a: u3,
+    b: u3,
+    c: u2,
+};
+
+const bit_field_1 = BitField1{
+    .a = 1,
+    .b = 2,
+    .c = 3,
+};
+
+test "bit field access" {
+    var data = bit_field_1;
+    try expect(getA(&data) == 1);
+    try expect(getB(&data) == 2);
+    try expect(getC(&data) == 3);
+    comptime try expect(@sizeOf(BitField1) == 1);
+
+    data.b += 1;
+    try expect(data.b == 3);
+
+    data.a += 1;
+    try expect(data.a == 2);
+    try expect(data.b == 3);
+}
+
+fn getA(data: *const BitField1) u3 {
+    return data.a;
+}
+
+fn getB(data: *const BitField1) u3 {
+    return data.b;
+}
+
+fn getC(data: *const BitField1) u2 {
+    return data.c;
+}
diff --git a/test/behavior/struct_stage1.zig b/test/behavior/struct_stage1.zig
index ea076d5d24..66549d1767 100644
--- a/test/behavior/struct_stage1.zig
+++ b/test/behavior/struct_stage1.zig
@@ -6,45 +6,6 @@ const expectEqual = std.testing.expectEqual;
 const expectEqualSlices = std.testing.expectEqualSlices;
 const maxInt = std.math.maxInt;
 
-const BitField1 = packed struct {
-    a: u3,
-    b: u3,
-    c: u2,
-};
-
-const bit_field_1 = BitField1{
-    .a = 1,
-    .b = 2,
-    .c = 3,
-};
-
-test "bit field access" {
-    var data = bit_field_1;
-    try expect(getA(&data) == 1);
-    try expect(getB(&data) == 2);
-    try expect(getC(&data) == 3);
-    comptime try expect(@sizeOf(BitField1) == 1);
-
-    data.b += 1;
-    try expect(data.b == 3);
-
-    data.a += 1;
-    try expect(data.a == 2);
-    try expect(data.b == 3);
-}
-
-fn getA(data: *const BitField1) u3 {
-    return data.a;
-}
-
-fn getB(data: *const BitField1) u3 {
-    return data.b;
-}
-
-fn getC(data: *const BitField1) u2 {
-    return data.c;
-}
-
 const Foo32Bits = packed struct {
     field: u24,
     pad: u8,