From 64e4f9db8fa6fc47b0a2ef3143edacf472fb8c48 Mon Sep 17 00:00:00 2001 From: CMDRZero Date: Wed, 17 Sep 2025 19:49:34 -0700 Subject: [PATCH] Implement partially ordered operator precedence --- lib/c/math.zig | 4 +- lib/c/stdlib/drand48.zig | 12 +- lib/compiler/Maker/Step/Compile.zig | 2 +- lib/compiler/aro/aro/Compilation.zig | 6 +- lib/compiler/aro/aro/Driver.zig | 2 +- lib/compiler/aro/aro/Parser.zig | 2 +- lib/compiler/aro/aro/Preprocessor.zig | 6 +- lib/compiler/aro/aro/Preprocessor/Parser.zig | 2 +- lib/compiler/aro/aro/char_info.zig | 4 +- lib/compiler/aro/aro/record_layout.zig | 2 +- lib/compiler_rt/absv.zig | 2 +- lib/compiler_rt/addf3.zig | 2 +- lib/compiler_rt/atomics.zig | 2 +- lib/compiler_rt/comparef.zig | 8 +- lib/compiler_rt/divdf3.zig | 16 +- lib/compiler_rt/divsf3.zig | 14 +- lib/compiler_rt/divtf3.zig | 20 +- lib/compiler_rt/divxf3.zig | 20 +- lib/compiler_rt/elf/tls.zig | 2 +- lib/compiler_rt/extendf.zig | 4 +- lib/compiler_rt/floor_ceil.zig | 8 +- lib/compiler_rt/fmod.zig | 4 +- lib/compiler_rt/mulf3.zig | 2 +- lib/compiler_rt/rem_pio2l.zig | 2 +- lib/compiler_rt/sqrt.zig | 10 +- lib/compiler_rt/truncf.zig | 6 +- lib/std/Io/Dispatch.zig | 4 +- lib/std/Io/Kqueue.zig | 2 +- lib/std/Io/Threaded/test.zig | 2 +- lib/std/Io/Writer.zig | 2 +- lib/std/Io/net/HostName.zig | 2 +- lib/std/base64.zig | 6 +- lib/std/bit_set.zig | 8 +- lib/std/coff.zig | 2 +- lib/std/compress/flate/Compress.zig | 4 +- lib/std/crypto/aes/soft.zig | 2 +- lib/std/crypto/codecs/base64_hex_ct.zig | 2 +- lib/std/crypto/ml_kem.zig | 2 +- lib/std/crypto/scrypt.zig | 2 +- lib/std/crypto/sha2.zig | 2 +- lib/std/debug.zig | 2 +- lib/std/debug/SelfInfo/Elf.zig | 8 +- lib/std/debug/SelfInfo/MachO.zig | 4 +- lib/std/debug/SelfInfo/Windows.zig | 8 +- lib/std/dynamic_library.zig | 14 +- lib/std/fmt/parse_float/common.zig | 2 +- lib/std/hash/cityhash.zig | 2 +- lib/std/hash/xxhash.zig | 2 +- lib/std/hash_map.zig | 2 +- lib/std/heap/SafeAllocator.zig | 2 +- lib/std/math.zig | 28 +- lib/std/math/acos.zig | 2 +- lib/std/math/asin.zig | 2 +- lib/std/math/big/int.zig | 6 +- lib/std/math/big/int_test.zig | 32 +- lib/std/math/float.zig | 4 +- lib/std/mem.zig | 2 +- lib/std/os/linux/vdso.zig | 8 +- lib/std/os/uefi/status.zig | 2 +- lib/std/unicode.zig | 2 +- lib/std/zig/Ast.zig | 32 ++ lib/std/zig/Ast/Render.zig | 6 +- lib/std/zig/Parse.zig | 355 ++++++++++++++++--- lib/std/zig/TokenSmith.zig | 2 +- lib/std/zig/llvm/BitcodeReader.zig | 2 +- lib/std/zig/llvm/Builder.zig | 52 +-- lib/std/zig/llvm/bitcode_writer.zig | 2 +- lib/std/zig/parser_test.zig | 48 ++- lib/std/zig/system.zig | 10 +- lib/std/zig/system/windows.zig | 4 +- src/Air.zig | 2 +- src/Compilation.zig | 4 +- src/IncrementalDebugServer.zig | 4 +- src/InternPool.zig | 36 +- src/Sema.zig | 4 +- src/codegen/aarch64/Assemble.zig | 4 +- src/codegen/aarch64/Disassemble.zig | 8 +- src/codegen/aarch64/Mir.zig | 6 +- src/codegen/aarch64/Select.zig | 8 +- src/codegen/aarch64/encoding.zig | 38 +- src/codegen/loongarch/Mir.zig | 2 +- src/codegen/riscv64/CodeGen.zig | 4 +- src/codegen/riscv64/encoding.zig | 4 +- src/codegen/sparc64/CodeGen.zig | 4 +- src/codegen/spirv/CodeGen.zig | 2 +- src/codegen/x86_64/CodeGen.zig | 34 +- src/codegen/x86_64/Disassembler.zig | 2 +- src/codegen/x86_64/Emit.zig | 12 +- src/codegen/x86_64/Mir.zig | 2 +- src/codegen/x86_64/bits.zig | 2 +- src/codegen/x86_64/encoder.zig | 28 +- src/fmt.zig | 3 +- src/link/Dwarf.zig | 6 +- src/link/Dwarf2.zig | 4 +- src/link/Elf2.zig | 8 +- src/link/MachO/UnwindInfo.zig | 2 +- src/link/MachO/load_commands.zig | 4 +- src/link/Wasm/Flush.zig | 2 +- src/link/riscv.zig | 4 +- src/main.zig | 2 +- test/Runner.zig | 8 +- test/behavior/bitcast.zig | 2 +- test/behavior/error.zig | 2 +- test/behavior/math.zig | 6 +- test/behavior/try.zig | 6 +- test/behavior/x86_64/binary.zig | 4 +- test/behavior/x86_64/cast.zig | 8 +- tools/loongarch/OpcodeDesc.zig | 4 +- 108 files changed, 727 insertions(+), 411 deletions(-) diff --git a/lib/c/math.zig b/lib/c/math.zig index f9073add14799636be748725d54cf786e84c45aa..f5fdd126cda9ac2cd9d2be8f82235fa972c907fd 100644 --- a/lib/c/math.zig +++ b/lib/c/math.zig @@ -355,7 +355,7 @@ fn pow10f(x: f32) callconv(.c) f32 { fn rint(x: f64) callconv(.c) f64 { const toint: f64 = 1.0 / math.floatEps(f64); const a: u64 = @bitCast(x); - const e = a >> 52 & 0x7ff; + const e = (a >> 52) & 0x7ff; const s = a >> 63; var y: f64 = undefined; @@ -376,7 +376,7 @@ fn rint(x: f64) callconv(.c) f64 { fn rintf(x: f32) callconv(.c) f32 { const toint: f32 = 1.0 / math.floatEps(f32); const a: u32 = @bitCast(x); - const e = a >> 23 & 0xff; + const e = (a >> 23) & 0xff; const s = a >> 31; var y: f32 = undefined; diff --git a/lib/c/stdlib/drand48.zig b/lib/c/stdlib/drand48.zig index 46e72de0b901d45fab48ad0f8d3eafc5e56281d5..ce148a9a1524bb9d3399739755b68397eda3baea 100644 --- a/lib/c/stdlib/drand48.zig +++ b/lib/c/stdlib/drand48.zig @@ -30,7 +30,7 @@ var lcg: Lcg = .init(0, default_multiplier, default_addend); var seed48_xi: [3]c_ushort = undefined; fn erand48(xsubi: *[3]c_ushort) callconv(.c) f64 { - const xi = @as(u48, @as(u16, @truncate(xsubi[0])) | (@as(u48, @as(u16, @truncate(xsubi[1])))) << 16) | (@as(u48, @as(u16, @truncate(xsubi[2]))) << 32); + const xi = @as(u48, @as(u16, @truncate(xsubi[0])) | ((@as(u48, @as(u16, @truncate(xsubi[1])))) << 16)) | (@as(u48, @as(u16, @truncate(xsubi[2]))) << 32); var separate_lcg: Lcg = .init(xi, lcg.a, lcg.c); const next_xi = separate_lcg.next(); @@ -40,7 +40,7 @@ fn erand48(xsubi: *[3]c_ushort) callconv(.c) f64 { } fn jrand48(xsubi: *[3]c_ushort) callconv(.c) c_long { - const xi = @as(u48, @as(u16, @truncate(xsubi[0])) | (@as(u48, @as(u16, @truncate(xsubi[1])))) << 16) | (@as(u48, @as(u16, @truncate(xsubi[2]))) << 32); + const xi = @as(u48, @as(u16, @truncate(xsubi[0])) | ((@as(u48, @as(u16, @truncate(xsubi[1])))) << 16)) | (@as(u48, @as(u16, @truncate(xsubi[2]))) << 32); var separate_lcg: Lcg = .init(xi, lcg.a, lcg.c); const next_xi = separate_lcg.next(); @@ -50,7 +50,7 @@ fn jrand48(xsubi: *[3]c_ushort) callconv(.c) c_long { } fn nrand48(xsubi: *[3]c_ushort) callconv(.c) c_long { - const xi = @as(u48, @as(u16, @truncate(xsubi[0])) | (@as(u48, @as(u16, @truncate(xsubi[1])))) << 16) | (@as(u48, @as(u16, @truncate(xsubi[2]))) << 32); + const xi = @as(u48, @as(u16, @truncate(xsubi[0])) | ((@as(u48, @as(u16, @truncate(xsubi[1])))) << 16)) | (@as(u48, @as(u16, @truncate(xsubi[2]))) << 32); var separate_lcg: Lcg = .init(xi, lcg.a, lcg.c); const next_xi = separate_lcg.next(); @@ -74,14 +74,14 @@ fn mrand48() callconv(.c) c_long { // 0..3 is `Xi`, 3..6 is `a`, 6 is `c` // first low 16-bits, then mid, then high. fn lcong48(param: *[7]c_ushort) callconv(.c) void { - lcg.xi = (@as(u48, @as(u16, @truncate(param[0]))) | (@as(u48, @as(u16, @truncate(param[1])))) << 16) | (@as(u48, @as(u16, @truncate(param[2]))) << 32); - lcg.a = (@as(u48, @as(u16, @truncate(param[3]))) | (@as(u48, @as(u16, @truncate(param[4])))) << 16) | (@as(u48, @as(u16, @truncate(param[5]))) << 32); + lcg.xi = (@as(u48, @as(u16, @truncate(param[0]))) | ((@as(u48, @as(u16, @truncate(param[1])))) << 16)) | (@as(u48, @as(u16, @truncate(param[2]))) << 32); + lcg.a = (@as(u48, @as(u16, @truncate(param[3]))) | ((@as(u48, @as(u16, @truncate(param[4])))) << 16)) | (@as(u48, @as(u16, @truncate(param[5]))) << 32); lcg.c = @as(u16, @truncate(param[6])); } fn seed48(seed16v: *[3]c_ushort) callconv(.c) *[3]c_ushort { seed48_xi = .{ @truncate(lcg.xi & 0xFFFF), @truncate((lcg.xi >> 16) & 0xFFFF), @truncate((lcg.xi >> 32) & 0xFFFF) }; - const xi = (@as(u48, @as(u16, @truncate(seed16v[0]))) | (@as(u48, @as(u16, @truncate(seed16v[1])))) << 16) | (@as(u48, @as(u16, @truncate(seed16v[2]))) << 32); + const xi = (@as(u48, @as(u16, @truncate(seed16v[0]))) | ((@as(u48, @as(u16, @truncate(seed16v[1])))) << 16)) | (@as(u48, @as(u16, @truncate(seed16v[2]))) << 32); lcg = .init(xi, default_multiplier, default_addend); return &seed48_xi; } diff --git a/lib/compiler/Maker/Step/Compile.zig b/lib/compiler/Maker/Step/Compile.zig index 7e25860277b72a91cf62d23877325cd41ef85a09..8c6ab5fe30c55becc28af17276c89b3f4baca121 100644 --- a/lib/compiler/Maker/Step/Compile.zig +++ b/lib/compiler/Maker/Step/Compile.zig @@ -45,7 +45,7 @@ pub fn make( try lowerZigArgs(arena, compile_index, maker, progress_node, &argv, false); - const incremental = conf_comp.flags4.incremental.toBool() orelse graph.incremental == true; + const incremental = conf_comp.flags4.incremental.toBool() orelse graph.incremental orelse false; const opt_cache_digest = Step.evalZigProcess( compile_index, diff --git a/lib/compiler/aro/aro/Compilation.zig b/lib/compiler/aro/aro/Compilation.zig index 39cbb1c0b955e61c3b11779f9a1a42ca4a6da2ba..8d893abfc38bdb4200447838ceee77f7693fb75e 100644 --- a/lib/compiler/aro/aro/Compilation.zig +++ b/lib/compiler/aro/aro/Compilation.zig @@ -287,7 +287,7 @@ fn generateSystemDefines(comp: *Compilation, w: *Io.Writer) !void { const gnuc_version = comp.langopts.gnuc_version orelse comp.langopts.emulate.defaultGccVersion(); if (gnuc_version > 0) { try w.print("#define __GNUC__ {d}\n", .{gnuc_version / 10_000}); - try w.print("#define __GNUC_MINOR__ {d}\n", .{gnuc_version / 100 % 100}); + try w.print("#define __GNUC_MINOR__ {d}\n", .{(gnuc_version / 100) % 100}); try w.print("#define __GNUC_PATCHLEVEL__ {d}\n", .{gnuc_version % 100}); } @@ -962,7 +962,7 @@ fn generateSystemDefines(comp: *Compilation, w: *Io.Writer) !void { try define(w, "__ARM_ARCH_EXT_IDIV__"); } var sat = false; - if (arm_version == 6 and !target.cpu.has(.arm, .mclass) or arm_version > 6) { + if ((arm_version == 6 and !target.cpu.has(.arm, .mclass)) or arm_version > 6) { try define(w, "__ARM_FEATURE_SAT"); sat = true; } @@ -2856,7 +2856,7 @@ test "addSourceFromBuffer - exhaustive check for carriage return elimination" { if (buf[j] == alphabet[0]) buf[j - 1] = alphabet[(idx + 1) % alen] else break; } } - try std.testing.expect(source_count == std.math.powi(usize, alen, alen) catch unreachable); + try std.testing.expect(source_count == (std.math.powi(usize, alen, alen) catch unreachable)); } test "ignore BOM at beginning of file" { diff --git a/lib/compiler/aro/aro/Driver.zig b/lib/compiler/aro/aro/Driver.zig index b41a7a191135c0ee0402b90ac2e54e631f641c3a..0313cb62cb2db62735977ed5fed8b5d4b5c4b15f 100644 --- a/lib/compiler/aro/aro/Driver.zig +++ b/lib/compiler/aro/aro/Driver.zig @@ -1373,7 +1373,7 @@ fn getOutFileName(d: *Driver, source: Source, buf: *[std.fs.max_name_bytes]u8) ! if (d.only_preprocess_and_compile) ".s" else d.comp.target.ofmt.fileExt(d.comp.target.cpu.arch), }; return d.output_name orelse - mem.print(buf, fmt_template, fmt_args) catch return d.fatal("Filename too long for filesystem: " ++ fmt_template, fmt_args); + (mem.print(buf, fmt_template, fmt_args) catch return d.fatal("Filename too long for filesystem: " ++ fmt_template, fmt_args)); } return d.getRandomFilename(buf, d.comp.target.ofmt.fileExt(d.comp.target.cpu.arch)); diff --git a/lib/compiler/aro/aro/Parser.zig b/lib/compiler/aro/aro/Parser.zig index d6a48966f28db2edf53b019a084b3704ca0528e8..0405c0536e8795eb02d9a4427cf91fd24cbc66fc 100644 --- a/lib/compiler/aro/aro/Parser.zig +++ b/lib/compiler/aro/aro/Parser.zig @@ -7084,7 +7084,7 @@ pub const Result = struct { const b_child_qt = b.qt.get(p.comp, .pointer).?.child; if (!a_child_qt.eql(b_child_qt, p.comp)) try p.err(tok, .incompatible_pointers, .{ a.qt, b.qt }); - if (a.qt.childType(p.comp).sizeofOrNull(p.comp) orelse 1 == 0) try p.err(tok, .subtract_pointers_zero_elem_size, .{a.qt.childType(p.comp)}); + if ((a.qt.childType(p.comp).sizeofOrNull(p.comp) orelse 1) == 0) try p.err(tok, .subtract_pointers_zero_elem_size, .{a.qt.childType(p.comp)}); a.qt = p.comp.type_store.ptrdiff; } diff --git a/lib/compiler/aro/aro/Preprocessor.zig b/lib/compiler/aro/aro/Preprocessor.zig index 5df5c1c8f9969ff25b83cf11e5b1610f8e14a725..98f0b7a004c2950383278beb89a45e6204daa806 100644 --- a/lib/compiler/aro/aro/Preprocessor.zig +++ b/lib/compiler/aro/aro/Preprocessor.zig @@ -310,13 +310,13 @@ pub const InitOptions = struct { }; pub fn init(comp: *Compilation, options: InitOptions) !Preprocessor { - const source_epoch: SourceEpoch = options.source_epoch orelse comp.environment.sourceEpoch(comp.io) catch |er| switch (er) { + const source_epoch: SourceEpoch = options.source_epoch orelse (comp.environment.sourceEpoch(comp.io) catch |er| switch (er) { error.InvalidEpoch => blk: { const diagnostic: Diagnostic = .invalid_source_epoch; try comp.diagnostics.add(.{ .text = diagnostic.fmt, .kind = diagnostic.kind, .opt = diagnostic.opt, .location = null }); break :blk .default; }, - }; + }); var pp: Preprocessor = .{ .comp = comp, @@ -3882,7 +3882,7 @@ pub fn prettyPrintTokens(pp: *Preprocessor, w: *std.Io.Writer, macro_dump_mode: }, .keyword_pragma => { const pragma_name = pp.expandedSlice(pp.tokens.get(i + 1)); - const end_idx = mem.findScalarPos(Token.Id, tok_ids, i, .nl) orelse i + 1; + const end_idx = mem.findScalarPos(Token.Id, tok_ids, i, .nl) orelse (i + 1); const pragma_len = @as(u32, @intCast(end_idx)) - i; if (pp.comp.getPragma(pragma_name)) |prag| { diff --git a/lib/compiler/aro/aro/Preprocessor/Parser.zig b/lib/compiler/aro/aro/Preprocessor/Parser.zig index c4b3f60c5908bb220e876b63105156421ce6cdd4..c9a964b44ce5ac3e48cf3ca711218d478d8ff46c 100644 --- a/lib/compiler/aro/aro/Preprocessor/Parser.zig +++ b/lib/compiler/aro/aro/Preprocessor/Parser.zig @@ -323,7 +323,7 @@ fn binaryExpr(p: *Parser, min_prec: Token.Precedence, eval: bool) Error!?Value { const else_res = try p.binaryExpr(op_prec, eval_else) orelse return null; lhs = if (lhs.toBool()) rhs else else_res; - if (eval and rhs == .unsigned or else_res == .unsigned) { + if ((eval and rhs == .unsigned) or else_res == .unsigned) { try lhs.toUnsigned(p, operator, "right"); } }, diff --git a/lib/compiler/aro/aro/char_info.zig b/lib/compiler/aro/aro/char_info.zig index a4d5857c80e3d69cc72dd318a52f6f5de0da95db..b8a41a53ba05baf0c5bfe96cf02751bfe8fbdfbf 100644 --- a/lib/compiler/aro/aro/char_info.zig +++ b/lib/compiler/aro/aro/char_info.zig @@ -492,7 +492,7 @@ pub fn isXidStart(c: u21) bool { assert(c > 0x7F); const idx = c / 8 / tables.chunk; const chunk: usize = if (idx < tables.trie_start.len) tables.trie_start[idx] else 0; - const offset = chunk * tables.chunk / 2 + c / 8 % tables.chunk; + const offset = chunk * tables.chunk / 2 + (c / 8) % tables.chunk; return (tables.leaf[offset] >> (@as(u3, @intCast(c % 8)))) & 1 != 0; } @@ -500,7 +500,7 @@ pub fn isXidContinue(c: u21) bool { assert(c > 0x7F); const idx = c / 8 / tables.chunk; const chunk: usize = if (idx < tables.trie_continue.len) tables.trie_continue[idx] else 0; - const offset = chunk * tables.chunk / 2 + c / 8 % tables.chunk; + const offset = chunk * tables.chunk / 2 + (c / 8) % tables.chunk; return (tables.leaf[offset] >> (@as(u3, @intCast(c % 8)))) & 1 != 0; } diff --git a/lib/compiler/aro/aro/record_layout.zig b/lib/compiler/aro/aro/record_layout.zig index be725952ee63f3a5eb34826954b02d91d0f983df..ce37449c7b7e30fe6cfd863b27eeb96fa6877c45 100644 --- a/lib/compiler/aro/aro/record_layout.zig +++ b/lib/compiler/aro/aro/record_layout.zig @@ -324,7 +324,7 @@ const SysVContext = struct { // On Clang, the alignment requested by annotations is not respected if it is // larger than the value of #pragma pack. See test case 0083. - if (annotation_alignment <= self.max_field_align_bits orelse std.math.maxInt(u29)) { + if (annotation_alignment <= (self.max_field_align_bits orelse std.math.maxInt(u29))) { field_align_bits = @max(field_align_bits, annotation_alignment); } // On Clang, if there are no packing annotations and the field would cross a diff --git a/lib/compiler_rt/absv.zig b/lib/compiler_rt/absv.zig index 4621835dd6f6abd9cdb37a53231e88139556eb9a..b430b7c710b00305ea0ab9f98df83be49c84437d 100644 --- a/lib/compiler_rt/absv.zig +++ b/lib/compiler_rt/absv.zig @@ -11,7 +11,7 @@ pub inline fn absv(comptime ST: type, a: ST) ST { // compute the integer absolute value (abs) without branching var x: ST = a; const N: UT = @bitSizeOf(ST); - const sign: ST = a >> N - 1; + const sign: ST = a >> (N - 1); x +%= sign; x ^= sign; if (x < 0) @panic("integer overflow"); diff --git a/lib/compiler_rt/addf3.zig b/lib/compiler_rt/addf3.zig index 189f7afd6d02c78bdb63de8e38ca7731c96684d4..37c4f639fffe9c27e47c51359ae898c71d21cc73 100644 --- a/lib/compiler_rt/addf3.zig +++ b/lib/compiler_rt/addf3.zig @@ -259,7 +259,7 @@ inline fn addf3(comptime T: type, a: T, b: T) T { // adjust the exponent: if (aSignificand & (integerBit << 4) != 0) { const sticky = aSignificand & 1; - aSignificand = aSignificand >> 1 | sticky; + aSignificand = (aSignificand >> 1) | sticky; aExponent += 1; } } diff --git a/lib/compiler_rt/atomics.zig b/lib/compiler_rt/atomics.zig index 8b7861537a06cc8c9c9075f3faba1bba9488a709..f04eb95090dffb3428cd377ec5cedc7dee4dfc24 100644 --- a/lib/compiler_rt/atomics.zig +++ b/lib/compiler_rt/atomics.zig @@ -241,7 +241,7 @@ fn wideUpdate(comptime T: type, ptr: *T, val: T, update: anytype) T { while (true) { const old = @as(T, @truncate((wide_old & mask) >> inner_shift)); const new = update(val, old); - const wide_new = wide_old & ~mask | (@as(WideAtomic, new) << inner_shift); + const wide_new = (wide_old & ~mask) | (@as(WideAtomic, new) << inner_shift); if (@cmpxchgWeak(WideAtomic, wide_ptr, wide_old, wide_new, .seq_cst, .seq_cst)) |new_wide_old| { wide_old = new_wide_old; } else { diff --git a/lib/compiler_rt/comparef.zig b/lib/compiler_rt/comparef.zig index d230e9a6b42f8ef88114e4d72b838f3f47c01cec..af9d298ce15f38e1ab5f54335516c6d447a22e6f 100644 --- a/lib/compiler_rt/comparef.zig +++ b/lib/compiler_rt/comparef.zig @@ -130,13 +130,13 @@ fn __aeabi_fcmplt(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 { return @intFromBool(cmp_f32(a, b) == .lt); } fn __aeabi_fcmple(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 { - return @intFromBool(cmp_f32(a, b) orelse .gt != .gt); + return @intFromBool((cmp_f32(a, b) orelse .gt) != .gt); } fn __gesf2(a: compiler_rt.f32.Abi, b: compiler_rt.f32.Abi) callconv(.c) Order { return cmp_f32(compiler_rt.f32.fromAbi(a), compiler_rt.f32.fromAbi(b)) orelse .lt; } fn __aeabi_fcmpge(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 { - return @intFromBool(cmp_f32(a, b) orelse .lt != .lt); + return @intFromBool((cmp_f32(a, b) orelse .lt) != .lt); } fn __aeabi_fcmpgt(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 { return @intFromBool(cmp_f32(a, b) == .gt); @@ -164,13 +164,13 @@ fn __aeabi_dcmplt(a: f64, b: f64) callconv(.{ .arm_aapcs = .{} }) i32 { return @intFromBool(cmp_f64(a, b) == .lt); } fn __aeabi_dcmple(a: f64, b: f64) callconv(.{ .arm_aapcs = .{} }) i32 { - return @intFromBool(cmp_f64(a, b) orelse .gt != .gt); + return @intFromBool((cmp_f64(a, b) orelse .gt) != .gt); } fn __gedf2(a: compiler_rt.f64.Abi, b: compiler_rt.f64.Abi) callconv(.c) Order { return cmp_f64(compiler_rt.f64.fromAbi(a), compiler_rt.f64.fromAbi(b)) orelse .lt; } fn __aeabi_dcmpge(a: f64, b: f64) callconv(.{ .arm_aapcs = .{} }) i32 { - return @intFromBool(cmp_f64(a, b) orelse .lt != .lt); + return @intFromBool((cmp_f64(a, b) orelse .lt) != .lt); } fn __aeabi_dcmpgt(a: f64, b: f64) callconv(.{ .arm_aapcs = .{} }) i32 { return @intFromBool(cmp_f64(a, b) == .gt); diff --git a/lib/compiler_rt/divdf3.zig b/lib/compiler_rt/divdf3.zig index 90953e0d0616d6a211872eef0b0c18ba1ff0cdb4..cb390ef03e96971878fd7ffa49d3c9e2f748f757 100644 --- a/lib/compiler_rt/divdf3.zig +++ b/lib/compiler_rt/divdf3.zig @@ -119,12 +119,12 @@ pub fn div_f64(a: f64, b: f64) f64 { // with each iteration, so after three iterations, we have about 28 binary // digits of accuracy. var correction32: u32 = undefined; - correction32 = @truncate(~(@as(u64, recip32) *% q31b >> 32) +% 1); - recip32 = @truncate(@as(u64, recip32) *% correction32 >> 31); - correction32 = @truncate(~(@as(u64, recip32) *% q31b >> 32) +% 1); - recip32 = @truncate(@as(u64, recip32) *% correction32 >> 31); - correction32 = @truncate(~(@as(u64, recip32) *% q31b >> 32) +% 1); - recip32 = @truncate(@as(u64, recip32) *% correction32 >> 31); + correction32 = @truncate(~((@as(u64, recip32) *% q31b) >> 32) +% 1); + recip32 = @truncate((@as(u64, recip32) *% correction32) >> 31); + correction32 = @truncate(~((@as(u64, recip32) *% q31b) >> 32) +% 1); + recip32 = @truncate((@as(u64, recip32) *% correction32) >> 31); + correction32 = @truncate(~((@as(u64, recip32) *% q31b) >> 32) +% 1); + recip32 = @truncate((@as(u64, recip32) *% correction32) >> 31); // recip32 might have overflowed to exactly zero in the preceding // computation if the high word of b is exactly 1.0. This would sabotage @@ -137,10 +137,10 @@ pub fn div_f64(a: f64, b: f64) f64 { const q63blo: u32 = @truncate(bSignificand << 11); var correction: u64 = undefined; var reciprocal: u64 = undefined; - correction = ~(@as(u64, recip32) *% q31b +% (@as(u64, recip32) *% q63blo >> 32)) +% 1; + correction = ~(@as(u64, recip32) *% q31b +% ((@as(u64, recip32) *% q63blo) >> 32)) +% 1; const cHi: u32 = @truncate(correction >> 32); const cLo: u32 = @truncate(correction); - reciprocal = @as(u64, recip32) *% cHi +% (@as(u64, recip32) *% cLo >> 32); + reciprocal = @as(u64, recip32) *% cHi +% ((@as(u64, recip32) *% cLo) >> 32); // We already adjusted the 32-bit estimate, now we need to adjust the final // 64-bit reciprocal estimate downward to ensure that it is strictly smaller diff --git a/lib/compiler_rt/divsf3.zig b/lib/compiler_rt/divsf3.zig index c86c860948d315b260498c959e4678f5f64b9e94..bee27aef4b93258021e6160b172b6f7decdb5a56 100644 --- a/lib/compiler_rt/divsf3.zig +++ b/lib/compiler_rt/divsf3.zig @@ -126,12 +126,12 @@ pub fn div_f32(a: f32, b: f32) f32 { // with each iteration, so after three iterations, we have about 28 binary // digits of accuracy. var correction: u32 = undefined; - correction = @truncate(~(@as(u64, reciprocal) *% q31b >> 32) +% 1); - reciprocal = @truncate(@as(u64, reciprocal) *% correction >> 31); - correction = @truncate(~(@as(u64, reciprocal) *% q31b >> 32) +% 1); - reciprocal = @truncate(@as(u64, reciprocal) *% correction >> 31); - correction = @truncate(~(@as(u64, reciprocal) *% q31b >> 32) +% 1); - reciprocal = @truncate(@as(u64, reciprocal) *% correction >> 31); + correction = @truncate(~((@as(u64, reciprocal) *% q31b) >> 32) +% 1); + reciprocal = @truncate((@as(u64, reciprocal) *% correction) >> 31); + correction = @truncate(~((@as(u64, reciprocal) *% q31b) >> 32) +% 1); + reciprocal = @truncate((@as(u64, reciprocal) *% correction) >> 31); + correction = @truncate(~((@as(u64, reciprocal) *% q31b) >> 32) +% 1); + reciprocal = @truncate((@as(u64, reciprocal) *% correction) >> 31); // Exhaustive testing shows that the error in reciprocal after three steps // is in the interval [-0x1.f58108p-31, 0x1.d0e48cp-29], in line with our @@ -153,7 +153,7 @@ pub fn div_f32(a: f32, b: f32) f32 { // is the error in the reciprocal of b scaled by the maximum // possible value of a. As a consequence of this error bound, // either q or nextafter(q) is the correctly rounded - var quotient: Z = @truncate(@as(u64, reciprocal) *% (aSignificand << 1) >> 32); + var quotient: Z = @truncate((@as(u64, reciprocal) *% (aSignificand << 1)) >> 32); // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0). // In either case, we are going to compute a residual of the form diff --git a/lib/compiler_rt/divtf3.zig b/lib/compiler_rt/divtf3.zig index 9995a9bfd796070d9573ac050bf233c9646a5d98..e7b0164451f51b60bed8edd51cec07000588e073 100644 --- a/lib/compiler_rt/divtf3.zig +++ b/lib/compiler_rt/divtf3.zig @@ -119,16 +119,16 @@ pub fn div_f128(a: f128, b: f128) f128 { // This doubles the number of correct binary digits in the approximation // with each iteration. var correction64: u64 = undefined; - correction64 = @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1); - recip64 = @truncate(@as(u128, recip64) *% correction64 >> 63); - correction64 = @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1); - recip64 = @truncate(@as(u128, recip64) *% correction64 >> 63); - correction64 = @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1); - recip64 = @truncate(@as(u128, recip64) *% correction64 >> 63); - correction64 = @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1); - recip64 = @truncate(@as(u128, recip64) *% correction64 >> 63); - correction64 = @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1); - recip64 = @truncate(@as(u128, recip64) *% correction64 >> 63); + correction64 = @truncate(~((@as(u128, recip64) *% q63b) >> 64) +% 1); + recip64 = @truncate((@as(u128, recip64) *% correction64) >> 63); + correction64 = @truncate(~((@as(u128, recip64) *% q63b) >> 64) +% 1); + recip64 = @truncate((@as(u128, recip64) *% correction64) >> 63); + correction64 = @truncate(~((@as(u128, recip64) *% q63b) >> 64) +% 1); + recip64 = @truncate((@as(u128, recip64) *% correction64) >> 63); + correction64 = @truncate(~((@as(u128, recip64) *% q63b) >> 64) +% 1); + recip64 = @truncate((@as(u128, recip64) *% correction64) >> 63); + correction64 = @truncate(~((@as(u128, recip64) *% q63b) >> 64) +% 1); + recip64 = @truncate((@as(u128, recip64) *% correction64) >> 63); // The reciprocal may have overflowed to zero if the upper half of b is // exactly 1.0. This would sabatoge the full-width final stage of the diff --git a/lib/compiler_rt/divxf3.zig b/lib/compiler_rt/divxf3.zig index eb3fde6862ab3937e8828d729287a35ea9d3ead9..6921d63da57d547a08e122d55691a3b2328389b6 100644 --- a/lib/compiler_rt/divxf3.zig +++ b/lib/compiler_rt/divxf3.zig @@ -102,16 +102,16 @@ pub fn div_f80(a: f80, b: f80) f80 { // This doubles the number of correct binary digits in the approximation // with each iteration. var correction64: u64 = undefined; - correction64 = @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1); - recip64 = @truncate(@as(u128, recip64) *% correction64 >> 63); - correction64 = @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1); - recip64 = @truncate(@as(u128, recip64) *% correction64 >> 63); - correction64 = @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1); - recip64 = @truncate(@as(u128, recip64) *% correction64 >> 63); - correction64 = @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1); - recip64 = @truncate(@as(u128, recip64) *% correction64 >> 63); - correction64 = @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1); - recip64 = @truncate(@as(u128, recip64) *% correction64 >> 63); + correction64 = @truncate(~((@as(u128, recip64) *% q63b) >> 64) +% 1); + recip64 = @truncate((@as(u128, recip64) *% correction64) >> 63); + correction64 = @truncate(~((@as(u128, recip64) *% q63b) >> 64) +% 1); + recip64 = @truncate((@as(u128, recip64) *% correction64) >> 63); + correction64 = @truncate(~((@as(u128, recip64) *% q63b) >> 64) +% 1); + recip64 = @truncate((@as(u128, recip64) *% correction64) >> 63); + correction64 = @truncate(~((@as(u128, recip64) *% q63b) >> 64) +% 1); + recip64 = @truncate((@as(u128, recip64) *% correction64) >> 63); + correction64 = @truncate(~((@as(u128, recip64) *% q63b) >> 64) +% 1); + recip64 = @truncate((@as(u128, recip64) *% correction64) >> 63); // The reciprocal may have overflowed to zero if the upper half of b is // exactly 1.0. This would sabatoge the full-width final stage of the diff --git a/lib/compiler_rt/elf/tls.zig b/lib/compiler_rt/elf/tls.zig index 944cf394b65e1d629787fd09114dfee02bb080c5..c93dc3d258b0a2dfc639c98ab71195c9a53f6ab1 100644 --- a/lib/compiler_rt/elf/tls.zig +++ b/lib/compiler_rt/elf/tls.zig @@ -251,7 +251,7 @@ fn setThreadPointer(addr: usize) void { // Update the %gs selector asm volatile ("movl %[gs_val], %%gs" : - : [gs_val] "r" (gdt_entry_number << 3 | 3), + : [gs_val] "r" ((gdt_entry_number << 3) | 3), ); }, .x86_64 => { diff --git a/lib/compiler_rt/extendf.zig b/lib/compiler_rt/extendf.zig index a0c637b352680a3b1bf1728c662bce3bdb6db91c..b8c3178b42e53c181162302af93b2023e8b3e579 100644 --- a/lib/compiler_rt/extendf.zig +++ b/lib/compiler_rt/extendf.zig @@ -165,7 +165,7 @@ pub fn f128_floatCast_f80(a: f80) f128 { } // Apply the signbit to (dst_t)abs(a). - const result: u128 = abs_result | @as(u128, sign) << (dst_bits - 16); + const result: u128 = abs_result | (@as(u128, sign) << (dst_bits - 16)); return @bitCast(result); } @@ -232,7 +232,7 @@ inline fn extendf(comptime dst_t: type, comptime src_t: type, f: src_t) dst_t { } // Apply the signbit to (dst_t)abs(a). - const result: dst_rep_t = absResult | @as(dst_rep_t, sign) << (dstBits - srcBits); + const result: dst_rep_t = absResult | (@as(dst_rep_t, sign) << (dstBits - srcBits)); return @bitCast(result); } diff --git a/lib/compiler_rt/floor_ceil.zig b/lib/compiler_rt/floor_ceil.zig index a11076bb0bcfa1da7a55e3608544c8c8b2f5d211..7691e408d5dae5cdbff6b71c56ce2062d14ae6d9 100644 --- a/lib/compiler_rt/floor_ceil.zig +++ b/lib/compiler_rt/floor_ceil.zig @@ -141,13 +141,13 @@ inline fn impl(comptime T: type, comptime op: enum { floor, ceil }, x: T) T { const m = (@as(U, 1) << @intCast(mantissa - e)) - 1; if (u & m == 0) return x; if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1.0p120); - if (u >> bits - 1 == @intFromBool(op == .floor)) u += m; + if (u >> (bits - 1) == @intFromBool(op == .floor)) u += m; return @bitCast(u & ~m); } else { if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1.0p120); return switch (op) { - .floor => if (u >> bits - 1 == 0) 0.0 else if (u << 1 != 0) -1.0 else x, - .ceil => if (u >> bits - 1 != 0) -0.0 else if (u << 1 != 0) 1.0 else x, + .floor => if (u >> (bits - 1) == 0) 0.0 else if (u << 1 != 0) -1.0 else x, + .ceil => if (u >> (bits - 1) != 0) -0.0 else if (u << 1 != 0) 1.0 else x, }; } }, @@ -155,7 +155,7 @@ inline fn impl(comptime T: type, comptime op: enum { floor, ceil }, x: T) T { const e = (u >> mantissa) & mask; if (e >= bias + math.floatFractionalBits(T) or x == 0) return x; - const positive = u >> @bitSizeOf(T) - 1 == 0; + const positive = u >> (@bitSizeOf(T) - 1) == 0; const y: T = if (positive) x + C - C - x else diff --git a/lib/compiler_rt/fmod.zig b/lib/compiler_rt/fmod.zig index c079049f15d08ba6b59301db1523a3644dd1e940..bd4bc5c1b1037a688c15eaa5958e36877b4f0bbb 100644 --- a/lib/compiler_rt/fmod.zig +++ b/lib/compiler_rt/fmod.zig @@ -204,8 +204,8 @@ pub fn fmod_f128(a: f128, b: f128) f128 { } // OR in extra non-stored mantissa digit - var highA: u64 = (aPtr_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 highA: u64 = (aPtr_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]; const lowB: u64 = bPtr_u64[low_index]; diff --git a/lib/compiler_rt/mulf3.zig b/lib/compiler_rt/mulf3.zig index 7367339dbc82f74dc99a9f6de7f842e8cbb71968..f4dff4ed37218e8224c81aa854240429ca6903e8 100644 --- a/lib/compiler_rt/mulf3.zig +++ b/lib/compiler_rt/mulf3.zig @@ -237,7 +237,7 @@ fn wideShrWithTruncation(comptime Z: type, hi: *Z, lo: *Z, count: u32) bool { lo.* = (hi.* << @intCast(typeWidth -% count)) | (lo.* >> @intCast(count)); hi.* = hi.* >> @intCast(count); } else if (count < 2 * typeWidth) { - inexact = (hi.* << @intCast(2 * typeWidth -% count) | lo.*) != 0; + inexact = ((hi.* << @intCast(2 * typeWidth -% count)) | lo.*) != 0; lo.* = hi.* >> @intCast(count -% typeWidth); hi.* = 0; } else { diff --git a/lib/compiler_rt/rem_pio2l.zig b/lib/compiler_rt/rem_pio2l.zig index a6ff502500ae6a1365a7ea794a6d0bc6cd4421aa..fbb5011b350284c950814f6b1ca0112c1caa5da3 100644 --- a/lib/compiler_rt/rem_pio2l.zig +++ b/lib/compiler_rt/rem_pio2l.zig @@ -37,7 +37,7 @@ pub fn rem_pio2l(comptime T: type, x: T, y: *[2]T) i32 { const se = ld.signExponent(x_val); const top = ld.mantissaTop(x_val); const lhs = (@as(u32, se & 0x7fff) << 16) | top; - const rhs: u32 = ((0x3fff + 25) << 16) | 0x921f >> 1 | 0x8000; + const rhs: u32 = ((0x3fff + 25) << 16) | (0x921f >> 1) | 0x8000; return lhs < rhs; } diff --git a/lib/compiler_rt/sqrt.zig b/lib/compiler_rt/sqrt.zig index 6ba6d62b8e92d8d07e9ca99f2dd65559bd2ecfdb..d5282a6c9a7b92cf8d7f881c8d945033cb19248a 100644 --- a/lib/compiler_rt/sqrt.zig +++ b/lib/compiler_rt/sqrt.zig @@ -523,15 +523,15 @@ const rsqrt_tab: [128]u16 = .{ }; inline fn mul16(a: u16, b: u16) u16 { - return @intCast(@as(u32, a) * b >> 16); + return @intCast((@as(u32, a) * b) >> 16); } inline fn mul32(a: u32, b: u32) u32 { - return @intCast(@as(u64, a) * b >> 32); + return @intCast((@as(u64, a) * b) >> 32); } inline fn mul64(a: u64, b: u64) u64 { - return @intCast(@as(u128, a) * b >> 64); + return @intCast((@as(u128, a) * b) >> 64); } inline fn mul80(a: u80, b: u80) u80 { @@ -539,7 +539,7 @@ inline fn mul80(a: u80, b: u80) u80 { const alo = a & 0xFF_FFFF_FFFF; const bhi = b >> 40; const blo = b & 0xFF_FFFF_FFFF; - return ahi * bhi + (ahi * blo >> 40) + (alo * bhi >> 40); + return ahi * bhi + ((ahi * blo) >> 40) + ((alo * bhi) >> 40); } inline fn mul128(a: u128, b: u128) u128 { @@ -547,7 +547,7 @@ inline fn mul128(a: u128, b: u128) u128 { const alo = a & 0xFFFF_FFFF_FFFF_FFFF; const bhi = b >> 64; const blo = b & 0xFFFF_FFFF_FFFF_FFFF; - return ahi * bhi + (ahi * blo >> 64) + (alo * bhi >> 64); + return ahi * bhi + ((ahi * blo) >> 64) + ((alo * bhi) >> 64); } inline fn mul80_tail(a: u80, b: u80) u80 { diff --git a/lib/compiler_rt/truncf.zig b/lib/compiler_rt/truncf.zig index 9a1cb491e27bc214a2c5c7a4a91f8f236efae1ef..cd8e8cc2bd5088d71b9471d8112bf4266ec6d02a 100644 --- a/lib/compiler_rt/truncf.zig +++ b/lib/compiler_rt/truncf.zig @@ -279,7 +279,7 @@ inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t { absResult = 0; } else { const sticky: src_rep_t = @intFromBool(significand << @intCast(srcBits - shift) != 0); - const denormalizedSignificand: src_rep_t = significand >> @intCast(shift) | sticky; + const denormalizedSignificand: src_rep_t = (significand >> @intCast(shift)) | sticky; absResult = @intCast(denormalizedSignificand >> (srcSigBits - dstSigBits)); const roundBits: src_rep_t = denormalizedSignificand & roundMask; if (roundBits > halfway) { @@ -362,7 +362,7 @@ inline fn trunc_f80(comptime dst_t: type, a: f80) dst_t { abs_result = 0; } else { const sticky = @intFromBool(a_rep.fraction << @intCast(shift) != 0); - const denormalized_significand = a_rep.fraction >> @intCast(shift) | sticky; + const denormalized_significand = (a_rep.fraction >> @intCast(shift)) | sticky; abs_result = @intCast(denormalized_significand >> (src_sig_bits - dst_sig_bits)); const round_bits = denormalized_significand & round_mask; if (round_bits > halfway) { @@ -375,7 +375,7 @@ inline fn trunc_f80(comptime dst_t: type, a: f80) dst_t { } } - const result align(@alignOf(dst_t)) = abs_result | @as(dst_rep_t, sign) << dst_bits - 16; + const result align(@alignOf(dst_t)) = abs_result | (@as(dst_rep_t, sign) << (dst_bits - 16)); return @bitCast(result); } diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig index 41236b214ec68db199e0693c142adb7c3a822303..9ae2985c948dbd5e149b21654b88d1faf2b22fa9 100644 --- a/lib/std/Io/Dispatch.zig +++ b/lib/std/Io/Dispatch.zig @@ -1931,10 +1931,10 @@ const BatchWaiter = struct { fn batchAwaitAsync(userdata: ?*anyopaque, batch: *Io.Batch) Io.Cancelable!void { const ev: *Evented = @ptrCast(@alignCast(userdata)); - const queue = ev.batchDrainSubmitted(batch, false) catch |err| switch (err) { + const queue = (ev.batchDrainSubmitted(batch, false) catch |err| switch (err) { error.ConcurrencyUnavailable => unreachable, // passed concurrency=false error.Canceled => |e| return e, - } orelse return; + }) orelse return; if (batch.pending.head == .none) return; var waiter: BatchWaiter = .{ .sleeper = .init(ev.queue, Thread.current().currentFiber()), diff --git a/lib/std/Io/Kqueue.zig b/lib/std/Io/Kqueue.zig index 20e7820d0611c944701b599f703ddcd8424e541d..b4d2417848a06b42d2f5b3fe341f6816a48995cf 100644 --- a/lib/std/Io/Kqueue.zig +++ b/lib/std/Io/Kqueue.zig @@ -164,7 +164,7 @@ pub const InitError = Allocator.Error || CreateFileDescriptorError; pub fn init(k: *Kqueue, gpa: Allocator, options: InitOptions) !void { assert(options.n_threads != 0); - const n_threads = @max(1, options.n_threads orelse std.Thread.getCpuCount() catch 1); + const n_threads = @max(1, options.n_threads orelse (std.Thread.getCpuCount() catch 1)); const threads_size = n_threads * @sizeOf(Thread); const idle_stack_end_offset = std.mem.alignForward(usize, threads_size + idle_stack_size, std.heap.page_size_max); const allocated_slice = try gpa.alignedAlloc(u8, .of(Thread), idle_stack_end_offset); diff --git a/lib/std/Io/Threaded/test.zig b/lib/std/Io/Threaded/test.zig index 2f2da58252b540df458c26262218a2e4fbf11329..8580f792089a4a8e5b981a49d1296b5fc66cd8da 100644 --- a/lib/std/Io/Threaded/test.zig +++ b/lib/std/Io/Threaded/test.zig @@ -36,7 +36,7 @@ fn put(io: Io, queue: *Io.Queue(u8)) void { } fn get(io: Io, queue: *Io.Queue(u8)) void { - assert(queue.getOneUncancelable(io) catch unreachable == 42); + assert((queue.getOneUncancelable(io) catch unreachable) == 42); } test "concurrent vs concurrent prevents deadlock via oversubscription" { diff --git a/lib/std/Io/Writer.zig b/lib/std/Io/Writer.zig index fc9f6e6052aa49aff5a5fdf7e22cee25073cc681..aa38dbc8430198e3cc7510c64c30996cd9cde12a 100644 --- a/lib/std/Io/Writer.zig +++ b/lib/std/Io/Writer.zig @@ -1827,7 +1827,7 @@ pub fn printFloatHex(w: *Writer, value: anytype, case: std.fmt.Case, opt_precisi // Restore the alignment. mantissa <<= @as(std.math.Log2Int(TU), @intCast((mantissa_digits - precision) * 4)); - const overflow = mantissa & (1 << 1 + mantissa_digits * 4) != 0; + const overflow = mantissa & (1 << (1 + mantissa_digits * 4)) != 0; // Prefer a normalized result in case of overflow. if (overflow) { mantissa >>= 1; diff --git a/lib/std/Io/net/HostName.zig b/lib/std/Io/net/HostName.zig index 81f239948a6426404be3329660e68647bd75060c..0ebe427f75cb5a5b3aede4aa5e3be78128321451 100644 --- a/lib/std/Io/net/HostName.zig +++ b/lib/std/Io/net/HostName.zig @@ -230,7 +230,7 @@ pub fn expand(noalias packet: []const u8, start_i: usize, noalias dest_buffer: [ i += 1 + label_len; } else { return .{ - len orelse i - start_i + 1, + len orelse (i - start_i + 1), try .init(dest[0..dest_i]), }; } diff --git a/lib/std/base64.zig b/lib/std/base64.zig index 9771436f45b4943669910077e2938a34eae1cd08..3c3ca62ea20025167e4be1402df9205028a729d9 100644 --- a/lib/std/base64.zig +++ b/lib/std/base64.zig @@ -148,7 +148,7 @@ pub const Base64Encoder = struct { if (idx + 2 < source.len) { dest[out_idx] = encoder.alphabet_chars[source[idx] >> 2]; dest[out_idx + 1] = encoder.alphabet_chars[((source[idx] & 0x3) << 4) | (source[idx + 1] >> 4)]; - dest[out_idx + 2] = encoder.alphabet_chars[(source[idx + 1] & 0xf) << 2 | (source[idx + 2] >> 6)]; + dest[out_idx + 2] = encoder.alphabet_chars[((source[idx + 1] & 0xf) << 2) | (source[idx + 2] >> 6)]; dest[out_idx + 3] = encoder.alphabet_chars[source[idx + 2] & 0x3f]; out_idx += 4; } else if (idx + 1 < source.len) { @@ -282,7 +282,7 @@ pub const Base64Decoder = struct { dest_idx += 1; } } - if (acc_len > 4 or (acc & (@as(u12, 1) << acc_len) - 1) != 0) { + if (acc_len > 4 or (acc & ((@as(u12, 1) << acc_len) - 1)) != 0) { return error.InvalidPadding; } if (leftover_idx == null) return; @@ -357,7 +357,7 @@ pub const Base64DecoderWithIgnore = struct { dest_idx += 1; } } - if (acc_len > 4 or (acc & (@as(u12, 1) << acc_len) - 1) != 0) { + if (acc_len > 4 or (acc & ((@as(u12, 1) << acc_len) - 1)) != 0) { return error.InvalidPadding; } const padding_len = acc_len / 2; diff --git a/lib/std/bit_set.zig b/lib/std/bit_set.zig index b74cb49f0659b0693ee9f1b1cd3ba8298a22f319..1326570c1c6583e2c0cad45e3668f929195bacdf 100644 --- a/lib/std/bit_set.zig +++ b/lib/std/bit_set.zig @@ -468,11 +468,11 @@ pub fn Array(comptime MaskIntType: type, comptime size: usize) type { if (start_mask_index == end_mask_index) { var mask1 = std.math.boolMask(MaskInt, true) << start_bit; - var mask2 = std.math.boolMask(MaskInt, true) >> (mask_len - 1) - (end_bit - 1); + var mask2 = std.math.boolMask(MaskInt, true) >> ((mask_len - 1) - (end_bit - 1)); self.masks[start_mask_index] &= ~(mask1 & mask2); mask1 = std.math.boolMask(MaskInt, value) << start_bit; - mask2 = std.math.boolMask(MaskInt, value) >> (mask_len - 1) - (end_bit - 1); + mask2 = std.math.boolMask(MaskInt, value) >> ((mask_len - 1) - (end_bit - 1)); self.masks[start_mask_index] |= mask1 & mask2; } else { var bulk_mask_index: usize = undefined; @@ -875,11 +875,11 @@ pub const Dynamic = struct { if (start_mask_index == end_mask_index) { var mask1 = std.math.boolMask(MaskInt, true) << start_bit; - var mask2 = std.math.boolMask(MaskInt, true) >> (@bitSizeOf(MaskInt) - 1) - (end_bit - 1); + var mask2 = std.math.boolMask(MaskInt, true) >> ((@bitSizeOf(MaskInt) - 1) - (end_bit - 1)); self.masks[start_mask_index] &= ~(mask1 & mask2); mask1 = std.math.boolMask(MaskInt, value) << start_bit; - mask2 = std.math.boolMask(MaskInt, value) >> (@bitSizeOf(MaskInt) - 1) - (end_bit - 1); + mask2 = std.math.boolMask(MaskInt, value) >> ((@bitSizeOf(MaskInt) - 1) - (end_bit - 1)); self.masks[start_mask_index] |= mask1 & mask2; } else { var bulk_mask_index: usize = undefined; diff --git a/lib/std/coff.zig b/lib/std/coff.zig index a9a125f3e43e67a82dd509198bb396ee4e856f12..8bd58e906cac370b7885c97792636f3b38325802 100644 --- a/lib/std/coff.zig +++ b/lib/std/coff.zig @@ -2035,7 +2035,7 @@ pub const ArchiveMemberHeader = extern struct { if (trim.len == 0) return error.BadName; return if (trim[0] == '/') name: { if (trim.len == 1 or - trim.len == 2 and trim[1] == '/') + (trim.len == 2 and trim[1] == '/')) break :name trim; const offset = std.fmt.parseUnsigned(u50, trim[1..], 10) catch diff --git a/lib/std/compress/flate/Compress.zig b/lib/std/compress/flate/Compress.zig index 167bddd1b6923b2dd22fa2267c38c6e5118f8c39..3aade0c7c53b591f47e08812980e7223dbc764a3 100644 --- a/lib/std/compress/flate/Compress.zig +++ b/lib/std/compress/flate/Compress.zig @@ -1333,8 +1333,8 @@ const huffman = struct { const incomplete_allowed = smith.value(bool); while (nfreqs < @as(u8, @intFromBool(!incomplete_allowed)) + 1 or - nfreqs != freqs_buf.len and freqs_limit != 0 and - smith.eosWeightedSimple(15, 1)) + (nfreqs != freqs_buf.len and freqs_limit != 0 and + smith.eosWeightedSimple(15, 1))) { const f = smith.valueWeighted(u16, &.{ .rangeAtMost(u16, 0, @min(31, freqs_limit), @max(freqs_limit, 1)), diff --git a/lib/std/crypto/aes/soft.zig b/lib/std/crypto/aes/soft.zig index 35b9ed2cb5218b980037e4c146eebc74adb9dd26..c901ba548b79a14f932c8cf8af28949c60194dcf 100644 --- a/lib/std/crypto/aes/soft.zig +++ b/lib/std/crypto/aes/soft.zig @@ -728,7 +728,7 @@ pub const Aes256 = struct { // constants // Rijndael's irreducible polynomial. -const poly: u9 = 1 << 8 | 1 << 4 | 1 << 3 | 1 << 1 | 1 << 0; // x⁸ + x⁴ + x³ + x + 1 +const poly: u9 = (1 << 8) | (1 << 4) | (1 << 3) | (1 << 1) | (1 << 0); // x⁸ + x⁴ + x³ + x + 1 // Powers of x mod poly in GF(2). const powx = init: { diff --git a/lib/std/crypto/codecs/base64_hex_ct.zig b/lib/std/crypto/codecs/base64_hex_ct.zig index 3da08ceb25989747d6984d2f4017b8009543a865..8080eda2142d3fbc9286ce22b849ee46e54a7437 100644 --- a/lib/std/crypto/codecs/base64_hex_ct.zig +++ b/lib/std/crypto/codecs/base64_hex_ct.zig @@ -29,7 +29,7 @@ pub const hex = struct { const c: u16 = v & 0xf; const off = if (case == .upper) 32 else 0; const x = - ((87 - off + c + (((c -% 10) >> 8) & ~@as(u16, 38 - off))) & 0xff) << 8 | + (((87 - off + c + (((c -% 10) >> 8) & ~@as(u16, 38 - off))) & 0xff) << 8) | ((87 - off + b + (((b -% 10) >> 8) & ~@as(u16, 38 - off))) & 0xff); encoded[i * 2] = @truncate(x); encoded[i * 2 + 1] = @truncate(x >> 8); diff --git a/lib/std/crypto/ml_kem.zig b/lib/std/crypto/ml_kem.zig index 261b8f037f9b87131097e82e25db4ce31cc6af4d..70a306aa0f2c51a218f797119e85d112e727f144 100644 --- a/lib/std/crypto/ml_kem.zig +++ b/lib/std/crypto/ml_kem.zig @@ -1264,7 +1264,7 @@ const Poly = struct { const b1 = @as(i16, buf[3 * i + 1]); const b2 = @as(i16, buf[3 * i + 2]); ret.cs[2 * i] = b0 | ((b1 & 0xf) << 8); - ret.cs[2 * i + 1] = (b1 >> 4) | b2 << 4; + ret.cs[2 * i + 1] = (b1 >> 4) | (b2 << 4); } return ret; } diff --git a/lib/std/crypto/scrypt.zig b/lib/std/crypto/scrypt.zig index 9939188ebff47ad0a631255d7a2bf4be49c30e57..d99678d28002ff227fe9b6a37f46fb6f8dd156b7 100644 --- a/lib/std/crypto/scrypt.zig +++ b/lib/std/crypto/scrypt.zig @@ -82,7 +82,7 @@ fn blockMix(tmp: *align(16) [16]u32, in: []align(16) const u32, out: []align(16) fn integerify(b: []align(16) const u32, r: u30) u64 { const j = (2 * r - 1) * 16; - return @as(u64, b[j]) | @as(u64, b[j + 1]) << 32; + return @as(u64, b[j]) | (@as(u64, b[j + 1]) << 32); } fn smix(b: []align(16) u8, r: u30, n: usize, v: []align(16) u32, xy: []align(16) u32) void { diff --git a/lib/std/crypto/sha2.zig b/lib/std/crypto/sha2.zig index 3c5773af50fc827bc34cd10af4d90185d86f27d7..c390c0abbbfdc619ebd06323b3e44de7d2864f0d 100644 --- a/lib/std/crypto/sha2.zig +++ b/lib/std/crypto/sha2.zig @@ -557,7 +557,7 @@ fn Sha2x64(comptime iv: Iv64, digest_bits: comptime_int) type { } if (digest_bits % 8 != 0) @compileError("impl doesn't support non-byte digest_len"); - const bytes_left = digest_bits / 8 % 8; + const bytes_left = (digest_bits / 8) % 8; if (bytes_left > 0) { const rest = d.s[(digest_bits / 64)]; var buf: [8]u8 = undefined; diff --git a/lib/std/debug.zig b/lib/std/debug.zig index 0822957bc98e790b17f8b00835661bf0ba7f6ba1..5d709fdaa5435cf558b88a06229d09d64b036fce 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -1306,7 +1306,7 @@ fn printLineInfo( try writer.print("0x{x} in {s} ({s})", .{ address, symbol.name orelse "???", - symbol.compile_unit_name orelse debug_info.getModuleName(io, address) catch "???", + symbol.compile_unit_name orelse (debug_info.getModuleName(io, address) catch "???"), }); t.setColor(.reset) catch {}; try writer.writeAll("\n"); diff --git a/lib/std/debug/SelfInfo/Elf.zig b/lib/std/debug/SelfInfo/Elf.zig index af6bf48aaa718c75eacb22abb4445ce1b1483a6a..68080d1f25380dec9cc49b69635bfd07b233b850 100644 --- a/lib/std/debug/SelfInfo/Elf.zig +++ b/lib/std/debug/SelfInfo/Elf.zig @@ -16,11 +16,11 @@ pub fn deinit(si: *SelfInfo, io: Io) void { const gpa = std.debug.getDebugInfoAllocator(); for (si.modules.items) |*mod| { unwind: { - const u = &(mod.unwind orelse break :unwind catch break :unwind); + const u = &((mod.unwind orelse break :unwind) catch break :unwind); for (u.buf[0..u.len]) |*unwind| unwind.deinit(gpa); } loaded: { - const l = &(mod.loaded_elf orelse break :loaded catch break :loaded); + const l = &((mod.loaded_elf orelse break :loaded) catch break :loaded); l.file.deinit(gpa); } } @@ -431,11 +431,11 @@ fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize, lock: enum } for (si.modules.items) |*mod| { unwind: { - const u = &(mod.unwind orelse break :unwind catch break :unwind); + const u = &((mod.unwind orelse break :unwind) catch break :unwind); for (u.buf[0..u.len]) |*unwind| unwind.deinit(gpa); } loaded: { - const l = &(mod.loaded_elf orelse break :loaded catch break :loaded); + const l = &((mod.loaded_elf orelse break :loaded) catch break :loaded); l.file.deinit(gpa); } } diff --git a/lib/std/debug/SelfInfo/MachO.zig b/lib/std/debug/SelfInfo/MachO.zig index f68572d1ca07fab3f0a9249f1bdf42c85ba9ee2e..6f2e983a3e273cc8ec370e86a8af8190d6cb5f41 100644 --- a/lib/std/debug/SelfInfo/MachO.zig +++ b/lib/std/debug/SelfInfo/MachO.zig @@ -11,11 +11,11 @@ pub fn deinit(si: *SelfInfo, io: Io) void { const gpa = std.debug.getDebugInfoAllocator(); for (si.modules.keys()) |*module| { unwind: { - const u = &(module.unwind orelse break :unwind catch break :unwind); + const u = &((module.unwind orelse break :unwind) catch break :unwind); if (u.dwarf) |*dwarf| dwarf.deinit(gpa); } file: { - const f = &(module.file orelse break :file catch break :file); + const f = &((module.file orelse break :file) catch break :file); f.deinit(gpa); } } diff --git a/lib/std/debug/SelfInfo/Windows.zig b/lib/std/debug/SelfInfo/Windows.zig index ae81cccae4304e3222e6a24208112c4da9b91aaa..6cf7b03341326e93200c11798648fd7dd7820548 100644 --- a/lib/std/debug/SelfInfo/Windows.zig +++ b/lib/std/debug/SelfInfo/Windows.zig @@ -280,7 +280,7 @@ const Module = struct { // we have no information to add to the address break :pdb; }; - const module = pdb.getModule(mod_index) catch |err| switch (err) { + const module = (pdb.getModule(mod_index) catch |err| switch (err) { error.InvalidDebugInfo, error.MissingDebugInfo, error.OutOfMemory, @@ -289,7 +289,7 @@ const Module = struct { error.ReadFailed, error.EndOfStream, => return error.InvalidDebugInfo, - } orelse { + }) orelse { return error.InvalidDebugInfo; // bad module index }; @@ -539,9 +539,9 @@ const Module = struct { } var opt_pdb: ?Pdb = pdb: { - const path = coff_obj.getPdbPath() catch { + const path = (coff_obj.getPdbPath() catch { return error.InvalidDebugInfo; - } orelse { + }) orelse { break :pdb null; }; const pdb_file_open_result = if (fs.path.isAbsolute(path)) res: { diff --git a/lib/std/dynamic_library.zig b/lib/std/dynamic_library.zig index 37001e165729cd87af1fcdf9a93ae6d5d5ae0819..995a3d644905764993ec3574e2fb7d4708cf8a90 100644 --- a/lib/std/dynamic_library.zig +++ b/lib/std/dynamic_library.zig @@ -13,7 +13,7 @@ const posix = std.posix; /// Platform-specific functionality is available through the `inner` field. pub const DynLib = struct { const InnerType = switch (native_os) { - .linux => if (!builtin.link_libc or builtin.abi == .musl and builtin.link_mode == .static) + .linux => if (!builtin.link_libc or (builtin.abi == .musl and builtin.link_mode == .static)) ElfDynLib else DlDynLib, @@ -434,15 +434,15 @@ pub const ElfDynLib = struct { pub fn lookupAddress(self: *const ElfDynLib, vername: []const u8, name: []const u8) ?usize { const maybe_versym = if (self.verdef == null) null else self.versym; - const OK_TYPES = (1 << elf.STT_NOTYPE | 1 << elf.STT_OBJECT | 1 << elf.STT_FUNC | 1 << elf.STT_COMMON); - const OK_BINDS = (1 << elf.STB_GLOBAL | 1 << elf.STB_WEAK | 1 << elf.STB_GNU_UNIQUE); + const OK_TYPES = (1 << elf.STT_NOTYPE) | (1 << elf.STT_OBJECT) | (1 << elf.STT_FUNC) | (1 << elf.STT_COMMON); + const OK_BINDS = (1 << elf.STB_GLOBAL) | (1 << elf.STB_WEAK) | (1 << elf.STB_GNU_UNIQUE); switch (self.hash_table) { .dt_hash => |hashtab| { var i: usize = 0; while (i < hashtab[1]) : (i += 1) { - if (0 == (@as(u32, 1) << @as(u5, @intCast(self.syms[i].st_info & 0xf)) & OK_TYPES)) continue; - if (0 == (@as(u32, 1) << @as(u5, @intCast(self.syms[i].st_info >> 4)) & OK_BINDS)) continue; + if (0 == (@as(u32, 1) << @as(u5, @intCast(self.syms[i].st_info & 0xf))) & OK_TYPES) continue; + if (0 == (@as(u32, 1) << @as(u5, @intCast(self.syms[i].st_info >> 4))) & OK_BINDS) continue; if (0 == self.syms[i].st_shndx) continue; if (!mem.eql(u8, name, mem.sliceTo(self.strings + self.syms[i].st_name, 0))) continue; if (maybe_versym) |versym| { @@ -494,8 +494,8 @@ pub const ElfDynLib = struct { const symbol_index = current_index + gnu_hash_header.symoffset; const symbol = self.syms[symbol_index]; - if (0 == (@as(u32, 1) << @as(u5, @intCast(symbol.st_info & 0xf)) & OK_TYPES)) continue; - if (0 == (@as(u32, 1) << @as(u5, @intCast(symbol.st_info >> 4)) & OK_BINDS)) continue; + if (0 == (@as(u32, 1) << @as(u5, @intCast(symbol.st_info & 0xf))) & OK_TYPES) continue; + if (0 == (@as(u32, 1) << @as(u5, @intCast(symbol.st_info >> 4))) & OK_BINDS) continue; if (0 == symbol.st_shndx) continue; const symbol_name = mem.sliceTo(self.strings + symbol.st_name, 0); diff --git a/lib/std/fmt/parse_float/common.zig b/lib/std/fmt/parse_float/common.zig index 4c33a9081d040ed912b553c8287f8838090a306b..2f6813ed99af3a53dd7721a6aed83e21a0ac896c 100644 --- a/lib/std/fmt/parse_float/common.zig +++ b/lib/std/fmt/parse_float/common.zig @@ -82,7 +82,7 @@ pub fn isDigit(c: u8, comptime base: u8) bool { return if (base == 10) '0' <= c and c <= '9' else - '0' <= c and c <= '9' or 'a' <= c and c <= 'f' or 'A' <= c and c <= 'F'; + ('0' <= c and c <= '9') or ('a' <= c and c <= 'f') or ('A' <= c and c <= 'F'); } /// Returns the underlying storage type used for the mantissa of floating-point type. diff --git a/lib/std/hash/cityhash.zig b/lib/std/hash/cityhash.zig index 1acb039dab5551e4e0ef0b691c4d5ae8770bebb7..784db7d6551cfd3b52b02af931059989847d891f 100644 --- a/lib/std/hash/cityhash.zig +++ b/lib/std/hash/cityhash.zig @@ -222,7 +222,7 @@ pub const CityHash64 = struct { const c: u8 = str[str.len - 1]; const y: u32 = @as(u32, @intCast(a)) +% (@as(u32, @intCast(b)) << 8); const z: u32 = @as(u32, @truncate(str.len)) +% (@as(u32, @intCast(c)) << 2); - return shiftmix(@as(u64, @intCast(y)) *% k2 ^ @as(u64, @intCast(z)) *% k0) *% k2; + return shiftmix((@as(u64, @intCast(y)) *% k2) ^ (@as(u64, @intCast(z)) *% k0)) *% k2; } return k2; } diff --git a/lib/std/hash/xxhash.zig b/lib/std/hash/xxhash.zig index b33ac61b5bd233a0c6ccea59033d7ee6c2b62045..655b1f7ed2f6fb93e5efc166dbf41d580fc4498b 100644 --- a/lib/std/hash/xxhash.zig +++ b/lib/std/hash/xxhash.zig @@ -398,7 +398,7 @@ pub const XxHash32 = struct { } fn avalanche(value: u32) u32 { - var acc = value ^ value >> 15; + var acc = value ^ (value >> 15); acc *%= prime_2; acc ^= acc >> 13; acc *%= prime_3; diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig index 58dc8524e8ac07e960a47186eb6d8dd3a49d3efd..aa67d22466d73754401603bb9a2b6c6cedde1d5d 100644 --- a/lib/std/hash_map.zig +++ b/lib/std/hash_map.zig @@ -2019,7 +2019,7 @@ test "getOrPutAdapted" { const AdaptedContext = struct { fn eql(self: @This(), adapted_key: []const u8, test_key: u64) bool { _ = self; - return std.fmt.parseInt(u64, adapted_key, 10) catch unreachable == test_key; + return (std.fmt.parseInt(u64, adapted_key, 10) catch unreachable) == test_key; } fn hash(self: @This(), adapted_key: []const u8) u64 { _ = self; diff --git a/lib/std/heap/SafeAllocator.zig b/lib/std/heap/SafeAllocator.zig index 91f65184241713f66a39953092d889cd2bed4b84..77457e8685046d0115e076ee44041c062d83662f 100644 --- a/lib/std/heap/SafeAllocator.zig +++ b/lib/std/heap/SafeAllocator.zig @@ -211,7 +211,7 @@ const Bucket = struct { fn of(s: *SafeAllocator, ptr: [*]u8) *Bucket { const size_log2 = s.bucket_size_log2; - return @ptrFromInt(@intFromPtr(ptr) >> @intCast(size_log2) << @intCast(size_log2)); + return @ptrFromInt((@intFromPtr(ptr) >> @intCast(size_log2)) << @intCast(size_log2)); } fn fillAt(s: *SafeAllocator, ptr: [*]const u8) u32 { diff --git a/lib/std/math.zig b/lib/std/math.zig index 27d5e0d584dca43e838d31eabec11ca2134045d9..627cc50ecb3deac16ec4bd542e8f847fded75e46 100644 --- a/lib/std/math.zig +++ b/lib/std/math.zig @@ -710,7 +710,7 @@ pub fn rotr(comptime T: type, x: T, r: anytype) T { if (comptime isPowerOfTwo(@typeInfo(T).int.bits)) { const ar: Log2Int(T) = @intCast(@mod(r, @typeInfo(T).int.bits)); - return x >> ar | x << (1 +% ~ar); + return (x >> ar) | (x << (1 +% ~ar)); } else { const ar = @mod(r, @typeInfo(T).int.bits); return shr(T, x, ar) | shl(T, x, @typeInfo(T).int.bits - ar); @@ -753,7 +753,7 @@ pub fn rotl(comptime T: type, x: T, r: anytype) T { if (comptime isPowerOfTwo(@typeInfo(T).int.bits)) { const ar: Log2Int(T) = @intCast(@mod(r, @typeInfo(T).int.bits)); - return x << ar | x >> 1 +% ~ar; + return (x << ar) | (x >> (1 +% ~ar)); } else { const ar = @mod(r, @typeInfo(T).int.bits); return shl(T, x, ar) | shr(T, x, @typeInfo(T).int.bits - ar); @@ -1542,21 +1542,21 @@ pub const Order = enum { const neg: i32 = -1; const zero: i32 = 0; const pos: i32 = 1; - try testing.expect(order(zero, neg).differ() orelse - order(pos, zero) == .gt); - try testing.expect(order(zero, zero).differ() orelse - order(zero, zero) == .eq); - try testing.expect(order(pos, pos).differ() orelse - order(neg, zero) == .lt); - try testing.expect(order(zero, zero).differ() orelse + try testing.expect((order(zero, neg).differ() orelse + order(pos, zero)) == .gt); + try testing.expect((order(zero, zero).differ() orelse + order(zero, zero)) == .eq); + try testing.expect((order(pos, pos).differ() orelse + order(neg, zero)) == .lt); + try testing.expect((order(zero, zero).differ() orelse order(pos, neg).differ() orelse - order(neg, zero) == .gt); - try testing.expect(order(pos, pos).differ() orelse + order(neg, zero)) == .gt); + try testing.expect((order(pos, pos).differ() orelse order(pos, pos).differ() orelse - order(neg, neg) == .eq); - try testing.expect(order(zero, pos).differ() orelse + order(neg, neg)) == .eq); + try testing.expect((order(zero, pos).differ() orelse order(neg, pos).differ() orelse - order(pos, neg) == .lt); + order(pos, neg)) == .lt); } pub fn compare(self: Order, op: CompareOperator) bool { diff --git a/lib/std/math/acos.zig b/lib/std/math/acos.zig index d79c36182e0aa6ebd784c45f56c0232905a9c1a2..40fdef0b3d5b697a41dd60a1399e53340bfab620 100644 --- a/lib/std/math/acos.zig +++ b/lib/std/math/acos.zig @@ -176,7 +176,7 @@ fn acosBinary64(x: f64) f64 { // |x| >= 1 or nan if (ix >= 0x3ff0_0000) { const lx: u32 = @truncate(@as(u64, @bitCast(x))); - if ((ix - 0x3ff0_0000 | lx) == 0) { + if (((ix - 0x3ff0_0000) | lx) == 0) { if (hx >> 31 != 0) { return 2.0 * pio2_hi + 0x1.0p-120; } diff --git a/lib/std/math/asin.zig b/lib/std/math/asin.zig index dfd3f063954c68d25230993b0875873273eb9ff8..917c04216b49715e29b15b797e5aa02a07d8dead 100644 --- a/lib/std/math/asin.zig +++ b/lib/std/math/asin.zig @@ -156,7 +156,7 @@ fn asinBinary64(x: f64) f64 { if (ix >= 0x3ff0_0000) { const lx: u32 = @truncate(@as(u64, @bitCast(x))); // asin(1) = +-pi/2 with inexact - if ((ix - 0x3ff0_0000 | lx) == 0) { + if (((ix - 0x3ff0_0000) | lx) == 0) { return x * pio2_hi + 0x1.0p-120; } return 0.0 / (x - x); diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig index ba0ea5807b95a6f4fe287373763b7260f08caac8..2c2e57d150d07c566b49b6f8712cf3a20d583cfd 100644 --- a/lib/std/math/big/int.zig +++ b/lib/std/math/big/int.zig @@ -2401,7 +2401,7 @@ pub const Const = struct { const shift: usize = @intCast(exponent - @bitSizeOf(Repr.Normalized.Fraction)); mantissa.shiftRight(normalized_abs, shift); const final_limb_index = (shift - 1) / limb_bits; - const round_bits = normalized_abs.limbs[final_limb_index] << @truncate(-%shift) | + const round_bits = (normalized_abs.limbs[final_limb_index] << @truncate(-%shift)) | @intFromBool(!std.mem.allEqual(Limb, normalized_abs.limbs[0..final_limb_index], 0)); if (round_bits == 0) break :exactness .exact; round: switch (round) { @@ -4902,10 +4902,10 @@ test "format" { try a.set(20000000000000000000); // > maxInt(u64) try testFormat(a, "20000000000000000000"); - try a.set(1 << 64 * @sizeOf(usize) * 8); + try a.set(1 << (64 * @sizeOf(usize) * 8)); try testFormat(a, "(BigInt)"); - try a.set(-(1 << 64 * @sizeOf(usize) * 8)); + try a.set(-(1 << (64 * @sizeOf(usize) * 8))); try testFormat(a, "(BigInt)"); } diff --git a/lib/std/math/big/int_test.zig b/lib/std/math/big/int_test.zig index 271041e761a1d6f089c7733aa2964913c771dc0d..1660b3bdfc98479e1dd0169b9c7b712273b5837f 100644 --- a/lib/std/math/big/int_test.zig +++ b/lib/std/math/big/int_test.zig @@ -2489,14 +2489,14 @@ test "truncate to minimum signed integer" { .len = undefined, .positive = undefined, }; - res.truncate(.{ .positive = true, .limbs = &.{1 << @bitSizeOf(Limb) - 1} }, .signed, @bitSizeOf(Limb)); - try testing.expect(res.toConst().orderAgainstScalar(-1 << @bitSizeOf(Limb) - 1).compare(.eq)); - res.truncate(.{ .positive = false, .limbs = &.{1 << @bitSizeOf(Limb) - 1} }, .signed, @bitSizeOf(Limb)); - try testing.expect(res.toConst().orderAgainstScalar(-1 << @bitSizeOf(Limb) - 1).compare(.eq)); - res.truncate(.{ .positive = true, .limbs = &.{1 << @bitSizeOf(Limb) - 1} }, .unsigned, @bitSizeOf(Limb)); - try testing.expect(res.toConst().orderAgainstScalar(1 << @bitSizeOf(Limb) - 1).compare(.eq)); - res.truncate(.{ .positive = false, .limbs = &.{1 << @bitSizeOf(Limb) - 1} }, .unsigned, @bitSizeOf(Limb)); - try testing.expect(res.toConst().orderAgainstScalar(1 << @bitSizeOf(Limb) - 1).compare(.eq)); + res.truncate(.{ .positive = true, .limbs = &.{1 << (@bitSizeOf(Limb) - 1)} }, .signed, @bitSizeOf(Limb)); + try testing.expect(res.toConst().orderAgainstScalar(-1 << (@bitSizeOf(Limb) - 1)).compare(.eq)); + res.truncate(.{ .positive = false, .limbs = &.{1 << (@bitSizeOf(Limb) - 1)} }, .signed, @bitSizeOf(Limb)); + try testing.expect(res.toConst().orderAgainstScalar(-1 << (@bitSizeOf(Limb) - 1)).compare(.eq)); + res.truncate(.{ .positive = true, .limbs = &.{1 << (@bitSizeOf(Limb) - 1)} }, .unsigned, @bitSizeOf(Limb)); + try testing.expect(res.toConst().orderAgainstScalar(1 << (@bitSizeOf(Limb) - 1)).compare(.eq)); + res.truncate(.{ .positive = false, .limbs = &.{1 << (@bitSizeOf(Limb) - 1)} }, .unsigned, @bitSizeOf(Limb)); + try testing.expect(res.toConst().orderAgainstScalar(1 << (@bitSizeOf(Limb) - 1)).compare(.eq)); } test "saturate single signed positive" { @@ -3880,7 +3880,7 @@ test "clz" { try testing.expectEqual(0, neg_limb_max_squared_plus_one.clz(@bitSizeOf(Limb) * 2 + 1)); const neg_limb_msb_squared: std.math.big.int.Const = .{ - .limbs = &.{ 0, 1 << @bitSizeOf(Limb) - 2 }, + .limbs = &.{ 0, 1 << (@bitSizeOf(Limb) - 2) }, .positive = false, }; try testing.expectEqual(0, neg_limb_msb_squared.clz(@bitSizeOf(Limb) * 2)); @@ -3896,7 +3896,7 @@ test "clz" { try testing.expectEqual(0, neg_limb_max.clz(@bitSizeOf(Limb) * 2 + 1)); const neg_limb_msb: std.math.big.int.Const = .{ - .limbs = &.{1 << @bitSizeOf(Limb) - 1}, + .limbs = &.{1 << (@bitSizeOf(Limb) - 1)}, .positive = false, }; try testing.expectEqual(0, neg_limb_msb.clz(@bitSizeOf(Limb))); @@ -3936,7 +3936,7 @@ test "clz" { try testing.expectEqual(@bitSizeOf(Limb) * 2, one.clz(@bitSizeOf(Limb) * 2 + 1)); const limb_msb: std.math.big.int.Const = .{ - .limbs = &.{1 << @bitSizeOf(Limb) - 1}, + .limbs = &.{1 << (@bitSizeOf(Limb) - 1)}, .positive = true, }; try testing.expectEqual(0, limb_msb.clz(@bitSizeOf(Limb))); @@ -3956,7 +3956,7 @@ test "clz" { try testing.expectEqual(@bitSizeOf(Limb) + 1, limb_max.clz(@bitSizeOf(Limb) * 2 + 1)); const limb_msb_squared: std.math.big.int.Const = .{ - .limbs = &.{ 0, 1 << @bitSizeOf(Limb) - 2 }, + .limbs = &.{ 0, 1 << (@bitSizeOf(Limb) - 2) }, .positive = true, }; try testing.expectEqual(0, limb_msb_squared.clz(@bitSizeOf(Limb) * 2 - 1)); @@ -3992,7 +3992,7 @@ test "ctz" { try testing.expectEqual(@bitSizeOf(Limb) + 1, neg_limb_max_squared_plus_one.ctz(@bitSizeOf(Limb) * 2 + 1)); const neg_limb_msb_squared: std.math.big.int.Const = .{ - .limbs = &.{ 0, 1 << @bitSizeOf(Limb) - 2 }, + .limbs = &.{ 0, 1 << (@bitSizeOf(Limb) - 2) }, .positive = false, }; try testing.expectEqual(@bitSizeOf(Limb) * 2 - 2, neg_limb_msb_squared.ctz(@bitSizeOf(Limb) * 2)); @@ -4008,7 +4008,7 @@ test "ctz" { try testing.expectEqual(0, neg_limb_max.ctz(@bitSizeOf(Limb) * 2 + 1)); const neg_limb_msb: std.math.big.int.Const = .{ - .limbs = &.{1 << @bitSizeOf(Limb) - 1}, + .limbs = &.{1 << (@bitSizeOf(Limb) - 1)}, .positive = false, }; try testing.expectEqual(@bitSizeOf(Limb) - 1, neg_limb_msb.ctz(@bitSizeOf(Limb))); @@ -4048,7 +4048,7 @@ test "ctz" { try testing.expectEqual(0, one.ctz(@bitSizeOf(Limb) * 2 + 1)); const limb_msb: std.math.big.int.Const = .{ - .limbs = &.{1 << @bitSizeOf(Limb) - 1}, + .limbs = &.{1 << (@bitSizeOf(Limb) - 1)}, .positive = true, }; try testing.expectEqual(@bitSizeOf(Limb) - 1, limb_msb.ctz(@bitSizeOf(Limb))); @@ -4068,7 +4068,7 @@ test "ctz" { try testing.expectEqual(0, limb_max.ctz(@bitSizeOf(Limb) * 2 + 1)); const limb_msb_squared: std.math.big.int.Const = .{ - .limbs = &.{ 0, 1 << @bitSizeOf(Limb) - 2 }, + .limbs = &.{ 0, 1 << (@bitSizeOf(Limb) - 2) }, .positive = true, }; try testing.expectEqual(@bitSizeOf(Limb) * 2 - 2, limb_msb_squared.ctz(@bitSizeOf(Limb) * 2 - 1)); diff --git a/lib/std/math/float.zig b/lib/std/math/float.zig index 0b16875cc3559756a91ac10f96afee9d9a9fb5f1..afbf9ccf2a10b2d79e988f89365483478e4933cc 100644 --- a/lib/std/math/float.zig +++ b/lib/std/math/float.zig @@ -281,7 +281,7 @@ pub inline fn nan(comptime Type: type) Type { return reconstructFloat( RuntimeType, floatExponentMax(RuntimeType) + 1, - mantissaOne(RuntimeType) | 1 << (floatFractionalBits(RuntimeType) - 1), + mantissaOne(RuntimeType) | (1 << (floatFractionalBits(RuntimeType) - 1)), ); } @@ -297,7 +297,7 @@ pub inline fn snan(comptime Type: type) Type { return reconstructFloat( RuntimeType, floatExponentMax(RuntimeType) + 1, - mantissaOne(RuntimeType) | 1 << (floatFractionalBits(RuntimeType) - 2), + mantissaOne(RuntimeType) | (1 << (floatFractionalBits(RuntimeType) - 2)), ); } diff --git a/lib/std/mem.zig b/lib/std/mem.zig index a679291dba1bcae6e79286ad3b7b199562f68695..ce4523c71cc6d24ad79f8e48bce3b2117522aa01 100644 --- a/lib/std/mem.zig +++ b/lib/std/mem.zig @@ -4354,7 +4354,7 @@ pub fn alignPointerOffset(ptr: anytype, align_to: usize) ?usize { @compileError("expected many item pointer, got " ++ @typeName(T)); // Do nothing if the pointer is already well-aligned. - if (align_to <= info.pointer.attrs.@"align" orelse @alignOf(info.pointer.child)) + if (align_to <= (info.pointer.attrs.@"align" orelse @alignOf(info.pointer.child))) return 0; // Calculate the aligned base address with an eye out for overflow. diff --git a/lib/std/os/linux/vdso.zig b/lib/std/os/linux/vdso.zig index 5add23f5c42bd6f93cfdc39825b42cc969d8e321..21546043d5d2614852127dd9dca0beca5aaff29f 100644 --- a/lib/std/os/linux/vdso.zig +++ b/lib/std/os/linux/vdso.zig @@ -62,13 +62,13 @@ pub fn lookup(vername: []const u8, name: []const u8) usize { const hashtab = maybe_hashtab orelse return 0; if (maybe_verdef == null) maybe_versym = null; - const OK_TYPES = (1 << elf.STT_NOTYPE | 1 << elf.STT_OBJECT | 1 << elf.STT_FUNC | 1 << elf.STT_COMMON); - const OK_BINDS = (1 << elf.STB_GLOBAL | 1 << elf.STB_WEAK | 1 << elf.STB_GNU_UNIQUE); + const OK_TYPES = (1 << elf.STT_NOTYPE) | (1 << elf.STT_OBJECT) | (1 << elf.STT_FUNC) | (1 << elf.STT_COMMON); + const OK_BINDS = (1 << elf.STB_GLOBAL) | (1 << elf.STB_WEAK) | (1 << elf.STB_GNU_UNIQUE); var i: usize = 0; while (i < hashtab[1]) : (i += 1) { - if (0 == (@as(u32, 1) << @as(u5, @intCast(syms[i].st_info & 0xf)) & OK_TYPES)) continue; - if (0 == (@as(u32, 1) << @as(u5, @intCast(syms[i].st_info >> 4)) & OK_BINDS)) continue; + if (0 == (@as(u32, 1) << @as(u5, @intCast(syms[i].st_info & 0xf))) & OK_TYPES) continue; + if (0 == (@as(u32, 1) << @as(u5, @intCast(syms[i].st_info >> 4))) & OK_BINDS) continue; if (0 == syms[i].st_shndx) continue; const sym_name = @as([*:0]u8, @ptrCast(strings + syms[i].st_name)); if (!mem.eql(u8, name, mem.sliceTo(sym_name, 0))) continue; diff --git a/lib/std/os/uefi/status.zig b/lib/std/os/uefi/status.zig index 2e17ef64c98a6af1a43e44a88deb8f0d0eb72ea7..b48694c22eb854613cd1cea3b20d0c9103c784f4 100644 --- a/lib/std/os/uefi/status.zig +++ b/lib/std/os/uefi/status.zig @@ -1,6 +1,6 @@ const testing = @import("std").testing; -const high_bit = 1 << @typeInfo(usize).int.bits - 1; +const high_bit = 1 << (@typeInfo(usize).int.bits - 1); pub const Status = enum(usize) { /// The operation completed successfully. diff --git a/lib/std/unicode.zig b/lib/std/unicode.zig index a6cd094800cc0a77fcd84394bc08736df7352b0f..9929be13e9ac09c0904c378cfe4248717a27973c 100644 --- a/lib/std/unicode.zig +++ b/lib/std/unicode.zig @@ -485,7 +485,7 @@ pub fn utf16DecodeSurrogatePair(surrogate_pair: []const u16) !u21 { const high_half: u21 = surrogate_pair[0]; const low_half = surrogate_pair[1]; if (!utf16IsLowSurrogate(low_half)) return error.ExpectedSecondSurrogateHalf; - return 0x10000 + ((high_half & 0x03ff) << 10) | (low_half & 0x03ff); + return (0x10000 + ((high_half & 0x03ff) << 10)) | (low_half & 0x03ff); } pub const Utf16LeIterator = struct { diff --git a/lib/std/zig/Ast.zig b/lib/std/zig/Ast.zig index a0a2dda60d90503e92394892a82677b0d44a045a..14a16e1730564aa7add9e659dc81a76175b5a95c 100644 --- a/lib/std/zig/Ast.zig +++ b/lib/std/zig/Ast.zig @@ -555,6 +555,33 @@ pub fn renderError(tree: Ast, parse_error: Error, w: *Writer) Writer.Error!void .var_const_decl => { return w.writeAll("use 'var' or 'const' to declare variable"); }, + .ambiguous_operator_precedence => { + return w.print("ambiguous operator precedence with operators … {s} … {s} …; use parentheses to disambiguate", .{ + tree.tokenTag(parse_error.token - @as(u32, @intCast(parse_error.extra.offset))).lexeme().?, + tree.tokenTag(parse_error.token).lexeme().?, + }); + }, + .previous_ambiguous_operator => { + return w.writeAll("previous ambiguous operator here"); + }, + .illegal_chained_operators => { + return w.print("repetition of non-chainable operators … {s} … {s} …; use parentheses to disambiguate", .{ + tree.tokenTag(parse_error.token - @as(u32, @intCast(parse_error.extra.offset))).lexeme().?, + tree.tokenTag(parse_error.token).lexeme().?, + }); + }, + .hint_operator_precedence_left => { + return w.print("did you mean `(… {s} …) {s} …` ?", .{ + tree.tokenTag(parse_error.token - @as(u32, @intCast(parse_error.extra.offset))).lexeme().?, + tree.tokenTag(parse_error.token).lexeme().?, + }); + }, + .hint_operator_precedence_right => { + return w.print("did you mean `… {s} (… {s} …)` ?", .{ + tree.tokenTag(parse_error.token - @as(u32, @intCast(parse_error.extra.offset))).lexeme().?, + tree.tokenTag(parse_error.token).lexeme().?, + }); + }, .invalid_byte => { const tok_slice = tree.source[tree.tokens.items(.start)[parse_error.token]..]; @@ -2893,6 +2920,11 @@ pub const Error = struct { expected_var_const, wrong_equal_var_decl, var_const_decl, + ambiguous_operator_precedence, + previous_ambiguous_operator, + hint_operator_precedence_left, + hint_operator_precedence_right, + illegal_chained_operators, zig_style_container, previous_field, diff --git a/lib/std/zig/Ast/Render.zig b/lib/std/zig/Ast/Render.zig index 79916610ecfb2112fb077e07e5d6a230761fea3a..f4cfed386044725ea7074d584d1879ac42b33777 100644 --- a/lib/std/zig/Ast/Render.zig +++ b/lib/std/zig/Ast/Render.zig @@ -1483,9 +1483,9 @@ fn renderThenElse( last_else_token = error_token + 1; // | } - const indent_else_expr = indent_then_expr and + const indent_else_expr = (indent_then_expr and !nodeIsBlock(tree.nodeTag(else_expr)) and - !nodeIsIfForWhileSwitch(tree.nodeTag(else_expr)) or + !nodeIsIfForWhileSwitch(tree.nodeTag(else_expr))) or tree.tokenTag(tree.firstToken(else_expr)) == .multiline_string_literal_line; if (indent_else_expr) { @@ -3195,7 +3195,7 @@ fn renderComments(r: *Render, start: usize, end: usize) Error!bool { } } - index = 1 + (newline orelse end - 1); + index = 1 + (newline orelse (end - 1)); const comment_content = mem.trimStart(u8, trimmed_comment["//".len..], &std.ascii.whitespace); if (ais.disabled_offset != null and mem.eql(u8, comment_content, "zig fmt: on")) { diff --git a/lib/std/zig/Parse.zig b/lib/std/zig/Parse.zig index facb74a006b5389a61bcc6a089234028fa0b1128..79e90e487284339b5a438e15bbdb8fc40b9a27ef 100644 --- a/lib/std/zig/Parse.zig +++ b/lib/std/zig/Parse.zig @@ -1512,7 +1512,7 @@ fn expectAssignExpr(p: *Parse) !Node.Index { } fn parseExpr(p: *Parse) Error!?Node.Index { - return p.parseExprPrecedence(0); + return p.parseExprPrecedence(.start, p.tok_i); } fn expectExpr(p: *Parse) Error!Node.Index { @@ -1524,67 +1524,317 @@ const Assoc = enum { none, }; +const PrecClass = struct { + group: Group, + assoc: Assoc = Assoc.left, + + const Group = enum { + const num_distinct = std.meta.fieldNames(Group).len; + + arithmetic_product_chainable, + arithmetic_mod_nonchainable, + arithmetic_sum, + + bitwise_shift, + bitwise_and, + bitwise_xor, + bitwise_or, + + comparison, + + bool_and, + bool_or, + + recovery_orelse, + recovery_catch, + + root, + + /// For this to work correctly we require that all subgroups are strictly adjacent + /// Major groups are defined by the first text before an underscore + const Major: type = b: { + var major_names: []const []const u8 = &.{}; + for (std.meta.fieldNames(Group)) |fieldname| { + var major_name: []const u8 = fieldname[0..]; + for (fieldname, 0..) |c, i| { + if (c == '_') { + major_name = fieldname[0..i]; + break; + } + } + if (major_names.len == 0 or !std.mem.eql(u8, major_name, major_names[major_names.len - 1])) { + major_names = major_names ++ &[1][]const u8{major_name}; + } + } + + const IntType = std.math.IntFittingRange(0, major_names.len - 1); + var values: [major_names.len]IntType = undefined; + for (0..major_names.len) |i| values[i] = i; + + break :b @Enum( + IntType, + .exhaustive, + major_names, + &values, + ); + }; + }; + + pub const start: PrecClass = .{ .group = .root }; + + pub const Rel = enum(i2) { + lt = -1, + eq = 0, + gt = 1, + + fn inverted(self: Rel) Rel { + return @enumFromInt(-@intFromEnum(self)); + } + }; + + const PrecedenceArray = [Group.num_distinct][Group.num_distinct]?Rel; + + fn setMajorRelation(prec_array: *PrecedenceArray, major_a: Group.Major, rel: Rel, major_b: Group.Major) void { + for (std.meta.fieldNames(Group), 0..) |fieldname_i, i| { + if (!std.mem.startsWith(u8, fieldname_i, @tagName(major_a))) continue; + + for (std.meta.fieldNames(Group), 0..) |fieldname_j, j| { + if (!std.mem.startsWith(u8, fieldname_j, @tagName(major_b))) continue; + + prec_array.*[i][j] = rel; + } + } + } + + fn setMinorRelation(prec_array: *PrecedenceArray, minor_a: Group, rel: Rel, minor_b: Group) void { + prec_array.*[@intFromEnum(minor_a)][@intFromEnum(minor_b)] = rel; + } + + /// Arithmetic_* > Comparison + /// Bitwise_* > Comparison + /// Comparison > Bool_* > Root + /// Recovery > Root + /// + /// *_Product > *_Sum + /// + /// order[y][x] --> y cmp x + const precedence_ordering = b: { + @setEvalBranchQuota(20_000); + const major_greater_than_relations = [_][2]Group.Major{ + // zig fmt: off + .{ .arithmetic, .comparison }, + .{ .bitwise, .comparison }, + .{ .comparison, .bool }, + .{ .bool, .root }, + .{ .recovery, .root }, + // zig fmt: on + }; + + var order: PrecedenceArray = @splat(@splat(null)); + + for (major_greater_than_relations) |relation| { + setMajorRelation(&order, relation[0], .gt, relation[1]); + } + + setMinorRelation(&order, .arithmetic_mod_nonchainable, .gt, .arithmetic_sum); + setMinorRelation(&order, .arithmetic_product_chainable, .gt, .arithmetic_sum); + + computeTransativeOrdering(&order); + break :b order; + }; + + /// Uses the table from Zig-0.16.0 + /// * / % *% *| || + /// + - ++ +% -% +| -| + /// << >> <<| + /// & ^ | orelse catch + /// == != < > <= >= + /// and + /// or + const v16_precedence_ordering = b: { + @setEvalBranchQuota(20_000); + + var order: PrecedenceArray = @splat(@splat(null)); + + setMinorRelation(&order, .arithmetic_product_chainable, .eq, .arithmetic_mod_nonchainable); + setMinorRelation(&order, .arithmetic_mod_nonchainable, .gt, .arithmetic_sum); + setMinorRelation(&order, .arithmetic_product_chainable, .gt, .arithmetic_sum); + + setMinorRelation(&order, .arithmetic_sum, .gt, .bitwise_shift); + + // Here since the transative ordering computer cant leverage equals to derive a = b < c --> a < c, we have to manually list these + setMinorRelation(&order, .bitwise_shift, .gt, .bitwise_and); + setMinorRelation(&order, .bitwise_shift, .gt, .bitwise_xor); + setMinorRelation(&order, .bitwise_shift, .gt, .bitwise_or); + setMinorRelation(&order, .bitwise_shift, .gt, .recovery_catch); + setMinorRelation(&order, .bitwise_shift, .gt, .recovery_orelse); + + setMinorRelation(&order, .bitwise_and, .eq, .bitwise_xor); + setMinorRelation(&order, .bitwise_xor, .eq, .bitwise_or); + setMinorRelation(&order, .bitwise_or, .eq, .recovery_catch); + setMinorRelation(&order, .recovery_catch, .eq, .recovery_orelse); + setMinorRelation(&order, .recovery_orelse, .eq, .bitwise_and); + + setMinorRelation(&order, .bitwise_and, .gt, .comparison); + setMinorRelation(&order, .bitwise_xor, .gt, .comparison); + setMinorRelation(&order, .bitwise_or, .gt, .comparison); + setMinorRelation(&order, .recovery_catch, .gt, .comparison); + setMinorRelation(&order, .recovery_orelse, .gt, .comparison); + + setMinorRelation(&order, .comparison, .gt, .bool_and); + + setMinorRelation(&order, .bool_and, .gt, .bool_or); + + setMinorRelation(&order, .bool_or, .gt, .root); + + computeTransativeOrdering(&order); + for (order) |row| { + for (row) |item| { + if (item == null) @compileError("Null entry in old precedence ordering which had none."); + } + } + break :b order; + }; + + pub fn cmp(lhs: PrecClass, rhs: PrecClass) ?Rel { + return PrecClass.precedence_ordering[@intFromEnum(lhs.group)][@intFromEnum(rhs.group)]; + } + + pub fn v16_cmp(lhs: PrecClass, rhs: PrecClass) Rel { + return PrecClass.v16_precedence_ordering[@intFromEnum(lhs.group)][@intFromEnum(rhs.group)].?; + } + + fn computeTransativeOrdering(order: *PrecedenceArray) void { + for (0..Group.num_distinct) |i| for (0..Group.num_distinct) |j| for (0..Group.num_distinct) |k| { + if (order[i][k] == order[k][j] and order[i][k] != null) order[i][j] = order[i][k]; + }; + for (0..Group.num_distinct) |i| for (0..Group.num_distinct) |j| { + if (i == j) order[i][j] = .eq; + if (order[i][j] == null and order[j][i] != null) order[i][j] = order[j][i].?.inverted(); + }; + } +}; + const OperInfo = struct { - prec: i8, + prec: PrecClass, tag: Node.Tag, - assoc: Assoc = Assoc.left, }; -// A table of binary operator information. Higher precedence numbers are -// stickier. All operators at the same precedence level should have the same -// associativity. -const operTable = std.enums.directEnumArrayDefault(Token.Tag, OperInfo, .{ .prec = -1, .tag = Node.Tag.root }, 0, .{ - .keyword_or = .{ .prec = 10, .tag = .bool_or }, - - .keyword_and = .{ .prec = 20, .tag = .bool_and }, - - .equal_equal = .{ .prec = 30, .tag = .equal_equal, .assoc = Assoc.none }, - .bang_equal = .{ .prec = 30, .tag = .bang_equal, .assoc = Assoc.none }, - .angle_bracket_left = .{ .prec = 30, .tag = .less_than, .assoc = Assoc.none }, - .angle_bracket_right = .{ .prec = 30, .tag = .greater_than, .assoc = Assoc.none }, - .angle_bracket_left_equal = .{ .prec = 30, .tag = .less_or_equal, .assoc = Assoc.none }, - .angle_bracket_right_equal = .{ .prec = 30, .tag = .greater_or_equal, .assoc = Assoc.none }, - - .ampersand = .{ .prec = 40, .tag = .bit_and }, - .caret = .{ .prec = 40, .tag = .bit_xor }, - .pipe = .{ .prec = 40, .tag = .bit_or }, - .keyword_orelse = .{ .prec = 40, .tag = .@"orelse" }, - .keyword_catch = .{ .prec = 40, .tag = .@"catch" }, - - .angle_bracket_angle_bracket_left = .{ .prec = 50, .tag = .shl }, - .angle_bracket_angle_bracket_left_pipe = .{ .prec = 50, .tag = .shl_sat }, - .angle_bracket_angle_bracket_right = .{ .prec = 50, .tag = .shr }, - - .plus = .{ .prec = 60, .tag = .add }, - .minus = .{ .prec = 60, .tag = .sub }, - .plus_plus = .{ .prec = 60, .tag = .array_cat }, - .plus_percent = .{ .prec = 60, .tag = .add_wrap }, - .minus_percent = .{ .prec = 60, .tag = .sub_wrap }, - .plus_pipe = .{ .prec = 60, .tag = .add_sat }, - .minus_pipe = .{ .prec = 60, .tag = .sub_sat }, - - .pipe_pipe = .{ .prec = 70, .tag = .merge_error_sets }, - .asterisk = .{ .prec = 70, .tag = .mul }, - .slash = .{ .prec = 70, .tag = .div }, - .percent = .{ .prec = 70, .tag = .mod }, - .asterisk_percent = .{ .prec = 70, .tag = .mul_wrap }, - .asterisk_pipe = .{ .prec = 70, .tag = .mul_sat }, +const operTable = std.enums.directEnumArrayDefault(Token.Tag, OperInfo, .{ .prec = .start, .tag = Node.Tag.root }, 0, .{ + // zig fmt: off + .keyword_or = .{ .prec = .{ .group = .bool_or }, .tag = .bool_or }, + + .keyword_and = .{ .prec = .{ .group = .bool_and }, .tag = .bool_and }, + + .equal_equal = .{ .prec = .{ .group = .comparison, .assoc = Assoc.none }, .tag = .equal_equal }, + .bang_equal = .{ .prec = .{ .group = .comparison, .assoc = Assoc.none }, .tag = .bang_equal }, + .angle_bracket_left = .{ .prec = .{ .group = .comparison, .assoc = Assoc.none }, .tag = .less_than }, + .angle_bracket_right = .{ .prec = .{ .group = .comparison, .assoc = Assoc.none }, .tag = .greater_than }, + .angle_bracket_left_equal = .{ .prec = .{ .group = .comparison, .assoc = Assoc.none }, .tag = .less_or_equal }, + .angle_bracket_right_equal = .{ .prec = .{ .group = .comparison, .assoc = Assoc.none }, .tag = .greater_or_equal }, + + .ampersand = .{ .prec = .{ .group = .bitwise_and }, .tag = .bit_and }, + .caret = .{ .prec = .{ .group = .bitwise_xor }, .tag = .bit_xor }, + .pipe = .{ .prec = .{ .group = .bitwise_or }, .tag = .bit_or }, + + .keyword_orelse = .{ .prec = .{ .group = .recovery_orelse }, .tag = .@"orelse" }, + .keyword_catch = .{ .prec = .{ .group = .recovery_catch }, .tag = .@"catch" }, + + .angle_bracket_angle_bracket_left = .{ .prec = .{ .group = .bitwise_shift, .assoc = Assoc.none }, .tag = .shl }, + .angle_bracket_angle_bracket_left_pipe = .{ .prec = .{ .group = .bitwise_shift, .assoc = Assoc.none }, .tag = .shl_sat }, + .angle_bracket_angle_bracket_right = .{ .prec = .{ .group = .bitwise_shift, .assoc = Assoc.none }, .tag = .shr }, + + .plus = .{ .prec = .{ .group = .arithmetic_sum }, .tag = .add }, + .minus = .{ .prec = .{ .group = .arithmetic_sum }, .tag = .sub }, + .plus_plus = .{ .prec = .{ .group = .arithmetic_sum }, .tag = .array_cat }, + .plus_percent = .{ .prec = .{ .group = .arithmetic_sum }, .tag = .add_wrap }, + .minus_percent = .{ .prec = .{ .group = .arithmetic_sum }, .tag = .sub_wrap }, + .plus_pipe = .{ .prec = .{ .group = .arithmetic_sum }, .tag = .add_sat }, + .minus_pipe = .{ .prec = .{ .group = .arithmetic_sum }, .tag = .sub_sat }, + + .pipe_pipe = .{ .prec = .{ .group = .arithmetic_product_chainable }, .tag = .merge_error_sets }, + .asterisk = .{ .prec = .{ .group = .arithmetic_product_chainable }, .tag = .mul }, + .slash = .{ .prec = .{ .group = .arithmetic_product_chainable }, .tag = .div }, + .asterisk_percent = .{ .prec = .{ .group = .arithmetic_product_chainable }, .tag = .mul_wrap }, + .asterisk_pipe = .{ .prec = .{ .group = .arithmetic_product_chainable }, .tag = .mul_sat }, + + .percent = .{ .prec = .{ .group = .arithmetic_mod_nonchainable, .assoc = Assoc.none }, .tag = .mod }, + // zig fmt: on }); -fn parseExprPrecedence(p: *Parse, min_prec: i32) Error!?Node.Index { - assert(min_prec >= 0); +fn parseExprPrecedence(p: *Parse, min_exc_prec: PrecClass, prev_token_const: u32) Error!?Node.Index { var node = try p.parsePrefixExpr() orelse return null; - var banned_prec: i8 = -1; + var prev_operator_token = prev_token_const; while (true) { const tok_tag = p.tokenTag(p.tok_i); - const info = operTable[@as(usize, @intCast(@backingInt(tok_tag)))]; - if (info.prec < min_prec) { + const info = operTable[@intFromEnum(tok_tag)]; + + const rel = info.prec.cmp(min_exc_prec) orelse b: { + const prev_op_tok_tag = p.tokenTag(prev_operator_token); + const prev_op_info = operTable[@intFromEnum(prev_op_tok_tag)]; + const v16_rel = prev_op_info.prec.v16_cmp(info.prec); + try p.warnMsg(.{ + .tag = .ambiguous_operator_precedence, + .is_note = false, + .token = p.tok_i, + .extra = .{ .offset = p.tok_i - prev_operator_token }, + }); + try p.warnMsg(.{ + .tag = .previous_ambiguous_operator, + .is_note = true, + .token = prev_operator_token, + }); + if (v16_rel == .gt or v16_rel == .eq) { + try p.warnMsg(.{ + .tag = .hint_operator_precedence_left, + .is_note = true, + .token = p.tok_i, + .extra = .{ .offset = p.tok_i - prev_operator_token }, + }); + } else { + try p.warnMsg(.{ + .tag = .hint_operator_precedence_right, + .is_note = true, + .token = p.tok_i, + .extra = .{ .offset = p.tok_i - prev_operator_token }, + }); + } + break :b .gt; + }; + + if (rel == .lt) { break; } - if (info.prec == banned_prec) { - return p.fail(.chained_comparison_operators); + + if (min_exc_prec.group == info.prec.group and min_exc_prec.assoc == .none and info.prec.assoc == .none) { + //Special cased check to maintain the old more helpful error for chained comparisons. + if (info.prec.group == .comparison) { + try p.warn(.chained_comparison_operators); + } else { + try p.warnMsg(.{ + .tag = .illegal_chained_operators, + .is_note = false, + .token = p.tok_i, + .extra = .{ .offset = p.tok_i - prev_operator_token }, + }); + try p.warnMsg(.{ + .tag = .previous_ambiguous_operator, + .is_note = true, + .token = prev_operator_token, + }); + try p.warnMsg(.{ + .tag = .hint_operator_precedence_left, + .is_note = true, + .token = p.tok_i, + .extra = .{ .offset = p.tok_i - prev_operator_token }, + }); + } + } + + if (rel == .eq) { + break; } const oper_token = p.nextToken(); @@ -1614,7 +1864,8 @@ fn parseExprPrecedence(p: *Parse, min_prec: i32) Error!?Node.Index { } } - const rhs = try p.parseExprPrecedence(info.prec + 1) orelse { + prev_operator_token = oper_token; + const rhs = try p.parseExprPrecedence(info.prec, prev_operator_token) orelse { try p.warn(.expected_expr); return node; }; @@ -1624,10 +1875,6 @@ fn parseExprPrecedence(p: *Parse, min_prec: i32) Error!?Node.Index { .main_token = oper_token, .data = .{ .node_and_node = .{ node, rhs } }, }); - - if (info.assoc == Assoc.none) { - banned_prec = info.prec; - } } return node; diff --git a/lib/std/zig/TokenSmith.zig b/lib/std/zig/TokenSmith.zig index cdc30da0f2f9cba86bf0b508d1f5b627f25feb9a..43829781aee29063c1493072ebd129ef0b671299 100644 --- a/lib/std/zig/TokenSmith.zig +++ b/lib/std/zig/TokenSmith.zig @@ -160,7 +160,7 @@ pub fn gen(smith: *Smith) TokenSmith { var no_period = false; var not_exponent = true; for (t.source_buf[t.source_len..][0..len], 0..) |*c, i| { - const invalid_period = no_period and c.* == '.' or i + 1 == len; + const invalid_period = (no_period and c.* == '.') or i + 1 == len; const is_exponent = c.* == '-' or c.* == '+'; const invalid_exponent = not_exponent and is_exponent; const valid_exponent = !not_exponent and is_exponent; diff --git a/lib/std/zig/llvm/BitcodeReader.zig b/lib/std/zig/llvm/BitcodeReader.zig index f32a85e01e36dd7176871fdac0fef32ee2d5a8e7..0e96d0ac5963d405384674d49bd94eeb88e017dc 100644 --- a/lib/std/zig/llvm/BitcodeReader.zig +++ b/lib/std/zig/llvm/BitcodeReader.zig @@ -404,7 +404,7 @@ fn readFixed(bc: *BitcodeReader, comptime T: type, bits: u7) !T { if (bc.bit_offset == 0) bc.bit_buffer = try bc.read32Bits(); const chunk_len = @min(@as(u6, 32) - bc.bit_offset, remaining); const chunk_mask = @as(u32, std.math.maxInt(u32)) >> @intCast(32 - chunk_len); - result |= @as(T, @intCast(bc.bit_buffer >> bc.bit_offset & chunk_mask)) << @intCast(shift); + result |= @as(T, @intCast((bc.bit_buffer >> bc.bit_offset) & chunk_mask)) << @intCast(shift); shift += @intCast(chunk_len); remaining -= chunk_len; bc.bit_offset = @truncate(bc.bit_offset + chunk_len); diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig index 16a4f283ce6ccf976af56428e5ac996c94138bdf..5cf1765116b517eafe92790d5cb2542ede043b83 100644 --- a/lib/std/zig/llvm/Builder.zig +++ b/lib/std/zig/llvm/Builder.zig @@ -1076,7 +1076,7 @@ pub const Type = enum(u32) { child: Type, fn length(self: Array) u64 { - return @as(u64, self.len_hi) << 32 | self.len_lo; + return (@as(u64, self.len_hi) << 32) | self.len_lo; } }; @@ -9520,7 +9520,7 @@ pub const Metadata = packed struct(u32) { size_in_bits_hi: u32, pub fn bitSize(self: BasicType) u64 { - return @as(u64, self.size_in_bits_hi) << 32 | self.size_in_bits_lo; + return (@as(u64, self.size_in_bits_hi) << 32) | self.size_in_bits_lo; } }; @@ -9537,10 +9537,10 @@ pub const Metadata = packed struct(u32) { fields_tuple: Metadata.Optional, pub fn bitSize(self: CompositeType) u64 { - return @as(u64, self.size_in_bits_hi) << 32 | self.size_in_bits_lo; + return (@as(u64, self.size_in_bits_hi) << 32) | self.size_in_bits_lo; } pub fn bitAlign(self: CompositeType) u64 { - return @as(u64, self.align_in_bits_hi) << 32 | self.align_in_bits_lo; + return (@as(u64, self.align_in_bits_hi) << 32) | self.align_in_bits_lo; } }; @@ -9558,13 +9558,13 @@ pub const Metadata = packed struct(u32) { offset_in_bits_hi: u32, pub fn bitSize(self: DerivedType) u64 { - return @as(u64, self.size_in_bits_hi) << 32 | self.size_in_bits_lo; + return (@as(u64, self.size_in_bits_hi) << 32) | self.size_in_bits_lo; } pub fn bitAlign(self: DerivedType) u64 { - return @as(u64, self.align_in_bits_hi) << 32 | self.align_in_bits_lo; + return (@as(u64, self.align_in_bits_hi) << 32) | self.align_in_bits_lo; } pub fn bitOffset(self: DerivedType) u64 { - return @as(u64, self.offset_in_bits_hi) << 32 | self.offset_in_bits_lo; + return (@as(u64, self.offset_in_bits_hi) << 32) | self.offset_in_bits_lo; } }; @@ -12457,7 +12457,7 @@ fn doubleConstAssumeCapacity(self: *Builder, val: f64) Constant { if (ctx.builder.constant_items.items(.tag)[rhs_index] != .double) return false; const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index]; const rhs_extra = ctx.builder.constantExtraData(Constant.Double, rhs_data); - return @as(u64, @bitCast(lhs_key)) == @as(u64, rhs_extra.hi) << 32 | rhs_extra.lo; + return @as(u64, @bitCast(lhs_key)) == (@as(u64, rhs_extra.hi) << 32) | rhs_extra.lo; } }; const gop = self.constant_map.getOrPutAssumeCapacityAdapted(val, Adapter{ .builder = self }); @@ -12488,8 +12488,8 @@ fn fp128ConstAssumeCapacity(self: *Builder, val: f128) Constant { if (ctx.builder.constant_items.items(.tag)[rhs_index] != .fp128) return false; const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index]; const rhs_extra = ctx.builder.constantExtraData(Constant.Fp128, rhs_data); - return @as(u128, @bitCast(lhs_key)) == @as(u128, rhs_extra.hi_hi) << 96 | - @as(u128, rhs_extra.hi_lo) << 64 | @as(u128, rhs_extra.lo_hi) << 32 | rhs_extra.lo_lo; + return @as(u128, @bitCast(lhs_key)) == (@as(u128, rhs_extra.hi_hi) << 96) | + (@as(u128, rhs_extra.hi_lo) << 64) | (@as(u128, rhs_extra.lo_hi) << 32) | rhs_extra.lo_lo; } }; const gop = self.constant_map.getOrPutAssumeCapacityAdapted(val, Adapter{ .builder = self }); @@ -12522,8 +12522,8 @@ fn x86_fp80ConstAssumeCapacity(self: *Builder, val: f80) Constant { if (ctx.builder.constant_items.items(.tag)[rhs_index] != .x86_fp80) return false; const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index]; const rhs_extra = ctx.builder.constantExtraData(Constant.Fp80, rhs_data); - return @as(u80, @bitCast(lhs_key)) == @as(u80, rhs_extra.hi) << 64 | - @as(u80, rhs_extra.lo_hi) << 32 | rhs_extra.lo_lo; + return @as(u80, @bitCast(lhs_key)) == (@as(u80, rhs_extra.hi) << 64) | + (@as(u80, rhs_extra.lo_hi) << 32) | rhs_extra.lo_lo; } }; const gop = self.constant_map.getOrPutAssumeCapacityAdapted(val, Adapter{ .builder = self }); @@ -12555,8 +12555,8 @@ fn ppc_fp128ConstAssumeCapacity(self: *Builder, val: [2]f64) Constant { if (ctx.builder.constant_items.items(.tag)[rhs_index] != .ppc_fp128) return false; const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index]; const rhs_extra = ctx.builder.constantExtraData(Constant.Fp128, rhs_data); - return @as(u64, @bitCast(lhs_key[0])) == @as(u64, rhs_extra.lo_hi) << 32 | rhs_extra.lo_lo and - @as(u64, @bitCast(lhs_key[1])) == @as(u64, rhs_extra.hi_hi) << 32 | rhs_extra.hi_lo; + return @as(u64, @bitCast(lhs_key[0])) == (@as(u64, rhs_extra.lo_hi) << 32) | rhs_extra.lo_lo and + @as(u64, @bitCast(lhs_key[1])) == (@as(u64, rhs_extra.hi_hi) << 32) | rhs_extra.hi_lo; } }; const gop = self.constant_map.getOrPutAssumeCapacityAdapted(val, Adapter{ .builder = self }); @@ -15225,18 +15225,18 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco for (limbs) |*limb| { const val = std.mem.littleToNative(i64, @bitCast(limb.*)); limb.* = @bitCast(if (val >= 0) - val << 1 | 0 + (val << 1) | 0 else - -%val << 1 | 1); + (-%val << 1) | 1); } try constants_block.writeUnabbrev(5, record.items); continue; }; try constants_block.writeAbbrev(ConstantsBlock.Integer{ .value = @bitCast(if (val >= 0) - val << 1 | 0 + (val << 1) | 0 else - -%val << 1 | 1), + (-%val << 1) | 1), }); }, .half, @@ -15252,8 +15252,8 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco .x86_fp80 => { const extra = self.constantExtraData(Constant.Fp80, data); try constants_block.writeAbbrev(ConstantsBlock.Fp80{ - .hi = @as(u64, extra.hi) << 48 | @as(u64, extra.lo_hi) << 16 | - extra.lo_lo >> 16, + .hi = (@as(u64, extra.hi) << 48) | (@as(u64, extra.lo_hi) << 16) | + (extra.lo_lo >> 16), .lo = @truncate(extra.lo_lo), }); }, @@ -15262,8 +15262,8 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco => { const extra = self.constantExtraData(Constant.Fp128, data); try constants_block.writeAbbrev(ConstantsBlock.Fp128{ - .lo = @as(u64, extra.lo_hi) << 32 | @as(u64, extra.lo_lo), - .hi = @as(u64, extra.hi_hi) << 32 | @as(u64, extra.hi_lo), + .lo = (@as(u64, extra.lo_hi) << 32) | @as(u64, extra.lo_lo), + .hi = (@as(u64, extra.hi_hi) << 32) | @as(u64, extra.hi_lo), }); }, .array, @@ -15724,9 +15724,9 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco for (limbs) |*limb| { const val = std.mem.littleToNative(i64, @bitCast(limb.*)); limb.* = @bitCast(if (val >= 0) - val << 1 | 0 + (val << 1) | 0 else - -%val << 1 | 1); + (-%val << 1) | 1); } try metadata_block.writeUnabbrev(@backingInt(MetadataBlock.Code.ENUMERATOR), record.items); continue; @@ -15736,9 +15736,9 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco .bit_width = extra.bit_width, .name = extra.name, .value = @bitCast(if (val >= 0) - val << 1 | 0 + (val << 1) | 0 else - -%val << 1 | 1), + (-%val << 1) | 1), }, metadata_adapter); }, .subrange => { diff --git a/lib/std/zig/llvm/bitcode_writer.zig b/lib/std/zig/llvm/bitcode_writer.zig index 0ee722165be0a39a2695d4f23f249c6e2a8299f0..9c9e9d4473c26e2c1b9fa0e63befb5bbc420fc02 100644 --- a/lib/std/zig/llvm/bitcode_writer.zig +++ b/lib/std/zig/llvm/bitcode_writer.zig @@ -102,7 +102,7 @@ pub fn BitcodeWriter(comptime types: []const type) type { // If input is larger than one VBR block can store // then store vbr_bits - 1 bits and a continue bit while (in_buffer > mask) { - try self.writeBits(in_buffer & mask | continue_bit, vbr_bits); + try self.writeBits((in_buffer & mask) | continue_bit, vbr_bits); in_buffer >>= @intCast(vbr_bits - 1); } diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig index f8b93bd4c960502651073a3097cfc80195f05022..696515cdf62614c4a477256b5dcc5b641ba4d6d7 100644 --- a/lib/std/zig/parser_test.zig +++ b/lib/std/zig/parser_test.zig @@ -3046,19 +3046,14 @@ test "zig fmt: precedence" { \\ !(a{}); \\ a + b{}; \\ (a + b){}; - \\ a << b + c; \\ (a << b) + c; - \\ a & b << c; \\ (a & b) << c; - \\ a ^ b & c; \\ (a ^ b) & c; - \\ a | b ^ c; \\ (a | b) ^ c; \\ a == b | c; \\ (a == b) | c; \\ a and b == c; \\ (a and b) == c; - \\ a or b and c; \\ (a or b) and c; \\ (a or b) and c; \\ a == b and c == d; @@ -3067,6 +3062,47 @@ test "zig fmt: precedence" { ); } +test "zig fmt: ambiguous precedence" { + try testError( + \\test "ambiguous precedence" { + \\ a & b << c; + \\ a << b + c; + \\ a << b | c; + \\ a ^ b & c; + \\ a | b ^ c; + \\ a or b and c; + \\ a orelse b catch c; + \\ a % b % c; + \\} + \\ + , &[_]Error{ + .ambiguous_operator_precedence, + .previous_ambiguous_operator, + .hint_operator_precedence_right, + .ambiguous_operator_precedence, + .previous_ambiguous_operator, + .hint_operator_precedence_right, + .ambiguous_operator_precedence, + .previous_ambiguous_operator, + .hint_operator_precedence_left, + .ambiguous_operator_precedence, + .previous_ambiguous_operator, + .hint_operator_precedence_left, + .ambiguous_operator_precedence, + .previous_ambiguous_operator, + .hint_operator_precedence_left, + .ambiguous_operator_precedence, + .previous_ambiguous_operator, + .hint_operator_precedence_right, + .ambiguous_operator_precedence, + .previous_ambiguous_operator, + .hint_operator_precedence_left, + .illegal_chained_operators, + .previous_ambiguous_operator, + .hint_operator_precedence_left, + }); +} + test "zig fmt: prefix operators" { try testCanonical( \\test "prefix operators" { @@ -7205,7 +7241,7 @@ test "recovery: missing comma" { \\ 2 => {} \\ 3 => {} \\ else => { - \\ foo & bar +; + \\ foo & bar &; \\ } \\ } \\} diff --git a/lib/std/zig/system.zig b/lib/std/zig/system.zig index 41de483284a972e2f6e87668b739fba5592415ae..70e2d4b6dd25d25f20b995e5d262f7a631a81151 100644 --- a/lib/std/zig/system.zig +++ b/lib/std/zig/system.zig @@ -266,8 +266,8 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target { // Minor * 1(0),000 summed has been convention since FreeBSD 2.2 (1997) // e.g. 492101 = 4.11-STABLE = 4.(9+2) const major = value / 100_000; - const minor1 = value % 100_000 / 10_000; // usually 0 since 5.1 - const minor2 = value % 10_000 / 1_000; // 0 before 5.1, minor version since + const minor1 = (value % 100_000) / 10_000; // usually 0 since 5.1 + const minor2 = (value % 10_000) / 1_000; // 0 before 5.1, minor version since const patch = value % 1_000; os.version_range.semver.min = .{ .major = major, .minor = minor1 + minor2, .patch = patch }; os.version_range.semver.max = os.version_range.semver.min; @@ -280,8 +280,8 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target { // r = 0 (*) // p = patchlevel const major = value / 100_000_000; - const minor = value % 100_000_000 / 1_000_000; - const patch = value % 10_000 / 100; + const minor = (value % 100_000_000) / 1_000_000; + const patch = (value % 10_000) / 100; os.version_range.semver.min = .{ .major = major, .minor = minor, .patch = patch }; os.version_range.semver.max = os.version_range.semver.min; }, @@ -292,7 +292,7 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target { // m = minor; odd-numbers indicate current dev branch // p = patch const major = value / 100_000; - const minor = value % 100_000 / 100; + const minor = (value % 100_000) / 100; const patch = value % 100; os.version_range.semver.min = .{ .major = major, .minor = minor, .patch = patch }; os.version_range.semver.max = os.version_range.semver.min; diff --git a/lib/std/zig/system/windows.zig b/lib/std/zig/system/windows.zig index 0df7d598572cc91192a7a2b5b11684cfd77dec7c..65ecc9f3ff8b84d1981765f29343a723cbe1ba54 100644 --- a/lib/std/zig/system/windows.zig +++ b/lib/std/zig/system/windows.zig @@ -25,7 +25,7 @@ pub fn detectRuntimeVersion() WindowsVersion { // `---` `` ``--> Sub-version (Starting from Windows 10 onwards) // \ `--> Service pack (Always zero in the constants defined) // `--> OS version (Major & minor) - const os_ver: u16 = @as(u16, @intCast(version_info.dwMajorVersion & 0xff)) << 8 | + const os_ver: u16 = (@as(u16, @intCast(version_info.dwMajorVersion & 0xff)) << 8) | @as(u16, @intCast(version_info.dwMinorVersion & 0xff)); const sp_ver: u8 = 0; const sub_ver: u8 = if (os_ver >= 0x0A00) subver: { @@ -40,7 +40,7 @@ pub fn detectRuntimeVersion() WindowsVersion { break :subver @as(u8, @truncate(last_idx)); } else 0; - const version: u32 = @as(u32, os_ver) << 16 | @as(u16, sp_ver) << 8 | sub_ver; + const version: u32 = (@as(u32, os_ver) << 16) | (@as(u16, sp_ver) << 8) | sub_ver; return @as(WindowsVersion, @fromBackingInt(@intCast(version))); } diff --git a/src/Air.zig b/src/Air.zig index 56d2e22b8c8f994cec690ce9d2661001dea16223..c786837dbf773b88868217f130b433b82a53d655 100644 --- a/src/Air.zig +++ b/src/Air.zig @@ -1505,7 +1505,7 @@ pub const ShuffleTwoMask = enum(u32) { return @fromBackingInt(@intCast(idx << 1)); } pub fn bElem(idx: u32) ShuffleTwoMask { - return @fromBackingInt(@intCast(idx << 1 | 1)); + return @fromBackingInt(@intCast((idx << 1) | 1)); } pub const Unwrapped = union(enum) { /// The resulting element is this index into the first runtime vector. diff --git a/src/Compilation.zig b/src/Compilation.zig index 94dad2b74fa251bafaa9dd8246d52d8e45fdf0e1..886b46179a789159d76b2b782f249d9a079ef370 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -1990,7 +1990,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, .path = try options.dirs.global_cache.join(arena, &.{zir_sub_dir}), }; - const std_mod = options.std_mod orelse Module.create(arena, .{ + const std_mod = options.std_mod orelse (Module.create(arena, .{ .paths = .{ .root = try .fromRoot(arena, options.dirs, .zig_lib, "std"), .root_src_path = "std.zig", @@ -2015,7 +2015,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, error.StackProtectorUnsupportedByTarget => unreachable, error.StackProtectorUnavailableWithoutLibC => unreachable, error.PatchableFunctionEntryUnsupportedByBackend => unreachable, - }; + }); const zcu = try arena.create(Zcu); zcu.* = .{ diff --git a/src/IncrementalDebugServer.zig b/src/IncrementalDebugServer.zig index c8cb5a26907835fa808d8f05eb6ba1d567131dc5..3e696d49ab3758b54e682de46ceba04d82337a71 100644 --- a/src/IncrementalDebugServer.zig +++ b/src/IncrementalDebugServer.zig @@ -243,7 +243,7 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const for (zcu.incremental_debug_state.types.keys()) |type_ip_index| { const ty: Type = .fromInterned(type_ip_index); const ty_name = ty.containerTypeName(ip).fqn.toSlice(ip); - const success = switch (@as(u2, @intFromBool(anchor_start)) << 1 | @intFromBool(anchor_end)) { + const success = switch ((@as(u2, @intFromBool(anchor_start)) << 1) | @intFromBool(anchor_end)) { 0b00 => std.mem.find(u8, ty_name, query) != null, 0b01 => std.mem.endsWith(u8, ty_name, query), 0b10 => std.mem.startsWith(u8, ty_name, query), @@ -264,7 +264,7 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const for (zcu.incremental_debug_state.navs.keys()) |nav_index| { const nav = ip.getNav(nav_index); const nav_fqn = nav.fqn.toSlice(ip); - const success = switch (@as(u2, @intFromBool(anchor_start)) << 1 | @intFromBool(anchor_end)) { + const success = switch ((@as(u2, @intFromBool(anchor_start)) << 1) | @intFromBool(anchor_end)) { 0b00 => std.mem.find(u8, nav_fqn, query) != null, 0b01 => std.mem.endsWith(u8, nav_fqn, query), 0b10 => std.mem.startsWith(u8, nav_fqn, query), diff --git a/src/InternPool.zig b/src/InternPool.zig index 77bf96a5f0a46a67a56e1d445d3a9d9e3ff4e5d7..8c076a75dfc977feea4b1dc0d75adb2e582bd00d 100644 --- a/src/InternPool.zig +++ b/src/InternPool.zig @@ -215,7 +215,7 @@ pub const TrackedInst = extern struct { }; pub fn unwrap(tracked_inst_index: TrackedInst.Index, ip: *const InternPool) Unwrapped { return .{ - .tid = @fromBackingInt(@intCast(@backingInt(tracked_inst_index) >> ip.tid_shift_32 & ip.getTidMask())), + .tid = @fromBackingInt(@intCast((@backingInt(tracked_inst_index) >> ip.tid_shift_32) & ip.getTidMask())), .index = @backingInt(tracked_inst_index) & ip.getIndexMask(u32), }; } @@ -517,7 +517,7 @@ pub const ComptimeUnit = extern struct { }; fn unwrap(id: Id, ip: *const InternPool) Unwrapped { return .{ - .tid = @fromBackingInt(@intCast(@backingInt(id) >> ip.tid_shift_32 & ip.getTidMask())), + .tid = @fromBackingInt(@intCast((@backingInt(id) >> ip.tid_shift_32) & ip.getTidMask())), .index = @backingInt(id) & ip.getIndexMask(u31), }; } @@ -655,7 +655,7 @@ pub const Nav = struct { }; fn unwrap(nav_index: Nav.Index, ip: *const InternPool) Unwrapped { return .{ - .tid = @fromBackingInt(@intCast(@backingInt(nav_index) >> ip.tid_shift_30 & ip.getTidMask())), + .tid = @fromBackingInt(@intCast((@backingInt(nav_index) >> ip.tid_shift_30) & ip.getTidMask())), .index = @backingInt(nav_index) & ip.getIndexMask(u30), }; } @@ -1627,7 +1627,7 @@ pub const MapIndex = enum(u32) { }; fn unwrap(map_index: MapIndex, ip: *const InternPool) Unwrapped { return .{ - .tid = @fromBackingInt(@intCast(@backingInt(map_index) >> ip.tid_shift_32 & ip.getTidMask())), + .tid = @fromBackingInt(@intCast((@backingInt(map_index) >> ip.tid_shift_32) & ip.getTidMask())), .index = @backingInt(map_index) & ip.getIndexMask(u32), }; } @@ -1648,14 +1648,14 @@ pub const NamespaceIndex = enum(u32) { assert(unwrapped.bucket_index <= ip.getIndexMask(u32) >> Local.namespaces_bucket_width); assert(unwrapped.index <= Local.namespaces_bucket_mask); return @fromBackingInt(@intCast(@shlExact(@as(u32, @backingInt(unwrapped.tid)), ip.tid_shift_32) | - unwrapped.bucket_index << Local.namespaces_bucket_width | + (unwrapped.bucket_index << Local.namespaces_bucket_width) | unwrapped.index)); } }; fn unwrap(namespace_index: NamespaceIndex, ip: *const InternPool) Unwrapped { const index = @backingInt(namespace_index) & ip.getIndexMask(u32); return .{ - .tid = @fromBackingInt(@intCast(@backingInt(namespace_index) >> ip.tid_shift_32 & ip.getTidMask())), + .tid = @fromBackingInt(@intCast((@backingInt(namespace_index) >> ip.tid_shift_32) & ip.getTidMask())), .bucket_index = index >> Local.namespaces_bucket_width, .index = index & Local.namespaces_bucket_mask, }; @@ -1696,7 +1696,7 @@ pub const FileIndex = enum(u32) { }; pub fn unwrap(file_index: FileIndex, ip: *const InternPool) Unwrapped { return .{ - .tid = @fromBackingInt(@intCast(@backingInt(file_index) >> ip.tid_shift_32 & ip.getTidMask())), + .tid = @fromBackingInt(@intCast((@backingInt(file_index) >> ip.tid_shift_32) & ip.getTidMask())), .index = @backingInt(file_index) & ip.getIndexMask(u32), }; } @@ -1755,7 +1755,7 @@ pub const String = enum(u32) { }; fn unwrap(string: String, ip: *const InternPool) Unwrapped { return .{ - .tid = @fromBackingInt(@intCast(@backingInt(string) >> ip.tid_shift_32 & ip.getTidMask())), + .tid = @fromBackingInt(@intCast((@backingInt(string) >> ip.tid_shift_32) & ip.getTidMask())), .index = @backingInt(string) & ip.getIndexMask(u32), }; } @@ -4199,7 +4199,7 @@ pub const Index = enum(u32) { }; pub fn unwrap(index: Index, ip: *const InternPool) Unwrapped { return .{ - .tid = @fromBackingInt(@intCast(@backingInt(index) >> ip.tid_shift_30 & ip.getTidMask())), + .tid = @fromBackingInt(@intCast((@backingInt(index) >> ip.tid_shift_30) & ip.getTidMask())), .index = @backingInt(index) & ip.getIndexMask(u30), }; } @@ -6062,7 +6062,7 @@ pub const PtrNav = struct { }; } fn byteOffset(data: @This()) u64 { - return @as(u64, data.byte_offset_a) << 32 | data.byte_offset_b; + return (@as(u64, data.byte_offset_a) << 32) | data.byte_offset_b; } }; @@ -6080,7 +6080,7 @@ pub const PtrUav = struct { }; } fn byteOffset(data: @This()) u64 { - return @as(u64, data.byte_offset_a) << 32 | data.byte_offset_b; + return (@as(u64, data.byte_offset_a) << 32) | data.byte_offset_b; } }; @@ -6101,7 +6101,7 @@ pub const PtrUavAligned = struct { }; } fn byteOffset(data: @This()) u64 { - return @as(u64, data.byte_offset_a) << 32 | data.byte_offset_b; + return (@as(u64, data.byte_offset_a) << 32) | data.byte_offset_b; } }; @@ -6119,7 +6119,7 @@ pub const PtrComptimeAlloc = struct { }; } fn byteOffset(data: @This()) u64 { - return @as(u64, data.byte_offset_a) << 32 | data.byte_offset_b; + return (@as(u64, data.byte_offset_a) << 32) | data.byte_offset_b; } }; @@ -6137,7 +6137,7 @@ pub const PtrComptimeField = struct { }; } fn byteOffset(data: @This()) u64 { - return @as(u64, data.byte_offset_a) << 32 | data.byte_offset_b; + return (@as(u64, data.byte_offset_a) << 32) | data.byte_offset_b; } }; @@ -6155,7 +6155,7 @@ pub const PtrBase = struct { }; } fn byteOffset(data: @This()) u64 { - return @as(u64, data.byte_offset_a) << 32 | data.byte_offset_b; + return (@as(u64, data.byte_offset_a) << 32) | data.byte_offset_b; } }; @@ -6175,7 +6175,7 @@ pub const PtrBaseIndex = struct { }; } fn byteOffset(data: @This()) u64 { - return @as(u64, data.byte_offset_a) << 32 | data.byte_offset_b; + return (@as(u64, data.byte_offset_a) << 32) | data.byte_offset_b; } }; @@ -6191,7 +6191,7 @@ pub const PtrInt = struct { }; } fn byteOffset(data: @This()) u64 { - return @as(u64, data.byte_offset_a) << 32 | data.byte_offset_b; + return (@as(u64, data.byte_offset_a) << 32) | data.byte_offset_b; } }; @@ -12634,7 +12634,7 @@ const PackedCallingConvention = packed struct(u18) { std.lang.CallingConvention.SpirvFragmentOptions => .{ .tag = tag, .incoming_stack_alignment = .none, - .extra = @as(u4, @backingInt(pl.depth_assumption)) << 1 | @intFromBool(pl.pixel_centered_integer), + .extra = (@as(u4, @backingInt(pl.depth_assumption)) << 1) | @intFromBool(pl.pixel_centered_integer), }, std.lang.CallingConvention.SpirvMeshOptions => .{ .tag = tag, diff --git a/src/Sema.zig b/src/Sema.zig index e5ee288187f627f9438a64f3d91eac833268ed9c..971b0f6835b590ed3274fa2606408544797838ee 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -29942,10 +29942,10 @@ fn coerceVarArgParam( if (!uncasted_ty.validateExtern(.param_ty, zcu)) break :int inst; const target = zcu.getTarget(); const uncasted_info = uncasted_ty.intInfo(zcu); - if (uncasted_info.bits <= target.cTypeBitSize(switch (uncasted_info.signedness) { + if (uncasted_info.bits <= (target.cTypeBitSize(switch (uncasted_info.signedness) { .signed => .int, .unsigned => .uint, - }) orelse break :int inst) break :int try sema.coerce(block, switch (uncasted_info.signedness) { + }) orelse break :int inst)) break :int try sema.coerce(block, switch (uncasted_info.signedness) { .signed => .c_int, .unsigned => .c_uint, }, inst, inst_src); diff --git a/src/codegen/aarch64/Assemble.zig b/src/codegen/aarch64/Assemble.zig index ec80072277625ee3f749d806534ec969587231fa..6e72682cf92e386b3d3630859a920cfd397671d6 100644 --- a/src/codegen/aarch64/Assemble.zig +++ b/src/codegen/aarch64/Assemble.zig @@ -164,7 +164,7 @@ const matchers = matchers: { return @call(.auto, encode, args); } else if (pattern_token[0] == '<') { const symbol_name = comptime pattern_token[1 .. std.mem.findScalarPos(u8, pattern_token, 1, '|') orelse - pattern_token.len - 1]; + (pattern_token.len - 1)]; const symbol = @field(Symbol, symbol_name); const symbol_ptr = &@field(symbols, symbol_name); const symbol_value = zonCast(SymbolSpec, @field(instruction.symbols, symbol_name), .{}).parse(source_token) orelse { @@ -453,7 +453,7 @@ const SymbolSpec = union(enum) { } else { const Repr = std.math.FloatRepr(f16); const repr: Repr = @bitCast(fimm); - if (repr.mantissa & std.math.maxInt(Repr.Mantissa) >> 5 != 0 or switch (repr.exponent) { + if ((repr.mantissa & (std.math.maxInt(Repr.Mantissa) >> 5)) != 0 or switch (repr.exponent) { .denormal, .infinite => true, else => std.math.cast(i3, repr.exponent.unbias() - 1) == null, }) { diff --git a/src/codegen/aarch64/Disassemble.zig b/src/codegen/aarch64/Disassemble.zig index 76e2b89f4f962cbed82cdb8a2695f15f066b5cb2..2f0450aacea53118c1675125ec44d237f222e244 100644 --- a/src/codegen/aarch64/Disassemble.zig +++ b/src/codegen/aarch64/Disassemble.zig @@ -31,7 +31,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr .unallocated => break :unallocated, .pc_relative_addressing => |pc_relative_addressing| { const group = pc_relative_addressing.group; - const imm = (@as(i33, group.immhi) << 2 | @as(i33, group.immlo) << 0) + @as(i33, switch (group.op) { + const imm = ((@as(i33, group.immhi) << 2) | (@as(i33, group.immlo) << 0)) + @as(i33, switch (group.op) { .adr => aarch64.encoding.Instruction.size, .adrp => 0, }); @@ -311,7 +311,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr .hint => |hint| return writer.print("{f}{s}#0x{x}", .{ fmtCase(.hint, dis.case), dis.mnemonic_operands_separator, - @as(u7, hint.CRm) << 3 | @as(u7, hint.op2) << 0, + (@as(u7, hint.CRm) << 3) | (@as(u7, hint.op2) << 0), }), else => |decoded| return writer.print("{f}", .{fmtCase(decoded, dis.case)}), }, @@ -365,8 +365,8 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr dis.mnemonic_operands_separator, group.Rt.decode(.{}).general(@fromBackingInt(@intCast(group.b5))).fmtCase(dis.case), dis.operands_separator, - @as(u6, group.b5) << 5 | - @as(u6, group.b40) << 0, + (@as(u6, group.b5) << 5) | + (@as(u6, group.b40) << 0), dis.operands_separator, @as(u8, if (imm < 0) '-' else '+'), @abs(imm) << 2, diff --git a/src/codegen/aarch64/Mir.zig b/src/codegen/aarch64/Mir.zig index 1233a8180db0e726d2d2904eb2246734ad18ab56..d339069b3aba6ee3cd4157c764f3d0dceef21340 100644 --- a/src/codegen/aarch64/Mir.zig +++ b/src/codegen/aarch64/Mir.zig @@ -208,7 +208,7 @@ fn emitReloc( }; try atom.addReloc(gpa, .{ .r_offset = offset, - .r_info = @as(u64, @backingInt(sym_index)) << 32 | @backingInt(r_type), + .r_info = (@as(u64, @backingInt(sym_index)) << 32) | @backingInt(r_type), .r_addend = @bitCast(addend), }, zo); } else if (lf.cast(.macho)) |mf| { @@ -265,7 +265,7 @@ fn emitReloc( }; try atom.addReloc(gpa, .{ .r_offset = offset, - .r_info = @as(u64, @backingInt(sym_index)) << 32 | @backingInt(r_type), + .r_info = (@as(u64, @backingInt(sym_index)) << 32) | @backingInt(r_type), .r_addend = @bitCast(addend), }, zo); } else if (lf.cast(.macho)) |mf| { @@ -328,7 +328,7 @@ fn emitReloc( }; try atom.addReloc(gpa, .{ .r_offset = offset, - .r_info = @as(u64, @backingInt(sym_index)) << 32 | @backingInt(r_type), + .r_info = (@as(u64, @backingInt(sym_index)) << 32) | @backingInt(r_type), .r_addend = @bitCast(addend), }, zo); } else if (lf.cast(.macho)) |mf| { diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig index 202793ebdc1a3284eed294988deccc9dfa8da12e..147432c3d8e1e19ffcd58cf231b16457bb019652 100644 --- a/src/codegen/aarch64/Select.zig +++ b/src/codegen/aarch64/Select.zig @@ -8099,7 +8099,7 @@ fn movImmediate(isel: *Select, dst_reg: Register, src_imm: u64) !void { .{ .immediate = .{ .N = @fromBackingInt(@intCast(elem_width >> 6)), .immr = hi + mid_masked, - .imms = ((((lo + hi) & smask) | mid_masked) - 1) | -%@as(u6, @truncate(elem_width)) << 1, + .imms = ((((lo + hi) & smask) | mid_masked) - 1) | (-%@as(u6, @truncate(elem_width)) << 1), } }, )); } @@ -10831,7 +10831,7 @@ pub const Value = struct { if (feat_fp16) { const Repr = std.math.FloatRepr(f16); const repr: Repr = @bitCast(imm); - if (repr.mantissa & std.math.maxInt(Repr.Mantissa) >> 5 == 0 and switch (repr.exponent) { + if (repr.mantissa & (std.math.maxInt(Repr.Mantissa) >> 5) == 0 and switch (repr.exponent) { .denormal, .infinite => false, else => std.math.cast(i3, repr.exponent.unbias() - 1) != null, }) break :free try isel.emit(.fmov(mat.ra.h(), .{ .immediate = imm })); @@ -10855,7 +10855,7 @@ pub const Value = struct { } }; const Repr = std.math.FloatRepr(f32); const repr: Repr = @bitCast(imm); - if (repr.mantissa & std.math.maxInt(Repr.Mantissa) >> 5 == 0 and switch (repr.exponent) { + if (repr.mantissa & (std.math.maxInt(Repr.Mantissa) >> 5) == 0 and switch (repr.exponent) { .denormal, .infinite => false, else => std.math.cast(i3, repr.exponent.unbias() - 1) != null, }) break :free try isel.emit(.fmov(mat.ra.s(), .{ .immediate = @floatCast(imm) })); @@ -10878,7 +10878,7 @@ pub const Value = struct { } }; const Repr = std.math.FloatRepr(f64); const repr: Repr = @bitCast(imm); - if (repr.mantissa & std.math.maxInt(Repr.Mantissa) >> 5 == 0 and switch (repr.exponent) { + if (repr.mantissa & (std.math.maxInt(Repr.Mantissa) >> 5) == 0 and switch (repr.exponent) { .denormal, .infinite => false, else => std.math.cast(i3, repr.exponent.unbias() - 1) != null, }) break :free try isel.emit(.fmov(mat.ra.d(), .{ .immediate = @floatCast(imm) })); diff --git a/src/codegen/aarch64/encoding.zig b/src/codegen/aarch64/encoding.zig index c25d2fe507fcfe67a53e35a7e912fd8300d5aaa8..d26167109f10997c8fa795d94775d7f7ef00c83b 100644 --- a/src/codegen/aarch64/encoding.zig +++ b/src/codegen/aarch64/encoding.zig @@ -11886,9 +11886,9 @@ pub const Instruction = packed union { .cmode = switch (arrangement) { else => unreachable, .@"4h", .@"8h" => @as(u3, 0b100) | - @as(u3, @as(u1, @intCast(@shrExact(shifted_immediate.lsl, 3)))) << 0, + (@as(u3, @as(u1, @intCast(@shrExact(shifted_immediate.lsl, 3)))) << 0), .@"2s", .@"4s" => @as(u3, 0b000) | - @as(u3, @as(u2, @intCast(@shrExact(shifted_immediate.lsl, 3)))) << 0, + (@as(u3, @as(u2, @intCast(@shrExact(shifted_immediate.lsl, 3)))) << 0), }, .imm3 = @intCast(shifted_immediate.immediate >> 5), .Q = arrangement.size(), @@ -12384,7 +12384,7 @@ pub const Instruction = packed union { .dup = .{ .Rd = d.alias.encode(.{ .V = true }), .Rn = n.alias.encode(.{ .V = true }), - .imm5 = @shlExact(@as(u5, n.format.element.index) << 1 | @as(u5, 0b1), @backingInt(elem_size)), + .imm5 = @shlExact((@as(u5, n.format.element.index) << 1) | @as(u5, 0b1), @backingInt(elem_size)), }, } } }; }, @@ -12400,7 +12400,7 @@ pub const Instruction = packed union { .Rd = d.alias.encode(.{ .V = true }), .Rn = n.alias.encode(.{ .V = true }), .imm4 = .element, - .imm5 = @shlExact(@as(u5, element.index) << 1 | @as(u5, 0b1), @backingInt(elem_size)), + .imm5 = @shlExact((@as(u5, element.index) << 1) | @as(u5, 0b1), @backingInt(elem_size)), .Q = arrangement.size(), }, } } }; @@ -14195,7 +14195,7 @@ pub const Instruction = packed union { .Rd = d.alias.encode(.{ .V = true }), .Rn = n.alias.encode(.{ .V = true }), .imm4 = .{ .element = element.index << @intCast(@backingInt(elem_size)) }, - .imm5 = (@as(u5, d.format.element.index) << 1 | @as(u5, 0b1) << 0) << @backingInt(elem_size), + .imm5 = ((@as(u5, d.format.element.index) << 1) | (@as(u5, 0b1) << 0)) << @backingInt(elem_size), .op = .element, }, } } }; @@ -14211,7 +14211,7 @@ pub const Instruction = packed union { .Rd = d.alias.encode(.{ .V = true }), .Rn = n.alias.encode(.{}), .imm4 = .{ .general = .general }, - .imm5 = (@as(u5, d.format.element.index) << 1 | @as(u5, 0b1) << 0) << @backingInt(elem_size), + .imm5 = ((@as(u5, d.format.element.index) << 1) | (@as(u5, 0b1) << 0)) << @backingInt(elem_size), .op = .general, }, } } }; @@ -15072,16 +15072,16 @@ pub const Instruction = packed union { .lsl => |amount| switch (arrangement) { else => unreachable, .@"8b", .@"16b" => @as(u4, 0b1110) | - @as(u4, @as(u0, @intCast(@shrExact(amount, 3)))) << 1, + (@as(u4, @as(u0, @intCast(@shrExact(amount, 3)))) << 1), .@"4h", .@"8h" => @as(u4, 0b1000) | - @as(u4, @as(u1, @intCast(@shrExact(amount, 3)))) << 1, + (@as(u4, @as(u1, @intCast(@shrExact(amount, 3)))) << 1), .@"2s", .@"4s" => @as(u4, 0b0000) | - @as(u4, @as(u2, @intCast(@shrExact(amount, 3)))) << 1, + (@as(u4, @as(u2, @intCast(@shrExact(amount, 3)))) << 1), }, .msl => |amount| switch (arrangement) { else => unreachable, .@"2s", .@"4s" => @as(u4, 0b1100) | - @as(u4, @as(u1, @intCast(@shrExact(amount, 3) - 1))) << 0, + (@as(u4, @as(u1, @intCast(@shrExact(amount, 3) - 1))) << 0), }, .replicate => switch (arrangement) { else => unreachable, @@ -15345,9 +15345,9 @@ pub const Instruction = packed union { .cmode = switch (arrangement) { else => unreachable, .@"4h", .@"8h" => @as(u3, 0b100) | - @as(u3, @as(u1, @intCast(@shrExact(shifted_immediate.lsl, 3)))) << 0, + (@as(u3, @as(u1, @intCast(@shrExact(shifted_immediate.lsl, 3)))) << 0), .@"2s", .@"4s" => @as(u3, 0b000) | - @as(u3, @as(u2, @intCast(@shrExact(shifted_immediate.lsl, 3)))) << 0, + (@as(u3, @as(u2, @intCast(@shrExact(shifted_immediate.lsl, 3)))) << 0), }, .imm3 = @intCast(shifted_immediate.immediate >> 5), .Q = arrangement.size(), @@ -15660,9 +15660,9 @@ pub const Instruction = packed union { .Rn = n.alias.encode(.{ .V = true }), .imm5 = switch (vs) { else => unreachable, - .byte => @as(u5, @as(u4, @intCast(n.format.element.index))) << 1 | @as(u5, 0b1) << 0, - .half => @as(u5, @as(u3, @intCast(n.format.element.index))) << 2 | @as(u5, 0b10) << 0, - .single => @as(u5, @as(u2, @intCast(n.format.element.index))) << 3 | @as(u5, 0b100) << 0, + .byte => (@as(u5, @as(u4, @intCast(n.format.element.index))) << 1) | (@as(u5, 0b1) << 0), + .half => (@as(u5, @as(u3, @intCast(n.format.element.index))) << 2) | (@as(u5, 0b10) << 0), + .single => (@as(u5, @as(u2, @intCast(n.format.element.index))) << 3) | (@as(u5, 0b100) << 0), }, .Q = sf, }, @@ -16492,10 +16492,10 @@ pub const Instruction = packed union { .Rn = n.alias.encode(.{ .V = true }), .imm5 = switch (vs) { else => unreachable, - .byte => @as(u5, @as(u4, @intCast(n.format.element.index))) << 1 | @as(u5, 0b1) << 0, - .half => @as(u5, @as(u3, @intCast(n.format.element.index))) << 2 | @as(u5, 0b10) << 0, - .single => @as(u5, @as(u2, @intCast(n.format.element.index))) << 3 | @as(u5, 0b100) << 0, - .double => @as(u5, @as(u1, @intCast(n.format.element.index))) << 4 | @as(u5, 0b1000) << 0, + .byte => (@as(u5, @as(u4, @intCast(n.format.element.index))) << 1) | (@as(u5, 0b1) << 0), + .half => (@as(u5, @as(u3, @intCast(n.format.element.index))) << 2) | (@as(u5, 0b10) << 0), + .single => (@as(u5, @as(u2, @intCast(n.format.element.index))) << 3) | (@as(u5, 0b100) << 0), + .double => (@as(u5, @as(u1, @intCast(n.format.element.index))) << 4) | (@as(u5, 0b1000) << 0), }, .Q = sf, }, diff --git a/src/codegen/loongarch/Mir.zig b/src/codegen/loongarch/Mir.zig index e107984767b547ccb82c9ac1ab869c4ee4d02e24..6c7f2fb01099fc5eb841718c63ea25f65975176e 100644 --- a/src/codegen/loongarch/Mir.zig +++ b/src/codegen/loongarch/Mir.zig @@ -181,7 +181,7 @@ fn emitReloc( const atom = zo.symbol(@backingInt(atom_index)).atom(ef).?; try atom.addReloc(zcu.gpa, .{ .r_offset = offset, - .r_info = @as(u64, @backingInt(sym_index)) << 32 | @backingInt(reloc_type), + .r_info = (@as(u64, @backingInt(sym_index)) << 32) | @backingInt(reloc_type), .r_addend = @bitCast(addend), }, zo); } else unreachable; diff --git a/src/codegen/riscv64/CodeGen.zig b/src/codegen/riscv64/CodeGen.zig index c01390c2d9ec26d2da3f227eafc7ed7b98b30ba2..1dc9b9ced4c94d00d71223672229bffac7d78c6d 100644 --- a/src/codegen/riscv64/CodeGen.zig +++ b/src/codegen/riscv64/CodeGen.zig @@ -1764,7 +1764,7 @@ fn finishAir( ) !void { const tomb_bits = func.liveness.getTombBits(inst); for (0.., operands) |op_index, op| { - if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue; + if (tomb_bits & (@as(Air.Liveness.Bpi, 1) << @intCast(op_index)) == 0) continue; if (func.reused_operands.isSet(op_index)) continue; try func.processDeath(op.toIndexAllowNone() orelse continue); } @@ -6272,7 +6272,7 @@ fn airAsm(func: *Func, inst: Air.Inst.Index) !void { ""; op.* = switch (args.items[ - arg_map.get(op_str["%[".len .. mod_index orelse op_str.len - "]".len]) orelse + arg_map.get(op_str["%[".len .. mod_index orelse (op_str.len - "]".len)]) orelse return func.fail("no matching constraint: '{s}'", .{op_str}) ]) { .lea_symbol => |sym_off| if (mem.eql(u8, modifier, "plt")) blk: { diff --git a/src/codegen/riscv64/encoding.zig b/src/codegen/riscv64/encoding.zig index 5ca6a094d774fbaeb6a96c6c75ecd26a903da705..d04c77d7b806b9d7fc726fb382810b144ebc168d 100644 --- a/src/codegen/riscv64/encoding.zig +++ b/src/codegen/riscv64/encoding.zig @@ -582,8 +582,8 @@ pub const Instruction = union(Lir.Format) { .opcode = opcode, .funct3 = @backingInt(amo.width), - .funct7 = @as(u7, amo.funct5) << 2 | - @as(u7, @intFromBool(ops[3].barrier == .rl)) << 1 | + .funct7 = (@as(u7, amo.funct5) << 2) | + (@as(u7, @intFromBool(ops[3].barrier == .rl)) << 1) | @as(u7, @intFromBool(ops[4].barrier == .aq)), }, else => unreachable, diff --git a/src/codegen/sparc64/CodeGen.zig b/src/codegen/sparc64/CodeGen.zig index 6b1e44b16ebd803e448e68799ce8d8e769ac0573..63627e3d7d31f24f3092cb456a8e98d3a48ba63c 100644 --- a/src/codegen/sparc64/CodeGen.zig +++ b/src/codegen/sparc64/CodeGen.zig @@ -3475,11 +3475,11 @@ fn finishAirBookkeeping(self: *Self) void { fn finishAir(self: *Self, inst: Air.Inst.Index, result: MCValue, operands: [Air.Liveness.bpi - 1]Air.Inst.Ref) void { const tomb_bits = self.liveness.getTombBits(inst); for (0.., operands) |op_index, op| { - if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue; + if (tomb_bits & (@as(Air.Liveness.Bpi, 1) << @intCast(op_index)) == 0) continue; if (self.reused_operands.isSet(op_index)) continue; self.processDeath(op.toIndexAllowNone() orelse continue); } - if (tomb_bits & 1 << (Air.Liveness.bpi - 1) == 0) { + if (tomb_bits & (1 << (Air.Liveness.bpi - 1)) == 0) { log.debug("%{d} => {}", .{ inst, result }); const branch = &self.branch_stack.items[self.branch_stack.items.len - 1]; branch.inst_table.putAssumeCapacityNoClobber(inst, result); diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig index f2931cc1212c90a3fbced96f3870b191eb92704d..f8caf7cfd993184d1646303834ca8378497f8e49 100644 --- a/src/codegen/spirv/CodeGen.zig +++ b/src/codegen/spirv/CodeGen.zig @@ -1191,7 +1191,7 @@ fn constInt(cg: *CodeGen, ty: Type, value: anytype) !Id { const truncated_value = if (backing_bits == 64) value64 else - value64 & (@as(u64, 1) << @intCast(backing_bits)) - 1; + value64 & ((@as(u64, 1) << @intCast(backing_bits)) - 1); break :blk switch (backing_bits) { 1...32 => .{ .uint32 = @truncate(truncated_value) }, diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig index e3cfed33b33300e71e703147362bf501873df1d6..dd36e7c304247f92c27cc96a3b15a6d879df2529 100644 --- a/src/codegen/x86_64/CodeGen.zig +++ b/src/codegen/x86_64/CodeGen.zig @@ -173255,7 +173255,7 @@ fn finishAir( ) !void { const tomb_bits = self.liveness.getTombBits(inst); for (0.., operands) |op_index, op| { - if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue; + if (tomb_bits & (@as(Air.Liveness.Bpi, 1) << @intCast(op_index)) == 0) continue; if (self.reused_operands.isSet(op_index)) continue; try self.processDeath(op.toIndexAllowNone() orelse continue, .{}); } @@ -176321,7 +176321,7 @@ fn lowerSwitchBr( const unsigned_condition_ty = try cg.pt.intType(.unsigned, cg.intInfo(condition_ty).?.bits); const ExpectedContents = extern struct { - liveness_deaths: [1 << 8 | 1]Air.Inst.Index, + liveness_deaths: [(1 << 8) | 1]Air.Inst.Index, bigint_limbs: [std.math.big.int.calcTwosCompLimbCount(1 << 10)]std.math.big.Limb, relocs: [1 << 6]Mir.Inst.Index, }; @@ -177310,7 +177310,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { else ""; op.* = switch (args[ - arg_map.get(op_str["%[".len .. colon orelse op_str.len - "]".len]) orelse + arg_map.get(op_str["%[".len .. colon orelse (op_str.len - "]".len)]) orelse return self.fail("no matching constraint: '{s}'", .{op_str}) ]) { .immediate => |imm| if (std.mem.eql(u8, modifier, "") or @@ -177454,7 +177454,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { else ""; break :disp switch (args[ - arg_map.get(op_str["%[".len .. colon orelse open - "]".len]) orelse + arg_map.get(op_str["%[".len .. colon orelse (open - "]".len)]) orelse return self.fail("no matching constraint: '{s}'", .{op_str}) ]) { .immediate => |imm| if (std.mem.eql(u8, modifier, "") or @@ -179566,7 +179566,7 @@ fn atomicOp( }; defer if (mem_lock) |lock| self.register_manager.unlockReg(lock); - const use_sse = rmw_op orelse .Xchg != .Xchg and val_ty.isRuntimeFloat(); + const use_sse = (rmw_op orelse .Xchg) != .Xchg and val_ty.isRuntimeFloat(); const strat: enum { lock, loop, libcall } = if (use_sse) .loop else switch (rmw_op orelse .Xchg) { .Xchg, .Add, @@ -179626,7 +179626,7 @@ fn atomicOp( try self.asmRegisterMemory(.{ ._, .mov }, registerAlias(.rax, val_abi_size), ptr_mem); const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len); - if (!use_sse and rmw_op orelse .Xchg != .Xchg) { + if (!use_sse and (rmw_op orelse .Xchg) != .Xchg) { try self.genSetReg(tmp_reg, val_ty, .{ .register = .rax }, .{}); } if (rmw_op) |op| if (use_sse) { @@ -188854,7 +188854,7 @@ const Temp = struct { for (0.., op_refs, op_temps) |op_index, op_ref, op_temp| { if (op_temp.index == temp.index) continue; if (op_temp.tracking(cg).short != .dead) try op_temp.die(cg); - if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue; + if (tomb_bits & (@as(Air.Liveness.Bpi, 1) << @intCast(op_index)) == 0) continue; if (cg.reused_operands.isSet(op_index)) continue; try cg.processDeath(op_ref.toIndexAllowNone() orelse continue, .{}); } @@ -188916,7 +188916,7 @@ const Temp = struct { } for (0.., op_refs, op_temps) |op_index, op_ref, op_temp| { if (op_temp.index != temp.index) continue; - if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue; + if (tomb_bits & (@as(Air.Liveness.Bpi, 1) << @intCast(op_index)) == 0) continue; if (cg.reused_operands.isSet(op_index)) continue; try cg.processDeath(op_ref.toIndexAllowNone() orelse continue, .{}); } @@ -190117,9 +190117,9 @@ const Select = struct { (@as(u64, std.math.maxInt(u64)) >> @intCast(res_scalar_info.bits - scalar_info.bits))), .@"0x1p63_mem" => switch (res_scalar_info.bits) { else => unreachable, - 16 => @as(i64, @as(i16, @bitCast(@as(f16, 0x1p63)))) << 64 - 16, - 32 => @as(i64, @as(i32, @bitCast(@as(f32, 0x1p63)))) << 64 - 32, - 64 => @as(i64, @as(i64, @bitCast(@as(f64, 0x1p63)))) << 64 - 64, + 16 => @as(i64, @as(i16, @bitCast(@as(f16, 0x1p63)))) << (64 - 16), + 32 => @as(i64, @as(i32, @bitCast(@as(f32, 0x1p63)))) << (64 - 32), + 64 => @as(i64, @as(i64, @bitCast(@as(f64, 0x1p63)))) << (64 - 64), }, }; const shift: u6 = @intCast(64 - res_scalar_info.bits); @@ -191518,8 +191518,8 @@ const Select = struct { @as(SignedImm, @intCast(s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s)))), .log2_src0_elem_size => @intCast(std.math.log2(Select.Operand.Ref.src0.typeOf(s).indexableElem(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))), .elem_mask => @as(u8, std.math.maxInt(u8)) >> @intCast( - 8 - ((s.cg.unalignedSize(op.flags.base.ref.typeOf(s)) - 1) % - @divExact(op.flags.base.size.bitSize(s.cg.target), 8) + 1 >> + 8 - (((s.cg.unalignedSize(op.flags.base.ref.typeOf(s)) - 1) % + @divExact(op.flags.base.size.bitSize(s.cg.target), 8) + 1) >> op.flags.index.scale.toLog2()), ), inline .smin, .smax, .umax, .smin_shr_src1, .smax_shr_src1, .umax_shr_src1 => |adjust| switch (op.flags.base.size) { @@ -191548,7 +191548,7 @@ const Select = struct { }, .repeat => switch (SignedImm) { else => unreachable, - i64 => return @as(i64, op.imm) << 32 | @as(u32, @bitCast(op.imm)), + i64 => return (@as(i64, op.imm) << 32) | @as(u32, @bitCast(op.imm)), }, }; const rhs = op.flags.adjust.rhs.toLog2(); @@ -191559,10 +191559,10 @@ const Select = struct { break :op_res op_res[0]; }, .div => @shrExact(lhs, rhs), - .div_8_down => lhs >> 3 & @as(SignedImm, -1) << rhs, + .div_8_down => (lhs >> 3) & (@as(SignedImm, -1) << rhs), .rem_8_mul => lhs & ((@as(SignedImm, 8) << rhs) - 1), - .up_2_mul => ((lhs - 1) & @as(SignedImm, -2) << rhs) + (@as(SignedImm, 2) << rhs), - .up_32_mul => ((lhs - 1) & @as(SignedImm, -32) << rhs) + (@as(SignedImm, 32) << rhs), + .up_2_mul => ((lhs - 1) & (@as(SignedImm, -2) << rhs)) + (@as(SignedImm, 2) << rhs), + .up_32_mul => ((lhs - 1) & (@as(SignedImm, -32) << rhs)) + (@as(SignedImm, 32) << rhs), }; const disp: SignedImm = @bitCast(@as(UnsignedImm, @as(u32, @bitCast(op.imm)))); return switch (op.flags.adjust.sign) { diff --git a/src/codegen/x86_64/Disassembler.zig b/src/codegen/x86_64/Disassembler.zig index 4cbd66e9c834dd4efae40c438679e505c8632112..680781140bab39ebe4410066a42773bfa4a0d1a7 100644 --- a/src/codegen/x86_64/Disassembler.zig +++ b/src/codegen/x86_64/Disassembler.zig @@ -378,7 +378,7 @@ fn parseEncoding(dis: *Disassembler, prefixes: Prefixes) !?Encoding { } fn parseGpRegister(low_enc: u3, is_extended: bool, rex: Rex, bit_size: u64) Register { - const reg_id: u4 = @as(u4, @intCast(@intFromBool(is_extended))) << 3 | low_enc; + const reg_id: u4 = (@as(u4, @intCast(@intFromBool(is_extended))) << 3) | low_enc; const reg = @as(Register, @fromBackingInt(@intCast(reg_id))).toBitSize(bit_size); return switch (reg) { .spl => if (rex.present or rex.isSet()) .spl else .ah, diff --git a/src/codegen/x86_64/Emit.zig b/src/codegen/x86_64/Emit.zig index a82ae415ac502309854af8e9ca44636ee3c8ab43..ea5cfee2e91069205bda5442f23c7272785f01f5 100644 --- a/src/codegen/x86_64/Emit.zig +++ b/src/codegen/x86_64/Emit.zig @@ -694,13 +694,13 @@ pub fn emitMir(emit: *Emit) Error!void { for (emit.table_relocs.items) |table_reloc| try atom.addReloc(gpa, .{ .r_offset = table_reloc.source_offset, - .r_info = @as(u64, @backingInt(emit.atom_id)) << 32 | @backingInt(std.elf.R_X86_64.@"32S"), + .r_info = (@as(u64, @backingInt(emit.atom_id)) << 32) | @backingInt(std.elf.R_X86_64.@"32S"), .r_addend = @as(i64, table_offset) + table_reloc.target_offset, }, zo); for (emit.lower.mir.table) |entry| { try atom.addReloc(gpa, .{ .r_offset = table_offset, - .r_info = @as(u64, @backingInt(emit.atom_id)) << 32 | @backingInt(std.elf.R_X86_64.@"64"), + .r_info = (@as(u64, @backingInt(emit.atom_id)) << 32) | @backingInt(std.elf.R_X86_64.@"64"), .r_addend = emit.code_offset_mapping.items[entry], }, zo); table_offset += ptr_size; @@ -812,7 +812,7 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI .PC32; try atom.addReloc(gpa, .{ .r_offset = end_offset - 4, - .r_info = @as(u64, @backingInt(target.symbol)) << 32 | @backingInt(r_type), + .r_info = (@as(u64, @backingInt(target.symbol)) << 32) | @backingInt(r_type), .r_addend = if (emit.pic) reloc.off - 4 else reloc.off, }, zo); } else if (emit.bin_file.cast(.macho)) |macho_file| { @@ -854,7 +854,7 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI const r_type: std.elf.R_X86_64 = .PLT32; try atom.addReloc(gpa, .{ .r_offset = end_offset - 4, - .r_info = @as(u64, @backingInt(target.symbol)) << 32 | @backingInt(r_type), + .r_info = (@as(u64, @backingInt(target.symbol)) << 32) | @backingInt(r_type), .r_addend = reloc.off - 4, }, zo); } else if (emit.bin_file.cast(.elf2)) |elf| try elf.addReloc( @@ -894,7 +894,7 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI const r_type: std.elf.R_X86_64 = if (emit.pic) .TLSLD else unreachable; try atom.addReloc(gpa, .{ .r_offset = end_offset - 4, - .r_info = @as(u64, @backingInt(target_symbol)) << 32 | @backingInt(r_type), + .r_info = (@as(u64, @backingInt(target_symbol)) << 32) | @backingInt(r_type), .r_addend = reloc.off - 4, }, zo); } else if (emit.bin_file.cast(.elf2)) |elf| try elf.addReloc( @@ -912,7 +912,7 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI const r_type: std.elf.R_X86_64 = if (emit.pic) .DTPOFF32 else .TPOFF32; try atom.addReloc(gpa, .{ .r_offset = end_offset - 4, - .r_info = @as(u64, @backingInt(target.symbol)) << 32 | @backingInt(r_type), + .r_info = (@as(u64, @backingInt(target.symbol)) << 32) | @backingInt(r_type), .r_addend = reloc.off, }, zo); } else if (emit.bin_file.cast(.elf2)) |elf| try elf.addReloc( diff --git a/src/codegen/x86_64/Mir.zig b/src/codegen/x86_64/Mir.zig index 1b2d3cb63ebef6d025cb77cc109a4ddce7536e7b..07949a22b2a0c1fe407912278995518301e7c6e9 100644 --- a/src/codegen/x86_64/Mir.zig +++ b/src/codegen/x86_64/Mir.zig @@ -1949,7 +1949,7 @@ pub const Memory = struct { assert(mem.info.base == .reg); return encoder.Instruction.Memory.initMoffs( @fromBackingInt(@intCast(mem.base)), - @as(u64, mem.extra) << 32 | mem.off, + (@as(u64, mem.extra) << 32) | mem.off, ); }, } diff --git a/src/codegen/x86_64/bits.zig b/src/codegen/x86_64/bits.zig index cd4342b7f68b86a02834a36451b38a0cfa3e4444..ae7bb0d92c1ee36b5b6b2c28d23aa15a232a8d98 100644 --- a/src/codegen/x86_64/bits.zig +++ b/src/codegen/x86_64/bits.zig @@ -664,7 +664,7 @@ pub const Register = enum(u8) { .general_purpose, .gphi => if (reg.isExtended()) reg.enc() else - @as(u3, @truncate(@as(u24, 0o54673120) >> @as(u5, reg.enc()) * 3)), + @as(u3, @truncate(@as(u24, 0o54673120) >> (@as(u5, reg.enc()) * 3))), .sse => 17 + @as(u6, reg.enc()), .x87 => 33 + @as(u6, reg.enc()), .mmx => 41 + @as(u6, reg.enc()), diff --git a/src/codegen/x86_64/encoder.zig b/src/codegen/x86_64/encoder.zig index 56b76b42879bb05166d42162a7ac0b9801f244dd..ac7c2a2e8f0cc04f774290125a49198a3db4b075 100644 --- a/src/codegen/x86_64/encoder.zig +++ b/src/codegen/x86_64/encoder.zig @@ -844,25 +844,25 @@ fn Encoder(comptime opts: Options) type { try self.w.writeByte(0b1100_0100); try self.w.writeByte( - @as(u8, ~@intFromBool(fields.r)) << 7 | - @as(u8, ~@intFromBool(fields.x)) << 6 | - @as(u8, ~@intFromBool(fields.b)) << 5 | - @as(u8, @backingInt(fields.m)) << 0, + (@as(u8, ~@intFromBool(fields.r)) << 7) | + (@as(u8, ~@intFromBool(fields.x)) << 6) | + (@as(u8, ~@intFromBool(fields.b)) << 5) | + (@as(u8, @backingInt(fields.m)) << 0), ); try self.w.writeByte( - @as(u8, @intFromBool(fields.w)) << 7 | - @as(u8, ~@as(u4, @intCast(fields.v.enc()))) << 3 | - @as(u8, @intFromBool(fields.l)) << 2 | - @as(u8, @backingInt(fields.p)) << 0, + (@as(u8, @intFromBool(fields.w)) << 7) | + (@as(u8, ~@as(u4, @intCast(fields.v.enc()))) << 3) | + (@as(u8, @intFromBool(fields.l)) << 2) | + (@as(u8, @backingInt(fields.p)) << 0), ); } else { try self.w.writeByte(0b1100_0101); try self.w.writeByte( - @as(u8, ~@intFromBool(fields.r)) << 7 | - @as(u8, ~@as(u4, @intCast(fields.v.enc()))) << 3 | - @as(u8, @intFromBool(fields.l)) << 2 | - @as(u8, @backingInt(fields.p)) << 0, + (@as(u8, ~@intFromBool(fields.r)) << 7) | + (@as(u8, ~@as(u4, @intCast(fields.v.enc()))) << 3) | + (@as(u8, @intFromBool(fields.l)) << 2) | + (@as(u8, @backingInt(fields.p)) << 0), ); } } @@ -910,7 +910,7 @@ fn Encoder(comptime opts: Options) type { /// /// Remember to add a REX prefix byte if reg or rm are extended! pub fn modRm(self: Self, mod: u2, reg_or_opx: u3, rm: u3) !void { - try self.w.writeByte(@as(u8, mod) << 6 | @as(u8, reg_or_opx) << 3 | rm); + try self.w.writeByte((@as(u8, mod) << 6) | (@as(u8, reg_or_opx) << 3) | rm); } /// Construct a ModR/M byte using direct r/m addressing @@ -996,7 +996,7 @@ fn Encoder(comptime opts: Options) type { /// /// Remember to add a REX prefix byte if index or base are extended! pub fn sib(self: Self, scale: u2, index: u3, base: u3) !void { - try self.w.writeByte(@as(u8, scale) << 6 | @as(u8, index) << 3 | base); + try self.w.writeByte((@as(u8, scale) << 6) | (@as(u8, index) << 3) | base); } /// Construct a SIB byte with scale * index + base, no frills. diff --git a/src/fmt.zig b/src/fmt.zig index c12eadd95b5a3f25b57e0d497da887dcd7437616..42e7558ea9950968af8c026aa755951a052cd31e 100644 --- a/src/fmt.zig +++ b/src/fmt.zig @@ -323,7 +323,8 @@ fn fmtPathDir( if (mem.startsWith(u8, entry.name, ".")) continue; - if (is_dir or entry.kind == .file and (mem.endsWith(u8, entry.name, ".zig") or mem.endsWith(u8, entry.name, ".zon"))) { + const is_zig_or_zon = entry.kind == .file and (mem.endsWith(u8, entry.name, ".zig") or mem.endsWith(u8, entry.name, ".zon")); + if (is_dir or is_zig_or_zon) { const full_path = try fs.path.join(fmt.gpa, &[_][]const u8{ file_path, entry.name }); defer fmt.gpa.free(full_path); diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig index 7803ca1888a5748d2a2121b73c79df5527d2d019..10cb59aa9e12c117c95cd432d2e5b0ec512ce8cc 100644 --- a/src/link/Dwarf.zig +++ b/src/link/Dwarf.zig @@ -697,7 +697,7 @@ const Unit = struct { fw.writeByte(DW.LNS.extended_op) catch unreachable; const extended_op_bytes = fw.end; var op_len_bytes: u5 = 1; - while (true) switch (std.math.order(len - extended_op_bytes - op_len_bytes, @as(u32, 1) << 7 * op_len_bytes)) { + while (true) switch (std.math.order(len - extended_op_bytes - op_len_bytes, @as(u32, 1) << (7 * op_len_bytes))) { .lt => break fw.writeUleb128(len - extended_op_bytes - op_len_bytes) catch unreachable, .eq => { // no length will ever work, so undercount and futz with the leb encoding to make up the missing byte @@ -893,7 +893,7 @@ const Entry = struct { fw.writeUleb128(try dwarf.refAbbrevCode(.pad_n)) catch unreachable; const abbrev_code_bytes = fw.end; var block_len_bytes: u5 = 1; - while (true) switch (std.math.order(len - abbrev_code_bytes - block_len_bytes, @as(u32, 1) << 7 * block_len_bytes)) { + while (true) switch (std.math.order(len - abbrev_code_bytes - block_len_bytes, @as(u32, 1) << (7 * block_len_bytes))) { .lt => break fw.writeUleb128(len - abbrev_code_bytes - block_len_bytes) catch unreachable, .eq => { // no length will ever work, so undercount and futz with the leb encoding to make up the missing byte @@ -915,7 +915,7 @@ const Entry = struct { fw.writeByte(DW.LNS.extended_op) catch unreachable; const extended_op_bytes = fw.end; var op_len_bytes: u5 = 1; - while (true) switch (std.math.order(len - extended_op_bytes - op_len_bytes, @as(u32, 1) << 7 * op_len_bytes)) { + while (true) switch (std.math.order(len - extended_op_bytes - op_len_bytes, @as(u32, 1) << (7 * op_len_bytes))) { .lt => break fw.writeUleb128(len - extended_op_bytes - op_len_bytes) catch unreachable, .eq => { // no length will ever work, so undercount and futz with the leb encoding to make up the missing byte diff --git a/src/link/Dwarf2.zig b/src/link/Dwarf2.zig index 3c73609eb7bf663637ef432f198960a98f53ef68..ead00184c248ecd7c42b1f343d36f6ca1e60018e 100644 --- a/src/link/Dwarf2.zig +++ b/src/link/Dwarf2.zig @@ -1891,7 +1891,7 @@ pub fn genDebugInfoPadding(dwarf: *Dwarf, di_w: *std.Io.Writer, size: u64) std.I var block_len_size: u5 = 1; while (true) switch (std.math.order( size - abbrev_code_size - block_len_size, - @as(u64, 1) << 7 * block_len_size, + @as(u64, 1) << (7 * block_len_size), )) { .lt => break try di_w.writeUleb128(size - abbrev_code_size - block_len_size), .eq => { @@ -2023,7 +2023,7 @@ pub fn genDebugLinePadding(dl_w: *std.Io.Writer, size: u64) std.Io.Writer.Error! var op_len_size: u5 = 1; while (true) switch (std.math.order( size - extended_op_size - op_len_size, - @as(u64, 1) << 7 * op_len_size, + @as(u64, 1) << (7 * op_len_size), )) { .lt => break try dl_w.writeUleb128(size - extended_op_size - op_len_size), .eq => { diff --git a/src/link/Elf2.zig b/src/link/Elf2.zig index a585287261a2d73f365a4cb22ff89f041ddf7e2b..699174de84522cfe337fc4b662ac72e65250fc1f 100644 --- a/src/link/Elf2.zig +++ b/src/link/Elf2.zig @@ -7694,11 +7694,11 @@ fn loadArchive(elf: *Elf, path: std.Build.Cache.Path, fr: *Io.File.Reader) (Load { break :load_object; } - const member = header.name() orelse member: { - const strtab_offset = header.nameOffset() catch |err| switch (err) { + const member = header.name() orelse (member: { + const strtab_offset = (header.nameOffset() catch |err| switch (err) { error.Overflow => break :member error.Overflow, error.InvalidCharacter => break :load_object, - } orelse break :load_object; + }) orelse break :load_object; const strtab_written = strtab.written(); if (strtab_offset > strtab_written.len) break :member error.Overflow; const member = std.mem.sliceTo(strtab_written[strtab_offset..], '\n'); @@ -7708,7 +7708,7 @@ fn loadArchive(elf: *Elf, path: std.Build.Cache.Path, fr: *Io.File.Reader) (Load member; } catch |err| switch (err) { error.Overflow => return diags.failParse(path, "bad member name offset", .{}), - }; + }); try elf.loadObject(path, member, fr, .{ .offset = offset, .size = size }); } try fr.seekTo(std.mem.alignForward(u64, offset + size, 2)); diff --git a/src/link/MachO/UnwindInfo.zig b/src/link/MachO/UnwindInfo.zig index 7e54bd91e7888d230769ab962de967ebbf14ba47..e22099f396b7652f61baa27596e7f1861f0dd584 100644 --- a/src/link/MachO/UnwindInfo.zig +++ b/src/link/MachO/UnwindInfo.zig @@ -228,7 +228,7 @@ pub fn generate(info: *UnwindInfo, macho_file: *MachO) !void { if (next.getAtomAddress(macho_file) >= range_start_max) { break; } else if (info.getCommonEncoding(next.enc) != null or - page.getPageEncoding(next.enc) != null and !is_dwarf) + (page.getPageEncoding(next.enc) != null and !is_dwarf)) { i += 1; space_left -= 1; diff --git a/src/link/MachO/load_commands.zig b/src/link/MachO/load_commands.zig index f6b97406849f031a235a51f31c64cb8e3b65b545..68053b67b0d6dbc7e58734fcb29edebfa9f132e9 100644 --- a/src/link/MachO/load_commands.zig +++ b/src/link/MachO/load_commands.zig @@ -266,8 +266,8 @@ pub fn writeDylibIdLC(macho_file: *MachO, writer: *Writer) !void { try writeDylibLC(.{ .cmd = .ID_DYLIB, .name = install_name, - .current_version = @as(u32, @intCast(curr.major << 16 | curr.minor << 8 | curr.patch)), - .compatibility_version = @as(u32, @intCast(compat.major << 16 | compat.minor << 8 | compat.patch)), + .current_version = @as(u32, @intCast((curr.major << 16) | (curr.minor << 8) | curr.patch)), + .compatibility_version = @as(u32, @intCast((compat.major << 16) | (compat.minor << 8) | compat.patch)), }, writer); } diff --git a/src/link/Wasm/Flush.zig b/src/link/Wasm/Flush.zig index 745e3023dc0a9e61e68f7f6164c6ed220915447f..28da9ca08ec6eef24b5c125c949039a43fdc862e 100644 --- a/src/link/Wasm/Flush.zig +++ b/src/link/Wasm/Flush.zig @@ -1128,7 +1128,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { // indirect function table elements const table_index: u32 = @intCast( wasm.table_imports.getIndex(wasm.preloaded_strings.__indirect_function_table) orelse - wasm.table_imports.entries.len + wasm.tables.getIndex(.__indirect_function_table).?, + (wasm.table_imports.entries.len + wasm.tables.getIndex(.__indirect_function_table).?), ); // passive with implicit 0-index table or set table index manually const flags: u32 = if (table_index == 0) 0x0 else 0x02; diff --git a/src/link/riscv.zig b/src/link/riscv.zig index cfc42ac33969e1596982513fbad2216a4c52b62f..125668a7c11786487e110b52af4d7f6ce0439685 100644 --- a/src/link/riscv.zig +++ b/src/link/riscv.zig @@ -90,8 +90,8 @@ fn bitSlice( value: anytype, comptime high: comptime_int, comptime low: comptime_int, -) std.math.IntFittingRange(0, 1 << high - low) { - return @truncate((value >> low) & (1 << (high - low + 1)) - 1); +) std.math.IntFittingRange(0, 1 << (high - low)) { + return @truncate((value >> low) & ((1 << (high - low + 1)) - 1)); } pub const Eflags = packed struct(u32) { diff --git a/src/main.zig b/src/main.zig index 49838feb8beb6de697b763fc6852054050033a6e..5e55ccff87620a6c66b61e5a2fc4d1a7256a4f63 100644 --- a/src/main.zig +++ b/src/main.zig @@ -3524,7 +3524,7 @@ fn buildOutputType( }; const thread_limit = @min( - @max(n_jobs orelse std.Thread.getCpuCount() catch 1, 1), + @max(n_jobs orelse (std.Thread.getCpuCount() catch 1), 1), std.math.maxInt(Zcu.PerThread.IdBacking), ); try setThreadLimit(arena, thread_limit); diff --git a/test/Runner.zig b/test/Runner.zig index 1d838172a23bc9e182529cb6d37305def72f4c90..9f189e284818cb0b8e3a8bdf60af3b581a4fe66f 100644 --- a/test/Runner.zig +++ b/test/Runner.zig @@ -811,7 +811,7 @@ pub const DelimitedReader = struct { const d: *DelimitedReader = @fieldParentPtr("interface", r); const block = try d.unlimited.peekGreedy(d.delimiter.len); d.remaining = .limited(std.mem.findPos(u8, block, d.remaining.toInt().?, d.delimiter) orelse - block.len - d.delimiter.len + 1); + (block.len - d.delimiter.len + 1)); if (d.remaining == .nothing) return error.EndOfStream; const n = try d.unlimited.stream(w, limit.min(d.remaining)); d.remaining = d.remaining.subtract(n).?; @@ -821,7 +821,7 @@ pub const DelimitedReader = struct { const d: *DelimitedReader = @fieldParentPtr("interface", r); const block = try d.unlimited.peekGreedy(d.delimiter.len); d.remaining = .limited(std.mem.findPos(u8, block, d.remaining.toInt().?, d.delimiter) orelse - block.len - d.delimiter.len + 1); + (block.len - d.delimiter.len + 1)); if (d.remaining == .nothing) return error.EndOfStream; const n = try d.unlimited.discard(limit.min(d.remaining)); d.remaining = d.remaining.subtract(n).?; @@ -1397,9 +1397,9 @@ fn handleCommand( return update.fail("compiler failed to send terminating error_bundle", .{}); }, } - assert(contents_r.discardRemaining() catch |err| switch (err) { + assert((contents_r.discardRemaining() catch |err| switch (err) { error.ReadFailed => return error.ContentsReadFailed, - } == 0); + }) == 0); switch (cmd) { .todo, .skip => {}, else => update.allow_skip = false, diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig index 969e0a1af91cc39aa851be6cb6769aedd918113d..7f2b1e0984c717d2a77f5cfadd6f4ff015135dfc 100644 --- a/test/behavior/bitcast.zig +++ b/test/behavior/bitcast.zig @@ -470,7 +470,7 @@ test "@bitCast of packed struct with void field and multiple integers" { fn doTheTest(x: u8, y: u8) !void { const foo = @as(@This(), .{ .x = x, .v = {}, .y = y }); const as_int: u16 = @bitCast(foo); - try expect(as_int == @as(u16, y) << 8 | x); + try expect(as_int == (@as(u16, y) << 8) | x); } }; try S.doTheTest(123, 45); diff --git a/test/behavior/error.zig b/test/behavior/error.zig index 132193c85b777beabe63fad397d92d8d8e03918a..c6ad8ca25744096162d43d23b0000e40a94e16ac 100644 --- a/test/behavior/error.zig +++ b/test/behavior/error.zig @@ -209,7 +209,7 @@ fn testErrorSetType() !void { const a: MyErrSet!i32 = 5678; const b: MyErrSet!i32 = MyErrSet.OutOfMemory; - try expect(b catch error.OutOfMemory == error.OutOfMemory); + try expect((b catch error.OutOfMemory) == error.OutOfMemory); if (a) |value| try expect(value == 5678) else |err| switch (err) { error.OutOfMemory => unreachable, diff --git a/test/behavior/math.zig b/test/behavior/math.zig index 9d35984b7c1cb2ebbd405727138cd13826c570aa..78b409af179da2308d225bb6f4d62389e8e8d1c2 100644 --- a/test/behavior/math.zig +++ b/test/behavior/math.zig @@ -49,10 +49,10 @@ fn testThreeExprInARow(f: bool, t: bool) !void { try assertFalse(1 | 2 | 4 != 7); try assertFalse(3 ^ 6 ^ 8 != 13); try assertFalse(7 & 14 & 28 != 4); - try assertFalse(9 << 1 << 2 != 9 << 3); - try assertFalse(90 >> 1 >> 2 != 90 >> 3); + try assertFalse((9 << 1) << 2 != 9 << 3); + try assertFalse((90 >> 1) >> 2 != 90 >> 3); try assertFalse(100 - 1 + 1000 != 1099); - try assertFalse(5 * 4 / 2 % 3 != 1); + try assertFalse((5 * 4 / 2) % 3 != 1); try assertFalse(@as(i32, @as(i32, 5)) != 5); try assertFalse(!!false); try assertFalse(@as(i32, 7) != --(@as(i32, 7))); diff --git a/test/behavior/try.zig b/test/behavior/try.zig index 649e22d5f94b1e30bd7892816b1ddbeb0da22db3..b9a368852d535dfbb7c644fe9208af4490edeebd 100644 --- a/test/behavior/try.zig +++ b/test/behavior/try.zig @@ -186,9 +186,9 @@ test "try ptr propagation mutate" { res1.* += 1; res2.* += 1; - try expect(f0 catch unreachable == 1); - try expect(f1 catch unreachable == 2); - try expect(f2 catch unreachable == 3); + try expect((f0 catch unreachable) == 1); + try expect((f1 catch unreachable) == 2); + try expect((f2 catch unreachable) == 3); try expect(res0.* == 1); try expect(res1.* == 2); diff --git a/test/behavior/x86_64/binary.zig b/test/behavior/x86_64/binary.zig index 899092f4058d5a1c1e75c155ec9280a4e11224dc..b9fad8d2a59c493e1fb758913144269d44080013 100644 --- a/test/behavior/x86_64/binary.zig +++ b/test/behavior/x86_64/binary.zig @@ -5503,7 +5503,7 @@ inline fn shrExact(comptime Type: type, lhs: Type, rhs: Type) Type { const bit_cast_rhs: AsSignedness(Type, .unsigned) = @bitCast(rhs); const truncate_rhs: Log2Int(Type) = @truncate(bit_cast_rhs); const final_rhs = if (comptime cast(Log2Int(Scalar(Type)), @bitSizeOf(Scalar(Type)))) |bits| truncate_rhs % @as(Log2Int(Type), @splat(bits)) else truncate_rhs; - return @shrExact(lhs >> final_rhs << final_rhs, final_rhs); + return @shrExact((lhs >> final_rhs) << final_rhs, final_rhs); } test shrExact { const test_shr_exact = binary(shrExact, .{}); @@ -5527,7 +5527,7 @@ inline fn shlExactUnsafe(comptime Type: type, lhs: Type, rhs: Type) Type { const bit_cast_rhs: AsSignedness(Type, .unsigned) = @bitCast(rhs); const truncate_rhs: Log2Int(Type) = @truncate(bit_cast_rhs); const final_rhs = if (comptime cast(Log2Int(Scalar(Type)), @bitSizeOf(Scalar(Type)))) |bits| truncate_rhs % @as(Log2Int(Type), @splat(bits)) else truncate_rhs; - return @shlExact(lhs << final_rhs >> final_rhs, final_rhs); + return @shlExact((lhs << final_rhs) >> final_rhs, final_rhs); } test shlExactUnsafe { const test_shl_exact_unsafe = binary(shlExactUnsafe, .{}); diff --git a/test/behavior/x86_64/cast.zig b/test/behavior/x86_64/cast.zig index 35f880fa174f18433529c24dec41ef9cddc2eaca..62e37fc74181e7fefdb23c44eb1a9af81af20e37 100644 --- a/test/behavior/x86_64/cast.zig +++ b/test/behavior/x86_64/cast.zig @@ -14502,15 +14502,15 @@ inline fn intCast(comptime Result: type, comptime Type: type, rhs: Type, comptim // TODO: if (bits == 0) rhs else rhs >> bits, .shift => |bits| if (bits == 0) rhs else switch (@typeInfo(Type)) { .int => if (ct_rhs < 0) - rhs | imin(Type) >> bits + rhs | (imin(Type) >> bits) else - rhs & imax(Type) >> bits, - .vector => rhs | @select( + rhs & (imax(Type) >> bits), + .vector => (rhs | @select( Scalar(Type), ct_rhs < @as(Type, @splat(0)), @as(Type, @splat(imin(Scalar(Type)) >> bits)), @as(Type, @splat(0)), - ) & ~@select( + )) & ~@select( Scalar(Type), ct_rhs >= @as(Type, @splat(0)), @as(Type, @splat(imin(Scalar(Type)) >> bits)), diff --git a/tools/loongarch/OpcodeDesc.zig b/tools/loongarch/OpcodeDesc.zig index e88a65c2718e8cc9d24219d8a7dc4c19b91d8f3d..10ddc86d8f679f6c53dc2717f9b0e6b7929e219e 100644 --- a/tools/loongarch/OpcodeDesc.zig +++ b/tools/loongarch/OpcodeDesc.zig @@ -95,10 +95,10 @@ pub const Format = struct { const index: Slot.Index = try .parse(&reader); const length = try takeInteger(u5, &reader); const post_proc = post_proc: { - if ('p' == reader.peekByte() catch |err| switch (err) { + if ('p' == (reader.peekByte() catch |err| switch (err) { error.EndOfStream => ' ', else => return err, - }) { + })) { reader.toss(1); break :post_proc try Slot.PostProcess.parse(&reader); } else break :post_proc Slot.PostProcess.none; -- 2.54.0