Merge pull request #12574 from Vexu/remove-bit-op-type-param

stage2+stage1: remove type parameter from bit builtins

7 files changed, 84 insertions, 77 deletions

diff --git a/test/behavior/bitreverse.zig b/test/behavior/bitreverse.zig
index 585fe381b0..092f3a1fed 100644
--- a/test/behavior/bitreverse.zig
+++ b/test/behavior/bitreverse.zig
@@ -8,7 +8,7 @@ test "@bitReverse large exotic integer" {
     // Currently failing on stage1 for big-endian targets
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
 
-    try expect(@bitReverse(u95, @as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624);
+    try expect(@bitReverse(@as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624);
 }
 
 test "@bitReverse" {
@@ -23,74 +23,74 @@ test "@bitReverse" {
 
 fn testBitReverse() !void {
     // using comptime_ints, unsigned
-    try expect(@bitReverse(u0, @as(u0, 0)) == 0);
-    try expect(@bitReverse(u5, @as(u5, 0x12)) == 0x9);
-    try expect(@bitReverse(u8, @as(u8, 0x12)) == 0x48);
-    try expect(@bitReverse(u16, @as(u16, 0x1234)) == 0x2c48);
-    try expect(@bitReverse(u24, @as(u24, 0x123456)) == 0x6a2c48);
-    try expect(@bitReverse(u32, @as(u32, 0x12345678)) == 0x1e6a2c48);
-    try expect(@bitReverse(u40, @as(u40, 0x123456789a)) == 0x591e6a2c48);
-    try expect(@bitReverse(u48, @as(u48, 0x123456789abc)) == 0x3d591e6a2c48);
-    try expect(@bitReverse(u56, @as(u56, 0x123456789abcde)) == 0x7b3d591e6a2c48);
-    try expect(@bitReverse(u64, @as(u64, 0x123456789abcdef1)) == 0x8f7b3d591e6a2c48);
-    try expect(@bitReverse(u96, @as(u96, 0x123456789abcdef111213141)) == 0x828c84888f7b3d591e6a2c48);
-    try expect(@bitReverse(u128, @as(u128, 0x123456789abcdef11121314151617181)) == 0x818e868a828c84888f7b3d591e6a2c48);
+    try expect(@bitReverse(@as(u0, 0)) == 0);
+    try expect(@bitReverse(@as(u5, 0x12)) == 0x9);
+    try expect(@bitReverse(@as(u8, 0x12)) == 0x48);
+    try expect(@bitReverse(@as(u16, 0x1234)) == 0x2c48);
+    try expect(@bitReverse(@as(u24, 0x123456)) == 0x6a2c48);
+    try expect(@bitReverse(@as(u32, 0x12345678)) == 0x1e6a2c48);
+    try expect(@bitReverse(@as(u40, 0x123456789a)) == 0x591e6a2c48);
+    try expect(@bitReverse(@as(u48, 0x123456789abc)) == 0x3d591e6a2c48);
+    try expect(@bitReverse(@as(u56, 0x123456789abcde)) == 0x7b3d591e6a2c48);
+    try expect(@bitReverse(@as(u64, 0x123456789abcdef1)) == 0x8f7b3d591e6a2c48);
+    try expect(@bitReverse(@as(u96, 0x123456789abcdef111213141)) == 0x828c84888f7b3d591e6a2c48);
+    try expect(@bitReverse(@as(u128, 0x123456789abcdef11121314151617181)) == 0x818e868a828c84888f7b3d591e6a2c48);
 
     // using runtime uints, unsigned
     var num0: u0 = 0;
-    try expect(@bitReverse(u0, num0) == 0);
+    try expect(@bitReverse(num0) == 0);
     var num5: u5 = 0x12;
-    try expect(@bitReverse(u5, num5) == 0x9);
+    try expect(@bitReverse(num5) == 0x9);
     var num8: u8 = 0x12;
-    try expect(@bitReverse(u8, num8) == 0x48);
+    try expect(@bitReverse(num8) == 0x48);
     var num16: u16 = 0x1234;
-    try expect(@bitReverse(u16, num16) == 0x2c48);
+    try expect(@bitReverse(num16) == 0x2c48);
     var num24: u24 = 0x123456;
-    try expect(@bitReverse(u24, num24) == 0x6a2c48);
+    try expect(@bitReverse(num24) == 0x6a2c48);
     var num32: u32 = 0x12345678;
-    try expect(@bitReverse(u32, num32) == 0x1e6a2c48);
+    try expect(@bitReverse(num32) == 0x1e6a2c48);
     var num40: u40 = 0x123456789a;
-    try expect(@bitReverse(u40, num40) == 0x591e6a2c48);
+    try expect(@bitReverse(num40) == 0x591e6a2c48);
     var num48: u48 = 0x123456789abc;
-    try expect(@bitReverse(u48, num48) == 0x3d591e6a2c48);
+    try expect(@bitReverse(num48) == 0x3d591e6a2c48);
     var num56: u56 = 0x123456789abcde;
-    try expect(@bitReverse(u56, num56) == 0x7b3d591e6a2c48);
+    try expect(@bitReverse(num56) == 0x7b3d591e6a2c48);
     var num64: u64 = 0x123456789abcdef1;
-    try expect(@bitReverse(u64, num64) == 0x8f7b3d591e6a2c48);
+    try expect(@bitReverse(num64) == 0x8f7b3d591e6a2c48);
     var num128: u128 = 0x123456789abcdef11121314151617181;
-    try expect(@bitReverse(u128, num128) == 0x818e868a828c84888f7b3d591e6a2c48);
+    try expect(@bitReverse(num128) == 0x818e868a828c84888f7b3d591e6a2c48);
 
     // using comptime_ints, signed, positive
-    try expect(@bitReverse(u8, @as(u8, 0)) == 0);
-    try expect(@bitReverse(i8, @bitCast(i8, @as(u8, 0x92))) == @bitCast(i8, @as(u8, 0x49)));
-    try expect(@bitReverse(i16, @bitCast(i16, @as(u16, 0x1234))) == @bitCast(i16, @as(u16, 0x2c48)));
-    try expect(@bitReverse(i24, @bitCast(i24, @as(u24, 0x123456))) == @bitCast(i24, @as(u24, 0x6a2c48)));
-    try expect(@bitReverse(i24, @bitCast(i24, @as(u24, 0x12345f))) == @bitCast(i24, @as(u24, 0xfa2c48)));
-    try expect(@bitReverse(i24, @bitCast(i24, @as(u24, 0xf23456))) == @bitCast(i24, @as(u24, 0x6a2c4f)));
-    try expect(@bitReverse(i32, @bitCast(i32, @as(u32, 0x12345678))) == @bitCast(i32, @as(u32, 0x1e6a2c48)));
-    try expect(@bitReverse(i32, @bitCast(i32, @as(u32, 0xf2345678))) == @bitCast(i32, @as(u32, 0x1e6a2c4f)));
-    try expect(@bitReverse(i32, @bitCast(i32, @as(u32, 0x1234567f))) == @bitCast(i32, @as(u32, 0xfe6a2c48)));
-    try expect(@bitReverse(i40, @bitCast(i40, @as(u40, 0x123456789a))) == @bitCast(i40, @as(u40, 0x591e6a2c48)));
-    try expect(@bitReverse(i48, @bitCast(i48, @as(u48, 0x123456789abc))) == @bitCast(i48, @as(u48, 0x3d591e6a2c48)));
-    try expect(@bitReverse(i56, @bitCast(i56, @as(u56, 0x123456789abcde))) == @bitCast(i56, @as(u56, 0x7b3d591e6a2c48)));
-    try expect(@bitReverse(i64, @bitCast(i64, @as(u64, 0x123456789abcdef1))) == @bitCast(i64, @as(u64, 0x8f7b3d591e6a2c48)));
-    try expect(@bitReverse(i96, @bitCast(i96, @as(u96, 0x123456789abcdef111213141))) == @bitCast(i96, @as(u96, 0x828c84888f7b3d591e6a2c48)));
-    try expect(@bitReverse(i128, @bitCast(i128, @as(u128, 0x123456789abcdef11121314151617181))) == @bitCast(i128, @as(u128, 0x818e868a828c84888f7b3d591e6a2c48)));
+    try expect(@bitReverse(@as(u8, 0)) == 0);
+    try expect(@bitReverse(@bitCast(i8, @as(u8, 0x92))) == @bitCast(i8, @as(u8, 0x49)));
+    try expect(@bitReverse(@bitCast(i16, @as(u16, 0x1234))) == @bitCast(i16, @as(u16, 0x2c48)));
+    try expect(@bitReverse(@bitCast(i24, @as(u24, 0x123456))) == @bitCast(i24, @as(u24, 0x6a2c48)));
+    try expect(@bitReverse(@bitCast(i24, @as(u24, 0x12345f))) == @bitCast(i24, @as(u24, 0xfa2c48)));
+    try expect(@bitReverse(@bitCast(i24, @as(u24, 0xf23456))) == @bitCast(i24, @as(u24, 0x6a2c4f)));
+    try expect(@bitReverse(@bitCast(i32, @as(u32, 0x12345678))) == @bitCast(i32, @as(u32, 0x1e6a2c48)));
+    try expect(@bitReverse(@bitCast(i32, @as(u32, 0xf2345678))) == @bitCast(i32, @as(u32, 0x1e6a2c4f)));
+    try expect(@bitReverse(@bitCast(i32, @as(u32, 0x1234567f))) == @bitCast(i32, @as(u32, 0xfe6a2c48)));
+    try expect(@bitReverse(@bitCast(i40, @as(u40, 0x123456789a))) == @bitCast(i40, @as(u40, 0x591e6a2c48)));
+    try expect(@bitReverse(@bitCast(i48, @as(u48, 0x123456789abc))) == @bitCast(i48, @as(u48, 0x3d591e6a2c48)));
+    try expect(@bitReverse(@bitCast(i56, @as(u56, 0x123456789abcde))) == @bitCast(i56, @as(u56, 0x7b3d591e6a2c48)));
+    try expect(@bitReverse(@bitCast(i64, @as(u64, 0x123456789abcdef1))) == @bitCast(i64, @as(u64, 0x8f7b3d591e6a2c48)));
+    try expect(@bitReverse(@bitCast(i96, @as(u96, 0x123456789abcdef111213141))) == @bitCast(i96, @as(u96, 0x828c84888f7b3d591e6a2c48)));
+    try expect(@bitReverse(@bitCast(i128, @as(u128, 0x123456789abcdef11121314151617181))) == @bitCast(i128, @as(u128, 0x818e868a828c84888f7b3d591e6a2c48)));
 
     // using signed, negative. Compare to runtime ints returned from llvm.
     var neg8: i8 = -18;
-    try expect(@bitReverse(i8, @as(i8, -18)) == @bitReverse(i8, neg8));
+    try expect(@bitReverse(@as(i8, -18)) == @bitReverse(neg8));
     var neg16: i16 = -32694;
-    try expect(@bitReverse(i16, @as(i16, -32694)) == @bitReverse(i16, neg16));
+    try expect(@bitReverse(@as(i16, -32694)) == @bitReverse(neg16));
     var neg24: i24 = -6773785;
-    try expect(@bitReverse(i24, @as(i24, -6773785)) == @bitReverse(i24, neg24));
+    try expect(@bitReverse(@as(i24, -6773785)) == @bitReverse(neg24));
     var neg32: i32 = -16773785;
-    try expect(@bitReverse(i32, @as(i32, -16773785)) == @bitReverse(i32, neg32));
+    try expect(@bitReverse(@as(i32, -16773785)) == @bitReverse(neg32));
 }
 
 fn vector8() !void {
     var v = @Vector(2, u8){ 0x12, 0x23 };
-    var result = @bitReverse(u8, v);
+    var result = @bitReverse(v);
     try expect(result[0] == 0x48);
     try expect(result[1] == 0xc4);
 }
@@ -109,7 +109,7 @@ test "bitReverse vectors u8" {
 
 fn vector16() !void {
     var v = @Vector(2, u16){ 0x1234, 0x2345 };
-    var result = @bitReverse(u16, v);
+    var result = @bitReverse(v);
     try expect(result[0] == 0x2c48);
     try expect(result[1] == 0xa2c4);
 }
@@ -128,7 +128,7 @@ test "bitReverse vectors u16" {
 
 fn vector24() !void {
     var v = @Vector(2, u24){ 0x123456, 0x234567 };
-    var result = @bitReverse(u24, v);
+    var result = @bitReverse(v);
     try expect(result[0] == 0x6a2c48);
     try expect(result[1] == 0xe6a2c4);
 }
@@ -147,7 +147,7 @@ test "bitReverse vectors u24" {
 
 fn vector0() !void {
     var v = @Vector(2, u0){ 0, 0 };
-    var result = @bitReverse(u0, v);
+    var result = @bitReverse(v);
     try expect(result[0] == 0);
     try expect(result[1] == 0);
 }
diff --git a/test/behavior/bugs/10147.zig b/test/behavior/bugs/10147.zig
index b519c71865..221120bb73 100644
--- a/test/behavior/bugs/10147.zig
+++ b/test/behavior/bugs/10147.zig
@@ -2,6 +2,7 @@ const builtin = @import("builtin");
 const std = @import("std");
 
 test "uses correct LLVM builtin" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) 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
@@ -12,8 +13,8 @@ test "uses correct LLVM builtin" {
     var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };
     // The stage1 compiler used to call the same builtin function for both
     // scalar and vector inputs, causing the LLVM module verification to fail.
-    var a = @clz(u32, x);
-    var b = @clz(u32, y);
+    var a = @clz(x);
+    var b = @clz(y);
     try std.testing.expectEqual(@as(u6, 31), a);
     try std.testing.expectEqual([_]u6{ 31, 31, 31, 31 }, b);
 }
diff --git a/test/behavior/bugs/2114.zig b/test/behavior/bugs/2114.zig
index 54826cb0d1..a013688f4e 100644
--- a/test/behavior/bugs/2114.zig
+++ b/test/behavior/bugs/2114.zig
@@ -4,7 +4,7 @@ const expect = std.testing.expect;
 const math = std.math;
 
 fn ctz(x: anytype) usize {
-    return @ctz(@TypeOf(x), x);
+    return @ctz(x);
 }
 
 test "fixed" {
diff --git a/test/behavior/byteswap.zig b/test/behavior/byteswap.zig
index 263f2c046e..5313b612b0 100644
--- a/test/behavior/byteswap.zig
+++ b/test/behavior/byteswap.zig
@@ -3,6 +3,7 @@ const builtin = @import("builtin");
 const expect = std.testing.expect;
 
 test "@byteSwap integers" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@@ -46,7 +47,7 @@ test "@byteSwap integers" {
             );
         }
         fn t(comptime I: type, input: I, expected_output: I) !void {
-            try std.testing.expect(expected_output == @byteSwap(I, input));
+            try std.testing.expect(expected_output == @byteSwap(input));
         }
     };
     comptime try ByteSwapIntTest.run();
@@ -55,12 +56,13 @@ test "@byteSwap integers" {
 
 fn vector8() !void {
     var v = @Vector(2, u8){ 0x12, 0x13 };
-    var result = @byteSwap(u8, v);
+    var result = @byteSwap(v);
     try expect(result[0] == 0x12);
     try expect(result[1] == 0x13);
 }
 
 test "@byteSwap vectors u8" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@@ -73,12 +75,13 @@ test "@byteSwap vectors u8" {
 
 fn vector16() !void {
     var v = @Vector(2, u16){ 0x1234, 0x2345 };
-    var result = @byteSwap(u16, v);
+    var result = @byteSwap(v);
     try expect(result[0] == 0x3412);
     try expect(result[1] == 0x4523);
 }
 
 test "@byteSwap vectors u16" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@@ -91,12 +94,13 @@ test "@byteSwap vectors u16" {
 
 fn vector24() !void {
     var v = @Vector(2, u24){ 0x123456, 0x234567 };
-    var result = @byteSwap(u24, v);
+    var result = @byteSwap(v);
     try expect(result[0] == 0x563412);
     try expect(result[1] == 0x674523);
 }
 
 test "@byteSwap vectors u24" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@@ -109,12 +113,13 @@ test "@byteSwap vectors u24" {
 
 fn vector0() !void {
     var v = @Vector(2, u0){ 0, 0 };
-    var result = @byteSwap(u0, v);
+    var result = @byteSwap(v);
     try expect(result[0] == 0);
     try expect(result[1] == 0);
 }
 
 test "@byteSwap vectors u0" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig
index 1fc3f64cda..8fa5fc503e 100644
--- a/test/behavior/comptime_memory.zig
+++ b/test/behavior/comptime_memory.zig
@@ -82,7 +82,7 @@ test "type pun value and struct" {
 }
 
 fn bigToNativeEndian(comptime T: type, v: T) T {
-    return if (endian == .Big) v else @byteSwap(T, v);
+    return if (endian == .Big) v else @byteSwap(v);
 }
 test "type pun endianness" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index 804a061da2..860cbe7042 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -90,10 +90,11 @@ fn testClzBigInts() !void {
 }
 
 fn testOneClz(comptime T: type, x: T) u32 {
-    return @clz(T, x);
+    return @clz(x);
 }
 
 test "@clz vectors" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) 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
@@ -120,7 +121,7 @@ fn testOneClzVector(
     x: @Vector(len, T),
     expected: @Vector(len, u32),
 ) !void {
-    try expectVectorsEqual(@clz(T, x), expected);
+    try expectVectorsEqual(@clz(x), expected);
 }
 
 fn expectVectorsEqual(a: anytype, b: anytype) !void {
@@ -151,19 +152,18 @@ fn testCtz() !void {
 }
 
 fn testOneCtz(comptime T: type, x: T) u32 {
-    return @ctz(T, x);
+    return @ctz(x);
 }
 
 test "@ctz vectors" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) 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
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
 
-    if ((builtin.zig_backend == .stage1 or builtin.zig_backend == .stage2_llvm) and
-        builtin.cpu.arch == .aarch64)
-    {
+    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // This regressed with LLVM 14:
         // https://github.com/ziglang/zig/issues/12013
         return error.SkipZigTest;
@@ -187,7 +187,7 @@ fn testOneCtzVector(
     x: @Vector(len, T),
     expected: @Vector(len, u32),
 ) !void {
-    try expectVectorsEqual(@ctz(T, x), expected);
+    try expectVectorsEqual(@ctz(x), expected);
 }
 
 test "const number literal" {
diff --git a/test/behavior/popcount.zig b/test/behavior/popcount.zig
index dbfeb64111..e061814692 100644
--- a/test/behavior/popcount.zig
+++ b/test/behavior/popcount.zig
@@ -18,53 +18,54 @@ test "@popCount 128bit integer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     comptime {
-        try expect(@popCount(u128, @as(u128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
-        try expect(@popCount(i128, @as(i128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
+        try expect(@popCount(@as(u128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
+        try expect(@popCount(@as(i128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
     }
 
     {
         var x: u128 = 0b11111111000110001100010000100001000011000011100101010001;
-        try expect(@popCount(u128, x) == 24);
+        try expect(@popCount(x) == 24);
     }
 
-    try expect(@popCount(i128, @as(i128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
+    try expect(@popCount(@as(i128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
 }
 
 fn testPopCountIntegers() !void {
     {
         var x: u32 = 0xffffffff;
-        try expect(@popCount(u32, x) == 32);
+        try expect(@popCount(x) == 32);
     }
     {
         var x: u5 = 0x1f;
-        try expect(@popCount(u5, x) == 5);
+        try expect(@popCount(x) == 5);
     }
     {
         var x: u32 = 0xaa;
-        try expect(@popCount(u32, x) == 4);
+        try expect(@popCount(x) == 4);
     }
     {
         var x: u32 = 0xaaaaaaaa;
-        try expect(@popCount(u32, x) == 16);
+        try expect(@popCount(x) == 16);
     }
     {
         var x: u32 = 0xaaaaaaaa;
-        try expect(@popCount(u32, x) == 16);
+        try expect(@popCount(x) == 16);
     }
     {
         var x: i16 = -1;
-        try expect(@popCount(i16, x) == 16);
+        try expect(@popCount(x) == 16);
     }
     {
         var x: i8 = -120;
-        try expect(@popCount(i8, x) == 2);
+        try expect(@popCount(x) == 2);
     }
     comptime {
-        try expect(@popCount(u8, @bitCast(u8, @as(i8, -120))) == 2);
+        try expect(@popCount(@bitCast(u8, @as(i8, -120))) == 2);
     }
 }
 
 test "@popCount vectors" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -79,13 +80,13 @@ fn testPopCountVectors() !void {
     {
         var x: @Vector(8, u32) = [1]u32{0xffffffff} ** 8;
         const expected = [1]u6{32} ** 8;
-        const result: [8]u6 = @popCount(u32, x);
+        const result: [8]u6 = @popCount(x);
         try expect(std.mem.eql(u6, &expected, &result));
     }
     {
         var x: @Vector(8, i16) = [1]i16{-1} ** 8;
         const expected = [1]u5{16} ** 8;
-        const result: [8]u5 = @popCount(i16, x);
+        const result: [8]u5 = @popCount(x);
         try expect(std.mem.eql(u5, &expected, &result));
     }
 }