authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-03-15 14:18:33-04:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2020-03-15 14:18:33-04:00
log0a69a10f2a1997edaeae047c44eca7b260ab72b9
tree8564e93458e119af35c7ae7f404addf221c4a183
parent880d8fc38089a406c6b3225148a6f50ae452cb6b
parent57f9f0755814ab4170b6f770510fe3fb8db2c1e3
signature Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #4740 from Vexu/cleanup

Cleanup and a fix in self-hosted parser

3 files changed, 402 insertions(+), 444 deletions(-)

lib/std/zig/ast.zig+66-92
......@@ -740,11 +740,11 @@ pub const Node = struct {
740740 var i = index;
741741
742742 switch (self.init_arg_expr) {
743 InitArg.Type => |t| {
743 .Type => |t| {
744744 if (i < 1) return t;
745745 i -= 1;
746746 },
747 InitArg.None, InitArg.Enum => {},
747 .None, .Enum => {},
748748 }
749749
750750 if (i < self.fields_and_decls.len) return self.fields_and_decls.at(i).*;
......@@ -904,12 +904,7 @@ pub const Node = struct {
904904 }
905905
906906 switch (self.return_type) {
907 // TODO allow this and next prong to share bodies since the types are the same
908 ReturnType.Explicit => |node| {
909 if (i < 1) return node;
910 i -= 1;
911 },
912 ReturnType.InferErrorSet => |node| {
907 .Explicit, .InferErrorSet => |node| {
913908 if (i < 1) return node;
914909 i -= 1;
915910 },
......@@ -934,9 +929,7 @@ pub const Node = struct {
934929 pub fn lastToken(self: *const FnProto) TokenIndex {
935930 if (self.body_node) |body_node| return body_node.lastToken();
936931 switch (self.return_type) {
937 // TODO allow this and next prong to share bodies since the types are the same
938 ReturnType.Explicit => |node| return node.lastToken(),
939 ReturnType.InferErrorSet => |node| return node.lastToken(),
932 .Explicit, .InferErrorSet => |node| return node.lastToken(),
940933 }
941934 }
942935 };
......@@ -1512,55 +1505,55 @@ pub const Node = struct {
15121505 i -= 1;
15131506
15141507 switch (self.op) {
1515 Op.Catch => |maybe_payload| {
1508 .Catch => |maybe_payload| {
15161509 if (maybe_payload) |payload| {
15171510 if (i < 1) return payload;
15181511 i -= 1;
15191512 }
15201513 },
15211514
1522 Op.Add,
1523 Op.AddWrap,
1524 Op.ArrayCat,
1525 Op.ArrayMult,
1526 Op.Assign,
1527 Op.AssignBitAnd,
1528 Op.AssignBitOr,
1529 Op.AssignBitShiftLeft,
1530 Op.AssignBitShiftRight,
1531 Op.AssignBitXor,
1532 Op.AssignDiv,
1533 Op.AssignSub,
1534 Op.AssignSubWrap,
1535 Op.AssignMod,
1536 Op.AssignAdd,
1537 Op.AssignAddWrap,
1538 Op.AssignMul,
1539 Op.AssignMulWrap,
1540 Op.BangEqual,
1541 Op.BitAnd,
1542 Op.BitOr,
1543 Op.BitShiftLeft,
1544 Op.BitShiftRight,
1545 Op.BitXor,
1546 Op.BoolAnd,
1547 Op.BoolOr,
1548 Op.Div,
1549 Op.EqualEqual,
1550 Op.ErrorUnion,
1551 Op.GreaterOrEqual,
1552 Op.GreaterThan,
1553 Op.LessOrEqual,
1554 Op.LessThan,
1555 Op.MergeErrorSets,
1556 Op.Mod,
1557 Op.Mul,
1558 Op.MulWrap,
1559 Op.Period,
1560 Op.Range,
1561 Op.Sub,
1562 Op.SubWrap,
1563 Op.UnwrapOptional,
1515 .Add,
1516 .AddWrap,
1517 .ArrayCat,
1518 .ArrayMult,
1519 .Assign,
1520 .AssignBitAnd,
1521 .AssignBitOr,
1522 .AssignBitShiftLeft,
1523 .AssignBitShiftRight,
1524 .AssignBitXor,
1525 .AssignDiv,
1526 .AssignSub,
1527 .AssignSubWrap,
1528 .AssignMod,
1529 .AssignAdd,
1530 .AssignAddWrap,
1531 .AssignMul,
1532 .AssignMulWrap,
1533 .BangEqual,
1534 .BitAnd,
1535 .BitOr,
1536 .BitShiftLeft,
1537 .BitShiftRight,
1538 .BitXor,
1539 .BoolAnd,
1540 .BoolOr,
1541 .Div,
1542 .EqualEqual,
1543 .ErrorUnion,
1544 .GreaterOrEqual,
1545 .GreaterThan,
1546 .LessOrEqual,
1547 .LessThan,
1548 .MergeErrorSets,
1549 .Mod,
1550 .Mul,
1551 .MulWrap,
1552 .Period,
1553 .Range,
1554 .Sub,
1555 .SubWrap,
1556 .UnwrapOptional,
15641557 => {},
15651558 }
15661559
......@@ -1591,7 +1584,6 @@ pub const Node = struct {
15911584 Await,
15921585 BitNot,
15931586 BoolNot,
1594 Cancel,
15951587 OptionalType,
15961588 Negation,
15971589 NegationWrap,
......@@ -1628,8 +1620,7 @@ pub const Node = struct {
16281620 var i = index;
16291621
16301622 switch (self.op) {
1631 // TODO https://github.com/ziglang/zig/issues/1107
1632 Op.SliceType => |addr_of_info| {
1623 .PtrType, .SliceType => |addr_of_info| {
16331624 if (addr_of_info.sentinel) |sentinel| {
16341625 if (i < 1) return sentinel;
16351626 i -= 1;
......@@ -1641,14 +1632,7 @@ pub const Node = struct {
16411632 }
16421633 },
16431634
1644 Op.PtrType => |addr_of_info| {
1645 if (addr_of_info.align_info) |align_info| {
1646 if (i < 1) return align_info.node;
1647 i -= 1;
1648 }
1649 },
1650
1651 Op.ArrayType => |array_info| {
1635 .ArrayType => |array_info| {
16521636 if (i < 1) return array_info.len_expr;
16531637 i -= 1;
16541638 if (array_info.sentinel) |sentinel| {
......@@ -1657,16 +1641,15 @@ pub const Node = struct {
16571641 }
16581642 },
16591643
1660 Op.AddressOf,
1661 Op.Await,
1662 Op.BitNot,
1663 Op.BoolNot,
1664 Op.Cancel,
1665 Op.OptionalType,
1666 Op.Negation,
1667 Op.NegationWrap,
1668 Op.Try,
1669 Op.Resume,
1644 .AddressOf,
1645 .Await,
1646 .BitNot,
1647 .BoolNot,
1648 .OptionalType,
1649 .Negation,
1650 .NegationWrap,
1651 .Try,
1652 .Resume,
16701653 => {},
16711654 }
16721655
......@@ -1850,19 +1833,14 @@ pub const Node = struct {
18501833 var i = index;
18511834
18521835 switch (self.kind) {
1853 Kind.Break => |maybe_label| {
1836 .Break,
1837 .Continue => |maybe_label| {
18541838 if (maybe_label) |label| {
18551839 if (i < 1) return label;
18561840 i -= 1;
18571841 }
18581842 },
1859 Kind.Continue => |maybe_label| {
1860 if (maybe_label) |label| {
1861 if (i < 1) return label;
1862 i -= 1;
1863 }
1864 },
1865 Kind.Return => {},
1843 .Return => {},
18661844 }
18671845
18681846 if (self.rhs) |rhs| {
......@@ -1883,17 +1861,13 @@ pub const Node = struct {
18831861 }
18841862
18851863 switch (self.kind) {
1886 Kind.Break => |maybe_label| {
1887 if (maybe_label) |label| {
1888 return label.lastToken();
1889 }
1890 },
1891 Kind.Continue => |maybe_label| {
1864 .Break,
1865 .Continue => |maybe_label| {
18921866 if (maybe_label) |label| {
18931867 return label.lastToken();
18941868 }
18951869 },
1896 Kind.Return => return self.ltoken,
1870 .Return => return self.ltoken,
18971871 }
18981872
18991873 return self.ltoken;
......@@ -2134,11 +2108,11 @@ pub const Node = struct {
21342108 i -= 1;
21352109
21362110 switch (self.kind) {
2137 Kind.Variable => |variable_name| {
2111 .Variable => |variable_name| {
21382112 if (i < 1) return &variable_name.base;
21392113 i -= 1;
21402114 },
2141 Kind.Return => |return_type| {
2115 .Return => |return_type| {
21422116 if (i < 1) return return_type;
21432117 i -= 1;
21442118 },
lib/std/zig/parse.zig+336-351
......@@ -23,7 +23,7 @@ pub fn parse(allocator: *Allocator, source: []const u8) Allocator.Error!*Tree {
2323 var arena = std.heap.ArenaAllocator.init(allocator);
2424 errdefer arena.deinit();
2525 const tree = try arena.allocator.create(ast.Tree);
26 tree.* = ast.Tree{
26 tree.* = .{
2727 .source = source,
2828 .root_node = undefined,
2929 .arena_allocator = arena,
......@@ -66,10 +66,10 @@ pub fn parse(allocator: *Allocator, source: []const u8) Allocator.Error!*Tree {
6666/// Root <- skip ContainerMembers eof
6767fn parseRoot(arena: *Allocator, it: *TokenIterator, tree: *Tree) Error!*Node.Root {
6868 const node = try arena.create(Node.Root);
69 node.* = Node.Root{
69 node.* = .{
7070 .decls = try parseContainerMembers(arena, it, tree),
7171 .eof_token = eatToken(it, .Eof) orelse {
72 try tree.errors.push(AstError{
72 try tree.errors.push(.{
7373 .ExpectedContainerMembers = .{ .token = it.index },
7474 });
7575 return error.ParseError;
......@@ -139,8 +139,8 @@ fn parseContainerMembers(arena: *Allocator, it: *TokenIterator, tree: *Tree) !No
139139 }
140140
141141 if (visib_token != null) {
142 try tree.errors.push(AstError{
143 .ExpectedPubItem = AstError.ExpectedPubItem{ .token = it.index },
142 try tree.errors.push(.{
143 .ExpectedPubItem = .{ .token = it.index },
144144 });
145145 return error.ParseError;
146146 }
......@@ -157,8 +157,8 @@ fn parseContainerMembers(arena: *Allocator, it: *TokenIterator, tree: *Tree) !No
157157
158158 // Dangling doc comment
159159 if (doc_comments != null) {
160 try tree.errors.push(AstError{
161 .UnattachedDocComment = AstError.UnattachedDocComment{ .token = doc_comments.?.firstToken() },
160 try tree.errors.push(.{
161 .UnattachedDocComment = .{ .token = doc_comments.?.firstToken() },
162162 });
163163 }
164164 break;
......@@ -177,7 +177,7 @@ fn parseContainerDocComments(arena: *Allocator, it: *TokenIterator, tree: *Tree)
177177 if (lines.len == 0) return null;
178178
179179 const node = try arena.create(Node.DocComment);
180 node.* = Node.DocComment{
180 node.* = .{
181181 .lines = lines,
182182 };
183183 return &node.base;
......@@ -186,15 +186,15 @@ fn parseContainerDocComments(arena: *Allocator, it: *TokenIterator, tree: *Tree)
186186/// TestDecl <- KEYWORD_test STRINGLITERALSINGLE Block
187187fn parseTestDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
188188 const test_token = eatToken(it, .Keyword_test) orelse return null;
189 const name_node = try expectNode(arena, it, tree, parseStringLiteralSingle, AstError{
190 .ExpectedStringLiteral = AstError.ExpectedStringLiteral{ .token = it.index },
189 const name_node = try expectNode(arena, it, tree, parseStringLiteralSingle, .{
190 .ExpectedStringLiteral = .{ .token = it.index },
191191 });
192 const block_node = try expectNode(arena, it, tree, parseBlock, AstError{
193 .ExpectedLBrace = AstError.ExpectedLBrace{ .token = it.index },
192 const block_node = try expectNode(arena, it, tree, parseBlock, .{
193 .ExpectedLBrace = .{ .token = it.index },
194194 });
195195
196196 const test_node = try arena.create(Node.TestDecl);
197 test_node.* = Node.TestDecl{
197 test_node.* = .{
198198 .doc_comments = null,
199199 .test_token = test_token,
200200 .name = name_node,
......@@ -211,12 +211,12 @@ fn parseTopLevelComptime(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*
211211 return null;
212212 };
213213 putBackToken(it, lbrace);
214 const block_node = try expectNode(arena, it, tree, parseBlockExpr, AstError{
215 .ExpectedLabelOrLBrace = AstError.ExpectedLabelOrLBrace{ .token = it.index },
214 const block_node = try expectNode(arena, it, tree, parseBlockExpr, .{
215 .ExpectedLabelOrLBrace = .{ .token = it.index },
216216 });
217217
218218 const comptime_node = try arena.create(Node.Comptime);
219 comptime_node.* = Node.Comptime{
219 comptime_node.* = .{
220220 .doc_comments = null,
221221 .comptime_token = tok,
222222 .expr = block_node,
......@@ -250,8 +250,8 @@ fn parseTopLevelDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
250250 fn_node.body_node = body_node;
251251 return node;
252252 }
253 try tree.errors.push(AstError{
254 .ExpectedSemiOrLBrace = AstError.ExpectedSemiOrLBrace{ .token = it.index },
253 try tree.errors.push(.{
254 .ExpectedSemiOrLBrace = .{ .token = it.index },
255255 });
256256 return null;
257257 }
......@@ -277,8 +277,8 @@ fn parseTopLevelDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
277277 }
278278
279279 if (thread_local_token != null) {
280 try tree.errors.push(AstError{
281 .ExpectedVarDecl = AstError.ExpectedVarDecl{ .token = it.index },
280 try tree.errors.push(.{
281 .ExpectedVarDecl = .{ .token = it.index },
282282 });
283283 return error.ParseError;
284284 }
......@@ -291,8 +291,8 @@ fn parseTopLevelDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
291291 }
292292
293293 const use_node = (try parseUse(arena, it, tree)) orelse return null;
294 const expr_node = try expectNode(arena, it, tree, parseExpr, AstError{
295 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
294 const expr_node = try expectNode(arena, it, tree, parseExpr, .{
295 .ExpectedExpr = .{ .token = it.index },
296296 });
297297 const semicolon_token = try expectToken(it, tree, .Semicolon);
298298 const use_node_raw = use_node.cast(Node.Use).?;
......@@ -310,7 +310,7 @@ fn parseFnProto(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
310310 if (fnCC == .Extern) {
311311 putBackToken(it, fnCC.Extern); // 'extern' is also used in ContainerDecl
312312 } else {
313 try tree.errors.push(AstError{
313 try tree.errors.push(.{
314314 .ExpectedToken = .{ .token = it.index, .expected_id = .Keyword_fn },
315315 });
316316 return error.ParseError;
......@@ -328,16 +328,16 @@ fn parseFnProto(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
328328 const exclamation_token = eatToken(it, .Bang);
329329
330330 const return_type_expr = (try parseVarType(arena, it, tree)) orelse
331 try expectNode(arena, it, tree, parseTypeExpr, AstError{
332 .ExpectedReturnType = AstError.ExpectedReturnType{ .token = it.index },
331 try expectNode(arena, it, tree, parseTypeExpr, .{
332 .ExpectedReturnType = .{ .token = it.index },
333333 });
334334
335 const return_type = if (exclamation_token != null)
336 Node.FnProto.ReturnType{
335 const return_type: Node.FnProto.ReturnType = if (exclamation_token != null)
336 .{
337337 .InferErrorSet = return_type_expr,
338338 }
339339 else
340 Node.FnProto.ReturnType{
340 .{
341341 .Explicit = return_type_expr,
342342 };
343343
......@@ -347,7 +347,7 @@ fn parseFnProto(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
347347 null;
348348
349349 const fn_proto_node = try arena.create(Node.FnProto);
350 fn_proto_node.* = Node.FnProto{
350 fn_proto_node.* = .{
351351 .doc_comments = null,
352352 .visib_token = null,
353353 .fn_token = fn_token,
......@@ -382,8 +382,8 @@ fn parseVarDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
382382
383383 const name_token = try expectToken(it, tree, .Identifier);
384384 const type_node = if (eatToken(it, .Colon) != null)
385 try expectNode(arena, it, tree, parseTypeExpr, AstError{
386 .ExpectedTypeExpr = AstError.ExpectedTypeExpr{ .token = it.index },
385 try expectNode(arena, it, tree, parseTypeExpr, .{
386 .ExpectedTypeExpr = .{ .token = it.index },
387387 })
388388 else
389389 null;
......@@ -391,14 +391,14 @@ fn parseVarDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
391391 const section_node = try parseLinkSection(arena, it, tree);
392392 const eq_token = eatToken(it, .Equal);
393393 const init_node = if (eq_token != null) blk: {
394 break :blk try expectNode(arena, it, tree, parseExpr, AstError{
395 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
394 break :blk try expectNode(arena, it, tree, parseExpr, .{
395 .ExpectedExpr = .{ .token = it.index },
396396 });
397397 } else null;
398398 const semicolon_token = try expectToken(it, tree, .Semicolon);
399399
400400 const node = try arena.create(Node.VarDecl);
401 node.* = Node.VarDecl{
401 node.* = .{
402402 .doc_comments = null,
403403 .visib_token = null,
404404 .thread_local_token = null,
......@@ -433,22 +433,22 @@ fn parseContainerField(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*No
433433 node.* = .{ .token = var_tok };
434434 type_expr = &node.base;
435435 } else {
436 type_expr = try expectNode(arena, it, tree, parseTypeExpr, AstError{
437 .ExpectedTypeExpr = AstError.ExpectedTypeExpr{ .token = it.index },
436 type_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
437 .ExpectedTypeExpr = .{ .token = it.index },
438438 });
439439 align_expr = try parseByteAlign(arena, it, tree);
440440 }
441441 }
442442
443443 const value_expr = if (eatToken(it, .Equal)) |_|
444 try expectNode(arena, it, tree, parseExpr, AstError{
445 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
444 try expectNode(arena, it, tree, parseExpr, .{
445 .ExpectedExpr = .{ .token = it.index },
446446 })
447447 else
448448 null;
449449
450450 const node = try arena.create(Node.ContainerField);
451 node.* = Node.ContainerField{
451 node.* = .{
452452 .doc_comments = null,
453453 .comptime_token = comptime_token,
454454 .name_token = name_token,
......@@ -481,12 +481,12 @@ fn parseStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) Error!?*No
481481 }
482482
483483 if (comptime_token) |token| {
484 const block_expr = try expectNode(arena, it, tree, parseBlockExprStatement, AstError{
485 .ExpectedBlockOrAssignment = AstError.ExpectedBlockOrAssignment{ .token = it.index },
484 const block_expr = try expectNode(arena, it, tree, parseBlockExprStatement, .{
485 .ExpectedBlockOrAssignment = .{ .token = it.index },
486486 });
487487
488488 const node = try arena.create(Node.Comptime);
489 node.* = Node.Comptime{
489 node.* = .{
490490 .doc_comments = null,
491491 .comptime_token = token,
492492 .expr = block_expr,
......@@ -511,13 +511,13 @@ fn parseStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) Error!?*No
511511 const semicolon = eatToken(it, .Semicolon);
512512
513513 const body_node = if (semicolon == null) blk: {
514 break :blk try expectNode(arena, it, tree, parseBlockExprStatement, AstError{
515 .ExpectedBlockOrExpression = AstError.ExpectedBlockOrExpression{ .token = it.index },
514 break :blk try expectNode(arena, it, tree, parseBlockExprStatement, .{
515 .ExpectedBlockOrExpression = .{ .token = it.index },
516516 });
517517 } else null;
518518
519519 const node = try arena.create(Node.Suspend);
520 node.* = Node.Suspend{
520 node.* = .{
521521 .suspend_token = suspend_token,
522522 .body = body_node,
523523 };
......@@ -526,11 +526,11 @@ fn parseStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) Error!?*No
526526
527527 const defer_token = eatToken(it, .Keyword_defer) orelse eatToken(it, .Keyword_errdefer);
528528 if (defer_token) |token| {
529 const expr_node = try expectNode(arena, it, tree, parseBlockExprStatement, AstError{
530 .ExpectedBlockOrExpression = AstError.ExpectedBlockOrExpression{ .token = it.index },
529 const expr_node = try expectNode(arena, it, tree, parseBlockExprStatement, .{
530 .ExpectedBlockOrExpression = .{ .token = it.index },
531531 });
532532 const node = try arena.create(Node.Defer);
533 node.* = Node.Defer{
533 node.* = .{
534534 .defer_token = token,
535535 .expr = expr_node,
536536 };
......@@ -561,8 +561,8 @@ fn parseIfStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
561561 } else null;
562562
563563 if (block_expr == null and assign_expr == null) {
564 try tree.errors.push(AstError{
565 .ExpectedBlockOrAssignment = AstError.ExpectedBlockOrAssignment{ .token = it.index },
564 try tree.errors.push(.{
565 .ExpectedBlockOrAssignment = .{ .token = it.index },
566566 });
567567 return error.ParseError;
568568 }
......@@ -572,12 +572,12 @@ fn parseIfStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
572572 const else_node = if (semicolon == null) blk: {
573573 const else_token = eatToken(it, .Keyword_else) orelse break :blk null;
574574 const payload = try parsePayload(arena, it, tree);
575 const else_body = try expectNode(arena, it, tree, parseStatement, AstError{
576 .InvalidToken = AstError.InvalidToken{ .token = it.index },
575 const else_body = try expectNode(arena, it, tree, parseStatement, .{
576 .InvalidToken = .{ .token = it.index },
577577 });
578578
579579 const node = try arena.create(Node.Else);
580 node.* = Node.Else{
580 node.* = .{
581581 .else_token = else_token,
582582 .payload = payload,
583583 .body = else_body,
......@@ -599,8 +599,8 @@ fn parseIfStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
599599 if_prefix.@"else" = else_node;
600600 return if_node;
601601 }
602 try tree.errors.push(AstError{
603 .ExpectedSemiOrElse = AstError.ExpectedSemiOrElse{ .token = it.index },
602 try tree.errors.push(.{
603 .ExpectedSemiOrElse = .{ .token = it.index },
604604 });
605605 return error.ParseError;
606606 }
......@@ -628,8 +628,8 @@ fn parseLabeledStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*
628628 }
629629
630630 if (label_token != null) {
631 try tree.errors.push(AstError{
632 .ExpectedLabelable = AstError.ExpectedLabelable{ .token = it.index },
631 try tree.errors.push(.{
632 .ExpectedLabelable = .{ .token = it.index },
633633 });
634634 return error.ParseError;
635635 }
......@@ -665,12 +665,12 @@ fn parseForStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
665665 for_prefix.body = block_expr_node;
666666
667667 if (eatToken(it, .Keyword_else)) |else_token| {
668 const statement_node = try expectNode(arena, it, tree, parseStatement, AstError{
669 .InvalidToken = AstError.InvalidToken{ .token = it.index },
668 const statement_node = try expectNode(arena, it, tree, parseStatement, .{
669 .InvalidToken = .{ .token = it.index },
670670 });
671671
672672 const else_node = try arena.create(Node.Else);
673 else_node.* = Node.Else{
673 else_node.* = .{
674674 .else_token = else_token,
675675 .payload = null,
676676 .body = statement_node,
......@@ -689,12 +689,12 @@ fn parseForStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
689689 if (eatToken(it, .Semicolon) != null) return node;
690690
691691 if (eatToken(it, .Keyword_else)) |else_token| {
692 const statement_node = try expectNode(arena, it, tree, parseStatement, AstError{
693 .ExpectedStatement = AstError.ExpectedStatement{ .token = it.index },
692 const statement_node = try expectNode(arena, it, tree, parseStatement, .{
693 .ExpectedStatement = .{ .token = it.index },
694694 });
695695
696696 const else_node = try arena.create(Node.Else);
697 else_node.* = Node.Else{
697 else_node.* = .{
698698 .else_token = else_token,
699699 .payload = null,
700700 .body = statement_node,
......@@ -703,8 +703,8 @@ fn parseForStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
703703 return node;
704704 }
705705
706 try tree.errors.push(AstError{
707 .ExpectedSemiOrElse = AstError.ExpectedSemiOrElse{ .token = it.index },
706 try tree.errors.push(.{
707 .ExpectedSemiOrElse = .{ .token = it.index },
708708 });
709709 return null;
710710 }
......@@ -725,12 +725,12 @@ fn parseWhileStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*No
725725 if (eatToken(it, .Keyword_else)) |else_token| {
726726 const payload = try parsePayload(arena, it, tree);
727727
728 const statement_node = try expectNode(arena, it, tree, parseStatement, AstError{
729 .InvalidToken = AstError.InvalidToken{ .token = it.index },
728 const statement_node = try expectNode(arena, it, tree, parseStatement, .{
729 .InvalidToken = .{ .token = it.index },
730730 });
731731
732732 const else_node = try arena.create(Node.Else);
733 else_node.* = Node.Else{
733 else_node.* = .{
734734 .else_token = else_token,
735735 .payload = payload,
736736 .body = statement_node,
......@@ -751,12 +751,12 @@ fn parseWhileStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*No
751751 if (eatToken(it, .Keyword_else)) |else_token| {
752752 const payload = try parsePayload(arena, it, tree);
753753
754 const statement_node = try expectNode(arena, it, tree, parseStatement, AstError{
755 .ExpectedStatement = AstError.ExpectedStatement{ .token = it.index },
754 const statement_node = try expectNode(arena, it, tree, parseStatement, .{
755 .ExpectedStatement = .{ .token = it.index },
756756 });
757757
758758 const else_node = try arena.create(Node.Else);
759 else_node.* = Node.Else{
759 else_node.* = .{
760760 .else_token = else_token,
761761 .payload = payload,
762762 .body = statement_node,
......@@ -765,8 +765,8 @@ fn parseWhileStatement(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*No
765765 return node;
766766 }
767767
768 try tree.errors.push(AstError{
769 .ExpectedSemiOrElse = AstError.ExpectedSemiOrElse{ .token = it.index },
768 try tree.errors.push(.{
769 .ExpectedSemiOrElse = .{ .token = it.index },
770770 });
771771 return null;
772772 }
......@@ -894,8 +894,8 @@ fn parsePrimaryExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
894894 }
895895
896896 if (eatToken(it, .Keyword_comptime)) |token| {
897 const expr_node = try expectNode(arena, it, tree, parseExpr, AstError{
898 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
897 const expr_node = try expectNode(arena, it, tree, parseExpr, .{
898 .ExpectedExpr = .{ .token = it.index },
899899 });
900900 const node = try arena.create(Node.Comptime);
901901 node.* = .{
......@@ -907,8 +907,8 @@ fn parsePrimaryExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
907907 }
908908
909909 if (eatToken(it, .Keyword_noasync)) |token| {
910 const expr_node = try expectNode(arena, it, tree, parseExpr, AstError{
911 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
910 const expr_node = try expectNode(arena, it, tree, parseExpr, .{
911 .ExpectedExpr = .{ .token = it.index },
912912 });
913913 const node = try arena.create(Node.Noasync);
914914 node.* = .{
......@@ -930,13 +930,13 @@ fn parsePrimaryExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
930930 }
931931
932932 if (eatToken(it, .Keyword_resume)) |token| {
933 const expr_node = try expectNode(arena, it, tree, parseExpr, AstError{
934 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
933 const expr_node = try expectNode(arena, it, tree, parseExpr, .{
934 .ExpectedExpr = .{ .token = it.index },
935935 });
936936 const node = try arena.create(Node.PrefixOp);
937937 node.* = .{
938938 .op_token = token,
939 .op = Node.PrefixOp.Op.Resume,
939 .op = .Resume,
940940 .rhs = expr_node,
941941 };
942942 return &node.base;
......@@ -992,7 +992,7 @@ fn parseBlock(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
992992 const rbrace = try expectToken(it, tree, .RBrace);
993993
994994 const block_node = try arena.create(Node.Block);
995 block_node.* = Node.Block{
995 block_node.* = .{
996996 .label = null,
997997 .lbrace = lbrace,
998998 .statements = statements,
......@@ -1019,8 +1019,8 @@ fn parseLoopExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
10191019 if (inline_token == null) return null;
10201020
10211021 // If we've seen "inline", there should have been a "for" or "while"
1022 try tree.errors.push(AstError{
1023 .ExpectedInlinable = AstError.ExpectedInlinable{ .token = it.index },
1022 try tree.errors.push(.{
1023 .ExpectedInlinable = .{ .token = it.index },
10241024 });
10251025 return error.ParseError;
10261026}
......@@ -1030,18 +1030,18 @@ fn parseForExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
10301030 const node = (try parseForPrefix(arena, it, tree)) orelse return null;
10311031 const for_prefix = node.cast(Node.For).?;
10321032
1033 const body_node = try expectNode(arena, it, tree, parseExpr, AstError{
1034 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1033 const body_node = try expectNode(arena, it, tree, parseExpr, .{
1034 .ExpectedExpr = .{ .token = it.index },
10351035 });
10361036 for_prefix.body = body_node;
10371037
10381038 if (eatToken(it, .Keyword_else)) |else_token| {
1039 const body = try expectNode(arena, it, tree, parseExpr, AstError{
1040 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1039 const body = try expectNode(arena, it, tree, parseExpr, .{
1040 .ExpectedExpr = .{ .token = it.index },
10411041 });
10421042
10431043 const else_node = try arena.create(Node.Else);
1044 else_node.* = Node.Else{
1044 else_node.* = .{
10451045 .else_token = else_token,
10461046 .payload = null,
10471047 .body = body,
......@@ -1058,19 +1058,19 @@ fn parseWhileExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
10581058 const node = (try parseWhilePrefix(arena, it, tree)) orelse return null;
10591059 const while_prefix = node.cast(Node.While).?;
10601060
1061 const body_node = try expectNode(arena, it, tree, parseExpr, AstError{
1062 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1061 const body_node = try expectNode(arena, it, tree, parseExpr, .{
1062 .ExpectedExpr = .{ .token = it.index },
10631063 });
10641064 while_prefix.body = body_node;
10651065
10661066 if (eatToken(it, .Keyword_else)) |else_token| {
10671067 const payload = try parsePayload(arena, it, tree);
1068 const body = try expectNode(arena, it, tree, parseExpr, AstError{
1069 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1068 const body = try expectNode(arena, it, tree, parseExpr, .{
1069 .ExpectedExpr = .{ .token = it.index },
10701070 });
10711071
10721072 const else_node = try arena.create(Node.Else);
1073 else_node.* = Node.Else{
1073 else_node.* = .{
10741074 .else_token = else_token,
10751075 .payload = payload,
10761076 .body = body,
......@@ -1098,14 +1098,14 @@ fn parseInitList(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node.Suf
10981098 const lbrace = eatToken(it, .LBrace) orelse return null;
10991099 var init_list = Node.SuffixOp.Op.InitList.init(arena);
11001100
1101 const op = blk: {
1101 const op: Node.SuffixOp.Op = blk: {
11021102 if (try parseFieldInit(arena, it, tree)) |field_init| {
11031103 try init_list.push(field_init);
11041104 while (eatToken(it, .Comma)) |_| {
11051105 const next = (try parseFieldInit(arena, it, tree)) orelse break;
11061106 try init_list.push(next);
11071107 }
1108 break :blk Node.SuffixOp.Op{ .StructInitializer = init_list };
1108 break :blk .{ .StructInitializer = init_list };
11091109 }
11101110
11111111 if (try parseExpr(arena, it, tree)) |expr| {
......@@ -1114,14 +1114,14 @@ fn parseInitList(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node.Suf
11141114 const next = (try parseExpr(arena, it, tree)) orelse break;
11151115 try init_list.push(next);
11161116 }
1117 break :blk Node.SuffixOp.Op{ .ArrayInitializer = init_list };
1117 break :blk .{ .ArrayInitializer = init_list };
11181118 }
11191119
1120 break :blk Node.SuffixOp.Op{ .StructInitializer = init_list };
1120 break :blk .{ .StructInitializer = init_list };
11211121 };
11221122
11231123 const node = try arena.create(Node.SuffixOp);
1124 node.* = Node.SuffixOp{
1124 node.* = .{
11251125 .lhs = .{ .node = undefined }, // set by caller
11261126 .op = op,
11271127 .rtoken = try expectToken(it, tree, .RBrace),
......@@ -1140,8 +1140,8 @@ fn parseErrorUnionExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*No
11401140
11411141 if (try SimpleBinOpParseFn(.Bang, Node.InfixOp.Op.ErrorUnion)(arena, it, tree)) |node| {
11421142 const error_union = node.cast(Node.InfixOp).?;
1143 const type_expr = try expectNode(arena, it, tree, parseTypeExpr, AstError{
1144 .ExpectedTypeExpr = AstError.ExpectedTypeExpr{ .token = it.index },
1143 const type_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
1144 .ExpectedTypeExpr = .{ .token = it.index },
11451145 });
11461146 error_union.lhs = suffix_expr;
11471147 error_union.rhs = type_expr;
......@@ -1168,8 +1168,8 @@ fn parseSuffixExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
11681168 return parsePrimaryTypeExpr(arena, it, tree);
11691169 }
11701170 // TODO: Implement hack for parsing `async fn ...` in ast_parse_suffix_expr
1171 var res = try expectNode(arena, it, tree, parsePrimaryTypeExpr, AstError{
1172 .ExpectedPrimaryTypeExpr = AstError.ExpectedPrimaryTypeExpr{ .token = it.index },
1171 var res = try expectNode(arena, it, tree, parsePrimaryTypeExpr, .{
1172 .ExpectedPrimaryTypeExpr = .{ .token = it.index },
11731173 });
11741174
11751175 while (try parseSuffixOp(arena, it, tree)) |node| {
......@@ -1182,16 +1182,16 @@ fn parseSuffixExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
11821182 }
11831183
11841184 const params = (try parseFnCallArguments(arena, it, tree)) orelse {
1185 try tree.errors.push(AstError{
1186 .ExpectedParamList = AstError.ExpectedParamList{ .token = it.index },
1185 try tree.errors.push(.{
1186 .ExpectedParamList = .{ .token = it.index },
11871187 });
11881188 return null;
11891189 };
11901190 const node = try arena.create(Node.SuffixOp);
1191 node.* = Node.SuffixOp{
1191 node.* = .{
11921192 .lhs = .{ .node = res },
1193 .op = Node.SuffixOp.Op{
1194 .Call = Node.SuffixOp.Op.Call{
1193 .op = .{
1194 .Call = .{
11951195 .params = params.list,
11961196 .async_token = async_token,
11971197 },
......@@ -1215,10 +1215,10 @@ fn parseSuffixExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
12151215 }
12161216 if (try parseFnCallArguments(arena, it, tree)) |params| {
12171217 const call = try arena.create(Node.SuffixOp);
1218 call.* = Node.SuffixOp{
1218 call.* = .{
12191219 .lhs = .{ .node = res },
1220 .op = Node.SuffixOp.Op{
1221 .Call = Node.SuffixOp.Op.Call{
1220 .op = .{
1221 .Call = .{
12221222 .params = params.list,
12231223 .async_token = null,
12241224 },
......@@ -1264,7 +1264,7 @@ fn parsePrimaryTypeExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*N
12641264 if (try parseBuiltinCall(arena, it, tree)) |node| return node;
12651265 if (eatToken(it, .CharLiteral)) |token| {
12661266 const node = try arena.create(Node.CharLiteral);
1267 node.* = Node.CharLiteral{
1267 node.* = .{
12681268 .token = token,
12691269 };
12701270 return &node.base;
......@@ -1300,15 +1300,15 @@ fn parsePrimaryTypeExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*N
13001300 }
13011301 if (eatToken(it, .Keyword_error)) |token| {
13021302 const period = try expectToken(it, tree, .Period);
1303 const identifier = try expectNode(arena, it, tree, parseIdentifier, AstError{
1304 .ExpectedIdentifier = AstError.ExpectedIdentifier{ .token = it.index },
1303 const identifier = try expectNode(arena, it, tree, parseIdentifier, .{
1304 .ExpectedIdentifier = .{ .token = it.index },
13051305 });
13061306 const global_error_set = try createLiteral(arena, Node.ErrorType, token);
13071307 const node = try arena.create(Node.InfixOp);
13081308 node.* = .{
13091309 .op_token = period,
13101310 .lhs = global_error_set,
1311 .op = Node.InfixOp.Op.Period,
1311 .op = .Period,
13121312 .rhs = identifier,
13131313 };
13141314 return &node.base;
......@@ -1358,7 +1358,7 @@ fn parseErrorSetDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
13581358 const rbrace = try expectToken(it, tree, .RBrace);
13591359
13601360 const node = try arena.create(Node.ErrorSetDecl);
1361 node.* = Node.ErrorSetDecl{
1361 node.* = .{
13621362 .error_token = error_token,
13631363 .decls = decls,
13641364 .rbrace_token = rbrace,
......@@ -1369,13 +1369,13 @@ fn parseErrorSetDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
13691369/// GroupedExpr <- LPAREN Expr RPAREN
13701370fn parseGroupedExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
13711371 const lparen = eatToken(it, .LParen) orelse return null;
1372 const expr = try expectNode(arena, it, tree, parseExpr, AstError{
1373 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1372 const expr = try expectNode(arena, it, tree, parseExpr, .{
1373 .ExpectedExpr = .{ .token = it.index },
13741374 });
13751375 const rparen = try expectToken(it, tree, .RParen);
13761376
13771377 const node = try arena.create(Node.GroupedExpression);
1378 node.* = Node.GroupedExpression{
1378 node.* = .{
13791379 .lparen = lparen,
13801380 .expr = expr,
13811381 .rparen = rparen,
......@@ -1435,8 +1435,8 @@ fn parseLoopTypeExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
14351435 if (inline_token == null) return null;
14361436
14371437 // If we've seen "inline", there should have been a "for" or "while"
1438 try tree.errors.push(AstError{
1439 .ExpectedInlinable = AstError.ExpectedInlinable{ .token = it.index },
1438 try tree.errors.push(.{
1439 .ExpectedInlinable = .{ .token = it.index },
14401440 });
14411441 return error.ParseError;
14421442}
......@@ -1446,18 +1446,18 @@ fn parseForTypeExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
14461446 const node = (try parseForPrefix(arena, it, tree)) orelse return null;
14471447 const for_prefix = node.cast(Node.For).?;
14481448
1449 const type_expr = try expectNode(arena, it, tree, parseTypeExpr, AstError{
1450 .ExpectedTypeExpr = AstError.ExpectedTypeExpr{ .token = it.index },
1449 const type_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
1450 .ExpectedTypeExpr = .{ .token = it.index },
14511451 });
14521452 for_prefix.body = type_expr;
14531453
14541454 if (eatToken(it, .Keyword_else)) |else_token| {
1455 const else_expr = try expectNode(arena, it, tree, parseTypeExpr, AstError{
1456 .ExpectedTypeExpr = AstError.ExpectedTypeExpr{ .token = it.index },
1455 const else_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
1456 .ExpectedTypeExpr = .{ .token = it.index },
14571457 });
14581458
14591459 const else_node = try arena.create(Node.Else);
1460 else_node.* = Node.Else{
1460 else_node.* = .{
14611461 .else_token = else_token,
14621462 .payload = null,
14631463 .body = else_expr,
......@@ -1474,20 +1474,20 @@ fn parseWhileTypeExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Nod
14741474 const node = (try parseWhilePrefix(arena, it, tree)) orelse return null;
14751475 const while_prefix = node.cast(Node.While).?;
14761476
1477 const type_expr = try expectNode(arena, it, tree, parseTypeExpr, AstError{
1478 .ExpectedTypeExpr = AstError.ExpectedTypeExpr{ .token = it.index },
1477 const type_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
1478 .ExpectedTypeExpr = .{ .token = it.index },
14791479 });
14801480 while_prefix.body = type_expr;
14811481
14821482 if (eatToken(it, .Keyword_else)) |else_token| {
14831483 const payload = try parsePayload(arena, it, tree);
14841484
1485 const else_expr = try expectNode(arena, it, tree, parseTypeExpr, AstError{
1486 .ExpectedTypeExpr = AstError.ExpectedTypeExpr{ .token = it.index },
1485 const else_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
1486 .ExpectedTypeExpr = .{ .token = it.index },
14871487 });
14881488
14891489 const else_node = try arena.create(Node.Else);
1490 else_node.* = Node.Else{
1490 else_node.* = .{
14911491 .else_token = else_token,
14921492 .payload = null,
14931493 .body = else_expr,
......@@ -1503,8 +1503,8 @@ fn parseWhileTypeExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Nod
15031503fn parseSwitchExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
15041504 const switch_token = eatToken(it, .Keyword_switch) orelse return null;
15051505 _ = try expectToken(it, tree, .LParen);
1506 const expr_node = try expectNode(arena, it, tree, parseExpr, AstError{
1507 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1506 const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1507 .ExpectedExpr = .{ .token = it.index },
15081508 });
15091509 _ = try expectToken(it, tree, .RParen);
15101510 _ = try expectToken(it, tree, .LBrace);
......@@ -1512,7 +1512,7 @@ fn parseSwitchExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
15121512 const rbrace = try expectToken(it, tree, .RBrace);
15131513
15141514 const node = try arena.create(Node.Switch);
1515 node.* = Node.Switch{
1515 node.* = .{
15161516 .switch_token = switch_token,
15171517 .expr = expr_node,
15181518 .cases = cases,
......@@ -1526,12 +1526,12 @@ fn parseAsmExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
15261526 const asm_token = eatToken(it, .Keyword_asm) orelse return null;
15271527 const volatile_token = eatToken(it, .Keyword_volatile);
15281528 _ = try expectToken(it, tree, .LParen);
1529 const template = try expectNode(arena, it, tree, parseExpr, AstError{
1530 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1529 const template = try expectNode(arena, it, tree, parseExpr, .{
1530 .ExpectedExpr = .{ .token = it.index },
15311531 });
15321532
15331533 const node = try arena.create(Node.Asm);
1534 node.* = Node.Asm{
1534 node.* = .{
15351535 .asm_token = asm_token,
15361536 .volatile_token = volatile_token,
15371537 .template = template,
......@@ -1553,7 +1553,7 @@ fn parseAnonLiteral(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
15531553 // anon enum literal
15541554 if (eatToken(it, .Identifier)) |name| {
15551555 const node = try arena.create(Node.EnumLiteral);
1556 node.* = Node.EnumLiteral{
1556 node.* = .{
15571557 .dot = dot,
15581558 .name = name,
15591559 };
......@@ -1580,32 +1580,32 @@ fn parseAsmOutput(arena: *Allocator, it: *TokenIterator, tree: *Tree, asm_node:
15801580/// AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
15811581fn parseAsmOutputItem(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node.AsmOutput {
15821582 const lbracket = eatToken(it, .LBracket) orelse return null;
1583 const name = try expectNode(arena, it, tree, parseIdentifier, AstError{
1584 .ExpectedIdentifier = AstError.ExpectedIdentifier{ .token = it.index },
1583 const name = try expectNode(arena, it, tree, parseIdentifier, .{
1584 .ExpectedIdentifier = .{ .token = it.index },
15851585 });
15861586 _ = try expectToken(it, tree, .RBracket);
15871587
1588 const constraint = try expectNode(arena, it, tree, parseStringLiteral, AstError{
1589 .ExpectedStringLiteral = AstError.ExpectedStringLiteral{ .token = it.index },
1588 const constraint = try expectNode(arena, it, tree, parseStringLiteral, .{
1589 .ExpectedStringLiteral = .{ .token = it.index },
15901590 });
15911591
15921592 _ = try expectToken(it, tree, .LParen);
1593 const kind = blk: {
1593 const kind: Node.AsmOutput.Kind = blk: {
15941594 if (eatToken(it, .Arrow) != null) {
1595 const return_ident = try expectNode(arena, it, tree, parseTypeExpr, AstError{
1596 .ExpectedTypeExpr = AstError.ExpectedTypeExpr{ .token = it.index },
1595 const return_ident = try expectNode(arena, it, tree, parseTypeExpr, .{
1596 .ExpectedTypeExpr = .{ .token = it.index },
15971597 });
1598 break :blk Node.AsmOutput.Kind{ .Return = return_ident };
1598 break :blk .{ .Return = return_ident };
15991599 }
1600 const variable = try expectNode(arena, it, tree, parseIdentifier, AstError{
1601 .ExpectedIdentifier = AstError.ExpectedIdentifier{ .token = it.index },
1600 const variable = try expectNode(arena, it, tree, parseIdentifier, .{
1601 .ExpectedIdentifier = .{ .token = it.index },
16021602 });
1603 break :blk Node.AsmOutput.Kind{ .Variable = variable.cast(Node.Identifier).? };
1603 break :blk .{ .Variable = variable.cast(Node.Identifier).? };
16041604 };
16051605 const rparen = try expectToken(it, tree, .RParen);
16061606
16071607 const node = try arena.create(Node.AsmOutput);
1608 node.* = Node.AsmOutput{
1608 node.* = .{
16091609 .lbracket = lbracket,
16101610 .symbolic_name = name,
16111611 .constraint = constraint,
......@@ -1625,23 +1625,23 @@ fn parseAsmInput(arena: *Allocator, it: *TokenIterator, tree: *Tree, asm_node: *
16251625/// AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN
16261626fn parseAsmInputItem(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node.AsmInput {
16271627 const lbracket = eatToken(it, .LBracket) orelse return null;
1628 const name = try expectNode(arena, it, tree, parseIdentifier, AstError{
1629 .ExpectedIdentifier = AstError.ExpectedIdentifier{ .token = it.index },
1628 const name = try expectNode(arena, it, tree, parseIdentifier, .{
1629 .ExpectedIdentifier = .{ .token = it.index },
16301630 });
16311631 _ = try expectToken(it, tree, .RBracket);
16321632
1633 const constraint = try expectNode(arena, it, tree, parseStringLiteral, AstError{
1634 .ExpectedStringLiteral = AstError.ExpectedStringLiteral{ .token = it.index },
1633 const constraint = try expectNode(arena, it, tree, parseStringLiteral, .{
1634 .ExpectedStringLiteral = .{ .token = it.index },
16351635 });
16361636
16371637 _ = try expectToken(it, tree, .LParen);
1638 const expr = try expectNode(arena, it, tree, parseExpr, AstError{
1639 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1638 const expr = try expectNode(arena, it, tree, parseExpr, .{
1639 .ExpectedExpr = .{ .token = it.index },
16401640 });
16411641 const rparen = try expectToken(it, tree, .RParen);
16421642
16431643 const node = try arena.create(Node.AsmInput);
1644 node.* = Node.AsmInput{
1644 node.* = .{
16451645 .lbracket = lbracket,
16461646 .symbolic_name = name,
16471647 .constraint = constraint,
......@@ -1664,8 +1664,8 @@ fn parseAsmClobbers(arena: *Allocator, it: *TokenIterator, tree: *Tree, asm_node
16641664/// BreakLabel <- COLON IDENTIFIER
16651665fn parseBreakLabel(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
16661666 _ = eatToken(it, .Colon) orelse return null;
1667 return try expectNode(arena, it, tree, parseIdentifier, AstError{
1668 .ExpectedIdentifier = AstError.ExpectedIdentifier{ .token = it.index },
1667 return try expectNode(arena, it, tree, parseIdentifier, .{
1668 .ExpectedIdentifier = .{ .token = it.index },
16691669 });
16701670}
16711671
......@@ -1694,12 +1694,12 @@ fn parseFieldInit(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
16941694 putBackToken(it, period_token);
16951695 return null;
16961696 };
1697 const expr_node = try expectNode(arena, it, tree, parseExpr, AstError{
1698 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1697 const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1698 .ExpectedExpr = .{ .token = it.index },
16991699 });
17001700
17011701 const node = try arena.create(Node.FieldInitializer);
1702 node.* = Node.FieldInitializer{
1702 node.* = .{
17031703 .period_token = period_token,
17041704 .name_token = name_token,
17051705 .expr = expr_node,
......@@ -1711,8 +1711,8 @@ fn parseFieldInit(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
17111711fn parseWhileContinueExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
17121712 _ = eatToken(it, .Colon) orelse return null;
17131713 _ = try expectToken(it, tree, .LParen);
1714 const node = try expectNode(arena, it, tree, parseAssignExpr, AstError{
1715 .ExpectedExprOrAssignment = AstError.ExpectedExprOrAssignment{ .token = it.index },
1714 const node = try expectNode(arena, it, tree, parseAssignExpr, .{
1715 .ExpectedExprOrAssignment = .{ .token = it.index },
17161716 });
17171717 _ = try expectToken(it, tree, .RParen);
17181718 return node;
......@@ -1722,8 +1722,8 @@ fn parseWhileContinueExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?
17221722fn parseLinkSection(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
17231723 _ = eatToken(it, .Keyword_linksection) orelse return null;
17241724 _ = try expectToken(it, tree, .LParen);
1725 const expr_node = try expectNode(arena, it, tree, parseExpr, AstError{
1726 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1725 const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1726 .ExpectedExpr = .{ .token = it.index },
17271727 });
17281728 _ = try expectToken(it, tree, .RParen);
17291729 return expr_node;
......@@ -1733,8 +1733,8 @@ fn parseLinkSection(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
17331733fn parseCallconv(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
17341734 _ = eatToken(it, .Keyword_callconv) orelse return null;
17351735 _ = try expectToken(it, tree, .LParen);
1736 const expr_node = try expectNode(arena, it, tree, parseExpr, AstError{
1737 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1736 const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1737 .ExpectedExpr = .{ .token = it.index },
17381738 });
17391739 _ = try expectToken(it, tree, .RParen);
17401740 return expr_node;
......@@ -1775,14 +1775,14 @@ fn parseParamDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
17751775 comptime_token == null and
17761776 name_token == null and
17771777 doc_comments == null) return null;
1778 try tree.errors.push(AstError{
1779 .ExpectedParamType = AstError.ExpectedParamType{ .token = it.index },
1778 try tree.errors.push(.{
1779 .ExpectedParamType = .{ .token = it.index },
17801780 });
17811781 return error.ParseError;
17821782 };
17831783
17841784 const param_decl = try arena.create(Node.ParamDecl);
1785 param_decl.* = Node.ParamDecl{
1785 param_decl.* = .{
17861786 .doc_comments = doc_comments,
17871787 .comptime_token = comptime_token,
17881788 .noalias_token = noalias_token,
......@@ -1821,14 +1821,14 @@ const ParamType = union(enum) {
18211821fn parseIfPrefix(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
18221822 const if_token = eatToken(it, .Keyword_if) orelse return null;
18231823 _ = try expectToken(it, tree, .LParen);
1824 const condition = try expectNode(arena, it, tree, parseExpr, AstError{
1825 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1824 const condition = try expectNode(arena, it, tree, parseExpr, .{
1825 .ExpectedExpr = .{ .token = it.index },
18261826 });
18271827 _ = try expectToken(it, tree, .RParen);
18281828 const payload = try parsePtrPayload(arena, it, tree);
18291829
18301830 const node = try arena.create(Node.If);
1831 node.* = Node.If{
1831 node.* = .{
18321832 .if_token = if_token,
18331833 .condition = condition,
18341834 .payload = payload,
......@@ -1843,8 +1843,8 @@ fn parseWhilePrefix(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
18431843 const while_token = eatToken(it, .Keyword_while) orelse return null;
18441844
18451845 _ = try expectToken(it, tree, .LParen);
1846 const condition = try expectNode(arena, it, tree, parseExpr, AstError{
1847 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1846 const condition = try expectNode(arena, it, tree, parseExpr, .{
1847 .ExpectedExpr = .{ .token = it.index },
18481848 });
18491849 _ = try expectToken(it, tree, .RParen);
18501850
......@@ -1852,7 +1852,7 @@ fn parseWhilePrefix(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
18521852 const continue_expr = try parseWhileContinueExpr(arena, it, tree);
18531853
18541854 const node = try arena.create(Node.While);
1855 node.* = Node.While{
1855 node.* = .{
18561856 .label = null,
18571857 .inline_token = null,
18581858 .while_token = while_token,
......@@ -1870,17 +1870,17 @@ fn parseForPrefix(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
18701870 const for_token = eatToken(it, .Keyword_for) orelse return null;
18711871
18721872 _ = try expectToken(it, tree, .LParen);
1873 const array_expr = try expectNode(arena, it, tree, parseExpr, AstError{
1874 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
1873 const array_expr = try expectNode(arena, it, tree, parseExpr, .{
1874 .ExpectedExpr = .{ .token = it.index },
18751875 });
18761876 _ = try expectToken(it, tree, .RParen);
18771877
1878 const payload = try expectNode(arena, it, tree, parsePtrIndexPayload, AstError{
1879 .ExpectedPayload = AstError.ExpectedPayload{ .token = it.index },
1878 const payload = try expectNode(arena, it, tree, parsePtrIndexPayload, .{
1879 .ExpectedPayload = .{ .token = it.index },
18801880 });
18811881
18821882 const node = try arena.create(Node.For);
1883 node.* = Node.For{
1883 node.* = .{
18841884 .label = null,
18851885 .inline_token = null,
18861886 .for_token = for_token,
......@@ -1895,13 +1895,13 @@ fn parseForPrefix(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
18951895/// Payload <- PIPE IDENTIFIER PIPE
18961896fn parsePayload(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
18971897 const lpipe = eatToken(it, .Pipe) orelse return null;
1898 const identifier = try expectNode(arena, it, tree, parseIdentifier, AstError{
1899 .ExpectedIdentifier = AstError.ExpectedIdentifier{ .token = it.index },
1898 const identifier = try expectNode(arena, it, tree, parseIdentifier, .{
1899 .ExpectedIdentifier = .{ .token = it.index },
19001900 });
19011901 const rpipe = try expectToken(it, tree, .Pipe);
19021902
19031903 const node = try arena.create(Node.Payload);
1904 node.* = Node.Payload{
1904 node.* = .{
19051905 .lpipe = lpipe,
19061906 .error_symbol = identifier,
19071907 .rpipe = rpipe,
......@@ -1913,13 +1913,13 @@ fn parsePayload(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
19131913fn parsePtrPayload(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
19141914 const lpipe = eatToken(it, .Pipe) orelse return null;
19151915 const asterisk = eatToken(it, .Asterisk);
1916 const identifier = try expectNode(arena, it, tree, parseIdentifier, AstError{
1917 .ExpectedIdentifier = AstError.ExpectedIdentifier{ .token = it.index },
1916 const identifier = try expectNode(arena, it, tree, parseIdentifier, .{
1917 .ExpectedIdentifier = .{ .token = it.index },
19181918 });
19191919 const rpipe = try expectToken(it, tree, .Pipe);
19201920
19211921 const node = try arena.create(Node.PointerPayload);
1922 node.* = Node.PointerPayload{
1922 node.* = .{
19231923 .lpipe = lpipe,
19241924 .ptr_token = asterisk,
19251925 .value_symbol = identifier,
......@@ -1932,21 +1932,21 @@ fn parsePtrPayload(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
19321932fn parsePtrIndexPayload(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
19331933 const lpipe = eatToken(it, .Pipe) orelse return null;
19341934 const asterisk = eatToken(it, .Asterisk);
1935 const identifier = try expectNode(arena, it, tree, parseIdentifier, AstError{
1936 .ExpectedIdentifier = AstError.ExpectedIdentifier{ .token = it.index },
1935 const identifier = try expectNode(arena, it, tree, parseIdentifier, .{
1936 .ExpectedIdentifier = .{ .token = it.index },
19371937 });
19381938
19391939 const index = if (eatToken(it, .Comma) == null)
19401940 null
19411941 else
1942 try expectNode(arena, it, tree, parseIdentifier, AstError{
1943 .ExpectedIdentifier = AstError.ExpectedIdentifier{ .token = it.index },
1942 try expectNode(arena, it, tree, parseIdentifier, .{
1943 .ExpectedIdentifier = .{ .token = it.index },
19441944 });
19451945
19461946 const rpipe = try expectToken(it, tree, .Pipe);
19471947
19481948 const node = try arena.create(Node.PointerIndexPayload);
1949 node.* = Node.PointerIndexPayload{
1949 node.* = .{
19501950 .lpipe = lpipe,
19511951 .ptr_token = asterisk,
19521952 .value_symbol = identifier,
......@@ -1961,8 +1961,8 @@ fn parseSwitchProng(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
19611961 const node = (try parseSwitchCase(arena, it, tree)) orelse return null;
19621962 const arrow = try expectToken(it, tree, .EqualAngleBracketRight);
19631963 const payload = try parsePtrPayload(arena, it, tree);
1964 const expr = try expectNode(arena, it, tree, parseAssignExpr, AstError{
1965 .ExpectedExprOrAssignment = AstError.ExpectedExprOrAssignment{ .token = it.index },
1964 const expr = try expectNode(arena, it, tree, parseAssignExpr, .{
1965 .ExpectedExprOrAssignment = .{ .token = it.index },
19661966 });
19671967
19681968 const switch_case = node.cast(Node.SwitchCase).?;
......@@ -1987,14 +1987,14 @@ fn parseSwitchCase(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
19871987 }
19881988 } else if (eatToken(it, .Keyword_else)) |else_token| {
19891989 const else_node = try arena.create(Node.SwitchElse);
1990 else_node.* = Node.SwitchElse{
1990 else_node.* = .{
19911991 .token = else_token,
19921992 };
19931993 try list.push(&else_node.base);
19941994 } else return null;
19951995
19961996 const node = try arena.create(Node.SwitchCase);
1997 node.* = Node.SwitchCase{
1997 node.* = .{
19981998 .items = list,
19991999 .arrow_token = undefined, // set by caller
20002000 .payload = null,
......@@ -2007,15 +2007,15 @@ fn parseSwitchCase(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
20072007fn parseSwitchItem(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
20082008 const expr = (try parseExpr(arena, it, tree)) orelse return null;
20092009 if (eatToken(it, .Ellipsis3)) |token| {
2010 const range_end = try expectNode(arena, it, tree, parseExpr, AstError{
2011 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
2010 const range_end = try expectNode(arena, it, tree, parseExpr, .{
2011 .ExpectedExpr = .{ .token = it.index },
20122012 });
20132013
20142014 const node = try arena.create(Node.InfixOp);
2015 node.* = Node.InfixOp{
2015 node.* = .{
20162016 .op_token = token,
20172017 .lhs = expr,
2018 .op = Node.InfixOp.Op{ .Range = {} },
2018 .op = .Range,
20192019 .rhs = range_end,
20202020 };
20212021 return &node.base;
......@@ -2039,24 +2039,22 @@ fn parseSwitchItem(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
20392039/// / MINUSPERCENTEQUAL
20402040/// / EQUAL
20412041fn parseAssignOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
2042 const Op = Node.InfixOp.Op;
2043
20442042 const token = nextToken(it);
2045 const op = switch (token.ptr.id) {
2046 .AsteriskEqual => Op{ .AssignMul = {} },
2047 .SlashEqual => Op{ .AssignDiv = {} },
2048 .PercentEqual => Op{ .AssignMod = {} },
2049 .PlusEqual => Op{ .AssignAdd = {} },
2050 .MinusEqual => Op{ .AssignSub = {} },
2051 .AngleBracketAngleBracketLeftEqual => Op{ .AssignBitShiftLeft = {} },
2052 .AngleBracketAngleBracketRightEqual => Op{ .AssignBitShiftRight = {} },
2053 .AmpersandEqual => Op{ .AssignBitAnd = {} },
2054 .CaretEqual => Op{ .AssignBitXor = {} },
2055 .PipeEqual => Op{ .AssignBitOr = {} },
2056 .AsteriskPercentEqual => Op{ .AssignMulWrap = {} },
2057 .PlusPercentEqual => Op{ .AssignAddWrap = {} },
2058 .MinusPercentEqual => Op{ .AssignSubWrap = {} },
2059 .Equal => Op{ .Assign = {} },
2043 const op: Node.InfixOp.Op = switch (token.ptr.id) {
2044 .AsteriskEqual => .AssignMul,
2045 .SlashEqual => .AssignDiv,
2046 .PercentEqual => .AssignMod,
2047 .PlusEqual => .AssignAdd,
2048 .MinusEqual => .AssignSub,
2049 .AngleBracketAngleBracketLeftEqual => .AssignBitShiftLeft,
2050 .AngleBracketAngleBracketRightEqual => .AssignBitShiftRight,
2051 .AmpersandEqual => .AssignBitAnd,
2052 .CaretEqual => .AssignBitXor,
2053 .PipeEqual => .AssignBitOr,
2054 .AsteriskPercentEqual => .AssignMulWrap,
2055 .PlusPercentEqual => .AssignAddWrap,
2056 .MinusPercentEqual => .AssignSubWrap,
2057 .Equal => .Assign,
20602058 else => {
20612059 putBackToken(it, token.index);
20622060 return null;
......@@ -2064,7 +2062,7 @@ fn parseAssignOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
20642062 };
20652063
20662064 const node = try arena.create(Node.InfixOp);
2067 node.* = Node.InfixOp{
2065 node.* = .{
20682066 .op_token = token.index,
20692067 .lhs = undefined, // set by caller
20702068 .op = op,
......@@ -2081,16 +2079,14 @@ fn parseAssignOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
20812079/// / LARROWEQUAL
20822080/// / RARROWEQUAL
20832081fn parseCompareOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
2084 const ops = Node.InfixOp.Op;
2085
20862082 const token = nextToken(it);
2087 const op = switch (token.ptr.id) {
2088 .EqualEqual => ops{ .EqualEqual = {} },
2089 .BangEqual => ops{ .BangEqual = {} },
2090 .AngleBracketLeft => ops{ .LessThan = {} },
2091 .AngleBracketRight => ops{ .GreaterThan = {} },
2092 .AngleBracketLeftEqual => ops{ .LessOrEqual = {} },
2093 .AngleBracketRightEqual => ops{ .GreaterOrEqual = {} },
2083 const op: Node.InfixOp.Op = switch (token.ptr.id) {
2084 .EqualEqual => .EqualEqual,
2085 .BangEqual => .BangEqual,
2086 .AngleBracketLeft => .LessThan,
2087 .AngleBracketRight => .GreaterThan,
2088 .AngleBracketLeftEqual => .LessOrEqual,
2089 .AngleBracketRightEqual => .GreaterOrEqual,
20942090 else => {
20952091 putBackToken(it, token.index);
20962092 return null;
......@@ -2107,15 +2103,13 @@ fn parseCompareOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
21072103/// / KEYWORD_orelse
21082104/// / KEYWORD_catch Payload?
21092105fn parseBitwiseOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
2110 const ops = Node.InfixOp.Op;
2111
21122106 const token = nextToken(it);
2113 const op = switch (token.ptr.id) {
2114 .Ampersand => ops{ .BitAnd = {} },
2115 .Caret => ops{ .BitXor = {} },
2116 .Pipe => ops{ .BitOr = {} },
2117 .Keyword_orelse => ops{ .UnwrapOptional = {} },
2118 .Keyword_catch => ops{ .Catch = try parsePayload(arena, it, tree) },
2107 const op: Node.InfixOp.Op = switch (token.ptr.id) {
2108 .Ampersand => .BitAnd,
2109 .Caret => .BitXor,
2110 .Pipe => .BitOr,
2111 .Keyword_orelse => .UnwrapOptional,
2112 .Keyword_catch => .{ .Catch = try parsePayload(arena, it, tree) },
21192113 else => {
21202114 putBackToken(it, token.index);
21212115 return null;
......@@ -2129,12 +2123,10 @@ fn parseBitwiseOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
21292123/// <- LARROW2
21302124/// / RARROW2
21312125fn parseBitShiftOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
2132 const ops = Node.InfixOp.Op;
2133
21342126 const token = nextToken(it);
2135 const op = switch (token.ptr.id) {
2136 .AngleBracketAngleBracketLeft => ops{ .BitShiftLeft = {} },
2137 .AngleBracketAngleBracketRight => ops{ .BitShiftRight = {} },
2127 const op: Node.InfixOp.Op = switch (token.ptr.id) {
2128 .AngleBracketAngleBracketLeft => .BitShiftLeft,
2129 .AngleBracketAngleBracketRight => .BitShiftRight,
21382130 else => {
21392131 putBackToken(it, token.index);
21402132 return null;
......@@ -2151,15 +2143,13 @@ fn parseBitShiftOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
21512143/// / PLUSPERCENT
21522144/// / MINUSPERCENT
21532145fn parseAdditionOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
2154 const ops = Node.InfixOp.Op;
2155
21562146 const token = nextToken(it);
2157 const op = switch (token.ptr.id) {
2158 .Plus => ops{ .Add = {} },
2159 .Minus => ops{ .Sub = {} },
2160 .PlusPlus => ops{ .ArrayCat = {} },
2161 .PlusPercent => ops{ .AddWrap = {} },
2162 .MinusPercent => ops{ .SubWrap = {} },
2147 const op: Node.InfixOp.Op = switch (token.ptr.id) {
2148 .Plus => .Add,
2149 .Minus => .Sub,
2150 .PlusPlus => .ArrayCat,
2151 .PlusPercent => .AddWrap,
2152 .MinusPercent => .SubWrap,
21632153 else => {
21642154 putBackToken(it, token.index);
21652155 return null;
......@@ -2177,16 +2167,14 @@ fn parseAdditionOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
21772167/// / ASTERISK2
21782168/// / ASTERISKPERCENT
21792169fn parseMultiplyOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
2180 const ops = Node.InfixOp.Op;
2181
21822170 const token = nextToken(it);
2183 const op = switch (token.ptr.id) {
2184 .PipePipe => ops{ .BoolOr = {} },
2185 .Asterisk => ops{ .Mul = {} },
2186 .Slash => ops{ .Div = {} },
2187 .Percent => ops{ .Mod = {} },
2188 .AsteriskAsterisk => ops{ .ArrayMult = {} },
2189 .AsteriskPercent => ops{ .MulWrap = {} },
2171 const op: Node.InfixOp.Op = switch (token.ptr.id) {
2172 .PipePipe => .MergeErrorSets,
2173 .Asterisk => .Mul,
2174 .Slash => .Div,
2175 .Percent => .Mod,
2176 .AsteriskAsterisk => .ArrayMult,
2177 .AsteriskPercent => .MulWrap,
21902178 else => {
21912179 putBackToken(it, token.index);
21922180 return null;
......@@ -2205,17 +2193,15 @@ fn parseMultiplyOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
22052193/// / KEYWORD_try
22062194/// / KEYWORD_await
22072195fn parsePrefixOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
2208 const ops = Node.PrefixOp.Op;
2209
22102196 const token = nextToken(it);
2211 const op = switch (token.ptr.id) {
2212 .Bang => ops{ .BoolNot = {} },
2213 .Minus => ops{ .Negation = {} },
2214 .Tilde => ops{ .BitNot = {} },
2215 .MinusPercent => ops{ .NegationWrap = {} },
2216 .Ampersand => ops{ .AddressOf = {} },
2217 .Keyword_try => ops{ .Try = {} },
2218 .Keyword_await => ops{ .Await = .{} },
2197 const op: Node.PrefixOp.Op = switch (token.ptr.id) {
2198 .Bang => .BoolNot,
2199 .Minus => .Negation,
2200 .Tilde => .BitNot,
2201 .MinusPercent => .NegationWrap,
2202 .Ampersand => .AddressOf,
2203 .Keyword_try => .Try,
2204 .Keyword_await => .Await,
22192205 else => {
22202206 putBackToken(it, token.index);
22212207 return null;
......@@ -2223,7 +2209,7 @@ fn parsePrefixOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
22232209 };
22242210
22252211 const node = try arena.create(Node.PrefixOp);
2226 node.* = Node.PrefixOp{
2212 node.* = .{
22272213 .op_token = token.index,
22282214 .op = op,
22292215 .rhs = undefined, // set by caller
......@@ -2246,9 +2232,9 @@ fn parsePrefixOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
22462232fn parsePrefixTypeOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
22472233 if (eatToken(it, .QuestionMark)) |token| {
22482234 const node = try arena.create(Node.PrefixOp);
2249 node.* = Node.PrefixOp{
2235 node.* = .{
22502236 .op_token = token,
2251 .op = Node.PrefixOp.Op.OptionalType,
2237 .op = .OptionalType,
22522238 .rhs = undefined, // set by caller
22532239 };
22542240 return &node.base;
......@@ -2264,7 +2250,7 @@ fn parsePrefixTypeOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
22642250 return null;
22652251 };
22662252 const node = try arena.create(Node.AnyFrameType);
2267 node.* = Node.AnyFrameType{
2253 node.* = .{
22682254 .anyframe_token = token,
22692255 .result = Node.AnyFrameType.Result{
22702256 .arrow_token = arrow,
......@@ -2286,18 +2272,18 @@ fn parsePrefixTypeOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
22862272 while (true) {
22872273 if (eatToken(it, .Keyword_align)) |align_token| {
22882274 const lparen = try expectToken(it, tree, .LParen);
2289 const expr_node = try expectNode(arena, it, tree, parseExpr, AstError{
2290 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
2275 const expr_node = try expectNode(arena, it, tree, parseExpr, .{
2276 .ExpectedExpr = .{ .token = it.index },
22912277 });
22922278
22932279 // Optional bit range
22942280 const bit_range = if (eatToken(it, .Colon)) |_| bit_range_value: {
2295 const range_start = try expectNode(arena, it, tree, parseIntegerLiteral, AstError{
2296 .ExpectedIntegerLiteral = AstError.ExpectedIntegerLiteral{ .token = it.index },
2281 const range_start = try expectNode(arena, it, tree, parseIntegerLiteral, .{
2282 .ExpectedIntegerLiteral = .{ .token = it.index },
22972283 });
22982284 _ = try expectToken(it, tree, .Colon);
2299 const range_end = try expectNode(arena, it, tree, parseIntegerLiteral, AstError{
2300 .ExpectedIntegerLiteral = AstError.ExpectedIntegerLiteral{ .token = it.index },
2285 const range_end = try expectNode(arena, it, tree, parseIntegerLiteral, .{
2286 .ExpectedIntegerLiteral = .{ .token = it.index },
23012287 });
23022288
23032289 break :bit_range_value Node.PrefixOp.PtrInfo.Align.BitRange{
......@@ -2340,8 +2326,8 @@ fn parsePrefixTypeOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
23402326 while (true) {
23412327 if (try parseByteAlign(arena, it, tree)) |align_expr| {
23422328 if (slice_type.align_info != null) {
2343 try tree.errors.push(AstError{
2344 .ExtraAlignQualifier = AstError.ExtraAlignQualifier{ .token = it.index },
2329 try tree.errors.push(.{
2330 .ExtraAlignQualifier = .{ .token = it.index },
23452331 });
23462332 return error.ParseError;
23472333 }
......@@ -2353,8 +2339,8 @@ fn parsePrefixTypeOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
23532339 }
23542340 if (eatToken(it, .Keyword_const)) |const_token| {
23552341 if (slice_type.const_token != null) {
2356 try tree.errors.push(AstError{
2357 .ExtraConstQualifier = AstError.ExtraConstQualifier{ .token = it.index },
2342 try tree.errors.push(.{
2343 .ExtraConstQualifier = .{ .token = it.index },
23582344 });
23592345 return error.ParseError;
23602346 }
......@@ -2363,8 +2349,8 @@ fn parsePrefixTypeOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
23632349 }
23642350 if (eatToken(it, .Keyword_volatile)) |volatile_token| {
23652351 if (slice_type.volatile_token != null) {
2366 try tree.errors.push(AstError{
2367 .ExtraVolatileQualifier = AstError.ExtraVolatileQualifier{ .token = it.index },
2352 try tree.errors.push(.{
2353 .ExtraVolatileQualifier = .{ .token = it.index },
23682354 });
23692355 return error.ParseError;
23702356 }
......@@ -2373,8 +2359,8 @@ fn parsePrefixTypeOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
23732359 }
23742360 if (eatToken(it, .Keyword_allowzero)) |allowzero_token| {
23752361 if (slice_type.allowzero_token != null) {
2376 try tree.errors.push(AstError{
2377 .ExtraAllowZeroQualifier = AstError.ExtraAllowZeroQualifier{ .token = it.index },
2362 try tree.errors.push(.{
2363 .ExtraAllowZeroQualifier = .{ .token = it.index },
23782364 });
23792365 return error.ParseError;
23802366 }
......@@ -2398,15 +2384,14 @@ fn parsePrefixTypeOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
23982384/// / DOTASTERISK
23992385/// / DOTQUESTIONMARK
24002386fn parseSuffixOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
2401 const Op = Node.SuffixOp.Op;
24022387 const OpAndToken = struct {
24032388 op: Node.SuffixOp.Op,
24042389 token: TokenIndex,
24052390 };
2406 const op_and_token = blk: {
2391 const op_and_token: OpAndToken = blk: {
24072392 if (eatToken(it, .LBracket)) |_| {
2408 const index_expr = try expectNode(arena, it, tree, parseExpr, AstError{
2409 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
2393 const index_expr = try expectNode(arena, it, tree, parseExpr, .{
2394 .ExpectedExpr = .{ .token = it.index },
24102395 });
24112396
24122397 if (eatToken(it, .Ellipsis2) != null) {
......@@ -2415,9 +2400,9 @@ fn parseSuffixOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
24152400 try parseExpr(arena, it, tree)
24162401 else
24172402 null;
2418 break :blk OpAndToken{
2419 .op = Op{
2420 .Slice = Op.Slice{
2403 break :blk .{
2404 .op = .{
2405 .Slice = .{
24212406 .start = index_expr,
24222407 .end = end_expr,
24232408 .sentinel = sentinel,
......@@ -2427,14 +2412,14 @@ fn parseSuffixOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
24272412 };
24282413 }
24292414
2430 break :blk OpAndToken{
2431 .op = Op{ .ArrayAccess = index_expr },
2415 break :blk .{
2416 .op = .{ .ArrayAccess = index_expr },
24322417 .token = try expectToken(it, tree, .RBracket),
24332418 };
24342419 }
24352420
24362421 if (eatToken(it, .PeriodAsterisk)) |period_asterisk| {
2437 break :blk OpAndToken{ .op = Op{ .Deref = {} }, .token = period_asterisk };
2422 break :blk .{ .op = .Deref, .token = period_asterisk };
24382423 }
24392424
24402425 if (eatToken(it, .Period)) |period| {
......@@ -2443,19 +2428,19 @@ fn parseSuffixOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
24432428 // Should there be an ast.Node.SuffixOp.FieldAccess variant? Or should
24442429 // this grammar rule be altered?
24452430 const node = try arena.create(Node.InfixOp);
2446 node.* = Node.InfixOp{
2431 node.* = .{
24472432 .op_token = period,
24482433 .lhs = undefined, // set by caller
2449 .op = Node.InfixOp.Op.Period,
2434 .op = .Period,
24502435 .rhs = identifier,
24512436 };
24522437 return &node.base;
24532438 }
24542439 if (eatToken(it, .QuestionMark)) |question_mark| {
2455 break :blk OpAndToken{ .op = Op{ .UnwrapOptional = {} }, .token = question_mark };
2440 break :blk .{ .op = .UnwrapOptional, .token = question_mark };
24562441 }
2457 try tree.errors.push(AstError{
2458 .ExpectedSuffixOp = AstError.ExpectedSuffixOp{ .token = it.index },
2442 try tree.errors.push(.{
2443 .ExpectedSuffixOp = .{ .token = it.index },
24592444 });
24602445 return null;
24612446 }
......@@ -2464,7 +2449,7 @@ fn parseSuffixOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
24642449 };
24652450
24662451 const node = try arena.create(Node.SuffixOp);
2467 node.* = Node.SuffixOp{
2452 node.* = .{
24682453 .lhs = undefined, // set by caller
24692454 .op = op_and_token.op,
24702455 .rtoken = op_and_token.token,
......@@ -2491,22 +2476,22 @@ fn parseArrayTypeStart(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*No
24912476 const lbracket = eatToken(it, .LBracket) orelse return null;
24922477 const expr = try parseExpr(arena, it, tree);
24932478 const sentinel = if (eatToken(it, .Colon)) |_|
2494 try expectNode(arena, it, tree, parseExpr, AstError{
2479 try expectNode(arena, it, tree, parseExpr, .{
24952480 .ExpectedExpr = .{ .token = it.index },
24962481 })
24972482 else
24982483 null;
24992484 const rbracket = try expectToken(it, tree, .RBracket);
25002485
2501 const op = if (expr) |len_expr|
2502 Node.PrefixOp.Op{
2486 const op: Node.PrefixOp.Op = if (expr) |len_expr|
2487 .{
25032488 .ArrayType = .{
25042489 .len_expr = len_expr,
25052490 .sentinel = sentinel,
25062491 },
25072492 }
25082493 else
2509 Node.PrefixOp.Op{
2494 .{
25102495 .SliceType = Node.PrefixOp.PtrInfo{
25112496 .allowzero_token = null,
25122497 .align_info = null,
......@@ -2517,7 +2502,7 @@ fn parseArrayTypeStart(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*No
25172502 };
25182503
25192504 const node = try arena.create(Node.PrefixOp);
2520 node.* = Node.PrefixOp{
2505 node.* = .{
25212506 .op_token = lbracket,
25222507 .op = op,
25232508 .rhs = undefined, // set by caller
......@@ -2533,7 +2518,7 @@ fn parseArrayTypeStart(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*No
25332518fn parsePtrTypeStart(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
25342519 if (eatToken(it, .Asterisk)) |asterisk| {
25352520 const sentinel = if (eatToken(it, .Colon)) |_|
2536 try expectNode(arena, it, tree, parseExpr, AstError{
2521 try expectNode(arena, it, tree, parseExpr, .{
25372522 .ExpectedExpr = .{ .token = it.index },
25382523 })
25392524 else
......@@ -2549,17 +2534,17 @@ fn parsePtrTypeStart(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
25492534
25502535 if (eatToken(it, .AsteriskAsterisk)) |double_asterisk| {
25512536 const node = try arena.create(Node.PrefixOp);
2552 node.* = Node.PrefixOp{
2537 node.* = .{
25532538 .op_token = double_asterisk,
2554 .op = Node.PrefixOp.Op{ .PtrType = .{} },
2539 .op = .{ .PtrType = .{} },
25552540 .rhs = undefined, // set by caller
25562541 };
25572542
25582543 // Special case for **, which is its own token
25592544 const child = try arena.create(Node.PrefixOp);
2560 child.* = Node.PrefixOp{
2545 child.* = .{
25612546 .op_token = double_asterisk,
2562 .op = Node.PrefixOp.Op{ .PtrType = .{} },
2547 .op = .{ .PtrType = .{} },
25632548 .rhs = undefined, // set by caller
25642549 };
25652550 node.rhs = &child.base;
......@@ -2586,7 +2571,7 @@ fn parsePtrTypeStart(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
25862571 }
25872572 }
25882573 const sentinel = if (eatToken(it, .Colon)) |_|
2589 try expectNode(arena, it, tree, parseExpr, AstError{
2574 try expectNode(arena, it, tree, parseExpr, .{
25902575 .ExpectedExpr = .{ .token = it.index },
25912576 })
25922577 else
......@@ -2629,8 +2614,8 @@ fn parseContainerDeclType(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?
26292614 .Keyword_struct => Node.ContainerDecl.InitArg{ .None = {} },
26302615 .Keyword_enum => blk: {
26312616 if (eatToken(it, .LParen) != null) {
2632 const expr = try expectNode(arena, it, tree, parseExpr, AstError{
2633 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
2617 const expr = try expectNode(arena, it, tree, parseExpr, .{
2618 .ExpectedExpr = .{ .token = it.index },
26342619 });
26352620 _ = try expectToken(it, tree, .RParen);
26362621 break :blk Node.ContainerDecl.InitArg{ .Type = expr };
......@@ -2641,8 +2626,8 @@ fn parseContainerDeclType(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?
26412626 if (eatToken(it, .LParen) != null) {
26422627 if (eatToken(it, .Keyword_enum) != null) {
26432628 if (eatToken(it, .LParen) != null) {
2644 const expr = try expectNode(arena, it, tree, parseExpr, AstError{
2645 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
2629 const expr = try expectNode(arena, it, tree, parseExpr, .{
2630 .ExpectedExpr = .{ .token = it.index },
26462631 });
26472632 _ = try expectToken(it, tree, .RParen);
26482633 _ = try expectToken(it, tree, .RParen);
......@@ -2651,8 +2636,8 @@ fn parseContainerDeclType(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?
26512636 _ = try expectToken(it, tree, .RParen);
26522637 break :blk Node.ContainerDecl.InitArg{ .Enum = null };
26532638 }
2654 const expr = try expectNode(arena, it, tree, parseExpr, AstError{
2655 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
2639 const expr = try expectNode(arena, it, tree, parseExpr, .{
2640 .ExpectedExpr = .{ .token = it.index },
26562641 });
26572642 _ = try expectToken(it, tree, .RParen);
26582643 break :blk Node.ContainerDecl.InitArg{ .Type = expr };
......@@ -2666,7 +2651,7 @@ fn parseContainerDeclType(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?
26662651 };
26672652
26682653 const node = try arena.create(Node.ContainerDecl);
2669 node.* = Node.ContainerDecl{
2654 node.* = .{
26702655 .layout_token = null,
26712656 .kind_token = kind_token.index,
26722657 .init_arg_expr = init_arg_expr,
......@@ -2681,8 +2666,8 @@ fn parseContainerDeclType(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?
26812666fn parseByteAlign(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
26822667 _ = eatToken(it, .Keyword_align) orelse return null;
26832668 _ = try expectToken(it, tree, .LParen);
2684 const expr = try expectNode(arena, it, tree, parseExpr, AstError{
2685 .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
2669 const expr = try expectNode(arena, it, tree, parseExpr, .{
2670 .ExpectedExpr = .{ .token = it.index },
26862671 });
26872672 _ = try expectToken(it, tree, .RParen);
26882673 return expr;
......@@ -2738,7 +2723,7 @@ fn SimpleBinOpParseFn(comptime token: Token.Id, comptime op: Node.InfixOp.Op) No
27382723 pub fn parse(arena: *Allocator, it: *TokenIterator, tree: *Tree) Error!?*Node {
27392724 const op_token = eatToken(it, token) orelse return null;
27402725 const node = try arena.create(Node.InfixOp);
2741 node.* = Node.InfixOp{
2726 node.* = .{
27422727 .op_token = op_token,
27432728 .lhs = undefined, // set by caller
27442729 .op = op,
......@@ -2754,13 +2739,13 @@ fn SimpleBinOpParseFn(comptime token: Token.Id, comptime op: Node.InfixOp.Op) No
27542739fn parseBuiltinCall(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
27552740 const token = eatToken(it, .Builtin) orelse return null;
27562741 const params = (try parseFnCallArguments(arena, it, tree)) orelse {
2757 try tree.errors.push(AstError{
2758 .ExpectedParamList = AstError.ExpectedParamList{ .token = it.index },
2742 try tree.errors.push(.{
2743 .ExpectedParamList = .{ .token = it.index },
27592744 });
27602745 return error.ParseError;
27612746 };
27622747 const node = try arena.create(Node.BuiltinCall);
2763 node.* = Node.BuiltinCall{
2748 node.* = .{
27642749 .builtin_token = token,
27652750 .params = params.list,
27662751 .rparen_token = params.rparen,
......@@ -2773,7 +2758,7 @@ fn parseErrorTag(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
27732758 const token = eatToken(it, .Identifier) orelse return null;
27742759
27752760 const node = try arena.create(Node.ErrorTag);
2776 node.* = Node.ErrorTag{
2761 node.* = .{
27772762 .doc_comments = doc_comments,
27782763 .name_token = token,
27792764 };
......@@ -2783,7 +2768,7 @@ fn parseErrorTag(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
27832768fn parseIdentifier(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
27842769 const token = eatToken(it, .Identifier) orelse return null;
27852770 const node = try arena.create(Node.Identifier);
2786 node.* = Node.Identifier{
2771 node.* = .{
27872772 .token = token,
27882773 };
27892774 return &node.base;
......@@ -2792,7 +2777,7 @@ fn parseIdentifier(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
27922777fn parseVarType(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
27932778 const token = eatToken(it, .Keyword_var) orelse return null;
27942779 const node = try arena.create(Node.VarType);
2795 node.* = Node.VarType{
2780 node.* = .{
27962781 .token = token,
27972782 };
27982783 return &node.base;
......@@ -2810,7 +2795,7 @@ fn createLiteral(arena: *Allocator, comptime T: type, token: TokenIndex) !*Node
28102795fn parseStringLiteralSingle(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
28112796 if (eatToken(it, .StringLiteral)) |token| {
28122797 const node = try arena.create(Node.StringLiteral);
2813 node.* = Node.StringLiteral{
2798 node.* = .{
28142799 .token = token,
28152800 };
28162801 return &node.base;
......@@ -2824,7 +2809,7 @@ fn parseStringLiteral(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Nod
28242809
28252810 if (eatToken(it, .MultilineStringLiteralLine)) |first_line| {
28262811 const node = try arena.create(Node.MultilineStringLiteral);
2827 node.* = Node.MultilineStringLiteral{
2812 node.* = .{
28282813 .lines = Node.MultilineStringLiteral.LineList.init(arena),
28292814 };
28302815 try node.lines.push(first_line);
......@@ -2840,7 +2825,7 @@ fn parseStringLiteral(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Nod
28402825fn parseIntegerLiteral(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
28412826 const token = eatToken(it, .IntegerLiteral) orelse return null;
28422827 const node = try arena.create(Node.IntegerLiteral);
2843 node.* = Node.IntegerLiteral{
2828 node.* = .{
28442829 .token = token,
28452830 };
28462831 return &node.base;
......@@ -2849,7 +2834,7 @@ fn parseIntegerLiteral(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*No
28492834fn parseFloatLiteral(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
28502835 const token = eatToken(it, .FloatLiteral) orelse return null;
28512836 const node = try arena.create(Node.FloatLiteral);
2852 node.* = Node.FloatLiteral{
2837 node.* = .{
28532838 .token = token,
28542839 };
28552840 return &node.base;
......@@ -2858,9 +2843,9 @@ fn parseFloatLiteral(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
28582843fn parseTry(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
28592844 const token = eatToken(it, .Keyword_try) orelse return null;
28602845 const node = try arena.create(Node.PrefixOp);
2861 node.* = Node.PrefixOp{
2846 node.* = .{
28622847 .op_token = token,
2863 .op = Node.PrefixOp.Op.Try,
2848 .op = .Try,
28642849 .rhs = undefined, // set by caller
28652850 };
28662851 return &node.base;
......@@ -2869,7 +2854,7 @@ fn parseTry(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
28692854fn parseUse(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
28702855 const token = eatToken(it, .Keyword_usingnamespace) orelse return null;
28712856 const node = try arena.create(Node.Use);
2872 node.* = Node.Use{
2857 node.* = .{
28732858 .doc_comments = null,
28742859 .visib_token = null,
28752860 .use_token = token,
......@@ -2884,17 +2869,17 @@ fn parseIf(arena: *Allocator, it: *TokenIterator, tree: *Tree, bodyParseFn: Node
28842869 const node = (try parseIfPrefix(arena, it, tree)) orelse return null;
28852870 const if_prefix = node.cast(Node.If).?;
28862871
2887 if_prefix.body = try expectNode(arena, it, tree, bodyParseFn, AstError{
2888 .InvalidToken = AstError.InvalidToken{ .token = it.index },
2872 if_prefix.body = try expectNode(arena, it, tree, bodyParseFn, .{
2873 .InvalidToken = .{ .token = it.index },
28892874 });
28902875
28912876 const else_token = eatToken(it, .Keyword_else) orelse return node;
28922877 const payload = try parsePayload(arena, it, tree);
2893 const else_expr = try expectNode(arena, it, tree, bodyParseFn, AstError{
2894 .InvalidToken = AstError.InvalidToken{ .token = it.index },
2878 const else_expr = try expectNode(arena, it, tree, bodyParseFn, .{
2879 .InvalidToken = .{ .token = it.index },
28952880 });
28962881 const else_node = try arena.create(Node.Else);
2897 else_node.* = Node.Else{
2882 else_node.* = .{
28982883 .else_token = else_token,
28992884 .payload = payload,
29002885 .body = else_expr,
......@@ -2914,7 +2899,7 @@ fn parseDocComment(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node.D
29142899 if (lines.len == 0) return null;
29152900
29162901 const node = try arena.create(Node.DocComment);
2917 node.* = Node.DocComment{
2902 node.* = .{
29182903 .lines = lines,
29192904 };
29202905 return node;
......@@ -2925,7 +2910,7 @@ fn parseAppendedDocComment(arena: *Allocator, it: *TokenIterator, tree: *Tree, a
29252910 const comment_token = eatToken(it, .DocComment) orelse return null;
29262911 if (tree.tokensOnSameLine(after_token, comment_token)) {
29272912 const node = try arena.create(Node.DocComment);
2928 node.* = Node.DocComment{
2913 node.* = .{
29292914 .lines = Node.DocComment.LineList.init(arena),
29302915 };
29312916 try node.lines.push(comment_token);
......@@ -2974,14 +2959,14 @@ fn parsePrefixOpExpr(
29742959 switch (rightmost_op.id) {
29752960 .PrefixOp => {
29762961 const prefix_op = rightmost_op.cast(Node.PrefixOp).?;
2977 prefix_op.rhs = try expectNode(arena, it, tree, childParseFn, AstError{
2978 .InvalidToken = AstError.InvalidToken{ .token = it.index },
2962 prefix_op.rhs = try expectNode(arena, it, tree, childParseFn, .{
2963 .InvalidToken = .{ .token = it.index },
29792964 });
29802965 },
29812966 .AnyFrameType => {
29822967 const prom = rightmost_op.cast(Node.AnyFrameType).?;
2983 prom.result.?.return_type = try expectNode(arena, it, tree, childParseFn, AstError{
2984 .InvalidToken = AstError.InvalidToken{ .token = it.index },
2968 prom.result.?.return_type = try expectNode(arena, it, tree, childParseFn, .{
2969 .InvalidToken = .{ .token = it.index },
29852970 });
29862971 },
29872972 else => unreachable,
......@@ -3010,8 +2995,8 @@ fn parseBinOpExpr(
30102995 var res = (try childParseFn(arena, it, tree)) orelse return null;
30112996
30122997 while (try opParseFn(arena, it, tree)) |node| {
3013 const right = try expectNode(arena, it, tree, childParseFn, AstError{
3014 .InvalidToken = AstError.InvalidToken{ .token = it.index },
2998 const right = try expectNode(arena, it, tree, childParseFn, .{
2999 .InvalidToken = .{ .token = it.index },
30153000 });
30163001 const left = res;
30173002 res = node;
......@@ -3031,7 +3016,7 @@ fn parseBinOpExpr(
30313016
30323017fn createInfixOp(arena: *Allocator, index: TokenIndex, op: Node.InfixOp.Op) !*Node {
30333018 const node = try arena.create(Node.InfixOp);
3034 node.* = Node.InfixOp{
3019 node.* = .{
30353020 .op_token = index,
30363021 .lhs = undefined, // set by caller
30373022 .op = op,
......@@ -3051,8 +3036,8 @@ fn eatAnnotatedToken(it: *TokenIterator, id: Token.Id) ?AnnotatedToken {
30513036fn expectToken(it: *TokenIterator, tree: *Tree, id: Token.Id) Error!TokenIndex {
30523037 const token = nextToken(it);
30533038 if (token.ptr.id != id) {
3054 try tree.errors.push(AstError{
3055 .ExpectedToken = AstError.ExpectedToken{ .token = token.index, .expected_id = id },
3039 try tree.errors.push(.{
3040 .ExpectedToken = .{ .token = token.index, .expected_id = id },
30563041 });
30573042 return error.ParseError;
30583043 }
lib/std/zig/render.zig-1
......@@ -583,7 +583,6 @@ fn renderExpression(
583583 },
584584
585585 .Try,
586 .Cancel,
587586 .Resume,
588587 => {
589588 try renderToken(tree, stream, prefix_op_node.op_token, indent, start_col, Space.Space);