implement vector negation

also fix vector behavior tests, they weren't actually testing
runtime vectors, but now they are.

See #903

3 files changed, 80 insertions, 9 deletions

diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index c39d34b3e9..48eb7cd85d 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -2,6 +2,18 @@ const tests = @import("tests.zig");
 
 pub fn addCases(cases: *tests.CompileErrorContext) void {
     cases.addTest(
+        "comptime vector overflow shows the index",
+        \\comptime {
+        \\    var a: @Vector(4, u8) = []u8{ 1, 2, 255, 4 };
+        \\    var b: @Vector(4, u8) = []u8{ 5, 6, 1, 8 };
+        \\    var x = a + b;
+        \\}
+    ,
+        ".tmp_source.zig:4:15: error: operation caused overflow",
+        ".tmp_source.zig:4:15: note: when computing vector element at index 2",
+    );
+
+    cases.addTest(
         "packed struct with fields of not allowed types",
         \\const A = packed struct {
         \\    x: anyerror,
diff --git a/test/runtime_safety.zig b/test/runtime_safety.zig
index 12cac64b3a..0427efabd5 100644
--- a/test/runtime_safety.zig
+++ b/test/runtime_safety.zig
@@ -118,6 +118,47 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
         \\}
     );
 
+    cases.addRuntimeSafety("vector integer subtraction overflow",
+        \\pub fn panic(message: []const u8, stack_trace: ?*@import("builtin").StackTrace) noreturn {
+        \\    @import("std").os.exit(126);
+        \\}
+        \\pub fn main() void {
+        \\    var a: @Vector(4, u32) = []u32{ 1, 2, 8, 4 };
+        \\    var b: @Vector(4, u32) = []u32{ 5, 6, 7, 8 };
+        \\    const x = sub(b, a);
+        \\}
+        \\fn sub(a: @Vector(4, u32), b: @Vector(4, u32)) @Vector(4, u32) {
+        \\    return a - b;
+        \\}
+    );
+
+    cases.addRuntimeSafety("vector integer multiplication overflow",
+        \\pub fn panic(message: []const u8, stack_trace: ?*@import("builtin").StackTrace) noreturn {
+        \\    @import("std").os.exit(126);
+        \\}
+        \\pub fn main() void {
+        \\    var a: @Vector(4, u8) = []u8{ 1, 2, 200, 4 };
+        \\    var b: @Vector(4, u8) = []u8{ 5, 6, 2, 8 };
+        \\    const x = mul(b, a);
+        \\}
+        \\fn mul(a: @Vector(4, u8), b: @Vector(4, u8)) @Vector(4, u8) {
+        \\    return a * b;
+        \\}
+    );
+
+    cases.addRuntimeSafety("vector integer negation overflow",
+        \\pub fn panic(message: []const u8, stack_trace: ?*@import("builtin").StackTrace) noreturn {
+        \\    @import("std").os.exit(126);
+        \\}
+        \\pub fn main() void {
+        \\    var a: @Vector(4, i16) = []i16{ 1, -32768, 200, 4 };
+        \\    const x = neg(a);
+        \\}
+        \\fn neg(a: @Vector(4, i16)) @Vector(4, i16) {
+        \\    return -a;
+        \\}
+    );
+
     cases.addRuntimeSafety("integer subtraction overflow",
         \\pub fn panic(message: []const u8, stack_trace: ?*@import("builtin").StackTrace) noreturn {
         \\    @import("std").os.exit(126);
diff --git a/test/stage1/behavior/vector.zig b/test/stage1/behavior/vector.zig
index b0d2871454..21bbe3160d 100644
--- a/test/stage1/behavior/vector.zig
+++ b/test/stage1/behavior/vector.zig
@@ -5,11 +5,28 @@ const expect = std.testing.expect;
 test "vector wrap operators" {
     const S = struct {
         fn doTheTest() void {
-            const v: @Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
-            const x: @Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };
-            expect(mem.eql(i32, ([4]i32)(v +% x), [4]i32{ 11, 22, 33, 44 }));
-            expect(mem.eql(i32, ([4]i32)(v -% x), [4]i32{ 9, 18, 27, 36 }));
-            expect(mem.eql(i32, ([4]i32)(v *% x), [4]i32{ 10, 40, 90, 160 }));
+            var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
+            var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
+            expect(mem.eql(i32, ([4]i32)(v +% x), [4]i32{ -2147483648, 2147483645, 33, 44 }));
+            expect(mem.eql(i32, ([4]i32)(v -% x), [4]i32{ 2147483646, 2147483647, 27, 36 }));
+            expect(mem.eql(i32, ([4]i32)(v *% x), [4]i32{ 2147483647, 2, 90, 160 }));
+            var z: @Vector(4, i32) = [4]i32{ 1, 2, 3, -2147483648 };
+            expect(mem.eql(i32, ([4]i32)(-%z), [4]i32{ -1, -2, -3, -2147483648 }));
+        }
+    };
+    S.doTheTest();
+    comptime S.doTheTest();
+}
+
+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 };
+            expect(mem.eql(i32, ([4]i32)(v + x), [4]i32{ 11, 22, 33, 44 }));
+            expect(mem.eql(i32, ([4]i32)(v - x), [4]i32{ 9, 18, 27, 36 }));
+            expect(mem.eql(i32, ([4]i32)(v * x), [4]i32{ 10, 40, 90, 160 }));
+            expect(mem.eql(i32, ([4]i32)(-v), [4]i32{ -10, -20, -30, -40 }));
         }
     };
     S.doTheTest();
@@ -19,11 +36,12 @@ test "vector wrap operators" {
 test "vector float operators" {
     const S = struct {
         fn doTheTest() void {
-            const v: @Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
-            const 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 };
             expect(mem.eql(f32, ([4]f32)(v + x), [4]f32{ 11, 22, 33, 44 }));
             expect(mem.eql(f32, ([4]f32)(v - x), [4]f32{ 9, 18, 27, 36 }));
             expect(mem.eql(f32, ([4]f32)(v * x), [4]f32{ 10, 40, 90, 160 }));
+            expect(mem.eql(f32, ([4]f32)(-x), [4]f32{ -1, -2, -3, -4 }));
         }
     };
     S.doTheTest();
@@ -33,8 +51,8 @@ test "vector float operators" {
 test "vector bit operators" {
     const S = struct {
         fn doTheTest() void {
-            const v: @Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
-            const 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 };
             expect(mem.eql(u8, ([4]u8)(v ^ x), [4]u8{ 0b01011010, 0b10100101, 0b00000000, 0b11111111 }));
             expect(mem.eql(u8, ([4]u8)(v | x), [4]u8{ 0b11111010, 0b10101111, 0b10101010, 0b11111111 }));
             expect(mem.eql(u8, ([4]u8)(v & x), [4]u8{ 0b10100000, 0b00001010, 0b10101010, 0b00000000 }));