diff --git a/src/value.zig b/src/value.zig
index 6f0f786072..454b1d76a2 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -2693,16 +2693,14 @@ pub const Value = extern union {
         if (int_ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, int_ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intToFloatScalar(val.indexVectorlike(i), arena, int_ty.scalarType(), float_ty.scalarType(), target);
+                scalar.* = try intToFloatScalar(val.indexVectorlike(i), arena, float_ty.scalarType(), target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
-        return intToFloatScalar(val, arena, int_ty, float_ty, target);
+        return intToFloatScalar(val, arena, float_ty, target);
     }
 
-    pub fn intToFloatScalar(val: Value, arena: Allocator, int_ty: Type, float_ty: Type, target: Target) !Value {
-        assert(int_ty.isNumeric() and !int_ty.isAnyFloat());
-        assert(float_ty.isAnyFloat());
+    pub fn intToFloatScalar(val: Value, arena: Allocator, float_ty: Type, target: Target) !Value {
         switch (val.tag()) {
             .undef, .zero, .one => return val,
             .the_only_possible_value => return Value.initTag(.zero), // for i0, u0
@@ -2754,16 +2752,14 @@ pub const Value = extern union {
         if (float_ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try floatToIntScalar(val.indexVectorlike(i), arena, float_ty.scalarType(), int_ty.scalarType(), target);
+                scalar.* = try floatToIntScalar(val.indexVectorlike(i), arena, int_ty.scalarType(), target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
-        return floatToIntScalar(val, arena, float_ty, int_ty, target);
+        return floatToIntScalar(val, arena, int_ty, target);
     }
 
-    pub fn floatToIntScalar(val: Value, arena: Allocator, float_ty: Type, int_ty: Type, target: Target) error{ FloatCannotFit, OutOfMemory }!Value {
-        assert(float_ty.isAnyFloat());
-        assert(int_ty.isInt());
+    pub fn floatToIntScalar(val: Value, arena: Allocator, int_ty: Type, target: Target) error{ FloatCannotFit, OutOfMemory }!Value {
         const Limb = std.math.big.Limb;
 
         var value = val.toFloat(f64); // TODO: f128 ?
diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index 697969f42e..1d8dd9f661 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -6,7 +6,12 @@ const expect = std.testing.expect;
 const Vector = std.meta.Vector;
 
 test "implicit cast vector to array - bool" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             const a: Vector(4, bool) = [_]bool{ true, false, true, false };
@@ -19,7 +24,12 @@ test "implicit cast vector to array - bool" {
 }
 
 test "vector wrap operators" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
@@ -36,7 +46,12 @@ test "vector wrap operators" {
 }
 
 test "vector bin compares with mem.eql" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
@@ -54,7 +69,12 @@ test "vector bin compares with mem.eql" {
 }
 
 test "vector int operators" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var v: Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
@@ -70,7 +90,12 @@ test "vector int operators" {
 }
 
 test "vector float operators" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var v: Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
@@ -86,7 +111,12 @@ test "vector float operators" {
 }
 
 test "vector bit operators" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var v: Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
@@ -101,7 +131,12 @@ test "vector bit operators" {
 }
 
 test "implicit cast vector to array" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var a: Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
@@ -115,7 +150,12 @@ test "implicit cast vector to array" {
 }
 
 test "array to vector" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var foo: f32 = 3.14;
@@ -129,7 +169,12 @@ test "array to vector" {
 }
 
 test "vector casts of sizes not divisible by 8" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             {
@@ -159,7 +204,12 @@ test "vector casts of sizes not divisible by 8" {
 }
 
 test "vector @splat" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn testForT(comptime N: comptime_int, v: anytype) !void {
             const T = @TypeOf(v);
@@ -195,7 +245,12 @@ test "vector @splat" {
 }
 
 test "load vector elements via comptime index" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
@@ -213,7 +268,12 @@ test "load vector elements via comptime index" {
 }
 
 test "store vector elements via comptime index" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
@@ -237,7 +297,12 @@ test "store vector elements via comptime index" {
 }
 
 test "load vector elements via runtime index" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
@@ -255,7 +320,12 @@ test "load vector elements via runtime index" {
 }
 
 test "store vector elements via runtime index" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
@@ -274,7 +344,12 @@ test "store vector elements via runtime index" {
 }
 
 test "initialize vector which is a struct field" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const Vec4Obj = struct {
         data: Vector(4, f32),
     };
@@ -292,7 +367,12 @@ test "initialize vector which is a struct field" {
 }
 
 test "vector comparison operators" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             {
@@ -327,7 +407,12 @@ test "vector comparison operators" {
 }
 
 test "vector division operators" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    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 {
             if (!comptime std.meta.trait.isSignedInt(T)) {
@@ -410,7 +495,12 @@ test "vector division operators" {
 }
 
 test "vector bitwise not operator" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTestNot(comptime T: type, x: Vector(4, T)) !void {
             var y = ~x;
@@ -436,7 +526,12 @@ test "vector bitwise not operator" {
 }
 
 test "vector shift operators" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTestShift(x: anytype, y: anytype) !void {
             const N = @typeInfo(@TypeOf(x)).Array.len;
@@ -667,7 +762,12 @@ test "vector reduce operation" {
 }
 
 test "mask parameter of @shuffle is comptime scope" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    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);
     var v4_a = __v4hi{ 0, 0, 0, 0 };
     var v4_b = __v4hi{ 0, 0, 0, 0 };
@@ -681,13 +781,30 @@ test "mask parameter of @shuffle is comptime scope" {
 }
 
 test "saturating add" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
-            const u8x3 = std.meta.Vector(3, u8);
-            try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 255, 254, 1 } +| u8x3{ 1, 2, 255 })));
-            const i8x3 = std.meta.Vector(3, i8);
-            try expect(mem.eql(i8, &@as([3]i8, i8x3{ 127, 127, 127 }), &@as([3]i8, i8x3{ 127, 126, 1 } +| i8x3{ 1, 2, 127 })));
+            { // 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 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 expected = i8x3{ 127, 127, 127 };
+                try expect(mem.eql(i8, &@as([3]i8, expected), &@as([3]i8, result)));
+            }
         }
     };
     try S.doTheTest();
@@ -695,11 +812,21 @@ test "saturating add" {
 }
 
 test "saturating subtraction" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
+            // Broken out to avoid https://github.com/ziglang/zig/issues/11251
             const u8x3 = std.meta.Vector(3, u8);
-            try expect(mem.eql(u8, &@as([3]u8, u8x3{ 0, 0, 0 }), &@as([3]u8, u8x3{ 0, 0, 0 } -| u8x3{ 255, 255, 255 })));
+            const lhs = u8x3{ 0, 0, 0 };
+            const rhs = u8x3{ 255, 255, 255 };
+            const result = lhs -| rhs;
+            const expected = u8x3{ 0, 0, 0 };
+            try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
         }
     };
     try S.doTheTest();
@@ -707,14 +834,24 @@ test "saturating subtraction" {
 }
 
 test "saturating multiplication" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     // TODO: once #9660 has been solved, remove this line
     if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
+            // Broken out to avoid https://github.com/ziglang/zig/issues/11251
             const u8x3 = std.meta.Vector(3, u8);
-            try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 2, 2, 2 } *| u8x3{ 255, 255, 255 })));
+            const lhs = u8x3{ 2, 2, 2 };
+            const rhs = u8x3{ 255, 255, 255 };
+            const result = lhs *| rhs;
+            const expected = u8x3{ 255, 255, 255 };
+            try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
         }
     };
 
@@ -723,11 +860,21 @@ test "saturating multiplication" {
 }
 
 test "saturating shift-left" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
+            // Broken out to avoid https://github.com/ziglang/zig/issues/11251
             const u8x3 = std.meta.Vector(3, u8);
-            try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 255, 255, 255 } <<| u8x3{ 1, 1, 1 })));
+            const lhs = u8x3{ 1, 1, 1 };
+            const rhs = u8x3{ 255, 255, 255 };
+            const result = lhs <<| rhs;
+            const expected = u8x3{ 255, 255, 255 };
+            try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
         }
     };
     try S.doTheTest();