Commit c57dfa2f06e088b67ace125f84e2d97de5396c41 | zig

author	CMDRZero <gbell12907@gmail.com> 2026-07-18 23:57:30-05:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2026-10-22 12:21:43+02:00
log	c57dfa2f06e088b67ace125f84e2d97de5396c41
tree	72ce9b61000c17cf3b74fd252aabd08959d22a75
parent	1bae04f02026427d1754f704bd24fce3317f3e89

Add --upgrade for migrating precedence. Known bug: deletes comments from assignment lines. No clue why.

4 files changed, 105 insertions(+), 36 deletions(-)

lib
- std
  - zig
    Ast.zig
    Ast
    Render.zig
    Parse.zig
src
- fmt.zig

lib/std/zig/Ast.zig+2-4

...	@@ -139,10 +139,7 @@ pub fn deinit(tree: *Ast, gpa: Allocator) void {	...	@@ -139,10 +139,7 @@ pub fn deinit(tree: *Ast, gpa: Allocator) void {
139	}	139	}
140		140
141	pub const Mode = enum { zig, zon };	141	pub const Mode = enum { zig, zon };
142	pub const ParseOptions = struct {	142	pub const ParseOptions = struct { recover: bool = true, mode: Mode = .zig, use_old_precedence: bool = false };
143	recover: bool = true,
144	mode: Mode = .zig,
145	};
146		143
147	/// Result should be freed with tree.deinit() when there are	144	/// Result should be freed with tree.deinit() when there are
148	/// no more references to any of the tokens or nodes.	145	/// no more references to any of the tokens or nodes.
...	@@ -185,6 +182,7 @@ pub fn parseTokens(	...	@@ -185,6 +182,7 @@ pub fn parseTokens(
185	.scratch = .empty,	182	.scratch = .empty,
186	.tok_i = 0,	183	.tok_i = 0,
187	.recover = options.recover,	184	.recover = options.recover,
		185	.use_old_precedence = options.use_old_precedence,
188	};	186	};
189	defer parser.errors.deinit(gpa);	187	defer parser.errors.deinit(gpa);
190	defer parser.nodes.deinit(gpa);	188	defer parser.nodes.deinit(gpa);

lib/std/zig/Ast/Render.zig+34-3

...	@@ -4,6 +4,7 @@ const mem = std.mem;	...	@@ -4,6 +4,7 @@ const mem = std.mem;
4	const Allocator = std.mem.Allocator;	4	const Allocator = std.mem.Allocator;
5	const meta = std.meta;	5	const meta = std.meta;
6	const Ast = std.zig.Ast;	6	const Ast = std.zig.Ast;
		7	const Parse = @import("../../zig/Parse.zig");
7	const Token = std.zig.Token;	8	const Token = std.zig.Token;
8	const primitives = std.zig.primitives;	9	const primitives = std.zig.primitives;
9	const Writer = std.Io.Writer;	10	const Writer = std.Io.Writer;
...	@@ -539,13 +540,43 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {	...	@@ -539,13 +540,43 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
539	.@"orelse",	540	.@"orelse",
540	=> {	541	=> {
541	const lhs, const rhs = tree.nodeData(node).node_and_node;	542	const lhs, const rhs = tree.nodeData(node).node_and_node;
542	try renderExpression(r, lhs, .space);	543
543	const op_token = tree.nodeMainToken(node);	544	const lhs_tag = tree.nodeTag(lhs);
		545	const center_tag = tree.nodeTag(node);
		546	const rhs_tag = tree.nodeTag(rhs);
		547
		548	const lhs_prec = Parse.precedenceFromNodeTag(lhs_tag);
		549	const center_prec = Parse.precedenceFromNodeTag(center_tag);
		550	const rhs_prec = Parse.precedenceFromNodeTag(rhs_tag);
		551
		552	const left_rel = lhs_prec.cmp(center_prec);
		553	const right_rel = rhs_prec.cmp(center_prec);
		554
		555	const paren_left = left_rel == null or left_rel == .lt or (left_rel == .eq and lhs_prec.group == center_prec.group and lhs_prec.assoc == .none);
		556	const paren_right = right_rel == null or right_rel == .lt;
		557
		558
		559	if (paren_left) try ais.writeByte('(');
		560	try renderExpression(r, lhs, .none);
		561	if (paren_left) try ais.writeByte(')');
		562	// Multiline string literals will eat the space so we need to skip if we thats next.
		563	if (tree.tokenTag(tree.lastToken(lhs)) != .multiline_string_literal_line) try renderOnlySpace(r, .space);
		564
544	try ais.pushIndent(.binop);	565	try ais.pushIndent(.binop);
		566	const op_token = tree.nodeMainToken(node);
545	const rhs_seperate_line = !tree.tokensOnSameLine(op_token, op_token + 1) or	567	const rhs_seperate_line = !tree.tokensOnSameLine(op_token, op_token + 1) or
546	tree.tokenTag(op_token + 1) == .multiline_string_literal_line;	568	tree.tokenTag(op_token + 1) == .multiline_string_literal_line;
547	try renderToken(r, op_token, if (rhs_seperate_line) .newline else .space);	569	try renderToken(r, op_token, if (rhs_seperate_line) .newline else .space);
548	try renderExpression(r, rhs, space);	570
		571	if (paren_right) try ais.writeByte('(');
		572	try renderExpression(r, rhs, .none);
		573	if (paren_right) try ais.writeByte(')');
		574
		575	const most_recent = tree.lastToken(rhs);
		576	const lexeme = tokenSliceForRender(tree, most_recent);
		577	// If our space is .none, then the above code functions as normal and putting this here will duplicate comments and such
		578	if (space != .none) try renderSpace(r, most_recent, lexeme.len, space);
		579
549	ais.popIndent();	580	ais.popIndent();
550	},	581	},
551		582

lib/std/zig/Parse.zig+63-28

 @@ -24,6 +24,7 @@ nodes: Ast.NodeList,
 extra_data: std.ArrayList(u32),
 scratch: std.ArrayList(Node.Index),
 recover: bool,
+use_old_precedence: bool = false,
 fn tokenTag(p: *const Parse, token_index: TokenIndex) Token.Tag {
     return p.tokens.items(.tag)[token_index];
 @@ -1531,6 +1532,8 @@ const PrecClass = struct {
     const Group = enum {
         const num_distinct = std.meta.fieldNames(Group).len;
+        top,
         arithmetic_product_chainable,
         arithmetic_mod_nonchainable,
         arithmetic_sum,
 @@ -1588,7 +1591,7 @@ const PrecClass = struct {
         gt = 1,
         fn inverted(self: Rel) Rel {
-            return @enumFromInt(-@intFromEnum(self));
+            return @fromBackingInt(@intCast(-@backingInt(self)));
         }
     };
 @@ -1602,12 +1605,14 @@ const PrecClass = struct {
                 if (!std.mem.startsWith(u8, fieldname_j, @tagName(major_b))) continue;
                 prec_array.*[i][j] = rel;
+                prec_array.*[j][i] = rel.inverted();
             }
         }
     }
     fn setMinorRelation(prec_array: *PrecedenceArray, minor_a: Group, rel: Rel, minor_b: Group) void {
-        prec_array.*[@intFromEnum(minor_a)][@intFromEnum(minor_b)] = rel;
+        prec_array.*[@backingInt(minor_a)][@backingInt(minor_b)] = rel;
+        prec_array.*[@backingInt(minor_b)][@backingInt(minor_a)] = rel.inverted();
     }
     /// Arithmetic_* > Comparison
 @@ -1622,6 +1627,9 @@ const PrecClass = struct {
         @setEvalBranchQuota(20_000);
         const major_greater_than_relations = [_][2]Group.Major{
             // zig fmt: off
+            .{ .top,        .arithmetic },
+            .{ .top,        .bitwise },
+            .{ .top,        .recovery },
             .{ .arithmetic, .comparison },
             .{ .bitwise,    .comparison },
             .{ .comparison, .bool },
 @@ -1656,30 +1664,21 @@ const PrecClass = struct {
         var order: PrecedenceArray = @splat(@splat(null));
+        setMinorRelation(&order, .top, .gt, .arithmetic_product_chainable);
         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_and, .eq, .bitwise_or);
-        setMinorRelation(&order, .bitwise_or, .eq, .recovery_catch);
+        setMinorRelation(&order, .bitwise_and, .eq, .recovery_catch);
-        setMinorRelation(&order, .recovery_catch, .eq, .recovery_orelse);
+        setMinorRelation(&order, .bitwise_and, .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);
 @@ -1697,16 +1696,22 @@ const PrecClass = struct {
     };
     pub fn cmp(lhs: PrecClass, rhs: PrecClass) ?Rel {
-        return PrecClass.precedence_ordering[@intFromEnum(lhs.group)][@intFromEnum(rhs.group)];
+        return PrecClass.precedence_ordering[@backingInt(lhs.group)][@backingInt(rhs.group)];
     }
     pub fn v16_cmp(lhs: PrecClass, rhs: PrecClass) Rel {
-        return PrecClass.v16_precedence_ordering[@intFromEnum(lhs.group)][@intFromEnum(rhs.group)].?;
+        return PrecClass.v16_precedence_ordering[@backingInt(lhs.group)][@backingInt(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];
+            if (order[i][j] == null or order[j][k] == null) continue;
+            // X < Y < Z ==> X < Z         X > Y > Z ==> X > Z
+            if (order[i][j] == order[j][k]) order[i][k] = order[i][j];
+            // X = Y < Z ==> X < Z         X = Y > Z ==> X > Z
+            if (order[i][j] == .eq) order[i][k] = order[j][k];
+            // X < Y = Z ==> X < Z         X > Y = Z ==> X > Z
+            if (order[j][k] == .eq) order[i][k] = order[i][j];
         };
         for (0..Group.num_distinct) |i| for (0..Group.num_distinct) |j| {
             if (i == j) order[i][j] = .eq;
 @@ -1762,6 +1767,23 @@ const operTable = std.enums.directEnumArrayDefault(Token.Tag, OperInfo, .{ .prec
     // zig fmt: on
 });
+fn comptimePrecedenceFromNodeTag(comptime tag: Node.Tag) PrecClass {
+    for (operTable) |data| {
+        if (data.tag == tag) return data.prec;
+    }
+    return .{ .group = .top, .assoc = .left };
+}
+pub fn precedenceFromNodeTag(tag: Node.Tag) PrecClass {
+    return switch (tag) {
+        inline else => |ct_tag| comptimePrecedenceFromNodeTag(ct_tag),
+    };
+}
+pub fn newPrecedenceBetween(left_tok: Node.Tag, right_tok: Node.Tag) ?PrecClass.Rel {
+    return precedenceFromNodeTag(left_tok).cmp(precedenceFromNodeTag(right_tok));
+}
 fn parseExprPrecedence(p: *Parse, min_exc_prec: PrecClass, prev_token_const: u32) Error!?Node.Index {
     var node = try p.parsePrefixExpr() orelse return null;
 @@ -1769,17 +1791,21 @@ fn parseExprPrecedence(p: *Parse, min_exc_prec: PrecClass, prev_token_const: u32
     while (true) {
         const tok_tag = p.tokenTag(p.tok_i);
-        const info = operTable[@intFromEnum(tok_tag)];
+        const info = operTable[@backingInt(tok_tag)];
-        const rel = info.prec.cmp(min_exc_prec) orelse b: {
+        const prec_relation = if (!p.use_old_precedence) info.prec.cmp(min_exc_prec) else info.prec.v16_cmp(min_exc_prec);
+        const rel = prec_relation orelse b: {
+            // This issues warnings if the relation is null, which it never is in 0.16.0
             const prev_op_tok_tag = p.tokenTag(prev_operator_token);
-            const prev_op_info = operTable[@intFromEnum(prev_op_tok_tag)];
+            const prev_op_info = operTable[@backingInt(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 },
+                .extra = .{
+                    .offset = p.tok_i - prev_operator_token,
+                },
             });
             try p.warnMsg(.{
                 .tag = .previous_ambiguous_operator,
 @@ -1791,14 +1817,18 @@ fn parseExprPrecedence(p: *Parse, min_exc_prec: PrecClass, prev_token_const: u32
                     .tag = .hint_operator_precedence_left,
                     .is_note = true,
                     .token = p.tok_i,
-                    .extra = .{ .offset = p.tok_i - prev_operator_token },
+                    .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 },
+                    .extra = .{
+                        .offset = p.tok_i - prev_operator_token,
+                    },
                 });
             }
             break :b .gt;
 @@ -1812,12 +1842,15 @@ fn parseExprPrecedence(p: *Parse, min_exc_prec: PrecClass, prev_token_const: u32
             //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 {
+                // In 0.16.0 the only reptition prohibited was comparisons which we checked above
+            } else if (!p.use_old_precedence) {
                 try p.warnMsg(.{
                     .tag = .illegal_chained_operators,
                     .is_note = false,
                     .token = p.tok_i,
-                    .extra = .{ .offset = p.tok_i - prev_operator_token },
+                    .extra = .{
+                        .offset = p.tok_i - prev_operator_token,
+                    },
                 });
                 try p.warnMsg(.{
                     .tag = .previous_ambiguous_operator,
 @@ -1828,7 +1861,9 @@ fn parseExprPrecedence(p: *Parse, min_exc_prec: PrecClass, prev_token_const: u32
                     .tag = .hint_operator_precedence_left,
                     .is_note = true,
                     .token = p.tok_i,
-                    .extra = .{ .offset = p.tok_i - prev_operator_token },
+                    .extra = .{
+                        .offset = p.tok_i - prev_operator_token,
+                    },
                 });
             }
         }

src/fmt.zig+6-1

...	@@ -41,6 +41,7 @@ const Fmt = struct {	...	@@ -41,6 +41,7 @@ const Fmt = struct {
41	out_buffer: std.Io.Writer.Allocating,	41	out_buffer: std.Io.Writer.Allocating,
42	stdout_writer: *Io.File.Writer,	42	stdout_writer: *Io.File.Writer,
43	stats: ?*Stats,	43	stats: ?*Stats,
		44	fix_precedence: bool,
44		45
45	const SeenMap = std.AutoHashMap(Io.File.INode, void);	46	const SeenMap = std.AutoHashMap(Io.File.INode, void);
46	};	47	};
...	@@ -66,6 +67,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !	...	@@ -66,6 +67,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
66	var check_ast_flag = false;	67	var check_ast_flag = false;
67	var force_zon = false;	68	var force_zon = false;
68	var enable_stats = false;	69	var enable_stats = false;
		70	var fix_precedence = false;
69		71
70	var input_files = std.array_list.Managed([]const u8).init(gpa);	72	var input_files = std.array_list.Managed([]const u8).init(gpa);
71	defer input_files.deinit();	73	defer input_files.deinit();
...	@@ -107,6 +109,8 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !	...	@@ -107,6 +109,8 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
107	try excluded_files.append(next_arg);	109	try excluded_files.append(next_arg);
108	} else if (mem.eql(u8, arg, "--zon")) {	110	} else if (mem.eql(u8, arg, "--zon")) {
109	force_zon = true;	111	force_zon = true;
		112	} else if (mem.eql(u8, arg, "--upgrade")) {
		113	fix_precedence = true;
110	} else {	114	} else {
111	fatal("unrecognized parameter: {q}", .{arg});	115	fatal("unrecognized parameter: {q}", .{arg});
112	}	116	}
...	@@ -198,6 +202,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !	...	@@ -198,6 +202,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
198	.out_buffer = .init(gpa),	202	.out_buffer = .init(gpa),
199	.stdout_writer = &stdout_writer,	203	.stdout_writer = &stdout_writer,
200	.stats = null,	204	.stats = null,
		205	.fix_precedence = fix_precedence,
201	};	206	};
202	defer fmt.seen.deinit();	207	defer fmt.seen.deinit();
203	defer fmt.out_buffer.deinit();	208	defer fmt.out_buffer.deinit();
...	@@ -382,7 +387,7 @@ fn fmtPathFile(	...	@@ -382,7 +387,7 @@ fn fmtPathFile(
382	break :mode .zig;	387	break :mode .zig;
383	};	388	};
384		389
385	var tree = try std.zig.Ast.parse(gpa, source_code, .{ .mode = mode });	390	var tree = try std.zig.Ast.parse(gpa, source_code, .{ .mode = mode, .use_old_precedence = fmt.fix_precedence });
386	defer tree.deinit(gpa);	391	defer tree.deinit(gpa);
387		392
388	if (tree.errors.len != 0) {	393	if (tree.errors.len != 0) {