From 51595d6b75d8ac2443a2c142c71f2a617c12fe96 Mon Sep 17 00:00:00 2001 From: mlugg Date: Fri, 10 Nov 2023 05:27:17 +0000 Subject: [PATCH] lib: correct unnecessary uses of 'var' --- lib/build_runner.zig | 2 +- lib/compiler_rt/absvdi2_test.zig | 2 +- lib/compiler_rt/absvsi2_test.zig | 2 +- lib/compiler_rt/absvti2_test.zig | 2 +- lib/compiler_rt/addo.zig | 2 +- lib/compiler_rt/addodi4_test.zig | 4 +- lib/compiler_rt/addosi4_test.zig | 4 +- lib/compiler_rt/addoti4_test.zig | 4 +- lib/compiler_rt/bswapdi2_test.zig | 2 +- lib/compiler_rt/bswapsi2_test.zig | 2 +- lib/compiler_rt/bswapti2_test.zig | 2 +- lib/compiler_rt/ceil.zig | 2 +- lib/compiler_rt/clzdi2_test.zig | 4 +- lib/compiler_rt/clzti2_test.zig | 4 +- lib/compiler_rt/cmpdi2_test.zig | 2 +- lib/compiler_rt/cmpsi2_test.zig | 2 +- lib/compiler_rt/cmpti2_test.zig | 2 +- lib/compiler_rt/ctzdi2_test.zig | 4 +- lib/compiler_rt/ctzsi2_test.zig | 4 +- lib/compiler_rt/ctzti2_test.zig | 4 +- lib/compiler_rt/divc3_test.zig | 40 ++++----- lib/compiler_rt/divxf3.zig | 4 +- lib/compiler_rt/emutls.zig | 22 ++--- lib/compiler_rt/exp.zig | 2 +- lib/compiler_rt/exp2.zig | 2 +- lib/compiler_rt/ffsdi2_test.zig | 4 +- lib/compiler_rt/ffssi2_test.zig | 4 +- lib/compiler_rt/ffsti2_test.zig | 4 +- lib/compiler_rt/float_from_int.zig | 6 +- lib/compiler_rt/fma.zig | 32 +++---- lib/compiler_rt/fmod.zig | 16 ++-- lib/compiler_rt/mulc3.zig | 2 +- lib/compiler_rt/mulc3_test.zig | 32 +++---- lib/compiler_rt/mulo.zig | 4 +- lib/compiler_rt/negdi2_test.zig | 2 +- lib/compiler_rt/negsi2_test.zig | 2 +- lib/compiler_rt/negti2_test.zig | 2 +- lib/compiler_rt/negvdi2_test.zig | 2 +- lib/compiler_rt/negvsi2_test.zig | 2 +- lib/compiler_rt/negvti2_test.zig | 2 +- lib/compiler_rt/paritydi2_test.zig | 6 +- lib/compiler_rt/paritysi2_test.zig | 6 +- lib/compiler_rt/parityti2_test.zig | 6 +- lib/compiler_rt/popcountdi2_test.zig | 2 +- lib/compiler_rt/popcountsi2_test.zig | 2 +- lib/compiler_rt/popcountti2_test.zig | 2 +- lib/compiler_rt/powiXf2_test.zig | 10 +-- lib/compiler_rt/subo.zig | 2 +- lib/compiler_rt/subodi4_test.zig | 4 +- lib/compiler_rt/subosi4_test.zig | 4 +- lib/compiler_rt/suboti4_test.zig | 4 +- lib/compiler_rt/ucmpdi2_test.zig | 2 +- lib/compiler_rt/ucmpsi2_test.zig | 2 +- lib/compiler_rt/ucmpti2_test.zig | 2 +- lib/compiler_rt/udivmod.zig | 8 +- lib/compiler_rt/udivmodei4.zig | 4 +- lib/std/Build/Cache.zig | 2 +- lib/std/Build/Cache/DepTokenizer.zig | 6 +- lib/std/Build/Step/CheckObject.zig | 2 +- lib/std/Build/Step/ConfigHeader.zig | 4 +- lib/std/Build/Step/Run.zig | 2 +- lib/std/Progress.zig | 1 + lib/std/Thread/WaitGroup.zig | 2 +- lib/std/array_hash_map.zig | 6 +- lib/std/array_list.zig | 4 +- lib/std/atomic/Atomic.zig | 2 +- lib/std/atomic/queue.zig | 4 +- lib/std/atomic/stack.zig | 4 +- lib/std/base64.zig | 22 ++--- lib/std/buf_map.zig | 3 +- lib/std/buf_set.zig | 9 +- lib/std/builtin.zig | 7 +- lib/std/child_process.zig | 2 +- lib/std/coff.zig | 2 +- lib/std/compress/deflate/bits_utils.zig | 4 +- lib/std/compress/deflate/compressor.zig | 50 +++++------ lib/std/compress/deflate/compressor_test.zig | 32 +++---- lib/std/compress/deflate/decompressor.zig | 50 +++++------ lib/std/compress/deflate/deflate_fast.zig | 64 +++++++------- .../compress/deflate/deflate_fast_test.zig | 18 ++-- lib/std/compress/deflate/dict_decoder.zig | 14 +-- .../compress/deflate/huffman_bit_writer.zig | 86 +++++++++---------- lib/std/compress/deflate/huffman_code.zig | 16 ++-- lib/std/compress/zstandard.zig | 2 +- lib/std/compress/zstandard/decode/huffman.zig | 2 +- lib/std/compress/zstandard/decompress.zig | 4 +- lib/std/crypto/25519/curve25519.zig | 2 +- lib/std/crypto/25519/field.zig | 2 +- lib/std/crypto/Certificate.zig | 2 +- lib/std/crypto/aes.zig | 2 +- lib/std/crypto/aes_ocb.zig | 2 +- lib/std/crypto/argon2.zig | 2 +- lib/std/crypto/ascon.zig | 3 +- lib/std/crypto/bcrypt.zig | 2 +- lib/std/crypto/blake3.zig | 2 +- lib/std/crypto/ecdsa.zig | 2 +- lib/std/crypto/pbkdf2.zig | 6 +- lib/std/crypto/pcurves/common.zig | 2 +- lib/std/crypto/poly1305.zig | 6 +- lib/std/crypto/salsa20.zig | 6 +- lib/std/crypto/scrypt.zig | 14 +-- lib/std/crypto/tls/Client.zig | 6 +- lib/std/debug.zig | 8 +- lib/std/dwarf.zig | 10 +-- lib/std/dwarf/expressions.zig | 8 +- lib/std/enums.zig | 5 +- lib/std/event/group.zig | 2 +- lib/std/event/loop.zig | 2 +- lib/std/event/rwlock.zig | 8 +- lib/std/fmt.zig | 20 +++-- lib/std/fmt/errol.zig | 4 +- lib/std/fmt/parse_float/parse.zig | 4 +- lib/std/fs.zig | 4 +- lib/std/fs/get_app_data_dir.zig | 4 + lib/std/fs/test.zig | 2 +- lib/std/fs/watch.zig | 6 +- lib/std/hash/auto_hash.zig | 1 + lib/std/hash/cityhash.zig | 2 +- lib/std/hash/murmur.zig | 56 ++++++------ lib/std/hash_map.zig | 8 +- lib/std/heap.zig | 18 ++-- lib/std/heap/arena_allocator.zig | 2 +- lib/std/heap/general_purpose_allocator.zig | 6 +- lib/std/heap/memory_pool.zig | 2 +- lib/std/http/Client.zig | 2 +- lib/std/http/protocol.zig | 15 ++-- lib/std/io/Reader/test.zig | 16 ++-- lib/std/io/buffered_reader.zig | 25 +++--- lib/std/io/test.zig | 4 +- lib/std/json/dynamic_test.zig | 18 ++-- lib/std/json/static_test.zig | 18 ++-- lib/std/math.zig | 3 +- lib/std/math/atan.zig | 4 +- lib/std/math/atan2.zig | 16 ++-- lib/std/math/big/int.zig | 10 +-- lib/std/math/big/int_test.zig | 37 ++++++-- lib/std/math/cbrt.zig | 4 +- lib/std/math/complex/atan.zig | 4 +- lib/std/math/ilogb.zig | 4 +- lib/std/math/log1p.zig | 8 +- lib/std/math/sqrt.zig | 2 +- lib/std/mem.zig | 25 +++--- lib/std/meta.zig | 16 ++-- lib/std/meta/trait.zig | 7 +- lib/std/net.zig | 8 +- lib/std/net/test.zig | 10 +-- lib/std/os.zig | 12 +-- lib/std/os/linux.zig | 1 + lib/std/os/linux/io_uring.zig | 39 +++++---- lib/std/os/plan9.zig | 2 +- lib/std/os/test.zig | 30 +++---- lib/std/os/uefi.zig | 7 +- lib/std/os/uefi/device_path.zig | 4 +- lib/std/os/uefi/pool_allocator.zig | 2 +- lib/std/os/uefi/protocol/device_path.zig | 5 +- lib/std/os/windows.zig | 6 +- lib/std/pdb.zig | 2 +- lib/std/priority_dequeue.zig | 10 +-- lib/std/priority_queue.zig | 2 +- lib/std/process.zig | 24 +++--- lib/std/rand/test.zig | 4 +- lib/std/sort.zig | 2 +- lib/std/sort/block.zig | 4 +- lib/std/sort/pdq.zig | 8 +- lib/std/tar.zig | 2 +- lib/std/testing.zig | 20 ++--- lib/std/treap.zig | 2 +- lib/std/unicode.zig | 2 +- lib/std/zig/Parse.zig | 3 +- lib/std/zig/c_translation.zig | 15 ++-- lib/std/zig/perf_test.zig | 2 +- lib/std/zig/render.zig | 2 +- lib/std/zig/string_literal.zig | 2 +- lib/std/zig/system/NativeTargetInfo.zig | 2 +- 174 files changed, 738 insertions(+), 711 deletions(-) diff --git a/lib/build_runner.zig b/lib/build_runner.zig index 3eb405914f..a5e537c43c 100644 --- a/lib/build_runner.zig +++ b/lib/build_runner.zig @@ -24,7 +24,7 @@ pub fn main() !void { }; const arena = thread_safe_arena.allocator(); - var args = try process.argsAlloc(arena); + const args = try process.argsAlloc(arena); // skip my own exe name var arg_idx: usize = 1; diff --git a/lib/compiler_rt/absvdi2_test.zig b/lib/compiler_rt/absvdi2_test.zig index e861ef0ff3..ad6f9f63b3 100644 --- a/lib/compiler_rt/absvdi2_test.zig +++ b/lib/compiler_rt/absvdi2_test.zig @@ -3,7 +3,7 @@ const testing = @import("std").testing; const __absvdi2 = @import("absvdi2.zig").__absvdi2; fn test__absvdi2(a: i64, expected: i64) !void { - var result = __absvdi2(a); + const result = __absvdi2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/absvsi2_test.zig b/lib/compiler_rt/absvsi2_test.zig index 9c74ebee67..d0a2cbc341 100644 --- a/lib/compiler_rt/absvsi2_test.zig +++ b/lib/compiler_rt/absvsi2_test.zig @@ -3,7 +3,7 @@ const testing = @import("std").testing; const __absvsi2 = @import("absvsi2.zig").__absvsi2; fn test__absvsi2(a: i32, expected: i32) !void { - var result = __absvsi2(a); + const result = __absvsi2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/absvti2_test.zig b/lib/compiler_rt/absvti2_test.zig index fbed961775..62f5d76fa5 100644 --- a/lib/compiler_rt/absvti2_test.zig +++ b/lib/compiler_rt/absvti2_test.zig @@ -3,7 +3,7 @@ const testing = @import("std").testing; const __absvti2 = @import("absvti2.zig").__absvti2; fn test__absvti2(a: i128, expected: i128) !void { - var result = __absvti2(a); + const result = __absvti2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/addo.zig b/lib/compiler_rt/addo.zig index 5248dfb8b8..2663dc5cae 100644 --- a/lib/compiler_rt/addo.zig +++ b/lib/compiler_rt/addo.zig @@ -18,7 +18,7 @@ comptime { inline fn addoXi4_generic(comptime ST: type, a: ST, b: ST, overflow: *c_int) ST { @setRuntimeSafety(builtin.is_test); overflow.* = 0; - var sum: ST = a +% b; + const sum: ST = a +% b; // Hackers Delight: section Overflow Detection, subsection Signed Add/Subtract // Let sum = a +% b == a + b + carry == wraparound addition. // Overflow in a+b+carry occurs, iff a and b have opposite signs diff --git a/lib/compiler_rt/addodi4_test.zig b/lib/compiler_rt/addodi4_test.zig index f70a80a5b2..92f8e9c1f2 100644 --- a/lib/compiler_rt/addodi4_test.zig +++ b/lib/compiler_rt/addodi4_test.zig @@ -6,8 +6,8 @@ const math = std.math; fn test__addodi4(a: i64, b: i64) !void { var result_ov: c_int = undefined; var expected_ov: c_int = undefined; - var result = addv.__addodi4(a, b, &result_ov); - var expected: i64 = simple_addodi4(a, b, &expected_ov); + const result = addv.__addodi4(a, b, &result_ov); + const expected: i64 = simple_addodi4(a, b, &expected_ov); try testing.expectEqual(expected, result); try testing.expectEqual(expected_ov, result_ov); } diff --git a/lib/compiler_rt/addosi4_test.zig b/lib/compiler_rt/addosi4_test.zig index a8f81d70d1..3494909f50 100644 --- a/lib/compiler_rt/addosi4_test.zig +++ b/lib/compiler_rt/addosi4_test.zig @@ -4,8 +4,8 @@ const testing = @import("std").testing; fn test__addosi4(a: i32, b: i32) !void { var result_ov: c_int = undefined; var expected_ov: c_int = undefined; - var result = addv.__addosi4(a, b, &result_ov); - var expected: i32 = simple_addosi4(a, b, &expected_ov); + const result = addv.__addosi4(a, b, &result_ov); + const expected: i32 = simple_addosi4(a, b, &expected_ov); try testing.expectEqual(expected, result); try testing.expectEqual(expected_ov, result_ov); } diff --git a/lib/compiler_rt/addoti4_test.zig b/lib/compiler_rt/addoti4_test.zig index dd0f4e3d3c..dc85830df9 100644 --- a/lib/compiler_rt/addoti4_test.zig +++ b/lib/compiler_rt/addoti4_test.zig @@ -6,8 +6,8 @@ const math = std.math; fn test__addoti4(a: i128, b: i128) !void { var result_ov: c_int = undefined; var expected_ov: c_int = undefined; - var result = addv.__addoti4(a, b, &result_ov); - var expected: i128 = simple_addoti4(a, b, &expected_ov); + const result = addv.__addoti4(a, b, &result_ov); + const expected: i128 = simple_addoti4(a, b, &expected_ov); try testing.expectEqual(expected, result); try testing.expectEqual(expected_ov, result_ov); } diff --git a/lib/compiler_rt/bswapdi2_test.zig b/lib/compiler_rt/bswapdi2_test.zig index a425179920..78e1492b4f 100644 --- a/lib/compiler_rt/bswapdi2_test.zig +++ b/lib/compiler_rt/bswapdi2_test.zig @@ -2,7 +2,7 @@ const bswap = @import("bswap.zig"); const testing = @import("std").testing; fn test__bswapdi2(a: u64, expected: u64) !void { - var result = bswap.__bswapdi2(a); + const result = bswap.__bswapdi2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/bswapsi2_test.zig b/lib/compiler_rt/bswapsi2_test.zig index 912d3b2819..4a138f88c5 100644 --- a/lib/compiler_rt/bswapsi2_test.zig +++ b/lib/compiler_rt/bswapsi2_test.zig @@ -2,7 +2,7 @@ const bswap = @import("bswap.zig"); const testing = @import("std").testing; fn test__bswapsi2(a: u32, expected: u32) !void { - var result = bswap.__bswapsi2(a); + const result = bswap.__bswapsi2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/bswapti2_test.zig b/lib/compiler_rt/bswapti2_test.zig index 6a164a28b3..c190961dc3 100644 --- a/lib/compiler_rt/bswapti2_test.zig +++ b/lib/compiler_rt/bswapti2_test.zig @@ -2,7 +2,7 @@ const bswap = @import("bswap.zig"); const testing = @import("std").testing; fn test__bswapti2(a: u128, expected: u128) !void { - var result = bswap.__bswapti2(a); + const result = bswap.__bswapti2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/ceil.zig b/lib/compiler_rt/ceil.zig index baa9edbee4..41ce1c00d8 100644 --- a/lib/compiler_rt/ceil.zig +++ b/lib/compiler_rt/ceil.zig @@ -32,7 +32,7 @@ pub fn __ceilh(x: f16) callconv(.C) f16 { pub fn ceilf(x: f32) callconv(.C) f32 { var u: u32 = @bitCast(x); - var e = @as(i32, @intCast((u >> 23) & 0xFF)) - 0x7F; + const e = @as(i32, @intCast((u >> 23) & 0xFF)) - 0x7F; var m: u32 = undefined; // TODO: Shouldn't need this explicit check. diff --git a/lib/compiler_rt/clzdi2_test.zig b/lib/compiler_rt/clzdi2_test.zig index b4b120e754..decb28421e 100644 --- a/lib/compiler_rt/clzdi2_test.zig +++ b/lib/compiler_rt/clzdi2_test.zig @@ -2,8 +2,8 @@ const clz = @import("count0bits.zig"); const testing = @import("std").testing; fn test__clzdi2(a: u64, expected: i64) !void { - var x: i64 = @bitCast(a); - var result = clz.__clzdi2(x); + const x: i64 = @bitCast(a); + const result = clz.__clzdi2(x); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/clzti2_test.zig b/lib/compiler_rt/clzti2_test.zig index 9477a34f70..cc2bbb163f 100644 --- a/lib/compiler_rt/clzti2_test.zig +++ b/lib/compiler_rt/clzti2_test.zig @@ -2,8 +2,8 @@ const clz = @import("count0bits.zig"); const testing = @import("std").testing; fn test__clzti2(a: u128, expected: i64) !void { - var x: i128 = @bitCast(a); - var result = clz.__clzti2(x); + const x: i128 = @bitCast(a); + const result = clz.__clzti2(x); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/cmpdi2_test.zig b/lib/compiler_rt/cmpdi2_test.zig index a6d136b875..3291a6564f 100644 --- a/lib/compiler_rt/cmpdi2_test.zig +++ b/lib/compiler_rt/cmpdi2_test.zig @@ -2,7 +2,7 @@ const cmp = @import("cmp.zig"); const testing = @import("std").testing; fn test__cmpdi2(a: i64, b: i64, expected: i64) !void { - var result = cmp.__cmpdi2(a, b); + const result = cmp.__cmpdi2(a, b); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/cmpsi2_test.zig b/lib/compiler_rt/cmpsi2_test.zig index caf3599974..c418c2e14a 100644 --- a/lib/compiler_rt/cmpsi2_test.zig +++ b/lib/compiler_rt/cmpsi2_test.zig @@ -2,7 +2,7 @@ const cmp = @import("cmp.zig"); const testing = @import("std").testing; fn test__cmpsi2(a: i32, b: i32, expected: i32) !void { - var result = cmp.__cmpsi2(a, b); + const result = cmp.__cmpsi2(a, b); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/cmpti2_test.zig b/lib/compiler_rt/cmpti2_test.zig index 50f84e9952..3f83f2fa9c 100644 --- a/lib/compiler_rt/cmpti2_test.zig +++ b/lib/compiler_rt/cmpti2_test.zig @@ -2,7 +2,7 @@ const cmp = @import("cmp.zig"); const testing = @import("std").testing; fn test__cmpti2(a: i128, b: i128, expected: i128) !void { - var result = cmp.__cmpti2(a, b); + const result = cmp.__cmpti2(a, b); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/ctzdi2_test.zig b/lib/compiler_rt/ctzdi2_test.zig index 7850ac53c4..eb7822de70 100644 --- a/lib/compiler_rt/ctzdi2_test.zig +++ b/lib/compiler_rt/ctzdi2_test.zig @@ -2,8 +2,8 @@ const ctz = @import("count0bits.zig"); const testing = @import("std").testing; fn test__ctzdi2(a: u64, expected: i32) !void { - var x: i64 = @bitCast(a); - var result = ctz.__ctzdi2(x); + const x: i64 = @bitCast(a); + const result = ctz.__ctzdi2(x); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/ctzsi2_test.zig b/lib/compiler_rt/ctzsi2_test.zig index c273c959fe..e545d22c33 100644 --- a/lib/compiler_rt/ctzsi2_test.zig +++ b/lib/compiler_rt/ctzsi2_test.zig @@ -2,8 +2,8 @@ const ctz = @import("count0bits.zig"); const testing = @import("std").testing; fn test__ctzsi2(a: u32, expected: i32) !void { - var x: i32 = @bitCast(a); - var result = ctz.__ctzsi2(x); + const x: i32 = @bitCast(a); + const result = ctz.__ctzsi2(x); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/ctzti2_test.zig b/lib/compiler_rt/ctzti2_test.zig index 2b881bbf8a..70a0cd0a77 100644 --- a/lib/compiler_rt/ctzti2_test.zig +++ b/lib/compiler_rt/ctzti2_test.zig @@ -2,8 +2,8 @@ const ctz = @import("count0bits.zig"); const testing = @import("std").testing; fn test__ctzti2(a: u128, expected: i32) !void { - var x: i128 = @bitCast(a); - var result = ctz.__ctzti2(x); + const x: i128 = @bitCast(a); + const result = ctz.__ctzti2(x); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/divc3_test.zig b/lib/compiler_rt/divc3_test.zig index 525e2f70fc..4056168e1e 100644 --- a/lib/compiler_rt/divc3_test.zig +++ b/lib/compiler_rt/divc3_test.zig @@ -19,20 +19,20 @@ test { fn testDiv(comptime T: type, comptime f: fn (T, T, T, T) callconv(.C) Complex(T)) !void { { - var a: T = 1.0; - var b: T = 0.0; - var c: T = -1.0; - var d: T = 0.0; + const a: T = 1.0; + const b: T = 0.0; + const c: T = -1.0; + const d: T = 0.0; const result = f(a, b, c, d); try expect(result.real == -1.0); try expect(result.imag == 0.0); } { - var a: T = 1.0; - var b: T = 0.0; - var c: T = -4.0; - var d: T = 0.0; + const a: T = 1.0; + const b: T = 0.0; + const c: T = -4.0; + const d: T = 0.0; const result = f(a, b, c, d); try expect(result.real == -0.25); @@ -41,10 +41,10 @@ fn testDiv(comptime T: type, comptime f: fn (T, T, T, T) callconv(.C) Complex(T) { // if the first operand is an infinity and the second operand is a finite number, then the // result of the / operator is an infinity; - var a: T = -math.inf(T); - var b: T = 0.0; - var c: T = -4.0; - var d: T = 1.0; + const a: T = -math.inf(T); + const b: T = 0.0; + const c: T = -4.0; + const d: T = 1.0; const result = f(a, b, c, d); try expect(result.real == math.inf(T)); @@ -53,10 +53,10 @@ fn testDiv(comptime T: type, comptime f: fn (T, T, T, T) callconv(.C) Complex(T) { // if the first operand is a finite number and the second operand is an infinity, then the // result of the / operator is a zero; - var a: T = 17.2; - var b: T = 0.0; - var c: T = -math.inf(T); - var d: T = 0.0; + const a: T = 17.2; + const b: T = 0.0; + const c: T = -math.inf(T); + const d: T = 0.0; const result = f(a, b, c, d); try expect(result.real == -0.0); @@ -65,10 +65,10 @@ fn testDiv(comptime T: type, comptime f: fn (T, T, T, T) callconv(.C) Complex(T) { // if the first operand is a nonzero finite number or an infinity and the second operand is // a zero, then the result of the / operator is an infinity - var a: T = 1.1; - var b: T = 0.1; - var c: T = 0.0; - var d: T = 0.0; + const a: T = 1.1; + const b: T = 0.1; + const c: T = 0.0; + const d: T = 0.0; const result = f(a, b, c, d); try expect(result.real == math.inf(T)); diff --git a/lib/compiler_rt/divxf3.zig b/lib/compiler_rt/divxf3.zig index baa39cd61c..84a7da0fc3 100644 --- a/lib/compiler_rt/divxf3.zig +++ b/lib/compiler_rt/divxf3.zig @@ -162,7 +162,7 @@ pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 { // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0). // Right shift the quotient if it falls in the [1,2) range and adjust the // exponent accordingly. - var quotient: u64 = if (quotient128 < (integerBit << 1)) b: { + const quotient: u64 = if (quotient128 < (integerBit << 1)) b: { quotientExponent -= 1; break :b @intCast(quotient128); } else @intCast(quotient128 >> 1); @@ -177,7 +177,7 @@ pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 { // // If r is greater than 1/2 ulp(q)*b, then q rounds up. Otherwise, we // already have the correct result. The exact halfway case cannot occur. - var residual: u64 = -%(quotient *% q63b); + const residual: u64 = -%(quotient *% q63b); const writtenExponent = quotientExponent + exponentBias; if (writtenExponent >= maxExponent) { diff --git a/lib/compiler_rt/emutls.zig b/lib/compiler_rt/emutls.zig index 01c090deab..3a04012925 100644 --- a/lib/compiler_rt/emutls.zig +++ b/lib/compiler_rt/emutls.zig @@ -57,8 +57,8 @@ const simple_allocator = struct { /// Resize a slice. pub fn reallocSlice(comptime T: type, slice: []T, len: usize) []T { - var c_ptr: *anyopaque = @ptrCast(slice.ptr); - var new_array: [*]T = @ptrCast(@alignCast(std.c.realloc(c_ptr, @sizeOf(T) * len) orelse abort())); + const c_ptr: *anyopaque = @ptrCast(slice.ptr); + const new_array: [*]T = @ptrCast(@alignCast(std.c.realloc(c_ptr, @sizeOf(T) * len) orelse abort())); return new_array[0..len]; } @@ -78,7 +78,7 @@ const ObjectArray = struct { /// create a new ObjectArray with n slots. must call deinit() to deallocate. pub fn init(n: usize) *ObjectArray { - var array = simple_allocator.alloc(ObjectArray); + const array = simple_allocator.alloc(ObjectArray); array.* = ObjectArray{ .slots = simple_allocator.allocSlice(?ObjectPointer, n), @@ -166,7 +166,7 @@ const current_thread_storage = struct { const size = @max(16, index); // create a new array and store it. - var array: *ObjectArray = ObjectArray.init(size); + const array: *ObjectArray = ObjectArray.init(size); current_thread_storage.setspecific(array); return array; } @@ -304,13 +304,13 @@ const emutls_control = extern struct { test "simple_allocator" { if (!builtin.link_libc or builtin.os.tag != .openbsd) return error.SkipZigTest; - var data1: *[64]u8 = simple_allocator.alloc([64]u8); + const data1: *[64]u8 = simple_allocator.alloc([64]u8); defer simple_allocator.free(data1); for (data1) |*c| { c.* = 0xff; } - var data2: [*]u8 = simple_allocator.advancedAlloc(@alignOf(u8), 64); + const data2: [*]u8 = simple_allocator.advancedAlloc(@alignOf(u8), 64); defer simple_allocator.free(data2); for (data2[0..63]) |*c| { c.* = 0xff; @@ -324,7 +324,7 @@ test "__emutls_get_address zeroed" { try expect(ctl.object.index == 0); // retrieve a variable from ctl - var x: *usize = @ptrCast(@alignCast(__emutls_get_address(&ctl))); + const x: *usize = @ptrCast(@alignCast(__emutls_get_address(&ctl))); try expect(ctl.object.index != 0); // index has been allocated for this ctl try expect(x.* == 0); // storage has been zeroed @@ -332,7 +332,7 @@ test "__emutls_get_address zeroed" { x.* = 1234; // retrieve a variable from ctl (same ctl) - var y: *usize = @ptrCast(@alignCast(__emutls_get_address(&ctl))); + const y: *usize = @ptrCast(@alignCast(__emutls_get_address(&ctl))); try expect(y.* == 1234); // same content that x.* try expect(x == y); // same pointer @@ -345,7 +345,7 @@ test "__emutls_get_address with default_value" { var ctl = emutls_control.init(usize, &value); try expect(ctl.object.index == 0); - var x: *usize = @ptrCast(@alignCast(__emutls_get_address(&ctl))); + const x: *usize = @ptrCast(@alignCast(__emutls_get_address(&ctl))); try expect(ctl.object.index != 0); try expect(x.* == 5678); // storage initialized with default value @@ -354,7 +354,7 @@ test "__emutls_get_address with default_value" { try expect(value == 5678); // the default value didn't change - var y: *usize = @ptrCast(@alignCast(__emutls_get_address(&ctl))); + const y: *usize = @ptrCast(@alignCast(__emutls_get_address(&ctl))); try expect(y.* == 9012); // the modified storage persists } @@ -364,7 +364,7 @@ test "test default_value with differents sizes" { const testType = struct { fn _testType(comptime T: type, value: T) !void { var ctl = emutls_control.init(T, &value); - var x = ctl.get_typed_pointer(T); + const x = ctl.get_typed_pointer(T); try expect(x.* == value); } }._testType; diff --git a/lib/compiler_rt/exp.zig b/lib/compiler_rt/exp.zig index 65a6adb440..6b8ac04076 100644 --- a/lib/compiler_rt/exp.zig +++ b/lib/compiler_rt/exp.zig @@ -117,7 +117,7 @@ pub fn exp(x_: f64) callconv(.C) f64 { const P5: f64 = 4.13813679705723846039e-08; var x = x_; - var ux: u64 = @bitCast(x); + const ux: u64 = @bitCast(x); var hx = ux >> 32; const sign: i32 = @intCast(hx >> 31); hx &= 0x7FFFFFFF; diff --git a/lib/compiler_rt/exp2.zig b/lib/compiler_rt/exp2.zig index 84bbe19d73..5ffb73c4f5 100644 --- a/lib/compiler_rt/exp2.zig +++ b/lib/compiler_rt/exp2.zig @@ -38,7 +38,7 @@ pub fn exp2f(x: f32) callconv(.C) f32 { const P3: f32 = 0x1.c6b348p-5; const P4: f32 = 0x1.3b2c9cp-7; - var u: u32 = @bitCast(x); + const u: u32 = @bitCast(x); const ix = u & 0x7FFFFFFF; // |x| > 126 diff --git a/lib/compiler_rt/ffsdi2_test.zig b/lib/compiler_rt/ffsdi2_test.zig index 135052bf39..1845990231 100644 --- a/lib/compiler_rt/ffsdi2_test.zig +++ b/lib/compiler_rt/ffsdi2_test.zig @@ -2,8 +2,8 @@ const ffs = @import("count0bits.zig"); const testing = @import("std").testing; fn test__ffsdi2(a: u64, expected: i32) !void { - var x = @as(i64, @bitCast(a)); - var result = ffs.__ffsdi2(x); + const x = @as(i64, @bitCast(a)); + const result = ffs.__ffsdi2(x); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/ffssi2_test.zig b/lib/compiler_rt/ffssi2_test.zig index 38435a9e4b..24cb24eb3d 100644 --- a/lib/compiler_rt/ffssi2_test.zig +++ b/lib/compiler_rt/ffssi2_test.zig @@ -2,8 +2,8 @@ const ffs = @import("count0bits.zig"); const testing = @import("std").testing; fn test__ffssi2(a: u32, expected: i32) !void { - var x = @as(i32, @bitCast(a)); - var result = ffs.__ffssi2(x); + const x = @as(i32, @bitCast(a)); + const result = ffs.__ffssi2(x); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/ffsti2_test.zig b/lib/compiler_rt/ffsti2_test.zig index a0686b33e4..b5bc73f3b3 100644 --- a/lib/compiler_rt/ffsti2_test.zig +++ b/lib/compiler_rt/ffsti2_test.zig @@ -2,8 +2,8 @@ const ffs = @import("count0bits.zig"); const testing = @import("std").testing; fn test__ffsti2(a: u128, expected: i32) !void { - var x = @as(i128, @bitCast(a)); - var result = ffs.__ffsti2(x); + const x = @as(i128, @bitCast(a)); + const result = ffs.__ffsti2(x); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/float_from_int.zig b/lib/compiler_rt/float_from_int.zig index 5ef511a4bf..66f5eb0587 100644 --- a/lib/compiler_rt/float_from_int.zig +++ b/lib/compiler_rt/float_from_int.zig @@ -18,12 +18,12 @@ pub fn floatFromInt(comptime T: type, x: anytype) T { const max_exp = exp_bias; // Sign - var abs_val = if (@TypeOf(x) == comptime_int or @typeInfo(@TypeOf(x)).Int.signedness == .signed) @abs(x) else x; + const abs_val = if (@TypeOf(x) == comptime_int or @typeInfo(@TypeOf(x)).Int.signedness == .signed) @abs(x) else x; const sign_bit = if (x < 0) @as(uT, 1) << (float_bits - 1) else 0; var result: uT = sign_bit; // Compute significand - var exp = int_bits - @clz(abs_val) - 1; + const exp = int_bits - @clz(abs_val) - 1; if (int_bits <= fractional_bits or exp <= fractional_bits) { const shift_amt = fractional_bits - @as(math.Log2Int(uT), @intCast(exp)); @@ -31,7 +31,7 @@ pub fn floatFromInt(comptime T: type, x: anytype) T { result = @as(uT, @intCast(abs_val)) << shift_amt; result ^= implicit_bit; // Remove implicit integer bit } else { - var shift_amt: math.Log2Int(Z) = @intCast(exp - fractional_bits); + const shift_amt: math.Log2Int(Z) = @intCast(exp - fractional_bits); const exact_tie: bool = @ctz(abs_val) == shift_amt - 1; // Shift down result and remove implicit integer bit diff --git a/lib/compiler_rt/fma.zig b/lib/compiler_rt/fma.zig index accc4ed36c..ad775db5dd 100644 --- a/lib/compiler_rt/fma.zig +++ b/lib/compiler_rt/fma.zig @@ -59,13 +59,13 @@ pub fn fma(x: f64, y: f64, z: f64) callconv(.C) f64 { } const x1 = math.frexp(x); - var ex = x1.exponent; - var xs = x1.significand; + const ex = x1.exponent; + const xs = x1.significand; const x2 = math.frexp(y); - var ey = x2.exponent; - var ys = x2.significand; + const ey = x2.exponent; + const ys = x2.significand; const x3 = math.frexp(z); - var ez = x3.exponent; + const ez = x3.exponent; var zs = x3.significand; var spread = ex + ey - ez; @@ -118,13 +118,13 @@ pub fn fmaq(x: f128, y: f128, z: f128) callconv(.C) f128 { } const x1 = math.frexp(x); - var ex = x1.exponent; - var xs = x1.significand; + const ex = x1.exponent; + const xs = x1.significand; const x2 = math.frexp(y); - var ey = x2.exponent; - var ys = x2.significand; + const ey = x2.exponent; + const ys = x2.significand; const x3 = math.frexp(z); - var ez = x3.exponent; + const ez = x3.exponent; var zs = x3.significand; var spread = ex + ey - ez; @@ -181,15 +181,15 @@ fn dd_mul(a: f64, b: f64) dd { var p = a * split; var ha = a - p; ha += p; - var la = a - ha; + const la = a - ha; p = b * split; var hb = b - p; hb += p; - var lb = b - hb; + const lb = b - hb; p = ha * hb; - var q = ha * lb + la * hb; + const q = ha * lb + la * hb; ret.hi = p + q; ret.lo = p - ret.hi + q + la * lb; @@ -301,15 +301,15 @@ fn dd_mul128(a: f128, b: f128) dd128 { var p = a * split; var ha = a - p; ha += p; - var la = a - ha; + const la = a - ha; p = b * split; var hb = b - p; hb += p; - var lb = b - hb; + const lb = b - hb; p = ha * hb; - var q = ha * lb + la * hb; + const q = ha * lb + la * hb; ret.hi = p + q; ret.lo = p - ret.hi + q + la * lb; diff --git a/lib/compiler_rt/fmod.zig b/lib/compiler_rt/fmod.zig index 7c40298f32..08e1ff892c 100644 --- a/lib/compiler_rt/fmod.zig +++ b/lib/compiler_rt/fmod.zig @@ -81,13 +81,13 @@ pub fn __fmodx(a: f80, b: f80) callconv(.C) f80 { if (expB == 0) expB = normalize(f80, &bRep); var highA: u64 = 0; - var highB: u64 = 0; + const highB: u64 = 0; var lowA: u64 = @truncate(aRep); - var lowB: u64 = @truncate(bRep); + const lowB: u64 = @truncate(bRep); while (expA > expB) : (expA -= 1) { var high = highA -% highB; - var low = lowA -% lowB; + const low = lowA -% lowB; if (lowA < lowB) { high -%= 1; } @@ -104,7 +104,7 @@ pub fn __fmodx(a: f80, b: f80) callconv(.C) f80 { } var high = highA -% highB; - var low = lowA -% lowB; + const low = lowA -% lowB; if (lowA < lowB) { high -%= 1; } @@ -194,13 +194,13 @@ pub fn fmodq(a: f128, b: f128) callconv(.C) f128 { // OR in extra non-stored mantissa digit var highA: u64 = (aPtr_u64[high_index] & (std.math.maxInt(u64) >> 16)) | 1 << 48; - var highB: u64 = (bPtr_u64[high_index] & (std.math.maxInt(u64) >> 16)) | 1 << 48; + const highB: u64 = (bPtr_u64[high_index] & (std.math.maxInt(u64) >> 16)) | 1 << 48; var lowA: u64 = aPtr_u64[low_index]; - var lowB: u64 = bPtr_u64[low_index]; + const lowB: u64 = bPtr_u64[low_index]; while (expA > expB) : (expA -= 1) { var high = highA -% highB; - var low = lowA -% lowB; + const low = lowA -% lowB; if (lowA < lowB) { high -%= 1; } @@ -217,7 +217,7 @@ pub fn fmodq(a: f128, b: f128) callconv(.C) f128 { } var high = highA -% highB; - var low = lowA -% lowB; + const low = lowA -% lowB; if (lowA < lowB) { high -= 1; } diff --git a/lib/compiler_rt/mulc3.zig b/lib/compiler_rt/mulc3.zig index 0033df70b6..eea753245f 100644 --- a/lib/compiler_rt/mulc3.zig +++ b/lib/compiler_rt/mulc3.zig @@ -25,7 +25,7 @@ pub inline fn mulc3(comptime T: type, a_in: T, b_in: T, c_in: T, d_in: T) Comple const zero: T = 0.0; const one: T = 1.0; - var z = Complex(T){ + const z: Complex(T) = .{ .real = ac - bd, .imag = ad + bc, }; diff --git a/lib/compiler_rt/mulc3_test.zig b/lib/compiler_rt/mulc3_test.zig index b07ecd12ae..6495f1cfe1 100644 --- a/lib/compiler_rt/mulc3_test.zig +++ b/lib/compiler_rt/mulc3_test.zig @@ -19,20 +19,20 @@ test { fn testMul(comptime T: type, comptime f: fn (T, T, T, T) callconv(.C) Complex(T)) !void { { - var a: T = 1.0; - var b: T = 0.0; - var c: T = -1.0; - var d: T = 0.0; + const a: T = 1.0; + const b: T = 0.0; + const c: T = -1.0; + const d: T = 0.0; const result = f(a, b, c, d); try expect(result.real == -1.0); try expect(result.imag == 0.0); } { - var a: T = 1.0; - var b: T = 0.0; - var c: T = -4.0; - var d: T = 0.0; + const a: T = 1.0; + const b: T = 0.0; + const c: T = -4.0; + const d: T = 0.0; const result = f(a, b, c, d); try expect(result.real == -4.0); @@ -41,10 +41,10 @@ fn testMul(comptime T: type, comptime f: fn (T, T, T, T) callconv(.C) Complex(T) { // if one operand is an infinity and the other operand is a nonzero finite number or an infinity, // then the result of the * operator is an infinity; - var a: T = math.inf(T); - var b: T = -math.inf(T); - var c: T = 1.0; - var d: T = 0.0; + const a: T = math.inf(T); + const b: T = -math.inf(T); + const c: T = 1.0; + const d: T = 0.0; const result = f(a, b, c, d); try expect(result.real == math.inf(T)); @@ -53,10 +53,10 @@ fn testMul(comptime T: type, comptime f: fn (T, T, T, T) callconv(.C) Complex(T) { // if one operand is an infinity and the other operand is a nonzero finite number or an infinity, // then the result of the * operator is an infinity; - var a: T = math.inf(T); - var b: T = -1.0; - var c: T = 1.0; - var d: T = math.inf(T); + const a: T = math.inf(T); + const b: T = -1.0; + const c: T = 1.0; + const d: T = math.inf(T); const result = f(a, b, c, d); try expect(result.real == math.inf(T)); diff --git a/lib/compiler_rt/mulo.zig b/lib/compiler_rt/mulo.zig index d40554da10..ec77068fc6 100644 --- a/lib/compiler_rt/mulo.zig +++ b/lib/compiler_rt/mulo.zig @@ -20,7 +20,7 @@ comptime { inline fn muloXi4_genericSmall(comptime ST: type, a: ST, b: ST, overflow: *c_int) ST { overflow.* = 0; const min = math.minInt(ST); - var res: ST = a *% b; + const res: ST = a *% b; // Hacker's Delight section Overflow subsection Multiplication // case a=-2^{31}, b=-1 problem, because // on some machines a*b = -2^{31} with overflow @@ -41,7 +41,7 @@ inline fn muloXi4_genericFast(comptime ST: type, a: ST, b: ST, overflow: *c_int) }; const min = math.minInt(ST); const max = math.maxInt(ST); - var res: EST = @as(EST, a) * @as(EST, b); + const res: EST = @as(EST, a) * @as(EST, b); //invariant: -2^{bitwidth(EST)} < res < 2^{bitwidth(EST)-1} if (res < min or max < res) overflow.* = 1; diff --git a/lib/compiler_rt/negdi2_test.zig b/lib/compiler_rt/negdi2_test.zig index 2bb6ad29a8..a4bb0217ad 100644 --- a/lib/compiler_rt/negdi2_test.zig +++ b/lib/compiler_rt/negdi2_test.zig @@ -2,7 +2,7 @@ const neg = @import("negXi2.zig"); const testing = @import("std").testing; fn test__negdi2(a: i64, expected: i64) !void { - var result = neg.__negdi2(a); + const result = neg.__negdi2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/negsi2_test.zig b/lib/compiler_rt/negsi2_test.zig index 608a44c12f..2584de2136 100644 --- a/lib/compiler_rt/negsi2_test.zig +++ b/lib/compiler_rt/negsi2_test.zig @@ -5,7 +5,7 @@ const testing = std.testing; const print = std.debug.print; fn test__negsi2(a: i32, expected: i32) !void { - var result = neg.__negsi2(a); + const result = neg.__negsi2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/negti2_test.zig b/lib/compiler_rt/negti2_test.zig index 37841573c1..d58f9c8f27 100644 --- a/lib/compiler_rt/negti2_test.zig +++ b/lib/compiler_rt/negti2_test.zig @@ -2,7 +2,7 @@ const neg = @import("negXi2.zig"); const testing = @import("std").testing; fn test__negti2(a: i128, expected: i128) !void { - var result = neg.__negti2(a); + const result = neg.__negti2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/negvdi2_test.zig b/lib/compiler_rt/negvdi2_test.zig index 25a7213f69..8d791c5371 100644 --- a/lib/compiler_rt/negvdi2_test.zig +++ b/lib/compiler_rt/negvdi2_test.zig @@ -2,7 +2,7 @@ const negv = @import("negv.zig"); const testing = @import("std").testing; fn test__negvdi2(a: i64, expected: i64) !void { - var result = negv.__negvdi2(a); + const result = negv.__negvdi2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/negvsi2_test.zig b/lib/compiler_rt/negvsi2_test.zig index 4e0c27c9ae..f502b65d2b 100644 --- a/lib/compiler_rt/negvsi2_test.zig +++ b/lib/compiler_rt/negvsi2_test.zig @@ -2,7 +2,7 @@ const negv = @import("negv.zig"); const testing = @import("std").testing; fn test__negvsi2(a: i32, expected: i32) !void { - var result = negv.__negvsi2(a); + const result = negv.__negvsi2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/negvti2_test.zig b/lib/compiler_rt/negvti2_test.zig index aa50f2bd43..dd183481e8 100644 --- a/lib/compiler_rt/negvti2_test.zig +++ b/lib/compiler_rt/negvti2_test.zig @@ -2,7 +2,7 @@ const negv = @import("negv.zig"); const testing = @import("std").testing; fn test__negvti2(a: i128, expected: i128) !void { - var result = negv.__negvti2(a); + const result = negv.__negvti2(a); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/paritydi2_test.zig b/lib/compiler_rt/paritydi2_test.zig index 92f8e6a53e..fdcbe3ac68 100644 --- a/lib/compiler_rt/paritydi2_test.zig +++ b/lib/compiler_rt/paritydi2_test.zig @@ -13,8 +13,8 @@ fn paritydi2Naive(a: i64) i32 { } fn test__paritydi2(a: i64) !void { - var x = parity.__paritydi2(a); - var expected: i64 = paritydi2Naive(a); + const x = parity.__paritydi2(a); + const expected: i64 = paritydi2Naive(a); try testing.expectEqual(expected, x); } @@ -30,7 +30,7 @@ test "paritydi2" { var rnd = RndGen.init(42); var i: u32 = 0; while (i < 10_000) : (i += 1) { - var rand_num = rnd.random().int(i64); + const rand_num = rnd.random().int(i64); try test__paritydi2(rand_num); } } diff --git a/lib/compiler_rt/paritysi2_test.zig b/lib/compiler_rt/paritysi2_test.zig index 804dc74c33..ec1820c4fd 100644 --- a/lib/compiler_rt/paritysi2_test.zig +++ b/lib/compiler_rt/paritysi2_test.zig @@ -13,8 +13,8 @@ fn paritysi2Naive(a: i32) i32 { } fn test__paritysi2(a: i32) !void { - var x = parity.__paritysi2(a); - var expected: i32 = paritysi2Naive(a); + const x = parity.__paritysi2(a); + const expected: i32 = paritysi2Naive(a); try testing.expectEqual(expected, x); } @@ -30,7 +30,7 @@ test "paritysi2" { var rnd = RndGen.init(42); var i: u32 = 0; while (i < 10_000) : (i += 1) { - var rand_num = rnd.random().int(i32); + const rand_num = rnd.random().int(i32); try test__paritysi2(rand_num); } } diff --git a/lib/compiler_rt/parityti2_test.zig b/lib/compiler_rt/parityti2_test.zig index f934ee9021..587cc1890f 100644 --- a/lib/compiler_rt/parityti2_test.zig +++ b/lib/compiler_rt/parityti2_test.zig @@ -13,8 +13,8 @@ fn parityti2Naive(a: i128) i32 { } fn test__parityti2(a: i128) !void { - var x = parity.__parityti2(a); - var expected: i128 = parityti2Naive(a); + const x = parity.__parityti2(a); + const expected: i128 = parityti2Naive(a); try testing.expectEqual(expected, x); } @@ -30,7 +30,7 @@ test "parityti2" { var rnd = RndGen.init(42); var i: u32 = 0; while (i < 10_000) : (i += 1) { - var rand_num = rnd.random().int(i128); + const rand_num = rnd.random().int(i128); try test__parityti2(rand_num); } } diff --git a/lib/compiler_rt/popcountdi2_test.zig b/lib/compiler_rt/popcountdi2_test.zig index daf2c1f183..b3967c410b 100644 --- a/lib/compiler_rt/popcountdi2_test.zig +++ b/lib/compiler_rt/popcountdi2_test.zig @@ -29,7 +29,7 @@ test "popcountdi2" { var rnd = RndGen.init(42); var i: u32 = 0; while (i < 10_000) : (i += 1) { - var rand_num = rnd.random().int(i64); + const rand_num = rnd.random().int(i64); try test__popcountdi2(rand_num); } } diff --git a/lib/compiler_rt/popcountsi2_test.zig b/lib/compiler_rt/popcountsi2_test.zig index 497b62516f..bf30e069aa 100644 --- a/lib/compiler_rt/popcountsi2_test.zig +++ b/lib/compiler_rt/popcountsi2_test.zig @@ -29,7 +29,7 @@ test "popcountsi2" { var rnd = RndGen.init(42); var i: u32 = 0; while (i < 10_000) : (i += 1) { - var rand_num = rnd.random().int(i32); + const rand_num = rnd.random().int(i32); try test__popcountsi2(rand_num); } } diff --git a/lib/compiler_rt/popcountti2_test.zig b/lib/compiler_rt/popcountti2_test.zig index b873bcd449..4d242a8328 100644 --- a/lib/compiler_rt/popcountti2_test.zig +++ b/lib/compiler_rt/popcountti2_test.zig @@ -29,7 +29,7 @@ test "popcountti2" { var rnd = RndGen.init(42); var i: u32 = 0; while (i < 10_000) : (i += 1) { - var rand_num = rnd.random().int(i128); + const rand_num = rnd.random().int(i128); try test__popcountti2(rand_num); } } diff --git a/lib/compiler_rt/powiXf2_test.zig b/lib/compiler_rt/powiXf2_test.zig index dfa676a5a8..7bd43c73c3 100644 --- a/lib/compiler_rt/powiXf2_test.zig +++ b/lib/compiler_rt/powiXf2_test.zig @@ -9,27 +9,27 @@ const testing = std.testing; const math = std.math; fn test__powihf2(a: f16, b: i32, expected: f16) !void { - var result = powiXf2.__powihf2(a, b); + const result = powiXf2.__powihf2(a, b); try testing.expectEqual(expected, result); } fn test__powisf2(a: f32, b: i32, expected: f32) !void { - var result = powiXf2.__powisf2(a, b); + const result = powiXf2.__powisf2(a, b); try testing.expectEqual(expected, result); } fn test__powidf2(a: f64, b: i32, expected: f64) !void { - var result = powiXf2.__powidf2(a, b); + const result = powiXf2.__powidf2(a, b); try testing.expectEqual(expected, result); } fn test__powitf2(a: f128, b: i32, expected: f128) !void { - var result = powiXf2.__powitf2(a, b); + const result = powiXf2.__powitf2(a, b); try testing.expectEqual(expected, result); } fn test__powixf2(a: f80, b: i32, expected: f80) !void { - var result = powiXf2.__powixf2(a, b); + const result = powiXf2.__powixf2(a, b); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/subo.zig b/lib/compiler_rt/subo.zig index b3542a9e9d..a14dd5e18e 100644 --- a/lib/compiler_rt/subo.zig +++ b/lib/compiler_rt/subo.zig @@ -27,7 +27,7 @@ pub fn __suboti4(a: i128, b: i128, overflow: *c_int) callconv(.C) i128 { inline fn suboXi4_generic(comptime ST: type, a: ST, b: ST, overflow: *c_int) ST { overflow.* = 0; - var sum: ST = a -% b; + const sum: ST = a -% b; // Hackers Delight: section Overflow Detection, subsection Signed Add/Subtract // Let sum = a -% b == a - b - carry == wraparound subtraction. // Overflow in a-b-carry occurs, iff a and b have opposite signs diff --git a/lib/compiler_rt/subodi4_test.zig b/lib/compiler_rt/subodi4_test.zig index 687e97c71c..2dd717e14b 100644 --- a/lib/compiler_rt/subodi4_test.zig +++ b/lib/compiler_rt/subodi4_test.zig @@ -6,8 +6,8 @@ const math = std.math; fn test__subodi4(a: i64, b: i64) !void { var result_ov: c_int = undefined; var expected_ov: c_int = undefined; - var result = subo.__subodi4(a, b, &result_ov); - var expected: i64 = simple_subodi4(a, b, &expected_ov); + const result = subo.__subodi4(a, b, &result_ov); + const expected: i64 = simple_subodi4(a, b, &expected_ov); try testing.expectEqual(expected, result); try testing.expectEqual(expected_ov, result_ov); } diff --git a/lib/compiler_rt/subosi4_test.zig b/lib/compiler_rt/subosi4_test.zig index 6c7ae97c25..8644e8100e 100644 --- a/lib/compiler_rt/subosi4_test.zig +++ b/lib/compiler_rt/subosi4_test.zig @@ -4,8 +4,8 @@ const testing = @import("std").testing; fn test__subosi4(a: i32, b: i32) !void { var result_ov: c_int = undefined; var expected_ov: c_int = undefined; - var result = subo.__subosi4(a, b, &result_ov); - var expected: i32 = simple_subosi4(a, b, &expected_ov); + const result = subo.__subosi4(a, b, &result_ov); + const expected: i32 = simple_subosi4(a, b, &expected_ov); try testing.expectEqual(expected, result); try testing.expectEqual(expected_ov, result_ov); } diff --git a/lib/compiler_rt/suboti4_test.zig b/lib/compiler_rt/suboti4_test.zig index f42fe3edce..68ad0ff72f 100644 --- a/lib/compiler_rt/suboti4_test.zig +++ b/lib/compiler_rt/suboti4_test.zig @@ -6,8 +6,8 @@ const math = std.math; fn test__suboti4(a: i128, b: i128) !void { var result_ov: c_int = undefined; var expected_ov: c_int = undefined; - var result = subo.__suboti4(a, b, &result_ov); - var expected: i128 = simple_suboti4(a, b, &expected_ov); + const result = subo.__suboti4(a, b, &result_ov); + const expected: i128 = simple_suboti4(a, b, &expected_ov); try testing.expectEqual(expected, result); try testing.expectEqual(expected_ov, result_ov); } diff --git a/lib/compiler_rt/ucmpdi2_test.zig b/lib/compiler_rt/ucmpdi2_test.zig index 00c10e52be..5efc8daffe 100644 --- a/lib/compiler_rt/ucmpdi2_test.zig +++ b/lib/compiler_rt/ucmpdi2_test.zig @@ -2,7 +2,7 @@ const cmp = @import("cmp.zig"); const testing = @import("std").testing; fn test__ucmpdi2(a: u64, b: u64, expected: i32) !void { - var result = cmp.__ucmpdi2(a, b); + const result = cmp.__ucmpdi2(a, b); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/ucmpsi2_test.zig b/lib/compiler_rt/ucmpsi2_test.zig index cbca4b33cf..161438ab78 100644 --- a/lib/compiler_rt/ucmpsi2_test.zig +++ b/lib/compiler_rt/ucmpsi2_test.zig @@ -2,7 +2,7 @@ const cmp = @import("cmp.zig"); const testing = @import("std").testing; fn test__ucmpsi2(a: u32, b: u32, expected: i32) !void { - var result = cmp.__ucmpsi2(a, b); + const result = cmp.__ucmpsi2(a, b); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/ucmpti2_test.zig b/lib/compiler_rt/ucmpti2_test.zig index 56f2dc61fb..6b3f7fdf21 100644 --- a/lib/compiler_rt/ucmpti2_test.zig +++ b/lib/compiler_rt/ucmpti2_test.zig @@ -2,7 +2,7 @@ const cmp = @import("cmp.zig"); const testing = @import("std").testing; fn test__ucmpti2(a: u128, b: u128, expected: i32) !void { - var result = cmp.__ucmpti2(a, b); + const result = cmp.__ucmpti2(a, b); try testing.expectEqual(expected, result); } diff --git a/lib/compiler_rt/udivmod.zig b/lib/compiler_rt/udivmod.zig index 1075cb0f31..a9705f317d 100644 --- a/lib/compiler_rt/udivmod.zig +++ b/lib/compiler_rt/udivmod.zig @@ -52,7 +52,7 @@ fn divwide_generic(comptime T: type, _u1: T, _u0: T, v_: T, r: *T) T { if (rhat >= b) break; } - var un21 = un64 *% b +% un1 -% q1 *% v; + const un21 = un64 *% b +% un1 -% q1 *% v; // Compute the second quotient digit var q0 = un21 / vn1; @@ -101,8 +101,8 @@ pub fn udivmod(comptime T: type, a_: T, b_: T, maybe_rem: ?*T) T { return 0; } - var a: [2]HalfT = @bitCast(a_); - var b: [2]HalfT = @bitCast(b_); + const a: [2]HalfT = @bitCast(a_); + const b: [2]HalfT = @bitCast(b_); var q: [2]HalfT = undefined; var r: [2]HalfT = undefined; @@ -125,7 +125,7 @@ pub fn udivmod(comptime T: type, a_: T, b_: T, maybe_rem: ?*T) T { } // 0 <= shift <= 63 - var shift: Log2Int(T) = @clz(b[hi]) - @clz(a[hi]); + const shift: Log2Int(T) = @clz(b[hi]) - @clz(a[hi]); var af: T = @bitCast(a); var bf = @as(T, @bitCast(b)) << shift; q = @bitCast(@as(T, 0)); diff --git a/lib/compiler_rt/udivmodei4.zig b/lib/compiler_rt/udivmodei4.zig index 064a3b842e..194f45a23d 100644 --- a/lib/compiler_rt/udivmodei4.zig +++ b/lib/compiler_rt/udivmodei4.zig @@ -116,7 +116,7 @@ pub fn __udivei4(r_q: [*]u32, u_p: [*]const u32, v_p: [*]const u32, bits: usize) @setRuntimeSafety(builtin.is_test); const u = u_p[0 .. bits / 32]; const v = v_p[0 .. bits / 32]; - var q = r_q[0 .. bits / 32]; + const q = r_q[0 .. bits / 32]; @call(.always_inline, divmod, .{ q, null, u, v }) catch unreachable; } @@ -124,7 +124,7 @@ pub fn __umodei4(r_p: [*]u32, u_p: [*]const u32, v_p: [*]const u32, bits: usize) @setRuntimeSafety(builtin.is_test); const u = u_p[0 .. bits / 32]; const v = v_p[0 .. bits / 32]; - var r = r_p[0 .. bits / 32]; + const r = r_p[0 .. bits / 32]; @call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable; } diff --git a/lib/std/Build/Cache.zig b/lib/std/Build/Cache.zig index a5943be6bb..283a3d1f5f 100644 --- a/lib/std/Build/Cache.zig +++ b/lib/std/Build/Cache.zig @@ -141,7 +141,7 @@ fn findPrefixResolved(cache: *const Cache, resolved_path: []u8) !PrefixedPath { var i: u8 = 1; // Start at 1 to skip over checking the null prefix. while (i < prefixes_slice.len) : (i += 1) { const p = prefixes_slice[i].path.?; - var sub_path = getPrefixSubpath(gpa, p, resolved_path) catch |err| switch (err) { + const sub_path = getPrefixSubpath(gpa, p, resolved_path) catch |err| switch (err) { error.NotASubPath => continue, else => |e| return e, }; diff --git a/lib/std/Build/Cache/DepTokenizer.zig b/lib/std/Build/Cache/DepTokenizer.zig index 0e5224edc0..9edc53cbb2 100644 --- a/lib/std/Build/Cache/DepTokenizer.zig +++ b/lib/std/Build/Cache/DepTokenizer.zig @@ -950,7 +950,7 @@ fn printSection(out: anytype, label: []const u8, bytes: []const u8) !void { fn printLabel(out: anytype, label: []const u8, bytes: []const u8) !void { var buf: [80]u8 = undefined; - var text = try std.fmt.bufPrint(buf[0..], "{s} {d} bytes ", .{ label, bytes.len }); + const text = try std.fmt.bufPrint(buf[0..], "{s} {d} bytes ", .{ label, bytes.len }); try out.writeAll(text); var i: usize = text.len; const end = 79; @@ -983,12 +983,12 @@ fn hexDump(out: anytype, bytes: []const u8) !void { try printDecValue(out, offset, 8); try out.writeAll(":"); try out.writeAll(" "); - var end1 = @min(offset + n, offset + 8); + const end1 = @min(offset + n, offset + 8); for (bytes[offset..end1]) |b| { try out.writeAll(" "); try printHexValue(out, b, 2); } - var end2 = offset + n; + const end2 = offset + n; if (end2 > end1) { try out.writeAll(" "); for (bytes[end1..end2]) |b| { diff --git a/lib/std/Build/Step/CheckObject.zig b/lib/std/Build/Step/CheckObject.zig index d27c8d6d27..d826916727 100644 --- a/lib/std/Build/Step/CheckObject.zig +++ b/lib/std/Build/Step/CheckObject.zig @@ -293,7 +293,7 @@ const Check = struct { /// Creates a new empty sequence of actions. pub fn checkStart(self: *CheckObject) void { - var new_check = Check.create(self.step.owner.allocator); + const new_check = Check.create(self.step.owner.allocator); self.checks.append(new_check) catch @panic("OOM"); } diff --git a/lib/std/Build/Step/ConfigHeader.zig b/lib/std/Build/Step/ConfigHeader.zig index 87d02e2f93..9f040349c6 100644 --- a/lib/std/Build/Step/ConfigHeader.zig +++ b/lib/std/Build/Step/ConfigHeader.zig @@ -307,8 +307,8 @@ fn render_cmake( values: std.StringArrayHashMap(Value), src_path: []const u8, ) !void { - var build = step.owner; - var allocator = build.allocator; + const build = step.owner; + const allocator = build.allocator; var values_copy = try values.clone(); defer values_copy.deinit(); diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig index 3d26d25070..5555b03e94 100644 --- a/lib/std/Build/Step/Run.zig +++ b/lib/std/Build/Step/Run.zig @@ -301,7 +301,7 @@ pub fn addPathDir(self: *Run, search_path: []const u8) void { const env_map = getEnvMapInternal(self); const key = "PATH"; - var prev_path = env_map.get(key); + const prev_path = env_map.get(key); if (prev_path) |pp| { const new_path = b.fmt("{s}" ++ [1]u8{fs.path.delimiter} ++ "{s}", .{ pp, search_path }); diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig index 7d3b8b8b1c..fef89a228f 100644 --- a/lib/std/Progress.zig +++ b/lib/std/Progress.zig @@ -397,6 +397,7 @@ fn bufWrite(self: *Progress, end: *usize, comptime format: []const u8, args: any test "basic functionality" { var disable = true; + _ = &disable; if (disable) { // This test is disabled because it uses time.sleep() and is therefore slow. It also // prints bogus progress data to stderr. diff --git a/lib/std/Thread/WaitGroup.zig b/lib/std/Thread/WaitGroup.zig index c8be6658db..f2274db86a 100644 --- a/lib/std/Thread/WaitGroup.zig +++ b/lib/std/Thread/WaitGroup.zig @@ -25,7 +25,7 @@ pub fn finish(self: *WaitGroup) void { } pub fn wait(self: *WaitGroup) void { - var state = self.state.fetchAdd(is_waiting, .Acquire); + const state = self.state.fetchAdd(is_waiting, .Acquire); assert(state & is_waiting == 0); if ((state / one_pending) > 0) { diff --git a/lib/std/array_hash_map.zig b/lib/std/array_hash_map.zig index bf5f6581ac..b82a037e14 100644 --- a/lib/std/array_hash_map.zig +++ b/lib/std/array_hash_map.zig @@ -2076,11 +2076,11 @@ test "iterator hash map" { try reset_map.putNoClobber(1, 22); try reset_map.putNoClobber(2, 33); - var keys = [_]i32{ + const keys = [_]i32{ 0, 2, 1, }; - var values = [_]i32{ + const values = [_]i32{ 11, 33, 22, }; @@ -2116,7 +2116,7 @@ test "iterator hash map" { } it.reset(); - var entry = it.next().?; + const entry = it.next().?; try testing.expect(entry.key_ptr.* == first_entry.key_ptr.*); try testing.expect(entry.value_ptr.* == first_entry.value_ptr.*); } diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig index e50eb92041..24655046a9 100644 --- a/lib/std/array_list.zig +++ b/lib/std/array_list.zig @@ -979,7 +979,7 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ pub fn ensureTotalCapacity(self: *Self, allocator: Allocator, new_capacity: usize) Allocator.Error!void { if (self.capacity >= new_capacity) return; - var better_capacity = growCapacity(self.capacity, new_capacity); + const better_capacity = growCapacity(self.capacity, new_capacity); return self.ensureTotalCapacityPrecise(allocator, better_capacity); } @@ -1159,7 +1159,7 @@ test "std.ArrayList/ArrayListUnmanaged.init" { } { - var list = ArrayListUnmanaged(i32){}; + const list = ArrayListUnmanaged(i32){}; try testing.expect(list.items.len == 0); try testing.expect(list.capacity == 0); diff --git a/lib/std/atomic/Atomic.zig b/lib/std/atomic/Atomic.zig index e38ada0c20..892e9633d5 100644 --- a/lib/std/atomic/Atomic.zig +++ b/lib/std/atomic/Atomic.zig @@ -125,7 +125,7 @@ pub fn Atomic(comptime T: type) type { @compileError(@tagName(Ordering.Unordered) ++ " is only allowed on atomic loads and stores"); } - comptime var success_is_stronger = switch (failure) { + const success_is_stronger = switch (failure) { .SeqCst => success == .SeqCst, .AcqRel => @compileError(@tagName(failure) ++ " implies " ++ @tagName(Ordering.Release) ++ " which is only allowed on success"), .Acquire => success == .SeqCst or success == .AcqRel or success == .Acquire, diff --git a/lib/std/atomic/queue.zig b/lib/std/atomic/queue.zig index e8d37507d3..552f2f9510 100644 --- a/lib/std/atomic/queue.zig +++ b/lib/std/atomic/queue.zig @@ -175,11 +175,11 @@ const puts_per_thread = 500; const put_thread_count = 3; test "std.atomic.Queue" { - var plenty_of_memory = try std.heap.page_allocator.alloc(u8, 300 * 1024); + const plenty_of_memory = try std.heap.page_allocator.alloc(u8, 300 * 1024); defer std.heap.page_allocator.free(plenty_of_memory); var fixed_buffer_allocator = std.heap.FixedBufferAllocator.init(plenty_of_memory); - var a = fixed_buffer_allocator.threadSafeAllocator(); + const a = fixed_buffer_allocator.threadSafeAllocator(); var queue = Queue(i32).init(); var context = Context{ diff --git a/lib/std/atomic/stack.zig b/lib/std/atomic/stack.zig index 1f19869fd6..0fc622cf63 100644 --- a/lib/std/atomic/stack.zig +++ b/lib/std/atomic/stack.zig @@ -85,11 +85,11 @@ const puts_per_thread = 500; const put_thread_count = 3; test "std.atomic.stack" { - var plenty_of_memory = try std.heap.page_allocator.alloc(u8, 300 * 1024); + const plenty_of_memory = try std.heap.page_allocator.alloc(u8, 300 * 1024); defer std.heap.page_allocator.free(plenty_of_memory); var fixed_buffer_allocator = std.heap.FixedBufferAllocator.init(plenty_of_memory); - var a = fixed_buffer_allocator.threadSafeAllocator(); + const a = fixed_buffer_allocator.threadSafeAllocator(); var stack = Stack(i32).init(); var context = Context{ diff --git a/lib/std/base64.zig b/lib/std/base64.zig index 8d0effd05b..ce84e640d1 100644 --- a/lib/std/base64.zig +++ b/lib/std/base64.zig @@ -239,7 +239,7 @@ pub const Base64Decoder = struct { if ((bits & invalid_char_tst) != 0) return error.InvalidCharacter; std.mem.writeInt(u32, dest[dest_idx..][0..4], bits, .little); } - var remaining = source[fast_src_idx..]; + const remaining = source[fast_src_idx..]; for (remaining, fast_src_idx..) |c, src_idx| { const d = decoder.char_to_index[c]; if (d == invalid_char) { @@ -259,7 +259,7 @@ pub const Base64Decoder = struct { return error.InvalidPadding; } if (leftover_idx == null) return; - var leftover = source[leftover_idx.?..]; + const leftover = source[leftover_idx.?..]; if (decoder.pad_char) |pad_char| { const padding_len = acc_len / 2; var padding_chars: usize = 0; @@ -338,7 +338,7 @@ pub const Base64DecoderWithIgnore = struct { if (decoder.pad_char != null and padding_len != 0) return error.InvalidPadding; return dest_idx; } - var leftover = source[leftover_idx.?..]; + const leftover = source[leftover_idx.?..]; if (decoder.pad_char) |pad_char| { var padding_chars: usize = 0; for (leftover) |c| { @@ -483,7 +483,7 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [ // Base64Decoder { var buffer: [0x100]u8 = undefined; - var decoded = buffer[0..try codecs.Decoder.calcSizeForSlice(expected_encoded)]; + const decoded = buffer[0..try codecs.Decoder.calcSizeForSlice(expected_encoded)]; try codecs.Decoder.decode(decoded, expected_encoded); try testing.expectEqualSlices(u8, expected_decoded, decoded); } @@ -492,8 +492,8 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [ { const decoder_ignore_nothing = codecs.decoderWithIgnore(""); var buffer: [0x100]u8 = undefined; - var decoded = buffer[0..try decoder_ignore_nothing.calcSizeUpperBound(expected_encoded.len)]; - var written = try decoder_ignore_nothing.decode(decoded, expected_encoded); + const decoded = buffer[0..try decoder_ignore_nothing.calcSizeUpperBound(expected_encoded.len)]; + const written = try decoder_ignore_nothing.decode(decoded, expected_encoded); try testing.expect(written <= decoded.len); try testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]); } @@ -502,8 +502,8 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [ fn testDecodeIgnoreSpace(codecs: Codecs, expected_decoded: []const u8, encoded: []const u8) !void { const decoder_ignore_space = codecs.decoderWithIgnore(" "); var buffer: [0x100]u8 = undefined; - var decoded = buffer[0..try decoder_ignore_space.calcSizeUpperBound(encoded.len)]; - var written = try decoder_ignore_space.decode(decoded, encoded); + const decoded = buffer[0..try decoder_ignore_space.calcSizeUpperBound(encoded.len)]; + const written = try decoder_ignore_space.decode(decoded, encoded); try testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]); } @@ -511,7 +511,7 @@ fn testError(codecs: Codecs, encoded: []const u8, expected_err: anyerror) !void const decoder_ignore_space = codecs.decoderWithIgnore(" "); var buffer: [0x100]u8 = undefined; if (codecs.Decoder.calcSizeForSlice(encoded)) |decoded_size| { - var decoded = buffer[0..decoded_size]; + const decoded = buffer[0..decoded_size]; if (codecs.Decoder.decode(decoded, encoded)) |_| { return error.ExpectedError; } else |err| if (err != expected_err) return err; @@ -525,7 +525,7 @@ fn testError(codecs: Codecs, encoded: []const u8, expected_err: anyerror) !void fn testNoSpaceLeftError(codecs: Codecs, encoded: []const u8) !void { const decoder_ignore_space = codecs.decoderWithIgnore(" "); var buffer: [0x100]u8 = undefined; - var decoded = buffer[0 .. (try codecs.Decoder.calcSizeForSlice(encoded)) - 1]; + const decoded = buffer[0 .. (try codecs.Decoder.calcSizeForSlice(encoded)) - 1]; if (decoder_ignore_space.decode(decoded, encoded)) |_| { return error.ExpectedError; } else |err| if (err != error.NoSpaceLeft) return err; @@ -534,7 +534,7 @@ fn testNoSpaceLeftError(codecs: Codecs, encoded: []const u8) !void { fn testFourBytesDestNoSpaceLeftError(codecs: Codecs, encoded: []const u8) !void { const decoder_ignore_space = codecs.decoderWithIgnore(" "); var buffer: [0x100]u8 = undefined; - var decoded = buffer[0..4]; + const decoded = buffer[0..4]; if (decoder_ignore_space.decode(decoded, encoded)) |_| { return error.ExpectedError; } else |err| if (err != error.NoSpaceLeft) return err; diff --git a/lib/std/buf_map.zig b/lib/std/buf_map.zig index f20a581972..4de5e01e0f 100644 --- a/lib/std/buf_map.zig +++ b/lib/std/buf_map.zig @@ -15,8 +15,7 @@ pub const BufMap = struct { /// That allocator will be used for both backing allocations /// and string deduplication. pub fn init(allocator: Allocator) BufMap { - var self = BufMap{ .hash_map = BufMapHashMap.init(allocator) }; - return self; + return .{ .hash_map = BufMapHashMap.init(allocator) }; } /// Free the backing storage of the map, as well as all diff --git a/lib/std/buf_set.zig b/lib/std/buf_set.zig index 90ee86e12d..46c10f82f8 100644 --- a/lib/std/buf_set.zig +++ b/lib/std/buf_set.zig @@ -17,8 +17,7 @@ pub const BufSet = struct { /// be used internally for both backing allocations and /// string duplication. pub fn init(a: Allocator) BufSet { - var self = BufSet{ .hash_map = BufSetHashMap.init(a) }; - return self; + return .{ .hash_map = BufSetHashMap.init(a) }; } /// Free a BufSet along with all stored keys. @@ -76,8 +75,8 @@ pub const BufSet = struct { self: *const BufSet, new_allocator: Allocator, ) Allocator.Error!BufSet { - var cloned_hashmap = try self.hash_map.cloneWithAllocator(new_allocator); - var cloned = BufSet{ .hash_map = cloned_hashmap }; + const cloned_hashmap = try self.hash_map.cloneWithAllocator(new_allocator); + const cloned = BufSet{ .hash_map = cloned_hashmap }; var it = cloned.hash_map.keyIterator(); while (it.next()) |key_ptr| { key_ptr.* = try cloned.copy(key_ptr.*); @@ -134,7 +133,7 @@ test "BufSet clone" { } test "BufSet.clone with arena" { - var allocator = std.testing.allocator; + const allocator = std.testing.allocator; var arena = std.heap.ArenaAllocator.init(allocator); defer arena.deinit(); diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 4042bc2743..19c704c9a5 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -777,9 +777,8 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr } var fmt: [256]u8 = undefined; - var slice = try std.fmt.bufPrint(&fmt, "\r\nerr: {s}\r\n", .{exit_msg}); - - var len = try std.unicode.utf8ToUtf16Le(utf16, slice); + const slice = try std.fmt.bufPrint(&fmt, "\r\nerr: {s}\r\n", .{exit_msg}); + const len = try std.unicode.utf8ToUtf16Le(utf16, slice); utf16[len] = 0; @@ -790,7 +789,7 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr }; var exit_size: usize = 0; - var exit_data = ExitData.create_exit_data(msg, &exit_size) catch null; + const exit_data = ExitData.create_exit_data(msg, &exit_size) catch null; if (exit_data) |data| { if (uefi.system_table.std_err) |out| { diff --git a/lib/std/child_process.zig b/lib/std/child_process.zig index b3edbcd76a..1d79302860 100644 --- a/lib/std/child_process.zig +++ b/lib/std/child_process.zig @@ -847,7 +847,7 @@ pub const ChildProcess = struct { } windowsCreateProcessPathExt(self.allocator, &dir_buf, &app_buf, PATHEXT, cmd_line_w.ptr, envp_ptr, cwd_w_ptr, &siStartInfo, &piProcInfo) catch |no_path_err| { - var original_err = switch (no_path_err) { + const original_err = switch (no_path_err) { error.FileNotFound, error.InvalidExe, error.AccessDenied => |e| e, error.UnrecoverableInvalidExe => return error.InvalidExe, else => |e| return e, diff --git a/lib/std/coff.zig b/lib/std/coff.zig index b2bf09ef2a..e9214cbd79 100644 --- a/lib/std/coff.zig +++ b/lib/std/coff.zig @@ -1075,7 +1075,7 @@ pub const Coff = struct { var stream = std.io.fixedBufferStream(data); const reader = stream.reader(); try stream.seekTo(pe_pointer_offset); - var coff_header_offset = try reader.readInt(u32, .little); + const coff_header_offset = try reader.readInt(u32, .little); try stream.seekTo(coff_header_offset); var buf: [4]u8 = undefined; try reader.readNoEof(&buf); diff --git a/lib/std/compress/deflate/bits_utils.zig b/lib/std/compress/deflate/bits_utils.zig index 4b440dc44e..97a557d0da 100644 --- a/lib/std/compress/deflate/bits_utils.zig +++ b/lib/std/compress/deflate/bits_utils.zig @@ -15,7 +15,7 @@ test "bitReverse" { out: u16, }; - var reverse_bits_tests = [_]ReverseBitsTest{ + const reverse_bits_tests = [_]ReverseBitsTest{ .{ .in = 1, .bit_count = 1, .out = 1 }, .{ .in = 1, .bit_count = 2, .out = 2 }, .{ .in = 1, .bit_count = 3, .out = 4 }, @@ -27,7 +27,7 @@ test "bitReverse" { }; for (reverse_bits_tests) |h| { - var v = bitReverse(u16, h.in, h.bit_count); + const v = bitReverse(u16, h.in, h.bit_count); try std.testing.expectEqual(h.out, v); } } diff --git a/lib/std/compress/deflate/compressor.zig b/lib/std/compress/deflate/compressor.zig index 72de63f162..e41b097636 100644 --- a/lib/std/compress/deflate/compressor.zig +++ b/lib/std/compress/deflate/compressor.zig @@ -156,8 +156,8 @@ fn levels(compression: Compression) CompressionLevel { // up to length 'max'. Both slices must be at least 'max' // bytes in size. fn matchLen(a: []u8, b: []u8, max: u32) u32 { - var bounded_a = a[0..max]; - var bounded_b = b[0..max]; + const bounded_a = a[0..max]; + const bounded_b = b[0..max]; for (bounded_a, 0..) |av, i| { if (bounded_b[i] != av) { return @as(u32, @intCast(i)); @@ -191,7 +191,7 @@ fn bulkHash4(b: []u8, dst: []u32) u32 { @as(u32, b[0]) << 24; dst[0] = (hb *% hash_mul) >> (32 - hash_bits); - var end = b.len - min_match_length + 1; + const end = b.len - min_match_length + 1; var i: u32 = 1; while (i < end) : (i += 1) { hb = (hb << 8) | @as(u32, b[i + 3]); @@ -305,7 +305,7 @@ pub fn Compressor(comptime WriterType: anytype) type { } self.hash_offset += window_size; if (self.hash_offset > max_hash_offset) { - var delta = self.hash_offset - 1; + const delta = self.hash_offset - 1; self.hash_offset -= delta; self.chain_head -|= delta; @@ -369,31 +369,31 @@ pub fn Compressor(comptime WriterType: anytype) type { } // Add all to window. @memcpy(self.window[0..b.len], b); - var n = b.len; + const n = b.len; // Calculate 256 hashes at the time (more L1 cache hits) - var loops = (n + 256 - min_match_length) / 256; + const loops = (n + 256 - min_match_length) / 256; var j: usize = 0; while (j < loops) : (j += 1) { - var index = j * 256; + const index = j * 256; var end = index + 256 + min_match_length - 1; if (end > n) { end = n; } - var to_check = self.window[index..end]; - var dst_size = to_check.len - min_match_length + 1; + const to_check = self.window[index..end]; + const dst_size = to_check.len - min_match_length + 1; if (dst_size <= 0) { continue; } - var dst = self.hash_match[0..dst_size]; + const dst = self.hash_match[0..dst_size]; _ = self.bulk_hasher(to_check, dst); var new_h: u32 = 0; for (dst, 0..) |val, i| { - var di = i + index; + const di = i + index; new_h = val; - var hh = &self.hash_head[new_h & hash_mask]; + const hh = &self.hash_head[new_h & hash_mask]; // Get previous value with the same hash. // Our chain should point to the previous value. self.hash_prev[di & window_mask] = hh.*; @@ -447,13 +447,13 @@ pub fn Compressor(comptime WriterType: anytype) type { } var w_end = win[pos + length]; - var w_pos = win[pos..]; - var min_index = pos -| window_size; + const w_pos = win[pos..]; + const min_index = pos -| window_size; var i = prev_head; while (tries > 0) : (tries -= 1) { if (w_end == win[i + length]) { - var n = matchLen(win[i..], w_pos, min_match_look); + const n = matchLen(win[i..], w_pos, min_match_look); if (n > length and (n > min_match_length or pos - i <= 4096)) { length = n; @@ -565,7 +565,7 @@ pub fn Compressor(comptime WriterType: anytype) type { while (true) { assert(self.index <= self.window_end); - var lookahead = self.window_end -| self.index; + const lookahead = self.window_end -| self.index; if (lookahead < min_match_length + max_match_length) { if (!self.sync) { break; @@ -590,16 +590,16 @@ pub fn Compressor(comptime WriterType: anytype) type { if (self.index < self.max_insert_index) { // Update the hash self.hash = hash4(self.window[self.index .. self.index + min_match_length]); - var hh = &self.hash_head[self.hash & hash_mask]; + const hh = &self.hash_head[self.hash & hash_mask]; self.chain_head = @as(u32, @intCast(hh.*)); self.hash_prev[self.index & window_mask] = @as(u32, @intCast(self.chain_head)); hh.* = @as(u32, @intCast(self.index + self.hash_offset)); } - var prev_length = self.length; - var prev_offset = self.offset; + const prev_length = self.length; + const prev_offset = self.offset; self.length = min_match_length - 1; self.offset = 0; - var min_index = self.index -| window_size; + const min_index = self.index -| window_size; if (self.hash_offset <= self.chain_head and self.chain_head - self.hash_offset >= min_index and @@ -610,7 +610,7 @@ pub fn Compressor(comptime WriterType: anytype) type { prev_length < self.compression_level.lazy)) { { - var fmatch = self.findMatch( + const fmatch = self.findMatch( self.index, self.chain_head -| self.hash_offset, min_match_length - 1, @@ -658,7 +658,7 @@ pub fn Compressor(comptime WriterType: anytype) type { self.hash = hash4(self.window[index .. index + min_match_length]); // Get previous value with the same hash. // Our chain should point to the previous value. - var hh = &self.hash_head[self.hash & hash_mask]; + const hh = &self.hash_head[self.hash & hash_mask]; self.hash_prev[index & window_mask] = hh.*; // Set the head of the hash chain to us. hh.* = @as(u32, @intCast(index + self.hash_offset)); @@ -740,7 +740,7 @@ pub fn Compressor(comptime WriterType: anytype) type { // compressed form of data to its underlying writer. while (buf.len > 0) { try self.step(); - var filled = self.fill(buf); + const filled = self.fill(buf); buf = buf[filled..]; } @@ -1097,12 +1097,12 @@ test "bulkHash4" { while (j < out.len) : (j += 1) { var y = out[0..j]; - var dst = try testing.allocator.alloc(u32, y.len - min_match_length + 1); + const dst = try testing.allocator.alloc(u32, y.len - min_match_length + 1); defer testing.allocator.free(dst); _ = bulkHash4(y, dst); for (dst, 0..) |got, i| { - var want = hash4(y[i..]); + const want = hash4(y[i..]); try testing.expectEqual(want, got); } } diff --git a/lib/std/compress/deflate/compressor_test.zig b/lib/std/compress/deflate/compressor_test.zig index 140284ea5e..1f765e3fdc 100644 --- a/lib/std/compress/deflate/compressor_test.zig +++ b/lib/std/compress/deflate/compressor_test.zig @@ -27,7 +27,7 @@ fn testSync(level: deflate.Compression, input: []const u8) !void { var whole_buf = std.ArrayList(u8).init(testing.allocator); defer whole_buf.deinit(); - var multi_writer = io.multiWriter(.{ + const multi_writer = io.multiWriter(.{ divided_buf.writer(), whole_buf.writer(), }).writer(); @@ -48,7 +48,7 @@ fn testSync(level: deflate.Compression, input: []const u8) !void { defer decomp.deinit(); // Write first half of the input and flush() - var half: usize = (input.len + 1) / 2; + const half: usize = (input.len + 1) / 2; var half_len: usize = half - 0; { _ = try comp.writer().writeAll(input[0..half]); @@ -57,10 +57,10 @@ fn testSync(level: deflate.Compression, input: []const u8) !void { try comp.flush(); // Read back - var decompressed = try testing.allocator.alloc(u8, half_len); + const decompressed = try testing.allocator.alloc(u8, half_len); defer testing.allocator.free(decompressed); - var read = try decomp.reader().readAll(decompressed); // read at least half + const read = try decomp.reader().readAll(decompressed); // read at least half try testing.expectEqual(half_len, read); try testing.expectEqualSlices(u8, input[0..half], decompressed); } @@ -74,7 +74,7 @@ fn testSync(level: deflate.Compression, input: []const u8) !void { try comp.close(); // Read back - var decompressed = try testing.allocator.alloc(u8, half_len); + const decompressed = try testing.allocator.alloc(u8, half_len); defer testing.allocator.free(decompressed); var read = try decomp.reader().readAll(decompressed); @@ -94,11 +94,11 @@ fn testSync(level: deflate.Compression, input: []const u8) !void { try comp.close(); // stream should work for ordinary reader too (reading whole_buf in one go) - var whole_buf_reader = io.fixedBufferStream(whole_buf.items).reader(); + const whole_buf_reader = io.fixedBufferStream(whole_buf.items).reader(); var decomp = try decompressor(testing.allocator, whole_buf_reader, null); defer decomp.deinit(); - var decompressed = try testing.allocator.alloc(u8, input.len); + const decompressed = try testing.allocator.alloc(u8, input.len); defer testing.allocator.free(decompressed); _ = try decomp.reader().readAll(decompressed); @@ -125,10 +125,10 @@ fn testToFromWithLevelAndLimit(level: deflate.Compression, input: []const u8, li var decomp = try decompressor(testing.allocator, fib.reader(), null); defer decomp.deinit(); - var decompressed = try testing.allocator.alloc(u8, input.len); + const decompressed = try testing.allocator.alloc(u8, input.len); defer testing.allocator.free(decompressed); - var read: usize = try decomp.reader().readAll(decompressed); + const read: usize = try decomp.reader().readAll(decompressed); try testing.expectEqual(input.len, read); try testing.expectEqualSlices(u8, input, decompressed); @@ -153,7 +153,7 @@ fn testToFromWithLimit(input: []const u8, limit: [11]u32) !void { } test "deflate/inflate" { - var limits = [_]u32{0} ** 11; + const limits = [_]u32{0} ** 11; var test0 = [_]u8{}; var test1 = [_]u8{0x11}; @@ -313,7 +313,7 @@ test "decompressor dictionary" { try comp.writer().writeAll(text); try comp.close(); - var decompressed = try testing.allocator.alloc(u8, text.len); + const decompressed = try testing.allocator.alloc(u8, text.len); defer testing.allocator.free(decompressed); var decomp = try decompressor( @@ -432,7 +432,7 @@ test "deflate/inflate string" { }; inline for (deflate_inflate_string_tests) |t| { - var golden = @embedFile("testdata/" ++ t.filename); + const golden = @embedFile("testdata/" ++ t.filename); try testToFromWithLimit(golden, t.limit); } } @@ -466,14 +466,14 @@ test "inflate reset" { var decomp = try decompressor(testing.allocator, fib.reader(), null); defer decomp.deinit(); - var decompressed_0: []u8 = try decomp.reader() + const decompressed_0: []u8 = try decomp.reader() .readAllAlloc(testing.allocator, math.maxInt(usize)); defer testing.allocator.free(decompressed_0); fib = io.fixedBufferStream(compressed_strings[1].items); try decomp.reset(fib.reader(), null); - var decompressed_1: []u8 = try decomp.reader() + const decompressed_1: []u8 = try decomp.reader() .readAllAlloc(testing.allocator, math.maxInt(usize)); defer testing.allocator.free(decompressed_1); @@ -513,14 +513,14 @@ test "inflate reset dictionary" { var decomp = try decompressor(testing.allocator, fib.reader(), dict); defer decomp.deinit(); - var decompressed_0: []u8 = try decomp.reader() + const decompressed_0: []u8 = try decomp.reader() .readAllAlloc(testing.allocator, math.maxInt(usize)); defer testing.allocator.free(decompressed_0); fib = io.fixedBufferStream(compressed_strings[1].items); try decomp.reset(fib.reader(), dict); - var decompressed_1: []u8 = try decomp.reader() + const decompressed_1: []u8 = try decomp.reader() .readAllAlloc(testing.allocator, math.maxInt(usize)); defer testing.allocator.free(decompressed_1); diff --git a/lib/std/compress/deflate/decompressor.zig b/lib/std/compress/deflate/decompressor.zig index 4e7f46db42..8e86bc09f3 100644 --- a/lib/std/compress/deflate/decompressor.zig +++ b/lib/std/compress/deflate/decompressor.zig @@ -136,11 +136,11 @@ const HuffmanDecoder = struct { self.min = min; if (max > huffman_chunk_bits) { - var num_links = @as(u32, 1) << @as(u5, @intCast(max - huffman_chunk_bits)); + const num_links = @as(u32, 1) << @as(u5, @intCast(max - huffman_chunk_bits)); self.link_mask = @as(u32, @intCast(num_links - 1)); // create link tables - var link = next_code[huffman_chunk_bits + 1] >> 1; + const link = next_code[huffman_chunk_bits + 1] >> 1; self.links = try self.allocator.alloc([]u16, huffman_num_chunks - link); self.sub_chunks = ArrayList(u32).init(self.allocator); self.initialized = true; @@ -148,7 +148,7 @@ const HuffmanDecoder = struct { while (j < huffman_num_chunks) : (j += 1) { var reverse = @as(u32, @intCast(bu.bitReverse(u16, @as(u16, @intCast(j)), 16))); reverse >>= @as(u32, @intCast(16 - huffman_chunk_bits)); - var off = j - @as(u32, @intCast(link)); + const off = j - @as(u32, @intCast(link)); if (sanity) { // check we are not overwriting an existing chunk assert(self.chunks[reverse] == 0); @@ -168,9 +168,9 @@ const HuffmanDecoder = struct { if (n == 0) { continue; } - var ncode = next_code[n]; + const ncode = next_code[n]; next_code[n] += 1; - var chunk = @as(u16, @intCast((li << huffman_value_shift) | n)); + const chunk = @as(u16, @intCast((li << huffman_value_shift) | n)); var reverse = @as(u16, @intCast(bu.bitReverse(u16, @as(u16, @intCast(ncode)), 16))); reverse >>= @as(u4, @intCast(16 - n)); if (n <= huffman_chunk_bits) { @@ -187,14 +187,14 @@ const HuffmanDecoder = struct { self.chunks[off] = chunk; } } else { - var j = reverse & (huffman_num_chunks - 1); + const j = reverse & (huffman_num_chunks - 1); if (sanity) { // Expect an indirect chunk assert(self.chunks[j] & huffman_count_mask == huffman_chunk_bits + 1); // Longer codes should have been // associated with a link table above. } - var value = self.chunks[j] >> huffman_value_shift; + const value = self.chunks[j] >> huffman_value_shift; var link_tab = self.links[value]; reverse >>= huffman_chunk_bits; var off = reverse; @@ -354,8 +354,8 @@ pub fn Decompressor(comptime ReaderType: type) type { fn init(allocator: Allocator, in_reader: ReaderType, dict: ?[]const u8) !Self { fixed_huffman_decoder = try fixedHuffmanDecoderInit(allocator); - var bits = try allocator.create([max_num_lit + max_num_dist]u32); - var codebits = try allocator.create([num_codes]u32); + const bits = try allocator.create([max_num_lit + max_num_dist]u32); + const codebits = try allocator.create([num_codes]u32); var dd = ddec.DictDecoder{}; try dd.init(allocator, max_match_offset, dict); @@ -416,7 +416,7 @@ pub fn Decompressor(comptime ReaderType: type) type { } self.final = self.b & 1 == 1; self.b >>= 1; - var typ = self.b & 3; + const typ = self.b & 3; self.b >>= 2; self.nb -= 1 + 2; switch (typ) { @@ -494,21 +494,21 @@ pub fn Decompressor(comptime ReaderType: type) type { while (self.nb < 5 + 5 + 4) { try self.moreBits(); } - var nlit = @as(u32, @intCast(self.b & 0x1F)) + 257; + const nlit = @as(u32, @intCast(self.b & 0x1F)) + 257; if (nlit > max_num_lit) { corrupt_input_error_offset = self.roffset; self.err = InflateError.CorruptInput; return InflateError.CorruptInput; } self.b >>= 5; - var ndist = @as(u32, @intCast(self.b & 0x1F)) + 1; + const ndist = @as(u32, @intCast(self.b & 0x1F)) + 1; if (ndist > max_num_dist) { corrupt_input_error_offset = self.roffset; self.err = InflateError.CorruptInput; return InflateError.CorruptInput; } self.b >>= 5; - var nclen = @as(u32, @intCast(self.b & 0xF)) + 4; + const nclen = @as(u32, @intCast(self.b & 0xF)) + 4; // num_codes is 19, so nclen is always valid. self.b >>= 4; self.nb -= 5 + 5 + 4; @@ -536,9 +536,9 @@ pub fn Decompressor(comptime ReaderType: type) type { // HLIT + 257 code lengths, HDIST + 1 code lengths, // using the code length Huffman code. i = 0; - var n = nlit + ndist; + const n = nlit + ndist; while (i < n) { - var x = try self.huffSym(&self.hd1); + const x = try self.huffSym(&self.hd1); if (x < 16) { // Actual length. self.bits[i] = x; @@ -618,7 +618,7 @@ pub fn Decompressor(comptime ReaderType: type) type { switch (self.step_state) { .init => { // Read literal and/or (length, distance) according to RFC section 3.2.3. - var v = try self.huffSym(self.hl.?); + const v = try self.huffSym(self.hl.?); var n: u32 = 0; // number of bits extra var length: u32 = 0; switch (v) { @@ -699,7 +699,7 @@ pub fn Decompressor(comptime ReaderType: type) type { switch (dist) { 0...3 => dist += 1, 4...max_num_dist - 1 => { // 4...29 - var nb = @as(u32, @intCast(dist - 2)) >> 1; + const nb = @as(u32, @intCast(dist - 2)) >> 1; // have 1 bit in bottom of dist, need nb more. var extra = (dist & 1) << @as(u5, @intCast(nb)); while (self.nb < nb) { @@ -757,14 +757,14 @@ pub fn Decompressor(comptime ReaderType: type) type { self.b = 0; // Length then ones-complement of length. - var nr: u32 = 4; + const nr: u32 = 4; self.inner_reader.readNoEof(self.buf[0..nr]) catch { self.err = InflateError.UnexpectedEndOfStream; return InflateError.UnexpectedEndOfStream; }; self.roffset += @as(u64, @intCast(nr)); - var n = @as(u32, @intCast(self.buf[0])) | @as(u32, @intCast(self.buf[1])) << 8; - var nn = @as(u32, @intCast(self.buf[2])) | @as(u32, @intCast(self.buf[3])) << 8; + const n = @as(u32, @intCast(self.buf[0])) | @as(u32, @intCast(self.buf[1])) << 8; + const nn = @as(u32, @intCast(self.buf[2])) | @as(u32, @intCast(self.buf[3])) << 8; if (@as(u16, @intCast(nn)) != @as(u16, @truncate(~n))) { corrupt_input_error_offset = self.roffset; self.err = InflateError.CorruptInput; @@ -789,7 +789,7 @@ pub fn Decompressor(comptime ReaderType: type) type { buf = buf[0..self.copy_len]; } - var cnt = try self.inner_reader.read(buf); + const cnt = try self.inner_reader.read(buf); if (cnt < buf.len) { self.err = InflateError.UnexpectedEndOfStream; } @@ -819,7 +819,7 @@ pub fn Decompressor(comptime ReaderType: type) type { } fn moreBits(self: *Self) InflateError!void { - var c = self.inner_reader.readByte() catch |e| { + const c = self.inner_reader.readByte() catch |e| { if (e == error.EndOfStream) { return InflateError.UnexpectedEndOfStream; } @@ -845,7 +845,7 @@ pub fn Decompressor(comptime ReaderType: type) type { var b = self.b; while (true) { while (nb < n) { - var c = self.inner_reader.readByte() catch |e| { + const c = self.inner_reader.readByte() catch |e| { self.b = b; self.nb = nb; if (e == error.EndOfStream) { @@ -1053,7 +1053,7 @@ test "inflate A Tale of Two Cities (1859) intro" { defer decomp.deinit(); var got: [700]u8 = undefined; - var got_len = try decomp.reader().read(&got); + const got_len = try decomp.reader().read(&got); try testing.expectEqual(@as(usize, 616), got_len); try testing.expectEqualSlices(u8, expected, got[0..expected.len]); } @@ -1117,6 +1117,6 @@ fn decompress(input: []const u8) !void { const reader = fib.reader(); var decomp = try decompressor(allocator, reader, null); defer decomp.deinit(); - var output = try decomp.reader().readAllAlloc(allocator, math.maxInt(usize)); + const output = try decomp.reader().readAllAlloc(allocator, math.maxInt(usize)); defer std.testing.allocator.free(output); } diff --git a/lib/std/compress/deflate/deflate_fast.zig b/lib/std/compress/deflate/deflate_fast.zig index a11548fa1f..3a2668762e 100644 --- a/lib/std/compress/deflate/deflate_fast.zig +++ b/lib/std/compress/deflate/deflate_fast.zig @@ -30,7 +30,7 @@ const table_size = 1 << table_bits; // Size of the table. const buffer_reset = math.maxInt(i32) - max_store_block_size * 2; fn load32(b: []u8, i: i32) u32 { - var s = b[@as(usize, @intCast(i)) .. @as(usize, @intCast(i)) + 4]; + const s = b[@as(usize, @intCast(i)) .. @as(usize, @intCast(i)) + 4]; return @as(u32, @intCast(s[0])) | @as(u32, @intCast(s[1])) << 8 | @as(u32, @intCast(s[2])) << 16 | @@ -38,7 +38,7 @@ fn load32(b: []u8, i: i32) u32 { } fn load64(b: []u8, i: i32) u64 { - var s = b[@as(usize, @intCast(i))..@as(usize, @intCast(i + 8))]; + const s = b[@as(usize, @intCast(i))..@as(usize, @intCast(i + 8))]; return @as(u64, @intCast(s[0])) | @as(u64, @intCast(s[1])) << 8 | @as(u64, @intCast(s[2])) << 16 | @@ -117,7 +117,7 @@ pub const DeflateFast = struct { // s_limit is when to stop looking for offset/length copies. The input_margin // lets us use a fast path for emitLiteral in the main loop, while we are // looking for copies. - var s_limit = @as(i32, @intCast(src.len - input_margin)); + const s_limit = @as(i32, @intCast(src.len - input_margin)); // next_emit is where in src the next emitLiteral should start from. var next_emit: i32 = 0; @@ -147,18 +147,18 @@ pub const DeflateFast = struct { var candidate: TableEntry = undefined; while (true) { s = next_s; - var bytes_between_hash_lookups = skip >> 5; + const bytes_between_hash_lookups = skip >> 5; next_s = s + bytes_between_hash_lookups; skip += bytes_between_hash_lookups; if (next_s > s_limit) { break :outer; } candidate = self.table[next_hash & table_mask]; - var now = load32(src, next_s); + const now = load32(src, next_s); self.table[next_hash & table_mask] = .{ .offset = s + self.cur, .val = cv }; next_hash = hash(now); - var offset = s - (candidate.offset - self.cur); + const offset = s - (candidate.offset - self.cur); if (offset > max_match_offset or cv != candidate.val) { // Out of range or not matched. cv = now; @@ -187,8 +187,8 @@ pub const DeflateFast = struct { // Extend the 4-byte match as long as possible. // s += 4; - var t = candidate.offset - self.cur + 4; - var l = self.matchLen(s, t, src); + const t = candidate.offset - self.cur + 4; + const l = self.matchLen(s, t, src); // matchToken is flate's equivalent of Snappy's emitCopy. (length,offset) dst[tokens_count.*] = token.matchToken( @@ -209,20 +209,20 @@ pub const DeflateFast = struct { // are faster as one load64 call (with some shifts) instead of // three load32 calls. var x = load64(src, s - 1); - var prev_hash = hash(@as(u32, @truncate(x))); + const prev_hash = hash(@as(u32, @truncate(x))); self.table[prev_hash & table_mask] = TableEntry{ .offset = self.cur + s - 1, .val = @as(u32, @truncate(x)), }; x >>= 8; - var curr_hash = hash(@as(u32, @truncate(x))); + const curr_hash = hash(@as(u32, @truncate(x))); candidate = self.table[curr_hash & table_mask]; self.table[curr_hash & table_mask] = TableEntry{ .offset = self.cur + s, .val = @as(u32, @truncate(x)), }; - var offset = s - (candidate.offset - self.cur); + const offset = s - (candidate.offset - self.cur); if (offset > max_match_offset or @as(u32, @truncate(x)) != candidate.val) { cv = @as(u32, @truncate(x >> 8)); next_hash = hash(cv); @@ -261,7 +261,7 @@ pub const DeflateFast = struct { // If we are inside the current block if (t >= 0) { var b = src[@as(usize, @intCast(t))..]; - var a = src[@as(usize, @intCast(s))..@as(usize, @intCast(s1))]; + const a = src[@as(usize, @intCast(s))..@as(usize, @intCast(s1))]; b = b[0..a.len]; // Extend the match to be as long as possible. for (a, 0..) |_, i| { @@ -273,7 +273,7 @@ pub const DeflateFast = struct { } // We found a match in the previous block. - var tp = @as(i32, @intCast(self.prev_len)) + t; + const tp = @as(i32, @intCast(self.prev_len)) + t; if (tp < 0) { return 0; } @@ -293,7 +293,7 @@ pub const DeflateFast = struct { // If we reached our limit, we matched everything we are // allowed to in the previous block and we return. - var n = @as(i32, @intCast(b.len)); + const n = @as(i32, @intCast(b.len)); if (@as(u32, @intCast(s + n)) == s1) { return n; } @@ -366,7 +366,7 @@ test "best speed match 1/3" { .cur = 0, }; var current = [_]u8{ 3, 4, 5, 0, 1, 2, 3, 4, 5 }; - var got: i32 = e.matchLen(3, -3, ¤t); + const got: i32 = e.matchLen(3, -3, ¤t); try expectEqual(@as(i32, 6), got); } { @@ -379,7 +379,7 @@ test "best speed match 1/3" { .cur = 0, }; var current = [_]u8{ 2, 4, 5, 0, 1, 2, 3, 4, 5 }; - var got: i32 = e.matchLen(3, -3, ¤t); + const got: i32 = e.matchLen(3, -3, ¤t); try expectEqual(@as(i32, 3), got); } { @@ -392,7 +392,7 @@ test "best speed match 1/3" { .cur = 0, }; var current = [_]u8{ 3, 4, 5, 0, 1, 2, 3, 4, 5 }; - var got: i32 = e.matchLen(3, -3, ¤t); + const got: i32 = e.matchLen(3, -3, ¤t); try expectEqual(@as(i32, 2), got); } { @@ -405,7 +405,7 @@ test "best speed match 1/3" { .cur = 0, }; var current = [_]u8{ 2, 2, 2, 2, 1, 2, 3, 4, 5 }; - var got: i32 = e.matchLen(0, -1, ¤t); + const got: i32 = e.matchLen(0, -1, ¤t); try expectEqual(@as(i32, 4), got); } { @@ -418,7 +418,7 @@ test "best speed match 1/3" { .cur = 0, }; var current = [_]u8{ 2, 2, 2, 2, 1, 2, 3, 4, 5 }; - var got: i32 = e.matchLen(4, -7, ¤t); + const got: i32 = e.matchLen(4, -7, ¤t); try expectEqual(@as(i32, 5), got); } { @@ -431,7 +431,7 @@ test "best speed match 1/3" { .cur = 0, }; var current = [_]u8{ 2, 2, 2, 2, 1, 2, 3, 4, 5 }; - var got: i32 = e.matchLen(0, -1, ¤t); + const got: i32 = e.matchLen(0, -1, ¤t); try expectEqual(@as(i32, 0), got); } { @@ -444,7 +444,7 @@ test "best speed match 1/3" { .cur = 0, }; var current = [_]u8{ 9, 2, 2, 2, 1, 2, 3, 4, 5 }; - var got: i32 = e.matchLen(1, 0, ¤t); + const got: i32 = e.matchLen(1, 0, ¤t); try expectEqual(@as(i32, 0), got); } } @@ -462,7 +462,7 @@ test "best speed match 2/3" { .cur = 0, }; var current = [_]u8{ 9, 2, 2, 2, 1, 2, 3, 4, 5 }; - var got: i32 = e.matchLen(1, -5, ¤t); + const got: i32 = e.matchLen(1, -5, ¤t); try expectEqual(@as(i32, 0), got); } { @@ -475,7 +475,7 @@ test "best speed match 2/3" { .cur = 0, }; var current = [_]u8{ 9, 2, 2, 2, 1, 2, 3, 4, 5 }; - var got: i32 = e.matchLen(1, -1, ¤t); + const got: i32 = e.matchLen(1, -1, ¤t); try expectEqual(@as(i32, 0), got); } { @@ -488,7 +488,7 @@ test "best speed match 2/3" { .cur = 0, }; var current = [_]u8{ 2, 2, 2, 2, 1, 2, 3, 4, 5 }; - var got: i32 = e.matchLen(1, 0, ¤t); + const got: i32 = e.matchLen(1, 0, ¤t); try expectEqual(@as(i32, 3), got); } { @@ -501,7 +501,7 @@ test "best speed match 2/3" { .cur = 0, }; var current = [_]u8{ 3, 4, 5 }; - var got: i32 = e.matchLen(0, -3, ¤t); + const got: i32 = e.matchLen(0, -3, ¤t); try expectEqual(@as(i32, 3), got); } } @@ -564,11 +564,11 @@ test "best speed match 2/2" { }; for (cases) |c| { - var previous = try testing.allocator.alloc(u8, c.previous); + const previous = try testing.allocator.alloc(u8, c.previous); defer testing.allocator.free(previous); @memset(previous, 0); - var current = try testing.allocator.alloc(u8, c.current); + const current = try testing.allocator.alloc(u8, c.current); defer testing.allocator.free(current); @memset(current, 0); @@ -579,7 +579,7 @@ test "best speed match 2/2" { .allocator = undefined, .cur = 0, }; - var got: i32 = e.matchLen(c.s, c.t, current); + const got: i32 = e.matchLen(c.s, c.t, current); try expectEqual(@as(i32, c.expected), got); } } @@ -609,10 +609,10 @@ test "best speed shift offsets" { // Second part should pick up matches from the first block. tokens_count = 0; enc.encode(&tokens, &tokens_count, &test_data); - var want_first_tokens = tokens_count; + const want_first_tokens = tokens_count; tokens_count = 0; enc.encode(&tokens, &tokens_count, &test_data); - var want_second_tokens = tokens_count; + const want_second_tokens = tokens_count; try expect(want_first_tokens > want_second_tokens); @@ -657,7 +657,7 @@ test "best speed reset" { const ArrayList = std.ArrayList; const input_size = 65536; - var input = try testing.allocator.alloc(u8, input_size); + const input = try testing.allocator.alloc(u8, input_size); defer testing.allocator.free(input); var i: usize = 0; @@ -699,7 +699,7 @@ test "best speed reset" { // Reset until we are right before the wraparound. // Each reset adds max_match_offset to the offset. i = 0; - var limit = (buffer_reset - input.len - o - max_match_offset) / max_match_offset; + const limit = (buffer_reset - input.len - o - max_match_offset) / max_match_offset; while (i < limit) : (i += 1) { // skip ahead to where we are close to wrap around... comp.reset(discard.writer()); diff --git a/lib/std/compress/deflate/deflate_fast_test.zig b/lib/std/compress/deflate/deflate_fast_test.zig index 08f6079aa5..ca9a978ad1 100644 --- a/lib/std/compress/deflate/deflate_fast_test.zig +++ b/lib/std/compress/deflate/deflate_fast_test.zig @@ -39,18 +39,18 @@ test "best speed" { var tc_15 = [_]u32{ 65536, 129 }; var tc_16 = [_]u32{ 65536, 65536, 256 }; var tc_17 = [_]u32{ 65536, 65536, 65536 }; - var test_cases = [_][]u32{ + const test_cases = [_][]u32{ &tc_01, &tc_02, &tc_03, &tc_04, &tc_05, &tc_06, &tc_07, &tc_08, &tc_09, &tc_10, &tc_11, &tc_12, &tc_13, &tc_14, &tc_15, &tc_16, &tc_17, }; for (test_cases) |tc| { - var firsts = [_]u32{ 1, 65534, 65535, 65536, 65537, 131072 }; + const firsts = [_]u32{ 1, 65534, 65535, 65536, 65537, 131072 }; for (firsts) |first_n| { tc[0] = first_n; - var to_flush = [_]bool{ false, true }; + const to_flush = [_]bool{ false, true }; for (to_flush) |flush| { var compressed = ArrayList(u8).init(testing.allocator); defer compressed.deinit(); @@ -75,14 +75,14 @@ test "best speed" { try comp.close(); - var decompressed = try testing.allocator.alloc(u8, want.items.len); + const decompressed = try testing.allocator.alloc(u8, want.items.len); defer testing.allocator.free(decompressed); var fib = io.fixedBufferStream(compressed.items); var decomp = try inflate.decompressor(testing.allocator, fib.reader(), null); defer decomp.deinit(); - var read = try decomp.reader().readAll(decompressed); + const read = try decomp.reader().readAll(decompressed); _ = decomp.close(); try testing.expectEqual(want.items.len, read); @@ -109,7 +109,7 @@ test "best speed max match offset" { for (extras) |extra| { var offset_adj: i32 = -5; while (offset_adj <= 5) : (offset_adj += 1) { - var offset = deflate_const.max_match_offset + offset_adj; + const offset = deflate_const.max_match_offset + offset_adj; // Make src to be a []u8 of the form // fmt("{s}{s}{s}{s}{s}", .{abc, zeros0, xyzMaybe, abc, zeros1}) @@ -119,7 +119,7 @@ test "best speed max match offset" { // zeros1 is between 0 and 30 zeros. // The difference between the two abc's will be offset, which // is max_match_offset plus or minus a small adjustment. - var src_len: usize = @as(usize, @intCast(offset + @as(i32, abc.len) + @as(i32, @intCast(extra)))); + const src_len: usize = @as(usize, @intCast(offset + @as(i32, abc.len) + @as(i32, @intCast(extra)))); var src = try testing.allocator.alloc(u8, src_len); defer testing.allocator.free(src); @@ -143,13 +143,13 @@ test "best speed max match offset" { try comp.writer().writeAll(src); _ = try comp.close(); - var decompressed = try testing.allocator.alloc(u8, src.len); + const decompressed = try testing.allocator.alloc(u8, src.len); defer testing.allocator.free(decompressed); var fib = io.fixedBufferStream(compressed.items); var decomp = try inflate.decompressor(testing.allocator, fib.reader(), null); defer decomp.deinit(); - var read = try decomp.reader().readAll(decompressed); + const read = try decomp.reader().readAll(decompressed); _ = decomp.close(); try testing.expectEqual(src.len, read); diff --git a/lib/std/compress/deflate/dict_decoder.zig b/lib/std/compress/deflate/dict_decoder.zig index 75fdd359dd..72a3f6310b 100644 --- a/lib/std/compress/deflate/dict_decoder.zig +++ b/lib/std/compress/deflate/dict_decoder.zig @@ -123,7 +123,7 @@ pub const DictDecoder = struct { // This invariant must be kept: 0 < dist <= histSize() pub fn writeCopy(self: *Self, dist: u32, length: u32) u32 { assert(0 < dist and dist <= self.histSize()); - var dst_base = self.wr_pos; + const dst_base = self.wr_pos; var dst_pos = dst_base; var src_pos: i32 = @as(i32, @intCast(dst_pos)) - @as(i32, @intCast(dist)); var end_pos = dst_pos + length; @@ -175,12 +175,12 @@ pub const DictDecoder = struct { // This invariant must be kept: 0 < dist <= histSize() pub fn tryWriteCopy(self: *Self, dist: u32, length: u32) u32 { var dst_pos = self.wr_pos; - var end_pos = dst_pos + length; + const end_pos = dst_pos + length; if (dst_pos < dist or end_pos > self.hist.len) { return 0; } - var dst_base = dst_pos; - var src_pos = dst_pos - dist; + const dst_base = dst_pos; + const src_pos = dst_pos - dist; // Copy possibly overlapping section before destination position. while (dst_pos < end_pos) { @@ -195,7 +195,7 @@ pub const DictDecoder = struct { // emitted to the user. The data returned by readFlush must be fully consumed // before calling any other DictDecoder methods. pub fn readFlush(self: *Self) []u8 { - var to_read = self.hist[self.rd_pos..self.wr_pos]; + const to_read = self.hist[self.rd_pos..self.wr_pos]; self.rd_pos = self.wr_pos; if (self.wr_pos == self.hist.len) { self.wr_pos = 0; @@ -279,7 +279,7 @@ test "dictionary decoder" { length: u32, // Length of copy or insertion }; - var poem_refs = [_]PoemRefs{ + const poem_refs = [_]PoemRefs{ .{ .dist = 0, .length = 38 }, .{ .dist = 33, .length = 3 }, .{ .dist = 0, .length = 48 }, .{ .dist = 79, .length = 3 }, .{ .dist = 0, .length = 11 }, .{ .dist = 34, .length = 5 }, .{ .dist = 0, .length = 6 }, .{ .dist = 23, .length = 7 }, .{ .dist = 0, .length = 8 }, @@ -368,7 +368,7 @@ test "dictionary decoder" { fn writeString(dst_dd: *DictDecoder, dst: anytype, str: []const u8) !void { var string = str; while (string.len > 0) { - var cnt = DictDecoder.copy(dst_dd.writeSlice(), string); + const cnt = DictDecoder.copy(dst_dd.writeSlice(), string); dst_dd.writeMark(cnt); string = string[cnt..]; if (dst_dd.availWrite() == 0) { diff --git a/lib/std/compress/deflate/huffman_bit_writer.zig b/lib/std/compress/deflate/huffman_bit_writer.zig index 18813b0b28..27c8b0a7af 100644 --- a/lib/std/compress/deflate/huffman_bit_writer.zig +++ b/lib/std/compress/deflate/huffman_bit_writer.zig @@ -134,7 +134,7 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { self.bits |= @as(u64, @intCast(b)) << @as(u6, @intCast(self.nbits)); self.nbits += nb; if (self.nbits >= 48) { - var bits = self.bits; + const bits = self.bits; self.bits >>= 48; self.nbits -= 48; var n = self.nbytes; @@ -224,7 +224,7 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { while (size != bad_code) : (in_index += 1) { // INVARIANT: We have seen "count" copies of size that have not yet // had output generated for them. - var next_size = codegen[in_index]; + const next_size = codegen[in_index]; if (next_size == size) { count += 1; continue; @@ -295,12 +295,12 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { while (num_codegens > 4 and self.codegen_freq[codegen_order[num_codegens - 1]] == 0) { num_codegens -= 1; } - var header = 3 + 5 + 5 + 4 + (3 * num_codegens) + + const header = 3 + 5 + 5 + 4 + (3 * num_codegens) + self.codegen_encoding.bitLength(self.codegen_freq[0..]) + self.codegen_freq[16] * 2 + self.codegen_freq[17] * 3 + self.codegen_freq[18] * 7; - var size = header + + const size = header + lit_enc.bitLength(self.literal_freq) + off_enc.bitLength(self.offset_freq) + extra_bits; @@ -339,7 +339,7 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { self.bits |= @as(u64, @intCast(c.code)) << @as(u6, @intCast(self.nbits)); self.nbits += @as(u32, @intCast(c.len)); if (self.nbits >= 48) { - var bits = self.bits; + const bits = self.bits; self.bits >>= 48; self.nbits -= 48; var n = self.nbytes; @@ -386,13 +386,13 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { var i: u32 = 0; while (i < num_codegens) : (i += 1) { - var value = @as(u32, @intCast(self.codegen_encoding.codes[codegen_order[i]].len)); + const value = @as(u32, @intCast(self.codegen_encoding.codes[codegen_order[i]].len)); try self.writeBits(@as(u32, @intCast(value)), 3); } i = 0; while (true) { - var code_word: u32 = @as(u32, @intCast(self.codegen[i])); + const code_word: u32 = @as(u32, @intCast(self.codegen[i])); i += 1; if (code_word == bad_code) { break; @@ -458,14 +458,14 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { return; } - var lit_and_off = self.indexTokens(tokens); - var num_literals = lit_and_off.num_literals; - var num_offsets = lit_and_off.num_offsets; + const lit_and_off = self.indexTokens(tokens); + const num_literals = lit_and_off.num_literals; + const num_offsets = lit_and_off.num_offsets; var extra_bits: u32 = 0; - var ret = storedSizeFits(input); - var stored_size = ret.size; - var storable = ret.storable; + const ret = storedSizeFits(input); + const stored_size = ret.size; + const storable = ret.storable; if (storable) { // We only bother calculating the costs of the extra bits required by @@ -504,12 +504,12 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { &self.offset_encoding, ); self.codegen_encoding.generate(self.codegen_freq[0..], 7); - var dynamic_size = self.dynamicSize( + const dynamic_size = self.dynamicSize( &self.literal_encoding, &self.offset_encoding, extra_bits, ); - var dyn_size = dynamic_size.size; + const dyn_size = dynamic_size.size; num_codegens = dynamic_size.num_codegens; if (dyn_size < size) { @@ -551,9 +551,9 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { return; } - var total_tokens = self.indexTokens(tokens); - var num_literals = total_tokens.num_literals; - var num_offsets = total_tokens.num_offsets; + const total_tokens = self.indexTokens(tokens); + const num_literals = total_tokens.num_literals; + const num_offsets = total_tokens.num_offsets; // Generate codegen and codegenFrequencies, which indicates how to encode // the literal_encoding and the offset_encoding. @@ -564,15 +564,15 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { &self.offset_encoding, ); self.codegen_encoding.generate(self.codegen_freq[0..], 7); - var dynamic_size = self.dynamicSize(&self.literal_encoding, &self.offset_encoding, 0); - var size = dynamic_size.size; - var num_codegens = dynamic_size.num_codegens; + const dynamic_size = self.dynamicSize(&self.literal_encoding, &self.offset_encoding, 0); + const size = dynamic_size.size; + const num_codegens = dynamic_size.num_codegens; // Store bytes, if we don't get a reasonable improvement. - var stored_size = storedSizeFits(input); - var ssize = stored_size.size; - var storable = stored_size.storable; + const stored_size = storedSizeFits(input); + const ssize = stored_size.size; + const storable = stored_size.storable; if (storable and ssize < (size + (size >> 4))) { try self.writeStoredHeader(input.?.len, eof); try self.writeBytes(input.?); @@ -611,8 +611,8 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { self.literal_freq[token.literal(t)] += 1; continue; } - var length = token.length(t); - var offset = token.offset(t); + const length = token.length(t); + const offset = token.offset(t); self.literal_freq[length_codes_start + token.lengthCode(length)] += 1; self.offset_freq[token.offsetCode(offset)] += 1; } @@ -660,21 +660,21 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { continue; } // Write the length - var length = token.length(t); - var length_code = token.lengthCode(length); + const length = token.length(t); + const length_code = token.lengthCode(length); try self.writeCode(le_codes[length_code + length_codes_start]); - var extra_length_bits = @as(u32, @intCast(length_extra_bits[length_code])); + const extra_length_bits = @as(u32, @intCast(length_extra_bits[length_code])); if (extra_length_bits > 0) { - var extra_length = @as(u32, @intCast(length - length_base[length_code])); + const extra_length = @as(u32, @intCast(length - length_base[length_code])); try self.writeBits(extra_length, extra_length_bits); } // Write the offset - var offset = token.offset(t); - var offset_code = token.offsetCode(offset); + const offset = token.offset(t); + const offset_code = token.offsetCode(offset); try self.writeCode(oe_codes[offset_code]); - var extra_offset_bits = @as(u32, @intCast(offset_extra_bits[offset_code])); + const extra_offset_bits = @as(u32, @intCast(offset_extra_bits[offset_code])); if (extra_offset_bits > 0) { - var extra_offset = @as(u32, @intCast(offset - offset_base[offset_code])); + const extra_offset = @as(u32, @intCast(offset - offset_base[offset_code])); try self.writeBits(extra_offset, extra_offset_bits); } } @@ -718,15 +718,15 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { &self.huff_offset, ); self.codegen_encoding.generate(self.codegen_freq[0..], 7); - var dynamic_size = self.dynamicSize(&self.literal_encoding, &self.huff_offset, 0); - var size = dynamic_size.size; + const dynamic_size = self.dynamicSize(&self.literal_encoding, &self.huff_offset, 0); + const size = dynamic_size.size; num_codegens = dynamic_size.num_codegens; // Store bytes, if we don't get a reasonable improvement. - var stored_size_ret = storedSizeFits(input); - var ssize = stored_size_ret.size; - var storable = stored_size_ret.storable; + const stored_size_ret = storedSizeFits(input); + const ssize = stored_size_ret.size; + const storable = stored_size_ret.storable; if (storable and ssize < (size + (size >> 4))) { try self.writeStoredHeader(input.len, eof); @@ -736,18 +736,18 @@ pub fn HuffmanBitWriter(comptime WriterType: type) type { // Huffman. try self.writeDynamicHeader(num_literals, num_offsets, num_codegens, eof); - var encoding = self.literal_encoding.codes[0..257]; + const encoding = self.literal_encoding.codes[0..257]; var n = self.nbytes; for (input) |t| { // Bitwriting inlined, ~30% speedup - var c = encoding[t]; + const c = encoding[t]; self.bits |= @as(u64, @intCast(c.code)) << @as(u6, @intCast(self.nbits)); self.nbits += @as(u32, @intCast(c.len)); if (self.nbits < 48) { continue; } // Store 6 bytes - var bits = self.bits; + const bits = self.bits; self.bits >>= 48; self.nbits -= 48; var bytes = self.bytes[n..][0..6]; @@ -1679,7 +1679,7 @@ fn testWriterEOF(ttype: TestType, ht_tokens: []const token.Token, input: []const try bw.flush(); - var b = buf.items; + const b = buf.items; try expect(b.len > 0); try expect(b[0] & 1 == 1); } diff --git a/lib/std/compress/deflate/huffman_code.zig b/lib/std/compress/deflate/huffman_code.zig index 4fea45f863..c484d71fad 100644 --- a/lib/std/compress/deflate/huffman_code.zig +++ b/lib/std/compress/deflate/huffman_code.zig @@ -96,7 +96,7 @@ pub const HuffmanEncoder = struct { mem.sort(LiteralNode, self.lfs, {}, byFreq); // Get the number of literals for each bit count - var bit_count = self.bitCounts(list, max_bits); + const bit_count = self.bitCounts(list, max_bits); // And do the assignment self.assignEncodingAndSize(bit_count, list); } @@ -128,7 +128,7 @@ pub const HuffmanEncoder = struct { // that should be encoded in i bits. fn bitCounts(self: *HuffmanEncoder, list: []LiteralNode, max_bits_to_use: usize) []u32 { var max_bits = max_bits_to_use; - var n = list.len; + const n = list.len; assert(max_bits < max_bits_limit); @@ -184,10 +184,10 @@ pub const HuffmanEncoder = struct { continue; } - var prev_freq = l.last_freq; + const prev_freq = l.last_freq; if (l.next_char_freq < l.next_pair_freq) { // The next item on this row is a leaf node. - var next = leaf_counts[level][level] + 1; + const next = leaf_counts[level][level] + 1; l.last_freq = l.next_char_freq; // Lower leaf_counts are the same of the previous node. leaf_counts[level][level] = next; @@ -236,7 +236,7 @@ pub const HuffmanEncoder = struct { var bit_count = self.bit_count[0 .. max_bits + 1]; var bits: u32 = 1; - var counts = &leaf_counts[max_bits]; + const counts = &leaf_counts[max_bits]; { var level = max_bits; while (level > 0) : (level -= 1) { @@ -267,7 +267,7 @@ pub const HuffmanEncoder = struct { // are encoded using "bits" bits, and get the values // code, code + 1, .... The code values are // assigned in literal order (not frequency order). - var chunk = list[list.len - @as(u32, @intCast(bits)) ..]; + const chunk = list[list.len - @as(u32, @intCast(bits)) ..]; self.lns = chunk; mem.sort(LiteralNode, self.lns, {}, byLiteral); @@ -303,7 +303,7 @@ pub fn newHuffmanEncoder(allocator: Allocator, size: u32) !HuffmanEncoder { // Generates a HuffmanCode corresponding to the fixed literal table pub fn generateFixedLiteralEncoding(allocator: Allocator) !HuffmanEncoder { - var h = try newHuffmanEncoder(allocator, deflate_const.max_num_frequencies); + const h = try newHuffmanEncoder(allocator, deflate_const.max_num_frequencies); var codes = h.codes; var ch: u16 = 0; @@ -338,7 +338,7 @@ pub fn generateFixedLiteralEncoding(allocator: Allocator) !HuffmanEncoder { } pub fn generateFixedOffsetEncoding(allocator: Allocator) !HuffmanEncoder { - var h = try newHuffmanEncoder(allocator, 30); + const h = try newHuffmanEncoder(allocator, 30); var codes = h.codes; for (codes, 0..) |_, ch| { codes[ch] = HuffCode{ .code = bu.bitReverse(u16, @as(u16, @intCast(ch)), 5), .len = 5 }; diff --git a/lib/std/compress/zstandard.zig b/lib/std/compress/zstandard.zig index 225d6a9c69..4d9421acac 100644 --- a/lib/std/compress/zstandard.zig +++ b/lib/std/compress/zstandard.zig @@ -268,7 +268,7 @@ test "zstandard decompression" { const compressed3 = @embedFile("testdata/rfc8478.txt.zst.3"); const compressed19 = @embedFile("testdata/rfc8478.txt.zst.19"); - var buffer = try std.testing.allocator.alloc(u8, uncompressed.len); + const buffer = try std.testing.allocator.alloc(u8, uncompressed.len); defer std.testing.allocator.free(buffer); const res3 = try decompress.decode(buffer, compressed3, true); diff --git a/lib/std/compress/zstandard/decode/huffman.zig b/lib/std/compress/zstandard/decode/huffman.zig index 13fb1ac5f2..9fc5cac7e5 100644 --- a/lib/std/compress/zstandard/decode/huffman.zig +++ b/lib/std/compress/zstandard/decode/huffman.zig @@ -54,7 +54,7 @@ fn decodeFseHuffmanTreeSlice(src: []const u8, compressed_size: usize, weights: * const start_index = std.math.cast(usize, counting_reader.bytes_read) orelse return error.MalformedHuffmanTree; - var huff_data = src[start_index..compressed_size]; + const huff_data = src[start_index..compressed_size]; var huff_bits: readers.ReverseBitReader = undefined; huff_bits.init(huff_data) catch return error.MalformedHuffmanTree; diff --git a/lib/std/compress/zstandard/decompress.zig b/lib/std/compress/zstandard/decompress.zig index c33d87379a..a012312ab1 100644 --- a/lib/std/compress/zstandard/decompress.zig +++ b/lib/std/compress/zstandard/decompress.zig @@ -304,7 +304,7 @@ pub fn decodeZstandardFrame( var frame_context = context: { var fbs = std.io.fixedBufferStream(src[consumed_count..]); - var source = fbs.reader(); + const source = fbs.reader(); const frame_header = try decodeZstandardHeader(source); consumed_count += fbs.pos; break :context FrameContext.init( @@ -447,7 +447,7 @@ pub fn decodeZstandardFrameArrayList( var frame_context = context: { var fbs = std.io.fixedBufferStream(src[consumed_count..]); - var source = fbs.reader(); + const source = fbs.reader(); const frame_header = try decodeZstandardHeader(source); consumed_count += fbs.pos; break :context try FrameContext.init(frame_header, window_size_max, verify_checksum); diff --git a/lib/std/crypto/25519/curve25519.zig b/lib/std/crypto/25519/curve25519.zig index d5d70d00e4..48f167922e 100644 --- a/lib/std/crypto/25519/curve25519.zig +++ b/lib/std/crypto/25519/curve25519.zig @@ -129,7 +129,7 @@ test "non-affine edwards25519 to curve25519 projection" { const skh = "90e7595fc89e52fdfddce9c6a43d74dbf6047025ee0462d2d172e8b6a2841d6e"; var sk: [32]u8 = undefined; _ = std.fmt.hexToBytes(&sk, skh) catch unreachable; - var edp = try crypto.ecc.Edwards25519.basePoint.mul(sk); + const edp = try crypto.ecc.Edwards25519.basePoint.mul(sk); const xp = try Curve25519.fromEdwards25519(edp); const expected_hex = "cc4f2cdb695dd766f34118eb67b98652fed1d8bc49c330b119bbfa8a64989378"; var expected: [32]u8 = undefined; diff --git a/lib/std/crypto/25519/field.zig b/lib/std/crypto/25519/field.zig index 401616f1b8..e18093f4c2 100644 --- a/lib/std/crypto/25519/field.zig +++ b/lib/std/crypto/25519/field.zig @@ -416,7 +416,7 @@ pub const Fe = struct { /// Compute the square root of `x2`, returning `error.NotSquare` if `x2` was not a square pub fn sqrt(x2: Fe) NotSquareError!Fe { - var x2_copy = x2; + const x2_copy = x2; const x = x2.uncheckedSqrt(); const check = x.sq().sub(x2_copy); if (check.isZero()) { diff --git a/lib/std/crypto/Certificate.zig b/lib/std/crypto/Certificate.zig index 9303e3c522..8318269d87 100644 --- a/lib/std/crypto/Certificate.zig +++ b/lib/std/crypto/Certificate.zig @@ -982,7 +982,7 @@ pub const rsa = struct { if (mgf_len > mgf_out_buf.len) { // Modulus > 4096 bits return error.InvalidSignature; } - var mgf_out = mgf_out_buf[0 .. ((mgf_len - 1) / Hash.digest_length + 1) * Hash.digest_length]; + const mgf_out = mgf_out_buf[0 .. ((mgf_len - 1) / Hash.digest_length + 1) * Hash.digest_length]; var dbMask = try MGF1(Hash, mgf_out, h, mgf_len); // 8. Let DB = maskedDB \xor dbMask. diff --git a/lib/std/crypto/aes.zig b/lib/std/crypto/aes.zig index d043099f50..f5752888fc 100644 --- a/lib/std/crypto/aes.zig +++ b/lib/std/crypto/aes.zig @@ -47,7 +47,7 @@ test "ctr" { }; var out: [exp_out.len]u8 = undefined; - var ctx = Aes128.initEnc(key); + const ctx = Aes128.initEnc(key); ctr(AesEncryptCtx(Aes128), ctx, out[0..], in[0..], iv, std.builtin.Endian.big); try testing.expectEqualSlices(u8, exp_out[0..], out[0..]); } diff --git a/lib/std/crypto/aes_ocb.zig b/lib/std/crypto/aes_ocb.zig index 05353a3c82..879710d848 100644 --- a/lib/std/crypto/aes_ocb.zig +++ b/lib/std/crypto/aes_ocb.zig @@ -95,7 +95,7 @@ fn AesOcb(comptime Aes: anytype) type { var ktop_: Block = undefined; aes_enc_ctx.encrypt(&ktop_, &nx); const ktop = mem.readInt(u128, &ktop_, .big); - var stretch = (@as(u192, ktop) << 64) | @as(u192, @as(u64, @truncate(ktop >> 64)) ^ @as(u64, @truncate(ktop >> 56))); + const stretch = (@as(u192, ktop) << 64) | @as(u192, @as(u64, @truncate(ktop >> 64)) ^ @as(u64, @truncate(ktop >> 56))); var offset: Block = undefined; mem.writeInt(u128, &offset, @as(u128, @truncate(stretch >> (64 - @as(u7, bottom)))), .big); return offset; diff --git a/lib/std/crypto/argon2.zig b/lib/std/crypto/argon2.zig index 4e6d391799..8440590a98 100644 --- a/lib/std/crypto/argon2.zig +++ b/lib/std/crypto/argon2.zig @@ -565,7 +565,7 @@ const PhcFormatHasher = struct { const expected_hash = hash_result.hash.constSlice(); var hash_buf: [max_hash_len]u8 = undefined; if (expected_hash.len > hash_buf.len) return HasherError.InvalidEncoding; - var hash = hash_buf[0..expected_hash.len]; + const hash = hash_buf[0..expected_hash.len]; try kdf(allocator, hash, password, hash_result.salt.constSlice(), params, mode); if (!mem.eql(u8, hash, expected_hash)) return HasherError.PasswordVerificationFailed; diff --git a/lib/std/crypto/ascon.zig b/lib/std/crypto/ascon.zig index 521f9c922e..7691f14590 100644 --- a/lib/std/crypto/ascon.zig +++ b/lib/std/crypto/ascon.zig @@ -42,8 +42,7 @@ pub fn State(comptime endian: std.builtin.Endian) type { /// Initialize the state from u64 words in native endianness. pub fn initFromWords(initial_state: [5]u64) Self { - var state = Self{ .st = initial_state }; - return state; + return .{ .st = initial_state }; } /// Initialize the state for Ascon XOF diff --git a/lib/std/crypto/bcrypt.zig b/lib/std/crypto/bcrypt.zig index 720f264d16..7c505f542f 100644 --- a/lib/std/crypto/bcrypt.zig +++ b/lib/std/crypto/bcrypt.zig @@ -431,7 +431,7 @@ pub fn bcrypt( const trimmed_len = @min(password.len, password_buf.len - 1); @memcpy(password_buf[0..trimmed_len], password[0..trimmed_len]); password_buf[trimmed_len] = 0; - var passwordZ = password_buf[0 .. trimmed_len + 1]; + const passwordZ = password_buf[0 .. trimmed_len + 1]; state.expand(salt[0..], passwordZ); const rounds: u64 = @as(u64, 1) << params.rounds_log; diff --git a/lib/std/crypto/blake3.zig b/lib/std/crypto/blake3.zig index 04becf6789..d87211fb1e 100644 --- a/lib/std/crypto/blake3.zig +++ b/lib/std/crypto/blake3.zig @@ -241,7 +241,7 @@ const Output = struct { var out_block_it = ChunkIterator.init(output, 2 * OUT_LEN); var output_block_counter: usize = 0; while (out_block_it.next()) |out_block| { - var words = compress( + const words = compress( self.input_chaining_value, self.block_words, self.block_len, diff --git a/lib/std/crypto/ecdsa.zig b/lib/std/crypto/ecdsa.zig index 6f8a32ea21..321923525b 100644 --- a/lib/std/crypto/ecdsa.zig +++ b/lib/std/crypto/ecdsa.zig @@ -201,7 +201,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type { const scalar_encoded_length = Curve.scalar.encoded_length; const h_len = @max(Hash.digest_length, scalar_encoded_length); var h: [h_len]u8 = [_]u8{0} ** h_len; - var h_slice = h[h_len - Hash.digest_length .. h_len]; + const h_slice = h[h_len - Hash.digest_length .. h_len]; self.h.final(h_slice); std.debug.assert(h.len >= scalar_encoded_length); diff --git a/lib/std/crypto/pbkdf2.zig b/lib/std/crypto/pbkdf2.zig index 2e0318369b..cb11950228 100644 --- a/lib/std/crypto/pbkdf2.zig +++ b/lib/std/crypto/pbkdf2.zig @@ -255,10 +255,8 @@ test "Very large dk_len" { const c = 1; const dk_len = 1 << 33; - var dk = try std.testing.allocator.alloc(u8, dk_len); - defer { - std.testing.allocator.free(dk); - } + const dk = try std.testing.allocator.alloc(u8, dk_len); + defer std.testing.allocator.free(dk); // Just verify this doesn't crash with an overflow try pbkdf2(dk, p, s, c, HmacSha1); diff --git a/lib/std/crypto/pcurves/common.zig b/lib/std/crypto/pcurves/common.zig index 4a6815ae05..ccf40f59ce 100644 --- a/lib/std/crypto/pcurves/common.zig +++ b/lib/std/crypto/pcurves/common.zig @@ -71,7 +71,7 @@ pub fn Field(comptime params: FieldParams) type { /// Unpack a field element. pub fn fromBytes(s_: [encoded_length]u8, endian: std.builtin.Endian) NonCanonicalError!Fe { - var s = if (endian == .little) s_ else orderSwap(s_); + const s = if (endian == .little) s_ else orderSwap(s_); try rejectNonCanonical(s, .little); var limbs_z: NonMontgomeryDomainFieldElement = undefined; fiat.fromBytes(&limbs_z, s); diff --git a/lib/std/crypto/poly1305.zig b/lib/std/crypto/poly1305.zig index 67e1b630c1..d9fd344c19 100644 --- a/lib/std/crypto/poly1305.zig +++ b/lib/std/crypto/poly1305.zig @@ -90,8 +90,8 @@ pub const Poly1305 = struct { h2 = t2 & 3; // Add c*(4+1) - var cclo = t2 & ~@as(u64, 3); - var cchi = t3; + const cclo = t2 & ~@as(u64, 3); + const cchi = t3; v = @addWithOverflow(h0, cclo); h0 = v[0]; v = add(h1, cchi, v[1]); @@ -163,7 +163,7 @@ pub const Poly1305 = struct { var h0 = st.h[0]; var h1 = st.h[1]; - var h2 = st.h[2]; + const h2 = st.h[2]; // H - (2^130 - 5) var v = @subWithOverflow(h0, 0xfffffffffffffffb); diff --git a/lib/std/crypto/salsa20.zig b/lib/std/crypto/salsa20.zig index b83db0a317..7f4c1b0157 100644 --- a/lib/std/crypto/salsa20.zig +++ b/lib/std/crypto/salsa20.zig @@ -605,8 +605,8 @@ test "xsalsa20poly1305 box" { crypto.random.bytes(&msg); crypto.random.bytes(&nonce); - var kp1 = try Box.KeyPair.create(null); - var kp2 = try Box.KeyPair.create(null); + const kp1 = try Box.KeyPair.create(null); + const kp2 = try Box.KeyPair.create(null); try Box.seal(boxed[0..], msg[0..], nonce, kp1.public_key, kp2.secret_key); try Box.open(msg2[0..], boxed[0..], nonce, kp2.public_key, kp1.secret_key); } @@ -617,7 +617,7 @@ test "xsalsa20poly1305 sealedbox" { var boxed: [msg.len + SealedBox.seal_length]u8 = undefined; crypto.random.bytes(&msg); - var kp = try Box.KeyPair.create(null); + const kp = try Box.KeyPair.create(null); try SealedBox.seal(boxed[0..], msg[0..], kp.public_key); try SealedBox.open(msg2[0..], boxed[0..], kp); } diff --git a/lib/std/crypto/scrypt.zig b/lib/std/crypto/scrypt.zig index cf16476d92..96943b06f1 100644 --- a/lib/std/crypto/scrypt.zig +++ b/lib/std/crypto/scrypt.zig @@ -87,8 +87,8 @@ fn integerify(b: []align(16) const u32, r: u30) u64 { } fn smix(b: []align(16) u8, r: u30, n: usize, v: []align(16) u32, xy: []align(16) u32) void { - var x: []align(16) u32 = @alignCast(xy[0 .. 32 * r]); - var y: []align(16) u32 = @alignCast(xy[32 * r ..]); + const x: []align(16) u32 = @alignCast(xy[0 .. 32 * r]); + const y: []align(16) u32 = @alignCast(xy[32 * r ..]); for (x, 0..) |*v1, j| { v1.* = mem.readInt(u32, b[4 * j ..][0..4], .little); @@ -191,9 +191,9 @@ pub fn kdf( params.r > max_int / 256 or n > max_int / 128 / @as(u64, params.r)) return KdfError.WeakParameters; - var xy = try allocator.alignedAlloc(u32, 16, 64 * params.r); + const xy = try allocator.alignedAlloc(u32, 16, 64 * params.r); defer allocator.free(xy); - var v = try allocator.alignedAlloc(u32, 16, 32 * n * params.r); + const v = try allocator.alignedAlloc(u32, 16, 32 * n * params.r); defer allocator.free(v); var dk = try allocator.alignedAlloc(u8, 16, params.p * 128 * params.r); defer allocator.free(dk); @@ -263,7 +263,7 @@ const crypt_format = struct { const value = self.constSlice(); const len = Codec.encodedLen(value.len); if (len > buf.len) return EncodingError.NoSpaceLeft; - var encoded = buf[0..len]; + const encoded = buf[0..len]; Codec.encode(encoded, value); return encoded; } @@ -439,7 +439,7 @@ const PhcFormatHasher = struct { const expected_hash = hash_result.hash.constSlice(); var hash_buf: [max_hash_len]u8 = undefined; if (expected_hash.len > hash_buf.len) return HasherError.InvalidEncoding; - var hash = hash_buf[0..expected_hash.len]; + const hash = hash_buf[0..expected_hash.len]; try kdf(allocator, hash, password, hash_result.salt.constSlice(), params); if (!mem.eql(u8, hash, expected_hash)) return HasherError.PasswordVerificationFailed; } @@ -487,7 +487,7 @@ const CryptFormatHasher = struct { const expected_hash = hash_result.hash.constSlice(); var hash_buf: [max_hash_len]u8 = undefined; if (expected_hash.len > hash_buf.len) return HasherError.InvalidEncoding; - var hash = hash_buf[0..expected_hash.len]; + const hash = hash_buf[0..expected_hash.len]; try kdf(allocator, hash, password, hash_result.salt, params); if (!mem.eql(u8, hash, expected_hash)) return HasherError.PasswordVerificationFailed; } diff --git a/lib/std/crypto/tls/Client.zig b/lib/std/crypto/tls/Client.zig index 5f6b1e4c14..af564a1e52 100644 --- a/lib/std/crypto/tls/Client.zig +++ b/lib/std/crypto/tls/Client.zig @@ -491,7 +491,7 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In try all_extd.ensure(4); const et = all_extd.decode(tls.ExtensionType); const ext_size = all_extd.decode(u16); - var extd = try all_extd.sub(ext_size); + const extd = try all_extd.sub(ext_size); _ = extd; switch (et) { .server_name => {}, @@ -516,7 +516,7 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In while (!certs_decoder.eof()) { try certs_decoder.ensure(3); const cert_size = certs_decoder.decode(u24); - var certd = try certs_decoder.sub(cert_size); + const certd = try certs_decoder.sub(cert_size); const subject_cert: Certificate = .{ .buffer = certd.buf, @@ -552,7 +552,7 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In try certs_decoder.ensure(2); const total_ext_size = certs_decoder.decode(u16); - var all_extd = try certs_decoder.sub(total_ext_size); + const all_extd = try certs_decoder.sub(total_ext_size); _ = all_extd; } }, diff --git a/lib/std/debug.zig b/lib/std/debug.zig index 9247ab4047..0ce9f7b132 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -812,7 +812,7 @@ pub fn writeStackTraceWindows( var addr_buf: [1024]usize = undefined; const n = walkStackWindows(addr_buf[0..], context); const addrs = addr_buf[0..n]; - var start_i: usize = if (start_addr) |saddr| blk: { + const start_i: usize = if (start_addr) |saddr| blk: { for (addrs, 0..) |addr, i| { if (addr == saddr) break :blk i; } @@ -1158,7 +1158,7 @@ pub fn readElfDebugInfo( var zlib_stream = std.compress.zlib.decompressStream(allocator, section_stream.reader()) catch continue; defer zlib_stream.deinit(); - var decompressed_section = try allocator.alloc(u8, chdr.ch_size); + const decompressed_section = try allocator.alloc(u8, chdr.ch_size); errdefer allocator.free(decompressed_section); const read = zlib_stream.reader().readAll(decompressed_section) catch continue; @@ -2046,7 +2046,7 @@ pub const ModuleDebugInfo = switch (native_os) { }; try DW.openDwarfDebugInfo(&di, allocator); - var info = OFileInfo{ + const info = OFileInfo{ .di = di, .addr_table = addr_table, }; @@ -2122,7 +2122,7 @@ pub const ModuleDebugInfo = switch (native_os) { // Check if its debug infos are already in the cache const o_file_path = mem.sliceTo(self.strings[symbol.ofile..], 0); - var o_file_info = self.ofiles.getPtr(o_file_path) orelse + const o_file_info = self.ofiles.getPtr(o_file_path) orelse (self.loadOFile(allocator, o_file_path) catch |err| switch (err) { error.FileNotFound, error.MissingDebugInfo, diff --git a/lib/std/dwarf.zig b/lib/std/dwarf.zig index 7b4aa0fdec..97864c03ff 100644 --- a/lib/std/dwarf.zig +++ b/lib/std/dwarf.zig @@ -622,7 +622,7 @@ fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, en return parseFormValue(allocator, in_stream, child_form_id, endian, is_64); } const F = @TypeOf(async parseFormValue(allocator, in_stream, child_form_id, endian, is_64)); - var frame = try allocator.create(F); + const frame = try allocator.create(F); defer allocator.destroy(frame); return await @asyncCall(frame, {}, parseFormValue, .{ allocator, in_stream, child_form_id, endian, is_64 }); }, @@ -1034,7 +1034,7 @@ pub const DwarfInfo = struct { // specified by DW_AT.low_pc or to some other value encoded // in the list itself. // If no starting value is specified use zero. - var base_address = compile_unit.die.getAttrAddr(di, AT.low_pc, compile_unit.*) catch |err| switch (err) { + const base_address = compile_unit.die.getAttrAddr(di, AT.low_pc, compile_unit.*) catch |err| switch (err) { error.MissingDebugInfo => @as(u64, 0), // TODO https://github.com/ziglang/zig/issues/11135 else => return err, }; @@ -1438,7 +1438,7 @@ pub const DwarfInfo = struct { if (opcode == LNS.extended_op) { const op_size = try leb.readULEB128(u64, in); if (op_size < 1) return badDwarf(); - var sub_op = try in.readByte(); + const sub_op = try in.readByte(); switch (sub_op) { LNE.end_sequence => { prog.end_sequence = true; @@ -2308,7 +2308,7 @@ fn readEhPointer(reader: anytype, enc: u8, addr_size_bytes: u8, ctx: EhPointerCo else => return badDwarf(), }; - var base = switch (enc & EH.PE.rel_mask) { + const base = switch (enc & EH.PE.rel_mask) { EH.PE.pcrel => ctx.pc_rel_base, EH.PE.textrel => ctx.text_rel_base orelse return error.PointerBaseNotSpecified, EH.PE.datarel => ctx.data_rel_base orelse return error.PointerBaseNotSpecified, @@ -2624,7 +2624,7 @@ pub const CommonInformationEntry = struct { var has_aug_data = false; var aug_str_len: usize = 0; - var aug_str_start = stream.pos; + const aug_str_start = stream.pos; var aug_byte = try reader.readByte(); while (aug_byte != 0) : (aug_byte = try reader.readByte()) { switch (aug_byte) { diff --git a/lib/std/dwarf/expressions.zig b/lib/std/dwarf/expressions.zig index 729ff0de9b..61acab7793 100644 --- a/lib/std/dwarf/expressions.zig +++ b/lib/std/dwarf/expressions.zig @@ -443,7 +443,7 @@ pub fn StackMachine(comptime options: ExpressionOptions) type { OP.xderef_type, => { if (self.stack.items.len == 0) return error.InvalidExpression; - var addr = try self.stack.items[self.stack.items.len - 1].asIntegral(); + const addr = try self.stack.items[self.stack.items.len - 1].asIntegral(); const addr_space_identifier: ?usize = switch (opcode) { OP.xderef, OP.xderef_size, @@ -1350,7 +1350,7 @@ test "DWARF expressions" { // Arithmetic and Logical Operations { - var context = ExpressionContext{}; + const context = ExpressionContext{}; stack_machine.reset(); program.clearRetainingCapacity(); @@ -1474,7 +1474,7 @@ test "DWARF expressions" { // Control Flow Operations { - var context = ExpressionContext{}; + const context = ExpressionContext{}; const expected = .{ .{ OP.le, 1, 1, 0 }, .{ OP.ge, 1, 0, 1 }, @@ -1531,7 +1531,7 @@ test "DWARF expressions" { // Type conversions { - var context = ExpressionContext{}; + const context = ExpressionContext{}; stack_machine.reset(); program.clearRetainingCapacity(); diff --git a/lib/std/enums.zig b/lib/std/enums.zig index b3b546c4d0..0ee090dae1 100644 --- a/lib/std/enums.zig +++ b/lib/std/enums.zig @@ -123,6 +123,7 @@ pub fn directEnumArray( test "std.enums.directEnumArray" { const E = enum(i4) { a = 4, b = 6, c = 2 }; var runtime_false: bool = false; + _ = &runtime_false; const array = directEnumArray(E, bool, 4, .{ .a = true, .b = runtime_false, @@ -165,6 +166,7 @@ pub fn directEnumArrayDefault( test "std.enums.directEnumArrayDefault" { const E = enum(i4) { a = 4, b = 6, c = 2 }; var runtime_false: bool = false; + _ = &runtime_false; const array = directEnumArrayDefault(E, bool, false, 4, .{ .a = true, .b = runtime_false, @@ -179,6 +181,7 @@ test "std.enums.directEnumArrayDefault" { test "std.enums.directEnumArrayDefault slice" { const E = enum(i4) { a = 4, b = 6, c = 2 }; var runtime_b = "b"; + _ = &runtime_b; const array = directEnumArrayDefault(E, []const u8, "default", 4, .{ .a = "a", .b = runtime_b, @@ -196,7 +199,7 @@ pub fn nameCast(comptime E: type, comptime value: anytype) E { return comptime blk: { const V = @TypeOf(value); if (V == E) break :blk value; - var name: ?[]const u8 = switch (@typeInfo(V)) { + const name: ?[]const u8 = switch (@typeInfo(V)) { .EnumLiteral, .Enum => @tagName(value), .Pointer => if (std.meta.trait.isZigString(V)) value else null, else => null, diff --git a/lib/std/event/group.zig b/lib/std/event/group.zig index 639d90b12a..6d513000f4 100644 --- a/lib/std/event/group.zig +++ b/lib/std/event/group.zig @@ -66,7 +66,7 @@ pub fn Group(comptime ReturnType: type) type { /// `func` must be async and have return type `ReturnType`. /// Thread-safe. pub fn call(self: *Self, comptime func: anytype, args: anytype) error{OutOfMemory}!void { - var frame = try self.allocator.create(@TypeOf(@call(.{ .modifier = .async_kw }, func, args))); + const frame = try self.allocator.create(@TypeOf(@call(.{ .modifier = .async_kw }, func, args))); errdefer self.allocator.destroy(frame); const node = try self.allocator.create(AllocStack.Node); errdefer self.allocator.destroy(node); diff --git a/lib/std/event/loop.zig b/lib/std/event/loop.zig index 883312d176..58cf09fbf5 100644 --- a/lib/std/event/loop.zig +++ b/lib/std/event/loop.zig @@ -753,7 +753,7 @@ pub const Loop = struct { } }; - var run_frame = try alloc.create(@Frame(Wrapper.run)); + const run_frame = try alloc.create(@Frame(Wrapper.run)); run_frame.* = async Wrapper.run(args, self, alloc); } diff --git a/lib/std/event/rwlock.zig b/lib/std/event/rwlock.zig index 47ddf74fd5..0f017a0ca0 100644 --- a/lib/std/event/rwlock.zig +++ b/lib/std/event/rwlock.zig @@ -228,7 +228,7 @@ test "std.event.RwLock" { } fn testLock(allocator: Allocator, lock: *RwLock) callconv(.Async) void { var read_nodes: [100]Loop.NextTickNode = undefined; - for (read_nodes) |*read_node| { + for (&read_nodes) |*read_node| { const frame = allocator.create(@Frame(readRunner)) catch @panic("memory"); read_node.data = frame; frame.* = async readRunner(lock); @@ -236,19 +236,19 @@ fn testLock(allocator: Allocator, lock: *RwLock) callconv(.Async) void { } var write_nodes: [shared_it_count]Loop.NextTickNode = undefined; - for (write_nodes) |*write_node| { + for (&write_nodes) |*write_node| { const frame = allocator.create(@Frame(writeRunner)) catch @panic("memory"); write_node.data = frame; frame.* = async writeRunner(lock); Loop.instance.?.onNextTick(write_node); } - for (write_nodes) |*write_node| { + for (&write_nodes) |*write_node| { const casted = @as(*const @Frame(writeRunner), @ptrCast(write_node.data)); await casted; allocator.destroy(casted); } - for (read_nodes) |*read_node| { + for (&read_nodes) |*read_node| { const casted = @as(*const @Frame(readRunner), @ptrCast(read_node.data)); await casted; allocator.destroy(casted); diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig index ed049079b6..e21b1b9af1 100644 --- a/lib/std/fmt.zig +++ b/lib/std/fmt.zig @@ -1296,10 +1296,10 @@ pub fn formatFloatDecimal( errol.roundToPrecision(&float_decimal, precision, errol.RoundMode.Decimal); // exp < 0 means the leading is always 0 as errol result is normalized. - var num_digits_whole = if (float_decimal.exp > 0) @as(usize, @intCast(float_decimal.exp)) else 0; + const num_digits_whole = if (float_decimal.exp > 0) @as(usize, @intCast(float_decimal.exp)) else 0; // the actual slice into the buffer, we may need to zero-pad between num_digits_whole and this. - var num_digits_whole_no_pad = @min(num_digits_whole, float_decimal.digits.len); + const num_digits_whole_no_pad = @min(num_digits_whole, float_decimal.digits.len); if (num_digits_whole > 0) { // We may have to zero pad, for instance 1e4 requires zero padding. @@ -1354,10 +1354,10 @@ pub fn formatFloatDecimal( } } else { // exp < 0 means the leading is always 0 as errol result is normalized. - var num_digits_whole = if (float_decimal.exp > 0) @as(usize, @intCast(float_decimal.exp)) else 0; + const num_digits_whole = if (float_decimal.exp > 0) @as(usize, @intCast(float_decimal.exp)) else 0; // the actual slice into the buffer, we may need to zero-pad between num_digits_whole and this. - var num_digits_whole_no_pad = @min(num_digits_whole, float_decimal.digits.len); + const num_digits_whole_no_pad = @min(num_digits_whole, float_decimal.digits.len); if (num_digits_whole > 0) { // We may have to zero pad, for instance 1e4 requires zero padding. @@ -2218,6 +2218,7 @@ test "slice" { } { var runtime_zero: usize = 0; + _ = &runtime_zero; const value = @as([*]align(1) const []const u8, @ptrFromInt(0xdeadbeef))[runtime_zero..runtime_zero]; try expectFmt("slice: []const u8@deadbeef\n", "slice: {*}\n", .{value}); } @@ -2232,6 +2233,7 @@ test "slice" { { var int_slice = [_]u32{ 1, 4096, 391891, 1111111111 }; var runtime_zero: usize = 0; + _ = &runtime_zero; try expectFmt("int: { 1, 4096, 391891, 1111111111 }", "int: {any}", .{int_slice[runtime_zero..]}); try expectFmt("int: { 1, 4096, 391891, 1111111111 }", "int: {d}", .{int_slice[runtime_zero..]}); try expectFmt("int: { 1, 1000, 5fad3, 423a35c7 }", "int: {x}", .{int_slice[runtime_zero..]}); @@ -2794,14 +2796,14 @@ test "padding" { } test "decimal float padding" { - var number: f32 = 3.1415; + const number: f32 = 3.1415; try expectFmt("left-pad: **3.141\n", "left-pad: {d:*>7.3}\n", .{number}); try expectFmt("center-pad: *3.141*\n", "center-pad: {d:*^7.3}\n", .{number}); try expectFmt("right-pad: 3.141**\n", "right-pad: {d:*<7.3}\n", .{number}); } test "sci float padding" { - var number: f32 = 3.1415; + const number: f32 = 3.1415; try expectFmt("left-pad: **3.141e+00\n", "left-pad: {e:*>11.3}\n", .{number}); try expectFmt("center-pad: *3.141e+00*\n", "center-pad: {e:*^11.3}\n", .{number}); try expectFmt("right-pad: 3.141e+00**\n", "right-pad: {e:*<11.3}\n", .{number}); @@ -2825,7 +2827,7 @@ test "named arguments" { } test "runtime width specifier" { - var width: usize = 9; + const width: usize = 9; try expectFmt("~~hello~~", "{s:~^[1]}", .{ "hello", width }); try expectFmt("~~hello~~", "{s:~^[width]}", .{ .string = "hello", .width = width }); try expectFmt(" hello", "{s:[1]}", .{ "hello", width }); @@ -2833,8 +2835,8 @@ test "runtime width specifier" { } test "runtime precision specifier" { - var number: f32 = 3.1415; - var precision: usize = 2; + const number: f32 = 3.1415; + const precision: usize = 2; try expectFmt("3.14e+00", "{:1.[1]}", .{ number, precision }); try expectFmt("3.14e+00", "{:1.[precision]}", .{ .number = number, .precision = precision }); } diff --git a/lib/std/fmt/errol.zig b/lib/std/fmt/errol.zig index af686d6448..760ebca786 100644 --- a/lib/std/fmt/errol.zig +++ b/lib/std/fmt/errol.zig @@ -367,8 +367,8 @@ fn errolFixed(val: f64, buffer: []u8) FloatDecimal { var lo = ((fpprev(val) - n) + mid) / 2.0; var hi = ((fpnext(val) - n) + mid) / 2.0; - var buf_index = u64toa(u, buffer); - var exp = @as(i32, @intCast(buf_index)); + const buf_index = u64toa(u, buffer); + const exp: i32 = @intCast(buf_index); var j = buf_index; buffer[j] = 0; diff --git a/lib/std/fmt/parse_float/parse.zig b/lib/std/fmt/parse_float/parse.zig index a31df31312..841119aa02 100644 --- a/lib/std/fmt/parse_float/parse.zig +++ b/lib/std/fmt/parse_float/parse.zig @@ -105,7 +105,7 @@ fn parsePartialNumberBase(comptime T: type, stream: *FloatStream, negative: bool // parse initial digits before dot var mantissa: MantissaT = 0; tryParseDigits(MantissaT, stream, &mantissa, info.base); - var int_end = stream.offsetTrue(); + const int_end = stream.offsetTrue(); var n_digits = @as(isize, @intCast(stream.offsetTrue())); // the base being 16 implies a 0x prefix, which shouldn't be included in the digit count if (info.base == 16) n_digits -= 2; @@ -188,7 +188,7 @@ fn parsePartialNumberBase(comptime T: type, stream: *FloatStream, negative: bool // than 19 digits. That means we must have a decimal // point, and at least 1 fractional digit. stream.advance(1); - var marker = stream.offsetTrue(); + const marker = stream.offsetTrue(); tryParseNDigits(MantissaT, stream, &mantissa, info.base, info.max_mantissa_digits); break :blk @as(i64, @intCast(marker)) - @as(i64, @intCast(stream.offsetTrue())); } diff --git a/lib/std/fs.zig b/lib/std/fs.zig index 6cda6716b7..fd8116edaa 100644 --- a/lib/std/fs.zig +++ b/lib/std/fs.zig @@ -1689,7 +1689,7 @@ pub const Dir = struct { } if (builtin.os.tag == .windows) { var dir_path_buffer: [os.windows.PATH_MAX_WIDE]u16 = undefined; - var dir_path = try os.windows.GetFinalPathNameByHandle(self.fd, .{}, &dir_path_buffer); + const dir_path = try os.windows.GetFinalPathNameByHandle(self.fd, .{}, &dir_path_buffer); if (builtin.link_libc) { return os.chdirW(dir_path); } @@ -1810,7 +1810,7 @@ pub const Dir = struct { const base_flags = w.STANDARD_RIGHTS_READ | w.FILE_READ_ATTRIBUTES | w.FILE_READ_EA | w.SYNCHRONIZE | w.FILE_TRAVERSE; const flags: u32 = if (iterable) base_flags | w.FILE_LIST_DIRECTORY else base_flags; - var dir = try self.makeOpenDirAccessMaskW(sub_path_w, flags, .{ + const dir = try self.makeOpenDirAccessMaskW(sub_path_w, flags, .{ .no_follow = args.no_follow, .create_disposition = w.FILE_OPEN, }); diff --git a/lib/std/fs/get_app_data_dir.zig b/lib/std/fs/get_app_data_dir.zig index ae203e5260..904cea5e7f 100644 --- a/lib/std/fs/get_app_data_dir.zig +++ b/lib/std/fs/get_app_data_dir.zig @@ -57,6 +57,10 @@ pub fn getAppDataDir(allocator: mem.Allocator, appname: []const u8) GetAppDataDi }, .haiku => { var dir_path_ptr: [*:0]u8 = undefined; + if (true) { + _ = &dir_path_ptr; + @compileError("TODO: init dir_path_ptr"); + } // TODO look into directory_which const be_user_settings = 0xbbe; const rc = os.system.find_directory(be_user_settings, -1, true, dir_path_ptr, 1); diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig index 9a11c7cb29..6786aec4b0 100644 --- a/lib/std/fs/test.zig +++ b/lib/std/fs/test.zig @@ -80,7 +80,7 @@ const TestContext = struct { transform_fn: *const PathType.TransformFn, pub fn init(path_type: PathType, allocator: mem.Allocator, transform_fn: *const PathType.TransformFn) TestContext { - var tmp = tmpIterableDir(.{}); + const tmp = tmpIterableDir(.{}); return .{ .path_type = path_type, .arena = ArenaAllocator.init(allocator), diff --git a/lib/std/fs/watch.zig b/lib/std/fs/watch.zig index 280c8888e6..e6485093ca 100644 --- a/lib/std/fs/watch.zig +++ b/lib/std/fs/watch.zig @@ -116,7 +116,7 @@ pub fn Watch(comptime V: type) type { }, }; - var buf = try allocator.alloc(Event.Error!Event, event_buf_count); + const buf = try allocator.alloc(Event.Error!Event, event_buf_count); self.channel.init(buf); self.os_data.putter_frame = async self.linuxEventPutter(); return self; @@ -132,7 +132,7 @@ pub fn Watch(comptime V: type) type { }, }; - var buf = try allocator.alloc(Event.Error!Event, event_buf_count); + const buf = try allocator.alloc(Event.Error!Event, event_buf_count); self.channel.init(buf); return self; }, @@ -147,7 +147,7 @@ pub fn Watch(comptime V: type) type { }, }; - var buf = try allocator.alloc(Event.Error!Event, event_buf_count); + const buf = try allocator.alloc(Event.Error!Event, event_buf_count); self.channel.init(buf); return self; }, diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig index c5c6c585eb..78e2cab104 100644 --- a/lib/std/hash/auto_hash.zig +++ b/lib/std/hash/auto_hash.zig @@ -280,6 +280,7 @@ test "hash slice shallow" { const array2 = [_]u32{ 1, 2, 3, 4, 5, 6 }; // TODO audit deep/shallow - maybe it has the wrong behavior with respect to array pointers and slices var runtime_zero: usize = 0; + _ = &runtime_zero; const a = array1[runtime_zero..]; const b = array2[runtime_zero..]; const c = array1[runtime_zero..3]; diff --git a/lib/std/hash/cityhash.zig b/lib/std/hash/cityhash.zig index cd240da964..781949321d 100644 --- a/lib/std/hash/cityhash.zig +++ b/lib/std/hash/cityhash.zig @@ -271,7 +271,7 @@ pub const CityHash64 = struct { var b1: u64 = b; a1 +%= w; b1 = rotr64(b1 +% a1 +% z, 21); - var c: u64 = a1; + const c: u64 = a1; a1 +%= x; a1 +%= y; b1 +%= rotr64(a1, 44); diff --git a/lib/std/hash/murmur.zig b/lib/std/hash/murmur.zig index a9299f245d..65a52f6b56 100644 --- a/lib/std/hash/murmur.zig +++ b/lib/std/hash/murmur.zig @@ -134,7 +134,7 @@ pub const Murmur2_64 = struct { const m: u64 = 0xc6a4a7935bd1e995; const len: u64 = 4; var h1: u64 = seed ^ (len *% m); - var k1: u64 = v; + const k1: u64 = v; h1 ^= k1; h1 *%= m; h1 ^= h1 >> 47; @@ -282,16 +282,14 @@ pub const Murmur3_32 = struct { const verify = @import("verify.zig"); test "murmur2_32" { - var v0: u32 = 0x12345678; - var v1: u64 = 0x1234567812345678; - var v0le: u32 = v0; - var v1le: u64 = v1; - if (native_endian == .big) { - v0le = @byteSwap(v0le); - v1le = @byteSwap(v1le); - } - try testing.expectEqual(Murmur2_32.hash(@as([*]u8, @ptrCast(&v0le))[0..4]), Murmur2_32.hashUint32(v0)); - try testing.expectEqual(Murmur2_32.hash(@as([*]u8, @ptrCast(&v1le))[0..8]), Murmur2_32.hashUint64(v1)); + const v0: u32 = 0x12345678; + const v1: u64 = 0x1234567812345678; + const v0le: u32, const v1le: u64 = switch (native_endian) { + .little => .{ v0, v1 }, + .big => .{ @byteSwap(v0), @byteSwap(v1) }, + }; + try testing.expectEqual(Murmur2_32.hash(@as([*]const u8, @ptrCast(&v0le))[0..4]), Murmur2_32.hashUint32(v0)); + try testing.expectEqual(Murmur2_32.hash(@as([*]const u8, @ptrCast(&v1le))[0..8]), Murmur2_32.hashUint64(v1)); } test "murmur2_32 smhasher" { @@ -306,16 +304,14 @@ test "murmur2_32 smhasher" { } test "murmur2_64" { - var v0: u32 = 0x12345678; - var v1: u64 = 0x1234567812345678; - var v0le: u32 = v0; - var v1le: u64 = v1; - if (native_endian == .big) { - v0le = @byteSwap(v0le); - v1le = @byteSwap(v1le); - } - try testing.expectEqual(Murmur2_64.hash(@as([*]u8, @ptrCast(&v0le))[0..4]), Murmur2_64.hashUint32(v0)); - try testing.expectEqual(Murmur2_64.hash(@as([*]u8, @ptrCast(&v1le))[0..8]), Murmur2_64.hashUint64(v1)); + const v0: u32 = 0x12345678; + const v1: u64 = 0x1234567812345678; + const v0le: u32, const v1le: u64 = switch (native_endian) { + .little => .{ v0, v1 }, + .big => .{ @byteSwap(v0), @byteSwap(v1) }, + }; + try testing.expectEqual(Murmur2_64.hash(@as([*]const u8, @ptrCast(&v0le))[0..4]), Murmur2_64.hashUint32(v0)); + try testing.expectEqual(Murmur2_64.hash(@as([*]const u8, @ptrCast(&v1le))[0..8]), Murmur2_64.hashUint64(v1)); } test "mumur2_64 smhasher" { @@ -330,16 +326,14 @@ test "mumur2_64 smhasher" { } test "murmur3_32" { - var v0: u32 = 0x12345678; - var v1: u64 = 0x1234567812345678; - var v0le: u32 = v0; - var v1le: u64 = v1; - if (native_endian == .big) { - v0le = @byteSwap(v0le); - v1le = @byteSwap(v1le); - } - try testing.expectEqual(Murmur3_32.hash(@as([*]u8, @ptrCast(&v0le))[0..4]), Murmur3_32.hashUint32(v0)); - try testing.expectEqual(Murmur3_32.hash(@as([*]u8, @ptrCast(&v1le))[0..8]), Murmur3_32.hashUint64(v1)); + const v0: u32 = 0x12345678; + const v1: u64 = 0x1234567812345678; + const v0le: u32, const v1le: u64 = switch (native_endian) { + .little => .{ v0, v1 }, + .big => .{ @byteSwap(v0), @byteSwap(v1) }, + }; + try testing.expectEqual(Murmur3_32.hash(@as([*]const u8, @ptrCast(&v0le))[0..4]), Murmur3_32.hashUint32(v0)); + try testing.expectEqual(Murmur3_32.hash(@as([*]const u8, @ptrCast(&v1le))[0..8]), Murmur3_32.hashUint64(v1)); } test "mumur3_32 smhasher" { diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig index 40a412bf3c..2353c8962e 100644 --- a/lib/std/hash_map.zig +++ b/lib/std/hash_map.zig @@ -1484,8 +1484,8 @@ pub fn HashMapUnmanaged( var i: Size = 0; var metadata = self.metadata.?; - var keys_ptr = self.keys(); - var values_ptr = self.values(); + const keys_ptr = self.keys(); + const values_ptr = self.values(); while (i < self.capacity()) : (i += 1) { if (metadata[i].isUsed()) { other.putAssumeCapacityNoClobberContext(keys_ptr[i], values_ptr[i], new_ctx); @@ -1521,8 +1521,8 @@ pub fn HashMapUnmanaged( const old_capacity = self.capacity(); var i: Size = 0; var metadata = self.metadata.?; - var keys_ptr = self.keys(); - var values_ptr = self.values(); + const keys_ptr = self.keys(); + const values_ptr = self.values(); while (i < old_capacity) : (i += 1) { if (metadata[i].isUsed()) { map.putAssumeCapacityNoClobberContext(keys_ptr[i], values_ptr[i], ctx); diff --git a/lib/std/heap.zig b/lib/std/heap.zig index 0c61242e56..ec8679f6b2 100644 --- a/lib/std/heap.zig +++ b/lib/std/heap.zig @@ -81,10 +81,10 @@ const CAllocator = struct { // Thin wrapper around regular malloc, overallocate to account for // alignment padding and store the original malloc()'ed pointer before // the aligned address. - var unaligned_ptr = @as([*]u8, @ptrCast(c.malloc(len + alignment - 1 + @sizeOf(usize)) orelse return null)); + const unaligned_ptr = @as([*]u8, @ptrCast(c.malloc(len + alignment - 1 + @sizeOf(usize)) orelse return null)); const unaligned_addr = @intFromPtr(unaligned_ptr); const aligned_addr = mem.alignForward(usize, unaligned_addr + @sizeOf(usize), alignment); - var aligned_ptr = unaligned_ptr + (aligned_addr - unaligned_addr); + const aligned_ptr = unaligned_ptr + (aligned_addr - unaligned_addr); getHeader(aligned_ptr).* = unaligned_ptr; return aligned_ptr; @@ -661,12 +661,12 @@ test "FixedBufferAllocator.reset" { const X = 0xeeeeeeeeeeeeeeee; const Y = 0xffffffffffffffff; - var x = try allocator.create(u64); + const x = try allocator.create(u64); x.* = X; try testing.expectError(error.OutOfMemory, allocator.create(u64)); fba.reset(); - var y = try allocator.create(u64); + const y = try allocator.create(u64); y.* = Y; // we expect Y to have overwritten X. @@ -691,9 +691,9 @@ test "FixedBufferAllocator Reuse memory on realloc" { var fixed_buffer_allocator = FixedBufferAllocator.init(small_fixed_buffer[0..]); const allocator = fixed_buffer_allocator.allocator(); - var slice0 = try allocator.alloc(u8, 5); + const slice0 = try allocator.alloc(u8, 5); try testing.expect(slice0.len == 5); - var slice1 = try allocator.realloc(slice0, 10); + const slice1 = try allocator.realloc(slice0, 10); try testing.expect(slice1.ptr == slice0.ptr); try testing.expect(slice1.len == 10); try testing.expectError(error.OutOfMemory, allocator.realloc(slice1, 11)); @@ -706,8 +706,8 @@ test "FixedBufferAllocator Reuse memory on realloc" { var slice0 = try allocator.alloc(u8, 2); slice0[0] = 1; slice0[1] = 2; - var slice1 = try allocator.alloc(u8, 2); - var slice2 = try allocator.realloc(slice0, 4); + const slice1 = try allocator.alloc(u8, 2); + const slice2 = try allocator.realloc(slice0, 4); try testing.expect(slice0.ptr != slice2.ptr); try testing.expect(slice1.ptr != slice2.ptr); try testing.expect(slice2[0] == 1); @@ -757,7 +757,7 @@ pub fn testAllocator(base_allocator: mem.Allocator) !void { allocator.free(slice); // Zero-length allocation - var empty = try allocator.alloc(u8, 0); + const empty = try allocator.alloc(u8, 0); allocator.free(empty); // Allocation with zero-sized types const zero_bit_ptr = try allocator.create(u0); diff --git a/lib/std/heap/arena_allocator.zig b/lib/std/heap/arena_allocator.zig index 69a99eccd3..09f2e609f4 100644 --- a/lib/std/heap/arena_allocator.zig +++ b/lib/std/heap/arena_allocator.zig @@ -257,7 +257,7 @@ test "ArenaAllocator (reset with preheating)" { rounds -= 1; _ = arena_allocator.reset(.retain_capacity); var alloced_bytes: usize = 0; - var total_size: usize = random.intRangeAtMost(usize, 256, 16384); + const total_size: usize = random.intRangeAtMost(usize, 256, 16384); while (alloced_bytes < total_size) { const size = random.intRangeAtMost(usize, 16, 256); const alignment = 32; diff --git a/lib/std/heap/general_purpose_allocator.zig b/lib/std/heap/general_purpose_allocator.zig index 6dc6df3998..b79d73f0e9 100644 --- a/lib/std/heap/general_purpose_allocator.zig +++ b/lib/std/heap/general_purpose_allocator.zig @@ -512,7 +512,7 @@ pub fn GeneralPurposeAllocator(comptime config: Config) type { var buckets = &self.buckets[bucket_index]; const slot_count = @divExact(page_size, size_class); if (self.cur_buckets[bucket_index] == null or self.cur_buckets[bucket_index].?.alloc_cursor == slot_count) { - var new_bucket = try self.createBucket(size_class); + const new_bucket = try self.createBucket(size_class); errdefer self.freeBucket(new_bucket, size_class); const node = try self.bucket_node_pool.create(); node.key = new_bucket; @@ -526,7 +526,7 @@ pub fn GeneralPurposeAllocator(comptime config: Config) type { const slot_index = bucket.alloc_cursor; bucket.alloc_cursor += 1; - var used_bits_byte = bucket.usedBits(slot_index / 8); + const used_bits_byte = bucket.usedBits(slot_index / 8); const used_bit_index: u3 = @as(u3, @intCast(slot_index % 8)); // TODO cast should be unnecessary used_bits_byte.* |= (@as(u8, 1) << used_bit_index); bucket.used_count += 1; @@ -915,7 +915,7 @@ pub fn GeneralPurposeAllocator(comptime config: Config) type { if (bucket.used_count == 0) { var entry = self.buckets[bucket_index].getEntryFor(bucket); // save the node for destruction/insertion into in empty_buckets - var node = entry.node.?; + const node = entry.node.?; entry.set(null); if (self.cur_buckets[bucket_index] == bucket) { self.cur_buckets[bucket_index] = null; diff --git a/lib/std/heap/memory_pool.zig b/lib/std/heap/memory_pool.zig index 722bdd8f3e..af86adacc1 100644 --- a/lib/std/heap/memory_pool.zig +++ b/lib/std/heap/memory_pool.zig @@ -172,7 +172,7 @@ test "memory pool: preheating (success)" { } test "memory pool: preheating (failure)" { - var failer = std.testing.failing_allocator; + const failer = std.testing.failing_allocator; try std.testing.expectError(error.OutOfMemory, MemoryPool(u32).initPreheated(failer, 5)); } diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig index eb9896d40a..9b66975a09 100644 --- a/lib/std/http/Client.zig +++ b/lib/std/http/Client.zig @@ -144,7 +144,7 @@ pub const ConnectionPool = struct { pool.mutex.lock(); defer pool.mutex.unlock(); - var next = pool.free.first; + const next = pool.free.first; _ = next; while (pool.free_len > new_size) { const popped = pool.free.popFirst() orelse unreachable; diff --git a/lib/std/http/protocol.zig b/lib/std/http/protocol.zig index 4fe9c80380..e757095803 100644 --- a/lib/std/http/protocol.zig +++ b/lib/std/http/protocol.zig @@ -765,10 +765,9 @@ test "HeadersParser.read length" { var r = HeadersParser.initDynamic(256); defer r.header_bytes.deinit(std.testing.allocator); const data = "GET / HTTP/1.1\r\nHost: localhost\r\nContent-Length: 5\r\n\r\nHello"; - var fbs = std.io.fixedBufferStream(data); - var conn = MockBufferedConnection{ - .conn = fbs, + var conn: MockBufferedConnection = .{ + .conn = std.io.fixedBufferStream(data), }; while (true) { // read headers @@ -796,10 +795,9 @@ test "HeadersParser.read chunked" { var r = HeadersParser.initDynamic(256); defer r.header_bytes.deinit(std.testing.allocator); const data = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n2\r\nHe\r\n2\r\nll\r\n1\r\no\r\n0\r\n\r\n"; - var fbs = std.io.fixedBufferStream(data); - var conn = MockBufferedConnection{ - .conn = fbs, + var conn: MockBufferedConnection = .{ + .conn = std.io.fixedBufferStream(data), }; while (true) { // read headers @@ -826,10 +824,9 @@ test "HeadersParser.read chunked trailer" { var r = HeadersParser.initDynamic(256); defer r.header_bytes.deinit(std.testing.allocator); const data = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n2\r\nHe\r\n2\r\nll\r\n1\r\no\r\n0\r\nContent-Type: text/plain\r\n\r\n"; - var fbs = std.io.fixedBufferStream(data); - var conn = MockBufferedConnection{ - .conn = fbs, + var conn: MockBufferedConnection = .{ + .conn = std.io.fixedBufferStream(data), }; while (true) { // read headers diff --git a/lib/std/io/Reader/test.zig b/lib/std/io/Reader/test.zig index 42fce98457..166a94fbcf 100644 --- a/lib/std/io/Reader/test.zig +++ b/lib/std/io/Reader/test.zig @@ -91,13 +91,13 @@ test "Reader.readUntilDelimiterAlloc returns ArrayLists with bytes read until th const reader = fis.reader(); { - var result = try reader.readUntilDelimiterAlloc(a, '\n', 5); + const result = try reader.readUntilDelimiterAlloc(a, '\n', 5); defer a.free(result); try std.testing.expectEqualStrings("0000", result); } { - var result = try reader.readUntilDelimiterAlloc(a, '\n', 5); + const result = try reader.readUntilDelimiterAlloc(a, '\n', 5); defer a.free(result); try std.testing.expectEqualStrings("1234", result); } @@ -112,7 +112,7 @@ test "Reader.readUntilDelimiterAlloc returns an empty ArrayList" { const reader = fis.reader(); { - var result = try reader.readUntilDelimiterAlloc(a, '\n', 5); + const result = try reader.readUntilDelimiterAlloc(a, '\n', 5); defer a.free(result); try std.testing.expectEqualStrings("", result); } @@ -126,7 +126,7 @@ test "Reader.readUntilDelimiterAlloc returns StreamTooLong, then an ArrayList wi try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterAlloc(a, '\n', 5)); - var result = try reader.readUntilDelimiterAlloc(a, '\n', 5); + const result = try reader.readUntilDelimiterAlloc(a, '\n', 5); defer a.free(result); try std.testing.expectEqualStrings("67", result); } @@ -219,13 +219,13 @@ test "Reader.readUntilDelimiterOrEofAlloc returns ArrayLists with bytes read unt const reader = fis.reader(); { - var result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?; + const result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?; defer a.free(result); try std.testing.expectEqualStrings("0000", result); } { - var result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?; + const result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?; defer a.free(result); try std.testing.expectEqualStrings("1234", result); } @@ -240,7 +240,7 @@ test "Reader.readUntilDelimiterOrEofAlloc returns an empty ArrayList" { const reader = fis.reader(); { - var result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?; + const result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?; defer a.free(result); try std.testing.expectEqualStrings("", result); } @@ -254,7 +254,7 @@ test "Reader.readUntilDelimiterOrEofAlloc returns StreamTooLong, then an ArrayLi try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)); - var result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?; + const result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?; defer a.free(result); try std.testing.expectEqualStrings("67", result); } diff --git a/lib/std/io/buffered_reader.zig b/lib/std/io/buffered_reader.zig index efc1d78cc4..40a81e3956 100644 --- a/lib/std/io/buffered_reader.zig +++ b/lib/std/io/buffered_reader.zig @@ -131,8 +131,9 @@ test "io.BufferedReader Block" { // len out == block { - var block_reader = BlockReader.init(block, 2); - var test_buf_reader = BufferedReader(4, BlockReader){ .unbuffered_reader = block_reader }; + var test_buf_reader: BufferedReader(4, BlockReader) = .{ + .unbuffered_reader = BlockReader.init(block, 2), + }; var out_buf: [4]u8 = undefined; _ = try test_buf_reader.read(&out_buf); try testing.expectEqualSlices(u8, &out_buf, block); @@ -143,8 +144,9 @@ test "io.BufferedReader Block" { // len out < block { - var block_reader = BlockReader.init(block, 2); - var test_buf_reader = BufferedReader(4, BlockReader){ .unbuffered_reader = block_reader }; + var test_buf_reader: BufferedReader(4, BlockReader) = .{ + .unbuffered_reader = BlockReader.init(block, 2), + }; var out_buf: [3]u8 = undefined; _ = try test_buf_reader.read(&out_buf); try testing.expectEqualSlices(u8, &out_buf, "012"); @@ -157,8 +159,9 @@ test "io.BufferedReader Block" { // len out > block { - var block_reader = BlockReader.init(block, 2); - var test_buf_reader = BufferedReader(4, BlockReader){ .unbuffered_reader = block_reader }; + var test_buf_reader: BufferedReader(4, BlockReader) = .{ + .unbuffered_reader = BlockReader.init(block, 2), + }; var out_buf: [5]u8 = undefined; _ = try test_buf_reader.read(&out_buf); try testing.expectEqualSlices(u8, &out_buf, "01230"); @@ -169,8 +172,9 @@ test "io.BufferedReader Block" { // len out == 0 { - var block_reader = BlockReader.init(block, 2); - var test_buf_reader = BufferedReader(4, BlockReader){ .unbuffered_reader = block_reader }; + var test_buf_reader: BufferedReader(4, BlockReader) = .{ + .unbuffered_reader = BlockReader.init(block, 2), + }; var out_buf: [0]u8 = undefined; _ = try test_buf_reader.read(&out_buf); try testing.expectEqualSlices(u8, &out_buf, ""); @@ -178,8 +182,9 @@ test "io.BufferedReader Block" { // len bufreader buf > block { - var block_reader = BlockReader.init(block, 2); - var test_buf_reader = BufferedReader(5, BlockReader){ .unbuffered_reader = block_reader }; + var test_buf_reader: BufferedReader(5, BlockReader) = .{ + .unbuffered_reader = BlockReader.init(block, 2), + }; var out_buf: [4]u8 = undefined; _ = try test_buf_reader.read(&out_buf); try testing.expectEqualSlices(u8, &out_buf, block); diff --git a/lib/std/io/test.zig b/lib/std/io/test.zig index 6de0fe1e53..c02446e53f 100644 --- a/lib/std/io/test.zig +++ b/lib/std/io/test.zig @@ -167,13 +167,13 @@ test "updateTimes" { file.close(); tmp.dir.deleteFile(tmp_file_name) catch {}; } - var stat_old = try file.stat(); + const stat_old = try file.stat(); // Set atime and mtime to 5s before try file.updateTimes( stat_old.atime - 5 * std.time.ns_per_s, stat_old.mtime - 5 * std.time.ns_per_s, ); - var stat_new = try file.stat(); + const stat_new = try file.stat(); try expect(stat_new.atime < stat_old.atime); try expect(stat_new.mtime < stat_old.mtime); } diff --git a/lib/std/json/dynamic_test.zig b/lib/std/json/dynamic_test.zig index 326c00e9b6..1e9f35eaf9 100644 --- a/lib/std/json/dynamic_test.zig +++ b/lib/std/json/dynamic_test.zig @@ -190,15 +190,15 @@ test "Value.jsonStringify" { var obj = ObjectMap.init(testing.allocator); defer obj.deinit(); try obj.putNoClobber("a", .{ .string = "b" }); - var array = [_]Value{ - Value.null, - Value{ .bool = true }, - Value{ .integer = 42 }, - Value{ .number_string = "43" }, - Value{ .float = 42 }, - Value{ .string = "weeee" }, - Value{ .array = Array.fromOwnedSlice(undefined, &vals) }, - Value{ .object = obj }, + const array = [_]Value{ + .null, + .{ .bool = true }, + .{ .integer = 42 }, + .{ .number_string = "43" }, + .{ .float = 42 }, + .{ .string = "weeee" }, + .{ .array = Array.fromOwnedSlice(undefined, &vals) }, + .{ .object = obj }, }; var buffer: [0x1000]u8 = undefined; var fbs = std.io.fixedBufferStream(&buffer); diff --git a/lib/std/json/static_test.zig b/lib/std/json/static_test.zig index 82b0d89044..e3d296584c 100644 --- a/lib/std/json/static_test.zig +++ b/lib/std/json/static_test.zig @@ -533,7 +533,7 @@ test "parse into struct with misc fields" { string: []const u8, }; }; - var document_str = + const document_str = \\{ \\ "int": 420, \\ "float": 3.14, @@ -588,7 +588,7 @@ test "parse into struct with strings and arrays with sentinels" { data: [:99]const i32, simple_data: []const i32, }; - var document_str = + const document_str = \\{ \\ "language": "zig", \\ "language_without_sentinel": "zig again!", @@ -634,7 +634,7 @@ test "parse into struct ignoring unknown fields" { language: []const u8, }; - var str = + const str = \\{ \\ "int": 420, \\ "float": 3.14, @@ -685,7 +685,7 @@ test "parse into tuple" { std.meta.Tuple(&.{ u8, []const u8, u8 }), Union, }); - var str = + const str = \\[ \\ 420, \\ 3.14, @@ -789,7 +789,7 @@ test "parse into vector" { vec_i32: @Vector(4, i32), vec_f32: @Vector(2, f32), }; - var s = + const s = \\{ \\ "vec_f32": [1.5, 2.5], \\ "vec_i32": [4, 5, 6, 7] @@ -821,7 +821,7 @@ test "json parse partial" { num: u32, yes: bool, }; - var str = + const str = \\{ \\ "outer": { \\ "key1": { @@ -835,7 +835,7 @@ test "json parse partial" { \\ } \\} ; - var allocator = testing.allocator; + const allocator = testing.allocator; var scanner = JsonScanner.initCompleteInput(allocator, str); defer scanner.deinit(); @@ -876,13 +876,13 @@ test "json parse allocate when streaming" { not_const: []u8, is_const: []const u8, }; - var str = + const str = \\{ \\ "not_const": "non const string", \\ "is_const": "const string" \\} ; - var allocator = testing.allocator; + const allocator = testing.allocator; var arena = ArenaAllocator.init(allocator); defer arena.deinit(); diff --git a/lib/std/math.zig b/lib/std/math.zig index 57471e2b03..1710cdc948 100644 --- a/lib/std/math.zig +++ b/lib/std/math.zig @@ -427,6 +427,7 @@ test "clamp" { // Mix of comptime and non-comptime var i: i32 = 1; + _ = &i; try testing.expect(std.math.clamp(i, 0, 1) == 1); } @@ -1113,7 +1114,7 @@ pub fn ceilPowerOfTwo(comptime T: type, value: T) (error{Overflow}!T) { comptime assert(info.signedness == .unsigned); const PromotedType = std.meta.Int(info.signedness, info.bits + 1); const overflowBit = @as(PromotedType, 1) << info.bits; - var x = ceilPowerOfTwoPromote(T, value); + const x = ceilPowerOfTwoPromote(T, value); if (overflowBit & x != 0) { return error.Overflow; } diff --git a/lib/std/math/atan.zig b/lib/std/math/atan.zig index bf85bdab7e..0e7a86df60 100644 --- a/lib/std/math/atan.zig +++ b/lib/std/math/atan.zig @@ -143,8 +143,8 @@ fn atan64(x_: f64) f64 { }; var x = x_; - var ux = @as(u64, @bitCast(x)); - var ix = @as(u32, @intCast(ux >> 32)); + const ux: u64 = @bitCast(x); + var ix: u32 = @intCast(ux >> 32); const sign = ix >> 31; ix &= 0x7FFFFFFF; diff --git a/lib/std/math/atan2.zig b/lib/std/math/atan2.zig index b3ed7b7bca..93b1b88f32 100644 --- a/lib/std/math/atan2.zig +++ b/lib/std/math/atan2.zig @@ -104,7 +104,7 @@ fn atan2_32(y: f32, x: f32) f32 { } // z = atan(|y / x|) with correct underflow - var z = z: { + const z = z: { if ((m & 2) != 0 and iy + (26 << 23) < ix) { break :z 0.0; } else { @@ -129,13 +129,13 @@ fn atan2_64(y: f64, x: f64) f64 { return x + y; } - var ux = @as(u64, @bitCast(x)); - var ix = @as(u32, @intCast(ux >> 32)); - var lx = @as(u32, @intCast(ux & 0xFFFFFFFF)); + const ux: u64 = @bitCast(x); + var ix: u32 = @intCast(ux >> 32); + const lx: u32 = @intCast(ux & 0xFFFFFFFF); - var uy = @as(u64, @bitCast(y)); - var iy = @as(u32, @intCast(uy >> 32)); - var ly = @as(u32, @intCast(uy & 0xFFFFFFFF)); + const uy: u64 = @bitCast(y); + var iy: u32 = @intCast(uy >> 32); + const ly: u32 = @intCast(uy & 0xFFFFFFFF); // x = 1.0 if ((ix -% 0x3FF00000) | lx == 0) { @@ -194,7 +194,7 @@ fn atan2_64(y: f64, x: f64) f64 { } // z = atan(|y / x|) with correct underflow - var z = z: { + const z = z: { if ((m & 2) != 0 and iy +% (64 << 20) < ix) { break :z 0.0; } else { diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig index 346da746d0..f02ef18246 100644 --- a/lib/std/math/big/int.zig +++ b/lib/std/math/big/int.zig @@ -797,7 +797,7 @@ pub const Mutable = struct { // 0b0..01..1000 with @log2(@sizeOf(Limb)) consecutive ones const endian_mask: usize = (@sizeOf(Limb) - 1) << 3; - var bytes = std.mem.sliceAsBytes(r.limbs); + const bytes = std.mem.sliceAsBytes(r.limbs); var bits = std.packed_int_array.PackedIntSliceEndian(u1, .little).init(bytes, limbs_required * @bitSizeOf(Limb)); var k: usize = 0; @@ -1407,7 +1407,7 @@ pub const Mutable = struct { } // Avoid copying u to s by swapping u and s - var tmp_s = s; + const tmp_s = s; s = u; u = tmp_s; } @@ -1911,7 +1911,7 @@ pub const Mutable = struct { var positive = true; if (signedness == .signed) { const total_bits = bit_offset + bit_count; - var last_byte = switch (endian) { + const last_byte = switch (endian) { .little => ((total_bits + 7) / 8) - 1, .big => buffer.len - ((total_bits + 7) / 8), }; @@ -3161,7 +3161,7 @@ pub const Managed = struct { /// r = a ^ b pub fn bitXor(r: *Managed, a: *const Managed, b: *const Managed) !void { - var cap = @max(a.len(), b.len()) + @intFromBool(a.isPositive() != b.isPositive()); + const cap = @max(a.len(), b.len()) + @intFromBool(a.isPositive() != b.isPositive()); try r.ensureCapacity(cap); var m = r.toMutable(); @@ -4178,7 +4178,7 @@ fn llpow(r: []Limb, a: []const Limb, b: u32, tmp_limbs: []Limb) void { // most significant bit set. // Square the result if the current bit is zero, square and multiply by a if // it is one. - var exp_bits = 32 - 1 - b_leading_zeros; + const exp_bits = 32 - 1 - b_leading_zeros; var exp = b << @as(u5, @intCast(1 + b_leading_zeros)); var i: usize = 0; diff --git a/lib/std/math/big/int_test.zig b/lib/std/math/big/int_test.zig index a925f2c4b2..e1f423e3c1 100644 --- a/lib/std/math/big/int_test.zig +++ b/lib/std/math/big/int_test.zig @@ -300,20 +300,18 @@ test "big.int twos complement limit set" { }; inline for (test_types) |T| { - // To work around 'control flow attempts to use compile-time variable at runtime' - const U = T; - const int_info = @typeInfo(U).Int; + const int_info = @typeInfo(T).Int; var a = try Managed.init(testing.allocator); defer a.deinit(); try a.setTwosCompIntLimit(.max, int_info.signedness, int_info.bits); - var max: U = maxInt(U); - try testing.expect(max == try a.to(U)); + const max: T = maxInt(T); + try testing.expect(max == try a.to(T)); try a.setTwosCompIntLimit(.min, int_info.signedness, int_info.bits); - var min: U = minInt(U); - try testing.expect(min == try a.to(U)); + const min: T = minInt(T); + try testing.expect(min == try a.to(T)); } } @@ -519,6 +517,9 @@ test "big.int add multi-single" { test "big.int add multi-multi" { var op1: u128 = 0xefefefef7f7f7f7f; var op2: u128 = 0xfefefefe9f9f9f9f; + // These must be runtime-known to prevent this comparison being tautological, as the + // compiler uses `std.math.big.int` internally to add these values at comptime. + _ = .{ &op1, &op2 }; var a = try Managed.initSet(testing.allocator, op1); defer a.deinit(); var b = try Managed.initSet(testing.allocator, op2); @@ -833,6 +834,7 @@ test "big.int sub multi-single" { test "big.int sub multi-multi" { var op1: u128 = 0xefefefefefefefefefefefef; var op2: u128 = 0xabababababababababababab; + _ = .{ &op1, &op2 }; var a = try Managed.initSet(testing.allocator, op1); defer a.deinit(); @@ -920,6 +922,8 @@ test "big.int mul multi-multi" { var op1: u256 = 0x998888efefefefefefefef; var op2: u256 = 0x333000abababababababab; + _ = .{ &op1, &op2 }; + var a = try Managed.initSet(testing.allocator, op1); defer a.deinit(); var b = try Managed.initSet(testing.allocator, op2); @@ -1042,6 +1046,8 @@ test "big.int mulWrap multi-multi unsigned" { var op1: u256 = 0x998888efefefefefefefef; var op2: u256 = 0x333000abababababababab; + _ = .{ &op1, &op2 }; + var a = try Managed.initSet(testing.allocator, op1); defer a.deinit(); var b = try Managed.initSet(testing.allocator, op2); @@ -1164,6 +1170,7 @@ test "big.int div single-single with rem" { test "big.int div multi-single no rem" { var op1: u128 = 0xffffeeeeddddcccc; var op2: u128 = 34; + _ = .{ &op1, &op2 }; var a = try Managed.initSet(testing.allocator, op1); defer a.deinit(); @@ -1183,6 +1190,7 @@ test "big.int div multi-single no rem" { test "big.int div multi-single with rem" { var op1: u128 = 0xffffeeeeddddcccf; var op2: u128 = 34; + _ = .{ &op1, &op2 }; var a = try Managed.initSet(testing.allocator, op1); defer a.deinit(); @@ -1202,6 +1210,7 @@ test "big.int div multi-single with rem" { test "big.int div multi>2-single" { var op1: u128 = 0xfefefefefefefefefefefefefefefefe; var op2: u128 = 0xefab8; + _ = .{ &op1, &op2 }; var a = try Managed.initSet(testing.allocator, op1); defer a.deinit(); @@ -2106,6 +2115,8 @@ test "big.int sat shift-left signed multi positive" { if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; var x: SignedDoubleLimb = 1; + _ = &x; + const shift = @bitSizeOf(SignedDoubleLimb) - 1; var a = try Managed.initSet(testing.allocator, x); @@ -2119,6 +2130,8 @@ test "big.int sat shift-left signed multi negative" { if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; var x: SignedDoubleLimb = -1; + _ = &x; + const shift = @bitSizeOf(SignedDoubleLimb) - 1; var a = try Managed.initSet(testing.allocator, x); @@ -2130,6 +2143,8 @@ test "big.int sat shift-left signed multi negative" { test "big.int bitNotWrap unsigned simple" { var x: u10 = 123; + _ = &x; + var a = try Managed.initSet(testing.allocator, x); defer a.deinit(); @@ -2149,6 +2164,8 @@ test "big.int bitNotWrap unsigned multi" { test "big.int bitNotWrap signed simple" { var x: i11 = -456; + _ = &x; + var a = try Managed.initSet(testing.allocator, -456); defer a.deinit(); @@ -2306,6 +2323,8 @@ test "big.int bitwise xor simple" { test "big.int bitwise xor multi-limb" { var x: DoubleLimb = maxInt(Limb) + 1; var y: DoubleLimb = maxInt(Limb); + _ = .{ &x, &y }; + var a = try Managed.initSet(testing.allocator, x); defer a.deinit(); var b = try Managed.initSet(testing.allocator, y); @@ -2548,7 +2567,7 @@ test "big.int gcd one large" { test "big.int mutable to managed" { const allocator = testing.allocator; - var limbs_buf = try allocator.alloc(Limb, 8); + const limbs_buf = try allocator.alloc(Limb, 8); defer allocator.free(limbs_buf); var a = Mutable.init(limbs_buf, 0xdeadbeef); @@ -2965,7 +2984,7 @@ test "big int conversion write twos complement zero" { // (2) should correctly interpret bytes based on the provided endianness // (3) should ignore any bits from bit_count to 8 * abi_size - var bit_count: usize = 12 * 8 + 1; + const bit_count: usize = 12 * 8 + 1; var buffer: []const u8 = undefined; buffer = &([_]u8{0} ** 13); diff --git a/lib/std/math/cbrt.zig b/lib/std/math/cbrt.zig index 22745ee4d5..db0273eda8 100644 --- a/lib/std/math/cbrt.zig +++ b/lib/std/math/cbrt.zig @@ -102,7 +102,7 @@ fn cbrt64(x: f64) f64 { // cbrt to 23 bits // cbrt(x) = t * cbrt(x / t^3) ~= t * P(t^3 / x) - var r = (t * t) * (t / x); + const r = (t * t) * (t / x); t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4)); // Round t away from 0 to 23 bits @@ -113,7 +113,7 @@ fn cbrt64(x: f64) f64 { // one step newton to 53 bits const s = t * t; var q = x / s; - var w = t + t; + const w = t + t; q = (q - t) / (w + q); return t + t * q; diff --git a/lib/std/math/complex/atan.zig b/lib/std/math/complex/atan.zig index 381fc43f7d..b932b6d624 100644 --- a/lib/std/math/complex/atan.zig +++ b/lib/std/math/complex/atan.zig @@ -55,7 +55,7 @@ fn atan32(z: Complex(f32)) Complex(f32) { } var t = 0.5 * math.atan2(f32, 2.0 * x, a); - var w = redupif32(t); + const w = redupif32(t); t = y - 1.0; a = x2 + t * t; @@ -104,7 +104,7 @@ fn atan64(z: Complex(f64)) Complex(f64) { } var t = 0.5 * math.atan2(f64, 2.0 * x, a); - var w = redupif64(t); + const w = redupif64(t); t = y - 1.0; a = x2 + t * t; diff --git a/lib/std/math/ilogb.zig b/lib/std/math/ilogb.zig index 735a2250c9..6f4bb13189 100644 --- a/lib/std/math/ilogb.zig +++ b/lib/std/math/ilogb.zig @@ -38,8 +38,8 @@ fn ilogbX(comptime T: type, x: T) i32 { const absMask = signBit - 1; - var u = @as(Z, @bitCast(x)) & absMask; - var e = @as(i32, @intCast(u >> significandBits)); + const u = @as(Z, @bitCast(x)) & absMask; + const e: i32 = @intCast(u >> significandBits); if (e == 0) { if (u == 0) { diff --git a/lib/std/math/log1p.zig b/lib/std/math/log1p.zig index 4cfdcecec9..4545823ece 100644 --- a/lib/std/math/log1p.zig +++ b/lib/std/math/log1p.zig @@ -33,8 +33,8 @@ fn log1p_32(x: f32) f32 { const Lg3: f32 = 0x91e9ee.0p-25; const Lg4: f32 = 0xf89e26.0p-26; - const u = @as(u32, @bitCast(x)); - var ix = u; + const u: u32 = @bitCast(x); + const ix = u; var k: i32 = 1; var f: f32 = undefined; var c: f32 = undefined; @@ -112,8 +112,8 @@ fn log1p_64(x: f64) f64 { const Lg6: f64 = 1.531383769920937332e-01; const Lg7: f64 = 1.479819860511658591e-01; - var ix = @as(u64, @bitCast(x)); - var hx = @as(u32, @intCast(ix >> 32)); + const ix: u64 = @bitCast(x); + const hx: u32 = @intCast(ix >> 32); var k: i32 = 1; var c: f64 = undefined; var f: f64 = undefined; diff --git a/lib/std/math/sqrt.zig b/lib/std/math/sqrt.zig index 0dd5381cd9..b4a9ee3838 100644 --- a/lib/std/math/sqrt.zig +++ b/lib/std/math/sqrt.zig @@ -50,7 +50,7 @@ fn sqrt_int(comptime T: type, value: T) Sqrt(T) { } while (one != 0) { - var c = op >= res + one; + const c = op >= res + one; if (c) op -= res + one; res >>= 1; if (c) res += one; diff --git a/lib/std/mem.zig b/lib/std/mem.zig index 73fe2e7757..bd0f8ca754 100644 --- a/lib/std/mem.zig +++ b/lib/std/mem.zig @@ -403,11 +403,11 @@ test "zeroes" { b: u32, }; - var c = zeroes(C_union); + const c = zeroes(C_union); try testing.expectEqual(@as(u8, 0), c.a); try testing.expectEqual(@as(u32, 0), c.b); - comptime var comptime_union = zeroes(C_union); + const comptime_union = comptime zeroes(C_union); try testing.expectEqual(@as(u8, 0), comptime_union.a); try testing.expectEqual(@as(u32, 0), comptime_union.b); @@ -3399,7 +3399,7 @@ test "reverseIterator" { try testing.expectEqual(@as(?i32, 3), it.nextPtr().?.*); try testing.expectEqual(@as(?*const i32, null), it.nextPtr()); - var mut_slice: []i32 = &array; + const mut_slice: []i32 = &array; var mut_it = reverseIterator(mut_slice); mut_it.nextPtr().?.* += 1; mut_it.nextPtr().?.* += 2; @@ -3419,7 +3419,7 @@ test "reverseIterator" { try testing.expectEqual(@as(?i32, 3), it.nextPtr().?.*); try testing.expectEqual(@as(?*const i32, null), it.nextPtr()); - var mut_ptr_to_array: *[2]i32 = &array; + const mut_ptr_to_array: *[2]i32 = &array; var mut_it = reverseIterator(mut_ptr_to_array); mut_it.nextPtr().?.* += 1; mut_it.nextPtr().?.* += 2; @@ -3581,7 +3581,7 @@ test "replacementSize" { /// Perform a replacement on an allocated buffer of pre-determined size. Caller must free returned memory. pub fn replaceOwned(comptime T: type, allocator: Allocator, input: []const T, needle: []const T, replacement: []const T) Allocator.Error![]T { - var output = try allocator.alloc(T, replacementSize(T, input, needle, replacement)); + const output = try allocator.alloc(T, replacementSize(T, input, needle, replacement)); _ = replace(T, input, needle, replacement, output); return output; } @@ -3693,8 +3693,8 @@ pub fn alignPointer(ptr: anytype, align_to: usize) ?@TypeOf(ptr) { test "alignPointer" { const S = struct { fn checkAlign(comptime T: type, base: usize, align_to: usize, expected: usize) !void { - var ptr = @as(T, @ptrFromInt(base)); - var aligned = alignPointer(ptr, align_to); + const ptr: T = @ptrFromInt(base); + const aligned = alignPointer(ptr, align_to); try testing.expectEqual(expected, @intFromPtr(aligned)); } }; @@ -3848,7 +3848,7 @@ test "bytesAsValue" { .big => "\xC0\xDE\xFA\xCE", .little => "\xCE\xFA\xDE\xC0", }.*; - var codeface = bytesAsValue(u32, &codeface_bytes); + const codeface = bytesAsValue(u32, &codeface_bytes); try testing.expect(codeface.* == 0xC0DEFACE); codeface.* = 0; for (codeface_bytes) |b| @@ -3941,6 +3941,7 @@ test "bytesAsSlice" { { const bytes = [_]u8{ 0xDE, 0xAD, 0xBE, 0xEF }; var runtime_zero: usize = 0; + _ = &runtime_zero; const slice = bytesAsSlice(u16, bytes[runtime_zero..]); try testing.expect(slice.len == 2); try testing.expect(bigToNative(u16, slice[0]) == 0xDEAD); @@ -3957,6 +3958,7 @@ test "bytesAsSlice keeps pointer alignment" { { var bytes = [_]u8{ 0x01, 0x02, 0x03, 0x04 }; var runtime_zero: usize = 0; + _ = &runtime_zero; const numbers = bytesAsSlice(u32, bytes[runtime_zero..]); try comptime testing.expect(@TypeOf(numbers) == []align(@alignOf(@TypeOf(bytes))) u32); } @@ -3967,8 +3969,8 @@ test "bytesAsSlice on a packed struct" { a: u8, }; - var b = [1]u8{9}; - var f = bytesAsSlice(F, &b); + const b: [1]u8 = .{9}; + const f = bytesAsSlice(F, &b); try testing.expect(f[0].a == 9); } @@ -4120,8 +4122,7 @@ pub const alignForwardGeneric = @compileError("renamed to alignForward"); /// result eventually gets discarded. // TODO: use @declareSideEffect() when it is available - https://github.com/ziglang/zig/issues/6168 pub fn doNotOptimizeAway(val: anytype) void { - var a: u8 = 0; - if (@typeInfo(@TypeOf(.{a})).Struct.fields[0].is_comptime) return; + if (@inComptime()) return; const max_gp_register_bits = @bitSizeOf(c_long); const t = @typeInfo(@TypeOf(val)); diff --git a/lib/std/meta.zig b/lib/std/meta.zig index 75dee47fa7..827b8f847c 100644 --- a/lib/std/meta.zig +++ b/lib/std/meta.zig @@ -738,7 +738,7 @@ test "std.meta.TagPayload" { }, }; const MovedEvent = TagPayload(Event, Event.Moved); - var e: Event = undefined; + const e: Event = .{ .Moved = undefined }; try testing.expect(MovedEvent == @TypeOf(e.Moved)); } @@ -839,9 +839,9 @@ test "std.meta.eql" { try testing.expect(eql(u_1, u_3)); try testing.expect(!eql(u_1, u_2)); - var a1 = "abcdef".*; - var a2 = "abcdef".*; - var a3 = "ghijkl".*; + const a1 = "abcdef".*; + const a2 = "abcdef".*; + const a3 = "ghijkl".*; try testing.expect(eql(a1, a2)); try testing.expect(!eql(a1, a3)); @@ -859,9 +859,9 @@ test "std.meta.eql" { try testing.expect(!eql(EU.tst(false), EU.tst(true))); const V = @Vector(4, u32); - var v1: V = @splat(1); - var v2: V = @splat(1); - var v3: V = @splat(2); + const v1: V = @splat(1); + const v2: V = @splat(1); + const v3: V = @splat(2); try testing.expect(eql(v1, v2)); try testing.expect(!eql(v1, v3)); @@ -879,6 +879,8 @@ test "intToEnum with error return" { var zero: u8 = 0; var one: u16 = 1; + _ = &zero; + _ = &one; try testing.expect(intToEnum(E1, zero) catch unreachable == E1.A); try testing.expect(intToEnum(E2, one) catch unreachable == E2.B); try testing.expect(intToEnum(E3, zero) catch unreachable == E3.A); diff --git a/lib/std/meta/trait.zig b/lib/std/meta/trait.zig index e00fac261c..3d3a1099fa 100644 --- a/lib/std/meta/trait.zig +++ b/lib/std/meta/trait.zig @@ -225,6 +225,7 @@ test "isSingleItemPtr" { try comptime testing.expect(isSingleItemPtr(@TypeOf(&array[0]))); try comptime testing.expect(!isSingleItemPtr(@TypeOf(array))); var runtime_zero: usize = 0; + _ = &runtime_zero; try testing.expect(!isSingleItemPtr(@TypeOf(array[runtime_zero..1]))); } @@ -253,6 +254,7 @@ pub fn isSlice(comptime T: type) bool { test "isSlice" { const array = [_]u8{0} ** 10; var runtime_zero: usize = 0; + _ = &runtime_zero; try testing.expect(isSlice(@TypeOf(array[runtime_zero..]))); try testing.expect(!isSlice(@TypeOf(array))); try testing.expect(!isSlice(@TypeOf(&array[0]))); @@ -341,8 +343,9 @@ pub fn isConstPtr(comptime T: type) bool { } test "isConstPtr" { - var t = @as(u8, 0); - const c = @as(u8, 0); + var t: u8 = 0; + t = t; + const c: u8 = 0; try testing.expect(isConstPtr(*const @TypeOf(t))); try testing.expect(isConstPtr(@TypeOf(&c))); try testing.expect(!isConstPtr(*@TypeOf(t))); diff --git a/lib/std/net.zig b/lib/std/net.zig index 9e32fe613f..7e15effe54 100644 --- a/lib/std/net.zig +++ b/lib/std/net.zig @@ -662,7 +662,7 @@ pub fn connectUnixSocket(path: []const u8) !Stream { fn if_nametoindex(name: []const u8) !u32 { if (builtin.target.os.tag == .linux) { var ifr: os.ifreq = undefined; - var sockfd = try os.socket(os.AF.UNIX, os.SOCK.DGRAM | os.SOCK.CLOEXEC, 0); + const sockfd = try os.socket(os.AF.UNIX, os.SOCK.DGRAM | os.SOCK.CLOEXEC, 0); defer os.closeSocket(sockfd); @memcpy(ifr.ifrn.name[0..name.len], name); @@ -1375,7 +1375,7 @@ fn linuxLookupNameFromDns( rc: ResolvConf, port: u16, ) !void { - var ctx = dpc_ctx{ + const ctx = dpc_ctx{ .addrs = addrs, .canon = canon, .port = port, @@ -1591,8 +1591,8 @@ fn resMSendRc( }}; const retry_interval = timeout / attempts; var next: u32 = 0; - var t2: u64 = @as(u64, @bitCast(std.time.milliTimestamp())); - var t0 = t2; + var t2: u64 = @bitCast(std.time.milliTimestamp()); + const t0 = t2; var t1 = t2 - retry_interval; var servfail_retry: usize = undefined; diff --git a/lib/std/net/test.zig b/lib/std/net/test.zig index 0fe53a7b9f..5e98ee2a4d 100644 --- a/lib/std/net/test.zig +++ b/lib/std/net/test.zig @@ -33,12 +33,12 @@ test "parse and render IPv6 addresses" { "::ffff:123.5.123.5", }; for (ips, 0..) |ip, i| { - var addr = net.Address.parseIp6(ip, 0) catch unreachable; + const addr = net.Address.parseIp6(ip, 0) catch unreachable; var newIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable; try std.testing.expect(std.mem.eql(u8, printed[i], newIp[1 .. newIp.len - 3])); if (builtin.os.tag == .linux) { - var addr_via_resolve = net.Address.resolveIp6(ip, 0) catch unreachable; + const addr_via_resolve = net.Address.resolveIp6(ip, 0) catch unreachable; var newResolvedIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr_via_resolve}) catch unreachable; try std.testing.expect(std.mem.eql(u8, printed[i], newResolvedIp[1 .. newResolvedIp.len - 3])); } @@ -80,7 +80,7 @@ test "parse and render IPv4 addresses" { "123.255.0.91", "127.0.0.1", }) |ip| { - var addr = net.Address.parseIp4(ip, 0) catch unreachable; + const addr = net.Address.parseIp4(ip, 0) catch unreachable; var newIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable; try std.testing.expect(std.mem.eql(u8, ip, newIp[0 .. newIp.len - 2])); } @@ -303,10 +303,10 @@ test "listen on a unix socket, send bytes, receive bytes" { var server = net.StreamServer.init(.{}); defer server.deinit(); - var socket_path = try generateFileName("socket.unix"); + const socket_path = try generateFileName("socket.unix"); defer testing.allocator.free(socket_path); - var socket_addr = try net.Address.initUnix(socket_path); + const socket_addr = try net.Address.initUnix(socket_path); defer std.fs.cwd().deleteFile(socket_path) catch {}; try server.listen(socket_addr); diff --git a/lib/std/os.zig b/lib/std/os.zig index 1ae5157d8b..cf388f76e9 100644 --- a/lib/std/os.zig +++ b/lib/std/os.zig @@ -4642,7 +4642,7 @@ pub fn faccessat(dirfd: fd_t, path: []const u8, mode: u32, flags: u32) AccessErr const path_w = try windows.sliceToPrefixedFileW(dirfd, path); return faccessatW(dirfd, path_w.span().ptr, mode, flags); } else if (builtin.os.tag == .wasi and !builtin.link_libc) { - var resolved = RelativePathWasi{ .dir_fd = dirfd, .relative_path = path }; + const resolved = RelativePathWasi{ .dir_fd = dirfd, .relative_path = path }; const file = blk: { break :blk fstatat(dirfd, path, flags); @@ -4775,7 +4775,7 @@ pub fn pipe2(flags: u32) PipeError![2]fd_t { } } - var fds: [2]fd_t = try pipe(); + const fds: [2]fd_t = try pipe(); errdefer { close(fds[0]); close(fds[1]); @@ -6709,7 +6709,7 @@ pub fn dn_expand( // loop invariants: p= msg.len) return error.InvalidDnsPacket; p = msg.ptr + j; @@ -7285,7 +7285,7 @@ pub const TimerFdGetError = error{InvalidHandle} || UnexpectedError; pub const TimerFdSetError = TimerFdGetError || error{Canceled}; pub fn timerfd_create(clokid: i32, flags: u32) TimerFdCreateError!fd_t { - var rc = linux.timerfd_create(clokid, flags); + const rc = linux.timerfd_create(clokid, flags); return switch (errno(rc)) { .SUCCESS => @as(fd_t, @intCast(rc)), .INVAL => unreachable, @@ -7299,7 +7299,7 @@ pub fn timerfd_create(clokid: i32, flags: u32) TimerFdCreateError!fd_t { } pub fn timerfd_settime(fd: i32, flags: u32, new_value: *const linux.itimerspec, old_value: ?*linux.itimerspec) TimerFdSetError!void { - var rc = linux.timerfd_settime(fd, flags, new_value, old_value); + const rc = linux.timerfd_settime(fd, flags, new_value, old_value); return switch (errno(rc)) { .SUCCESS => {}, .BADF => error.InvalidHandle, @@ -7312,7 +7312,7 @@ pub fn timerfd_settime(fd: i32, flags: u32, new_value: *const linux.itimerspec, pub fn timerfd_gettime(fd: i32) TimerFdGetError!linux.itimerspec { var curr_value: linux.itimerspec = undefined; - var rc = linux.timerfd_gettime(fd, &curr_value); + const rc = linux.timerfd_gettime(fd, &curr_value); return switch (errno(rc)) { .SUCCESS => return curr_value, .BADF => error.InvalidHandle, diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig index 9163eb98a9..97ad952562 100644 --- a/lib/std/os/linux.zig +++ b/lib/std/os/linux.zig @@ -1326,6 +1326,7 @@ pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr_const, vlen: u32, flags: u32) usize next_unsent = i + 1; break; } + size += iov.iov_len; } } if (next_unsent < kvlen or next_unsent == 0) { // want to make sure at least one syscall occurs (e.g. to trigger MSG.EOR) diff --git a/lib/std/os/linux/io_uring.zig b/lib/std/os/linux/io_uring.zig index 3b282422ae..2219d95832 100644 --- a/lib/std/os/linux/io_uring.zig +++ b/lib/std/os/linux/io_uring.zig @@ -137,7 +137,7 @@ pub const IO_Uring = struct { // We must therefore use wrapping addition and subtraction to avoid a runtime crash. const next = self.sq.sqe_tail +% 1; if (next -% head > self.sq.sqes.len) return error.SubmissionQueueFull; - var sqe = &self.sq.sqes[self.sq.sqe_tail & self.sq.mask]; + const sqe = &self.sq.sqes[self.sq.sqe_tail & self.sq.mask]; self.sq.sqe_tail = next; return sqe; } @@ -279,7 +279,7 @@ pub const IO_Uring = struct { const ready = self.cq_ready(); const count = @min(cqes.len, ready); var head = self.cq.head.*; - var tail = head +% count; + const tail = head +% count; // TODO Optimize this by using 1 or 2 memcpy's (if the tail wraps) rather than a loop. var i: usize = 0; // Do not use "less-than" operator since head and tail may wrap: @@ -1916,7 +1916,7 @@ test "splice/read" { var buffer_read = [_]u8{98} ** 20; _ = try file_src.write(&buffer_write); - var fds = try os.pipe(); + const fds = try os.pipe(); const pipe_offset: u64 = std.math.maxInt(u64); const sqe_splice_to_pipe = try ring.splice(0x11111111, fd_src, 0, fds[1], pipe_offset, buffer_write.len); @@ -2045,6 +2045,7 @@ test "openat" { // Workaround for LLVM bug: https://github.com/ziglang/zig/issues/12014 const path_addr = if (builtin.zig_backend == .stage2_llvm) p: { var workaround = path; + _ = &workaround; break :p @intFromPtr(workaround); } else @intFromPtr(path); @@ -2199,7 +2200,7 @@ test "sendmsg/recvmsg" { var iovecs_recv = [_]os.iovec{ os.iovec{ .iov_base = &buffer_recv, .iov_len = buffer_recv.len }, }; - var addr = [_]u8{0} ** 4; + const addr = [_]u8{0} ** 4; var address_recv = net.Address.initIp4(addr, 0); var msg_recv: os.msghdr = os.msghdr{ .name = &address_recv.any, @@ -2676,7 +2677,7 @@ test "shutdown" { var slen: os.socklen_t = address.getOsSockLen(); try os.getsockname(server, &address.any, &slen); - var shutdown_sqe = try ring.shutdown(0x445445445, server, os.linux.SHUT.RD); + const shutdown_sqe = try ring.shutdown(0x445445445, server, os.linux.SHUT.RD); try testing.expectEqual(linux.IORING_OP.SHUTDOWN, shutdown_sqe.opcode); try testing.expectEqual(@as(i32, server), shutdown_sqe.fd); @@ -2702,7 +2703,7 @@ test "shutdown" { const server = try os.socket(address.any.family, os.SOCK.STREAM | os.SOCK.CLOEXEC, 0); defer os.close(server); - var shutdown_sqe = ring.shutdown(0x445445445, server, os.linux.SHUT.RD) catch |err| switch (err) { + const shutdown_sqe = ring.shutdown(0x445445445, server, os.linux.SHUT.RD) catch |err| switch (err) { else => |errno| std.debug.panic("unhandled errno: {}", .{errno}), }; try testing.expectEqual(linux.IORING_OP.SHUTDOWN, shutdown_sqe.opcode); @@ -2740,7 +2741,7 @@ test "renameat" { // Submit renameat - var sqe = try ring.renameat( + const sqe = try ring.renameat( 0x12121212, tmp.dir.fd, old_path, @@ -2807,7 +2808,7 @@ test "unlinkat" { // Submit unlinkat - var sqe = try ring.unlinkat( + const sqe = try ring.unlinkat( 0x12121212, tmp.dir.fd, path, @@ -2854,7 +2855,7 @@ test "mkdirat" { // Submit mkdirat - var sqe = try ring.mkdirat( + const sqe = try ring.mkdirat( 0x12121212, tmp.dir.fd, path, @@ -2902,7 +2903,7 @@ test "symlinkat" { // Submit symlinkat - var sqe = try ring.symlinkat( + const sqe = try ring.symlinkat( 0x12121212, path, tmp.dir.fd, @@ -2953,7 +2954,7 @@ test "linkat" { // Submit linkat - var sqe = try ring.linkat( + const sqe = try ring.linkat( 0x12121212, tmp.dir.fd, first_path, @@ -3032,7 +3033,7 @@ test "provide_buffers: read" { var i: usize = 0; while (i < buffers.len) : (i += 1) { - var sqe = try ring.read(0xdededede, fd, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); + const sqe = try ring.read(0xdededede, fd, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); try testing.expectEqual(linux.IORING_OP.READ, sqe.opcode); try testing.expectEqual(@as(i32, fd), sqe.fd); try testing.expectEqual(@as(u64, 0), sqe.addr); @@ -3058,7 +3059,7 @@ test "provide_buffers: read" { // This read should fail { - var sqe = try ring.read(0xdfdfdfdf, fd, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); + const sqe = try ring.read(0xdfdfdfdf, fd, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); try testing.expectEqual(linux.IORING_OP.READ, sqe.opcode); try testing.expectEqual(@as(i32, fd), sqe.fd); try testing.expectEqual(@as(u64, 0), sqe.addr); @@ -3097,7 +3098,7 @@ test "provide_buffers: read" { // Final read which should work { - var sqe = try ring.read(0xdfdfdfdf, fd, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); + const sqe = try ring.read(0xdfdfdfdf, fd, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); try testing.expectEqual(linux.IORING_OP.READ, sqe.opcode); try testing.expectEqual(@as(i32, fd), sqe.fd); try testing.expectEqual(@as(u64, 0), sqe.addr); @@ -3158,7 +3159,7 @@ test "remove_buffers" { // Remove 3 buffers { - var sqe = try ring.remove_buffers(0xbababababa, 3, group_id); + const sqe = try ring.remove_buffers(0xbababababa, 3, group_id); try testing.expectEqual(linux.IORING_OP.REMOVE_BUFFERS, sqe.opcode); try testing.expectEqual(@as(i32, 3), sqe.fd); try testing.expectEqual(@as(u64, 0), sqe.addr); @@ -3270,7 +3271,7 @@ test "provide_buffers: accept/connect/send/recv" { var i: usize = 0; while (i < buffers.len) : (i += 1) { - var sqe = try ring.recv(0xdededede, socket_test_harness.client, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); + const sqe = try ring.recv(0xdededede, socket_test_harness.client, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); try testing.expectEqual(linux.IORING_OP.RECV, sqe.opcode); try testing.expectEqual(@as(i32, socket_test_harness.client), sqe.fd); try testing.expectEqual(@as(u64, 0), sqe.addr); @@ -3299,7 +3300,7 @@ test "provide_buffers: accept/connect/send/recv" { // This recv should fail { - var sqe = try ring.recv(0xdfdfdfdf, socket_test_harness.client, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); + const sqe = try ring.recv(0xdfdfdfdf, socket_test_harness.client, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); try testing.expectEqual(linux.IORING_OP.RECV, sqe.opcode); try testing.expectEqual(@as(i32, socket_test_harness.client), sqe.fd); try testing.expectEqual(@as(u64, 0), sqe.addr); @@ -3349,7 +3350,7 @@ test "provide_buffers: accept/connect/send/recv" { @memset(mem.sliceAsBytes(&buffers), 1); { - var sqe = try ring.recv(0xdfdfdfdf, socket_test_harness.client, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); + const sqe = try ring.recv(0xdfdfdfdf, socket_test_harness.client, .{ .buffer_selection = .{ .group_id = group_id, .len = buffer_len } }, 0); try testing.expectEqual(linux.IORING_OP.RECV, sqe.opcode); try testing.expectEqual(@as(i32, socket_test_harness.client), sqe.fd); try testing.expectEqual(@as(u64, 0), sqe.addr); @@ -3477,7 +3478,7 @@ test "accept multishot" { var nr: usize = 4; // number of clients to connect while (nr > 0) : (nr -= 1) { // connect client - var client = try os.socket(address.any.family, os.SOCK.STREAM | os.SOCK.CLOEXEC, 0); + const client = try os.socket(address.any.family, os.SOCK.STREAM | os.SOCK.CLOEXEC, 0); errdefer os.closeSocket(client); try os.connect(client, &address.any, address.getOsSockLen()); diff --git a/lib/std/os/plan9.zig b/lib/std/os/plan9.zig index 9334171221..b42fd52245 100644 --- a/lib/std/os/plan9.zig +++ b/lib/std/os/plan9.zig @@ -278,7 +278,7 @@ pub fn sbrk(n: usize) usize { bloc = @intFromPtr(&ExecData.end); bloc_max = @intFromPtr(&ExecData.end); } - var bl = std.mem.alignForward(usize, bloc, std.mem.page_size); + const bl = std.mem.alignForward(usize, bloc, std.mem.page_size); const n_aligned = std.mem.alignForward(usize, n, std.mem.page_size); if (bl + n_aligned > bloc_max) { // we need to allocate diff --git a/lib/std/os/test.zig b/lib/std/os/test.zig index f4a67f1035..40e0991e5f 100644 --- a/lib/std/os/test.zig +++ b/lib/std/os/test.zig @@ -58,7 +58,7 @@ test "chdir smoke test" { { // Create a tmp directory var tmp_dir_buf: [fs.MAX_PATH_BYTES]u8 = undefined; - var tmp_dir_path = path: { + const tmp_dir_path = path: { var allocator = std.heap.FixedBufferAllocator.init(&tmp_dir_buf); break :path try fs.path.resolve(allocator.allocator(), &[_][]const u8{ old_cwd, "zig-test-tmp" }); }; @@ -72,7 +72,7 @@ test "chdir smoke test" { // On Windows, fs.path.resolve returns an uppercase drive letter, but the drive letter returned by getcwd may be lowercase var resolved_cwd_buf: [fs.MAX_PATH_BYTES]u8 = undefined; - var resolved_cwd = path: { + const resolved_cwd = path: { var allocator = std.heap.FixedBufferAllocator.init(&resolved_cwd_buf); break :path try fs.path.resolve(allocator.allocator(), &[_][]const u8{new_cwd}); }; @@ -523,7 +523,7 @@ test "pipe" { if (native_os == .windows or native_os == .wasi) return error.SkipZigTest; - var fds = try os.pipe(); + const fds = try os.pipe(); try expect((try os.write(fds[1], "hello")) == 5); var buf: [16]u8 = undefined; try expect((try os.read(fds[0], buf[0..])) == 5); @@ -533,7 +533,7 @@ test "pipe" { } test "argsAlloc" { - var args = try std.process.argsAlloc(std.testing.allocator); + const args = try std.process.argsAlloc(std.testing.allocator); std.process.argsFree(std.testing.allocator, args); } @@ -1087,7 +1087,7 @@ test "timerfd" { return error.SkipZigTest; const linux = os.linux; - var tfd = try os.timerfd_create(linux.CLOCK.MONOTONIC, linux.TFD.CLOEXEC); + const tfd = try os.timerfd_create(linux.CLOCK.MONOTONIC, linux.TFD.CLOEXEC); defer os.close(tfd); // Fire event 10_000_000ns = 10ms after the os.timerfd_settime call. @@ -1097,8 +1097,8 @@ test "timerfd" { var fds: [1]os.pollfd = .{.{ .fd = tfd, .events = os.linux.POLL.IN, .revents = 0 }}; try expectEqual(@as(usize, 1), try os.poll(&fds, -1)); // -1 => infinite waiting - var git = try os.timerfd_gettime(tfd); - var expect_disarmed_timer: linux.itimerspec = .{ .it_interval = .{ .tv_sec = 0, .tv_nsec = 0 }, .it_value = .{ .tv_sec = 0, .tv_nsec = 0 } }; + const git = try os.timerfd_gettime(tfd); + const expect_disarmed_timer: linux.itimerspec = .{ .it_interval = .{ .tv_sec = 0, .tv_nsec = 0 }, .it_value = .{ .tv_sec = 0, .tv_nsec = 0 } }; try expectEqual(expect_disarmed_timer, git); } @@ -1128,11 +1128,11 @@ test "read with empty buffer" { break :blk try fs.realpathAlloc(allocator, relative_path); }; - var file_path: []u8 = try fs.path.join(allocator, &[_][]const u8{ base_path, "some_file" }); + const file_path: []u8 = try fs.path.join(allocator, &[_][]const u8{ base_path, "some_file" }); var file = try fs.cwd().createFile(file_path, .{ .read = true }); defer file.close(); - var bytes = try allocator.alloc(u8, 0); + const bytes = try allocator.alloc(u8, 0); _ = try os.read(file.handle, bytes); } @@ -1153,11 +1153,11 @@ test "pread with empty buffer" { break :blk try fs.realpathAlloc(allocator, relative_path); }; - var file_path: []u8 = try fs.path.join(allocator, &[_][]const u8{ base_path, "some_file" }); + const file_path: []u8 = try fs.path.join(allocator, &[_][]const u8{ base_path, "some_file" }); var file = try fs.cwd().createFile(file_path, .{ .read = true }); defer file.close(); - var bytes = try allocator.alloc(u8, 0); + const bytes = try allocator.alloc(u8, 0); _ = try os.pread(file.handle, bytes, 0); } @@ -1178,11 +1178,11 @@ test "write with empty buffer" { break :blk try fs.realpathAlloc(allocator, relative_path); }; - var file_path: []u8 = try fs.path.join(allocator, &[_][]const u8{ base_path, "some_file" }); + const file_path: []u8 = try fs.path.join(allocator, &[_][]const u8{ base_path, "some_file" }); var file = try fs.cwd().createFile(file_path, .{}); defer file.close(); - var bytes = try allocator.alloc(u8, 0); + const bytes = try allocator.alloc(u8, 0); _ = try os.write(file.handle, bytes); } @@ -1203,11 +1203,11 @@ test "pwrite with empty buffer" { break :blk try fs.realpathAlloc(allocator, relative_path); }; - var file_path: []u8 = try fs.path.join(allocator, &[_][]const u8{ base_path, "some_file" }); + const file_path: []u8 = try fs.path.join(allocator, &[_][]const u8{ base_path, "some_file" }); var file = try fs.cwd().createFile(file_path, .{}); defer file.close(); - var bytes = try allocator.alloc(u8, 0); + const bytes = try allocator.alloc(u8, 0); _ = try os.pwrite(file.handle, bytes, 0); } diff --git a/lib/std/os/uefi.zig b/lib/std/os/uefi.zig index 535b88a262..7ad01e58e7 100644 --- a/lib/std/os/uefi.zig +++ b/lib/std/os/uefi.zig @@ -149,11 +149,10 @@ pub const TimeCapabilities = extern struct { pub const FileHandle = *opaque {}; test "GUID formatting" { - var bytes = [_]u8{ 137, 60, 203, 50, 128, 128, 124, 66, 186, 19, 80, 73, 135, 59, 194, 135 }; + const bytes = [_]u8{ 137, 60, 203, 50, 128, 128, 124, 66, 186, 19, 80, 73, 135, 59, 194, 135 }; + const guid: Guid = @bitCast(bytes); - var guid = @as(Guid, @bitCast(bytes)); - - var str = try std.fmt.allocPrint(std.testing.allocator, "{}", .{guid}); + const str = try std.fmt.allocPrint(std.testing.allocator, "{}", .{guid}); defer std.testing.allocator.free(str); try std.testing.expect(std.mem.eql(u8, str, "32cb3c89-8080-427c-ba13-5049873bc287")); diff --git a/lib/std/os/uefi/device_path.zig b/lib/std/os/uefi/device_path.zig index b15654e8a7..55a3763d66 100644 --- a/lib/std/os/uefi/device_path.zig +++ b/lib/std/os/uefi/device_path.zig @@ -213,7 +213,7 @@ pub const DevicePath = union(Type) { // multiple adr entries can optionally follow pub fn adrs(self: *const AdrDevicePath) []align(1) const u32 { // self.length is a minimum of 8 with one adr which is size 4. - var entries = (self.length - 4) / @sizeOf(u32); + const entries = (self.length - 4) / @sizeOf(u32); return @as([*]align(1) const u32, @ptrCast(&self.adr))[0..entries]; } }; @@ -431,7 +431,7 @@ pub const DevicePath = union(Type) { device_product_id: u16 align(1), pub fn serial_number(self: *const UsbWwidDevicePath) []align(1) const u16 { - var serial_len = (self.length - @sizeOf(UsbWwidDevicePath)) / @sizeOf(u16); + const serial_len = (self.length - @sizeOf(UsbWwidDevicePath)) / @sizeOf(u16); return @as([*]align(1) const u16, @ptrCast(@as([*]const u8, @ptrCast(self)) + @sizeOf(UsbWwidDevicePath)))[0..serial_len]; } }; diff --git a/lib/std/os/uefi/pool_allocator.zig b/lib/std/os/uefi/pool_allocator.zig index 3f64a2f3f6..aa9798c6e5 100644 --- a/lib/std/os/uefi/pool_allocator.zig +++ b/lib/std/os/uefi/pool_allocator.zig @@ -34,7 +34,7 @@ const UefiPoolAllocator = struct { const unaligned_addr = @intFromPtr(unaligned_ptr); const aligned_addr = mem.alignForward(usize, unaligned_addr + @sizeOf(usize), ptr_align); - var aligned_ptr = unaligned_ptr + (aligned_addr - unaligned_addr); + const aligned_ptr = unaligned_ptr + (aligned_addr - unaligned_addr); getHeader(aligned_ptr).* = unaligned_ptr; return aligned_ptr; diff --git a/lib/std/os/uefi/protocol/device_path.zig b/lib/std/os/uefi/protocol/device_path.zig index 396398252d..a08eee193c 100644 --- a/lib/std/os/uefi/protocol/device_path.zig +++ b/lib/std/os/uefi/protocol/device_path.zig @@ -43,7 +43,7 @@ pub const DevicePath = extern struct { /// Creates a file device path from the existing device path and a file path. pub fn create_file_device_path(self: *DevicePath, allocator: Allocator, path: [:0]align(1) const u16) !*DevicePath { - var path_size = self.size(); + const path_size = self.size(); // 2 * (path.len + 1) for the path and its null terminator, which are u16s // DevicePath for the extra node before the end @@ -82,8 +82,7 @@ pub const DevicePath = extern struct { // Got the associated union type for self.type, now // we need to initialize it and its subtype if (self.type == enum_value) { - var subtype = self.initSubtype(ufield.type); - + const subtype = self.initSubtype(ufield.type); if (subtype) |sb| { // e.g. return .{ .Hardware = .{ .Pci = @ptrCast(...) } } return @unionInit(uefi.DevicePath, ufield.name, sb); diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig index b0c0ce5be0..efc3f5574d 100644 --- a/lib/std/os/windows.zig +++ b/lib/std/os/windows.zig @@ -1166,7 +1166,7 @@ test "QueryObjectName" { const handle = tmp.dir.fd; var out_buffer: [PATH_MAX_WIDE]u16 = undefined; - var result_path = try QueryObjectName(handle, &out_buffer); + const result_path = try QueryObjectName(handle, &out_buffer); const required_len_in_u16 = result_path.len + @divExact(@intFromPtr(result_path.ptr) - @intFromPtr(&out_buffer), 2) + 1; //insufficient size try std.testing.expectError(error.NameTooLong, QueryObjectName(handle, out_buffer[0 .. required_len_in_u16 - 1])); @@ -2045,8 +2045,8 @@ pub fn eqlIgnoreCaseUtf8(a: []const u8, b: []const u8) bool { }; while (true) { - var a_cp = a_utf8_it.nextCodepoint() orelse break; - var b_cp = b_utf8_it.nextCodepoint() orelse return false; + const a_cp = a_utf8_it.nextCodepoint() orelse break; + const b_cp = b_utf8_it.nextCodepoint() orelse return false; if (a_cp <= std.math.maxInt(u16) and b_cp <= std.math.maxInt(u16)) { if (a_cp != b_cp and upcaseImpl(@intCast(a_cp)) != upcaseImpl(@intCast(b_cp))) { diff --git a/lib/std/pdb.zig b/lib/std/pdb.zig index acc8aa1ec7..d0623145a0 100644 --- a/lib/std/pdb.zig +++ b/lib/std/pdb.zig @@ -897,7 +897,7 @@ const Msf = struct { return error.UnhandledBigDirectoryStream; // cf. BlockMapAddr comment. try file.seekTo(superblock.BlockSize * superblock.BlockMapAddr); - var dir_blocks = try allocator.alloc(u32, dir_block_count); + const dir_blocks = try allocator.alloc(u32, dir_block_count); for (dir_blocks) |*b| { b.* = try in.readInt(u32, .little); } diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig index 31ae965286..dc3981b65e 100644 --- a/lib/std/priority_dequeue.zig +++ b/lib/std/priority_dequeue.zig @@ -82,8 +82,8 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar }; fn getStartForSiftUp(self: Self, child: T, index: usize) StartIndexAndLayer { - var child_index = index; - var parent_index = parentIndex(child_index); + const child_index = index; + const parent_index = parentIndex(child_index); const parent = self.items[parent_index]; const min_layer = self.nextIsMinLayer(); @@ -115,7 +115,7 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar fn doSiftUp(self: *Self, start_index: usize, target_order: Order) void { var child_index = start_index; while (child_index > 2) { - var grandparent_index = grandparentIndex(child_index); + const grandparent_index = grandparentIndex(child_index); const child = self.items[child_index]; const grandparent = self.items[grandparent_index]; @@ -286,8 +286,8 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar } fn bestItemAtIndices(self: Self, index1: usize, index2: usize, target_order: Order) ItemAndIndex { - var item1 = self.getItem(index1); - var item2 = self.getItem(index2); + const item1 = self.getItem(index1); + const item2 = self.getItem(index2); return self.bestItem(item1, item2, target_order); } diff --git a/lib/std/priority_queue.zig b/lib/std/priority_queue.zig index a568eeadcf..74f7cb6885 100644 --- a/lib/std/priority_queue.zig +++ b/lib/std/priority_queue.zig @@ -470,7 +470,7 @@ test "std.PriorityQueue: remove at index" { break idx; idx += 1; } else unreachable; - var sorted_items = [_]u32{ 1, 3, 4, 5, 8, 9 }; + const sorted_items = [_]u32{ 1, 3, 4, 5, 8, 9 }; try expectEqual(queue.removeIndex(two_idx), 2); var i: usize = 0; diff --git a/lib/std/process.zig b/lib/std/process.zig index 518def4215..d736fbe8df 100644 --- a/lib/std/process.zig +++ b/lib/std/process.zig @@ -298,9 +298,9 @@ pub fn getEnvMap(allocator: Allocator) !EnvMap { return result; } - var environ = try allocator.alloc([*:0]u8, environ_count); + const environ = try allocator.alloc([*:0]u8, environ_count); defer allocator.free(environ); - var environ_buf = try allocator.alloc(u8, environ_buf_size); + const environ_buf = try allocator.alloc(u8, environ_buf_size); defer allocator.free(environ_buf); const environ_get_ret = os.wasi.environ_get(environ.ptr, environ_buf.ptr); @@ -412,7 +412,7 @@ pub fn hasEnvVar(allocator: Allocator, key: []const u8) error{OutOfMemory}!bool } test "os.getEnvVarOwned" { - var ga = std.testing.allocator; + const ga = std.testing.allocator; try testing.expectError(error.EnvironmentVariableNotFound, getEnvVarOwned(ga, "BADENV")); } @@ -477,10 +477,10 @@ pub const ArgIteratorWasi = struct { return &[_][:0]u8{}; } - var argv = try allocator.alloc([*:0]u8, count); + const argv = try allocator.alloc([*:0]u8, count); defer allocator.free(argv); - var argv_buf = try allocator.alloc(u8, buf_size); + const argv_buf = try allocator.alloc(u8, buf_size); switch (w.args_get(argv.ptr, argv_buf.ptr)) { .SUCCESS => {}, @@ -551,7 +551,7 @@ pub fn ArgIteratorGeneral(comptime options: ArgIteratorGeneralOptions) type { /// cmd_line_utf8 MUST remain valid and constant while using this instance pub fn init(allocator: Allocator, cmd_line_utf8: []const u8) InitError!Self { - var buffer = try allocator.alloc(u8, cmd_line_utf8.len + 1); + const buffer = try allocator.alloc(u8, cmd_line_utf8.len + 1); errdefer allocator.free(buffer); return Self{ @@ -564,7 +564,7 @@ pub fn ArgIteratorGeneral(comptime options: ArgIteratorGeneralOptions) type { /// cmd_line_utf8 will be free'd (with the allocator) on deinit() pub fn initTakeOwnership(allocator: Allocator, cmd_line_utf8: []const u8) InitError!Self { - var buffer = try allocator.alloc(u8, cmd_line_utf8.len + 1); + const buffer = try allocator.alloc(u8, cmd_line_utf8.len + 1); errdefer allocator.free(buffer); return Self{ @@ -577,8 +577,8 @@ pub fn ArgIteratorGeneral(comptime options: ArgIteratorGeneralOptions) type { /// cmd_line_utf16le MUST be encoded UTF16-LE, and is converted to UTF-8 in an internal buffer pub fn initUtf16le(allocator: Allocator, cmd_line_utf16le: [*:0]const u16) InitUtf16leError!Self { - var utf16le_slice = mem.sliceTo(cmd_line_utf16le, 0); - var cmd_line = std.unicode.utf16leToUtf8Alloc(allocator, utf16le_slice) catch |err| switch (err) { + const utf16le_slice = mem.sliceTo(cmd_line_utf16le, 0); + const cmd_line = std.unicode.utf16leToUtf8Alloc(allocator, utf16le_slice) catch |err| switch (err) { error.ExpectedSecondSurrogateHalf, error.DanglingSurrogateHalf, error.UnexpectedSecondSurrogateHalf, @@ -588,7 +588,7 @@ pub fn ArgIteratorGeneral(comptime options: ArgIteratorGeneralOptions) type { }; errdefer allocator.free(cmd_line); - var buffer = try allocator.alloc(u8, cmd_line.len + 1); + const buffer = try allocator.alloc(u8, cmd_line.len + 1); errdefer allocator.free(buffer); return Self{ @@ -681,7 +681,7 @@ pub fn ArgIteratorGeneral(comptime options: ArgIteratorGeneralOptions) type { 0 => { self.emitBackslashes(backslash_count); self.buffer[self.end] = 0; - var token = self.buffer[self.start..self.end :0]; + const token = self.buffer[self.start..self.end :0]; self.end += 1; self.start = self.end; return token; @@ -713,7 +713,7 @@ pub fn ArgIteratorGeneral(comptime options: ArgIteratorGeneralOptions) type { self.emitCharacter(character); } else { self.buffer[self.end] = 0; - var token = self.buffer[self.start..self.end :0]; + const token = self.buffer[self.start..self.end :0]; self.end += 1; self.start = self.end; return token; diff --git a/lib/std/rand/test.zig b/lib/std/rand/test.zig index d02c016357..d498985097 100644 --- a/lib/std/rand/test.zig +++ b/lib/std/rand/test.zig @@ -332,13 +332,13 @@ test "Random float chi-square goodness of fit" { while (i < num_numbers) : (i += 1) { const rand_f32 = random.float(f32); const rand_f64 = random.float(f64); - var f32_put = try f32_hist.getOrPut(@as(u32, @intFromFloat(rand_f32 * @as(f32, @floatFromInt(num_buckets))))); + const f32_put = try f32_hist.getOrPut(@as(u32, @intFromFloat(rand_f32 * @as(f32, @floatFromInt(num_buckets))))); if (f32_put.found_existing) { f32_put.value_ptr.* += 1; } else { f32_put.value_ptr.* = 1; } - var f64_put = try f64_hist.getOrPut(@as(u32, @intFromFloat(rand_f64 * @as(f64, @floatFromInt(num_buckets))))); + const f64_put = try f64_hist.getOrPut(@as(u32, @intFromFloat(rand_f64 * @as(f64, @floatFromInt(num_buckets))))); if (f64_put.found_existing) { f64_put.value_ptr.* += 1; } else { diff --git a/lib/std/sort.zig b/lib/std/sort.zig index e110a8beb8..f354e80df6 100644 --- a/lib/std/sort.zig +++ b/lib/std/sort.zig @@ -387,7 +387,7 @@ test "sort fuzz testing" { var i: usize = 0; while (i < test_case_count) : (i += 1) { const array_size = random.intRangeLessThan(usize, 0, 1000); - var array = try testing.allocator.alloc(i32, array_size); + const array = try testing.allocator.alloc(i32, array_size); defer testing.allocator.free(array); // populate with random data for (array) |*item| { diff --git a/lib/std/sort/block.zig b/lib/std/sort/block.zig index fe6e628653..4c94fb78ad 100644 --- a/lib/std/sort/block.zig +++ b/lib/std/sort/block.zig @@ -302,8 +302,8 @@ pub fn block( } else { iterator.begin(); while (!iterator.finished()) { - var A = iterator.nextRange(); - var B = iterator.nextRange(); + const A = iterator.nextRange(); + const B = iterator.nextRange(); if (lessThan(context, items[B.end - 1], items[A.start])) { // the two ranges are in reverse order, so a simple rotation should fix it diff --git a/lib/std/sort/pdq.zig b/lib/std/sort/pdq.zig index 0e1595b82c..d74c7788a4 100644 --- a/lib/std/sort/pdq.zig +++ b/lib/std/sort/pdq.zig @@ -276,10 +276,10 @@ fn chosePivot(a: usize, b: usize, pivot: *usize, context: anytype) Hint { // max_swaps is the maximum number of swaps allowed in this function const max_swaps = 4 * 3; - var len = b - a; - var i = a + len / 4 * 1; - var j = a + len / 4 * 2; - var k = a + len / 4 * 3; + const len = b - a; + const i = a + len / 4 * 1; + const j = a + len / 4 * 2; + const k = a + len / 4 * 3; var swaps: usize = 0; if (len >= 8) { diff --git a/lib/std/tar.zig b/lib/std/tar.zig index bdbec87e39..15727fdebf 100644 --- a/lib/std/tar.zig +++ b/lib/std/tar.zig @@ -218,7 +218,7 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi if (file_size == 0 and unstripped_file_name.len == 0) return; const file_name = try stripComponents(unstripped_file_name, options.strip_components); - var file = dir.createFile(file_name, .{}) catch |err| switch (err) { + const file = dir.createFile(file_name, .{}) catch |err| switch (err) { error.FileNotFound => again: { const code = code: { if (std.fs.path.dirname(file_name)) |dir_name| { diff --git a/lib/std/testing.zig b/lib/std/testing.zig index 95f1b156c1..09507a2392 100644 --- a/lib/std/testing.zig +++ b/lib/std/testing.zig @@ -399,7 +399,7 @@ fn SliceDiffer(comptime T: type) type { pub fn write(self: Self, writer: anytype) !void { for (self.expected, 0..) |value, i| { - var full_index = self.start_index + i; + const full_index = self.start_index + i; const diff = if (i < self.actual.len) !std.meta.eql(self.actual[i], value) else true; if (diff) try self.ttyconf.setColor(writer, .red); if (@typeInfo(T) == .Pointer) { @@ -424,7 +424,7 @@ const BytesDiffer = struct { // to avoid having to calculate diffs twice per chunk var diffs: std.bit_set.IntegerBitSet(16) = .{ .mask = 0 }; for (chunk, 0..) |byte, i| { - var absolute_byte_index = (expected_iterator.index - chunk.len) + i; + const absolute_byte_index = (expected_iterator.index - chunk.len) + i; const diff = if (absolute_byte_index < self.actual.len) self.actual[absolute_byte_index] != byte else true; if (diff) diffs.set(i); try self.writeByteDiff(writer, "{X:0>2} ", byte, diff); @@ -565,13 +565,13 @@ pub fn tmpDir(opts: std.fs.Dir.OpenDirOptions) TmpDir { var sub_path: [TmpDir.sub_path_len]u8 = undefined; _ = std.fs.base64_encoder.encode(&sub_path, &random_bytes); - var cwd = std.fs.cwd(); + const cwd = std.fs.cwd(); var cache_dir = cwd.makeOpenPath("zig-cache", .{}) catch @panic("unable to make tmp dir for testing: unable to make and open zig-cache dir"); defer cache_dir.close(); - var parent_dir = cache_dir.makeOpenPath("tmp", .{}) catch + const parent_dir = cache_dir.makeOpenPath("tmp", .{}) catch @panic("unable to make tmp dir for testing: unable to make and open zig-cache/tmp dir"); - var dir = parent_dir.makeOpenPath(&sub_path, opts) catch + const dir = parent_dir.makeOpenPath(&sub_path, opts) catch @panic("unable to make tmp dir for testing: unable to make and open the tmp dir"); return .{ @@ -587,13 +587,13 @@ pub fn tmpIterableDir(opts: std.fs.Dir.OpenDirOptions) TmpIterableDir { var sub_path: [TmpIterableDir.sub_path_len]u8 = undefined; _ = std.fs.base64_encoder.encode(&sub_path, &random_bytes); - var cwd = std.fs.cwd(); + const cwd = std.fs.cwd(); var cache_dir = cwd.makeOpenPath("zig-cache", .{}) catch @panic("unable to make tmp dir for testing: unable to make and open zig-cache dir"); defer cache_dir.close(); - var parent_dir = cache_dir.makeOpenPath("tmp", .{}) catch + const parent_dir = cache_dir.makeOpenPath("tmp", .{}) catch @panic("unable to make tmp dir for testing: unable to make and open zig-cache/tmp dir"); - var dir = parent_dir.makeOpenPathIterable(&sub_path, opts) catch + const dir = parent_dir.makeOpenPathIterable(&sub_path, opts) catch @panic("unable to make tmp dir for testing: unable to make and open the tmp dir"); return .{ @@ -618,8 +618,8 @@ test "expectEqual nested array" { } test "expectEqual vector" { - var a: @Vector(4, u32) = @splat(4); - var b: @Vector(4, u32) = @splat(4); + const a: @Vector(4, u32) = @splat(4); + const b: @Vector(4, u32) = @splat(4); try expectEqual(a, b); } diff --git a/lib/std/treap.zig b/lib/std/treap.zig index 383dc1802a..a555b49495 100644 --- a/lib/std/treap.zig +++ b/lib/std/treap.zig @@ -379,7 +379,7 @@ test "std.Treap: insert, find, replace, remove" { const key = node.key; // find the entry by-key and by-node after having been inserted. - var entry = treap.getEntryFor(node.key); + const entry = treap.getEntryFor(node.key); try testing.expectEqual(entry.key, key); try testing.expectEqual(entry.node, node); try testing.expectEqual(entry.node, treap.getEntryForExisting(node).node); diff --git a/lib/std/unicode.zig b/lib/std/unicode.zig index bd73a3bea3..2eadccda9e 100644 --- a/lib/std/unicode.zig +++ b/lib/std/unicode.zig @@ -242,7 +242,7 @@ pub fn utf8ValidateSlice(input: []const u8) bool { s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, }; - var n = remaining.len; + const n = remaining.len; var i: usize = 0; while (i < n) { const first_byte = remaining[i]; diff --git a/lib/std/zig/Parse.zig b/lib/std/zig/Parse.zig index 0187c09108..cc4f296229 100644 --- a/lib/std/zig/Parse.zig +++ b/lib/std/zig/Parse.zig @@ -3516,7 +3516,6 @@ fn parsePtrModifiers(p: *Parse) !PtrModifiers { var saw_const = false; var saw_volatile = false; var saw_allowzero = false; - var saw_addrspace = false; while (true) { switch (p.token_tags[p.tok_i]) { .keyword_align => { @@ -3557,7 +3556,7 @@ fn parsePtrModifiers(p: *Parse) !PtrModifiers { saw_allowzero = true; }, .keyword_addrspace => { - if (saw_addrspace) { + if (result.addrspace_node != 0) { try p.warn(.extra_addrspace_qualifier); } result.addrspace_node = try p.parseAddrSpace(); diff --git a/lib/std/zig/c_translation.zig b/lib/std/zig/c_translation.zig index 9a700a7a97..e9581b9e41 100644 --- a/lib/std/zig/c_translation.zig +++ b/lib/std/zig/c_translation.zig @@ -129,6 +129,7 @@ test "cast" { try testing.expectEqual(@as(?*anyopaque, @ptrFromInt(2)), cast(?*anyopaque, @as(*u8, @ptrFromInt(2)))); var foo: c_int = -1; + _ = &foo; try testing.expect(cast(*anyopaque, -1) == @as(*anyopaque, @ptrFromInt(@as(usize, @bitCast(@as(isize, -1)))))); try testing.expect(cast(*anyopaque, foo) == @as(*anyopaque, @ptrFromInt(@as(usize, @bitCast(@as(isize, -1)))))); try testing.expect(cast(?*anyopaque, -1) == @as(?*anyopaque, @ptrFromInt(@as(usize, @bitCast(@as(isize, -1)))))); @@ -601,22 +602,22 @@ test "WL_CONTAINER_OF" { a: u32 = 0, b: u32 = 0, }; - var x = S{}; - var y = S{}; - var ptr = Macros.WL_CONTAINER_OF(&x.b, &y, "b"); + const x = S{}; + const y = S{}; + const ptr = Macros.WL_CONTAINER_OF(&x.b, &y, "b"); try testing.expectEqual(&x, ptr); } test "CAST_OR_CALL casting" { - var arg = @as(c_int, 1000); - var casted = Macros.CAST_OR_CALL(u8, arg); + const arg: c_int = 1000; + const casted = Macros.CAST_OR_CALL(u8, arg); try testing.expectEqual(cast(u8, arg), casted); const S = struct { x: u32 = 0, }; - var s = S{}; - var casted_ptr = Macros.CAST_OR_CALL(*u8, &s); + var s: S = .{}; + const casted_ptr = Macros.CAST_OR_CALL(*u8, &s); try testing.expectEqual(cast(*u8, &s), casted_ptr); } diff --git a/lib/std/zig/perf_test.zig b/lib/std/zig/perf_test.zig index a53dee7fa8..2a893013d9 100644 --- a/lib/std/zig/perf_test.zig +++ b/lib/std/zig/perf_test.zig @@ -32,7 +32,7 @@ pub fn main() !void { fn testOnce() usize { var fixed_buf_alloc = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]); - var allocator = fixed_buf_alloc.allocator(); + const allocator = fixed_buf_alloc.allocator(); _ = std.zig.Ast.parse(allocator, source, .zig) catch @panic("parse failure"); return fixed_buf_alloc.end_index; } diff --git a/lib/std/zig/render.zig b/lib/std/zig/render.zig index d6e862a922..23e5ee83b4 100644 --- a/lib/std/zig/render.zig +++ b/lib/std/zig/render.zig @@ -3495,7 +3495,7 @@ fn AutoIndentingStream(comptime UnderlyingWriter: type) type { /// Turns all one-shot indents into regular indents /// Returns number of indents that must now be manually popped pub fn lockOneShotIndent(self: *Self) usize { - var locked_count = self.indent_one_shot_count; + const locked_count = self.indent_one_shot_count; self.indent_one_shot_count = 0; return locked_count; } diff --git a/lib/std/zig/string_literal.zig b/lib/std/zig/string_literal.zig index 53b1ab7ca8..8ba2fc2f65 100644 --- a/lib/std/zig/string_literal.zig +++ b/lib/std/zig/string_literal.zig @@ -288,7 +288,7 @@ test "parse" { var fixed_buf_mem: [64]u8 = undefined; var fixed_buf_alloc = std.heap.FixedBufferAllocator.init(&fixed_buf_mem); - var alloc = fixed_buf_alloc.allocator(); + const alloc = fixed_buf_alloc.allocator(); try expectError(error.InvalidLiteral, parseAlloc(alloc, "\"\\x6\"")); try expect(eql(u8, "foo\nbar", try parseAlloc(alloc, "\"foo\\nbar\""))); diff --git a/lib/std/zig/system/NativeTargetInfo.zig b/lib/std/zig/system/NativeTargetInfo.zig index ba0d699f91..88a8a3742e 100644 --- a/lib/std/zig/system/NativeTargetInfo.zig +++ b/lib/std/zig/system/NativeTargetInfo.zig @@ -189,7 +189,7 @@ pub fn detect(cross_target: CrossTarget) DetectError!NativeTargetInfo { // native CPU architecture as being different than the current target), we use this: const cpu_arch = cross_target.getCpuArch(); - var cpu = switch (cross_target.cpu_model) { + const cpu = switch (cross_target.cpu_model) { .native => detectNativeCpuAndFeatures(cpu_arch, os, cross_target), .baseline => Target.Cpu.baseline(cpu_arch), .determined_by_cpu_arch => if (cross_target.cpu_arch == null)