behavior tests: alter test coverage for vectors

 * Use `@Vector` syntax instead of `std.meta.Vector`.
 * Use `var` instead of `const` for tests so that we get runtime
   coverage instead of only comptime coverage. Comptime coverage is done
   with `comptime doTheTest()` calls.

1 files changed, 58 insertions, 59 deletions

diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index 1d8dd9f661..1651e8107b 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -3,7 +3,6 @@ const builtin = @import("builtin");
 const mem = std.mem;
 const math = std.math;
 const expect = std.testing.expect;
-const Vector = std.meta.Vector;
 
 test "implicit cast vector to array - bool" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
@@ -14,7 +13,7 @@ test "implicit cast vector to array - bool" {
 
     const S = struct {
         fn doTheTest() !void {
-            const a: Vector(4, bool) = [_]bool{ true, false, true, false };
+            const a: @Vector(4, bool) = [_]bool{ true, false, true, false };
             const result_array: [4]bool = a;
             try expect(mem.eql(bool, &result_array, &[4]bool{ true, false, true, false }));
         }
@@ -32,12 +31,12 @@ test "vector wrap operators" {
 
     const S = struct {
         fn doTheTest() !void {
-            var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
-            var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
+            var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
+            var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
             try expect(mem.eql(i32, &@as([4]i32, v +% x), &[4]i32{ -2147483648, 2147483645, 33, 44 }));
             try expect(mem.eql(i32, &@as([4]i32, v -% x), &[4]i32{ 2147483646, 2147483647, 27, 36 }));
             try expect(mem.eql(i32, &@as([4]i32, v *% x), &[4]i32{ 2147483647, 2, 90, 160 }));
-            var z: Vector(4, i32) = [4]i32{ 1, 2, 3, -2147483648 };
+            var z: @Vector(4, i32) = [4]i32{ 1, 2, 3, -2147483648 };
             try expect(mem.eql(i32, &@as([4]i32, -%z), &[4]i32{ -1, -2, -3, -2147483648 }));
         }
     };
@@ -54,8 +53,8 @@ test "vector bin compares with mem.eql" {
 
     const S = struct {
         fn doTheTest() !void {
-            var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
-            var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 30, 4 };
+            var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
+            var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 30, 4 };
             try expect(mem.eql(bool, &@as([4]bool, v == x), &[4]bool{ false, false, true, false }));
             try expect(mem.eql(bool, &@as([4]bool, v != x), &[4]bool{ true, true, false, true }));
             try expect(mem.eql(bool, &@as([4]bool, v < x), &[4]bool{ false, true, false, false }));
@@ -77,8 +76,8 @@ test "vector int operators" {
 
     const S = struct {
         fn doTheTest() !void {
-            var v: Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
-            var x: Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };
+            var v: @Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
+            var x: @Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };
             try expect(mem.eql(i32, &@as([4]i32, v + x), &[4]i32{ 11, 22, 33, 44 }));
             try expect(mem.eql(i32, &@as([4]i32, v - x), &[4]i32{ 9, 18, 27, 36 }));
             try expect(mem.eql(i32, &@as([4]i32, v * x), &[4]i32{ 10, 40, 90, 160 }));
@@ -98,8 +97,8 @@ test "vector float operators" {
 
     const S = struct {
         fn doTheTest() !void {
-            var v: Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
-            var x: Vector(4, f32) = [4]f32{ 1, 2, 3, 4 };
+            var v: @Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
+            var x: @Vector(4, f32) = [4]f32{ 1, 2, 3, 4 };
             try expect(mem.eql(f32, &@as([4]f32, v + x), &[4]f32{ 11, 22, 33, 44 }));
             try expect(mem.eql(f32, &@as([4]f32, v - x), &[4]f32{ 9, 18, 27, 36 }));
             try expect(mem.eql(f32, &@as([4]f32, v * x), &[4]f32{ 10, 40, 90, 160 }));
@@ -119,8 +118,8 @@ test "vector bit operators" {
 
     const S = struct {
         fn doTheTest() !void {
-            var v: Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
-            var x: Vector(4, u8) = [4]u8{ 0b11110000, 0b00001111, 0b10101010, 0b01010101 };
+            var v: @Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
+            var x: @Vector(4, u8) = [4]u8{ 0b11110000, 0b00001111, 0b10101010, 0b01010101 };
             try expect(mem.eql(u8, &@as([4]u8, v ^ x), &[4]u8{ 0b01011010, 0b10100101, 0b00000000, 0b11111111 }));
             try expect(mem.eql(u8, &@as([4]u8, v | x), &[4]u8{ 0b11111010, 0b10101111, 0b10101010, 0b11111111 }));
             try expect(mem.eql(u8, &@as([4]u8, v & x), &[4]u8{ 0b10100000, 0b00001010, 0b10101010, 0b00000000 }));
@@ -139,7 +138,7 @@ test "implicit cast vector to array" {
 
     const S = struct {
         fn doTheTest() !void {
-            var a: Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
+            var a: @Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
             var result_array: [4]i32 = a;
             result_array = a;
             try expect(mem.eql(i32, &result_array, &[4]i32{ 1, 2, 3, 4 }));
@@ -160,7 +159,7 @@ test "array to vector" {
         fn doTheTest() !void {
             var foo: f32 = 3.14;
             var arr = [4]f32{ foo, 1.5, 0.0, 0.0 };
-            var vec: Vector(4, f32) = arr;
+            var vec: @Vector(4, f32) = arr;
             try expect(mem.eql(f32, &@as([4]f32, vec), &arr));
         }
     };
@@ -178,22 +177,22 @@ test "vector casts of sizes not divisible by 8" {
     const S = struct {
         fn doTheTest() !void {
             {
-                var v: Vector(4, u3) = [4]u3{ 5, 2, 3, 0 };
+                var v: @Vector(4, u3) = [4]u3{ 5, 2, 3, 0 };
                 var x: [4]u3 = v;
                 try expect(mem.eql(u3, &x, &@as([4]u3, v)));
             }
             {
-                var v: Vector(4, u2) = [4]u2{ 1, 2, 3, 0 };
+                var v: @Vector(4, u2) = [4]u2{ 1, 2, 3, 0 };
                 var x: [4]u2 = v;
                 try expect(mem.eql(u2, &x, &@as([4]u2, v)));
             }
             {
-                var v: Vector(4, u1) = [4]u1{ 1, 0, 1, 0 };
+                var v: @Vector(4, u1) = [4]u1{ 1, 0, 1, 0 };
                 var x: [4]u1 = v;
                 try expect(mem.eql(u1, &x, &@as([4]u1, v)));
             }
             {
-                var v: Vector(4, bool) = [4]bool{ false, false, true, false };
+                var v: @Vector(4, bool) = [4]bool{ false, false, true, false };
                 var x: [4]bool = v;
                 try expect(mem.eql(bool, &x, &@as([4]bool, v)));
             }
@@ -214,7 +213,7 @@ test "vector @splat" {
         fn testForT(comptime N: comptime_int, v: anytype) !void {
             const T = @TypeOf(v);
             var vec = @splat(N, v);
-            try expect(Vector(N, T) == @TypeOf(vec));
+            try expect(@Vector(N, T) == @TypeOf(vec));
             var as_array = @as([N]T, vec);
             for (as_array) |elem| try expect(v == elem);
         }
@@ -253,7 +252,7 @@ test "load vector elements via comptime index" {
 
     const S = struct {
         fn doTheTest() !void {
-            var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
+            var v: @Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
             try expect(v[0] == 1);
             try expect(v[1] == 2);
             try expect(loadv(&v[2]) == 3);
@@ -276,7 +275,7 @@ test "store vector elements via comptime index" {
 
     const S = struct {
         fn doTheTest() !void {
-            var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
+            var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
 
             v[2] = 42;
             try expect(v[1] == 5);
@@ -305,7 +304,7 @@ test "load vector elements via runtime index" {
 
     const S = struct {
         fn doTheTest() !void {
-            var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
+            var v: @Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
             var i: u32 = 0;
             try expect(v[i] == 1);
             i += 1;
@@ -328,7 +327,7 @@ test "store vector elements via runtime index" {
 
     const S = struct {
         fn doTheTest() !void {
-            var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
+            var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
             var i: u32 = 2;
             v[i] = 1;
             try expect(v[1] == 5);
@@ -351,7 +350,7 @@ test "initialize vector which is a struct field" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const Vec4Obj = struct {
-        data: Vector(4, f32),
+        data: @Vector(4, f32),
     };
 
     const S = struct {
@@ -376,17 +375,17 @@ test "vector comparison operators" {
     const S = struct {
         fn doTheTest() !void {
             {
-                const v1: Vector(4, bool) = [_]bool{ true, false, true, false };
-                const v2: Vector(4, bool) = [_]bool{ false, true, false, true };
+                var v1: @Vector(4, bool) = [_]bool{ true, false, true, false };
+                var v2: @Vector(4, bool) = [_]bool{ false, true, false, true };
                 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v1)));
                 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v2)));
                 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v2)));
                 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v2 != v2)));
             }
             {
-                const v1 = @splat(4, @as(u32, 0xc0ffeeee));
-                const v2: Vector(4, c_uint) = v1;
-                const v3 = @splat(4, @as(u32, 0xdeadbeef));
+                var v1 = @splat(4, @as(u32, 0xc0ffeeee));
+                var v2: @Vector(4, c_uint) = v1;
+                var v3 = @splat(4, @as(u32, 0xdeadbeef));
                 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v2)));
                 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v3)));
                 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v3)));
@@ -414,7 +413,7 @@ test "vector division operators" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const S = struct {
-        fn doTheTestDiv(comptime T: type, x: Vector(4, T), y: Vector(4, T)) !void {
+        fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void {
             if (!comptime std.meta.trait.isSignedInt(T)) {
                 const d0 = x / y;
                 for (@as([4]T, d0)) |v, i| {
@@ -435,7 +434,7 @@ test "vector division operators" {
             }
         }
 
-        fn doTheTestMod(comptime T: type, x: Vector(4, T), y: Vector(4, T)) !void {
+        fn doTheTestMod(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void {
             if ((!comptime std.meta.trait.isSignedInt(T)) and @typeInfo(T) != .Float) {
                 const r0 = x % y;
                 for (@as([4]T, r0)) |v, i| {
@@ -502,7 +501,7 @@ test "vector bitwise not operator" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const S = struct {
-        fn doTheTestNot(comptime T: type, x: Vector(4, T)) !void {
+        fn doTheTestNot(comptime T: type, x: @Vector(4, T)) !void {
             var y = ~x;
             for (@as([4]T, y)) |v, i| {
                 try expect(~x[i] == v);
@@ -538,8 +537,8 @@ test "vector shift operators" {
             const TX = @typeInfo(@TypeOf(x)).Array.child;
             const TY = @typeInfo(@TypeOf(y)).Array.child;
 
-            var xv = @as(Vector(N, TX), x);
-            var yv = @as(Vector(N, TY), y);
+            var xv = @as(@Vector(N, TX), x);
+            var yv = @as(@Vector(N, TY), y);
 
             var z0 = xv >> yv;
             for (@as([N]TX, z0)) |v, i| {
@@ -555,8 +554,8 @@ test "vector shift operators" {
             const TX = @typeInfo(@TypeOf(x)).Array.child;
             const TY = @typeInfo(@TypeOf(y)).Array.child;
 
-            var xv = @as(Vector(N, TX), x);
-            var yv = @as(Vector(N, TY), y);
+            var xv = @as(@Vector(N, TX), x);
+            var yv = @as(@Vector(N, TY), y);
 
             var z = if (dir == .Left) @shlExact(xv, yv) else @shrExact(xv, yv);
             for (@as([N]TX, z)) |v, i| {
@@ -768,10 +767,10 @@ test "mask parameter of @shuffle is comptime scope" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
-    const __v4hi = std.meta.Vector(4, i16);
+    const __v4hi = @Vector(4, i16);
     var v4_a = __v4hi{ 0, 0, 0, 0 };
     var v4_b = __v4hi{ 0, 0, 0, 0 };
-    var shuffled: __v4hi = @shuffle(i16, v4_a, v4_b, std.meta.Vector(4, i32){
+    var shuffled: __v4hi = @shuffle(i16, v4_a, v4_b, @Vector(4, i32){
         std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),
         std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),
         std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),
@@ -790,18 +789,18 @@ test "saturating add" {
     const S = struct {
         fn doTheTest() !void {
             { // Broken out to avoid https://github.com/ziglang/zig/issues/11251
-                const u8x3 = std.meta.Vector(3, u8);
-                const lhs = u8x3{ 255, 254, 1 };
-                const rhs = u8x3{ 1, 2, 255 };
-                const result = lhs +| rhs;
+                const u8x3 = @Vector(3, u8);
+                var lhs = u8x3{ 255, 254, 1 };
+                var rhs = u8x3{ 1, 2, 255 };
+                var result = lhs +| rhs;
                 const expected = u8x3{ 255, 255, 255 };
                 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
             }
             { // Broken out to avoid https://github.com/ziglang/zig/issues/11251
-                const i8x3 = std.meta.Vector(3, i8);
-                const lhs = i8x3{ 127, 126, 1 };
-                const rhs = i8x3{ 1, 2, 127 };
-                const result = lhs +| rhs;
+                const i8x3 = @Vector(3, i8);
+                var lhs = i8x3{ 127, 126, 1 };
+                var rhs = i8x3{ 1, 2, 127 };
+                var result = lhs +| rhs;
                 const expected = i8x3{ 127, 127, 127 };
                 try expect(mem.eql(i8, &@as([3]i8, expected), &@as([3]i8, result)));
             }
@@ -821,10 +820,10 @@ test "saturating subtraction" {
     const S = struct {
         fn doTheTest() !void {
             // Broken out to avoid https://github.com/ziglang/zig/issues/11251
-            const u8x3 = std.meta.Vector(3, u8);
-            const lhs = u8x3{ 0, 0, 0 };
-            const rhs = u8x3{ 255, 255, 255 };
-            const result = lhs -| rhs;
+            const u8x3 = @Vector(3, u8);
+            var lhs = u8x3{ 0, 0, 0 };
+            var rhs = u8x3{ 255, 255, 255 };
+            var result = lhs -| rhs;
             const expected = u8x3{ 0, 0, 0 };
             try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
         }
@@ -846,10 +845,10 @@ test "saturating multiplication" {
     const S = struct {
         fn doTheTest() !void {
             // Broken out to avoid https://github.com/ziglang/zig/issues/11251
-            const u8x3 = std.meta.Vector(3, u8);
-            const lhs = u8x3{ 2, 2, 2 };
-            const rhs = u8x3{ 255, 255, 255 };
-            const result = lhs *| rhs;
+            const u8x3 = @Vector(3, u8);
+            var lhs = u8x3{ 2, 2, 2 };
+            var rhs = u8x3{ 255, 255, 255 };
+            var result = lhs *| rhs;
             const expected = u8x3{ 255, 255, 255 };
             try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
         }
@@ -869,10 +868,10 @@ test "saturating shift-left" {
     const S = struct {
         fn doTheTest() !void {
             // Broken out to avoid https://github.com/ziglang/zig/issues/11251
-            const u8x3 = std.meta.Vector(3, u8);
-            const lhs = u8x3{ 1, 1, 1 };
-            const rhs = u8x3{ 255, 255, 255 };
-            const result = lhs <<| rhs;
+            const u8x3 = @Vector(3, u8);
+            var lhs = u8x3{ 1, 1, 1 };
+            var rhs = u8x3{ 255, 255, 255 };
+            var result = lhs <<| rhs;
             const expected = u8x3{ 255, 255, 255 };
             try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
         }