std: remove unused variables

Author: g-w1

lib/std/Thread.zig

@@ -518,8 +518,8 @@ pub fn cpuCount() CpuCountError!usize {
         },
         .haiku => {
             var count: u32 = undefined;
-            var system_info: os.system_info = undefined;
-            const rc = os.system.get_system_info(&system_info);
+            // var system_info: os.system_info = undefined;
+            // const rc = os.system.get_system_info(&system_info);
             count = system_info.cpu_count;
             return @intCast(usize, count);
         },

lib/std/base64.zig

@@ -112,9 +112,6 @@ pub const Base64Encoder = struct {
         const out_len = encoder.calcSize(source.len);
         assert(dest.len >= out_len);
 
-        const nibbles = source.len / 3;
-        const leftover = source.len - 3 * nibbles;
-
         var acc: u12 = 0;
         var acc_len: u4 = 0;
         var out_idx: usize = 0;
@@ -223,7 +220,6 @@ pub const Base64Decoder = struct {
         if (decoder.pad_char) |pad_char| {
             const padding_len = acc_len / 2;
             var padding_chars: usize = 0;
-            var i: usize = 0;
             for (leftover) |c| {
                 if (c != pad_char) {
                     return if (c == Base64Decoder.invalid_char) error.InvalidCharacter else error.InvalidPadding;
@@ -302,7 +298,6 @@ pub const Base64DecoderWithIgnore = struct {
         var leftover = source[leftover_idx.?..];
         if (decoder.pad_char) |pad_char| {
             var padding_chars: usize = 0;
-            var i: usize = 0;
             for (leftover) |c| {
                 if (decoder_with_ignore.char_is_ignored[c]) continue;
                 if (c != pad_char) {

lib/std/c/tokenizer.zig

@@ -351,7 +351,6 @@ pub const Tokenizer = struct {
     pp_directive: bool = false,
 
     pub fn next(self: *Tokenizer) Token {
-        const start_index = self.index;
         var result = Token{
             .id = .Eof,
             .start = self.index,
@@ -1380,12 +1379,12 @@ test "operators" {
 
 test "keywords" {
     try expectTokens(
-        \\auto break case char const continue default do 
-        \\double else enum extern float for goto if int 
-        \\long register return short signed sizeof static 
-        \\struct switch typedef union unsigned void volatile 
-        \\while _Bool _Complex _Imaginary inline restrict _Alignas 
-        \\_Alignof _Atomic _Generic _Noreturn _Static_assert _Thread_local 
+        \\auto break case char const continue default do
+        \\double else enum extern float for goto if int
+        \\long register return short signed sizeof static
+        \\struct switch typedef union unsigned void volatile
+        \\while _Bool _Complex _Imaginary inline restrict _Alignas
+        \\_Alignof _Atomic _Generic _Noreturn _Static_assert _Thread_local
         \\
     , &[_]Token.Id{
         .Keyword_auto,

lib/std/compress/gzip.zig

@@ -58,10 +58,6 @@ pub fn GzipStream(comptime ReaderType: type) type {
             // Modification time, as a Unix timestamp.
             // If zero there's no timestamp available.
             const MTIME = mem.readIntLittle(u32, header[4..8]);
-            // Extra flags
-            const XFL = header[8];
-            // Operating system where the compression took place
-            const OS = header[9];
 
             if (FLG & FEXTRA != 0) {
                 // Skip the extra data, we could read and expose it to the user

lib/std/compress/zlib.zig

@@ -34,7 +34,6 @@ pub fn ZlibStream(comptime ReaderType: type) type {
 
             const CM = @truncate(u4, header[0]);
             const CINFO = @truncate(u4, header[0] >> 4);
-            const FCHECK = @truncate(u5, header[1]);
             const FDICT = @truncate(u1, header[1] >> 5);
 
             if ((@as(u16, header[0]) << 8 | header[1]) % 31 != 0)

lib/std/crypto/25519/scalar.zig

@@ -330,13 +330,10 @@ pub const Scalar = struct {
         const carry9 = z02 >> 56;
         const c01 = carry9;
         const carry10 = (z12 + c01) >> 56;
-        const t21 = @truncate(u64, z12 + c01) & 0xffffffffffffff;
         const c11 = carry10;
         const carry11 = (z22 + c11) >> 56;
-        const t22 = @truncate(u64, z22 + c11) & 0xffffffffffffff;
         const c21 = carry11;
         const carry12 = (z32 + c21) >> 56;
-        const t23 = @truncate(u64, z32 + c21) & 0xffffffffffffff;
         const c31 = carry12;
         const carry13 = (z42 + c31) >> 56;
         const t24 = @truncate(u64, z42 + c31) & 0xffffffffffffff;
@@ -605,13 +602,10 @@ const ScalarDouble = struct {
         const carry0 = z01 >> 56;
         const c00 = carry0;
         const carry1 = (z11 + c00) >> 56;
-        const t100 = @as(u64, @truncate(u64, z11 + c00)) & 0xffffffffffffff;
         const c10 = carry1;
         const carry2 = (z21 + c10) >> 56;
-        const t101 = @as(u64, @truncate(u64, z21 + c10)) & 0xffffffffffffff;
         const c20 = carry2;
         const carry3 = (z31 + c20) >> 56;
-        const t102 = @as(u64, @truncate(u64, z31 + c20)) & 0xffffffffffffff;
         const c30 = carry3;
         const carry4 = (z41 + c30) >> 56;
         const t103 = @as(u64, @truncate(u64, z41 + c30)) & 0xffffffffffffff;

lib/std/crypto/aes.zig

@@ -118,7 +118,6 @@ test "expand 128-bit key" {
         "d014f9a8c9ee2589e13f0cc8b6630ca6", "0c7b5a631319eafeb0398890664cfbb4", "df7d925a1f62b09da320626ed6757324", "12c07647c01f22c7bc42d2f37555114a", "6efcd876d2df54807c5df034c917c3b9", "6ea30afcbc238cf6ae82a4b4b54a338d", "90884413d280860a12a128421bc89739", "7c1f13f74208c219c021ae480969bf7b", "cc7505eb3e17d1ee82296c51c9481133", "2b3708a7f262d405bc3ebdbf4b617d62", "2b7e151628aed2a6abf7158809cf4f3c",
     };
     const enc = Aes128.initEnc(key);
-    const dec = Aes128.initDec(key);
     var exp: [16]u8 = undefined;
 
     for (enc.key_schedule.round_keys) |round_key, i| {

lib/std/crypto/aes/soft.zig

@@ -49,8 +49,6 @@ pub const Block = struct {
 
     /// Encrypt a block with a round key.
     pub inline fn encrypt(block: Block, round_key: Block) Block {
-        const src = &block.repr;
-
         const s0 = block.repr[0];
         const s1 = block.repr[1];
         const s2 = block.repr[2];
@@ -66,8 +64,6 @@ pub const Block = struct {
 
     /// Encrypt a block with the last round key.
     pub inline fn encryptLast(block: Block, round_key: Block) Block {
-        const src = &block.repr;
-
         const t0 = block.repr[0];
         const t1 = block.repr[1];
         const t2 = block.repr[2];
@@ -88,8 +84,6 @@ pub const Block = struct {
 
     /// Decrypt a block with a round key.
     pub inline fn decrypt(block: Block, round_key: Block) Block {
-        const src = &block.repr;
-
         const s0 = block.repr[0];
         const s1 = block.repr[1];
         const s2 = block.repr[2];
@@ -105,8 +99,6 @@ pub const Block = struct {
 
     /// Decrypt a block with the last round key.
     pub inline fn decryptLast(block: Block, round_key: Block) Block {
-        const src = &block.repr;
-
         const t0 = block.repr[0];
         const t1 = block.repr[1];
         const t2 = block.repr[2];

lib/std/crypto/aes_gcm.zig

@@ -114,7 +114,6 @@ test "Aes256Gcm - Empty message and no associated data" {
     const ad = "";
     const m = "";
     var c: [m.len]u8 = undefined;
-    var m2: [m.len]u8 = undefined;
     var tag: [Aes256Gcm.tag_length]u8 = undefined;
 
     Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key);

lib/std/crypto/aes_ocb.zig

@@ -271,7 +271,6 @@ test "AesOcb test vector 1" {
     var c: [0]u8 = undefined;
     Aes128Ocb.encrypt(&c, &tag, "", "", nonce, k);
 
-    var expected_c: [c.len]u8 = undefined;
     var expected_tag: [tag.len]u8 = undefined;
     _ = try hexToBytes(&expected_tag, "785407BFFFC8AD9EDCC5520AC9111EE6");
 

lib/std/crypto/bcrypt.zig

@@ -48,7 +48,6 @@ const State = struct {
     fn expand0(state: *State, key: []const u8) void {
         var i: usize = 0;
         var j: usize = 0;
-        var t: u32 = undefined;
         while (i < state.subkeys.len) : (i += 1) {
             state.subkeys[i] ^= toWord(key, &j);
         }
@@ -75,7 +74,6 @@ const State = struct {
     fn expand(state: *State, data: []const u8, key: []const u8) void {
         var i: usize = 0;
         var j: usize = 0;
-        var t: u32 = undefined;
         while (i < state.subkeys.len) : (i += 1) {
             state.subkeys[i] ^= toWord(key, &j);
         }

lib/std/crypto/chacha20.zig

@@ -444,7 +444,6 @@ fn ChaChaWith64BitNonce(comptime rounds_nb: usize) type {
                 if (comptime @sizeOf(usize) > 4) {
                     // A big block is giant: 256 GiB, but we can avoid this limitation
                     var remaining_blocks: u32 = @intCast(u32, (in.len / big_block));
-                    var i: u32 = 0;
                     while (remaining_blocks > 0) : (remaining_blocks -= 1) {
                         ChaChaImpl(rounds_nb).chacha20Xor(out[cursor .. cursor + big_block], in[cursor .. cursor + big_block], k, c);
                         c[1] += 1; // upper 32-bit of counter, generic chacha20Xor() doesn't know about this.

lib/std/dynamic_library.zig

@@ -407,7 +407,7 @@ test "dynamic_library" {
         else => return error.SkipZigTest,
     };
 
-    const dynlib = DynLib.open(libname) catch |err| {
+    _ = DynLib.open(libname) catch |err| {
         try testing.expect(err == error.FileNotFound);
         return;
     };

lib/std/event/channel.zig

@@ -308,7 +308,6 @@ test "std.event.Channel wraparound" {
 
     // add items to channel and pull them out until
     // the buffer wraps around, make sure it doesn't crash.
-    var result: i32 = undefined;
     channel.put(5);
     try testing.expectEqual(@as(i32, 5), channel.get());
     channel.put(6);

lib/std/event/group.zig

@@ -130,7 +130,7 @@ test "std.event.Group" {
     // TODO this file has bit-rotted. repair it
     if (true) return error.SkipZigTest;
 
-    const handle = async testGroup(std.heap.page_allocator);
+    _ = async testGroup(std.heap.page_allocator);
 }
 fn testGroup(allocator: *Allocator) callconv(.Async) void {
     var count: usize = 0;

lib/std/event/loop.zig

@@ -676,7 +676,7 @@ pub const Loop = struct {
             fn run(func_args: Args, loop: *Loop, allocator: *mem.Allocator) void {
                 loop.beginOneEvent();
                 loop.yield();
-                const result = @call(.{}, func, func_args);
+                @call(.{}, func, func_args); // compile error when called with non-void ret type
                 suspend {
                     loop.finishOneEvent();
                     allocator.destroy(@frame());

lib/std/event/rwlock.zig

@@ -225,7 +225,7 @@ test "std.event.RwLock" {
     var lock = RwLock.init();
     defer lock.deinit();
 
-    const handle = testLock(std.heap.page_allocator, &lock);
+    _ = testLock(std.heap.page_allocator, &lock);
 
     const expected_result = [1]i32{shared_it_count * @intCast(i32, shared_test_data.len)} ** shared_test_data.len;
     try testing.expectEqualSlices(i32, expected_result, shared_test_data);

lib/std/fmt.zig

@@ -1135,7 +1135,7 @@ pub fn formatFloatHexadecimal(
 
     // +1 for the decimal part.
     var buf: [1 + mantissa_digits]u8 = undefined;
-    const N = formatIntBuf(&buf, mantissa, 16, .lower, .{ .fill = '0', .width = 1 + mantissa_digits });
+    _ = formatIntBuf(&buf, mantissa, 16, .lower, .{ .fill = '0', .width = 1 + mantissa_digits });
 
     try writer.writeAll("0x");
     try writer.writeByte(buf[0]);
@@ -2157,7 +2157,6 @@ test "custom" {
         }
     };
 
-    var buf1: [32]u8 = undefined;
     var value = Vec2{
         .x = 10.2,
         .y = 2.22,
@@ -2215,7 +2214,7 @@ test "union" {
     try std.testing.expect(mem.eql(u8, uu_result[0..3], "UU@"));
 
     const eu_result = try bufPrint(buf[0..], "{}", .{eu_inst});
-    try std.testing.expect(mem.eql(u8, uu_result[0..3], "EU@"));
+    try std.testing.expect(mem.eql(u8, eu_result[0..3], "EU@"));
 }
 
 test "enum" {

lib/std/fmt/parse_float.zig

@@ -200,7 +200,6 @@ const ParseResult = enum {
 
 fn parseRepr(s: []const u8, n: *FloatRepr) !ParseResult {
     var digit_index: usize = 0;
-    var negative = false;
     var negative_exp = false;
     var exponent: i32 = 0;
 

lib/std/fs.zig

@@ -473,7 +473,7 @@ pub const Dir = struct {
                     }
 
                     var stat_info: os.libc_stat = undefined;
-                    const rc2 = os.system._kern_read_stat(
+                    _ = os.system._kern_read_stat(
                         self.dir.fd,
                         &haiku_entry.d_name,
                         false,
@@ -2434,7 +2434,7 @@ pub fn selfExePath(out_buffer: []u8) SelfExePathError![]u8 {
                     }) catch continue;
 
                     var real_path_buf: [MAX_PATH_BYTES]u8 = undefined;
-                    if (os.realpathZ(&resolved_path_buf, &real_path_buf)) |real_path| {
+                    if (os.realpathZ(resolved_path, &real_path_buf)) |real_path| {
                         // found a file, and hope it is the right file
                         if (real_path.len > out_buffer.len)
                             return error.NameTooLong;

lib/std/hash/auto_hash.zig

@@ -146,7 +146,7 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
         .Union => |info| {
             if (info.tag_type) |tag_type| {
                 const tag = meta.activeTag(key);
-                const s = hash(hasher, tag, strat);
+                hash(hasher, tag, strat);
                 inline for (info.fields) |field| {
                     if (@field(tag_type, field.name) == tag) {
                         hash(hasher, @field(key, field.name), strat);

lib/std/hash/cityhash.zig

@@ -353,7 +353,6 @@ fn SMHasherTest(comptime hash_fn: anytype) u32 {
 
     var key: [256]u8 = undefined;
     var hashes_bytes: [256 * @sizeOf(HashResult)]u8 = undefined;
-    var final: HashResult = 0;
 
     std.mem.set(u8, &key, 0);
     std.mem.set(u8, &hashes_bytes, 0);

lib/std/hash/wyhash.zig

@@ -166,8 +166,6 @@ pub const Wyhash = struct {
     }
 
     pub fn final(self: *Wyhash) u64 {
-        const seed = self.state.seed;
-        const rem_len = @intCast(u5, self.buf_len);
         const rem_key = self.buf[0..self.buf_len];
 
         return self.state.final(rem_key);

lib/std/hash_map.zig

@@ -1809,7 +1809,7 @@ test "std.hash_map getOrPut" {
 
     i = 0;
     while (i < 20) : (i += 1) {
-        var n = try map.getOrPutValue(i, 1);
+        _ = try map.getOrPutValue(i, 1);
     }
 
     i = 0;

lib/std/leb128.zig

@@ -198,15 +198,15 @@ fn test_read_ileb128_seq(comptime T: type, comptime N: usize, encoded: []const u
     var reader = std.io.fixedBufferStream(encoded);
     var i: usize = 0;
     while (i < N) : (i += 1) {
-        const v1 = try readILEB128(T, reader.reader());
+        _ = try readILEB128(T, reader.reader());
     }
 }
 
 fn test_read_uleb128_seq(comptime T: type, comptime N: usize, encoded: []const u8) !void {
     var reader = std.io.fixedBufferStream(encoded);
     var i: usize = 0;
     while (i < N) : (i += 1) {
-        const v1 = try readULEB128(T, reader.reader());
+        _ = try readULEB128(T, reader.reader());
     }
 }
 
@@ -309,7 +309,6 @@ fn test_write_leb128(value: anytype) !void {
     const B = std.meta.Int(signedness, larger_type_bits);
 
     const bytes_needed = bn: {
-        const S = std.meta.Int(signedness, @sizeOf(T) * 8);
         if (@typeInfo(T).Int.bits <= 7) break :bn @as(u16, 1);
 
         const unused_bits = if (value < 0) @clz(T, ~value) else @clz(T, value);

lib/std/linked_list.zig

@@ -359,8 +359,8 @@ test "basic TailQueue test" {
         }
     }
 
-    var first = list.popFirst(); // {2, 3, 4, 5}
-    var last = list.pop(); // {2, 3, 4}
+    _ = list.popFirst(); // {2, 3, 4, 5}
+    _ = list.pop(); // {2, 3, 4}
     list.remove(&three); // {2, 4}
 
     try testing.expect(list.first.?.data == 2);

lib/std/math/big/int.zig

@@ -2000,8 +2000,6 @@ fn llmulacc_karatsuba(allocator: *Allocator, r: []Limb, x: []const Limb, y: []co
     } else {
         llsub(j1, y0[0..y0_len], y1[0..y1_len]);
     }
-    const j0_len = llnormalize(j0);
-    const j1_len = llnormalize(j1);
     if (x_cmp == y_cmp) {
         mem.set(Limb, tmp[0..length], 0);
         llmulacc(allocator, tmp, j0, j1);

lib/std/math/big/rational.zig

@@ -204,7 +204,6 @@ pub const Rational = struct {
         const esize = math.floatExponentBits(T);
         const ebias = (1 << (esize - 1)) - 1;
         const emin = 1 - ebias;
-        const emax = ebias;
 
         if (self.p.eqZero()) {
             return 0;

lib/std/math/complex/ldexp.zig

@@ -12,6 +12,7 @@
 const std = @import("../../std.zig");
 const debug = std.debug;
 const math = std.math;
+const testing = std.testing;
 const cmath = math.complex;
 const testing = std.testing;
 const Complex = cmath.Complex;
@@ -27,6 +28,11 @@ pub fn ldexp_cexp(z: anytype, expt: i32) @TypeOf(z) {
     };
 }
 
+test "ldexp_cexp" {
+    try std.testing.expectEqual(ldexp_cexp(Complex(f32).init(0.01, 10), 1), Complex(f32).init(-5.44588740e+32, -3.53089629e+32));
+    try std.testing.expectEqual(ldexp_cexp(Complex(f32).init(18.2, 10), 20), Complex(f32).init(-2.85521341e+38, -1.85120655e+38));
+}
+
 fn frexp_exp32(x: f32, expt: *i32) f32 {
     const k = 235; // reduction constant
     const kln2 = 162.88958740; // k * ln2