parser: add error for ambiguous operator precedence

Author: nektro

deps/aro/aro/Driver.zig

@@ -104,9 +104,9 @@ pub const usage =
     \\  -fhosted                Compilation in a hosted environment
     \\  -fms-extensions         Enable support for Microsoft extensions
     \\  -fno-ms-extensions      Disable support for Microsoft extensions
-    \\  -fdollars-in-identifiers        
+    \\  -fdollars-in-identifiers
     \\                          Allow '$' in identifiers
-    \\  -fno-dollars-in-identifiers     
+    \\  -fno-dollars-in-identifiers
     \\                          Disallow '$' in identifiers
     \\  -fmacro-backtrace-limit=<limit>
     \\                          Set limit on how many macro expansion traces are shown in errors (default 6)
@@ -710,7 +710,7 @@ fn processSource(
             d.comp.target.ofmt.fileExt(d.comp.target.cpu.arch),
         };
         break :blk d.output_name orelse
-            std.fmt.bufPrint(&name_buf, fmt_template, fmt_args) catch return d.fatal("Filename too long for filesystem: " ++ fmt_template, fmt_args);
+            (std.fmt.bufPrint(&name_buf, fmt_template, fmt_args) catch return d.fatal("Filename too long for filesystem: " ++ fmt_template, fmt_args));
     } else blk: {
         const random_bytes_count = 12;
         const sub_path_len = comptime std.fs.base64_encoder.calcSize(random_bytes_count);
@@ -725,7 +725,7 @@ fn processSource(
             random_name,
             d.comp.target.ofmt.fileExt(d.comp.target.cpu.arch),
         };
-        break :blk std.fmt.bufPrint(&name_buf, fmt_template, fmt_args) catch return d.fatal("Filename too long for filesystem: " ++ fmt_template, fmt_args);
+        break :blk (std.fmt.bufPrint(&name_buf, fmt_template, fmt_args) catch return d.fatal("Filename too long for filesystem: " ++ fmt_template, fmt_args));
     };
 
     const out_file = std.fs.cwd().createFile(out_file_name, .{}) catch |er|

deps/aro/aro/char_info.zig

@@ -492,15 +492,15 @@ 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;
 }
 
 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;
 }
 

lib/compiler_rt/atomics.zig

@@ -243,7 +243,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, .SeqCst, .SeqCst)) |new_wide_old| {
             wide_old = new_wide_old;
         } else {

lib/std/math/big/int.zig

@@ -3752,7 +3752,7 @@ fn llshl(r: []Limb, a: []const Limb, shift: usize) void {
 
     // We only need the extra limb if the shift of the last element overflows.
     // This is useful for the implementation of `shiftLeftSat`.
-    if (a[a.len - 1] << interior_limb_shift >> interior_limb_shift != a[a.len - 1]) {
+    if ((a[a.len - 1] << interior_limb_shift) >> interior_limb_shift != a[a.len - 1]) {
         assert(r.len >= a.len + (shift / limb_bits) + 1);
     } else {
         assert(r.len >= a.len + (shift / limb_bits));

lib/std/zig/Ast.zig

@@ -452,7 +452,6 @@ pub fn renderError(tree: Ast, parse_error: Error, stream: anytype) !void {
         .for_input_not_captured => {
             return stream.writeAll("for input is not captured");
         },
-
         .expected_token => {
             const found_tag = token_tags[parse_error.token + @intFromBool(parse_error.token_is_prev)];
             const expected_symbol = parse_error.extra.expected_tag.symbol();
@@ -465,6 +464,9 @@ pub fn renderError(tree: Ast, parse_error: Error, stream: anytype) !void {
                 }),
             }
         },
+        .ambiguous_operator_precedence => {
+            return stream.writeAll("ambiguous operator precedence; use parentheses to disambiguate");
+        },
     }
 }
 
@@ -2912,6 +2914,7 @@ pub const Error = struct {
         var_const_decl,
         extra_for_capture,
         for_input_not_captured,
+        ambiguous_operator_precedence,
 
         zig_style_container,
         previous_field,

lib/std/zig/Parse.zig

@@ -1685,6 +1685,8 @@ fn parseExprPrecedence(p: *Parse, min_prec: i32) Error!Node.Index {
     }
 
     var banned_prec: i8 = -1;
+    var prev_op: Token.Tag = .invalid;
+    var prev_prec: i8 = -1;
 
     while (true) {
         const tok_tag = p.token_tags[p.tok_i];
@@ -1695,6 +1697,23 @@ fn parseExprPrecedence(p: *Parse, min_prec: i32) Error!Node.Index {
         if (info.prec == banned_prec) {
             return p.fail(.chained_comparison_operators);
         }
+        if (info.prec > 0) {
+            if (tok_tag != prev_op and info.prec == prev_prec) blk: {
+                if (prev_op == .plus and tok_tag == .minus) break :blk;
+                if (prev_op == .minus and tok_tag == .plus) break :blk;
+                if (prev_op == .plus_percent and tok_tag == .minus_percent) break :blk;
+                if (prev_op == .minus_percent and tok_tag == .plus_percent) break :blk;
+                if (prev_op == .plus_pipe and tok_tag == .minus_pipe) break :blk;
+                if (prev_op == .minus_pipe and tok_tag == .plus_pipe) break :blk;
+
+                if (prev_op == .asterisk and tok_tag == .slash) break :blk;
+                if (prev_op == .slash and tok_tag == .asterisk) break :blk;
+
+                return p.fail(.ambiguous_operator_precedence);
+            }
+            prev_op = tok_tag;
+            prev_prec = info.prec;
+        }
 
         const oper_token = p.nextToken();
         // Special-case handling for "catch"

lib/std/zig/system/NativeTargetInfo.zig

@@ -92,8 +92,8 @@ pub fn detect(cross_target: CrossTarget) DetectError!NativeTargetInfo {
                         // 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;
@@ -106,8 +106,8 @@ pub fn detect(cross_target: CrossTarget) DetectError!NativeTargetInfo {
                         // 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;
                     },
@@ -118,7 +118,7 @@ pub fn detect(cross_target: CrossTarget) DetectError!NativeTargetInfo {
                         //   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;

src/Compilation.zig

@@ -3538,7 +3538,8 @@ pub fn addZirErrorMessages(eb: *ErrorBundle.Wip, file: *Module.File) !void {
             }
             const token_starts = file.tree.tokens.items(.start);
             const start = token_starts[item.data.token] + item.data.byte_offset;
-            const end = start + @as(u32, @intCast(file.tree.tokenSlice(item.data.token).len)) - item.data.byte_offset;
+            const token_slice_len: u32 = @intCast(file.tree.tokenSlice(item.data.token).len);
+            const end = start + token_slice_len - item.data.byte_offset;
             break :blk Module.SrcLoc.Span{ .start = start, .end = end, .main = start };
         };
         const err_loc = std.zig.findLineColumn(file.source, err_span.main);

src/codegen/llvm.zig

@@ -11119,7 +11119,7 @@ fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.E
                 const size: u64 = struct_type.size(ip).*;
                 assert((std.math.divCeil(u64, size, 8) catch unreachable) == types_index);
                 if (size % 8 > 0) {
-                    types_buffer[types_index - 1] = try o.builder.intType(@intCast(size % 8 * 8));
+                    types_buffer[types_index - 1] = try o.builder.intType(@intCast((size % 8) * 8));
                 }
             },
             else => {},
@@ -11401,7 +11401,7 @@ const ParamTypeIterator = struct {
                     assert((std.math.divCeil(u64, size, 8) catch unreachable) == types_index);
                     if (size % 8 > 0) {
                         types_buffer[types_index - 1] =
-                            try it.object.builder.intType(@intCast(size % 8 * 8));
+                            try it.object.builder.intType(@intCast((size % 8) * 8));
                     }
                 },
                 else => {},

src/type.zig

@@ -2954,7 +2954,7 @@ pub const Type = struct {
     /// all the callsites of this function.
     pub fn legacyStructFieldName(ty: Type, i: u32, mod: *Module) InternPool.NullTerminatedString {
         return ty.structFieldName(i, mod).unwrap() orelse
-            mod.intern_pool.getOrPutStringFmt(mod.gpa, "{d}", .{i}) catch @panic("OOM");
+            (mod.intern_pool.getOrPutStringFmt(mod.gpa, "{d}", .{i}) catch @panic("OOM"));
     }
 
     pub fn structFieldCount(ty: Type, mod: *Module) u32 {

test/behavior/math.zig

@@ -51,7 +51,7 @@ fn testThreeExprInARow(f: bool, t: bool) !void {
     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)));

test/cases/compile_errors/ambiguous_operator_precedence.zig

@@ -0,0 +1,14 @@
+const std = @import("std");
+
+test {
+    var x: u16 = 0xFF00;
+    const y: u8 = 0xFF;
+    x = x | y & 0x0F;
+    try std.testing.expect(x == 0xFF0F);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :6:15: error: ambiguous operator precedence, must use parentheses to disambiguate