Commit 93384f7428c5186a1b44c6f5f8891ce40bc46e72 | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-05-19 21:11:30-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-05-19 21:22:52-04:00
log	93384f7428c5186a1b44c6f5f8891ce40bc46e72
tree	2baa7d2fcfc0ba0b088d45ccdb01543d480f42ff
parent	ed137d25ef0fb94f2ea0db4f993a0adfcaf63b58

use singly linked lists for std.zig.parse

std.ast uses a singly linked list for lists of things. This is a
breaking change to the self-hosted parser API.

std.ast.Tree has been separated into a private "Parser" type which
represents in-progress parsing, and std.ast.Tree which has only
"output" data. This means cleaner, but breaking, API for parse results.
Specifically, `tokens` and `errors` are no longer SegmentedList but a
slice.

The way to iterate over AST nodes has necessarily changed since lists of
nodes are now singly linked lists rather than SegmentedList.

From these changes, I observe the following on the
self-hosted-parser benchmark from ziglang/gotta-go-fast:

throughput: 45.6 MiB/s => 55.6 MiB/s
maxrss: 359 KB => 342 KB

This commit breaks the build; more updates are necessary to fix API
usage of the self-hosted parser.

5 files changed, 3386 insertions(+), 3108 deletions(-)

lib
- std
  - linked_list.zig
  - zig
    ast.zig
    parse.zig
    parser_test.zig
    render.zig

lib/std/linked_list.zig+2-53

...	...	@@ -21,6 +21,8 @@ pub fn SinglyLinkedList(comptime T: type) type {
21	21	next: ?*Node = null,
22	22	data: T,
23	23
	24	pub const Data = T;
	25
24	26	pub fn init(data: T) Node {
25	27	return Node{
26	28	.data = data,
...	...	@@ -51,25 +53,6 @@ pub fn SinglyLinkedList(comptime T: type) type {
51	53
52	54	first: ?*Node = null,
53	55
54		/// Initialize a linked list.
55		///
56		/// Returns:
57		/// An empty linked list.
58		pub fn init() Self {
59		return Self{
60		.first = null,
61		};
62		}
63
64		/// Insert a new node after an existing one.
65		///
66		/// Arguments:
67		/// node: Pointer to a node in the list.
68		/// new_node: Pointer to the new node to insert.
69		pub fn insertAfter(list: Self, node: Node, new_node: *Node) void {
70		node.insertAfter(new_node);
71		}
72
73	56	/// Insert a new node at the head.
74	57	///
75	58	/// Arguments:
...	...	@@ -104,40 +87,6 @@ pub fn SinglyLinkedList(comptime T: type) type {
104	87	list.first = first.next;
105	88	return first;
106	89	}
107
108		/// Allocate a new node.
109		///
110		/// Arguments:
111		/// allocator: Dynamic memory allocator.
112		///
113		/// Returns:
114		/// A pointer to the new node.
115		pub fn allocateNode(list: Self, allocator: Allocator) !*Node {
116		return allocator.create(Node);
117		}
118
119		/// Deallocate a node.
120		///
121		/// Arguments:
122		/// node: Pointer to the node to deallocate.
123		/// allocator: Dynamic memory allocator.
124		pub fn destroyNode(list: Self, node: Node, allocator: *Allocator) void {
125		allocator.destroy(node);
126		}
127
128		/// Allocate and initialize a node and its data.
129		///
130		/// Arguments:
131		/// data: The data to put inside the node.
132		/// allocator: Dynamic memory allocator.
133		///
134		/// Returns:
135		/// A pointer to the new node.
136		pub fn createNode(list: Self, data: T, allocator: Allocator) !*Node {
137		var node = try list.allocateNode(allocator);
138		node.* = Node.init(data);
139		return node;
140		}
141	90	};
142	91	}
143	92

lib/std/zig/ast.zig+467-178

...	...	@@ -1,42 +1,39 @@
1	1	const std = @import("../std.zig");
2	2	const assert = std.debug.assert;
3	3	const testing = std.testing;
4		const SegmentedList = std.SegmentedList;
	4	const LinkedList = std.SinglyLinkedList;
5	5	const mem = std.mem;
6	6	const Token = std.zig.Token;
7	7
8	8	pub const TokenIndex = usize;
9	9
10	10	pub const Tree = struct {
	11	/// Reference to externally-owned data.
11	12	source: []const u8,
12		tokens: TokenList,
13
14		/// undefined on parse error (errors not empty)
	13	tokens: []const Token,
	14	errors: []const Error,
	15	/// undefined on parse error (when errors field is not empty)
15	16	root_node: *Node.Root,
16		arena_allocator: std.heap.ArenaAllocator,
17		errors: ErrorList,
	17
	18	arena: std.heap.ArenaAllocator.State,
	19	gpa: *mem.Allocator,
18	20
19	21	/// translate-c uses this to avoid having to emit correct newlines
20	22	/// TODO get rid of this hack
21	23	generated: bool = false,
22	24
23		pub const TokenList = SegmentedList(Token, 64);
24		pub const ErrorList = SegmentedList(Error, 0);
25
26	25	pub fn deinit(self: *Tree) void {
27		// Here we copy the arena allocator into stack memory, because
28		// otherwise it would destroy itself while it was still working.
29		var arena_allocator = self.arena_allocator;
30		arena_allocator.deinit();
31		// self is destroyed
	26	self.gpa.free(self.tokens);
	27	self.gpa.free(self.errors);
	28	self.arena.promote(self.gpa).deinit();
32	29	}
33	30
34		pub fn renderError(self: Tree, parse_error: Error, stream: var) !void {
35		return parse_error.render(&self.tokens, stream);
	31	pub fn renderError(self: Tree, parse_error: const Error, stream: var) !void {
	32	return parse_error.render(self.tokens, stream);
36	33	}
37	34
38	35	pub fn tokenSlice(self: *Tree, token_index: TokenIndex) []const u8 {
39		return self.tokenSlicePtr(self.tokens.at(token_index));
	36	return self.tokenSlicePtr(self.tokens[token_index]);
40	37	}
41	38
42	39	pub fn tokenSlicePtr(self: Tree, token: const Token) []const u8 {
...	...	@@ -44,8 +41,8 @@ pub const Tree = struct {
44	41	}
45	42
46	43	pub fn getNodeSource(self: const Tree, node: const Node) []const u8 {
47		const first_token = self.tokens.at(node.firstToken());
48		const last_token = self.tokens.at(node.lastToken());
	44	const first_token = self.tokens[node.firstToken()];
	45	const last_token = self.tokens[node.lastToken()];
49	46	return self.source[first_token.start..last_token.end];
50	47	}
51	48
...	...	@@ -57,7 +54,7 @@ pub const Tree = struct {
57	54	};
58	55
59	56	/// Return the Location of the token relative to the offset specified by `start_index`.
60		pub fn tokenLocationPtr(self: Tree, start_index: usize, token: const Token) Location {
	57	pub fn tokenLocationPtr(self: *Tree, start_index: usize, token: Token) Location {
61	58	var loc = Location{
62	59	.line = 0,
63	60	.column = 0,
...	...	@@ -85,11 +82,11 @@ pub const Tree = struct {
85	82	}
86	83
87	84	pub fn tokenLocation(self: *Tree, start_index: usize, token_index: TokenIndex) Location {
88		return self.tokenLocationPtr(start_index, self.tokens.at(token_index));
	85	return self.tokenLocationPtr(start_index, self.tokens[token_index]);
89	86	}
90	87
91	88	pub fn tokensOnSameLine(self: *Tree, token1_index: TokenIndex, token2_index: TokenIndex) bool {
92		return self.tokensOnSameLinePtr(self.tokens.at(token1_index), self.tokens.at(token2_index));
	89	return self.tokensOnSameLinePtr(self.tokens[token1_index], self.tokens[token2_index]);
93	90	}
94	91
95	92	pub fn tokensOnSameLinePtr(self: Tree, token1: const Token, token2: *const Token) bool {
...	...	@@ -103,7 +100,7 @@ pub const Tree = struct {
103	100	/// Skips over comments
104	101	pub fn prevToken(self: *Tree, token_index: TokenIndex) TokenIndex {
105	102	var index = token_index - 1;
106		while (self.tokens.at(index).id == Token.Id.LineComment) {
	103	while (self.tokens[index].id == Token.Id.LineComment) {
107	104	index -= 1;
108	105	}
109	106	return index;
...	...	@@ -112,7 +109,7 @@ pub const Tree = struct {
112	109	/// Skips over comments
113	110	pub fn nextToken(self: *Tree, token_index: TokenIndex) TokenIndex {
114	111	var index = token_index + 1;
115		while (self.tokens.at(index).id == Token.Id.LineComment) {
	112	while (self.tokens[index].id == Token.Id.LineComment) {
116	113	index += 1;
117	114	}
118	115	return index;
...	...	@@ -169,7 +166,7 @@ pub const Error = union(enum) {
169	166	DeclBetweenFields: DeclBetweenFields,
170	167	InvalidAnd: InvalidAnd,
171	168
172		pub fn render(self: const Error, tokens: Tree.TokenList, stream: var) !void {
	169	pub fn render(self: *const Error, tokens: []const Token, stream: var) !void {
173	170	switch (self.*) {
174	171	.InvalidToken => \|*x\| return x.render(tokens, stream),
175	172	.ExpectedContainerMembers => \|*x\| return x.render(tokens, stream),
...	...	@@ -324,7 +321,7 @@ pub const Error = union(enum) {
324	321	pub const ExpectedCall = struct {
325	322	node: *Node,
326	323
327		pub fn render(self: const ExpectedCall, tokens: Tree.TokenList, stream: var) !void {
	324	pub fn render(self: *const ExpectedCall, tokens: []const Token, stream: var) !void {
328	325	return stream.print("expected " ++ @tagName(@TagType(Node.SuffixOp.Op).Call) ++ ", found {}", .{
329	326	@tagName(self.node.id),
330	327	});
...	...	@@ -334,7 +331,7 @@ pub const Error = union(enum) {
334	331	pub const ExpectedCallOrFnProto = struct {
335	332	node: *Node,
336	333
337		pub fn render(self: const ExpectedCallOrFnProto, tokens: Tree.TokenList, stream: var) !void {
	334	pub fn render(self: *const ExpectedCallOrFnProto, tokens: []const Token, stream: var) !void {
338	335	return stream.print("expected " ++ @tagName(@TagType(Node.SuffixOp.Op).Call) ++ " or " ++
339	336	@tagName(Node.Id.FnProto) ++ ", found {}", .{@tagName(self.node.id)});
340	337	}
...	...	@@ -344,8 +341,8 @@ pub const Error = union(enum) {
344	341	token: TokenIndex,
345	342	expected_id: Token.Id,
346	343
347		pub fn render(self: const ExpectedToken, tokens: Tree.TokenList, stream: var) !void {
348		const found_token = tokens.at(self.token);
	344	pub fn render(self: *const ExpectedToken, tokens: []const Token, stream: var) !void {
	345	const found_token = tokens[self.token];
349	346	switch (found_token.id) {
350	347	.Invalid => {
351	348	return stream.print("expected '{}', found invalid bytes", .{self.expected_id.symbol()});
...	...	@@ -362,8 +359,8 @@ pub const Error = union(enum) {
362	359	token: TokenIndex,
363	360	end_id: Token.Id,
364	361
365		pub fn render(self: const ExpectedCommaOrEnd, tokens: Tree.TokenList, stream: var) !void {
366		const actual_token = tokens.at(self.token);
	362	pub fn render(self: *const ExpectedCommaOrEnd, tokens: []const Token, stream: var) !void {
	363	const actual_token = tokens[self.token];
367	364	return stream.print("expected ',' or '{}', found '{}'", .{
368	365	self.end_id.symbol(),
369	366	actual_token.id.symbol(),
...	...	@@ -377,8 +374,8 @@ pub const Error = union(enum) {
377	374
378	375	token: TokenIndex,
379	376
380		pub fn render(self: const ThisError, tokens: Tree.TokenList, stream: var) !void {
381		const actual_token = tokens.at(self.token);
	377	pub fn render(self: *const ThisError, tokens: []const Token, stream: var) !void {
	378	const actual_token = tokens[self.token];
382	379	return stream.print(msg, .{actual_token.id.symbol()});
383	380	}
384	381	};
...	...	@@ -390,7 +387,7 @@ pub const Error = union(enum) {
390	387
391	388	token: TokenIndex,
392	389
393		pub fn render(self: const ThisError, tokens: Tree.TokenList, stream: var) !void {
	390	pub fn render(self: *const ThisError, tokens: []const Token, stream: var) !void {
394	391	return stream.writeAll(msg);
395	392	}
396	393	};
...	...	@@ -400,6 +397,23 @@ pub const Error = union(enum) {
400	397	pub const Node = struct {
401	398	id: Id,
402	399
	400	/// All the child Node types use this same Iterator state for their iteration.
	401	pub const Iterator = struct {
	402	parent_node: *const Node,
	403	node: ?LinkedList(Node).Node,
	404	index: usize,
	405
	406	pub fn next(it: Iterator) ?Node {
	407	inline for (@typeInfo(Id).Enum.fields) \|f\| {
	408	if (it.parent_node.id == @field(Id, f.name)) {
	409	const T = @field(Node, f.name);
	410	return @fieldParentPtr(T, "base", it.parent_node).iterateNext(it);
	411	}
	412	}
	413	unreachable;
	414	}
	415	};
	416
403	417	pub const Id = enum {
404	418	// Top level
405	419	Root,
...	...	@@ -473,11 +487,11 @@ pub const Node = struct {
473	487	return null;
474	488	}
475	489
476		pub fn iterate(base: Node, index: usize) ?Node {
	490	pub fn iterate(base: *Node) Iterator {
477	491	inline for (@typeInfo(Id).Enum.fields) \|f\| {
478	492	if (base.id == @field(Id, f.name)) {
479	493	const T = @field(Node, f.name);
480		return @fieldParentPtr(T, "base", base).iterate(index);
	494	return @fieldParentPtr(T, "base", base).iterate();
481	495	}
482	496	}
483	497	unreachable;
...	...	@@ -607,21 +621,35 @@ pub const Node = struct {
607	621	decls: DeclList,
608	622	eof_token: TokenIndex,
609	623
610		pub const DeclList = SegmentedList(*Node, 4);
	624	pub const DeclList = LinkedList(*Node);
611	625
612		pub fn iterate(self: Root, index: usize) ?Node {
613		if (index < self.decls.len) {
614		return self.decls.at(index).*;
615		}
616		return null;
	626	pub fn iterate(self: *const Root) Node.Iterator {
	627	return .{ .parent_node = &self.base, .index = 0, .node = self.decls.first };
	628	}
	629
	630	pub fn iterateNext(self: const Root, it: Node.Iterator) ?*Node {
	631	const decl = it.node orelse return null;
	632	it.node = decl.next;
	633	return decl.data;
617	634	}
618	635
619	636	pub fn firstToken(self: *const Root) TokenIndex {
620		return if (self.decls.len == 0) self.eof_token else (self.decls.at(0).*).firstToken();
	637	if (self.decls.first) \|first\| {
	638	return first.data.firstToken();
	639	} else {
	640	return self.eof_token;
	641	}
621	642	}
622	643
623	644	pub fn lastToken(self: *const Root) TokenIndex {
624		return if (self.decls.len == 0) self.eof_token else (self.decls.at(self.decls.len - 1).*).lastToken();
	645	if (self.decls.first) \|first\| {
	646	var node = first;
	647	while (true) {
	648	node = node.next orelse return node.data.lastToken();
	649	}
	650	} else {
	651	return self.eof_token;
	652	}
625	653	}
626	654	};
627	655
...	...	@@ -642,8 +670,13 @@ pub const Node = struct {
642	670	init_node: ?*Node,
643	671	semicolon_token: TokenIndex,
644	672
645		pub fn iterate(self: VarDecl, index: usize) ?Node {
646		var i = index;
	673	pub fn iterate(self: *const VarDecl) Node.Iterator {
	674	return .{ .parent_node = &self.base, .index = 0, .node = null };
	675	}
	676
	677	pub fn iterateNext(self: const VarDecl, it: Node.Iterator) ?*Node {
	678	var i = it.index;
	679	it.index += 1;
647	680
648	681	if (self.type_node) \|type_node\| {
649	682	if (i < 1) return type_node;
...	...	@@ -668,6 +701,7 @@ pub const Node = struct {
668	701	return null;
669	702	}
670	703
	704
671	705	pub fn firstToken(self: *const VarDecl) TokenIndex {
672	706	if (self.visib_token) \|visib_token\| return visib_token;
673	707	if (self.thread_local_token) \|thread_local_token\| return thread_local_token;
...	...	@@ -690,8 +724,13 @@ pub const Node = struct {
690	724	expr: *Node,
691	725	semicolon_token: TokenIndex,
692	726
693		pub fn iterate(self: Use, index: usize) ?Node {
694		var i = index;
	727	pub fn iterate(self: *const Use) Node.Iterator {
	728	return .{ .parent_node = &self.base, .index = 0, .node = null };
	729	}
	730
	731	pub fn iterateNext(self: const Use, it: Node.Iterator) ?*Node {
	732	var i = it.index;
	733	it.index += 1;
695	734
696	735	if (i < 1) return self.expr;
697	736	i -= 1;
...	...	@@ -715,15 +754,16 @@ pub const Node = struct {
715	754	decls: DeclList,
716	755	rbrace_token: TokenIndex,
717	756
718		pub const DeclList = SegmentedList(*Node, 2);
	757	pub const DeclList = LinkedList(*Node);
719	758
720		pub fn iterate(self: ErrorSetDecl, index: usize) ?Node {
721		var i = index;
722
723		if (i < self.decls.len) return self.decls.at(i).*;
724		i -= self.decls.len;
	759	pub fn iterate(self: *const ErrorSetDecl) Node.Iterator {
	760	return .{ .parent_node = &self.base, .index = 0, .node = self.decls.first };
	761	}
725	762
726		return null;
	763	pub fn iterateNext(self: const ErrorSetDecl, it: Node.Iterator) ?*Node {
	764	const decl = it.node orelse return null;
	765	it.node = decl.next;
	766	return decl.data;
727	767	}
728	768
729	769	pub fn firstToken(self: *const ErrorSetDecl) TokenIndex {
...	...	@@ -752,8 +792,13 @@ pub const Node = struct {
752	792	Type: *Node,
753	793	};
754	794
755		pub fn iterate(self: ContainerDecl, index: usize) ?Node {
756		var i = index;
	795	pub fn iterate(self: *const ContainerDecl) Node.Iterator {
	796	return .{ .parent_node = &self.base, .index = 0, .node = self.fields_and_decls.first };
	797	}
	798
	799	pub fn iterateNext(self: const ContainerDecl, it: Node.Iterator) ?*Node {
	800	var i = it.index;
	801	it.index += 1;
757	802
758	803	switch (self.init_arg_expr) {
759	804	.Type => \|t\| {
...	...	@@ -763,8 +808,10 @@ pub const Node = struct {
763	808	.None, .Enum => {},
764	809	}
765	810
766		if (i < self.fields_and_decls.len) return self.fields_and_decls.at(i).*;
767		i -= self.fields_and_decls.len;
	811	if (it.node) \|child\| {
	812	it.node = child.next;
	813	return child.data;
	814	}
768	815
769	816	return null;
770	817	}
...	...	@@ -790,8 +837,13 @@ pub const Node = struct {
790	837	value_expr: ?*Node,
791	838	align_expr: ?*Node,
792	839
793		pub fn iterate(self: ContainerField, index: usize) ?Node {
794		var i = index;
	840	pub fn iterate(self: *const ContainerField) Node.Iterator {
	841	return .{ .parent_node = &self.base, .index = 0, .node = null };
	842	}
	843
	844	pub fn iterateNext(self: const ContainerField, it: Node.Iterator) ?*Node {
	845	var i = it.index;
	846	it.index += 1;
795	847
796	848	if (self.type_expr) \|type_expr\| {
797	849	if (i < 1) return type_expr;
...	...	@@ -837,8 +889,13 @@ pub const Node = struct {
837	889	doc_comments: ?*DocComment,
838	890	name_token: TokenIndex,
839	891
840		pub fn iterate(self: ErrorTag, index: usize) ?Node {
841		var i = index;
	892	pub fn iterate(self: *const ErrorTag) Node.Iterator {
	893	return .{ .parent_node = &self.base, .index = 0, .node = null };
	894	}
	895
	896	pub fn iterateNext(self: const ErrorTag, it: Node.Iterator) ?*Node {
	897	var i = it.index;
	898	it.index += 1;
842	899
843	900	if (self.doc_comments) \|comments\| {
844	901	if (i < 1) return &comments.base;
...	...	@@ -861,7 +918,11 @@ pub const Node = struct {
861	918	base: Node = Node{ .id = .Identifier },
862	919	token: TokenIndex,
863	920
864		pub fn iterate(self: Identifier, index: usize) ?Node {
	921	pub fn iterate(self: *const Identifier) Node.Iterator {
	922	return .{ .parent_node = &self.base, .index = 0, .node = null };
	923	}
	924
	925	pub fn iterateNext(self: const Identifier, it: Node.Iterator) ?*Node {
865	926	return null;
866	927	}
867	928
...	...	@@ -892,7 +953,7 @@ pub const Node = struct {
892	953	is_extern_prototype: bool = false, // TODO: Remove once extern fn rewriting is
893	954	is_async: bool = false, // TODO: remove once async fn rewriting is
894	955
895		pub const ParamList = SegmentedList(*Node, 2);
	956	pub const ParamList = LinkedList(*Node);
896	957
897	958	pub const ReturnType = union(enum) {
898	959	Explicit: *Node,
...	...	@@ -900,16 +961,24 @@ pub const Node = struct {
900	961	Invalid: TokenIndex,
901	962	};
902	963
903		pub fn iterate(self: FnProto, index: usize) ?Node {
904		var i = index;
	964	pub fn iterate(self: *const FnProto) Node.Iterator {
	965	return .{ .parent_node = &self.base, .index = 0, .node = self.params.first };
	966	}
	967
	968	pub fn iterateNext(self: const FnProto, it: Node.Iterator) ?*Node {
	969	var i = it.index;
	970	it.index += 1;
905	971
906	972	if (self.lib_name) \|lib_name\| {
907	973	if (i < 1) return lib_name;
908	974	i -= 1;
909	975	}
910	976
911		if (i < self.params.len) return self.params.at(self.params.len - i - 1).*;
912		i -= self.params.len;
	977	if (it.node) \|param\| {
	978	it.index -= 1;
	979	it.node = param.next;
	980	return param.data;
	981	}
913	982
914	983	if (self.align_expr) \|align_expr\| {
915	984	if (i < 1) return align_expr;
...	...	@@ -963,8 +1032,13 @@ pub const Node = struct {
963	1032	return_type: *Node,
964	1033	};
965	1034
966		pub fn iterate(self: AnyFrameType, index: usize) ?Node {
967		var i = index;
	1035	pub fn iterate(self: *const AnyFrameType) Node.Iterator {
	1036	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1037	}
	1038
	1039	pub fn iterateNext(self: const AnyFrameType, it: Node.Iterator) ?*Node {
	1040	var i = it.index;
	1041	it.index += 1;
968	1042
969	1043	if (self.result) \|result\| {
970	1044	if (i < 1) return result.return_type;
...	...	@@ -998,8 +1072,13 @@ pub const Node = struct {
998	1072	type_expr: *Node,
999	1073	};
1000	1074
1001		pub fn iterate(self: ParamDecl, index: usize) ?Node {
1002		var i = index;
	1075	pub fn iterate(self: *const ParamDecl) Node.Iterator {
	1076	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1077	}
	1078
	1079	pub fn iterateNext(self: const ParamDecl, it: Node.Iterator) ?*Node {
	1080	var i = it.index;
	1081	it.index += 1;
1003	1082
1004	1083	if (i < 1) {
1005	1084	switch (self.param_type) {
...	...	@@ -1039,13 +1118,14 @@ pub const Node = struct {
1039	1118
1040	1119	pub const StatementList = Root.DeclList;
1041	1120
1042		pub fn iterate(self: Block, index: usize) ?Node {
1043		var i = index;
1044
1045		if (i < self.statements.len) return self.statements.at(i).*;
1046		i -= self.statements.len;
	1121	pub fn iterate(self: *const Block) Node.Iterator {
	1122	return .{ .parent_node = &self.base, .index = 0, .node = self.statements.first };
	1123	}
1047	1124
1048		return null;
	1125	pub fn iterateNext(self: const Block, it: Node.Iterator) ?*Node {
	1126	const child = it.node orelse return null;
	1127	it.node = child.next;
	1128	return child.data;
1049	1129	}
1050	1130
1051	1131	pub fn firstToken(self: *const Block) TokenIndex {
...	...	@@ -1067,8 +1147,13 @@ pub const Node = struct {
1067	1147	payload: ?*Node,
1068	1148	expr: *Node,
1069	1149
1070		pub fn iterate(self: Defer, index: usize) ?Node {
1071		var i = index;
	1150	pub fn iterate(self: *const Defer) Node.Iterator {
	1151	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1152	}
	1153
	1154	pub fn iterateNext(self: const Defer, it: Node.Iterator) ?*Node {
	1155	var i = it.index;
	1156	it.index += 1;
1072	1157
1073	1158	if (i < 1) return self.expr;
1074	1159	i -= 1;
...	...	@@ -1091,8 +1176,13 @@ pub const Node = struct {
1091	1176	comptime_token: TokenIndex,
1092	1177	expr: *Node,
1093	1178
1094		pub fn iterate(self: Comptime, index: usize) ?Node {
1095		var i = index;
	1179	pub fn iterate(self: *const Comptime) Node.Iterator {
	1180	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1181	}
	1182
	1183	pub fn iterateNext(self: const Comptime, it: Node.Iterator) ?*Node {
	1184	var i = it.index;
	1185	it.index += 1;
1096	1186
1097	1187	if (i < 1) return self.expr;
1098	1188	i -= 1;
...	...	@@ -1114,8 +1204,13 @@ pub const Node = struct {
1114	1204	nosuspend_token: TokenIndex,
1115	1205	expr: *Node,
1116	1206
1117		pub fn iterate(self: Nosuspend, index: usize) ?Node {
1118		var i = index;
	1207	pub fn iterate(self: *const Nosuspend) Node.Iterator {
	1208	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1209	}
	1210
	1211	pub fn iterateNext(self: const Nosuspend, it: Node.Iterator) ?*Node {
	1212	var i = it.index;
	1213	it.index += 1;
1119	1214
1120	1215	if (i < 1) return self.expr;
1121	1216	i -= 1;
...	...	@@ -1138,8 +1233,13 @@ pub const Node = struct {
1138	1233	error_symbol: *Node,
1139	1234	rpipe: TokenIndex,
1140	1235
1141		pub fn iterate(self: Payload, index: usize) ?Node {
1142		var i = index;
	1236	pub fn iterate(self: *const Payload) Node.Iterator {
	1237	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1238	}
	1239
	1240	pub fn iterateNext(self: const Payload, it: Node.Iterator) ?*Node {
	1241	var i = it.index;
	1242	it.index += 1;
1143	1243
1144	1244	if (i < 1) return self.error_symbol;
1145	1245	i -= 1;
...	...	@@ -1163,8 +1263,13 @@ pub const Node = struct {
1163	1263	value_symbol: *Node,
1164	1264	rpipe: TokenIndex,
1165	1265
1166		pub fn iterate(self: PointerPayload, index: usize) ?Node {
1167		var i = index;
	1266	pub fn iterate(self: *const PointerPayload) Node.Iterator {
	1267	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1268	}
	1269
	1270	pub fn iterateNext(self: const PointerPayload, it: Node.Iterator) ?*Node {
	1271	var i = it.index;
	1272	it.index += 1;
1168	1273
1169	1274	if (i < 1) return self.value_symbol;
1170	1275	i -= 1;
...	...	@@ -1189,8 +1294,13 @@ pub const Node = struct {
1189	1294	index_symbol: ?*Node,
1190	1295	rpipe: TokenIndex,
1191	1296
1192		pub fn iterate(self: PointerIndexPayload, index: usize) ?Node {
1193		var i = index;
	1297	pub fn iterate(self: *const PointerIndexPayload) Node.Iterator {
	1298	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1299	}
	1300
	1301	pub fn iterateNext(self: const PointerIndexPayload, it: Node.Iterator) ?*Node {
	1302	var i = it.index;
	1303	it.index += 1;
1194	1304
1195	1305	if (i < 1) return self.value_symbol;
1196	1306	i -= 1;
...	...	@@ -1218,8 +1328,13 @@ pub const Node = struct {
1218	1328	payload: ?*Node,
1219	1329	body: *Node,
1220	1330
1221		pub fn iterate(self: Else, index: usize) ?Node {
1222		var i = index;
	1331	pub fn iterate(self: *const Else) Node.Iterator {
	1332	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1333	}
	1334
	1335	pub fn iterateNext(self: const Else, it: Node.Iterator) ?*Node {
	1336	var i = it.index;
	1337	it.index += 1;
1223	1338
1224	1339	if (self.payload) \|payload\| {
1225	1340	if (i < 1) return payload;
...	...	@@ -1250,16 +1365,24 @@ pub const Node = struct {
1250	1365	cases: CaseList,
1251	1366	rbrace: TokenIndex,
1252	1367
1253		pub const CaseList = SegmentedList(*Node, 2);
	1368	pub const CaseList = LinkedList(*Node);
	1369
	1370	pub fn iterate(self: *const Switch) Node.Iterator {
	1371	return .{ .parent_node = &self.base, .index = 0, .node = self.cases.first };
	1372	}
1254	1373
1255		pub fn iterate(self: Switch, index: usize) ?Node {
1256		var i = index;
	1374	pub fn iterateNext(self: const Switch, it: Node.Iterator) ?*Node {
	1375	var i = it.index;
	1376	it.index += 1;
1257	1377
1258	1378	if (i < 1) return self.expr;
1259	1379	i -= 1;
1260	1380
1261		if (i < self.cases.len) return self.cases.at(i).*;
1262		i -= self.cases.len;
	1381	if (it.node) \|child\| {
	1382	it.index -= 1;
	1383	it.node = child.next;
	1384	return child.data;
	1385	}
1263	1386
1264	1387	return null;
1265	1388	}
...	...	@@ -1280,13 +1403,21 @@ pub const Node = struct {
1280	1403	payload: ?*Node,
1281	1404	expr: *Node,
1282	1405
1283		pub const ItemList = SegmentedList(*Node, 1);
	1406	pub const ItemList = LinkedList(*Node);
	1407
	1408	pub fn iterate(self: *const SwitchCase) Node.Iterator {
	1409	return .{ .parent_node = &self.base, .index = 0, .node = self.items.first };
	1410	}
1284	1411
1285		pub fn iterate(self: SwitchCase, index: usize) ?Node {
1286		var i = index;
	1412	pub fn iterateNext(self: const SwitchCase, it: Node.Iterator) ?*Node {
	1413	var i = it.index;
	1414	it.index += 1;
1287	1415
1288		if (i < self.items.len) return self.items.at(i).*;
1289		i -= self.items.len;
	1416	if (it.node) \|child\| {
	1417	it.index -= 1;
	1418	it.node = child.next;
	1419	return child.data;
	1420	}
1290	1421
1291	1422	if (self.payload) \|payload\| {
1292	1423	if (i < 1) return payload;
...	...	@@ -1300,7 +1431,7 @@ pub const Node = struct {
1300	1431	}
1301	1432
1302	1433	pub fn firstToken(self: *const SwitchCase) TokenIndex {
1303		return (self.items.at(0).*).firstToken();
	1434	return self.items.first.?.data.firstToken();
1304	1435	}
1305	1436
1306	1437	pub fn lastToken(self: *const SwitchCase) TokenIndex {
...	...	@@ -1312,7 +1443,11 @@ pub const Node = struct {
1312	1443	base: Node = Node{ .id = .SwitchElse },
1313	1444	token: TokenIndex,
1314	1445
1315		pub fn iterate(self: SwitchElse, index: usize) ?Node {
	1446	pub fn iterate(self: *const SwitchElse) Node.Iterator {
	1447	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1448	}
	1449
	1450	pub fn iterateNext(self: const SwitchElse, it: Node.Iterator) ?*Node {
1316	1451	return null;
1317	1452	}
1318	1453
...	...	@@ -1336,8 +1471,13 @@ pub const Node = struct {
1336	1471	body: *Node,
1337	1472	@"else": ?*Else,
1338	1473
1339		pub fn iterate(self: While, index: usize) ?Node {
1340		var i = index;
	1474	pub fn iterate(self: *const While) Node.Iterator {
	1475	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1476	}
	1477
	1478	pub fn iterateNext(self: const While, it: Node.Iterator) ?*Node {
	1479	var i = it.index;
	1480	it.index += 1;
1341	1481
1342	1482	if (i < 1) return self.condition;
1343	1483	i -= 1;
...	...	@@ -1394,8 +1534,13 @@ pub const Node = struct {
1394	1534	body: *Node,
1395	1535	@"else": ?*Else,
1396	1536
1397		pub fn iterate(self: For, index: usize) ?Node {
1398		var i = index;
	1537	pub fn iterate(self: *const For) Node.Iterator {
	1538	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1539	}
	1540
	1541	pub fn iterateNext(self: const For, it: Node.Iterator) ?*Node {
	1542	var i = it.index;
	1543	it.index += 1;
1399	1544
1400	1545	if (i < 1) return self.array_expr;
1401	1546	i -= 1;
...	...	@@ -1443,8 +1588,13 @@ pub const Node = struct {
1443	1588	body: *Node,
1444	1589	@"else": ?*Else,
1445	1590
1446		pub fn iterate(self: If, index: usize) ?Node {
1447		var i = index;
	1591	pub fn iterate(self: *const If) Node.Iterator {
	1592	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1593	}
	1594
	1595	pub fn iterateNext(self: const If, it: Node.Iterator) ?*Node {
	1596	var i = it.index;
	1597	it.index += 1;
1448	1598
1449	1599	if (i < 1) return self.condition;
1450	1600	i -= 1;
...	...	@@ -1531,8 +1681,13 @@ pub const Node = struct {
1531	1681	UnwrapOptional,
1532	1682	};
1533	1683
1534		pub fn iterate(self: InfixOp, index: usize) ?Node {
1535		var i = index;
	1684	pub fn iterate(self: *const InfixOp) Node.Iterator {
	1685	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1686	}
	1687
	1688	pub fn iterateNext(self: const InfixOp, it: Node.Iterator) ?*Node {
	1689	var i = it.index;
	1690	it.index += 1;
1536	1691
1537	1692	if (i < 1) return self.lhs;
1538	1693	i -= 1;
...	...	@@ -1649,8 +1804,13 @@ pub const Node = struct {
1649	1804	};
1650	1805	};
1651	1806
1652		pub fn iterate(self: PrefixOp, index: usize) ?Node {
1653		var i = index;
	1807	pub fn iterate(self: *const PrefixOp) Node.Iterator {
	1808	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1809	}
	1810
	1811	pub fn iterateNext(self: const PrefixOp, it: Node.Iterator) ?*Node {
	1812	var i = it.index;
	1813	it.index += 1;
1654	1814
1655	1815	switch (self.op) {
1656	1816	.PtrType, .SliceType => \|addr_of_info\| {
...	...	@@ -1707,8 +1867,13 @@ pub const Node = struct {
1707	1867	name_token: TokenIndex,
1708	1868	expr: *Node,
1709	1869
1710		pub fn iterate(self: FieldInitializer, index: usize) ?Node {
1711		var i = index;
	1870	pub fn iterate(self: *const FieldInitializer) Node.Iterator {
	1871	return .{ .parent_node = &self.base, .index = 0, .node = null };
	1872	}
	1873
	1874	pub fn iterateNext(self: const FieldInitializer, it: Node.Iterator) ?*Node {
	1875	var i = it.index;
	1876	it.index += 1;
1712	1877
1713	1878	if (i < 1) return self.expr;
1714	1879	i -= 1;
...	...	@@ -1745,13 +1910,13 @@ pub const Node = struct {
1745	1910	Deref,
1746	1911	UnwrapOptional,
1747	1912
1748		pub const InitList = SegmentedList(*Node, 2);
	1913	pub const InitList = LinkedList(*Node);
1749	1914
1750	1915	pub const Call = struct {
1751	1916	params: ParamList,
1752	1917	async_token: ?TokenIndex,
1753	1918
1754		pub const ParamList = SegmentedList(*Node, 2);
	1919	pub const ParamList = LinkedList(*Node);
1755	1920	};
1756	1921
1757	1922	pub const Slice = struct {
...	...	@@ -1761,8 +1926,20 @@ pub const Node = struct {
1761	1926	};
1762	1927	};
1763	1928
1764		pub fn iterate(self: SuffixOp, index: usize) ?Node {
1765		var i = index;
	1929	pub fn iterate(self: *const SuffixOp) Node.Iterator {
	1930	return .{ .parent_node = &self.base, .index = 0,
	1931	.node = switch(self.op) {
	1932	.Call => \|call\| call.params.first,
	1933	.ArrayInitializer => \|ai\| ai.first,
	1934	.StructInitializer => \|si\| si.first,
	1935	else => null,
	1936	},
	1937	};
	1938	}
	1939
	1940	pub fn iterateNext(self: const SuffixOp, it: Node.Iterator) ?*Node {
	1941	var i = it.index;
	1942	it.index += 1;
1766	1943
1767	1944	switch (self.lhs) {
1768	1945	.node => \|node\| {
...	...	@@ -1773,9 +1950,12 @@ pub const Node = struct {
1773	1950	}
1774	1951
1775	1952	switch (self.op) {
1776		.Call => \|*call_info\| {
1777		if (i < call_info.params.len) return call_info.params.at(i).*;
1778		i -= call_info.params.len;
	1953	.Call => \|call_info\| {
	1954	if (it.node) \|child\| {
	1955	it.index -= 1;
	1956	it.node = child.next;
	1957	return child.data;
	1958	}
1779	1959	},
1780	1960	.ArrayAccess => \|index_expr\| {
1781	1961	if (i < 1) return index_expr;
...	...	@@ -1794,13 +1974,19 @@ pub const Node = struct {
1794	1974	i -= 1;
1795	1975	}
1796	1976	},
1797		.ArrayInitializer => \|*exprs\| {
1798		if (i < exprs.len) return exprs.at(i).*;
1799		i -= exprs.len;
	1977	.ArrayInitializer => \|exprs\| {
	1978	if (it.node) \|child\| {
	1979	it.index -= 1;
	1980	it.node = child.next;
	1981	return child.data;
	1982	}
1800	1983	},
1801		.StructInitializer => \|*fields\| {
1802		if (i < fields.len) return fields.at(i).*;
1803		i -= fields.len;
	1984	.StructInitializer => \|fields\| {
	1985	if (it.node) \|child\| {
	1986	it.index -= 1;
	1987	it.node = child.next;
	1988	return child.data;
	1989	}
1804	1990	},
1805	1991	.UnwrapOptional,
1806	1992	.Deref,
...	...	@@ -1832,8 +2018,13 @@ pub const Node = struct {
1832	2018	expr: *Node,
1833	2019	rparen: TokenIndex,
1834	2020
1835		pub fn iterate(self: GroupedExpression, index: usize) ?Node {
1836		var i = index;
	2021	pub fn iterate(self: *const GroupedExpression) Node.Iterator {
	2022	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2023	}
	2024
	2025	pub fn iterateNext(self: const GroupedExpression, it: Node.Iterator) ?*Node {
	2026	var i = it.index;
	2027	it.index += 1;
1837	2028
1838	2029	if (i < 1) return self.expr;
1839	2030	i -= 1;
...	...	@@ -1862,8 +2053,13 @@ pub const Node = struct {
1862	2053	Return,
1863	2054	};
1864	2055
1865		pub fn iterate(self: ControlFlowExpression, index: usize) ?Node {
1866		var i = index;
	2056	pub fn iterate(self: *const ControlFlowExpression) Node.Iterator {
	2057	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2058	}
	2059
	2060	pub fn iterateNext(self: const ControlFlowExpression, it: Node.Iterator) ?*Node {
	2061	var i = it.index;
	2062	it.index += 1;
1867	2063
1868	2064	switch (self.kind) {
1869	2065	.Break, .Continue => \|maybe_label\| {
...	...	@@ -1910,8 +2106,13 @@ pub const Node = struct {
1910	2106	suspend_token: TokenIndex,
1911	2107	body: ?*Node,
1912	2108
1913		pub fn iterate(self: Suspend, index: usize) ?Node {
1914		var i = index;
	2109	pub fn iterate(self: *const Suspend) Node.Iterator {
	2110	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2111	}
	2112
	2113	pub fn iterateNext(self: const Suspend, it: Node.Iterator) ?*Node {
	2114	var i = it.index;
	2115	it.index += 1;
1915	2116
1916	2117	if (self.body) \|body\| {
1917	2118	if (i < 1) return body;
...	...	@@ -1938,7 +2139,11 @@ pub const Node = struct {
1938	2139	base: Node = Node{ .id = .IntegerLiteral },
1939	2140	token: TokenIndex,
1940	2141
1941		pub fn iterate(self: IntegerLiteral, index: usize) ?Node {
	2142	pub fn iterate(self: *const IntegerLiteral) Node.Iterator {
	2143	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2144	}
	2145
	2146	pub fn iterateNext(self: const IntegerLiteral, it: Node.Iterator) ?*Node {
1942	2147	return null;
1943	2148	}
1944	2149
...	...	@@ -1956,7 +2161,11 @@ pub const Node = struct {
1956	2161	dot: TokenIndex,
1957	2162	name: TokenIndex,
1958	2163
1959		pub fn iterate(self: EnumLiteral, index: usize) ?Node {
	2164	pub fn iterate(self: *const EnumLiteral) Node.Iterator {
	2165	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2166	}
	2167
	2168	pub fn iterateNext(self: const EnumLiteral, it: Node.Iterator) ?*Node {
1960	2169	return null;
1961	2170	}
1962	2171
...	...	@@ -1973,7 +2182,11 @@ pub const Node = struct {
1973	2182	base: Node = Node{ .id = .FloatLiteral },
1974	2183	token: TokenIndex,
1975	2184
1976		pub fn iterate(self: FloatLiteral, index: usize) ?Node {
	2185	pub fn iterate(self: *const FloatLiteral) Node.Iterator {
	2186	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2187	}
	2188
	2189	pub fn iterateNext(self: const FloatLiteral, it: Node.Iterator) ?*Node {
1977	2190	return null;
1978	2191	}
1979	2192
...	...	@@ -1992,15 +2205,16 @@ pub const Node = struct {
1992	2205	params: ParamList,
1993	2206	rparen_token: TokenIndex,
1994	2207
1995		pub const ParamList = SegmentedList(*Node, 2);
	2208	pub const ParamList = LinkedList(*Node);
1996	2209
1997		pub fn iterate(self: BuiltinCall, index: usize) ?Node {
1998		var i = index;
1999
2000		if (i < self.params.len) return self.params.at(i).*;
2001		i -= self.params.len;
	2210	pub fn iterate(self: *const BuiltinCall) Node.Iterator {
	2211	return .{ .parent_node = &self.base, .index = 0, .node = self.params.first };
	2212	}
2002	2213
2003		return null;
	2214	pub fn iterateNext(self: const BuiltinCall, it: Node.Iterator) ?*Node {
	2215	const param = it.node orelse return null;
	2216	it.node = param.next;
	2217	return param.data;
2004	2218	}
2005	2219
2006	2220	pub fn firstToken(self: *const BuiltinCall) TokenIndex {
...	...	@@ -2016,7 +2230,11 @@ pub const Node = struct {
2016	2230	base: Node = Node{ .id = .StringLiteral },
2017	2231	token: TokenIndex,
2018	2232
2019		pub fn iterate(self: StringLiteral, index: usize) ?Node {
	2233	pub fn iterate(self: *const StringLiteral) Node.Iterator {
	2234	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2235	}
	2236
	2237	pub fn iterateNext(self: const StringLiteral, it: Node.Iterator) ?*Node {
2020	2238	return null;
2021	2239	}
2022	2240
...	...	@@ -2033,18 +2251,25 @@ pub const Node = struct {
2033	2251	base: Node = Node{ .id = .MultilineStringLiteral },
2034	2252	lines: LineList,
2035	2253
2036		pub const LineList = SegmentedList(TokenIndex, 4);
	2254	pub const LineList = LinkedList(TokenIndex);
	2255
	2256	pub fn iterate(self: *const MultilineStringLiteral) Node.Iterator {
	2257	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2258	}
2037	2259
2038		pub fn iterate(self: MultilineStringLiteral, index: usize) ?Node {
	2260	pub fn iterateNext(self: const MultilineStringLiteral, it: Node.Iterator) ?*Node {
2039	2261	return null;
2040	2262	}
2041	2263
2042	2264	pub fn firstToken(self: *const MultilineStringLiteral) TokenIndex {
2043		return self.lines.at(0).*;
	2265	return self.lines.first.?.data;
2044	2266	}
2045	2267
2046	2268	pub fn lastToken(self: *const MultilineStringLiteral) TokenIndex {
2047		return self.lines.at(self.lines.len - 1).*;
	2269	var node = self.lines.first.?;
	2270	while (true) {
	2271	node = node.next orelse return node.data;
	2272	}
2048	2273	}
2049	2274	};
2050	2275
...	...	@@ -2052,7 +2277,11 @@ pub const Node = struct {
2052	2277	base: Node = Node{ .id = .CharLiteral },
2053	2278	token: TokenIndex,
2054	2279
2055		pub fn iterate(self: CharLiteral, index: usize) ?Node {
	2280	pub fn iterate(self: *const CharLiteral) Node.Iterator {
	2281	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2282	}
	2283
	2284	pub fn iterateNext(self: const CharLiteral, it: Node.Iterator) ?*Node {
2056	2285	return null;
2057	2286	}
2058	2287
...	...	@@ -2069,7 +2298,11 @@ pub const Node = struct {
2069	2298	base: Node = Node{ .id = .BoolLiteral },
2070	2299	token: TokenIndex,
2071	2300
2072		pub fn iterate(self: BoolLiteral, index: usize) ?Node {
	2301	pub fn iterate(self: *const BoolLiteral) Node.Iterator {
	2302	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2303	}
	2304
	2305	pub fn iterateNext(self: const BoolLiteral, it: Node.Iterator) ?*Node {
2073	2306	return null;
2074	2307	}
2075	2308
...	...	@@ -2086,7 +2319,11 @@ pub const Node = struct {
2086	2319	base: Node = Node{ .id = .NullLiteral },
2087	2320	token: TokenIndex,
2088	2321
2089		pub fn iterate(self: NullLiteral, index: usize) ?Node {
	2322	pub fn iterate(self: *const NullLiteral) Node.Iterator {
	2323	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2324	}
	2325
	2326	pub fn iterateNext(self: const NullLiteral, it: Node.Iterator) ?*Node {
2090	2327	return null;
2091	2328	}
2092	2329
...	...	@@ -2103,7 +2340,11 @@ pub const Node = struct {
2103	2340	base: Node = Node{ .id = .UndefinedLiteral },
2104	2341	token: TokenIndex,
2105	2342
2106		pub fn iterate(self: UndefinedLiteral, index: usize) ?Node {
	2343	pub fn iterate(self: *const UndefinedLiteral) Node.Iterator {
	2344	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2345	}
	2346
	2347	pub fn iterateNext(self: const UndefinedLiteral, it: Node.Iterator) ?*Node {
2107	2348	return null;
2108	2349	}
2109	2350
...	...	@@ -2129,8 +2370,13 @@ pub const Node = struct {
2129	2370	Return: *Node,
2130	2371	};
2131	2372
2132		pub fn iterate(self: AsmOutput, index: usize) ?Node {
2133		var i = index;
	2373	pub fn iterate(self: *const AsmOutput) Node.Iterator {
	2374	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2375	}
	2376
	2377	pub fn iterateNext(self: const AsmOutput, it: Node.Iterator) ?*Node {
	2378	var i = it.index;
	2379	it.index += 1;
2134	2380
2135	2381	if (i < 1) return self.symbolic_name;
2136	2382	i -= 1;
...	...	@@ -2169,8 +2415,13 @@ pub const Node = struct {
2169	2415	expr: *Node,
2170	2416	rparen: TokenIndex,
2171	2417
2172		pub fn iterate(self: AsmInput, index: usize) ?Node {
2173		var i = index;
	2418	pub fn iterate(self: *const AsmInput) Node.Iterator {
	2419	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2420	}
	2421
	2422	pub fn iterateNext(self: const AsmInput, it: Node.Iterator) ?*Node {
	2423	var i = it.index;
	2424	it.index += 1;
2174	2425
2175	2426	if (i < 1) return self.symbolic_name;
2176	2427	i -= 1;
...	...	@@ -2203,18 +2454,31 @@ pub const Node = struct {
2203	2454	clobbers: ClobberList,
2204	2455	rparen: TokenIndex,
2205	2456
2206		pub const OutputList = SegmentedList(*AsmOutput, 2);
2207		pub const InputList = SegmentedList(*AsmInput, 2);
2208		pub const ClobberList = SegmentedList(*Node, 2);
	2457	pub const OutputList = LinkedList(*AsmOutput);
	2458	pub const InputList = LinkedList(*AsmInput);
	2459	pub const ClobberList = LinkedList(*Node);
2209	2460
2210		pub fn iterate(self: Asm, index: usize) ?Node {
2211		var i = index;
	2461	pub fn iterate(self: *const Asm) Node.Iterator {
	2462	return .{ .parent_node = &self.base, .index = 0, .node = null};
	2463	}
2212	2464
2213		if (i < self.outputs.len) return &self.outputs.at(i).*.base;
2214		i -= self.outputs.len;
	2465	pub fn iterateNext(self: const Asm, it: Node.Iterator) ?*Node {
	2466	var i = it.index;
	2467	it.index += 1;
2215	2468
2216		if (i < self.inputs.len) return &self.inputs.at(i).*.base;
2217		i -= self.inputs.len;
	2469	var output: ?LinkedList(AsmOutput).Node = self.outputs.first;
	2470	while (output) \|o\| {
	2471	if (i < 1) return &o.data.base;
	2472	i -= 1;
	2473	output = o.next;
	2474	}
	2475
	2476	var input: ?LinkedList(AsmInput).Node = self.inputs.first;
	2477	while (input) \|o\| {
	2478	if (i < 1) return &o.data.base;
	2479	i -= 1;
	2480	input = o.next;
	2481	}
2218	2482
2219	2483	return null;
2220	2484	}
...	...	@@ -2232,7 +2496,11 @@ pub const Node = struct {
2232	2496	base: Node = Node{ .id = .Unreachable },
2233	2497	token: TokenIndex,
2234	2498
2235		pub fn iterate(self: Unreachable, index: usize) ?Node {
	2499	pub fn iterate(self: *const Unreachable) Node.Iterator {
	2500	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2501	}
	2502
	2503	pub fn iterateNext(self: const Unreachable, it: Node.Iterator) ?*Node {
2236	2504	return null;
2237	2505	}
2238	2506
...	...	@@ -2249,7 +2517,11 @@ pub const Node = struct {
2249	2517	base: Node = Node{ .id = .ErrorType },
2250	2518	token: TokenIndex,
2251	2519
2252		pub fn iterate(self: ErrorType, index: usize) ?Node {
	2520	pub fn iterate(self: *const ErrorType) Node.Iterator {
	2521	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2522	}
	2523
	2524	pub fn iterateNext(self: const ErrorType, it: Node.Iterator) ?*Node {
2253	2525	return null;
2254	2526	}
2255	2527
...	...	@@ -2266,7 +2538,11 @@ pub const Node = struct {
2266	2538	base: Node = Node{ .id = .VarType },
2267	2539	token: TokenIndex,
2268	2540
2269		pub fn iterate(self: VarType, index: usize) ?Node {
	2541	pub fn iterate(self: *const VarType) Node.Iterator {
	2542	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2543	}
	2544
	2545	pub fn iterateNext(self: const VarType, it: Node.Iterator) ?*Node {
2270	2546	return null;
2271	2547	}
2272	2548
...	...	@@ -2283,18 +2559,25 @@ pub const Node = struct {
2283	2559	base: Node = Node{ .id = .DocComment },
2284	2560	lines: LineList,
2285	2561
2286		pub const LineList = SegmentedList(TokenIndex, 4);
	2562	pub const LineList = LinkedList(TokenIndex);
	2563
	2564	pub fn iterate(self: *const DocComment) Node.Iterator {
	2565	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2566	}
2287	2567
2288		pub fn iterate(self: DocComment, index: usize) ?Node {
	2568	pub fn iterateNext(self: const DocComment, it: Node.Iterator) ?*Node {
2289	2569	return null;
2290	2570	}
2291	2571
2292	2572	pub fn firstToken(self: *const DocComment) TokenIndex {
2293		return self.lines.at(0).*;
	2573	return self.lines.first.?.data;
2294	2574	}
2295	2575
2296	2576	pub fn lastToken(self: *const DocComment) TokenIndex {
2297		return self.lines.at(self.lines.len - 1).*;
	2577	var node = self.lines.first.?;
	2578	while (true) {
	2579	node = node.next orelse return node.data;
	2580	}
2298	2581	}
2299	2582	};
2300	2583
...	...	@@ -2305,8 +2588,13 @@ pub const Node = struct {
2305	2588	name: *Node,
2306	2589	body_node: *Node,
2307	2590
2308		pub fn iterate(self: TestDecl, index: usize) ?Node {
2309		var i = index;
	2591	pub fn iterate(self: *const TestDecl) Node.Iterator {
	2592	return .{ .parent_node = &self.base, .index = 0, .node = null };
	2593	}
	2594
	2595	pub fn iterateNext(self: const TestDecl, it: Node.Iterator) ?*Node {
	2596	var i = it.index;
	2597	it.index += 1;
2310	2598
2311	2599	if (i < 1) return self.body_node;
2312	2600	i -= 1;
...	...	@@ -2331,5 +2619,6 @@ test "iterate" {
2331	2619	.eof_token = 0,
2332	2620	};
2333	2621	var base = &root.base;
2334		testing.expect(base.iterate(0) == null);
	2622	var it = base.iterate();
	2623	testing.expect(it.next() == null);
2335	2624	}

lib/std/zig/parse.zig+2852-2806

...	...	@@ -7,3303 +7,3349 @@ const Tree = ast.Tree;
7	7	const AstError = ast.Error;
8	8	const TokenIndex = ast.TokenIndex;
9	9	const Token = std.zig.Token;
10		const TokenIterator = Tree.TokenList.Iterator;
11	10
12	11	pub const Error = error{ParseError} \|\| Allocator.Error;
13	12
14	13	/// Result should be freed with tree.deinit() when there are
15	14	/// no more references to any of the tokens or nodes.
16		pub fn parse(allocator: Allocator, source: []const u8) Allocator.Error!Tree {
17		const tree = blk: {
18		// This block looks unnecessary, but is a "foot-shield" to prevent the SegmentedLists
19		// from being initialized with a pointer to this `arena`, which is created on
20		// the stack. Following code should instead refer to `&tree.arena_allocator`, a
21		// pointer to data which lives safely on the heap and will outlive `parse`. See:
22		// https://github.com/ziglang/zig/commit/cb4fb14b6e66bd213575f69eec9598be8394fae6
23		var arena = std.heap.ArenaAllocator.init(allocator);
24		errdefer arena.deinit();
25		const tree = try arena.allocator.create(ast.Tree);
26		tree.* = .{
27		.source = source,
28		.root_node = undefined,
29		.arena_allocator = arena,
30		.tokens = undefined,
31		.errors = undefined,
32		};
33		break :blk tree;
34		};
35		errdefer tree.deinit();
36		const arena = &tree.arena_allocator.allocator;
37
38		tree.tokens = ast.Tree.TokenList.init(arena);
39		tree.errors = ast.Tree.ErrorList.init(arena);
	15	pub fn parse(gpa: Allocator, source: []const u8) Allocator.Error!Tree {
	16	// TODO optimization idea: ensureCapacity on the tokens list and
	17	// then appendAssumeCapacity inside the loop.
	18	var tokens = std.ArrayList(Token).init(gpa);
	19	defer tokens.deinit();
40	20
41	21	var tokenizer = std.zig.Tokenizer.init(source);
42	22	while (true) {
43		const tree_token = try tree.tokens.addOne();
	23	const tree_token = try tokens.addOne();
44	24	tree_token.* = tokenizer.next();
45	25	if (tree_token.id == .Eof) break;
46	26	}
47		var it = tree.tokens.iterator(0);
48	27
49		while (it.peek().?.id == .LineComment) _ = it.next();
	28	var parser: Parser = .{
	29	.source = source,
	30	.arena = std.heap.ArenaAllocator.init(gpa),
	31	.gpa = gpa,
	32	.tokens = tokens.items,
	33	.errors = .{},
	34	.tok_i = 0,
	35	};
	36	defer parser.errors.deinit(gpa);
	37	errdefer parser.arena.deinit();
50	38
51		tree.root_node = try parseRoot(arena, &it, tree);
	39	while (tokens.items[parser.tok_i].id == .LineComment) parser.tok_i += 1;
52	40
53		return tree;
54		}
	41	const root_node = try parser.parseRoot();
55	42
56		/// Root <- skip ContainerMembers eof
57		fn parseRoot(arena: Allocator, it: TokenIterator, tree: Tree) Allocator.Error!Node.Root {
58		const node = try arena.create(Node.Root);
59		node.* = .{
60		.decls = try parseContainerMembers(arena, it, tree, true),
61		// parseContainerMembers will try to skip as much
62		// invalid tokens as it can so this can only be the EOF
63		.eof_token = eatToken(it, .Eof).?,
	43	const tree = try parser.arena.allocator.create(Tree);
	44	tree.* = .{
	45	.gpa = gpa,
	46	.source = source,
	47	.tokens = tokens.toOwnedSlice(),
	48	.errors = parser.errors.toOwnedSlice(gpa),
	49	.root_node = root_node,
	50	.arena = parser.arena.state,
64	51	};
65		return node;
	52	return tree;
66	53	}
67	54
68		/// ContainerMembers
69		/// <- TestDecl ContainerMembers
70		/// / TopLevelComptime ContainerMembers
71		/// / KEYWORD_pub? TopLevelDecl ContainerMembers
72		/// / ContainerField COMMA ContainerMembers
73		/// / ContainerField
74		/// /
75		fn parseContainerMembers(arena: Allocator, it: TokenIterator, tree: *Tree, top_level: bool) !Node.Root.DeclList {
76		var list = Node.Root.DeclList.init(arena);
77
78		var field_state: union(enum) {
79		/// no fields have been seen
80		none,
81		/// currently parsing fields
82		seen,
83		/// saw fields and then a declaration after them.
84		/// payload is first token of previous declaration.
85		end: TokenIndex,
86		/// ther was a declaration between fields, don't report more errors
87		err,
88		} = .none;
	55	/// Represents in-progress parsing, will be converted to an ast.Tree after completion.
	56	const Parser = struct {
	57	arena: std.heap.ArenaAllocator,
	58	gpa: *Allocator,
	59	source: []const u8,
	60	tokens: []const Token,
	61	tok_i: TokenIndex,
	62	errors: std.ArrayListUnmanaged(AstError),
89	63
90		while (true) {
91		if (try parseContainerDocComments(arena, it, tree)) \|node\| {
92		try list.push(node);
93		continue;
94		}
	64	/// Root <- skip ContainerMembers eof
	65	fn parseRoot(p: Parser) Allocator.Error!Node.Root {
	66	const node = try p.arena.allocator.create(Node.Root);
	67	node.* = .{
	68	.decls = try parseContainerMembers(p, true),
	69	// parseContainerMembers will try to skip as much
	70	// invalid tokens as it can so this can only be the EOF
	71	.eof_token = p.eatToken(.Eof).?,
	72	};
	73	return node;
	74	}
95	75
96		const doc_comments = try parseDocComment(arena, it, tree);
	76	fn llpush(
	77	p: *Parser,
	78	comptime T: type,
	79	it: ?std.SinglyLinkedList(T).Node,
	80	data: T,
	81	) !?std.SinglyLinkedList(T).Node {
	82	const llnode = try p.arena.allocator.create(std.SinglyLinkedList(T).Node);
	83	llnode.* = .{ .data = data };
	84	it.* = llnode;
	85	return &llnode.next;
	86	}
	87
	88	/// ContainerMembers
	89	/// <- TestDecl ContainerMembers
	90	/// / TopLevelComptime ContainerMembers
	91	/// / KEYWORD_pub? TopLevelDecl ContainerMembers
	92	/// / ContainerField COMMA ContainerMembers
	93	/// / ContainerField
	94	/// /
	95	fn parseContainerMembers(p: *Parser, top_level: bool) !Node.Root.DeclList {
	96	var list = Node.Root.DeclList{};
	97	var list_it = &list.first;
	98
	99	var field_state: union(enum) {
	100	/// no fields have been seen
	101	none,
	102	/// currently parsing fields
	103	seen,
	104	/// saw fields and then a declaration after them.
	105	/// payload is first token of previous declaration.
	106	end: TokenIndex,
	107	/// ther was a declaration between fields, don't report more errors
	108	err,
	109	} = .none;
97	110
98		if (parseTestDecl(arena, it, tree) catch \|err\| switch (err) {
99		error.OutOfMemory => return error.OutOfMemory,
100		error.ParseError => {
101		findNextContainerMember(it);
	111	while (true) {
	112	if (try p.parseContainerDocComments()) \|node\| {
	113	list_it = try p.llpush(*Node, list_it, node);
102	114	continue;
103		},
104		}) \|node\| {
105		if (field_state == .seen) {
106		field_state = .{ .end = node.firstToken() };
107	115	}
108		node.cast(Node.TestDecl).?.doc_comments = doc_comments;
109		try list.push(node);
110		continue;
111		}
112	116
113		if (parseTopLevelComptime(arena, it, tree) catch \|err\| switch (err) {
114		error.OutOfMemory => return error.OutOfMemory,
115		error.ParseError => {
116		findNextContainerMember(it);
	117	const doc_comments = try p.parseDocComment();
	118
	119	if (p.parseTestDecl() catch \|err\| switch (err) {
	120	error.OutOfMemory => return error.OutOfMemory,
	121	error.ParseError => {
	122	p.findNextContainerMember();
	123	continue;
	124	},
	125	}) \|node\| {
	126	if (field_state == .seen) {
	127	field_state = .{ .end = node.firstToken() };
	128	}
	129	node.cast(Node.TestDecl).?.doc_comments = doc_comments;
	130	list_it = try p.llpush(*Node, list_it, node);
117	131	continue;
118		},
119		}) \|node\| {
120		if (field_state == .seen) {
121		field_state = .{ .end = node.firstToken() };
122	132	}
123		node.cast(Node.Comptime).?.doc_comments = doc_comments;
124		try list.push(node);
125		continue;
126		}
127
128		const visib_token = eatToken(it, .Keyword_pub);
129	133
130		if (parseTopLevelDecl(arena, it, tree) catch \|err\| switch (err) {
131		error.OutOfMemory => return error.OutOfMemory,
132		error.ParseError => {
133		findNextContainerMember(it);
	134	if (p.parseTopLevelComptime() catch \|err\| switch (err) {
	135	error.OutOfMemory => return error.OutOfMemory,
	136	error.ParseError => {
	137	p.findNextContainerMember();
	138	continue;
	139	},
	140	}) \|node\| {
	141	if (field_state == .seen) {
	142	field_state = .{ .end = node.firstToken() };
	143	}
	144	node.cast(Node.Comptime).?.doc_comments = doc_comments;
	145	list_it = try p.llpush(*Node, list_it, node);
134	146	continue;
135		},
136		}) \|node\| {
137		if (field_state == .seen) {
138		field_state = .{ .end = visib_token orelse node.firstToken() };
139	147	}
140		switch (node.id) {
141		.FnProto => {
142		node.cast(Node.FnProto).?.doc_comments = doc_comments;
143		node.cast(Node.FnProto).?.visib_token = visib_token;
144		},
145		.VarDecl => {
146		node.cast(Node.VarDecl).?.doc_comments = doc_comments;
147		node.cast(Node.VarDecl).?.visib_token = visib_token;
148		},
149		.Use => {
150		node.cast(Node.Use).?.doc_comments = doc_comments;
151		node.cast(Node.Use).?.visib_token = visib_token;
	148
	149	const visib_token = p.eatToken(.Keyword_pub);
	150
	151	if (p.parseTopLevelDecl() catch \|err\| switch (err) {
	152	error.OutOfMemory => return error.OutOfMemory,
	153	error.ParseError => {
	154	p.findNextContainerMember();
	155	continue;
152	156	},
153		else => unreachable,
154		}
155		try list.push(node);
156		if (try parseAppendedDocComment(arena, it, tree, node.lastToken())) \|appended_comment\| {
	157	}) \|node\| {
	158	if (field_state == .seen) {
	159	field_state = .{ .end = visib_token orelse node.firstToken() };
	160	}
157	161	switch (node.id) {
158		.FnProto => {},
159		.VarDecl => node.cast(Node.VarDecl).?.doc_comments = appended_comment,
160		.Use => node.cast(Node.Use).?.doc_comments = appended_comment,
	162	.FnProto => {
	163	node.cast(Node.FnProto).?.doc_comments = doc_comments;
	164	node.cast(Node.FnProto).?.visib_token = visib_token;
	165	},
	166	.VarDecl => {
	167	node.cast(Node.VarDecl).?.doc_comments = doc_comments;
	168	node.cast(Node.VarDecl).?.visib_token = visib_token;
	169	},
	170	.Use => {
	171	node.cast(Node.Use).?.doc_comments = doc_comments;
	172	node.cast(Node.Use).?.visib_token = visib_token;
	173	},
161	174	else => unreachable,
162	175	}
	176	list_it = try p.llpush(*Node, list_it, node);
	177	if (try p.parseAppendedDocComment(node.lastToken())) \|appended_comment\| {
	178	switch (node.id) {
	179	.FnProto => {},
	180	.VarDecl => node.cast(Node.VarDecl).?.doc_comments = appended_comment,
	181	.Use => node.cast(Node.Use).?.doc_comments = appended_comment,
	182	else => unreachable,
	183	}
	184	}
	185	continue;
163	186	}
164		continue;
165		}
166
167		if (visib_token != null) {
168		try tree.errors.push(.{
169		.ExpectedPubItem = .{ .token = it.index },
170		});
171		// ignore this pub
172		continue;
173		}
174	187
175		if (parseContainerField(arena, it, tree) catch \|err\| switch (err) {
176		error.OutOfMemory => return error.OutOfMemory,
177		error.ParseError => {
178		// attempt to recover
179		findNextContainerMember(it);
	188	if (visib_token != null) {
	189	try p.errors.append(p.gpa, .{
	190	.ExpectedPubItem = .{ .token = p.tok_i },
	191	});
	192	// ignore this pub
180	193	continue;
181		},
182		}) \|node\| {
183		switch (field_state) {
184		.none => field_state = .seen,
185		.err, .seen => {},
186		.end => \|tok\| {
187		try tree.errors.push(.{
188		.DeclBetweenFields = .{ .token = tok },
189		});
190		// continue parsing, error will be reported later
191		field_state = .err;
192		},
193	194	}
194	195
195		const field = node.cast(Node.ContainerField).?;
196		field.doc_comments = doc_comments;
197		try list.push(node);
198		const comma = eatToken(it, .Comma) orelse {
199		// try to continue parsing
200		const index = it.index;
201		findNextContainerMember(it);
202		const next = it.peek().?.id;
203		switch (next) {
204		.Eof => break,
205		else => {
206		if (next == .RBrace) {
207		if (!top_level) break;
208		_ = nextToken(it);
209		}
210
211		// add error and continue
212		try tree.errors.push(.{
213		.ExpectedToken = .{ .token = index, .expected_id = .Comma },
	196	if (p.parseContainerField() catch \|err\| switch (err) {
	197	error.OutOfMemory => return error.OutOfMemory,
	198	error.ParseError => {
	199	// attempt to recover
	200	p.findNextContainerMember();
	201	continue;
	202	},
	203	}) \|node\| {
	204	switch (field_state) {
	205	.none => field_state = .seen,
	206	.err, .seen => {},
	207	.end => \|tok\| {
	208	try p.errors.append(p.gpa, .{
	209	.DeclBetweenFields = .{ .token = tok },
214	210	});
215		continue;
	211	// continue parsing, error will be reported later
	212	field_state = .err;
216	213	},
217	214	}
218		};
219		if (try parseAppendedDocComment(arena, it, tree, comma)) \|appended_comment\|
220		field.doc_comments = appended_comment;
221		continue;
222		}
223	215
224		// Dangling doc comment
225		if (doc_comments != null) {
226		try tree.errors.push(.{
227		.UnattachedDocComment = .{ .token = doc_comments.?.firstToken() },
228		});
229		}
	216	const field = node.cast(Node.ContainerField).?;
	217	field.doc_comments = doc_comments;
	218	list_it = try p.llpush(*Node, list_it, node);
	219	const comma = p.eatToken(.Comma) orelse {
	220	// try to continue parsing
	221	const index = p.tok_i;
	222	p.findNextContainerMember();
	223	const next = p.tokens[p.tok_i].id;
	224	switch (next) {
	225	.Eof => break,
	226	else => {
	227	if (next == .RBrace) {
	228	if (!top_level) break;
	229	_ = p.nextToken();
	230	}
	231
	232	// add error and continue
	233	try p.errors.append(p.gpa, .{
	234	.ExpectedToken = .{ .token = index, .expected_id = .Comma },
	235	});
	236	continue;
	237	},
	238	}
	239	};
	240	if (try p.parseAppendedDocComment(comma)) \|appended_comment\|
	241	field.doc_comments = appended_comment;
	242	continue;
	243	}
230	244
231		const next = it.peek().?.id;
232		switch (next) {
233		.Eof => break,
234		.Keyword_comptime => {
235		_ = nextToken(it);
236		try tree.errors.push(.{
237		.ExpectedBlockOrField = .{ .token = it.index },
	245	// Dangling doc comment
	246	if (doc_comments != null) {
	247	try p.errors.append(p.gpa, .{
	248	.UnattachedDocComment = .{ .token = doc_comments.?.firstToken() },
238	249	});
239		},
240		else => {
241		const index = it.index;
242		if (next == .RBrace) {
243		if (!top_level) break;
244		_ = nextToken(it);
245		}
	250	}
246	251
247		// this was likely not supposed to end yet,
248		// try to find the next declaration
249		findNextContainerMember(it);
250		try tree.errors.push(.{
251		.ExpectedContainerMembers = .{ .token = index },
252		});
253		},
	252	const next = p.tokens[p.tok_i].id;
	253	switch (next) {
	254	.Eof => break,
	255	.Keyword_comptime => {
	256	_ = p.nextToken();
	257	try p.errors.append(p.gpa, .{
	258	.ExpectedBlockOrField = .{ .token = p.tok_i },
	259	});
	260	},
	261	else => {
	262	const index = p.tok_i;
	263	if (next == .RBrace) {
	264	if (!top_level) break;
	265	_ = p.nextToken();
	266	}
	267
	268	// this was likely not supposed to end yet,
	269	// try to find the next declaration
	270	p.findNextContainerMember();
	271	try p.errors.append(p.gpa, .{
	272	.ExpectedContainerMembers = .{ .token = index },
	273	});
	274	},
	275	}
254	276	}
255		}
256	277
257		return list;
258		}
	278	return list;
	279	}
259	280
260		/// Attempts to find next container member by searching for certain tokens
261		fn findNextContainerMember(it: *TokenIterator) void {
262		var level: u32 = 0;
263		while (true) {
264		const tok = nextToken(it);
265		switch (tok.ptr.id) {
266		// any of these can start a new top level declaration
267		.Keyword_test,
268		.Keyword_comptime,
269		.Keyword_pub,
270		.Keyword_export,
271		.Keyword_extern,
272		.Keyword_inline,
273		.Keyword_noinline,
274		.Keyword_usingnamespace,
275		.Keyword_threadlocal,
276		.Keyword_const,
277		.Keyword_var,
278		.Keyword_fn,
279		.Identifier,
280		=> {
281		if (level == 0) {
282		putBackToken(it, tok.index);
283		return;
284		}
285		},
286		.Comma, .Semicolon => {
287		// this decl was likely meant to end here
288		if (level == 0) {
289		return;
290		}
291		},
292		.LParen, .LBracket, .LBrace => level += 1,
293		.RParen, .RBracket => {
294		if (level != 0) level -= 1;
295		},
296		.RBrace => {
297		if (level == 0) {
298		// end of container, exit
299		putBackToken(it, tok.index);
	281	/// Attempts to find next container member by searching for certain tokens
	282	fn findNextContainerMember(p: *Parser) void {
	283	var level: u32 = 0;
	284	while (true) {
	285	const tok = p.nextToken();
	286	switch (tok.ptr.id) {
	287	// any of these can start a new top level declaration
	288	.Keyword_test,
	289	.Keyword_comptime,
	290	.Keyword_pub,
	291	.Keyword_export,
	292	.Keyword_extern,
	293	.Keyword_inline,
	294	.Keyword_noinline,
	295	.Keyword_usingnamespace,
	296	.Keyword_threadlocal,
	297	.Keyword_const,
	298	.Keyword_var,
	299	.Keyword_fn,
	300	.Identifier,
	301	=> {
	302	if (level == 0) {
	303	p.putBackToken(tok.index);
	304	return;
	305	}
	306	},
	307	.Comma, .Semicolon => {
	308	// this decl was likely meant to end here
	309	if (level == 0) {
	310	return;
	311	}
	312	},
	313	.LParen, .LBracket, .LBrace => level += 1,
	314	.RParen, .RBracket => {
	315	if (level != 0) level -= 1;
	316	},
	317	.RBrace => {
	318	if (level == 0) {
	319	// end of container, exit
	320	p.putBackToken(tok.index);
	321	return;
	322	}
	323	level -= 1;
	324	},
	325	.Eof => {
	326	p.putBackToken(tok.index);
300	327	return;
301		}
302		level -= 1;
303		},
304		.Eof => {
305		putBackToken(it, tok.index);
306		return;
307		},
308		else => {},
	328	},
	329	else => {},
	330	}
309	331	}
310	332	}
311		}
312	333
313		/// Attempts to find the next statement by searching for a semicolon
314		fn findNextStmt(it: *TokenIterator) void {
315		var level: u32 = 0;
316		while (true) {
317		const tok = nextToken(it);
318		switch (tok.ptr.id) {
319		.LBrace => level += 1,
320		.RBrace => {
321		if (level == 0) {
322		putBackToken(it, tok.index);
323		return;
324		}
325		level -= 1;
326		},
327		.Semicolon => {
328		if (level == 0) {
	334	/// Attempts to find the next statement by searching for a semicolon
	335	fn findNextStmt(p: *Parser) void {
	336	var level: u32 = 0;
	337	while (true) {
	338	const tok = p.nextToken();
	339	switch (tok.ptr.id) {
	340	.LBrace => level += 1,
	341	.RBrace => {
	342	if (level == 0) {
	343	p.putBackToken(tok.index);
	344	return;
	345	}
	346	level -= 1;
	347	},
	348	.Semicolon => {
	349	if (level == 0) {
	350	return;
	351	}
	352	},
	353	.Eof => {
	354	p.putBackToken(tok.index);
329	355	return;
330		}
331		},
332		.Eof => {
333		putBackToken(it, tok.index);
334		return;
335		},
336		else => {},
	356	},
	357	else => {},
	358	}
337	359	}
338	360	}
339		}
340
341		/// Eat a multiline container doc comment
342		fn parseContainerDocComments(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
343		var lines = Node.DocComment.LineList.init(arena);
344		while (eatToken(it, .ContainerDocComment)) \|line\| {
345		try lines.push(line);
346		}
347
348		if (lines.len == 0) return null;
349
350		const node = try arena.create(Node.DocComment);
351		node.* = .{
352		.lines = lines,
353		};
354		return &node.base;
355		}
356
357		/// TestDecl <- KEYWORD_test STRINGLITERALSINGLE Block
358		fn parseTestDecl(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
359		const test_token = eatToken(it, .Keyword_test) orelse return null;
360		const name_node = try expectNode(arena, it, tree, parseStringLiteralSingle, .{
361		.ExpectedStringLiteral = .{ .token = it.index },
362		});
363		const block_node = try expectNode(arena, it, tree, parseBlock, .{
364		.ExpectedLBrace = .{ .token = it.index },
365		});
366
367		const test_node = try arena.create(Node.TestDecl);
368		test_node.* = .{
369		.doc_comments = null,
370		.test_token = test_token,
371		.name = name_node,
372		.body_node = block_node,
373		};
374		return &test_node.base;
375		}
376
377		/// TopLevelComptime <- KEYWORD_comptime BlockExpr
378		fn parseTopLevelComptime(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
379		const tok = eatToken(it, .Keyword_comptime) orelse return null;
380		const lbrace = eatToken(it, .LBrace) orelse {
381		putBackToken(it, tok);
382		return null;
383		};
384		putBackToken(it, lbrace);
385		const block_node = try expectNode(arena, it, tree, parseBlockExpr, .{
386		.ExpectedLabelOrLBrace = .{ .token = it.index },
387		});
388
389		const comptime_node = try arena.create(Node.Comptime);
390		comptime_node.* = .{
391		.doc_comments = null,
392		.comptime_token = tok,
393		.expr = block_node,
394		};
395		return &comptime_node.base;
396		}
397	361
398		/// TopLevelDecl
399		/// <- (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE? / (KEYWORD_inline / KEYWORD_noinline))? FnProto (SEMICOLON / Block)
400		/// / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? VarDecl
401		/// / KEYWORD_usingnamespace Expr SEMICOLON
402		fn parseTopLevelDecl(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
403		var lib_name: ?*Node = null;
404		const extern_export_inline_token = blk: {
405		if (eatToken(it, .Keyword_export)) \|token\| break :blk token;
406		if (eatToken(it, .Keyword_extern)) \|token\| {
407		lib_name = try parseStringLiteralSingle(arena, it, tree);
408		break :blk token;
409		}
410		if (eatToken(it, .Keyword_inline)) \|token\| break :blk token;
411		if (eatToken(it, .Keyword_noinline)) \|token\| break :blk token;
412		break :blk null;
413		};
414
415		if (try parseFnProto(arena, it, tree)) \|node\| {
416		const fn_node = node.cast(Node.FnProto).?;
417		fn_node.*.extern_export_inline_token = extern_export_inline_token;
418		fn_node.*.lib_name = lib_name;
419		if (eatToken(it, .Semicolon)) \|_\| return node;
420
421		if (try expectNodeRecoverable(arena, it, tree, parseBlock, .{
422		// since parseBlock only return error.ParseError on
423		// a missing '}' we can assume this function was
424		// supposed to end here.
425		.ExpectedSemiOrLBrace = .{ .token = it.index },
426		})) \|body_node\| {
427		fn_node.body_node = body_node;
428		}
429		return node;
430		}
	362	/// Eat a multiline container doc comment
	363	fn parseContainerDocComments(p: Parser) !?Node {
	364	var lines = Node.DocComment.LineList{};
	365	var lines_it: ?Node.DocComment.LineList.Node = &lines.first;
431	366
432		if (extern_export_inline_token) \|token\| {
433		if (tree.tokens.at(token).id == .Keyword_inline or
434		tree.tokens.at(token).id == .Keyword_noinline)
435		{
436		try tree.errors.push(.{
437		.ExpectedFn = .{ .token = it.index },
438		});
439		return error.ParseError;
	367	while (p.eatToken(.ContainerDocComment)) \|line\| {
	368	lines_it = try p.llpush(TokenIndex, lines_it, line);
440	369	}
441		}
442	370
443		const thread_local_token = eatToken(it, .Keyword_threadlocal);
	371	if (lines.first == null) return null;
444	372
445		if (try parseVarDecl(arena, it, tree)) \|node\| {
446		var var_decl = node.cast(Node.VarDecl).?;
447		var_decl.*.thread_local_token = thread_local_token;
448		var_decl.*.comptime_token = null;
449		var_decl.*.extern_export_token = extern_export_inline_token;
450		var_decl.*.lib_name = lib_name;
451		return node;
	373	const node = try p.arena.allocator.create(Node.DocComment);
	374	node.* = .{
	375	.lines = lines,
	376	};
	377	return &node.base;
452	378	}
453	379
454		if (thread_local_token != null) {
455		try tree.errors.push(.{
456		.ExpectedVarDecl = .{ .token = it.index },
	380	/// TestDecl <- KEYWORD_test STRINGLITERALSINGLE Block
	381	fn parseTestDecl(p: Parser) !?Node {
	382	const test_token = p.eatToken(.Keyword_test) orelse return null;
	383	const name_node = try p.expectNode(parseStringLiteralSingle, .{
	384	.ExpectedStringLiteral = .{ .token = p.tok_i },
457	385	});
458		// ignore this and try again;
459		return error.ParseError;
460		}
461
462		if (extern_export_inline_token) \|token\| {
463		try tree.errors.push(.{
464		.ExpectedVarDeclOrFn = .{ .token = it.index },
	386	const block_node = try p.expectNode(parseBlock, .{
	387	.ExpectedLBrace = .{ .token = p.tok_i },
465	388	});
466		// ignore this and try again;
467		return error.ParseError;
	389
	390	const test_node = try p.arena.allocator.create(Node.TestDecl);
	391	test_node.* = .{
	392	.doc_comments = null,
	393	.test_token = test_token,
	394	.name = name_node,
	395	.body_node = block_node,
	396	};
	397	return &test_node.base;
468	398	}
469	399
470		return try parseUse(arena, it, tree);
471		}
	400	/// TopLevelComptime <- KEYWORD_comptime BlockExpr
	401	fn parseTopLevelComptime(p: Parser) !?Node {
	402	const tok = p.eatToken(.Keyword_comptime) orelse return null;
	403	const lbrace = p.eatToken(.LBrace) orelse {
	404	p.putBackToken(tok);
	405	return null;
	406	};
	407	p.putBackToken(lbrace);
	408	const block_node = try p.expectNode(parseBlockExpr, .{
	409	.ExpectedLabelOrLBrace = .{ .token = p.tok_i },
	410	});
472	411
473		/// FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? LinkSection? EXCLAMATIONMARK? (KEYWORD_var / TypeExpr)
474		fn parseFnProto(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
475		// TODO: Remove once extern/async fn rewriting is
476		var is_async = false;
477		var is_extern = false;
478		const cc_token: ?usize = blk: {
479		if (eatToken(it, .Keyword_extern)) \|token\| {
480		is_extern = true;
481		break :blk token;
482		}
483		if (eatToken(it, .Keyword_async)) \|token\| {
484		is_async = true;
485		break :blk token;
486		}
487		break :blk null;
488		};
489		const fn_token = eatToken(it, .Keyword_fn) orelse {
490		if (cc_token) \|token\|
491		putBackToken(it, token);
492		return null;
493		};
494		const name_token = eatToken(it, .Identifier);
495		const lparen = try expectToken(it, tree, .LParen);
496		const params = try parseParamDeclList(arena, it, tree);
497		const rparen = try expectToken(it, tree, .RParen);
498		const align_expr = try parseByteAlign(arena, it, tree);
499		const section_expr = try parseLinkSection(arena, it, tree);
500		const callconv_expr = try parseCallconv(arena, it, tree);
501		const exclamation_token = eatToken(it, .Bang);
502
503		const return_type_expr = (try parseVarType(arena, it, tree)) orelse
504		try expectNodeRecoverable(arena, it, tree, parseTypeExpr, .{
505		// most likely the user forgot to specify the return type.
506		// Mark return type as invalid and try to continue.
507		.ExpectedReturnType = .{ .token = it.index },
508		});
509
510		// TODO https://github.com/ziglang/zig/issues/3750
511		const R = Node.FnProto.ReturnType;
512		const return_type = if (return_type_expr == null)
513		R{ .Invalid = rparen }
514		else if (exclamation_token != null)
515		R{ .InferErrorSet = return_type_expr.? }
516		else
517		R{ .Explicit = return_type_expr.? };
518
519		const var_args_token = if (params.len > 0) blk: {
520		const param_type = params.at(params.len - 1).*.cast(Node.ParamDecl).?.param_type;
521		break :blk if (param_type == .var_args) param_type.var_args else null;
522		} else
523		null;
524
525		const fn_proto_node = try arena.create(Node.FnProto);
526		fn_proto_node.* = .{
527		.doc_comments = null,
528		.visib_token = null,
529		.fn_token = fn_token,
530		.name_token = name_token,
531		.params = params,
532		.return_type = return_type,
533		.var_args_token = var_args_token,
534		.extern_export_inline_token = null,
535		.body_node = null,
536		.lib_name = null,
537		.align_expr = align_expr,
538		.section_expr = section_expr,
539		.callconv_expr = callconv_expr,
540		.is_extern_prototype = is_extern,
541		.is_async = is_async,
542		};
	412	const comptime_node = try p.arena.allocator.create(Node.Comptime);
	413	comptime_node.* = .{
	414	.doc_comments = null,
	415	.comptime_token = tok,
	416	.expr = block_node,
	417	};
	418	return &comptime_node.base;
	419	}
	420
	421	/// TopLevelDecl
	422	/// <- (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE? / (KEYWORD_inline / KEYWORD_noinline))? FnProto (SEMICOLON / Block)
	423	/// / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? VarDecl
	424	/// / KEYWORD_usingnamespace Expr SEMICOLON
	425	fn parseTopLevelDecl(p: Parser) !?Node {
	426	var lib_name: ?*Node = null;
	427	const extern_export_inline_token = blk: {
	428	if (p.eatToken(.Keyword_export)) \|token\| break :blk token;
	429	if (p.eatToken(.Keyword_extern)) \|token\| {
	430	lib_name = try p.parseStringLiteralSingle();
	431	break :blk token;
	432	}
	433	if (p.eatToken(.Keyword_inline)) \|token\| break :blk token;
	434	if (p.eatToken(.Keyword_noinline)) \|token\| break :blk token;
	435	break :blk null;
	436	};
543	437
544		return &fn_proto_node.base;
545		}
	438	if (try p.parseFnProto()) \|node\| {
	439	const fn_node = node.cast(Node.FnProto).?;
	440	fn_node.*.extern_export_inline_token = extern_export_inline_token;
	441	fn_node.*.lib_name = lib_name;
	442	if (p.eatToken(.Semicolon)) \|_\| return node;
	443
	444	if (try p.expectNodeRecoverable(parseBlock, .{
	445	// since parseBlock only return error.ParseError on
	446	// a missing '}' we can assume this function was
	447	// supposed to end here.
	448	.ExpectedSemiOrLBrace = .{ .token = p.tok_i },
	449	})) \|body_node\| {
	450	fn_node.body_node = body_node;
	451	}
	452	return node;
	453	}
546	454
547		/// VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? LinkSection? (EQUAL Expr)? SEMICOLON
548		fn parseVarDecl(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
549		const mut_token = eatToken(it, .Keyword_const) orelse
550		eatToken(it, .Keyword_var) orelse
551		return null;
	455	if (extern_export_inline_token) \|token\| {
	456	if (p.tokens[token].id == .Keyword_inline or
	457	p.tokens[token].id == .Keyword_noinline)
	458	{
	459	try p.errors.append(p.gpa, .{
	460	.ExpectedFn = .{ .token = p.tok_i },
	461	});
	462	return error.ParseError;
	463	}
	464	}
552	465
553		const name_token = try expectToken(it, tree, .Identifier);
554		const type_node = if (eatToken(it, .Colon) != null)
555		try expectNode(arena, it, tree, parseTypeExpr, .{
556		.ExpectedTypeExpr = .{ .token = it.index },
557		})
558		else
559		null;
560		const align_node = try parseByteAlign(arena, it, tree);
561		const section_node = try parseLinkSection(arena, it, tree);
562		const eq_token = eatToken(it, .Equal);
563		const init_node = if (eq_token != null) blk: {
564		break :blk try expectNode(arena, it, tree, parseExpr, .{
565		.ExpectedExpr = .{ .token = it.index },
566		});
567		} else null;
568		const semicolon_token = try expectToken(it, tree, .Semicolon);
569
570		const node = try arena.create(Node.VarDecl);
571		node.* = .{
572		.doc_comments = null,
573		.visib_token = null,
574		.thread_local_token = null,
575		.name_token = name_token,
576		.eq_token = eq_token,
577		.mut_token = mut_token,
578		.comptime_token = null,
579		.extern_export_token = null,
580		.lib_name = null,
581		.type_node = type_node,
582		.align_node = align_node,
583		.section_node = section_node,
584		.init_node = init_node,
585		.semicolon_token = semicolon_token,
586		};
587		return &node.base;
588		}
	466	const thread_local_token = p.eatToken(.Keyword_threadlocal);
589	467
590		/// ContainerField <- KEYWORD_comptime? IDENTIFIER (COLON TypeExpr ByteAlign?)? (EQUAL Expr)?
591		fn parseContainerField(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
592		const comptime_token = eatToken(it, .Keyword_comptime);
593		const name_token = eatToken(it, .Identifier) orelse {
594		if (comptime_token) \|t\| putBackToken(it, t);
595		return null;
596		};
	468	if (try p.parseVarDecl()) \|node\| {
	469	var var_decl = node.cast(Node.VarDecl).?;
	470	var_decl.*.thread_local_token = thread_local_token;
	471	var_decl.*.comptime_token = null;
	472	var_decl.*.extern_export_token = extern_export_inline_token;
	473	var_decl.*.lib_name = lib_name;
	474	return node;
	475	}
597	476
598		var align_expr: ?*Node = null;
599		var type_expr: ?*Node = null;
600		if (eatToken(it, .Colon)) \|_\| {
601		if (eatToken(it, .Keyword_var)) \|var_tok\| {
602		const node = try arena.create(ast.Node.VarType);
603		node.* = .{ .token = var_tok };
604		type_expr = &node.base;
605		} else {
606		type_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
607		.ExpectedTypeExpr = .{ .token = it.index },
	477	if (thread_local_token != null) {
	478	try p.errors.append(p.gpa, .{
	479	.ExpectedVarDecl = .{ .token = p.tok_i },
608	480	});
609		align_expr = try parseByteAlign(arena, it, tree);
	481	// ignore this and try again;
	482	return error.ParseError;
610	483	}
611		}
612
613		const value_expr = if (eatToken(it, .Equal)) \|_\|
614		try expectNode(arena, it, tree, parseExpr, .{
615		.ExpectedExpr = .{ .token = it.index },
616		})
617		else
618		null;
619	484
620		const node = try arena.create(Node.ContainerField);
621		node.* = .{
622		.doc_comments = null,
623		.comptime_token = comptime_token,
624		.name_token = name_token,
625		.type_expr = type_expr,
626		.value_expr = value_expr,
627		.align_expr = align_expr,
628		};
629		return &node.base;
630		}
	485	if (extern_export_inline_token) \|token\| {
	486	try p.errors.append(p.gpa, .{
	487	.ExpectedVarDeclOrFn = .{ .token = p.tok_i },
	488	});
	489	// ignore this and try again;
	490	return error.ParseError;
	491	}
631	492
632		/// Statement
633		/// <- KEYWORD_comptime? VarDecl
634		/// / KEYWORD_comptime BlockExprStatement
635		/// / KEYWORD_nosuspend BlockExprStatement
636		/// / KEYWORD_suspend (SEMICOLON / BlockExprStatement)
637		/// / KEYWORD_defer BlockExprStatement
638		/// / KEYWORD_errdefer Payload? BlockExprStatement
639		/// / IfStatement
640		/// / LabeledStatement
641		/// / SwitchExpr
642		/// / AssignExpr SEMICOLON
643		fn parseStatement(arena: Allocator, it: TokenIterator, tree: Tree) Error!?Node {
644		const comptime_token = eatToken(it, .Keyword_comptime);
645
646		const var_decl_node = try parseVarDecl(arena, it, tree);
647		if (var_decl_node) \|node\| {
648		const var_decl = node.cast(Node.VarDecl).?;
649		var_decl.comptime_token = comptime_token;
650		return node;
	493	return p.parseUse();
651	494	}
652	495
653		if (comptime_token) \|token\| {
654		const block_expr = try expectNode(arena, it, tree, parseBlockExprStatement, .{
655		.ExpectedBlockOrAssignment = .{ .token = it.index },
	496	/// FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? LinkSection? EXCLAMATIONMARK? (KEYWORD_var / TypeExpr)
	497	fn parseFnProto(p: Parser) !?Node {
	498	// TODO: Remove once extern/async fn rewriting is
	499	var is_async = false;
	500	var is_extern = false;
	501	const cc_token: ?TokenIndex = blk: {
	502	if (p.eatToken(.Keyword_extern)) \|token\| {
	503	is_extern = true;
	504	break :blk token;
	505	}
	506	if (p.eatToken(.Keyword_async)) \|token\| {
	507	is_async = true;
	508	break :blk token;
	509	}
	510	break :blk null;
	511	};
	512	const fn_token = p.eatToken(.Keyword_fn) orelse {
	513	if (cc_token) \|token\|
	514	p.putBackToken(token);
	515	return null;
	516	};
	517	var var_args_token: ?TokenIndex = null;
	518	const name_token = p.eatToken(.Identifier);
	519	const lparen = try p.expectToken(.LParen);
	520	const params = try p.parseParamDeclList(&var_args_token);
	521	const rparen = try p.expectToken(.RParen);
	522	const align_expr = try p.parseByteAlign();
	523	const section_expr = try p.parseLinkSection();
	524	const callconv_expr = try p.parseCallconv();
	525	const exclamation_token = p.eatToken(.Bang);
	526
	527	const return_type_expr = (try p.parseVarType()) orelse
	528	try p.expectNodeRecoverable(parseTypeExpr, .{
	529	// most likely the user forgot to specify the return type.
	530	// Mark return type as invalid and try to continue.
	531	.ExpectedReturnType = .{ .token = p.tok_i },
656	532	});
657	533
658		const node = try arena.create(Node.Comptime);
659		node.* = .{
	534	// TODO https://github.com/ziglang/zig/issues/3750
	535	const R = Node.FnProto.ReturnType;
	536	const return_type = if (return_type_expr == null)
	537	R{ .Invalid = rparen }
	538	else if (exclamation_token != null)
	539	R{ .InferErrorSet = return_type_expr.? }
	540	else
	541	R{ .Explicit = return_type_expr.? };
	542
	543	const fn_proto_node = try p.arena.allocator.create(Node.FnProto);
	544	fn_proto_node.* = .{
660	545	.doc_comments = null,
661		.comptime_token = token,
662		.expr = block_expr,
	546	.visib_token = null,
	547	.fn_token = fn_token,
	548	.name_token = name_token,
	549	.params = params,
	550	.return_type = return_type,
	551	.var_args_token = var_args_token,
	552	.extern_export_inline_token = null,
	553	.body_node = null,
	554	.lib_name = null,
	555	.align_expr = align_expr,
	556	.section_expr = section_expr,
	557	.callconv_expr = callconv_expr,
	558	.is_extern_prototype = is_extern,
	559	.is_async = is_async,
663	560	};
664		return &node.base;
665		}
666
667		if (eatToken(it, .Keyword_nosuspend)) \|nosuspend_token\| {
668		const block_expr = try expectNode(arena, it, tree, parseBlockExprStatement, .{
669		.ExpectedBlockOrAssignment = .{ .token = it.index },
670		});
671	561
672		const node = try arena.create(Node.Nosuspend);
673		node.* = .{
674		.nosuspend_token = nosuspend_token,
675		.expr = block_expr,
676		};
677		return &node.base;
	562	return &fn_proto_node.base;
678	563	}
679	564
680		if (eatToken(it, .Keyword_suspend)) \|suspend_token\| {
681		const semicolon = eatToken(it, .Semicolon);
	565	/// VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? LinkSection? (EQUAL Expr)? SEMICOLON
	566	fn parseVarDecl(p: Parser) !?Node {
	567	const mut_token = p.eatToken(.Keyword_const) orelse
	568	p.eatToken(.Keyword_var) orelse
	569	return null;
682	570
683		const body_node = if (semicolon == null) blk: {
684		break :blk try expectNode(arena, it, tree, parseBlockExprStatement, .{
685		.ExpectedBlockOrExpression = .{ .token = it.index },
	571	const name_token = try p.expectToken(.Identifier);
	572	const type_node = if (p.eatToken(.Colon) != null)
	573	try p.expectNode(parseTypeExpr, .{
	574	.ExpectedTypeExpr = .{ .token = p.tok_i },
	575	})
	576	else
	577	null;
	578	const align_node = try p.parseByteAlign();
	579	const section_node = try p.parseLinkSection();
	580	const eq_token = p.eatToken(.Equal);
	581	const init_node = if (eq_token != null) blk: {
	582	break :blk try p.expectNode(parseExpr, .{
	583	.ExpectedExpr = .{ .token = p.tok_i },
686	584	});
687	585	} else null;
	586	const semicolon_token = try p.expectToken(.Semicolon);
688	587
689		const node = try arena.create(Node.Suspend);
	588	const node = try p.arena.allocator.create(Node.VarDecl);
690	589	node.* = .{
691		.suspend_token = suspend_token,
692		.body = body_node,
	590	.doc_comments = null,
	591	.visib_token = null,
	592	.thread_local_token = null,
	593	.name_token = name_token,
	594	.eq_token = eq_token,
	595	.mut_token = mut_token,
	596	.comptime_token = null,
	597	.extern_export_token = null,
	598	.lib_name = null,
	599	.type_node = type_node,
	600	.align_node = align_node,
	601	.section_node = section_node,
	602	.init_node = init_node,
	603	.semicolon_token = semicolon_token,
693	604	};
694	605	return &node.base;
695	606	}
696	607
697		const defer_token = eatToken(it, .Keyword_defer) orelse eatToken(it, .Keyword_errdefer);
698		if (defer_token) \|token\| {
699		const payload = if (tree.tokens.at(token).id == .Keyword_errdefer)
700		try parsePayload(arena, it, tree)
	608	/// ContainerField <- KEYWORD_comptime? IDENTIFIER (COLON TypeExpr ByteAlign?)? (EQUAL Expr)?
	609	fn parseContainerField(p: Parser) !?Node {
	610	const comptime_token = p.eatToken(.Keyword_comptime);
	611	const name_token = p.eatToken(.Identifier) orelse {
	612	if (comptime_token) \|t\| p.putBackToken(t);
	613	return null;
	614	};
	615
	616	var align_expr: ?*Node = null;
	617	var type_expr: ?*Node = null;
	618	if (p.eatToken(.Colon)) \|_\| {
	619	if (p.eatToken(.Keyword_var)) \|var_tok\| {
	620	const node = try p.arena.allocator.create(ast.Node.VarType);
	621	node.* = .{ .token = var_tok };
	622	type_expr = &node.base;
	623	} else {
	624	type_expr = try p.expectNode(parseTypeExpr, .{
	625	.ExpectedTypeExpr = .{ .token = p.tok_i },
	626	});
	627	align_expr = try p.parseByteAlign();
	628	}
	629	}
	630
	631	const value_expr = if (p.eatToken(.Equal)) \|_\|
	632	try p.expectNode(parseExpr, .{
	633	.ExpectedExpr = .{ .token = p.tok_i },
	634	})
701	635	else
702	636	null;
703		const expr_node = try expectNode(arena, it, tree, parseBlockExprStatement, .{
704		.ExpectedBlockOrExpression = .{ .token = it.index },
705		});
706		const node = try arena.create(Node.Defer);
	637
	638	const node = try p.arena.allocator.create(Node.ContainerField);
707	639	node.* = .{
708		.defer_token = token,
709		.expr = expr_node,
710		.payload = payload,
	640	.doc_comments = null,
	641	.comptime_token = comptime_token,
	642	.name_token = name_token,
	643	.type_expr = type_expr,
	644	.value_expr = value_expr,
	645	.align_expr = align_expr,
711	646	};
712	647	return &node.base;
713	648	}
714	649
715		if (try parseIfStatement(arena, it, tree)) \|node\| return node;
716		if (try parseLabeledStatement(arena, it, tree)) \|node\| return node;
717		if (try parseSwitchExpr(arena, it, tree)) \|node\| return node;
718		if (try parseAssignExpr(arena, it, tree)) \|node\| {
719		_ = try expectTokenRecoverable(it, tree, .Semicolon);
720		return node;
721		}
722
723		return null;
724		}
725
726		/// IfStatement
727		/// <- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
728		/// / IfPrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
729		fn parseIfStatement(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
730		const if_node = (try parseIfPrefix(arena, it, tree)) orelse return null;
731		const if_prefix = if_node.cast(Node.If).?;
732
733		const block_expr = (try parseBlockExpr(arena, it, tree));
734		const assign_expr = if (block_expr == null)
735		try expectNode(arena, it, tree, parseAssignExpr, .{
736		.ExpectedBlockOrAssignment = .{ .token = it.index },
737		})
738		else
739		null;
740
741		const semicolon = if (assign_expr != null) eatToken(it, .Semicolon) else null;
742
743		const else_node = if (semicolon == null) blk: {
744		const else_token = eatToken(it, .Keyword_else) orelse break :blk null;
745		const payload = try parsePayload(arena, it, tree);
746		const else_body = try expectNode(arena, it, tree, parseStatement, .{
747		.InvalidToken = .{ .token = it.index },
748		});
	650	/// Statement
	651	/// <- KEYWORD_comptime? VarDecl
	652	/// / KEYWORD_comptime BlockExprStatement
	653	/// / KEYWORD_nosuspend BlockExprStatement
	654	/// / KEYWORD_suspend (SEMICOLON / BlockExprStatement)
	655	/// / KEYWORD_defer BlockExprStatement
	656	/// / KEYWORD_errdefer Payload? BlockExprStatement
	657	/// / IfStatement
	658	/// / LabeledStatement
	659	/// / SwitchExpr
	660	/// / AssignExpr SEMICOLON
	661	fn parseStatement(p: Parser) Error!?Node {
	662	const comptime_token = p.eatToken(.Keyword_comptime);
	663
	664	const var_decl_node = try p.parseVarDecl();
	665	if (var_decl_node) \|node\| {
	666	const var_decl = node.cast(Node.VarDecl).?;
	667	var_decl.comptime_token = comptime_token;
	668	return node;
	669	}
749	670
750		const node = try arena.create(Node.Else);
751		node.* = .{
752		.else_token = else_token,
753		.payload = payload,
754		.body = else_body,
755		};
	671	if (comptime_token) \|token\| {
	672	const block_expr = try p.expectNode(parseBlockExprStatement, .{
	673	.ExpectedBlockOrAssignment = .{ .token = p.tok_i },
	674	});
756	675
757		break :blk node;
758		} else null;
	676	const node = try p.arena.allocator.create(Node.Comptime);
	677	node.* = .{
	678	.doc_comments = null,
	679	.comptime_token = token,
	680	.expr = block_expr,
	681	};
	682	return &node.base;
	683	}
759	684
760		if (block_expr) \|body\| {
761		if_prefix.body = body;
762		if_prefix.@"else" = else_node;
763		return if_node;
764		}
	685	if (p.eatToken(.Keyword_nosuspend)) \|nosuspend_token\| {
	686	const block_expr = try p.expectNode(parseBlockExprStatement, .{
	687	.ExpectedBlockOrAssignment = .{ .token = p.tok_i },
	688	});
765	689
766		if (assign_expr) \|body\| {
767		if_prefix.body = body;
768		if (semicolon != null) return if_node;
769		if (else_node != null) {
770		if_prefix.@"else" = else_node;
771		return if_node;
	690	const node = try p.arena.allocator.create(Node.Nosuspend);
	691	node.* = .{
	692	.nosuspend_token = nosuspend_token,
	693	.expr = block_expr,
	694	};
	695	return &node.base;
772	696	}
773		try tree.errors.push(.{
774		.ExpectedSemiOrElse = .{ .token = it.index },
775		});
776		}
777
778		return if_node;
779		}
780	697
781		/// LabeledStatement <- BlockLabel? (Block / LoopStatement)
782		fn parseLabeledStatement(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
783		var colon: TokenIndex = undefined;
784		const label_token = parseBlockLabel(arena, it, tree, &colon);
	698	if (p.eatToken(.Keyword_suspend)) \|suspend_token\| {
	699	const semicolon = p.eatToken(.Semicolon);
785	700
786		if (try parseBlock(arena, it, tree)) \|node\| {
787		node.cast(Node.Block).?.label = label_token;
788		return node;
789		}
	701	const body_node = if (semicolon == null) blk: {
	702	break :blk try p.expectNode(parseBlockExprStatement, .{
	703	.ExpectedBlockOrExpression = .{ .token = p.tok_i },
	704	});
	705	} else null;
790	706
791		if (try parseLoopStatement(arena, it, tree)) \|node\| {
792		if (node.cast(Node.For)) \|for_node\| {
793		for_node.label = label_token;
794		} else if (node.cast(Node.While)) \|while_node\| {
795		while_node.label = label_token;
796		} else unreachable;
797		return node;
798		}
799
800		if (label_token != null) {
801		try tree.errors.push(.{
802		.ExpectedLabelable = .{ .token = it.index },
803		});
804		return error.ParseError;
805		}
806
807		return null;
808		}
	707	const node = try p.arena.allocator.create(Node.Suspend);
	708	node.* = .{
	709	.suspend_token = suspend_token,
	710	.body = body_node,
	711	};
	712	return &node.base;
	713	}
809	714
810		/// LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
811		fn parseLoopStatement(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
812		const inline_token = eatToken(it, .Keyword_inline);
	715	const defer_token = p.eatToken(.Keyword_defer) orelse p.eatToken(.Keyword_errdefer);
	716	if (defer_token) \|token\| {
	717	const payload = if (p.tokens[token].id == .Keyword_errdefer)
	718	try p.parsePayload()
	719	else
	720	null;
	721	const expr_node = try p.expectNode(parseBlockExprStatement, .{
	722	.ExpectedBlockOrExpression = .{ .token = p.tok_i },
	723	});
	724	const node = try p.arena.allocator.create(Node.Defer);
	725	node.* = .{
	726	.defer_token = token,
	727	.expr = expr_node,
	728	.payload = payload,
	729	};
	730	return &node.base;
	731	}
813	732
814		if (try parseForStatement(arena, it, tree)) \|node\| {
815		node.cast(Node.For).?.inline_token = inline_token;
816		return node;
817		}
	733	if (try p.parseIfStatement()) \|node\| return node;
	734	if (try p.parseLabeledStatement()) \|node\| return node;
	735	if (try p.parseSwitchExpr()) \|node\| return node;
	736	if (try p.parseAssignExpr()) \|node\| {
	737	_ = try p.expectTokenRecoverable(.Semicolon);
	738	return node;
	739	}
818	740
819		if (try parseWhileStatement(arena, it, tree)) \|node\| {
820		node.cast(Node.While).?.inline_token = inline_token;
821		return node;
	741	return null;
822	742	}
823		if (inline_token == null) return null;
824	743
825		// If we've seen "inline", there should have been a "for" or "while"
826		try tree.errors.push(.{
827		.ExpectedInlinable = .{ .token = it.index },
828		});
829		return error.ParseError;
830		}
	744	/// IfStatement
	745	/// <- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
	746	/// / IfPrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
	747	fn parseIfStatement(p: Parser) !?Node {
	748	const if_node = (try p.parseIfPrefix()) orelse return null;
	749	const if_prefix = if_node.cast(Node.If).?;
831	750
832		/// ForStatement
833		/// <- ForPrefix BlockExpr ( KEYWORD_else Statement )?
834		/// / ForPrefix AssignExpr ( SEMICOLON / KEYWORD_else Statement )
835		fn parseForStatement(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
836		const node = (try parseForPrefix(arena, it, tree)) orelse return null;
837		const for_prefix = node.cast(Node.For).?;
	751	const block_expr = (try p.parseBlockExpr());
	752	const assign_expr = if (block_expr == null)
	753	try p.expectNode(parseAssignExpr, .{
	754	.ExpectedBlockOrAssignment = .{ .token = p.tok_i },
	755	})
	756	else
	757	null;
838	758
839		if (try parseBlockExpr(arena, it, tree)) \|block_expr_node\| {
840		for_prefix.body = block_expr_node;
	759	const semicolon = if (assign_expr != null) p.eatToken(.Semicolon) else null;
841	760
842		if (eatToken(it, .Keyword_else)) \|else_token\| {
843		const statement_node = try expectNode(arena, it, tree, parseStatement, .{
844		.InvalidToken = .{ .token = it.index },
	761	const else_node = if (semicolon == null) blk: {
	762	const else_token = p.eatToken(.Keyword_else) orelse break :blk null;
	763	const payload = try p.parsePayload();
	764	const else_body = try p.expectNode(parseStatement, .{
	765	.InvalidToken = .{ .token = p.tok_i },
845	766	});
846	767
847		const else_node = try arena.create(Node.Else);
848		else_node.* = .{
	768	const node = try p.arena.allocator.create(Node.Else);
	769	node.* = .{
849	770	.else_token = else_token,
850		.payload = null,
851		.body = statement_node,
	771	.payload = payload,
	772	.body = else_body,
852	773	};
853		for_prefix.@"else" = else_node;
854	774
855		return node;
	775	break :blk node;
	776	} else null;
	777
	778	if (block_expr) \|body\| {
	779	if_prefix.body = body;
	780	if_prefix.@"else" = else_node;
	781	return if_node;
856	782	}
857	783
858		return node;
	784	if (assign_expr) \|body\| {
	785	if_prefix.body = body;
	786	if (semicolon != null) return if_node;
	787	if (else_node != null) {
	788	if_prefix.@"else" = else_node;
	789	return if_node;
	790	}
	791	try p.errors.append(p.gpa, .{
	792	.ExpectedSemiOrElse = .{ .token = p.tok_i },
	793	});
	794	}
	795
	796	return if_node;
859	797	}
860	798
861		if (try parseAssignExpr(arena, it, tree)) \|assign_expr\| {
862		for_prefix.body = assign_expr;
	799	/// LabeledStatement <- BlockLabel? (Block / LoopStatement)
	800	fn parseLabeledStatement(p: Parser) !?Node {
	801	var colon: TokenIndex = undefined;
	802	const label_token = p.parseBlockLabel(&colon);
	803
	804	if (try p.parseBlock()) \|node\| {
	805	node.cast(Node.Block).?.label = label_token;
	806	return node;
	807	}
863	808
864		if (eatToken(it, .Semicolon) != null) return node;
	809	if (try p.parseLoopStatement()) \|node\| {
	810	if (node.cast(Node.For)) \|for_node\| {
	811	for_node.label = label_token;
	812	} else if (node.cast(Node.While)) \|while_node\| {
	813	while_node.label = label_token;
	814	} else unreachable;
	815	return node;
	816	}
865	817
866		if (eatToken(it, .Keyword_else)) \|else_token\| {
867		const statement_node = try expectNode(arena, it, tree, parseStatement, .{
868		.ExpectedStatement = .{ .token = it.index },
	818	if (label_token != null) {
	819	try p.errors.append(p.gpa, .{
	820	.ExpectedLabelable = .{ .token = p.tok_i },
869	821	});
	822	return error.ParseError;
	823	}
870	824
871		const else_node = try arena.create(Node.Else);
872		else_node.* = .{
873		.else_token = else_token,
874		.payload = null,
875		.body = statement_node,
876		};
877		for_prefix.@"else" = else_node;
	825	return null;
	826	}
	827
	828	/// LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
	829	fn parseLoopStatement(p: Parser) !?Node {
	830	const inline_token = p.eatToken(.Keyword_inline);
	831
	832	if (try p.parseForStatement()) \|node\| {
	833	node.cast(Node.For).?.inline_token = inline_token;
878	834	return node;
879	835	}
880	836
881		try tree.errors.push(.{
882		.ExpectedSemiOrElse = .{ .token = it.index },
883		});
	837	if (try p.parseWhileStatement()) \|node\| {
	838	node.cast(Node.While).?.inline_token = inline_token;
	839	return node;
	840	}
	841	if (inline_token == null) return null;
884	842
885		return node;
	843	// If we've seen "inline", there should have been a "for" or "while"
	844	try p.errors.append(p.gpa, .{
	845	.ExpectedInlinable = .{ .token = p.tok_i },
	846	});
	847	return error.ParseError;
886	848	}
887	849
888		return null;
889		}
890
891		/// WhileStatement
892		/// <- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
893		/// / WhilePrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
894		fn parseWhileStatement(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
895		const node = (try parseWhilePrefix(arena, it, tree)) orelse return null;
896		const while_prefix = node.cast(Node.While).?;
	850	/// ForStatement
	851	/// <- ForPrefix BlockExpr ( KEYWORD_else Statement )?
	852	/// / ForPrefix AssignExpr ( SEMICOLON / KEYWORD_else Statement )
	853	fn parseForStatement(p: Parser) !?Node {
	854	const node = (try p.parseForPrefix()) orelse return null;
	855	const for_prefix = node.cast(Node.For).?;
897	856
898		if (try parseBlockExpr(arena, it, tree)) \|block_expr_node\| {
899		while_prefix.body = block_expr_node;
	857	if (try p.parseBlockExpr()) \|block_expr_node\| {
	858	for_prefix.body = block_expr_node;
900	859
901		if (eatToken(it, .Keyword_else)) \|else_token\| {
902		const payload = try parsePayload(arena, it, tree);
	860	if (p.eatToken(.Keyword_else)) \|else_token\| {
	861	const statement_node = try p.expectNode(parseStatement, .{
	862	.InvalidToken = .{ .token = p.tok_i },
	863	});
903	864
904		const statement_node = try expectNode(arena, it, tree, parseStatement, .{
905		.InvalidToken = .{ .token = it.index },
906		});
	865	const else_node = try p.arena.allocator.create(Node.Else);
	866	else_node.* = .{
	867	.else_token = else_token,
	868	.payload = null,
	869	.body = statement_node,
	870	};
	871	for_prefix.@"else" = else_node;
907	872
908		const else_node = try arena.create(Node.Else);
909		else_node.* = .{
910		.else_token = else_token,
911		.payload = payload,
912		.body = statement_node,
913		};
914		while_prefix.@"else" = else_node;
	873	return node;
	874	}
915	875
916	876	return node;
917	877	}
918	878
919		return node;
920		}
	879	if (try p.parseAssignExpr()) \|assign_expr\| {
	880	for_prefix.body = assign_expr;
921	881
922		if (try parseAssignExpr(arena, it, tree)) \|assign_expr_node\| {
923		while_prefix.body = assign_expr_node;
	882	if (p.eatToken(.Semicolon) != null) return node;
924	883
925		if (eatToken(it, .Semicolon) != null) return node;
	884	if (p.eatToken(.Keyword_else)) \|else_token\| {
	885	const statement_node = try p.expectNode(parseStatement, .{
	886	.ExpectedStatement = .{ .token = p.tok_i },
	887	});
926	888
927		if (eatToken(it, .Keyword_else)) \|else_token\| {
928		const payload = try parsePayload(arena, it, tree);
	889	const else_node = try p.arena.allocator.create(Node.Else);
	890	else_node.* = .{
	891	.else_token = else_token,
	892	.payload = null,
	893	.body = statement_node,
	894	};
	895	for_prefix.@"else" = else_node;
	896	return node;
	897	}
929	898
930		const statement_node = try expectNode(arena, it, tree, parseStatement, .{
931		.ExpectedStatement = .{ .token = it.index },
	899	try p.errors.append(p.gpa, .{
	900	.ExpectedSemiOrElse = .{ .token = p.tok_i },
932	901	});
933	902
934		const else_node = try arena.create(Node.Else);
935		else_node.* = .{
936		.else_token = else_token,
937		.payload = payload,
938		.body = statement_node,
939		};
940		while_prefix.@"else" = else_node;
941	903	return node;
942	904	}
943	905
944		try tree.errors.push(.{
945		.ExpectedSemiOrElse = .{ .token = it.index },
946		});
947
948		return node;
	906	return null;
949	907	}
950	908
951		return null;
952		}
	909	/// WhileStatement
	910	/// <- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
	911	/// / WhilePrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
	912	fn parseWhileStatement(p: Parser) !?Node {
	913	const node = (try p.parseWhilePrefix()) orelse return null;
	914	const while_prefix = node.cast(Node.While).?;
953	915
954		/// BlockExprStatement
955		/// <- BlockExpr
956		/// / AssignExpr SEMICOLON
957		fn parseBlockExprStatement(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
958		if (try parseBlockExpr(arena, it, tree)) \|node\| return node;
959		if (try parseAssignExpr(arena, it, tree)) \|node\| {
960		_ = try expectTokenRecoverable(it, tree, .Semicolon);
961		return node;
962		}
963		return null;
964		}
	916	if (try p.parseBlockExpr()) \|block_expr_node\| {
	917	while_prefix.body = block_expr_node;
965	918
966		/// BlockExpr <- BlockLabel? Block
967		fn parseBlockExpr(arena: Allocator, it: TokenIterator, tree: Tree) Error!?Node {
968		var colon: TokenIndex = undefined;
969		const label_token = parseBlockLabel(arena, it, tree, &colon);
970		const block_node = (try parseBlock(arena, it, tree)) orelse {
971		if (label_token) \|label\| {
972		putBackToken(it, label + 1); // ":"
973		putBackToken(it, label); // IDENTIFIER
974		}
975		return null;
976		};
977		block_node.cast(Node.Block).?.label = label_token;
978		return block_node;
979		}
	919	if (p.eatToken(.Keyword_else)) \|else_token\| {
	920	const payload = try p.parsePayload();
980	921
981		/// AssignExpr <- Expr (AssignOp Expr)?
982		fn parseAssignExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
983		return parseBinOpExpr(arena, it, tree, parseAssignOp, parseExpr, .Once);
984		}
	922	const statement_node = try p.expectNode(parseStatement, .{
	923	.InvalidToken = .{ .token = p.tok_i },
	924	});
985	925
986		/// Expr <- KEYWORD_try* BoolOrExpr
987		fn parseExpr(arena: Allocator, it: TokenIterator, tree: Tree) Error!?Node {
988		return parsePrefixOpExpr(arena, it, tree, parseTry, parseBoolOrExpr);
989		}
	926	const else_node = try p.arena.allocator.create(Node.Else);
	927	else_node.* = .{
	928	.else_token = else_token,
	929	.payload = payload,
	930	.body = statement_node,
	931	};
	932	while_prefix.@"else" = else_node;
990	933
991		/// BoolOrExpr <- BoolAndExpr (KEYWORD_or BoolAndExpr)*
992		fn parseBoolOrExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
993		return parseBinOpExpr(
994		arena,
995		it,
996		tree,
997		SimpleBinOpParseFn(.Keyword_or, Node.InfixOp.Op.BoolOr),
998		parseBoolAndExpr,
999		.Infinitely,
1000		);
1001		}
	934	return node;
	935	}
1002	936
1003		/// BoolAndExpr <- CompareExpr (KEYWORD_and CompareExpr)*
1004		fn parseBoolAndExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1005		return parseBinOpExpr(
1006		arena,
1007		it,
1008		tree,
1009		SimpleBinOpParseFn(.Keyword_and, .BoolAnd),
1010		parseCompareExpr,
1011		.Infinitely,
1012		);
1013		}
	937	return node;
	938	}
1014	939
1015		/// CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)?
1016		fn parseCompareExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1017		return parseBinOpExpr(arena, it, tree, parseCompareOp, parseBitwiseExpr, .Once);
1018		}
	940	if (try p.parseAssignExpr()) \|assign_expr_node\| {
	941	while_prefix.body = assign_expr_node;
1019	942
1020		/// BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)*
1021		fn parseBitwiseExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1022		return parseBinOpExpr(arena, it, tree, parseBitwiseOp, parseBitShiftExpr, .Infinitely);
1023		}
	943	if (p.eatToken(.Semicolon) != null) return node;
1024	944
1025		/// BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)*
1026		fn parseBitShiftExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1027		return parseBinOpExpr(arena, it, tree, parseBitShiftOp, parseAdditionExpr, .Infinitely);
1028		}
	945	if (p.eatToken(.Keyword_else)) \|else_token\| {
	946	const payload = try p.parsePayload();
1029	947
1030		/// AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)*
1031		fn parseAdditionExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1032		return parseBinOpExpr(arena, it, tree, parseAdditionOp, parseMultiplyExpr, .Infinitely);
1033		}
	948	const statement_node = try p.expectNode(parseStatement, .{
	949	.ExpectedStatement = .{ .token = p.tok_i },
	950	});
1034	951
1035		/// MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)*
1036		fn parseMultiplyExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1037		return parseBinOpExpr(arena, it, tree, parseMultiplyOp, parsePrefixExpr, .Infinitely);
1038		}
	952	const else_node = try p.arena.allocator.create(Node.Else);
	953	else_node.* = .{
	954	.else_token = else_token,
	955	.payload = payload,
	956	.body = statement_node,
	957	};
	958	while_prefix.@"else" = else_node;
	959	return node;
	960	}
1039	961
1040		/// PrefixExpr <- PrefixOp* PrimaryExpr
1041		fn parsePrefixExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1042		return parsePrefixOpExpr(arena, it, tree, parsePrefixOp, parsePrimaryExpr);
1043		}
	962	try p.errors.append(p.gpa, .{
	963	.ExpectedSemiOrElse = .{ .token = p.tok_i },
	964	});
1044	965
1045		/// PrimaryExpr
1046		/// <- AsmExpr
1047		/// / IfExpr
1048		/// / KEYWORD_break BreakLabel? Expr?
1049		/// / KEYWORD_comptime Expr
1050		/// / KEYWORD_nosuspend Expr
1051		/// / KEYWORD_continue BreakLabel?
1052		/// / KEYWORD_resume Expr
1053		/// / KEYWORD_return Expr?
1054		/// / BlockLabel? LoopExpr
1055		/// / Block
1056		/// / CurlySuffixExpr
1057		fn parsePrimaryExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1058		if (try parseAsmExpr(arena, it, tree)) \|node\| return node;
1059		if (try parseIfExpr(arena, it, tree)) \|node\| return node;
1060
1061		if (eatToken(it, .Keyword_break)) \|token\| {
1062		const label = try parseBreakLabel(arena, it, tree);
1063		const expr_node = try parseExpr(arena, it, tree);
1064		const node = try arena.create(Node.ControlFlowExpression);
1065		node.* = .{
1066		.ltoken = token,
1067		.kind = .{ .Break = label },
1068		.rhs = expr_node,
1069		};
1070		return &node.base;
1071		}
	966	return node;
	967	}
1072	968
1073		if (eatToken(it, .Keyword_comptime)) \|token\| {
1074		const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1075		.ExpectedExpr = .{ .token = it.index },
1076		});
1077		const node = try arena.create(Node.Comptime);
1078		node.* = .{
1079		.doc_comments = null,
1080		.comptime_token = token,
1081		.expr = expr_node,
1082		};
1083		return &node.base;
	969	return null;
1084	970	}
1085	971
1086		if (eatToken(it, .Keyword_nosuspend)) \|token\| {
1087		const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1088		.ExpectedExpr = .{ .token = it.index },
1089		});
1090		const node = try arena.create(Node.Nosuspend);
1091		node.* = .{
1092		.nosuspend_token = token,
1093		.expr = expr_node,
1094		};
1095		return &node.base;
	972	/// BlockExprStatement
	973	/// <- BlockExpr
	974	/// / AssignExpr SEMICOLON
	975	fn parseBlockExprStatement(p: Parser) !?Node {
	976	if (try p.parseBlockExpr()) \|node\| return node;
	977	if (try p.parseAssignExpr()) \|node\| {
	978	_ = try p.expectTokenRecoverable(.Semicolon);
	979	return node;
	980	}
	981	return null;
1096	982	}
1097	983
1098		if (eatToken(it, .Keyword_continue)) \|token\| {
1099		const label = try parseBreakLabel(arena, it, tree);
1100		const node = try arena.create(Node.ControlFlowExpression);
1101		node.* = .{
1102		.ltoken = token,
1103		.kind = .{ .Continue = label },
1104		.rhs = null,
	984	/// BlockExpr <- BlockLabel? Block
	985	fn parseBlockExpr(p: Parser) Error!?Node {
	986	var colon: TokenIndex = undefined;
	987	const label_token = p.parseBlockLabel(&colon);
	988	const block_node = (try p.parseBlock()) orelse {
	989	if (label_token) \|label\| {
	990	p.putBackToken(label + 1); // ":"
	991	p.putBackToken(label); // IDENTIFIER
	992	}
	993	return null;
1105	994	};
1106		return &node.base;
	995	block_node.cast(Node.Block).?.label = label_token;
	996	return block_node;
1107	997	}
1108	998
1109		if (eatToken(it, .Keyword_resume)) \|token\| {
1110		const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1111		.ExpectedExpr = .{ .token = it.index },
1112		});
1113		const node = try arena.create(Node.PrefixOp);
1114		node.* = .{
1115		.op_token = token,
1116		.op = .Resume,
1117		.rhs = expr_node,
1118		};
1119		return &node.base;
	999	/// AssignExpr <- Expr (AssignOp Expr)?
	1000	fn parseAssignExpr(p: Parser) !?Node {
	1001	return p.parseBinOpExpr(parseAssignOp, parseExpr, .Once);
1120	1002	}
1121	1003
1122		if (eatToken(it, .Keyword_return)) \|token\| {
1123		const expr_node = try parseExpr(arena, it, tree);
1124		const node = try arena.create(Node.ControlFlowExpression);
1125		node.* = .{
1126		.ltoken = token,
1127		.kind = .Return,
1128		.rhs = expr_node,
1129		};
1130		return &node.base;
	1004	/// Expr <- KEYWORD_try* BoolOrExpr
	1005	fn parseExpr(p: Parser) Error!?Node {
	1006	return p.parsePrefixOpExpr(parseTry, parseBoolOrExpr);
1131	1007	}
1132	1008
1133		var colon: TokenIndex = undefined;
1134		const label = parseBlockLabel(arena, it, tree, &colon);
1135		if (try parseLoopExpr(arena, it, tree)) \|node\| {
1136		if (node.cast(Node.For)) \|for_node\| {
1137		for_node.label = label;
1138		} else if (node.cast(Node.While)) \|while_node\| {
1139		while_node.label = label;
1140		} else unreachable;
1141		return node;
1142		}
1143		if (label) \|token\| {
1144		putBackToken(it, token + 1); // ":"
1145		putBackToken(it, token); // IDENTIFIER
	1009	/// BoolOrExpr <- BoolAndExpr (KEYWORD_or BoolAndExpr)*
	1010	fn parseBoolOrExpr(p: Parser) !?Node {
	1011	return p.parseBinOpExpr(
	1012	SimpleBinOpParseFn(.Keyword_or, Node.InfixOp.Op.BoolOr),
	1013	parseBoolAndExpr,
	1014	.Infinitely,
	1015	);
1146	1016	}
1147	1017
1148		if (try parseBlock(arena, it, tree)) \|node\| return node;
1149		if (try parseCurlySuffixExpr(arena, it, tree)) \|node\| return node;
1150
1151		return null;
1152		}
	1018	/// BoolAndExpr <- CompareExpr (KEYWORD_and CompareExpr)*
	1019	fn parseBoolAndExpr(p: Parser) !?Node {
	1020	return p.parseBinOpExpr(
	1021	SimpleBinOpParseFn(.Keyword_and, .BoolAnd),
	1022	parseCompareExpr,
	1023	.Infinitely,
	1024	);
	1025	}
1153	1026
1154		/// IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)?
1155		fn parseIfExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1156		return parseIf(arena, it, tree, parseExpr);
1157		}
	1027	/// CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)?
	1028	fn parseCompareExpr(p: Parser) !?Node {
	1029	return p.parseBinOpExpr(parseCompareOp, parseBitwiseExpr, .Once);
	1030	}
1158	1031
1159		/// Block <- LBRACE Statement* RBRACE
1160		fn parseBlock(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1161		const lbrace = eatToken(it, .LBrace) orelse return null;
	1032	/// BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)*
	1033	fn parseBitwiseExpr(p: Parser) !?Node {
	1034	return p.parseBinOpExpr(parseBitwiseOp, parseBitShiftExpr, .Infinitely);
	1035	}
1162	1036
1163		var statements = Node.Block.StatementList.init(arena);
1164		while (true) {
1165		const statement = (parseStatement(arena, it, tree) catch \|err\| switch (err) {
1166		error.OutOfMemory => return error.OutOfMemory,
1167		error.ParseError => {
1168		// try to skip to the next statement
1169		findNextStmt(it);
1170		continue;
1171		},
1172		}) orelse break;
1173		try statements.push(statement);
	1037	/// BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)*
	1038	fn parseBitShiftExpr(p: Parser) !?Node {
	1039	return p.parseBinOpExpr(parseBitShiftOp, parseAdditionExpr, .Infinitely);
1174	1040	}
1175	1041
1176		const rbrace = try expectToken(it, tree, .RBrace);
	1042	/// AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)*
	1043	fn parseAdditionExpr(p: Parser) !?Node {
	1044	return p.parseBinOpExpr(parseAdditionOp, parseMultiplyExpr, .Infinitely);
	1045	}
1177	1046
1178		const block_node = try arena.create(Node.Block);
1179		block_node.* = .{
1180		.label = null,
1181		.lbrace = lbrace,
1182		.statements = statements,
1183		.rbrace = rbrace,
1184		};
	1047	/// MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)*
	1048	fn parseMultiplyExpr(p: Parser) !?Node {
	1049	return p.parseBinOpExpr(parseMultiplyOp, parsePrefixExpr, .Infinitely);
	1050	}
1185	1051
1186		return &block_node.base;
1187		}
	1052	/// PrefixExpr <- PrefixOp* PrimaryExpr
	1053	fn parsePrefixExpr(p: Parser) !?Node {
	1054	return p.parsePrefixOpExpr(parsePrefixOp, parsePrimaryExpr);
	1055	}
1188	1056
1189		/// LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr)
1190		fn parseLoopExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1191		const inline_token = eatToken(it, .Keyword_inline);
	1057	/// PrimaryExpr
	1058	/// <- AsmExpr
	1059	/// / IfExpr
	1060	/// / KEYWORD_break BreakLabel? Expr?
	1061	/// / KEYWORD_comptime Expr
	1062	/// / KEYWORD_nosuspend Expr
	1063	/// / KEYWORD_continue BreakLabel?
	1064	/// / KEYWORD_resume Expr
	1065	/// / KEYWORD_return Expr?
	1066	/// / BlockLabel? LoopExpr
	1067	/// / Block
	1068	/// / CurlySuffixExpr
	1069	fn parsePrimaryExpr(p: Parser) !?Node {
	1070	if (try p.parseAsmExpr()) \|node\| return node;
	1071	if (try p.parseIfExpr()) \|node\| return node;
1192	1072
1193		if (try parseForExpr(arena, it, tree)) \|node\| {
1194		node.cast(Node.For).?.inline_token = inline_token;
1195		return node;
1196		}
	1073	if (p.eatToken(.Keyword_break)) \|token\| {
	1074	const label = try p.parseBreakLabel();
	1075	const expr_node = try p.parseExpr();
	1076	const node = try p.arena.allocator.create(Node.ControlFlowExpression);
	1077	node.* = .{
	1078	.ltoken = token,
	1079	.kind = .{ .Break = label },
	1080	.rhs = expr_node,
	1081	};
	1082	return &node.base;
	1083	}
1197	1084
1198		if (try parseWhileExpr(arena, it, tree)) \|node\| {
1199		node.cast(Node.While).?.inline_token = inline_token;
1200		return node;
1201		}
	1085	if (p.eatToken(.Keyword_comptime)) \|token\| {
	1086	const expr_node = try p.expectNode(parseExpr, .{
	1087	.ExpectedExpr = .{ .token = p.tok_i },
	1088	});
	1089	const node = try p.arena.allocator.create(Node.Comptime);
	1090	node.* = .{
	1091	.doc_comments = null,
	1092	.comptime_token = token,
	1093	.expr = expr_node,
	1094	};
	1095	return &node.base;
	1096	}
1202	1097
1203		if (inline_token == null) return null;
	1098	if (p.eatToken(.Keyword_nosuspend)) \|token\| {
	1099	const expr_node = try p.expectNode(parseExpr, .{
	1100	.ExpectedExpr = .{ .token = p.tok_i },
	1101	});
	1102	const node = try p.arena.allocator.create(Node.Nosuspend);
	1103	node.* = .{
	1104	.nosuspend_token = token,
	1105	.expr = expr_node,
	1106	};
	1107	return &node.base;
	1108	}
1204	1109
1205		// If we've seen "inline", there should have been a "for" or "while"
1206		try tree.errors.push(.{
1207		.ExpectedInlinable = .{ .token = it.index },
1208		});
1209		return error.ParseError;
1210		}
	1110	if (p.eatToken(.Keyword_continue)) \|token\| {
	1111	const label = try p.parseBreakLabel();
	1112	const node = try p.arena.allocator.create(Node.ControlFlowExpression);
	1113	node.* = .{
	1114	.ltoken = token,
	1115	.kind = .{ .Continue = label },
	1116	.rhs = null,
	1117	};
	1118	return &node.base;
	1119	}
1211	1120
1212		/// ForExpr <- ForPrefix Expr (KEYWORD_else Expr)?
1213		fn parseForExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1214		const node = (try parseForPrefix(arena, it, tree)) orelse return null;
1215		const for_prefix = node.cast(Node.For).?;
	1121	if (p.eatToken(.Keyword_resume)) \|token\| {
	1122	const expr_node = try p.expectNode(parseExpr, .{
	1123	.ExpectedExpr = .{ .token = p.tok_i },
	1124	});
	1125	const node = try p.arena.allocator.create(Node.PrefixOp);
	1126	node.* = .{
	1127	.op_token = token,
	1128	.op = .Resume,
	1129	.rhs = expr_node,
	1130	};
	1131	return &node.base;
	1132	}
1216	1133
1217		const body_node = try expectNode(arena, it, tree, parseExpr, .{
1218		.ExpectedExpr = .{ .token = it.index },
1219		});
1220		for_prefix.body = body_node;
	1134	if (p.eatToken(.Keyword_return)) \|token\| {
	1135	const expr_node = try p.parseExpr();
	1136	const node = try p.arena.allocator.create(Node.ControlFlowExpression);
	1137	node.* = .{
	1138	.ltoken = token,
	1139	.kind = .Return,
	1140	.rhs = expr_node,
	1141	};
	1142	return &node.base;
	1143	}
1221	1144
1222		if (eatToken(it, .Keyword_else)) \|else_token\| {
1223		const body = try expectNode(arena, it, tree, parseExpr, .{
1224		.ExpectedExpr = .{ .token = it.index },
1225		});
	1145	var colon: TokenIndex = undefined;
	1146	const label = p.parseBlockLabel(&colon);
	1147	if (try p.parseLoopExpr()) \|node\| {
	1148	if (node.cast(Node.For)) \|for_node\| {
	1149	for_node.label = label;
	1150	} else if (node.cast(Node.While)) \|while_node\| {
	1151	while_node.label = label;
	1152	} else unreachable;
	1153	return node;
	1154	}
	1155	if (label) \|token\| {
	1156	p.putBackToken(token + 1); // ":"
	1157	p.putBackToken(token); // IDENTIFIER
	1158	}
1226	1159
1227		const else_node = try arena.create(Node.Else);
1228		else_node.* = .{
1229		.else_token = else_token,
1230		.payload = null,
1231		.body = body,
1232		};
	1160	if (try p.parseBlock()) \|node\| return node;
	1161	if (try p.parseCurlySuffixExpr()) \|node\| return node;
1233	1162
1234		for_prefix.@"else" = else_node;
	1163	return null;
1235	1164	}
1236	1165
1237		return node;
1238		}
	1166	/// IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)?
	1167	fn parseIfExpr(p: Parser) !?Node {
	1168	return p.parseIf(parseExpr);
	1169	}
1239	1170
1240		/// WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)?
1241		fn parseWhileExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1242		const node = (try parseWhilePrefix(arena, it, tree)) orelse return null;
1243		const while_prefix = node.cast(Node.While).?;
	1171	/// Block <- LBRACE Statement* RBRACE
	1172	fn parseBlock(p: Parser) !?Node {
	1173	const lbrace = p.eatToken(.LBrace) orelse return null;
1244	1174
1245		const body_node = try expectNode(arena, it, tree, parseExpr, .{
1246		.ExpectedExpr = .{ .token = it.index },
1247		});
1248		while_prefix.body = body_node;
	1175	var statements = Node.Block.StatementList{};
	1176	var statements_it = &statements.first;
	1177	while (true) {
	1178	const statement = (p.parseStatement() catch \|err\| switch (err) {
	1179	error.OutOfMemory => return error.OutOfMemory,
	1180	error.ParseError => {
	1181	// try to skip to the next statement
	1182	p.findNextStmt();
	1183	continue;
	1184	},
	1185	}) orelse break;
	1186	statements_it = try p.llpush(*Node, statements_it, statement);
	1187	}
1249	1188
1250		if (eatToken(it, .Keyword_else)) \|else_token\| {
1251		const payload = try parsePayload(arena, it, tree);
1252		const body = try expectNode(arena, it, tree, parseExpr, .{
1253		.ExpectedExpr = .{ .token = it.index },
1254		});
	1189	const rbrace = try p.expectToken(.RBrace);
1255	1190
1256		const else_node = try arena.create(Node.Else);
1257		else_node.* = .{
1258		.else_token = else_token,
1259		.payload = payload,
1260		.body = body,
	1191	const block_node = try p.arena.allocator.create(Node.Block);
	1192	block_node.* = .{
	1193	.label = null,
	1194	.lbrace = lbrace,
	1195	.statements = statements,
	1196	.rbrace = rbrace,
1261	1197	};
1262	1198
1263		while_prefix.@"else" = else_node;
	1199	return &block_node.base;
1264	1200	}
1265	1201
1266		return node;
1267		}
1268
1269		/// CurlySuffixExpr <- TypeExpr InitList?
1270		fn parseCurlySuffixExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1271		const type_expr = (try parseTypeExpr(arena, it, tree)) orelse return null;
1272		const suffix_op = (try parseInitList(arena, it, tree)) orelse return type_expr;
1273		suffix_op.lhs.node = type_expr;
1274		return &suffix_op.base;
1275		}
	1202	/// LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr)
	1203	fn parseLoopExpr(p: Parser) !?Node {
	1204	const inline_token = p.eatToken(.Keyword_inline);
1276	1205
1277		/// InitList
1278		/// <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
1279		/// / LBRACE Expr (COMMA Expr)* COMMA? RBRACE
1280		/// / LBRACE RBRACE
1281		fn parseInitList(arena: Allocator, it: TokenIterator, tree: Tree) !?Node.SuffixOp {
1282		const lbrace = eatToken(it, .LBrace) orelse return null;
1283		var init_list = Node.SuffixOp.Op.InitList.init(arena);
1284
1285		const op: Node.SuffixOp.Op = blk: {
1286		if (try parseFieldInit(arena, it, tree)) \|field_init\| {
1287		try init_list.push(field_init);
1288		while (eatToken(it, .Comma)) \|_\| {
1289		const next = (try parseFieldInit(arena, it, tree)) orelse break;
1290		try init_list.push(next);
1291		}
1292		break :blk .{ .StructInitializer = init_list };
	1206	if (try p.parseForExpr()) \|node\| {
	1207	node.cast(Node.For).?.inline_token = inline_token;
	1208	return node;
1293	1209	}
1294	1210
1295		if (try parseExpr(arena, it, tree)) \|expr\| {
1296		try init_list.push(expr);
1297		while (eatToken(it, .Comma)) \|_\| {
1298		const next = (try parseExpr(arena, it, tree)) orelse break;
1299		try init_list.push(next);
1300		}
1301		break :blk .{ .ArrayInitializer = init_list };
	1211	if (try p.parseWhileExpr()) \|node\| {
	1212	node.cast(Node.While).?.inline_token = inline_token;
	1213	return node;
1302	1214	}
1303	1215
1304		break :blk .{ .StructInitializer = init_list };
1305		};
1306
1307		const node = try arena.create(Node.SuffixOp);
1308		node.* = .{
1309		.lhs = .{ .node = undefined }, // set by caller
1310		.op = op,
1311		.rtoken = try expectToken(it, tree, .RBrace),
1312		};
1313		return node;
1314		}
1315
1316		/// TypeExpr <- PrefixTypeOp* ErrorUnionExpr
1317		fn parseTypeExpr(arena: Allocator, it: TokenIterator, tree: Tree) Error!?Node {
1318		return parsePrefixOpExpr(arena, it, tree, parsePrefixTypeOp, parseErrorUnionExpr);
1319		}
1320
1321		/// ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
1322		fn parseErrorUnionExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1323		const suffix_expr = (try parseSuffixExpr(arena, it, tree)) orelse return null;
	1216	if (inline_token == null) return null;
1324	1217
1325		if (try SimpleBinOpParseFn(.Bang, Node.InfixOp.Op.ErrorUnion)(arena, it, tree)) \|node\| {
1326		const error_union = node.cast(Node.InfixOp).?;
1327		const type_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
1328		.ExpectedTypeExpr = .{ .token = it.index },
	1218	// If we've seen "inline", there should have been a "for" or "while"
	1219	try p.errors.append(p.gpa, .{
	1220	.ExpectedInlinable = .{ .token = p.tok_i },
1329	1221	});
1330		error_union.lhs = suffix_expr;
1331		error_union.rhs = type_expr;
1332		return node;
	1222	return error.ParseError;
1333	1223	}
1334	1224
1335		return suffix_expr;
1336		}
	1225	/// ForExpr <- ForPrefix Expr (KEYWORD_else Expr)?
	1226	fn parseForExpr(p: Parser) !?Node {
	1227	const node = (try p.parseForPrefix()) orelse return null;
	1228	const for_prefix = node.cast(Node.For).?;
1337	1229
1338		/// SuffixExpr
1339		/// <- KEYWORD_async PrimaryTypeExpr SuffixOp* FnCallArguments
1340		/// / PrimaryTypeExpr (SuffixOp / FnCallArguments)*
1341		fn parseSuffixExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1342		const maybe_async = eatToken(it, .Keyword_async);
1343		if (maybe_async) \|async_token\| {
1344		const token_fn = eatToken(it, .Keyword_fn);
1345		if (token_fn != null) {
1346		// TODO: remove this hack when async fn rewriting is
1347		// HACK: If we see the keyword `fn`, then we assume that
1348		// we are parsing an async fn proto, and not a call.
1349		// We therefore put back all tokens consumed by the async
1350		// prefix...
1351		putBackToken(it, token_fn.?);
1352		putBackToken(it, async_token);
1353		return parsePrimaryTypeExpr(arena, it, tree);
1354		}
1355		var res = try expectNode(arena, it, tree, parsePrimaryTypeExpr, .{
1356		.ExpectedPrimaryTypeExpr = .{ .token = it.index },
	1230	const body_node = try p.expectNode(parseExpr, .{
	1231	.ExpectedExpr = .{ .token = p.tok_i },
1357	1232	});
	1233	for_prefix.body = body_node;
1358	1234
1359		while (try parseSuffixOp(arena, it, tree)) \|node\| {
1360		switch (node.id) {
1361		.SuffixOp => node.cast(Node.SuffixOp).?.lhs = .{ .node = res },
1362		.InfixOp => node.cast(Node.InfixOp).?.lhs = res,
1363		else => unreachable,
1364		}
1365		res = node;
	1235	if (p.eatToken(.Keyword_else)) \|else_token\| {
	1236	const body = try p.expectNode(parseExpr, .{
	1237	.ExpectedExpr = .{ .token = p.tok_i },
	1238	});
	1239
	1240	const else_node = try p.arena.allocator.create(Node.Else);
	1241	else_node.* = .{
	1242	.else_token = else_token,
	1243	.payload = null,
	1244	.body = body,
	1245	};
	1246
	1247	for_prefix.@"else" = else_node;
1366	1248	}
1367	1249
1368		const params = (try parseFnCallArguments(arena, it, tree)) orelse {
1369		try tree.errors.push(.{
1370		.ExpectedParamList = .{ .token = it.index },
1371		});
1372		// ignore this, continue parsing
1373		return res;
1374		};
1375		const node = try arena.create(Node.SuffixOp);
1376		node.* = .{
1377		.lhs = .{ .node = res },
1378		.op = .{
1379		.Call = .{
1380		.params = params.list,
1381		.async_token = async_token,
1382		},
1383		},
1384		.rtoken = params.rparen,
1385		};
1386		return &node.base;
	1250	return node;
1387	1251	}
1388		if (try parsePrimaryTypeExpr(arena, it, tree)) \|expr\| {
1389		var res = expr;
1390	1252
1391		while (true) {
1392		if (try parseSuffixOp(arena, it, tree)) \|node\| {
	1253	/// WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)?
	1254	fn parseWhileExpr(p: Parser) !?Node {
	1255	const node = (try p.parseWhilePrefix()) orelse return null;
	1256	const while_prefix = node.cast(Node.While).?;
	1257
	1258	const body_node = try p.expectNode(parseExpr, .{
	1259	.ExpectedExpr = .{ .token = p.tok_i },
	1260	});
	1261	while_prefix.body = body_node;
	1262
	1263	if (p.eatToken(.Keyword_else)) \|else_token\| {
	1264	const payload = try p.parsePayload();
	1265	const body = try p.expectNode(parseExpr, .{
	1266	.ExpectedExpr = .{ .token = p.tok_i },
	1267	});
	1268
	1269	const else_node = try p.arena.allocator.create(Node.Else);
	1270	else_node.* = .{
	1271	.else_token = else_token,
	1272	.payload = payload,
	1273	.body = body,
	1274	};
	1275
	1276	while_prefix.@"else" = else_node;
	1277	}
	1278
	1279	return node;
	1280	}
	1281
	1282	/// CurlySuffixExpr <- TypeExpr InitList?
	1283	fn parseCurlySuffixExpr(p: Parser) !?Node {
	1284	const type_expr = (try p.parseTypeExpr()) orelse return null;
	1285	const suffix_op = (try p.parseInitList()) orelse return type_expr;
	1286	suffix_op.lhs.node = type_expr;
	1287	return &suffix_op.base;
	1288	}
	1289
	1290	/// InitList
	1291	/// <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
	1292	/// / LBRACE Expr (COMMA Expr)* COMMA? RBRACE
	1293	/// / LBRACE RBRACE
	1294	fn parseInitList(p: Parser) !?Node.SuffixOp {
	1295	const lbrace = p.eatToken(.LBrace) orelse return null;
	1296	var init_list = Node.SuffixOp.Op.InitList{};
	1297	var init_list_it = &init_list.first;
	1298
	1299	const op: Node.SuffixOp.Op = blk: {
	1300	if (try p.parseFieldInit()) \|field_init\| {
	1301	init_list_it = try p.llpush(*Node, init_list_it, field_init);
	1302	while (p.eatToken(.Comma)) \|_\| {
	1303	const next = (try p.parseFieldInit()) orelse break;
	1304	init_list_it = try p.llpush(*Node, init_list_it, next);
	1305	}
	1306	break :blk .{ .StructInitializer = init_list };
	1307	}
	1308
	1309	if (try p.parseExpr()) \|expr\| {
	1310	init_list_it = try p.llpush(*Node, init_list_it, expr);
	1311	while (p.eatToken(.Comma)) \|_\| {
	1312	const next = (try p.parseExpr()) orelse break;
	1313	init_list_it = try p.llpush(*Node, init_list_it, next);
	1314	}
	1315	break :blk .{ .ArrayInitializer = init_list };
	1316	}
	1317
	1318	break :blk .{ .StructInitializer = init_list };
	1319	};
	1320
	1321	const node = try p.arena.allocator.create(Node.SuffixOp);
	1322	node.* = .{
	1323	.lhs = .{ .node = undefined }, // set by caller
	1324	.op = op,
	1325	.rtoken = try p.expectToken(.RBrace),
	1326	};
	1327	return node;
	1328	}
	1329
	1330	/// TypeExpr <- PrefixTypeOp* ErrorUnionExpr
	1331	fn parseTypeExpr(p: Parser) Error!?Node {
	1332	return p.parsePrefixOpExpr(parsePrefixTypeOp, parseErrorUnionExpr);
	1333	}
	1334
	1335	/// ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
	1336	fn parseErrorUnionExpr(p: Parser) !?Node {
	1337	const suffix_expr = (try p.parseSuffixExpr()) orelse return null;
	1338
	1339	if (try SimpleBinOpParseFn(.Bang, Node.InfixOp.Op.ErrorUnion)(p)) \|node\| {
	1340	const error_union = node.cast(Node.InfixOp).?;
	1341	const type_expr = try p.expectNode(parseTypeExpr, .{
	1342	.ExpectedTypeExpr = .{ .token = p.tok_i },
	1343	});
	1344	error_union.lhs = suffix_expr;
	1345	error_union.rhs = type_expr;
	1346	return node;
	1347	}
	1348
	1349	return suffix_expr;
	1350	}
	1351
	1352	/// SuffixExpr
	1353	/// <- KEYWORD_async PrimaryTypeExpr SuffixOp* FnCallArguments
	1354	/// / PrimaryTypeExpr (SuffixOp / FnCallArguments)*
	1355	fn parseSuffixExpr(p: Parser) !?Node {
	1356	const maybe_async = p.eatToken(.Keyword_async);
	1357	if (maybe_async) \|async_token\| {
	1358	const token_fn = p.eatToken(.Keyword_fn);
	1359	if (token_fn != null) {
	1360	// TODO: remove this hack when async fn rewriting is
	1361	// HACK: If we see the keyword `fn`, then we assume that
	1362	// we are parsing an async fn proto, and not a call.
	1363	// We therefore put back all tokens consumed by the async
	1364	// prefix...
	1365	p.putBackToken(token_fn.?);
	1366	p.putBackToken(async_token);
	1367	return p.parsePrimaryTypeExpr();
	1368	}
	1369	var res = try p.expectNode(parsePrimaryTypeExpr, .{
	1370	.ExpectedPrimaryTypeExpr = .{ .token = p.tok_i },
	1371	});
	1372
	1373	while (try p.parseSuffixOp()) \|node\| {
1393	1374	switch (node.id) {
1394	1375	.SuffixOp => node.cast(Node.SuffixOp).?.lhs = .{ .node = res },
1395	1376	.InfixOp => node.cast(Node.InfixOp).?.lhs = res,
1396	1377	else => unreachable,
1397	1378	}
1398	1379	res = node;
1399		continue;
1400	1380	}
1401		if (try parseFnCallArguments(arena, it, tree)) \|params\| {
1402		const call = try arena.create(Node.SuffixOp);
1403		call.* = .{
1404		.lhs = .{ .node = res },
1405		.op = .{
1406		.Call = .{
1407		.params = params.list,
1408		.async_token = null,
1409		},
	1381
	1382	const params = (try p.parseFnCallArguments()) orelse {
	1383	try p.errors.append(p.gpa, .{
	1384	.ExpectedParamList = .{ .token = p.tok_i },
	1385	});
	1386	// ignore this, continue parsing
	1387	return res;
	1388	};
	1389	const node = try p.arena.allocator.create(Node.SuffixOp);
	1390	node.* = .{
	1391	.lhs = .{ .node = res },
	1392	.op = .{
	1393	.Call = .{
	1394	.params = params.list,
	1395	.async_token = async_token,
1410	1396	},
1411		.rtoken = params.rparen,
1412		};
1413		res = &call.base;
1414		continue;
	1397	},
	1398	.rtoken = params.rparen,
	1399	};
	1400	return &node.base;
	1401	}
	1402	if (try p.parsePrimaryTypeExpr()) \|expr\| {
	1403	var res = expr;
	1404
	1405	while (true) {
	1406	if (try p.parseSuffixOp()) \|node\| {
	1407	switch (node.id) {
	1408	.SuffixOp => node.cast(Node.SuffixOp).?.lhs = .{ .node = res },
	1409	.InfixOp => node.cast(Node.InfixOp).?.lhs = res,
	1410	else => unreachable,
	1411	}
	1412	res = node;
	1413	continue;
	1414	}
	1415	if (try p.parseFnCallArguments()) \|params\| {
	1416	const call = try p.arena.allocator.create(Node.SuffixOp);
	1417	call.* = .{
	1418	.lhs = .{ .node = res },
	1419	.op = .{
	1420	.Call = .{
	1421	.params = params.list,
	1422	.async_token = null,
	1423	},
	1424	},
	1425	.rtoken = params.rparen,
	1426	};
	1427	res = &call.base;
	1428	continue;
	1429	}
	1430	break;
1415	1431	}
1416		break;
	1432	return res;
1417	1433	}
1418		return res;
	1434
	1435	return null;
1419	1436	}
1420	1437
1421		return null;
1422		}
	1438	/// PrimaryTypeExpr
	1439	/// <- BUILTINIDENTIFIER FnCallArguments
	1440	/// / CHAR_LITERAL
	1441	/// / ContainerDecl
	1442	/// / DOT IDENTIFIER
	1443	/// / ErrorSetDecl
	1444	/// / FLOAT
	1445	/// / FnProto
	1446	/// / GroupedExpr
	1447	/// / LabeledTypeExpr
	1448	/// / IDENTIFIER
	1449	/// / IfTypeExpr
	1450	/// / INTEGER
	1451	/// / KEYWORD_comptime TypeExpr
	1452	/// / KEYWORD_error DOT IDENTIFIER
	1453	/// / KEYWORD_false
	1454	/// / KEYWORD_null
	1455	/// / KEYWORD_anyframe
	1456	/// / KEYWORD_true
	1457	/// / KEYWORD_undefined
	1458	/// / KEYWORD_unreachable
	1459	/// / STRINGLITERAL
	1460	/// / SwitchExpr
	1461	fn parsePrimaryTypeExpr(p: Parser) !?Node {
	1462	if (try p.parseBuiltinCall()) \|node\| return node;
	1463	if (p.eatToken(.CharLiteral)) \|token\| {
	1464	const node = try p.arena.allocator.create(Node.CharLiteral);
	1465	node.* = .{
	1466	.token = token,
	1467	};
	1468	return &node.base;
	1469	}
	1470	if (try p.parseContainerDecl()) \|node\| return node;
	1471	if (try p.parseAnonLiteral()) \|node\| return node;
	1472	if (try p.parseErrorSetDecl()) \|node\| return node;
	1473	if (try p.parseFloatLiteral()) \|node\| return node;
	1474	if (try p.parseFnProto()) \|node\| return node;
	1475	if (try p.parseGroupedExpr()) \|node\| return node;
	1476	if (try p.parseLabeledTypeExpr()) \|node\| return node;
	1477	if (try p.parseIdentifier()) \|node\| return node;
	1478	if (try p.parseIfTypeExpr()) \|node\| return node;
	1479	if (try p.parseIntegerLiteral()) \|node\| return node;
	1480	if (p.eatToken(.Keyword_comptime)) \|token\| {
	1481	const expr = (try p.parseTypeExpr()) orelse return null;
	1482	const node = try p.arena.allocator.create(Node.Comptime);
	1483	node.* = .{
	1484	.doc_comments = null,
	1485	.comptime_token = token,
	1486	.expr = expr,
	1487	};
	1488	return &node.base;
	1489	}
	1490	if (p.eatToken(.Keyword_error)) \|token\| {
	1491	const period = try p.expectTokenRecoverable(.Period);
	1492	const identifier = try p.expectNodeRecoverable(parseIdentifier, .{
	1493	.ExpectedIdentifier = .{ .token = p.tok_i },
	1494	});
	1495	const global_error_set = try p.createLiteral(Node.ErrorType, token);
	1496	if (period == null or identifier == null) return global_error_set;
1423	1497
1424		/// PrimaryTypeExpr
1425		/// <- BUILTINIDENTIFIER FnCallArguments
1426		/// / CHAR_LITERAL
1427		/// / ContainerDecl
1428		/// / DOT IDENTIFIER
1429		/// / ErrorSetDecl
1430		/// / FLOAT
1431		/// / FnProto
1432		/// / GroupedExpr
1433		/// / LabeledTypeExpr
1434		/// / IDENTIFIER
1435		/// / IfTypeExpr
1436		/// / INTEGER
1437		/// / KEYWORD_comptime TypeExpr
1438		/// / KEYWORD_error DOT IDENTIFIER
1439		/// / KEYWORD_false
1440		/// / KEYWORD_null
1441		/// / KEYWORD_anyframe
1442		/// / KEYWORD_true
1443		/// / KEYWORD_undefined
1444		/// / KEYWORD_unreachable
1445		/// / STRINGLITERAL
1446		/// / SwitchExpr
1447		fn parsePrimaryTypeExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1448		if (try parseBuiltinCall(arena, it, tree)) \|node\| return node;
1449		if (eatToken(it, .CharLiteral)) \|token\| {
1450		const node = try arena.create(Node.CharLiteral);
1451		node.* = .{
1452		.token = token,
	1498	const node = try p.arena.allocator.create(Node.InfixOp);
	1499	node.* = .{
	1500	.op_token = period.?,
	1501	.lhs = global_error_set,
	1502	.op = .Period,
	1503	.rhs = identifier.?,
	1504	};
	1505	return &node.base;
	1506	}
	1507	if (p.eatToken(.Keyword_false)) \|token\| return p.createLiteral(Node.BoolLiteral, token);
	1508	if (p.eatToken(.Keyword_null)) \|token\| return p.createLiteral(Node.NullLiteral, token);
	1509	if (p.eatToken(.Keyword_anyframe)) \|token\| {
	1510	const node = try p.arena.allocator.create(Node.AnyFrameType);
	1511	node.* = .{
	1512	.anyframe_token = token,
	1513	.result = null,
	1514	};
	1515	return &node.base;
	1516	}
	1517	if (p.eatToken(.Keyword_true)) \|token\| return p.createLiteral(Node.BoolLiteral, token);
	1518	if (p.eatToken(.Keyword_undefined)) \|token\| return p.createLiteral(Node.UndefinedLiteral, token);
	1519	if (p.eatToken(.Keyword_unreachable)) \|token\| return p.createLiteral(Node.Unreachable, token);
	1520	if (try p.parseStringLiteral()) \|node\| return node;
	1521	if (try p.parseSwitchExpr()) \|node\| return node;
	1522
	1523	return null;
	1524	}
	1525
	1526	/// ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
	1527	fn parseContainerDecl(p: Parser) !?Node {
	1528	const layout_token = p.eatToken(.Keyword_extern) orelse
	1529	p.eatToken(.Keyword_packed);
	1530
	1531	const node = (try p.parseContainerDeclAuto()) orelse {
	1532	if (layout_token) \|token\|
	1533	p.putBackToken(token);
	1534	return null;
1453	1535	};
1454		return &node.base;
	1536	node.cast(Node.ContainerDecl).?.*.layout_token = layout_token;
	1537	return node;
1455	1538	}
1456		if (try parseContainerDecl(arena, it, tree)) \|node\| return node;
1457		if (try parseAnonLiteral(arena, it, tree)) \|node\| return node;
1458		if (try parseErrorSetDecl(arena, it, tree)) \|node\| return node;
1459		if (try parseFloatLiteral(arena, it, tree)) \|node\| return node;
1460		if (try parseFnProto(arena, it, tree)) \|node\| return node;
1461		if (try parseGroupedExpr(arena, it, tree)) \|node\| return node;
1462		if (try parseLabeledTypeExpr(arena, it, tree)) \|node\| return node;
1463		if (try parseIdentifier(arena, it, tree)) \|node\| return node;
1464		if (try parseIfTypeExpr(arena, it, tree)) \|node\| return node;
1465		if (try parseIntegerLiteral(arena, it, tree)) \|node\| return node;
1466		if (eatToken(it, .Keyword_comptime)) \|token\| {
1467		const expr = (try parseTypeExpr(arena, it, tree)) orelse return null;
1468		const node = try arena.create(Node.Comptime);
	1539
	1540	/// ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
	1541	fn parseErrorSetDecl(p: Parser) !?Node {
	1542	const error_token = p.eatToken(.Keyword_error) orelse return null;
	1543	if (p.eatToken(.LBrace) == null) {
	1544	// Might parse as `KEYWORD_error DOT IDENTIFIER` later in PrimaryTypeExpr, so don't error
	1545	p.putBackToken(error_token);
	1546	return null;
	1547	}
	1548	const decls = try p.parseErrorTagList();
	1549	const rbrace = try p.expectToken(.RBrace);
	1550
	1551	const node = try p.arena.allocator.create(Node.ErrorSetDecl);
1469	1552	node.* = .{
1470		.doc_comments = null,
1471		.comptime_token = token,
1472		.expr = expr,
	1553	.error_token = error_token,
	1554	.decls = decls,
	1555	.rbrace_token = rbrace,
1473	1556	};
1474	1557	return &node.base;
1475	1558	}
1476		if (eatToken(it, .Keyword_error)) \|token\| {
1477		const period = try expectTokenRecoverable(it, tree, .Period);
1478		const identifier = try expectNodeRecoverable(arena, it, tree, parseIdentifier, .{
1479		.ExpectedIdentifier = .{ .token = it.index },
	1559
	1560	/// GroupedExpr <- LPAREN Expr RPAREN
	1561	fn parseGroupedExpr(p: Parser) !?Node {
	1562	const lparen = p.eatToken(.LParen) orelse return null;
	1563	const expr = try p.expectNode(parseExpr, .{
	1564	.ExpectedExpr = .{ .token = p.tok_i },
1480	1565	});
1481		const global_error_set = try createLiteral(arena, Node.ErrorType, token);
1482		if (period == null or identifier == null) return global_error_set;
	1566	const rparen = try p.expectToken(.RParen);
1483	1567
1484		const node = try arena.create(Node.InfixOp);
	1568	const node = try p.arena.allocator.create(Node.GroupedExpression);
1485	1569	node.* = .{
1486		.op_token = period.?,
1487		.lhs = global_error_set,
1488		.op = .Period,
1489		.rhs = identifier.?,
	1570	.lparen = lparen,
	1571	.expr = expr,
	1572	.rparen = rparen,
1490	1573	};
1491	1574	return &node.base;
1492	1575	}
1493		if (eatToken(it, .Keyword_false)) \|token\| return createLiteral(arena, Node.BoolLiteral, token);
1494		if (eatToken(it, .Keyword_null)) \|token\| return createLiteral(arena, Node.NullLiteral, token);
1495		if (eatToken(it, .Keyword_anyframe)) \|token\| {
1496		const node = try arena.create(Node.AnyFrameType);
1497		node.* = .{
1498		.anyframe_token = token,
1499		.result = null,
1500		};
1501		return &node.base;
	1576
	1577	/// IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
	1578	fn parseIfTypeExpr(p: Parser) !?Node {
	1579	return p.parseIf(parseTypeExpr);
1502	1580	}
1503		if (eatToken(it, .Keyword_true)) \|token\| return createLiteral(arena, Node.BoolLiteral, token);
1504		if (eatToken(it, .Keyword_undefined)) \|token\| return createLiteral(arena, Node.UndefinedLiteral, token);
1505		if (eatToken(it, .Keyword_unreachable)) \|token\| return createLiteral(arena, Node.Unreachable, token);
1506		if (try parseStringLiteral(arena, it, tree)) \|node\| return node;
1507		if (try parseSwitchExpr(arena, it, tree)) \|node\| return node;
1508	1581
1509		return null;
1510		}
	1582	/// LabeledTypeExpr
	1583	/// <- BlockLabel Block
	1584	/// / BlockLabel? LoopTypeExpr
	1585	fn parseLabeledTypeExpr(p: Parser) !?Node {
	1586	var colon: TokenIndex = undefined;
	1587	const label = p.parseBlockLabel(&colon);
1511	1588
1512		/// ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
1513		fn parseContainerDecl(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1514		const layout_token = eatToken(it, .Keyword_extern) orelse
1515		eatToken(it, .Keyword_packed);
	1589	if (label) \|token\| {
	1590	if (try p.parseBlock()) \|node\| {
	1591	node.cast(Node.Block).?.label = token;
	1592	return node;
	1593	}
	1594	}
1516	1595
1517		const node = (try parseContainerDeclAuto(arena, it, tree)) orelse {
1518		if (layout_token) \|token\|
1519		putBackToken(it, token);
1520		return null;
1521		};
1522		node.cast(Node.ContainerDecl).?.*.layout_token = layout_token;
1523		return node;
1524		}
	1596	if (try p.parseLoopTypeExpr()) \|node\| {
	1597	switch (node.id) {
	1598	.For => node.cast(Node.For).?.label = label,
	1599	.While => node.cast(Node.While).?.label = label,
	1600	else => unreachable,
	1601	}
	1602	return node;
	1603	}
1525	1604
1526		/// ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
1527		fn parseErrorSetDecl(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1528		const error_token = eatToken(it, .Keyword_error) orelse return null;
1529		if (eatToken(it, .LBrace) == null) {
1530		// Might parse as `KEYWORD_error DOT IDENTIFIER` later in PrimaryTypeExpr, so don't error
1531		putBackToken(it, error_token);
	1605	if (label) \|token\| {
	1606	p.putBackToken(colon);
	1607	p.putBackToken(token);
	1608	}
1532	1609	return null;
1533	1610	}
1534		const decls = try parseErrorTagList(arena, it, tree);
1535		const rbrace = try expectToken(it, tree, .RBrace);
1536
1537		const node = try arena.create(Node.ErrorSetDecl);
1538		node.* = .{
1539		.error_token = error_token,
1540		.decls = decls,
1541		.rbrace_token = rbrace,
1542		};
1543		return &node.base;
1544		}
1545
1546		/// GroupedExpr <- LPAREN Expr RPAREN
1547		fn parseGroupedExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1548		const lparen = eatToken(it, .LParen) orelse return null;
1549		const expr = try expectNode(arena, it, tree, parseExpr, .{
1550		.ExpectedExpr = .{ .token = it.index },
1551		});
1552		const rparen = try expectToken(it, tree, .RParen);
1553
1554		const node = try arena.create(Node.GroupedExpression);
1555		node.* = .{
1556		.lparen = lparen,
1557		.expr = expr,
1558		.rparen = rparen,
1559		};
1560		return &node.base;
1561		}
1562
1563		/// IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
1564		fn parseIfTypeExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1565		return parseIf(arena, it, tree, parseTypeExpr);
1566		}
1567	1611
1568		/// LabeledTypeExpr
1569		/// <- BlockLabel Block
1570		/// / BlockLabel? LoopTypeExpr
1571		fn parseLabeledTypeExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1572		var colon: TokenIndex = undefined;
1573		const label = parseBlockLabel(arena, it, tree, &colon);
	1612	/// LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
	1613	fn parseLoopTypeExpr(p: Parser) !?Node {
	1614	const inline_token = p.eatToken(.Keyword_inline);
1574	1615
1575		if (label) \|token\| {
1576		if (try parseBlock(arena, it, tree)) \|node\| {
1577		node.cast(Node.Block).?.label = token;
	1616	if (try p.parseForTypeExpr()) \|node\| {
	1617	node.cast(Node.For).?.inline_token = inline_token;
1578	1618	return node;
1579	1619	}
1580		}
1581	1620
1582		if (try parseLoopTypeExpr(arena, it, tree)) \|node\| {
1583		switch (node.id) {
1584		.For => node.cast(Node.For).?.label = label,
1585		.While => node.cast(Node.While).?.label = label,
1586		else => unreachable,
	1621	if (try p.parseWhileTypeExpr()) \|node\| {
	1622	node.cast(Node.While).?.inline_token = inline_token;
	1623	return node;
1587	1624	}
1588		return node;
1589		}
1590	1625
1591		if (label) \|token\| {
1592		putBackToken(it, colon);
1593		putBackToken(it, token);
	1626	if (inline_token == null) return null;
	1627
	1628	// If we've seen "inline", there should have been a "for" or "while"
	1629	try p.errors.append(p.gpa, .{
	1630	.ExpectedInlinable = .{ .token = p.tok_i },
	1631	});
	1632	return error.ParseError;
1594	1633	}
1595		return null;
1596		}
1597	1634
1598		/// LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
1599		fn parseLoopTypeExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1600		const inline_token = eatToken(it, .Keyword_inline);
	1635	/// ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr)?
	1636	fn parseForTypeExpr(p: Parser) !?Node {
	1637	const node = (try p.parseForPrefix()) orelse return null;
	1638	const for_prefix = node.cast(Node.For).?;
1601	1639
1602		if (try parseForTypeExpr(arena, it, tree)) \|node\| {
1603		node.cast(Node.For).?.inline_token = inline_token;
1604		return node;
1605		}
	1640	const type_expr = try p.expectNode(parseTypeExpr, .{
	1641	.ExpectedTypeExpr = .{ .token = p.tok_i },
	1642	});
	1643	for_prefix.body = type_expr;
1606	1644
1607		if (try parseWhileTypeExpr(arena, it, tree)) \|node\| {
1608		node.cast(Node.While).?.inline_token = inline_token;
1609		return node;
1610		}
	1645	if (p.eatToken(.Keyword_else)) \|else_token\| {
	1646	const else_expr = try p.expectNode(parseTypeExpr, .{
	1647	.ExpectedTypeExpr = .{ .token = p.tok_i },
	1648	});
1611	1649
1612		if (inline_token == null) return null;
	1650	const else_node = try p.arena.allocator.create(Node.Else);
	1651	else_node.* = .{
	1652	.else_token = else_token,
	1653	.payload = null,
	1654	.body = else_expr,
	1655	};
1613	1656
1614		// If we've seen "inline", there should have been a "for" or "while"
1615		try tree.errors.push(.{
1616		.ExpectedInlinable = .{ .token = it.index },
1617		});
1618		return error.ParseError;
1619		}
	1657	for_prefix.@"else" = else_node;
	1658	}
1620	1659
1621		/// ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr)?
1622		fn parseForTypeExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1623		const node = (try parseForPrefix(arena, it, tree)) orelse return null;
1624		const for_prefix = node.cast(Node.For).?;
	1660	return node;
	1661	}
1625	1662
1626		const type_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
1627		.ExpectedTypeExpr = .{ .token = it.index },
1628		});
1629		for_prefix.body = type_expr;
	1663	/// WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
	1664	fn parseWhileTypeExpr(p: Parser) !?Node {
	1665	const node = (try p.parseWhilePrefix()) orelse return null;
	1666	const while_prefix = node.cast(Node.While).?;
1630	1667
1631		if (eatToken(it, .Keyword_else)) \|else_token\| {
1632		const else_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
1633		.ExpectedTypeExpr = .{ .token = it.index },
	1668	const type_expr = try p.expectNode(parseTypeExpr, .{
	1669	.ExpectedTypeExpr = .{ .token = p.tok_i },
1634	1670	});
	1671	while_prefix.body = type_expr;
1635	1672
1636		const else_node = try arena.create(Node.Else);
1637		else_node.* = .{
1638		.else_token = else_token,
1639		.payload = null,
1640		.body = else_expr,
1641		};
	1673	if (p.eatToken(.Keyword_else)) \|else_token\| {
	1674	const payload = try p.parsePayload();
1642	1675
1643		for_prefix.@"else" = else_node;
1644		}
	1676	const else_expr = try p.expectNode(parseTypeExpr, .{
	1677	.ExpectedTypeExpr = .{ .token = p.tok_i },
	1678	});
1645	1679
1646		return node;
1647		}
	1680	const else_node = try p.arena.allocator.create(Node.Else);
	1681	else_node.* = .{
	1682	.else_token = else_token,
	1683	.payload = null,
	1684	.body = else_expr,
	1685	};
	1686
	1687	while_prefix.@"else" = else_node;
	1688	}
1648	1689
1649		/// WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
1650		fn parseWhileTypeExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1651		const node = (try parseWhilePrefix(arena, it, tree)) orelse return null;
1652		const while_prefix = node.cast(Node.While).?;
	1690	return node;
	1691	}
1653	1692
1654		const type_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
1655		.ExpectedTypeExpr = .{ .token = it.index },
1656		});
1657		while_prefix.body = type_expr;
	1693	/// SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
	1694	fn parseSwitchExpr(p: Parser) !?Node {
	1695	const switch_token = p.eatToken(.Keyword_switch) orelse return null;
	1696	_ = try p.expectToken(.LParen);
	1697	const expr_node = try p.expectNode(parseExpr, .{
	1698	.ExpectedExpr = .{ .token = p.tok_i },
	1699	});
	1700	_ = try p.expectToken(.RParen);
	1701	_ = try p.expectToken(.LBrace);
	1702	const cases = try p.parseSwitchProngList();
	1703	const rbrace = try p.expectToken(.RBrace);
1658	1704
1659		if (eatToken(it, .Keyword_else)) \|else_token\| {
1660		const payload = try parsePayload(arena, it, tree);
	1705	const node = try p.arena.allocator.create(Node.Switch);
	1706	node.* = .{
	1707	.switch_token = switch_token,
	1708	.expr = expr_node,
	1709	.cases = cases,
	1710	.rbrace = rbrace,
	1711	};
	1712	return &node.base;
	1713	}
1661	1714
1662		const else_expr = try expectNode(arena, it, tree, parseTypeExpr, .{
1663		.ExpectedTypeExpr = .{ .token = it.index },
	1715	/// AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN Expr AsmOutput? RPAREN
	1716	fn parseAsmExpr(p: Parser) !?Node {
	1717	const asm_token = p.eatToken(.Keyword_asm) orelse return null;
	1718	const volatile_token = p.eatToken(.Keyword_volatile);
	1719	_ = try p.expectToken(.LParen);
	1720	const template = try p.expectNode(parseExpr, .{
	1721	.ExpectedExpr = .{ .token = p.tok_i },
1664	1722	});
1665	1723
1666		const else_node = try arena.create(Node.Else);
1667		else_node.* = .{
1668		.else_token = else_token,
1669		.payload = null,
1670		.body = else_expr,
	1724	const node = try p.arena.allocator.create(Node.Asm);
	1725	node.* = .{
	1726	.asm_token = asm_token,
	1727	.volatile_token = volatile_token,
	1728	.template = template,
	1729	.outputs = Node.Asm.OutputList{},
	1730	.inputs = Node.Asm.InputList{},
	1731	.clobbers = Node.Asm.ClobberList{},
	1732	.rparen = undefined,
1671	1733	};
1672	1734
1673		while_prefix.@"else" = else_node;
	1735	try p.parseAsmOutput(node);
	1736	node.rparen = try p.expectToken(.RParen);
	1737	return &node.base;
1674	1738	}
1675	1739
1676		return node;
1677		}
	1740	/// DOT IDENTIFIER
	1741	fn parseAnonLiteral(p: Parser) !?Node {
	1742	const dot = p.eatToken(.Period) orelse return null;
1678	1743
1679		/// SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
1680		fn parseSwitchExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1681		const switch_token = eatToken(it, .Keyword_switch) orelse return null;
1682		_ = try expectToken(it, tree, .LParen);
1683		const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1684		.ExpectedExpr = .{ .token = it.index },
1685		});
1686		_ = try expectToken(it, tree, .RParen);
1687		_ = try expectToken(it, tree, .LBrace);
1688		const cases = try parseSwitchProngList(arena, it, tree);
1689		const rbrace = try expectToken(it, tree, .RBrace);
1690
1691		const node = try arena.create(Node.Switch);
1692		node.* = .{
1693		.switch_token = switch_token,
1694		.expr = expr_node,
1695		.cases = cases,
1696		.rbrace = rbrace,
1697		};
1698		return &node.base;
1699		}
	1744	// anon enum literal
	1745	if (p.eatToken(.Identifier)) \|name\| {
	1746	const node = try p.arena.allocator.create(Node.EnumLiteral);
	1747	node.* = .{
	1748	.dot = dot,
	1749	.name = name,
	1750	};
	1751	return &node.base;
	1752	}
1700	1753
1701		/// AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN Expr AsmOutput? RPAREN
1702		fn parseAsmExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1703		const asm_token = eatToken(it, .Keyword_asm) orelse return null;
1704		const volatile_token = eatToken(it, .Keyword_volatile);
1705		_ = try expectToken(it, tree, .LParen);
1706		const template = try expectNode(arena, it, tree, parseExpr, .{
1707		.ExpectedExpr = .{ .token = it.index },
1708		});
1709
1710		const node = try arena.create(Node.Asm);
1711		node.* = .{
1712		.asm_token = asm_token,
1713		.volatile_token = volatile_token,
1714		.template = template,
1715		.outputs = Node.Asm.OutputList.init(arena),
1716		.inputs = Node.Asm.InputList.init(arena),
1717		.clobbers = Node.Asm.ClobberList.init(arena),
1718		.rparen = undefined,
1719		};
	1754	// anon container literal
	1755	if (try p.parseInitList()) \|node\| {
	1756	node.lhs = .{ .dot = dot };
	1757	return &node.base;
	1758	}
1720	1759
1721		try parseAsmOutput(arena, it, tree, node);
1722		node.rparen = try expectToken(it, tree, .RParen);
1723		return &node.base;
1724		}
	1760	p.putBackToken(dot);
	1761	return null;
	1762	}
	1763
	1764	/// AsmOutput <- COLON AsmOutputList AsmInput?
	1765	fn parseAsmOutput(p: Parser, asm_node: Node.Asm) !void {
	1766	if (p.eatToken(.Colon) == null) return;
	1767	asm_node.outputs = try p.parseAsmOutputList();
	1768	try p.parseAsmInput(asm_node);
	1769	}
	1770
	1771	/// AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
	1772	fn parseAsmOutputItem(p: Parser) !?Node.AsmOutput {
	1773	const lbracket = p.eatToken(.LBracket) orelse return null;
	1774	const name = try p.expectNode(parseIdentifier, .{
	1775	.ExpectedIdentifier = .{ .token = p.tok_i },
	1776	});
	1777	_ = try p.expectToken(.RBracket);
	1778
	1779	const constraint = try p.expectNode(parseStringLiteral, .{
	1780	.ExpectedStringLiteral = .{ .token = p.tok_i },
	1781	});
1725	1782
1726		/// DOT IDENTIFIER
1727		fn parseAnonLiteral(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1728		const dot = eatToken(it, .Period) orelse return null;
	1783	_ = try p.expectToken(.LParen);
	1784	const kind: Node.AsmOutput.Kind = blk: {
	1785	if (p.eatToken(.Arrow) != null) {
	1786	const return_ident = try p.expectNode(parseTypeExpr, .{
	1787	.ExpectedTypeExpr = .{ .token = p.tok_i },
	1788	});
	1789	break :blk .{ .Return = return_ident };
	1790	}
	1791	const variable = try p.expectNode(parseIdentifier, .{
	1792	.ExpectedIdentifier = .{ .token = p.tok_i },
	1793	});
	1794	break :blk .{ .Variable = variable.cast(Node.Identifier).? };
	1795	};
	1796	const rparen = try p.expectToken(.RParen);
1729	1797
1730		// anon enum literal
1731		if (eatToken(it, .Identifier)) \|name\| {
1732		const node = try arena.create(Node.EnumLiteral);
	1798	const node = try p.arena.allocator.create(Node.AsmOutput);
1733	1799	node.* = .{
1734		.dot = dot,
1735		.name = name,
	1800	.lbracket = lbracket,
	1801	.symbolic_name = name,
	1802	.constraint = constraint,
	1803	.kind = kind,
	1804	.rparen = rparen,
1736	1805	};
1737		return &node.base;
	1806	return node;
1738	1807	}
1739	1808
1740		// anon container literal
1741		if (try parseInitList(arena, it, tree)) \|node\| {
1742		node.lhs = .{ .dot = dot };
1743		return &node.base;
	1809	/// AsmInput <- COLON AsmInputList AsmClobbers?
	1810	fn parseAsmInput(p: Parser, asm_node: Node.Asm) !void {
	1811	if (p.eatToken(.Colon) == null) return;
	1812	asm_node.inputs = try p.parseAsmInputList();
	1813	try p.parseAsmClobbers(asm_node);
1744	1814	}
1745	1815
1746		putBackToken(it, dot);
1747		return null;
1748		}
1749
1750		/// AsmOutput <- COLON AsmOutputList AsmInput?
1751		fn parseAsmOutput(arena: Allocator, it: TokenIterator, tree: Tree, asm_node: Node.Asm) !void {
1752		if (eatToken(it, .Colon) == null) return;
1753		asm_node.outputs = try parseAsmOutputList(arena, it, tree);
1754		try parseAsmInput(arena, it, tree, asm_node);
1755		}
1756
1757		/// AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
1758		fn parseAsmOutputItem(arena: Allocator, it: TokenIterator, tree: Tree) !?Node.AsmOutput {
1759		const lbracket = eatToken(it, .LBracket) orelse return null;
1760		const name = try expectNode(arena, it, tree, parseIdentifier, .{
1761		.ExpectedIdentifier = .{ .token = it.index },
1762		});
1763		_ = try expectToken(it, tree, .RBracket);
1764
1765		const constraint = try expectNode(arena, it, tree, parseStringLiteral, .{
1766		.ExpectedStringLiteral = .{ .token = it.index },
1767		});
1768
1769		_ = try expectToken(it, tree, .LParen);
1770		const kind: Node.AsmOutput.Kind = blk: {
1771		if (eatToken(it, .Arrow) != null) {
1772		const return_ident = try expectNode(arena, it, tree, parseTypeExpr, .{
1773		.ExpectedTypeExpr = .{ .token = it.index },
1774		});
1775		break :blk .{ .Return = return_ident };
1776		}
1777		const variable = try expectNode(arena, it, tree, parseIdentifier, .{
1778		.ExpectedIdentifier = .{ .token = it.index },
	1816	/// AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN
	1817	fn parseAsmInputItem(p: Parser) !?Node.AsmInput {
	1818	const lbracket = p.eatToken(.LBracket) orelse return null;
	1819	const name = try p.expectNode(parseIdentifier, .{
	1820	.ExpectedIdentifier = .{ .token = p.tok_i },
1779	1821	});
1780		break :blk .{ .Variable = variable.cast(Node.Identifier).? };
1781		};
1782		const rparen = try expectToken(it, tree, .RParen);
1783
1784		const node = try arena.create(Node.AsmOutput);
1785		node.* = .{
1786		.lbracket = lbracket,
1787		.symbolic_name = name,
1788		.constraint = constraint,
1789		.kind = kind,
1790		.rparen = rparen,
1791		};
1792		return node;
1793		}
	1822	_ = try p.expectToken(.RBracket);
1794	1823
1795		/// AsmInput <- COLON AsmInputList AsmClobbers?
1796		fn parseAsmInput(arena: Allocator, it: TokenIterator, tree: Tree, asm_node: Node.Asm) !void {
1797		if (eatToken(it, .Colon) == null) return;
1798		asm_node.inputs = try parseAsmInputList(arena, it, tree);
1799		try parseAsmClobbers(arena, it, tree, asm_node);
1800		}
	1824	const constraint = try p.expectNode(parseStringLiteral, .{
	1825	.ExpectedStringLiteral = .{ .token = p.tok_i },
	1826	});
1801	1827
1802		/// AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN
1803		fn parseAsmInputItem(arena: Allocator, it: TokenIterator, tree: Tree) !?Node.AsmInput {
1804		const lbracket = eatToken(it, .LBracket) orelse return null;
1805		const name = try expectNode(arena, it, tree, parseIdentifier, .{
1806		.ExpectedIdentifier = .{ .token = it.index },
1807		});
1808		_ = try expectToken(it, tree, .RBracket);
1809
1810		const constraint = try expectNode(arena, it, tree, parseStringLiteral, .{
1811		.ExpectedStringLiteral = .{ .token = it.index },
1812		});
1813
1814		_ = try expectToken(it, tree, .LParen);
1815		const expr = try expectNode(arena, it, tree, parseExpr, .{
1816		.ExpectedExpr = .{ .token = it.index },
1817		});
1818		const rparen = try expectToken(it, tree, .RParen);
1819
1820		const node = try arena.create(Node.AsmInput);
1821		node.* = .{
1822		.lbracket = lbracket,
1823		.symbolic_name = name,
1824		.constraint = constraint,
1825		.expr = expr,
1826		.rparen = rparen,
1827		};
1828		return node;
1829		}
	1828	_ = try p.expectToken(.LParen);
	1829	const expr = try p.expectNode(parseExpr, .{
	1830	.ExpectedExpr = .{ .token = p.tok_i },
	1831	});
	1832	const rparen = try p.expectToken(.RParen);
1830	1833
1831		/// AsmClobbers <- COLON StringList
1832		/// StringList <- (STRINGLITERAL COMMA)* STRINGLITERAL?
1833		fn parseAsmClobbers(arena: Allocator, it: TokenIterator, tree: Tree, asm_node: Node.Asm) !void {
1834		if (eatToken(it, .Colon) == null) return;
1835		asm_node.clobbers = try ListParseFn(
1836		Node.Asm.ClobberList,
1837		parseStringLiteral,
1838		)(arena, it, tree);
1839		}
	1834	const node = try p.arena.allocator.create(Node.AsmInput);
	1835	node.* = .{
	1836	.lbracket = lbracket,
	1837	.symbolic_name = name,
	1838	.constraint = constraint,
	1839	.expr = expr,
	1840	.rparen = rparen,
	1841	};
	1842	return node;
	1843	}
1840	1844
1841		/// BreakLabel <- COLON IDENTIFIER
1842		fn parseBreakLabel(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1843		_ = eatToken(it, .Colon) orelse return null;
1844		return try expectNode(arena, it, tree, parseIdentifier, .{
1845		.ExpectedIdentifier = .{ .token = it.index },
1846		});
1847		}
	1845	/// AsmClobbers <- COLON StringList
	1846	/// StringList <- (STRINGLITERAL COMMA)* STRINGLITERAL?
	1847	fn parseAsmClobbers(p: Parser, asm_node: Node.Asm) !void {
	1848	if (p.eatToken(.Colon) == null) return;
	1849	asm_node.clobbers = try ListParseFn(
	1850	Node.Asm.ClobberList,
	1851	parseStringLiteral,
	1852	)(p);
	1853	}
1848	1854
1849		/// BlockLabel <- IDENTIFIER COLON
1850		fn parseBlockLabel(arena: Allocator, it: TokenIterator, tree: Tree, colon_token: TokenIndex) ?TokenIndex {
1851		const identifier = eatToken(it, .Identifier) orelse return null;
1852		if (eatToken(it, .Colon)) \|colon\| {
1853		colon_token.* = colon;
1854		return identifier;
	1855	/// BreakLabel <- COLON IDENTIFIER
	1856	fn parseBreakLabel(p: Parser) !?Node {
	1857	_ = p.eatToken(.Colon) orelse return null;
	1858	return p.expectNode(parseIdentifier, .{
	1859	.ExpectedIdentifier = .{ .token = p.tok_i },
	1860	});
1855	1861	}
1856		putBackToken(it, identifier);
1857		return null;
1858		}
1859	1862
1860		/// FieldInit <- DOT IDENTIFIER EQUAL Expr
1861		fn parseFieldInit(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1862		const period_token = eatToken(it, .Period) orelse return null;
1863		const name_token = eatToken(it, .Identifier) orelse {
1864		// Because of anon literals `.{` is also valid.
1865		putBackToken(it, period_token);
1866		return null;
1867		};
1868		const eq_token = eatToken(it, .Equal) orelse {
1869		// `.Name` may also be an enum literal, which is a later rule.
1870		putBackToken(it, name_token);
1871		putBackToken(it, period_token);
	1863	/// BlockLabel <- IDENTIFIER COLON
	1864	fn parseBlockLabel(p: Parser, colon_token: TokenIndex) ?TokenIndex {
	1865	const identifier = p.eatToken(.Identifier) orelse return null;
	1866	if (p.eatToken(.Colon)) \|colon\| {
	1867	colon_token.* = colon;
	1868	return identifier;
	1869	}
	1870	p.putBackToken(identifier);
1872	1871	return null;
1873		};
1874		const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1875		.ExpectedExpr = .{ .token = it.index },
1876		});
1877
1878		const node = try arena.create(Node.FieldInitializer);
1879		node.* = .{
1880		.period_token = period_token,
1881		.name_token = name_token,
1882		.expr = expr_node,
1883		};
1884		return &node.base;
1885		}
1886
1887		/// WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
1888		fn parseWhileContinueExpr(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1889		_ = eatToken(it, .Colon) orelse return null;
1890		_ = try expectToken(it, tree, .LParen);
1891		const node = try expectNode(arena, it, tree, parseAssignExpr, .{
1892		.ExpectedExprOrAssignment = .{ .token = it.index },
1893		});
1894		_ = try expectToken(it, tree, .RParen);
1895		return node;
1896		}
	1872	}
1897	1873
1898		/// LinkSection <- KEYWORD_linksection LPAREN Expr RPAREN
1899		fn parseLinkSection(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1900		_ = eatToken(it, .Keyword_linksection) orelse return null;
1901		_ = try expectToken(it, tree, .LParen);
1902		const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1903		.ExpectedExpr = .{ .token = it.index },
1904		});
1905		_ = try expectToken(it, tree, .RParen);
1906		return expr_node;
1907		}
	1874	/// FieldInit <- DOT IDENTIFIER EQUAL Expr
	1875	fn parseFieldInit(p: Parser) !?Node {
	1876	const period_token = p.eatToken(.Period) orelse return null;
	1877	const name_token = p.eatToken(.Identifier) orelse {
	1878	// Because of anon literals `.{` is also valid.
	1879	p.putBackToken(period_token);
	1880	return null;
	1881	};
	1882	const eq_token = p.eatToken(.Equal) orelse {
	1883	// `.Name` may also be an enum literal, which is a later rule.
	1884	p.putBackToken(name_token);
	1885	p.putBackToken(period_token);
	1886	return null;
	1887	};
	1888	const expr_node = try p.expectNode(parseExpr, .{
	1889	.ExpectedExpr = .{ .token = p.tok_i },
	1890	});
1908	1891
1909		/// CallConv <- KEYWORD_callconv LPAREN Expr RPAREN
1910		fn parseCallconv(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1911		_ = eatToken(it, .Keyword_callconv) orelse return null;
1912		_ = try expectToken(it, tree, .LParen);
1913		const expr_node = try expectNode(arena, it, tree, parseExpr, .{
1914		.ExpectedExpr = .{ .token = it.index },
1915		});
1916		_ = try expectToken(it, tree, .RParen);
1917		return expr_node;
1918		}
	1892	const node = try p.arena.allocator.create(Node.FieldInitializer);
	1893	node.* = .{
	1894	.period_token = period_token,
	1895	.name_token = name_token,
	1896	.expr = expr_node,
	1897	};
	1898	return &node.base;
	1899	}
1919	1900
1920		/// ParamDecl <- (KEYWORD_noalias / KEYWORD_comptime)? (IDENTIFIER COLON)? ParamType
1921		fn parseParamDecl(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1922		const doc_comments = try parseDocComment(arena, it, tree);
1923		const noalias_token = eatToken(it, .Keyword_noalias);
1924		const comptime_token = if (noalias_token == null) eatToken(it, .Keyword_comptime) else null;
1925		const name_token = blk: {
1926		const identifier = eatToken(it, .Identifier) orelse break :blk null;
1927		if (eatToken(it, .Colon) != null) break :blk identifier;
1928		putBackToken(it, identifier); // ParamType may also be an identifier
1929		break :blk null;
1930		};
1931		const param_type = (try parseParamType(arena, it, tree)) orelse {
1932		// Only return cleanly if no keyword, identifier, or doc comment was found
1933		if (noalias_token == null and
1934		comptime_token == null and
1935		name_token == null and
1936		doc_comments == null) return null;
1937		try tree.errors.push(.{
1938		.ExpectedParamType = .{ .token = it.index },
	1901	/// WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
	1902	fn parseWhileContinueExpr(p: Parser) !?Node {
	1903	_ = p.eatToken(.Colon) orelse return null;
	1904	_ = try p.expectToken(.LParen);
	1905	const node = try p.expectNode(parseAssignExpr, .{
	1906	.ExpectedExprOrAssignment = .{ .token = p.tok_i },
1939	1907	});
1940		return error.ParseError;
1941		};
	1908	_ = try p.expectToken(.RParen);
	1909	return node;
	1910	}
1942	1911
1943		const param_decl = try arena.create(Node.ParamDecl);
1944		param_decl.* = .{
1945		.doc_comments = doc_comments,
1946		.comptime_token = comptime_token,
1947		.noalias_token = noalias_token,
1948		.name_token = name_token,
1949		.param_type = param_type,
1950		};
1951		return &param_decl.base;
1952		}
	1912	/// LinkSection <- KEYWORD_linksection LPAREN Expr RPAREN
	1913	fn parseLinkSection(p: Parser) !?Node {
	1914	_ = p.eatToken(.Keyword_linksection) orelse return null;
	1915	_ = try p.expectToken(.LParen);
	1916	const expr_node = try p.expectNode(parseExpr, .{
	1917	.ExpectedExpr = .{ .token = p.tok_i },
	1918	});
	1919	_ = try p.expectToken(.RParen);
	1920	return expr_node;
	1921	}
1953	1922
1954		/// ParamType
1955		/// <- KEYWORD_var
1956		/// / DOT3
1957		/// / TypeExpr
1958		fn parseParamType(arena: Allocator, it: TokenIterator, tree: *Tree) !?Node.ParamDecl.ParamType {
1959		// TODO cast from tuple to error union is broken
1960		const P = Node.ParamDecl.ParamType;
1961		if (try parseVarType(arena, it, tree)) \|node\| return P{ .var_type = node };
1962		if (eatToken(it, .Ellipsis3)) \|token\| return P{ .var_args = token };
1963		if (try parseTypeExpr(arena, it, tree)) \|node\| return P{ .type_expr = node };
1964		return null;
1965		}
1966
1967		/// IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
1968		fn parseIfPrefix(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1969		const if_token = eatToken(it, .Keyword_if) orelse return null;
1970		_ = try expectToken(it, tree, .LParen);
1971		const condition = try expectNode(arena, it, tree, parseExpr, .{
1972		.ExpectedExpr = .{ .token = it.index },
1973		});
1974		_ = try expectToken(it, tree, .RParen);
1975		const payload = try parsePtrPayload(arena, it, tree);
1976
1977		const node = try arena.create(Node.If);
1978		node.* = .{
1979		.if_token = if_token,
1980		.condition = condition,
1981		.payload = payload,
1982		.body = undefined, // set by caller
1983		.@"else" = null,
1984		};
1985		return &node.base;
1986		}
	1923	/// CallConv <- KEYWORD_callconv LPAREN Expr RPAREN
	1924	fn parseCallconv(p: Parser) !?Node {
	1925	_ = p.eatToken(.Keyword_callconv) orelse return null;
	1926	_ = try p.expectToken(.LParen);
	1927	const expr_node = try p.expectNode(parseExpr, .{
	1928	.ExpectedExpr = .{ .token = p.tok_i },
	1929	});
	1930	_ = try p.expectToken(.RParen);
	1931	return expr_node;
	1932	}
	1933
	1934	/// ParamDecl <- (KEYWORD_noalias / KEYWORD_comptime)? (IDENTIFIER COLON)? ParamType
	1935	fn parseParamDecl(p: Parser) !?Node {
	1936	const doc_comments = try p.parseDocComment();
	1937	const noalias_token = p.eatToken(.Keyword_noalias);
	1938	const comptime_token = if (noalias_token == null) p.eatToken(.Keyword_comptime) else null;
	1939	const name_token = blk: {
	1940	const identifier = p.eatToken(.Identifier) orelse break :blk null;
	1941	if (p.eatToken(.Colon) != null) break :blk identifier;
	1942	p.putBackToken(identifier); // ParamType may also be an identifier
	1943	break :blk null;
	1944	};
	1945	const param_type = (try p.parseParamType()) orelse {
	1946	// Only return cleanly if no keyword, identifier, or doc comment was found
	1947	if (noalias_token == null and
	1948	comptime_token == null and
	1949	name_token == null and
	1950	doc_comments == null) return null;
	1951	try p.errors.append(p.gpa, .{
	1952	.ExpectedParamType = .{ .token = p.tok_i },
	1953	});
	1954	return error.ParseError;
	1955	};
1987	1956
1988		/// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
1989		fn parseWhilePrefix(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
1990		const while_token = eatToken(it, .Keyword_while) orelse return null;
1991
1992		_ = try expectToken(it, tree, .LParen);
1993		const condition = try expectNode(arena, it, tree, parseExpr, .{
1994		.ExpectedExpr = .{ .token = it.index },
1995		});
1996		_ = try expectToken(it, tree, .RParen);
1997
1998		const payload = try parsePtrPayload(arena, it, tree);
1999		const continue_expr = try parseWhileContinueExpr(arena, it, tree);
2000
2001		const node = try arena.create(Node.While);
2002		node.* = .{
2003		.label = null,
2004		.inline_token = null,
2005		.while_token = while_token,
2006		.condition = condition,
2007		.payload = payload,
2008		.continue_expr = continue_expr,
2009		.body = undefined, // set by caller
2010		.@"else" = null,
2011		};
2012		return &node.base;
2013		}
	1957	const param_decl = try p.arena.allocator.create(Node.ParamDecl);
	1958	param_decl.* = .{
	1959	.doc_comments = doc_comments,
	1960	.comptime_token = comptime_token,
	1961	.noalias_token = noalias_token,
	1962	.name_token = name_token,
	1963	.param_type = param_type,
	1964	};
	1965	return &param_decl.base;
	1966	}
	1967
	1968	/// ParamType
	1969	/// <- KEYWORD_var
	1970	/// / DOT3
	1971	/// / TypeExpr
	1972	fn parseParamType(p: *Parser) !?Node.ParamDecl.ParamType {
	1973	// TODO cast from tuple to error union is broken
	1974	const P = Node.ParamDecl.ParamType;
	1975	if (try p.parseVarType()) \|node\| return P{ .var_type = node };
	1976	if (p.eatToken(.Ellipsis3)) \|token\| return P{ .var_args = token };
	1977	if (try p.parseTypeExpr()) \|node\| return P{ .type_expr = node };
	1978	return null;
	1979	}
2014	1980
2015		/// ForPrefix <- KEYWORD_for LPAREN Expr RPAREN PtrIndexPayload
2016		fn parseForPrefix(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2017		const for_token = eatToken(it, .Keyword_for) orelse return null;
2018
2019		_ = try expectToken(it, tree, .LParen);
2020		const array_expr = try expectNode(arena, it, tree, parseExpr, .{
2021		.ExpectedExpr = .{ .token = it.index },
2022		});
2023		_ = try expectToken(it, tree, .RParen);
2024
2025		const payload = try expectNode(arena, it, tree, parsePtrIndexPayload, .{
2026		.ExpectedPayload = .{ .token = it.index },
2027		});
2028
2029		const node = try arena.create(Node.For);
2030		node.* = .{
2031		.label = null,
2032		.inline_token = null,
2033		.for_token = for_token,
2034		.array_expr = array_expr,
2035		.payload = payload,
2036		.body = undefined, // set by caller
2037		.@"else" = null,
2038		};
2039		return &node.base;
2040		}
	1981	/// IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
	1982	fn parseIfPrefix(p: Parser) !?Node {
	1983	const if_token = p.eatToken(.Keyword_if) orelse return null;
	1984	_ = try p.expectToken(.LParen);
	1985	const condition = try p.expectNode(parseExpr, .{
	1986	.ExpectedExpr = .{ .token = p.tok_i },
	1987	});
	1988	_ = try p.expectToken(.RParen);
	1989	const payload = try p.parsePtrPayload();
2041	1990
2042		/// Payload <- PIPE IDENTIFIER PIPE
2043		fn parsePayload(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2044		const lpipe = eatToken(it, .Pipe) orelse return null;
2045		const identifier = try expectNode(arena, it, tree, parseIdentifier, .{
2046		.ExpectedIdentifier = .{ .token = it.index },
2047		});
2048		const rpipe = try expectToken(it, tree, .Pipe);
2049
2050		const node = try arena.create(Node.Payload);
2051		node.* = .{
2052		.lpipe = lpipe,
2053		.error_symbol = identifier,
2054		.rpipe = rpipe,
2055		};
2056		return &node.base;
2057		}
	1991	const node = try p.arena.allocator.create(Node.If);
	1992	node.* = .{
	1993	.if_token = if_token,
	1994	.condition = condition,
	1995	.payload = payload,
	1996	.body = undefined, // set by caller
	1997	.@"else" = null,
	1998	};
	1999	return &node.base;
	2000	}
2058	2001
2059		/// PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
2060		fn parsePtrPayload(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2061		const lpipe = eatToken(it, .Pipe) orelse return null;
2062		const asterisk = eatToken(it, .Asterisk);
2063		const identifier = try expectNode(arena, it, tree, parseIdentifier, .{
2064		.ExpectedIdentifier = .{ .token = it.index },
2065		});
2066		const rpipe = try expectToken(it, tree, .Pipe);
2067
2068		const node = try arena.create(Node.PointerPayload);
2069		node.* = .{
2070		.lpipe = lpipe,
2071		.ptr_token = asterisk,
2072		.value_symbol = identifier,
2073		.rpipe = rpipe,
2074		};
2075		return &node.base;
2076		}
	2002	/// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
	2003	fn parseWhilePrefix(p: Parser) !?Node {
	2004	const while_token = p.eatToken(.Keyword_while) orelse return null;
2077	2005
2078		/// PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
2079		fn parsePtrIndexPayload(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2080		const lpipe = eatToken(it, .Pipe) orelse return null;
2081		const asterisk = eatToken(it, .Asterisk);
2082		const identifier = try expectNode(arena, it, tree, parseIdentifier, .{
2083		.ExpectedIdentifier = .{ .token = it.index },
2084		});
2085
2086		const index = if (eatToken(it, .Comma) == null)
2087		null
2088		else
2089		try expectNode(arena, it, tree, parseIdentifier, .{
2090		.ExpectedIdentifier = .{ .token = it.index },
	2006	_ = try p.expectToken(.LParen);
	2007	const condition = try p.expectNode(parseExpr, .{
	2008	.ExpectedExpr = .{ .token = p.tok_i },
2091	2009	});
	2010	_ = try p.expectToken(.RParen);
2092	2011
2093		const rpipe = try expectToken(it, tree, .Pipe);
	2012	const payload = try p.parsePtrPayload();
	2013	const continue_expr = try p.parseWhileContinueExpr();
2094	2014
2095		const node = try arena.create(Node.PointerIndexPayload);
2096		node.* = .{
2097		.lpipe = lpipe,
2098		.ptr_token = asterisk,
2099		.value_symbol = identifier,
2100		.index_symbol = index,
2101		.rpipe = rpipe,
2102		};
2103		return &node.base;
2104		}
	2015	const node = try p.arena.allocator.create(Node.While);
	2016	node.* = .{
	2017	.label = null,
	2018	.inline_token = null,
	2019	.while_token = while_token,
	2020	.condition = condition,
	2021	.payload = payload,
	2022	.continue_expr = continue_expr,
	2023	.body = undefined, // set by caller
	2024	.@"else" = null,
	2025	};
	2026	return &node.base;
	2027	}
2105	2028
2106		/// SwitchProng <- SwitchCase EQUALRARROW PtrPayload? AssignExpr
2107		fn parseSwitchProng(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2108		const node = (try parseSwitchCase(arena, it, tree)) orelse return null;
2109		const arrow = try expectToken(it, tree, .EqualAngleBracketRight);
2110		const payload = try parsePtrPayload(arena, it, tree);
2111		const expr = try expectNode(arena, it, tree, parseAssignExpr, .{
2112		.ExpectedExprOrAssignment = .{ .token = it.index },
2113		});
2114
2115		const switch_case = node.cast(Node.SwitchCase).?;
2116		switch_case.arrow_token = arrow;
2117		switch_case.payload = payload;
2118		switch_case.expr = expr;
2119
2120		return node;
2121		}
	2029	/// ForPrefix <- KEYWORD_for LPAREN Expr RPAREN PtrIndexPayload
	2030	fn parseForPrefix(p: Parser) !?Node {
	2031	const for_token = p.eatToken(.Keyword_for) orelse return null;
2122	2032
2123		/// SwitchCase
2124		/// <- SwitchItem (COMMA SwitchItem)* COMMA?
2125		/// / KEYWORD_else
2126		fn parseSwitchCase(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2127		var list = Node.SwitchCase.ItemList.init(arena);
	2033	_ = try p.expectToken(.LParen);
	2034	const array_expr = try p.expectNode(parseExpr, .{
	2035	.ExpectedExpr = .{ .token = p.tok_i },
	2036	});
	2037	_ = try p.expectToken(.RParen);
2128	2038
2129		if (try parseSwitchItem(arena, it, tree)) \|first_item\| {
2130		try list.push(first_item);
2131		while (eatToken(it, .Comma) != null) {
2132		const next_item = (try parseSwitchItem(arena, it, tree)) orelse break;
2133		try list.push(next_item);
2134		}
2135		} else if (eatToken(it, .Keyword_else)) \|else_token\| {
2136		const else_node = try arena.create(Node.SwitchElse);
2137		else_node.* = .{
2138		.token = else_token,
2139		};
2140		try list.push(&else_node.base);
2141		} else return null;
	2039	const payload = try p.expectNode(parsePtrIndexPayload, .{
	2040	.ExpectedPayload = .{ .token = p.tok_i },
	2041	});
2142	2042
2143		const node = try arena.create(Node.SwitchCase);
2144		node.* = .{
2145		.items = list,
2146		.arrow_token = undefined, // set by caller
2147		.payload = null,
2148		.expr = undefined, // set by caller
2149		};
2150		return &node.base;
2151		}
	2043	const node = try p.arena.allocator.create(Node.For);
	2044	node.* = .{
	2045	.label = null,
	2046	.inline_token = null,
	2047	.for_token = for_token,
	2048	.array_expr = array_expr,
	2049	.payload = payload,
	2050	.body = undefined, // set by caller
	2051	.@"else" = null,
	2052	};
	2053	return &node.base;
	2054	}
2152	2055
2153		/// SwitchItem <- Expr (DOT3 Expr)?
2154		fn parseSwitchItem(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2155		const expr = (try parseExpr(arena, it, tree)) orelse return null;
2156		if (eatToken(it, .Ellipsis3)) \|token\| {
2157		const range_end = try expectNode(arena, it, tree, parseExpr, .{
2158		.ExpectedExpr = .{ .token = it.index },
	2056	/// Payload <- PIPE IDENTIFIER PIPE
	2057	fn parsePayload(p: Parser) !?Node {
	2058	const lpipe = p.eatToken(.Pipe) orelse return null;
	2059	const identifier = try p.expectNode(parseIdentifier, .{
	2060	.ExpectedIdentifier = .{ .token = p.tok_i },
2159	2061	});
	2062	const rpipe = try p.expectToken(.Pipe);
2160	2063
2161		const node = try arena.create(Node.InfixOp);
	2064	const node = try p.arena.allocator.create(Node.Payload);
2162	2065	node.* = .{
2163		.op_token = token,
2164		.lhs = expr,
2165		.op = .Range,
2166		.rhs = range_end,
	2066	.lpipe = lpipe,
	2067	.error_symbol = identifier,
	2068	.rpipe = rpipe,
2167	2069	};
2168	2070	return &node.base;
2169	2071	}
2170		return expr;
2171		}
2172	2072
2173		/// AssignOp
2174		/// <- ASTERISKEQUAL
2175		/// / SLASHEQUAL
2176		/// / PERCENTEQUAL
2177		/// / PLUSEQUAL
2178		/// / MINUSEQUAL
2179		/// / LARROW2EQUAL
2180		/// / RARROW2EQUAL
2181		/// / AMPERSANDEQUAL
2182		/// / CARETEQUAL
2183		/// / PIPEEQUAL
2184		/// / ASTERISKPERCENTEQUAL
2185		/// / PLUSPERCENTEQUAL
2186		/// / MINUSPERCENTEQUAL
2187		/// / EQUAL
2188		fn parseAssignOp(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2189		const token = nextToken(it);
2190		const op: Node.InfixOp.Op = switch (token.ptr.id) {
2191		.AsteriskEqual => .AssignMul,
2192		.SlashEqual => .AssignDiv,
2193		.PercentEqual => .AssignMod,
2194		.PlusEqual => .AssignAdd,
2195		.MinusEqual => .AssignSub,
2196		.AngleBracketAngleBracketLeftEqual => .AssignBitShiftLeft,
2197		.AngleBracketAngleBracketRightEqual => .AssignBitShiftRight,
2198		.AmpersandEqual => .AssignBitAnd,
2199		.CaretEqual => .AssignBitXor,
2200		.PipeEqual => .AssignBitOr,
2201		.AsteriskPercentEqual => .AssignMulWrap,
2202		.PlusPercentEqual => .AssignAddWrap,
2203		.MinusPercentEqual => .AssignSubWrap,
2204		.Equal => .Assign,
2205		else => {
2206		putBackToken(it, token.index);
2207		return null;
2208		},
2209		};
	2073	/// PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
	2074	fn parsePtrPayload(p: Parser) !?Node {
	2075	const lpipe = p.eatToken(.Pipe) orelse return null;
	2076	const asterisk = p.eatToken(.Asterisk);
	2077	const identifier = try p.expectNode(parseIdentifier, .{
	2078	.ExpectedIdentifier = .{ .token = p.tok_i },
	2079	});
	2080	const rpipe = try p.expectToken(.Pipe);
2210	2081
2211		const node = try arena.create(Node.InfixOp);
2212		node.* = .{
2213		.op_token = token.index,
2214		.lhs = undefined, // set by caller
2215		.op = op,
2216		.rhs = undefined, // set by caller
2217		};
2218		return &node.base;
2219		}
	2082	const node = try p.arena.allocator.create(Node.PointerPayload);
	2083	node.* = .{
	2084	.lpipe = lpipe,
	2085	.ptr_token = asterisk,
	2086	.value_symbol = identifier,
	2087	.rpipe = rpipe,
	2088	};
	2089	return &node.base;
	2090	}
2220	2091
2221		/// CompareOp
2222		/// <- EQUALEQUAL
2223		/// / EXCLAMATIONMARKEQUAL
2224		/// / LARROW
2225		/// / RARROW
2226		/// / LARROWEQUAL
2227		/// / RARROWEQUAL
2228		fn parseCompareOp(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2229		const token = nextToken(it);
2230		const op: Node.InfixOp.Op = switch (token.ptr.id) {
2231		.EqualEqual => .EqualEqual,
2232		.BangEqual => .BangEqual,
2233		.AngleBracketLeft => .LessThan,
2234		.AngleBracketRight => .GreaterThan,
2235		.AngleBracketLeftEqual => .LessOrEqual,
2236		.AngleBracketRightEqual => .GreaterOrEqual,
2237		else => {
2238		putBackToken(it, token.index);
2239		return null;
2240		},
2241		};
	2092	/// PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
	2093	fn parsePtrIndexPayload(p: Parser) !?Node {
	2094	const lpipe = p.eatToken(.Pipe) orelse return null;
	2095	const asterisk = p.eatToken(.Asterisk);
	2096	const identifier = try p.expectNode(parseIdentifier, .{
	2097	.ExpectedIdentifier = .{ .token = p.tok_i },
	2098	});
2242	2099
2243		return try createInfixOp(arena, token.index, op);
2244		}
	2100	const index = if (p.eatToken(.Comma) == null)
	2101	null
	2102	else
	2103	try p.expectNode(parseIdentifier, .{
	2104	.ExpectedIdentifier = .{ .token = p.tok_i },
	2105	});
2245	2106
2246		/// BitwiseOp
2247		/// <- AMPERSAND
2248		/// / CARET
2249		/// / PIPE
2250		/// / KEYWORD_orelse
2251		/// / KEYWORD_catch Payload?
2252		fn parseBitwiseOp(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2253		const token = nextToken(it);
2254		const op: Node.InfixOp.Op = switch (token.ptr.id) {
2255		.Ampersand => .BitAnd,
2256		.Caret => .BitXor,
2257		.Pipe => .BitOr,
2258		.Keyword_orelse => .UnwrapOptional,
2259		.Keyword_catch => .{ .Catch = try parsePayload(arena, it, tree) },
2260		else => {
2261		putBackToken(it, token.index);
2262		return null;
2263		},
2264		};
	2107	const rpipe = try p.expectToken(.Pipe);
2265	2108
2266		return try createInfixOp(arena, token.index, op);
2267		}
	2109	const node = try p.arena.allocator.create(Node.PointerIndexPayload);
	2110	node.* = .{
	2111	.lpipe = lpipe,
	2112	.ptr_token = asterisk,
	2113	.value_symbol = identifier,
	2114	.index_symbol = index,
	2115	.rpipe = rpipe,
	2116	};
	2117	return &node.base;
	2118	}
2268	2119
2269		/// BitShiftOp
2270		/// <- LARROW2
2271		/// / RARROW2
2272		fn parseBitShiftOp(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2273		const token = nextToken(it);
2274		const op: Node.InfixOp.Op = switch (token.ptr.id) {
2275		.AngleBracketAngleBracketLeft => .BitShiftLeft,
2276		.AngleBracketAngleBracketRight => .BitShiftRight,
2277		else => {
2278		putBackToken(it, token.index);
2279		return null;
2280		},
2281		};
	2120	/// SwitchProng <- SwitchCase EQUALRARROW PtrPayload? AssignExpr
	2121	fn parseSwitchProng(p: Parser) !?Node {
	2122	const node = (try p.parseSwitchCase()) orelse return null;
	2123	const arrow = try p.expectToken(.EqualAngleBracketRight);
	2124	const payload = try p.parsePtrPayload();
	2125	const expr = try p.expectNode(parseAssignExpr, .{
	2126	.ExpectedExprOrAssignment = .{ .token = p.tok_i },
	2127	});
2282	2128
2283		return try createInfixOp(arena, token.index, op);
2284		}
	2129	const switch_case = node.cast(Node.SwitchCase).?;
	2130	switch_case.arrow_token = arrow;
	2131	switch_case.payload = payload;
	2132	switch_case.expr = expr;
2285	2133
2286		/// AdditionOp
2287		/// <- PLUS
2288		/// / MINUS
2289		/// / PLUS2
2290		/// / PLUSPERCENT
2291		/// / MINUSPERCENT
2292		fn parseAdditionOp(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2293		const token = nextToken(it);
2294		const op: Node.InfixOp.Op = switch (token.ptr.id) {
2295		.Plus => .Add,
2296		.Minus => .Sub,
2297		.PlusPlus => .ArrayCat,
2298		.PlusPercent => .AddWrap,
2299		.MinusPercent => .SubWrap,
2300		else => {
2301		putBackToken(it, token.index);
2302		return null;
2303		},
2304		};
	2134	return node;
	2135	}
2305	2136
2306		return try createInfixOp(arena, token.index, op);
2307		}
	2137	/// SwitchCase
	2138	/// <- SwitchItem (COMMA SwitchItem)* COMMA?
	2139	/// / KEYWORD_else
	2140	fn parseSwitchCase(p: Parser) !?Node {
	2141	var list = Node.SwitchCase.ItemList{};
	2142	var list_it = &list.first;
2308	2143
2309		/// MultiplyOp
2310		/// <- PIPE2
2311		/// / ASTERISK
2312		/// / SLASH
2313		/// / PERCENT
2314		/// / ASTERISK2
2315		/// / ASTERISKPERCENT
2316		fn parseMultiplyOp(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2317		const token = nextToken(it);
2318		const op: Node.InfixOp.Op = switch (token.ptr.id) {
2319		.PipePipe => .MergeErrorSets,
2320		.Asterisk => .Mul,
2321		.Slash => .Div,
2322		.Percent => .Mod,
2323		.AsteriskAsterisk => .ArrayMult,
2324		.AsteriskPercent => .MulWrap,
2325		else => {
2326		putBackToken(it, token.index);
2327		return null;
2328		},
2329		};
	2144	if (try p.parseSwitchItem()) \|first_item\| {
	2145	list_it = try p.llpush(*Node, list_it, first_item);
	2146	while (p.eatToken(.Comma) != null) {
	2147	const next_item = (try p.parseSwitchItem()) orelse break;
	2148	list_it = try p.llpush(*Node, list_it, next_item);
	2149	}
	2150	} else if (p.eatToken(.Keyword_else)) \|else_token\| {
	2151	const else_node = try p.arena.allocator.create(Node.SwitchElse);
	2152	else_node.* = .{
	2153	.token = else_token,
	2154	};
	2155	list_it = try p.llpush(*Node, list_it, &else_node.base);
	2156	} else return null;
2330	2157
2331		return try createInfixOp(arena, token.index, op);
2332		}
	2158	const node = try p.arena.allocator.create(Node.SwitchCase);
	2159	node.* = .{
	2160	.items = list,
	2161	.arrow_token = undefined, // set by caller
	2162	.payload = null,
	2163	.expr = undefined, // set by caller
	2164	};
	2165	return &node.base;
	2166	}
2333	2167
2334		/// PrefixOp
2335		/// <- EXCLAMATIONMARK
2336		/// / MINUS
2337		/// / TILDE
2338		/// / MINUSPERCENT
2339		/// / AMPERSAND
2340		/// / KEYWORD_try
2341		/// / KEYWORD_await
2342		fn parsePrefixOp(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2343		const token = nextToken(it);
2344		const op: Node.PrefixOp.Op = switch (token.ptr.id) {
2345		.Bang => .BoolNot,
2346		.Minus => .Negation,
2347		.Tilde => .BitNot,
2348		.MinusPercent => .NegationWrap,
2349		.Ampersand => .AddressOf,
2350		.Keyword_try => .Try,
2351		.Keyword_await => .Await,
2352		else => {
2353		putBackToken(it, token.index);
2354		return null;
2355		},
2356		};
	2168	/// SwitchItem <- Expr (DOT3 Expr)?
	2169	fn parseSwitchItem(p: Parser) !?Node {
	2170	const expr = (try p.parseExpr()) orelse return null;
	2171	if (p.eatToken(.Ellipsis3)) \|token\| {
	2172	const range_end = try p.expectNode(parseExpr, .{
	2173	.ExpectedExpr = .{ .token = p.tok_i },
	2174	});
2357	2175
2358		const node = try arena.create(Node.PrefixOp);
2359		node.* = .{
2360		.op_token = token.index,
2361		.op = op,
2362		.rhs = undefined, // set by caller
2363		};
2364		return &node.base;
2365		}
	2176	const node = try p.arena.allocator.create(Node.InfixOp);
	2177	node.* = .{
	2178	.op_token = token,
	2179	.lhs = expr,
	2180	.op = .Range,
	2181	.rhs = range_end,
	2182	};
	2183	return &node.base;
	2184	}
	2185	return expr;
	2186	}
	2187
	2188	/// AssignOp
	2189	/// <- ASTERISKEQUAL
	2190	/// / SLASHEQUAL
	2191	/// / PERCENTEQUAL
	2192	/// / PLUSEQUAL
	2193	/// / MINUSEQUAL
	2194	/// / LARROW2EQUAL
	2195	/// / RARROW2EQUAL
	2196	/// / AMPERSANDEQUAL
	2197	/// / CARETEQUAL
	2198	/// / PIPEEQUAL
	2199	/// / ASTERISKPERCENTEQUAL
	2200	/// / PLUSPERCENTEQUAL
	2201	/// / MINUSPERCENTEQUAL
	2202	/// / EQUAL
	2203	fn parseAssignOp(p: Parser) !?Node {
	2204	const token = p.nextToken();
	2205	const op: Node.InfixOp.Op = switch (token.ptr.id) {
	2206	.AsteriskEqual => .AssignMul,
	2207	.SlashEqual => .AssignDiv,
	2208	.PercentEqual => .AssignMod,
	2209	.PlusEqual => .AssignAdd,
	2210	.MinusEqual => .AssignSub,
	2211	.AngleBracketAngleBracketLeftEqual => .AssignBitShiftLeft,
	2212	.AngleBracketAngleBracketRightEqual => .AssignBitShiftRight,
	2213	.AmpersandEqual => .AssignBitAnd,
	2214	.CaretEqual => .AssignBitXor,
	2215	.PipeEqual => .AssignBitOr,
	2216	.AsteriskPercentEqual => .AssignMulWrap,
	2217	.PlusPercentEqual => .AssignAddWrap,
	2218	.MinusPercentEqual => .AssignSubWrap,
	2219	.Equal => .Assign,
	2220	else => {
	2221	p.putBackToken(token.index);
	2222	return null;
	2223	},
	2224	};
2366	2225
2367		// TODO: ArrayTypeStart is either an array or a slice, but const/allowzero only work on
2368		// pointers. Consider updating this rule:
2369		// ...
2370		// / ArrayTypeStart
2371		// / SliceTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
2372		// / PtrTypeStart ...
2373
2374		/// PrefixTypeOp
2375		/// <- QUESTIONMARK
2376		/// / KEYWORD_anyframe MINUSRARROW
2377		/// / ArrayTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
2378		/// / PtrTypeStart (KEYWORD_align LPAREN Expr (COLON INTEGER COLON INTEGER)? RPAREN / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
2379		fn parsePrefixTypeOp(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2380		if (eatToken(it, .QuestionMark)) \|token\| {
2381		const node = try arena.create(Node.PrefixOp);
	2226	const node = try p.arena.allocator.create(Node.InfixOp);
2382	2227	node.* = .{
2383		.op_token = token,
2384		.op = .OptionalType,
	2228	.op_token = token.index,
	2229	.lhs = undefined, // set by caller
	2230	.op = op,
2385	2231	.rhs = undefined, // set by caller
2386	2232	};
2387	2233	return &node.base;
2388	2234	}
2389	2235
2390		// TODO: Returning a AnyFrameType instead of PrefixOp makes casting and setting .rhs or
2391		// .return_type more difficult for the caller (see parsePrefixOpExpr helper).
2392		// Consider making the AnyFrameType a member of PrefixOp and add a
2393		// PrefixOp.AnyFrameType variant?
2394		if (eatToken(it, .Keyword_anyframe)) \|token\| {
2395		const arrow = eatToken(it, .Arrow) orelse {
2396		putBackToken(it, token);
2397		return null;
	2236	/// CompareOp
	2237	/// <- EQUALEQUAL
	2238	/// / EXCLAMATIONMARKEQUAL
	2239	/// / LARROW
	2240	/// / RARROW
	2241	/// / LARROWEQUAL
	2242	/// / RARROWEQUAL
	2243	fn parseCompareOp(p: Parser) !?Node {
	2244	const token = p.nextToken();
	2245	const op: Node.InfixOp.Op = switch (token.ptr.id) {
	2246	.EqualEqual => .EqualEqual,
	2247	.BangEqual => .BangEqual,
	2248	.AngleBracketLeft => .LessThan,
	2249	.AngleBracketRight => .GreaterThan,
	2250	.AngleBracketLeftEqual => .LessOrEqual,
	2251	.AngleBracketRightEqual => .GreaterOrEqual,
	2252	else => {
	2253	p.putBackToken(token.index);
	2254	return null;
	2255	},
2398	2256	};
2399		const node = try arena.create(Node.AnyFrameType);
2400		node.* = .{
2401		.anyframe_token = token,
2402		.result = .{
2403		.arrow_token = arrow,
2404		.return_type = undefined, // set by caller
	2257
	2258	return p.createInfixOp(token.index, op);
	2259	}
	2260
	2261	/// BitwiseOp
	2262	/// <- AMPERSAND
	2263	/// / CARET
	2264	/// / PIPE
	2265	/// / KEYWORD_orelse
	2266	/// / KEYWORD_catch Payload?
	2267	fn parseBitwiseOp(p: Parser) !?Node {
	2268	const token = p.nextToken();
	2269	const op: Node.InfixOp.Op = switch (token.ptr.id) {
	2270	.Ampersand => .BitAnd,
	2271	.Caret => .BitXor,
	2272	.Pipe => .BitOr,
	2273	.Keyword_orelse => .UnwrapOptional,
	2274	.Keyword_catch => .{ .Catch = try p.parsePayload() },
	2275	else => {
	2276	p.putBackToken(token.index);
	2277	return null;
	2278	},
	2279	};
	2280
	2281	return p.createInfixOp(token.index, op);
	2282	}
	2283
	2284	/// BitShiftOp
	2285	/// <- LARROW2
	2286	/// / RARROW2
	2287	fn parseBitShiftOp(p: Parser) !?Node {
	2288	const token = p.nextToken();
	2289	const op: Node.InfixOp.Op = switch (token.ptr.id) {
	2290	.AngleBracketAngleBracketLeft => .BitShiftLeft,
	2291	.AngleBracketAngleBracketRight => .BitShiftRight,
	2292	else => {
	2293	p.putBackToken(token.index);
	2294	return null;
	2295	},
	2296	};
	2297
	2298	return p.createInfixOp(token.index, op);
	2299	}
	2300
	2301	/// AdditionOp
	2302	/// <- PLUS
	2303	/// / MINUS
	2304	/// / PLUS2
	2305	/// / PLUSPERCENT
	2306	/// / MINUSPERCENT
	2307	fn parseAdditionOp(p: Parser) !?Node {
	2308	const token = p.nextToken();
	2309	const op: Node.InfixOp.Op = switch (token.ptr.id) {
	2310	.Plus => .Add,
	2311	.Minus => .Sub,
	2312	.PlusPlus => .ArrayCat,
	2313	.PlusPercent => .AddWrap,
	2314	.MinusPercent => .SubWrap,
	2315	else => {
	2316	p.putBackToken(token.index);
	2317	return null;
	2318	},
	2319	};
	2320
	2321	return p.createInfixOp(token.index, op);
	2322	}
	2323
	2324	/// MultiplyOp
	2325	/// <- PIPE2
	2326	/// / ASTERISK
	2327	/// / SLASH
	2328	/// / PERCENT
	2329	/// / ASTERISK2
	2330	/// / ASTERISKPERCENT
	2331	fn parseMultiplyOp(p: Parser) !?Node {
	2332	const token = p.nextToken();
	2333	const op: Node.InfixOp.Op = switch (token.ptr.id) {
	2334	.PipePipe => .MergeErrorSets,
	2335	.Asterisk => .Mul,
	2336	.Slash => .Div,
	2337	.Percent => .Mod,
	2338	.AsteriskAsterisk => .ArrayMult,
	2339	.AsteriskPercent => .MulWrap,
	2340	else => {
	2341	p.putBackToken(token.index);
	2342	return null;
	2343	},
	2344	};
	2345
	2346	return p.createInfixOp(token.index, op);
	2347	}
	2348
	2349	/// PrefixOp
	2350	/// <- EXCLAMATIONMARK
	2351	/// / MINUS
	2352	/// / TILDE
	2353	/// / MINUSPERCENT
	2354	/// / AMPERSAND
	2355	/// / KEYWORD_try
	2356	/// / KEYWORD_await
	2357	fn parsePrefixOp(p: Parser) !?Node {
	2358	const token = p.nextToken();
	2359	const op: Node.PrefixOp.Op = switch (token.ptr.id) {
	2360	.Bang => .BoolNot,
	2361	.Minus => .Negation,
	2362	.Tilde => .BitNot,
	2363	.MinusPercent => .NegationWrap,
	2364	.Ampersand => .AddressOf,
	2365	.Keyword_try => .Try,
	2366	.Keyword_await => .Await,
	2367	else => {
	2368	p.putBackToken(token.index);
	2369	return null;
2405	2370	},
2406	2371	};
	2372
	2373	const node = try p.arena.allocator.create(Node.PrefixOp);
	2374	node.* = .{
	2375	.op_token = token.index,
	2376	.op = op,
	2377	.rhs = undefined, // set by caller
	2378	};
2407	2379	return &node.base;
2408	2380	}
2409	2381
2410		if (try parsePtrTypeStart(arena, it, tree)) \|node\| {
2411		// If the token encountered was **, there will be two nodes instead of one.
2412		// The attributes should be applied to the rightmost operator.
2413		const prefix_op = node.cast(Node.PrefixOp).?;
2414		var ptr_info = if (tree.tokens.at(prefix_op.op_token).id == .AsteriskAsterisk)
2415		&prefix_op.rhs.cast(Node.PrefixOp).?.op.PtrType
2416		else
2417		&prefix_op.op.PtrType;
	2382	// TODO: ArrayTypeStart is either an array or a slice, but const/allowzero only work on
	2383	// pointers. Consider updating this rule:
	2384	// ...
	2385	// / ArrayTypeStart
	2386	// / SliceTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
	2387	// / PtrTypeStart ...
	2388
	2389	/// PrefixTypeOp
	2390	/// <- QUESTIONMARK
	2391	/// / KEYWORD_anyframe MINUSRARROW
	2392	/// / ArrayTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
	2393	/// / PtrTypeStart (KEYWORD_align LPAREN Expr (COLON INTEGER COLON INTEGER)? RPAREN / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
	2394	fn parsePrefixTypeOp(p: Parser) !?Node {
	2395	if (p.eatToken(.QuestionMark)) \|token\| {
	2396	const node = try p.arena.allocator.create(Node.PrefixOp);
	2397	node.* = .{
	2398	.op_token = token,
	2399	.op = .OptionalType,
	2400	.rhs = undefined, // set by caller
	2401	};
	2402	return &node.base;
	2403	}
2418	2404
2419		while (true) {
2420		if (eatToken(it, .Keyword_align)) \|align_token\| {
2421		const lparen = try expectToken(it, tree, .LParen);
2422		const expr_node = try expectNode(arena, it, tree, parseExpr, .{
2423		.ExpectedExpr = .{ .token = it.index },
2424		});
	2405	// TODO: Returning a AnyFrameType instead of PrefixOp makes casting and setting .rhs or
	2406	// .return_type more difficult for the caller (see parsePrefixOpExpr helper).
	2407	// Consider making the AnyFrameType a member of PrefixOp and add a
	2408	// PrefixOp.AnyFrameType variant?
	2409	if (p.eatToken(.Keyword_anyframe)) \|token\| {
	2410	const arrow = p.eatToken(.Arrow) orelse {
	2411	p.putBackToken(token);
	2412	return null;
	2413	};
	2414	const node = try p.arena.allocator.create(Node.AnyFrameType);
	2415	node.* = .{
	2416	.anyframe_token = token,
	2417	.result = .{
	2418	.arrow_token = arrow,
	2419	.return_type = undefined, // set by caller
	2420	},
	2421	};
	2422	return &node.base;
	2423	}
2425	2424
2426		// Optional bit range
2427		const bit_range = if (eatToken(it, .Colon)) \|_\| bit_range_value: {
2428		const range_start = try expectNode(arena, it, tree, parseIntegerLiteral, .{
2429		.ExpectedIntegerLiteral = .{ .token = it.index },
2430		});
2431		_ = try expectToken(it, tree, .Colon);
2432		const range_end = try expectNode(arena, it, tree, parseIntegerLiteral, .{
2433		.ExpectedIntegerLiteral = .{ .token = it.index },
	2425	if (try p.parsePtrTypeStart()) \|node\| {
	2426	// If the token encountered was **, there will be two nodes instead of one.
	2427	// The attributes should be applied to the rightmost operator.
	2428	const prefix_op = node.cast(Node.PrefixOp).?;
	2429	var ptr_info = if (p.tokens[prefix_op.op_token].id == .AsteriskAsterisk)
	2430	&prefix_op.rhs.cast(Node.PrefixOp).?.op.PtrType
	2431	else
	2432	&prefix_op.op.PtrType;
	2433
	2434	while (true) {
	2435	if (p.eatToken(.Keyword_align)) \|align_token\| {
	2436	const lparen = try p.expectToken(.LParen);
	2437	const expr_node = try p.expectNode(parseExpr, .{
	2438	.ExpectedExpr = .{ .token = p.tok_i },
2434	2439	});
2435	2440
2436		break :bit_range_value Node.PrefixOp.PtrInfo.Align.BitRange{
2437		.start = range_start,
2438		.end = range_end,
	2441	// Optional bit range
	2442	const bit_range = if (p.eatToken(.Colon)) \|_\| bit_range_value: {
	2443	const range_start = try p.expectNode(parseIntegerLiteral, .{
	2444	.ExpectedIntegerLiteral = .{ .token = p.tok_i },
	2445	});
	2446	_ = try p.expectToken(.Colon);
	2447	const range_end = try p.expectNode(parseIntegerLiteral, .{
	2448	.ExpectedIntegerLiteral = .{ .token = p.tok_i },
	2449	});
	2450
	2451	break :bit_range_value Node.PrefixOp.PtrInfo.Align.BitRange{
	2452	.start = range_start,
	2453	.end = range_end,
	2454	};
	2455	} else null;
	2456	_ = try p.expectToken(.RParen);
	2457
	2458	if (ptr_info.align_info != null) {
	2459	try p.errors.append(p.gpa, .{
	2460	.ExtraAlignQualifier = .{ .token = p.tok_i - 1 },
	2461	});
	2462	continue;
	2463	}
	2464
	2465	ptr_info.align_info = Node.PrefixOp.PtrInfo.Align{
	2466	.node = expr_node,
	2467	.bit_range = bit_range,
2439	2468	};
2440		} else null;
2441		_ = try expectToken(it, tree, .RParen);
2442	2469
2443		if (ptr_info.align_info != null) {
2444		try tree.errors.push(.{
2445		.ExtraAlignQualifier = .{ .token = it.index - 1 },
2446		});
2447	2470	continue;
2448	2471	}
2449
2450		ptr_info.align_info = Node.PrefixOp.PtrInfo.Align{
2451		.node = expr_node,
2452		.bit_range = bit_range,
2453		};
2454
2455		continue;
2456		}
2457		if (eatToken(it, .Keyword_const)) \|const_token\| {
2458		if (ptr_info.const_token != null) {
2459		try tree.errors.push(.{
2460		.ExtraConstQualifier = .{ .token = it.index - 1 },
2461		});
	2472	if (p.eatToken(.Keyword_const)) \|const_token\| {
	2473	if (ptr_info.const_token != null) {
	2474	try p.errors.append(p.gpa, .{
	2475	.ExtraConstQualifier = .{ .token = p.tok_i - 1 },
	2476	});
	2477	continue;
	2478	}
	2479	ptr_info.const_token = const_token;
2462	2480	continue;
2463	2481	}
2464		ptr_info.const_token = const_token;
2465		continue;
2466		}
2467		if (eatToken(it, .Keyword_volatile)) \|volatile_token\| {
2468		if (ptr_info.volatile_token != null) {
2469		try tree.errors.push(.{
2470		.ExtraVolatileQualifier = .{ .token = it.index - 1 },
2471		});
	2482	if (p.eatToken(.Keyword_volatile)) \|volatile_token\| {
	2483	if (ptr_info.volatile_token != null) {
	2484	try p.errors.append(p.gpa, .{
	2485	.ExtraVolatileQualifier = .{ .token = p.tok_i - 1 },
	2486	});
	2487	continue;
	2488	}
	2489	ptr_info.volatile_token = volatile_token;
2472	2490	continue;
2473	2491	}
2474		ptr_info.volatile_token = volatile_token;
2475		continue;
2476		}
2477		if (eatToken(it, .Keyword_allowzero)) \|allowzero_token\| {
2478		if (ptr_info.allowzero_token != null) {
2479		try tree.errors.push(.{
2480		.ExtraAllowZeroQualifier = .{ .token = it.index - 1 },
2481		});
	2492	if (p.eatToken(.Keyword_allowzero)) \|allowzero_token\| {
	2493	if (ptr_info.allowzero_token != null) {
	2494	try p.errors.append(p.gpa, .{
	2495	.ExtraAllowZeroQualifier = .{ .token = p.tok_i - 1 },
	2496	});
	2497	continue;
	2498	}
	2499	ptr_info.allowzero_token = allowzero_token;
2482	2500	continue;
2483	2501	}
2484		ptr_info.allowzero_token = allowzero_token;
2485		continue;
	2502	break;
2486	2503	}
2487		break;
2488		}
2489	2504
2490		return node;
2491		}
	2505	return node;
	2506	}
2492	2507
2493		if (try parseArrayTypeStart(arena, it, tree)) \|node\| {
2494		switch (node.cast(Node.PrefixOp).?.op) {
2495		.ArrayType => {},
2496		.SliceType => \|*slice_type\| {
2497		// Collect pointer qualifiers in any order, but disallow duplicates
2498		while (true) {
2499		if (try parseByteAlign(arena, it, tree)) \|align_expr\| {
2500		if (slice_type.align_info != null) {
2501		try tree.errors.push(.{
2502		.ExtraAlignQualifier = .{ .token = it.index - 1 },
2503		});
	2508	if (try p.parseArrayTypeStart()) \|node\| {
	2509	switch (node.cast(Node.PrefixOp).?.op) {
	2510	.ArrayType => {},
	2511	.SliceType => \|*slice_type\| {
	2512	// Collect pointer qualifiers in any order, but disallow duplicates
	2513	while (true) {
	2514	if (try p.parseByteAlign()) \|align_expr\| {
	2515	if (slice_type.align_info != null) {
	2516	try p.errors.append(p.gpa, .{
	2517	.ExtraAlignQualifier = .{ .token = p.tok_i - 1 },
	2518	});
	2519	continue;
	2520	}
	2521	slice_type.align_info = Node.PrefixOp.PtrInfo.Align{
	2522	.node = align_expr,
	2523	.bit_range = null,
	2524	};
2504	2525	continue;
2505	2526	}
2506		slice_type.align_info = Node.PrefixOp.PtrInfo.Align{
2507		.node = align_expr,
2508		.bit_range = null,
2509		};
2510		continue;
2511		}
2512		if (eatToken(it, .Keyword_const)) \|const_token\| {
2513		if (slice_type.const_token != null) {
2514		try tree.errors.push(.{
2515		.ExtraConstQualifier = .{ .token = it.index - 1 },
2516		});
	2527	if (p.eatToken(.Keyword_const)) \|const_token\| {
	2528	if (slice_type.const_token != null) {
	2529	try p.errors.append(p.gpa, .{
	2530	.ExtraConstQualifier = .{ .token = p.tok_i - 1 },
	2531	});
	2532	continue;
	2533	}
	2534	slice_type.const_token = const_token;
2517	2535	continue;
2518	2536	}
2519		slice_type.const_token = const_token;
2520		continue;
2521		}
2522		if (eatToken(it, .Keyword_volatile)) \|volatile_token\| {
2523		if (slice_type.volatile_token != null) {
2524		try tree.errors.push(.{
2525		.ExtraVolatileQualifier = .{ .token = it.index - 1 },
2526		});
	2537	if (p.eatToken(.Keyword_volatile)) \|volatile_token\| {
	2538	if (slice_type.volatile_token != null) {
	2539	try p.errors.append(p.gpa, .{
	2540	.ExtraVolatileQualifier = .{ .token = p.tok_i - 1 },
	2541	});
	2542	continue;
	2543	}
	2544	slice_type.volatile_token = volatile_token;
2527	2545	continue;
2528	2546	}
2529		slice_type.volatile_token = volatile_token;
2530		continue;
	2547	if (p.eatToken(.Keyword_allowzero)) \|allowzero_token\| {
	2548	if (slice_type.allowzero_token != null) {
	2549	try p.errors.append(p.gpa, .{
	2550	.ExtraAllowZeroQualifier = .{ .token = p.tok_i - 1 },
	2551	});
	2552	continue;
	2553	}
	2554	slice_type.allowzero_token = allowzero_token;
	2555	continue;
	2556	}
	2557	break;
2531	2558	}
2532		if (eatToken(it, .Keyword_allowzero)) \|allowzero_token\| {
2533		if (slice_type.allowzero_token != null) {
2534		try tree.errors.push(.{
2535		.ExtraAllowZeroQualifier = .{ .token = it.index - 1 },
	2559	},
	2560	else => unreachable,
	2561	}
	2562	return node;
	2563	}
	2564
	2565	return null;
	2566	}
	2567
	2568	/// SuffixOp
	2569	/// <- LBRACKET Expr (DOT2 (Expr (COLON Expr)?)?)? RBRACKET
	2570	/// / DOT IDENTIFIER
	2571	/// / DOTASTERISK
	2572	/// / DOTQUESTIONMARK
	2573	fn parseSuffixOp(p: Parser) !?Node {
	2574	const OpAndToken = struct {
	2575	op: Node.SuffixOp.Op,
	2576	token: TokenIndex,
	2577	};
	2578	const op_and_token: OpAndToken = blk: {
	2579	if (p.eatToken(.LBracket)) \|_\| {
	2580	const index_expr = try p.expectNode(parseExpr, .{
	2581	.ExpectedExpr = .{ .token = p.tok_i },
	2582	});
	2583
	2584	if (p.eatToken(.Ellipsis2) != null) {
	2585	const end_expr = try p.parseExpr();
	2586	const sentinel: ?*ast.Node = if (p.eatToken(.Colon) != null)
	2587	try p.parseExpr()
	2588	else
	2589	null;
	2590	break :blk .{
	2591	.op = .{
	2592	.Slice = .{
	2593	.start = index_expr,
	2594	.end = end_expr,
	2595	.sentinel = sentinel,
	2596	},
	2597	},
	2598	.token = try p.expectToken(.RBracket),
	2599	};
	2600	}
	2601
	2602	break :blk .{
	2603	.op = .{ .ArrayAccess = index_expr },
	2604	.token = try p.expectToken(.RBracket),
	2605	};
	2606	}
	2607
	2608	if (p.eatToken(.PeriodAsterisk)) \|period_asterisk\| {
	2609	break :blk .{ .op = .Deref, .token = period_asterisk };
	2610	}
	2611
	2612	if (p.eatToken(.Period)) \|period\| {
	2613	if (try p.parseIdentifier()) \|identifier\| {
	2614	// TODO: It's a bit weird to return an InfixOp from the SuffixOp parser.
	2615	// Should there be an ast.Node.SuffixOp.FieldAccess variant? Or should
	2616	// this grammar rule be altered?
	2617	const node = try p.arena.allocator.create(Node.InfixOp);
	2618	node.* = .{
	2619	.op_token = period,
	2620	.lhs = undefined, // set by caller
	2621	.op = .Period,
	2622	.rhs = identifier,
	2623	};
	2624	return &node.base;
	2625	}
	2626	if (p.eatToken(.QuestionMark)) \|question_mark\| {
	2627	break :blk .{ .op = .UnwrapOptional, .token = question_mark };
	2628	}
	2629	try p.errors.append(p.gpa, .{
	2630	.ExpectedSuffixOp = .{ .token = p.tok_i },
	2631	});
	2632	return null;
	2633	}
	2634
	2635	return null;
	2636	};
	2637
	2638	const node = try p.arena.allocator.create(Node.SuffixOp);
	2639	node.* = .{
	2640	.lhs = undefined, // set by caller
	2641	.op = op_and_token.op,
	2642	.rtoken = op_and_token.token,
	2643	};
	2644	return &node.base;
	2645	}
	2646
	2647	/// FnCallArguments <- LPAREN ExprList RPAREN
	2648	/// ExprList <- (Expr COMMA)* Expr?
	2649	fn parseFnCallArguments(p: *Parser) !?AnnotatedParamList {
	2650	if (p.eatToken(.LParen) == null) return null;
	2651	const list = try ListParseFn(Node.FnProto.ParamList, parseExpr)(p);
	2652	const rparen = try p.expectToken(.RParen);
	2653	return AnnotatedParamList{ .list = list, .rparen = rparen };
	2654	}
	2655
	2656	const AnnotatedParamList = struct {
	2657	list: Node.FnProto.ParamList, // NOTE: may also be any other type SegmentedList(*Node, 2)
	2658	rparen: TokenIndex,
	2659	};
	2660
	2661	/// ArrayTypeStart <- LBRACKET Expr? RBRACKET
	2662	fn parseArrayTypeStart(p: Parser) !?Node {
	2663	const lbracket = p.eatToken(.LBracket) orelse return null;
	2664	const expr = try p.parseExpr();
	2665	const sentinel = if (p.eatToken(.Colon)) \|_\|
	2666	try p.expectNode(parseExpr, .{
	2667	.ExpectedExpr = .{ .token = p.tok_i },
	2668	})
	2669	else
	2670	null;
	2671	const rbracket = try p.expectToken(.RBracket);
	2672
	2673	const op: Node.PrefixOp.Op = if (expr) \|len_expr\|
	2674	.{
	2675	.ArrayType = .{
	2676	.len_expr = len_expr,
	2677	.sentinel = sentinel,
	2678	},
	2679	}
	2680	else
	2681	.{
	2682	.SliceType = Node.PrefixOp.PtrInfo{
	2683	.allowzero_token = null,
	2684	.align_info = null,
	2685	.const_token = null,
	2686	.volatile_token = null,
	2687	.sentinel = sentinel,
	2688	},
	2689	};
	2690
	2691	const node = try p.arena.allocator.create(Node.PrefixOp);
	2692	node.* = .{
	2693	.op_token = lbracket,
	2694	.op = op,
	2695	.rhs = undefined, // set by caller
	2696	};
	2697	return &node.base;
	2698	}
	2699
	2700	/// PtrTypeStart
	2701	/// <- ASTERISK
	2702	/// / ASTERISK2
	2703	/// / PTRUNKNOWN
	2704	/// / PTRC
	2705	fn parsePtrTypeStart(p: Parser) !?Node {
	2706	if (p.eatToken(.Asterisk)) \|asterisk\| {
	2707	const sentinel = if (p.eatToken(.Colon)) \|_\|
	2708	try p.expectNode(parseExpr, .{
	2709	.ExpectedExpr = .{ .token = p.tok_i },
	2710	})
	2711	else
	2712	null;
	2713	const node = try p.arena.allocator.create(Node.PrefixOp);
	2714	node.* = .{
	2715	.op_token = asterisk,
	2716	.op = .{ .PtrType = .{ .sentinel = sentinel } },
	2717	.rhs = undefined, // set by caller
	2718	};
	2719	return &node.base;
	2720	}
	2721
	2722	if (p.eatToken(.AsteriskAsterisk)) \|double_asterisk\| {
	2723	const node = try p.arena.allocator.create(Node.PrefixOp);
	2724	node.* = .{
	2725	.op_token = double_asterisk,
	2726	.op = .{ .PtrType = .{} },
	2727	.rhs = undefined, // set by caller
	2728	};
	2729
	2730	// Special case for **, which is its own token
	2731	const child = try p.arena.allocator.create(Node.PrefixOp);
	2732	child.* = .{
	2733	.op_token = double_asterisk,
	2734	.op = .{ .PtrType = .{} },
	2735	.rhs = undefined, // set by caller
	2736	};
	2737	node.rhs = &child.base;
	2738
	2739	return &node.base;
	2740	}
	2741	if (p.eatToken(.LBracket)) \|lbracket\| {
	2742	const asterisk = p.eatToken(.Asterisk) orelse {
	2743	p.putBackToken(lbracket);
	2744	return null;
	2745	};
	2746	if (p.eatToken(.Identifier)) \|ident\| {
	2747	const token_slice = p.source[p.tokens[ident].start..p.tokens[ident].end];
	2748	if (!std.mem.eql(u8, token_slice, "c")) {
	2749	p.putBackToken(ident);
	2750	} else {
	2751	_ = try p.expectToken(.RBracket);
	2752	const node = try p.arena.allocator.create(Node.PrefixOp);
	2753	node.* = .{
	2754	.op_token = lbracket,
	2755	.op = .{ .PtrType = .{} },
	2756	.rhs = undefined, // set by caller
	2757	};
	2758	return &node.base;
	2759	}
	2760	}
	2761	const sentinel = if (p.eatToken(.Colon)) \|_\|
	2762	try p.expectNode(parseExpr, .{
	2763	.ExpectedExpr = .{ .token = p.tok_i },
	2764	})
	2765	else
	2766	null;
	2767	_ = try p.expectToken(.RBracket);
	2768	const node = try p.arena.allocator.create(Node.PrefixOp);
	2769	node.* = .{
	2770	.op_token = lbracket,
	2771	.op = .{ .PtrType = .{ .sentinel = sentinel } },
	2772	.rhs = undefined, // set by caller
	2773	};
	2774	return &node.base;
	2775	}
	2776	return null;
	2777	}
	2778
	2779	/// ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE
	2780	fn parseContainerDeclAuto(p: Parser) !?Node {
	2781	const node = (try p.parseContainerDeclType()) orelse return null;
	2782	const lbrace = try p.expectToken(.LBrace);
	2783	const members = try p.parseContainerMembers(false);
	2784	const rbrace = try p.expectToken(.RBrace);
	2785
	2786	const decl_type = node.cast(Node.ContainerDecl).?;
	2787	decl_type.fields_and_decls = members;
	2788	decl_type.lbrace_token = lbrace;
	2789	decl_type.rbrace_token = rbrace;
	2790
	2791	return node;
	2792	}
	2793
	2794	/// ContainerDeclType
	2795	/// <- KEYWORD_struct
	2796	/// / KEYWORD_enum (LPAREN Expr RPAREN)?
	2797	/// / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
	2798	fn parseContainerDeclType(p: Parser) !?Node {
	2799	const kind_token = p.nextToken();
	2800
	2801	const init_arg_expr = switch (kind_token.ptr.id) {
	2802	.Keyword_struct => Node.ContainerDecl.InitArg{ .None = {} },
	2803	.Keyword_enum => blk: {
	2804	if (p.eatToken(.LParen) != null) {
	2805	const expr = try p.expectNode(parseExpr, .{
	2806	.ExpectedExpr = .{ .token = p.tok_i },
	2807	});
	2808	_ = try p.expectToken(.RParen);
	2809	break :blk Node.ContainerDecl.InitArg{ .Type = expr };
	2810	}
	2811	break :blk Node.ContainerDecl.InitArg{ .None = {} };
	2812	},
	2813	.Keyword_union => blk: {
	2814	if (p.eatToken(.LParen) != null) {
	2815	if (p.eatToken(.Keyword_enum) != null) {
	2816	if (p.eatToken(.LParen) != null) {
	2817	const expr = try p.expectNode(parseExpr, .{
	2818	.ExpectedExpr = .{ .token = p.tok_i },
2536	2819	});
2537		continue;
	2820	_ = try p.expectToken(.RParen);
	2821	_ = try p.expectToken(.RParen);
	2822	break :blk Node.ContainerDecl.InitArg{ .Enum = expr };
2538	2823	}
2539		slice_type.allowzero_token = allowzero_token;
2540		continue;
	2824	_ = try p.expectToken(.RParen);
	2825	break :blk Node.ContainerDecl.InitArg{ .Enum = null };
	2826	}
	2827	const expr = try p.expectNode(parseExpr, .{
	2828	.ExpectedExpr = .{ .token = p.tok_i },
	2829	});
	2830	_ = try p.expectToken(.RParen);
	2831	break :blk Node.ContainerDecl.InitArg{ .Type = expr };
	2832	}
	2833	break :blk Node.ContainerDecl.InitArg{ .None = {} };
	2834	},
	2835	else => {
	2836	p.putBackToken(kind_token.index);
	2837	return null;
	2838	},
	2839	};
	2840
	2841	const node = try p.arena.allocator.create(Node.ContainerDecl);
	2842	node.* = .{
	2843	.layout_token = null,
	2844	.kind_token = kind_token.index,
	2845	.init_arg_expr = init_arg_expr,
	2846	.fields_and_decls = undefined, // set by caller
	2847	.lbrace_token = undefined, // set by caller
	2848	.rbrace_token = undefined, // set by caller
	2849	};
	2850	return &node.base;
	2851	}
	2852
	2853	/// ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
	2854	fn parseByteAlign(p: Parser) !?Node {
	2855	_ = p.eatToken(.Keyword_align) orelse return null;
	2856	_ = try p.expectToken(.LParen);
	2857	const expr = try p.expectNode(parseExpr, .{
	2858	.ExpectedExpr = .{ .token = p.tok_i },
	2859	});
	2860	_ = try p.expectToken(.RParen);
	2861	return expr;
	2862	}
	2863
	2864	/// IdentifierList <- (IDENTIFIER COMMA)* IDENTIFIER?
	2865	/// Only ErrorSetDecl parses an IdentifierList
	2866	fn parseErrorTagList(p: *Parser) !Node.ErrorSetDecl.DeclList {
	2867	return ListParseFn(Node.ErrorSetDecl.DeclList, parseErrorTag)(p);
	2868	}
	2869
	2870	/// SwitchProngList <- (SwitchProng COMMA)* SwitchProng?
	2871	fn parseSwitchProngList(p: *Parser) !Node.Switch.CaseList {
	2872	return ListParseFn(Node.Switch.CaseList, parseSwitchProng)(p);
	2873	}
	2874
	2875	/// AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem?
	2876	fn parseAsmOutputList(p: *Parser) Error!Node.Asm.OutputList {
	2877	return ListParseFn(Node.Asm.OutputList, parseAsmOutputItem)(p);
	2878	}
	2879
	2880	/// AsmInputList <- (AsmInputItem COMMA)* AsmInputItem?
	2881	fn parseAsmInputList(p: *Parser) Error!Node.Asm.InputList {
	2882	return ListParseFn(Node.Asm.InputList, parseAsmInputItem)(p);
	2883	}
	2884
	2885	/// ParamDeclList <- (ParamDecl COMMA)* ParamDecl?
	2886	fn parseParamDeclList(p: Parser, var_args_token: ?TokenIndex) !Node.FnProto.ParamList {
	2887	var list = Node.FnProto.ParamList{};
	2888	var list_it = &list.first;
	2889	var last: ?*Node = null;
	2890	while (try p.parseParamDecl()) \|node\| {
	2891	last = node;
	2892	list_it = try p.llpush(*Node, list_it, node);
	2893
	2894	switch (p.tokens[p.tok_i].id) {
	2895	.Comma => _ = p.nextToken(),
	2896	// all possible delimiters
	2897	.Colon, .RParen, .RBrace, .RBracket => break,
	2898	else => {
	2899	// this is likely just a missing comma,
	2900	// continue parsing this list and give an error
	2901	try p.errors.append(p.gpa, .{
	2902	.ExpectedToken = .{ .token = p.tok_i, .expected_id = .Comma },
	2903	});
	2904	},
	2905	}
	2906	}
	2907	if (last) \|node\| {
	2908	const param_type = node.cast(Node.ParamDecl).?.param_type;
	2909	if (param_type == .var_args) {
	2910	var_args_token.* = param_type.var_args;
	2911	}
	2912	}
	2913	return list;
	2914	}
	2915
	2916	const NodeParseFn = fn (p: Parser) Error!?Node;
	2917
	2918	fn ListParseFn(comptime L: type, comptime nodeParseFn: var) ParseFn(L) {
	2919	return struct {
	2920	pub fn parse(p: *Parser) !L {
	2921	var list = L{};
	2922	var list_it = &list.first;
	2923	while (try nodeParseFn(p)) \|node\| {
	2924	list_it = try p.llpush(L.Node.Data, list_it, node);
	2925
	2926	switch (p.tokens[p.tok_i].id) {
	2927	.Comma => _ = p.nextToken(),
	2928	// all possible delimiters
	2929	.Colon, .RParen, .RBrace, .RBracket => break,
	2930	else => {
	2931	// this is likely just a missing comma,
	2932	// continue parsing this list and give an error
	2933	try p.errors.append(p.gpa, .{
	2934	.ExpectedToken = .{ .token = p.tok_i, .expected_id = .Comma },
	2935	});
	2936	},
2541	2937	}
2542		break;
2543	2938	}
2544		},
2545		else => unreachable,
2546		}
2547		return node;
	2939	return list;
	2940	}
	2941	}.parse;
2548	2942	}
2549	2943
2550		return null;
2551		}
2552
2553		/// SuffixOp
2554		/// <- LBRACKET Expr (DOT2 (Expr (COLON Expr)?)?)? RBRACKET
2555		/// / DOT IDENTIFIER
2556		/// / DOTASTERISK
2557		/// / DOTQUESTIONMARK
2558		fn parseSuffixOp(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2559		const OpAndToken = struct {
2560		op: Node.SuffixOp.Op,
2561		token: TokenIndex,
2562		};
2563		const op_and_token: OpAndToken = blk: {
2564		if (eatToken(it, .LBracket)) \|_\| {
2565		const index_expr = try expectNode(arena, it, tree, parseExpr, .{
2566		.ExpectedExpr = .{ .token = it.index },
2567		});
2568
2569		if (eatToken(it, .Ellipsis2) != null) {
2570		const end_expr = try parseExpr(arena, it, tree);
2571		const sentinel: ?*ast.Node = if (eatToken(it, .Colon) != null)
2572		try parseExpr(arena, it, tree)
2573		else
2574		null;
2575		break :blk .{
2576		.op = .{
2577		.Slice = .{
2578		.start = index_expr,
2579		.end = end_expr,
2580		.sentinel = sentinel,
2581		},
	2944	fn SimpleBinOpParseFn(comptime token: Token.Id, comptime op: Node.InfixOp.Op) NodeParseFn {
	2945	return struct {
	2946	pub fn parse(p: Parser) Error!?Node {
	2947	const op_token = if (token == .Keyword_and) switch (p.tokens[p.tok_i].id) {
	2948	.Keyword_and => p.nextToken().index,
	2949	.Invalid_ampersands => blk: {
	2950	try p.errors.append(p.gpa, .{
	2951	.InvalidAnd = .{ .token = p.tok_i },
	2952	});
	2953	break :blk p.nextToken().index;
2582	2954	},
2583		.token = try expectToken(it, tree, .RBracket),
2584		};
2585		}
2586
2587		break :blk .{
2588		.op = .{ .ArrayAccess = index_expr },
2589		.token = try expectToken(it, tree, .RBracket),
2590		};
2591		}
2592
2593		if (eatToken(it, .PeriodAsterisk)) \|period_asterisk\| {
2594		break :blk .{ .op = .Deref, .token = period_asterisk };
2595		}
	2955	else => return null,
	2956	} else p.eatToken(token) orelse return null;
2596	2957
2597		if (eatToken(it, .Period)) \|period\| {
2598		if (try parseIdentifier(arena, it, tree)) \|identifier\| {
2599		// TODO: It's a bit weird to return an InfixOp from the SuffixOp parser.
2600		// Should there be an ast.Node.SuffixOp.FieldAccess variant? Or should
2601		// this grammar rule be altered?
2602		const node = try arena.create(Node.InfixOp);
	2958	const node = try p.arena.allocator.create(Node.InfixOp);
2603	2959	node.* = .{
2604		.op_token = period,
	2960	.op_token = op_token,
2605	2961	.lhs = undefined, // set by caller
2606		.op = .Period,
2607		.rhs = identifier,
	2962	.op = op,
	2963	.rhs = undefined, // set by caller
2608	2964	};
2609	2965	return &node.base;
2610	2966	}
2611		if (eatToken(it, .QuestionMark)) \|question_mark\| {
2612		break :blk .{ .op = .UnwrapOptional, .token = question_mark };
2613		}
2614		try tree.errors.push(.{
2615		.ExpectedSuffixOp = .{ .token = it.index },
2616		});
2617		return null;
2618		}
2619
2620		return null;
2621		};
2622
2623		const node = try arena.create(Node.SuffixOp);
2624		node.* = .{
2625		.lhs = undefined, // set by caller
2626		.op = op_and_token.op,
2627		.rtoken = op_and_token.token,
2628		};
2629		return &node.base;
2630		}
	2967	}.parse;
	2968	}
2631	2969
2632		/// FnCallArguments <- LPAREN ExprList RPAREN
2633		/// ExprList <- (Expr COMMA)* Expr?
2634		fn parseFnCallArguments(arena: Allocator, it: TokenIterator, tree: *Tree) !?AnnotatedParamList {
2635		if (eatToken(it, .LParen) == null) return null;
2636		const list = try ListParseFn(Node.FnProto.ParamList, parseExpr)(arena, it, tree);
2637		const rparen = try expectToken(it, tree, .RParen);
2638		return AnnotatedParamList{ .list = list, .rparen = rparen };
2639		}
	2970	// Helper parsers not included in the grammar
2640	2971
2641		const AnnotatedParamList = struct {
2642		list: Node.FnProto.ParamList, // NOTE: may also be any other type SegmentedList(*Node, 2)
2643		rparen: TokenIndex,
2644		};
	2972	fn parseBuiltinCall(p: Parser) !?Node {
	2973	const token = p.eatToken(.Builtin) orelse return null;
	2974	const params = (try p.parseFnCallArguments()) orelse {
	2975	try p.errors.append(p.gpa, .{
	2976	.ExpectedParamList = .{ .token = p.tok_i },
	2977	});
2645	2978
2646		/// ArrayTypeStart <- LBRACKET Expr? RBRACKET
2647		fn parseArrayTypeStart(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2648		const lbracket = eatToken(it, .LBracket) orelse return null;
2649		const expr = try parseExpr(arena, it, tree);
2650		const sentinel = if (eatToken(it, .Colon)) \|_\|
2651		try expectNode(arena, it, tree, parseExpr, .{
2652		.ExpectedExpr = .{ .token = it.index },
2653		})
2654		else
2655		null;
2656		const rbracket = try expectToken(it, tree, .RBracket);
2657
2658		const op: Node.PrefixOp.Op = if (expr) \|len_expr\|
2659		.{
2660		.ArrayType = .{
2661		.len_expr = len_expr,
2662		.sentinel = sentinel,
2663		},
2664		}
2665		else
2666		.{
2667		.SliceType = Node.PrefixOp.PtrInfo{
2668		.allowzero_token = null,
2669		.align_info = null,
2670		.const_token = null,
2671		.volatile_token = null,
2672		.sentinel = sentinel,
2673		},
	2979	// lets pretend this was an identifier so we can continue parsing
	2980	const node = try p.arena.allocator.create(Node.Identifier);
	2981	node.* = .{
	2982	.token = token,
	2983	};
	2984	return &node.base;
2674	2985	};
2675
2676		const node = try arena.create(Node.PrefixOp);
2677		node.* = .{
2678		.op_token = lbracket,
2679		.op = op,
2680		.rhs = undefined, // set by caller
2681		};
2682		return &node.base;
2683		}
2684
2685		/// PtrTypeStart
2686		/// <- ASTERISK
2687		/// / ASTERISK2
2688		/// / PTRUNKNOWN
2689		/// / PTRC
2690		fn parsePtrTypeStart(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2691		if (eatToken(it, .Asterisk)) \|asterisk\| {
2692		const sentinel = if (eatToken(it, .Colon)) \|_\|
2693		try expectNode(arena, it, tree, parseExpr, .{
2694		.ExpectedExpr = .{ .token = it.index },
2695		})
2696		else
2697		null;
2698		const node = try arena.create(Node.PrefixOp);
	2986	const node = try p.arena.allocator.create(Node.BuiltinCall);
2699	2987	node.* = .{
2700		.op_token = asterisk,
2701		.op = .{ .PtrType = .{ .sentinel = sentinel } },
2702		.rhs = undefined, // set by caller
	2988	.builtin_token = token,
	2989	.params = params.list,
	2990	.rparen_token = params.rparen,
2703	2991	};
2704	2992	return &node.base;
2705	2993	}
2706	2994
2707		if (eatToken(it, .AsteriskAsterisk)) \|double_asterisk\| {
2708		const node = try arena.create(Node.PrefixOp);
	2995	fn parseErrorTag(p: Parser) !?Node {
	2996	const doc_comments = try p.parseDocComment(); // no need to rewind on failure
	2997	const token = p.eatToken(.Identifier) orelse return null;
	2998
	2999	const node = try p.arena.allocator.create(Node.ErrorTag);
2709	3000	node.* = .{
2710		.op_token = double_asterisk,
2711		.op = .{ .PtrType = .{} },
2712		.rhs = undefined, // set by caller
	3001	.doc_comments = doc_comments,
	3002	.name_token = token,
2713	3003	};
	3004	return &node.base;
	3005	}
2714	3006
2715		// Special case for **, which is its own token
2716		const child = try arena.create(Node.PrefixOp);
2717		child.* = .{
2718		.op_token = double_asterisk,
2719		.op = .{ .PtrType = .{} },
2720		.rhs = undefined, // set by caller
	3007	fn parseIdentifier(p: Parser) !?Node {
	3008	const token = p.eatToken(.Identifier) orelse return null;
	3009	const node = try p.arena.allocator.create(Node.Identifier);
	3010	node.* = .{
	3011	.token = token,
2721	3012	};
2722		node.rhs = &child.base;
2723
2724	3013	return &node.base;
2725	3014	}
2726		if (eatToken(it, .LBracket)) \|lbracket\| {
2727		const asterisk = eatToken(it, .Asterisk) orelse {
2728		putBackToken(it, lbracket);
2729		return null;
2730		};
2731		if (eatToken(it, .Identifier)) \|ident\| {
2732		if (!std.mem.eql(u8, tree.tokenSlice(ident), "c")) {
2733		putBackToken(it, ident);
2734		} else {
2735		_ = try expectToken(it, tree, .RBracket);
2736		const node = try arena.create(Node.PrefixOp);
2737		node.* = .{
2738		.op_token = lbracket,
2739		.op = .{ .PtrType = .{} },
2740		.rhs = undefined, // set by caller
2741		};
2742		return &node.base;
2743		}
2744		}
2745		const sentinel = if (eatToken(it, .Colon)) \|_\|
2746		try expectNode(arena, it, tree, parseExpr, .{
2747		.ExpectedExpr = .{ .token = it.index },
2748		})
2749		else
2750		null;
2751		_ = try expectToken(it, tree, .RBracket);
2752		const node = try arena.create(Node.PrefixOp);
	3015
	3016	fn parseVarType(p: Parser) !?Node {
	3017	const token = p.eatToken(.Keyword_var) orelse return null;
	3018	const node = try p.arena.allocator.create(Node.VarType);
2753	3019	node.* = .{
2754		.op_token = lbracket,
2755		.op = .{ .PtrType = .{ .sentinel = sentinel } },
2756		.rhs = undefined, // set by caller
	3020	.token = token,
2757	3021	};
2758	3022	return &node.base;
2759	3023	}
2760		return null;
2761		}
2762
2763		/// ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE
2764		fn parseContainerDeclAuto(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2765		const node = (try parseContainerDeclType(arena, it, tree)) orelse return null;
2766		const lbrace = try expectToken(it, tree, .LBrace);
2767		const members = try parseContainerMembers(arena, it, tree, false);
2768		const rbrace = try expectToken(it, tree, .RBrace);
2769
2770		const decl_type = node.cast(Node.ContainerDecl).?;
2771		decl_type.fields_and_decls = members;
2772		decl_type.lbrace_token = lbrace;
2773		decl_type.rbrace_token = rbrace;
2774
2775		return node;
2776		}
2777
2778		/// ContainerDeclType
2779		/// <- KEYWORD_struct
2780		/// / KEYWORD_enum (LPAREN Expr RPAREN)?
2781		/// / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
2782		fn parseContainerDeclType(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2783		const kind_token = nextToken(it);
2784
2785		const init_arg_expr = switch (kind_token.ptr.id) {
2786		.Keyword_struct => Node.ContainerDecl.InitArg{ .None = {} },
2787		.Keyword_enum => blk: {
2788		if (eatToken(it, .LParen) != null) {
2789		const expr = try expectNode(arena, it, tree, parseExpr, .{
2790		.ExpectedExpr = .{ .token = it.index },
2791		});
2792		_ = try expectToken(it, tree, .RParen);
2793		break :blk Node.ContainerDecl.InitArg{ .Type = expr };
2794		}
2795		break :blk Node.ContainerDecl.InitArg{ .None = {} };
2796		},
2797		.Keyword_union => blk: {
2798		if (eatToken(it, .LParen) != null) {
2799		if (eatToken(it, .Keyword_enum) != null) {
2800		if (eatToken(it, .LParen) != null) {
2801		const expr = try expectNode(arena, it, tree, parseExpr, .{
2802		.ExpectedExpr = .{ .token = it.index },
2803		});
2804		_ = try expectToken(it, tree, .RParen);
2805		_ = try expectToken(it, tree, .RParen);
2806		break :blk Node.ContainerDecl.InitArg{ .Enum = expr };
2807		}
2808		_ = try expectToken(it, tree, .RParen);
2809		break :blk Node.ContainerDecl.InitArg{ .Enum = null };
2810		}
2811		const expr = try expectNode(arena, it, tree, parseExpr, .{
2812		.ExpectedExpr = .{ .token = it.index },
2813		});
2814		_ = try expectToken(it, tree, .RParen);
2815		break :blk Node.ContainerDecl.InitArg{ .Type = expr };
2816		}
2817		break :blk Node.ContainerDecl.InitArg{ .None = {} };
2818		},
2819		else => {
2820		putBackToken(it, kind_token.index);
2821		return null;
2822		},
2823		};
2824
2825		const node = try arena.create(Node.ContainerDecl);
2826		node.* = .{
2827		.layout_token = null,
2828		.kind_token = kind_token.index,
2829		.init_arg_expr = init_arg_expr,
2830		.fields_and_decls = undefined, // set by caller
2831		.lbrace_token = undefined, // set by caller
2832		.rbrace_token = undefined, // set by caller
2833		};
2834		return &node.base;
2835		}
2836
2837		/// ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
2838		fn parseByteAlign(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2839		_ = eatToken(it, .Keyword_align) orelse return null;
2840		_ = try expectToken(it, tree, .LParen);
2841		const expr = try expectNode(arena, it, tree, parseExpr, .{
2842		.ExpectedExpr = .{ .token = it.index },
2843		});
2844		_ = try expectToken(it, tree, .RParen);
2845		return expr;
2846		}
2847	3024
2848		/// IdentifierList <- (IDENTIFIER COMMA)* IDENTIFIER?
2849		/// Only ErrorSetDecl parses an IdentifierList
2850		fn parseErrorTagList(arena: Allocator, it: TokenIterator, tree: *Tree) !Node.ErrorSetDecl.DeclList {
2851		return try ListParseFn(Node.ErrorSetDecl.DeclList, parseErrorTag)(arena, it, tree);
2852		}
2853
2854		/// SwitchProngList <- (SwitchProng COMMA)* SwitchProng?
2855		fn parseSwitchProngList(arena: Allocator, it: TokenIterator, tree: *Tree) !Node.Switch.CaseList {
2856		return try ListParseFn(Node.Switch.CaseList, parseSwitchProng)(arena, it, tree);
2857		}
2858
2859		/// AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem?
2860		fn parseAsmOutputList(arena: Allocator, it: TokenIterator, tree: *Tree) Error!Node.Asm.OutputList {
2861		return try ListParseFn(Node.Asm.OutputList, parseAsmOutputItem)(arena, it, tree);
2862		}
2863
2864		/// AsmInputList <- (AsmInputItem COMMA)* AsmInputItem?
2865		fn parseAsmInputList(arena: Allocator, it: TokenIterator, tree: *Tree) Error!Node.Asm.InputList {
2866		return try ListParseFn(Node.Asm.InputList, parseAsmInputItem)(arena, it, tree);
2867		}
2868
2869		/// ParamDeclList <- (ParamDecl COMMA)* ParamDecl?
2870		fn parseParamDeclList(arena: Allocator, it: TokenIterator, tree: *Tree) !Node.FnProto.ParamList {
2871		return try ListParseFn(Node.FnProto.ParamList, parseParamDecl)(arena, it, tree);
2872		}
2873
2874		fn ParseFn(comptime T: type) type {
2875		return fn (Allocator, TokenIterator, *Tree) Error!T;
2876		}
	3025	fn createLiteral(p: Parser, comptime T: type, token: TokenIndex) !Node {
	3026	const result = try p.arena.allocator.create(T);
	3027	result.* = T{
	3028	.base = Node{ .id = Node.typeToId(T) },
	3029	.token = token,
	3030	};
	3031	return &result.base;
	3032	}
2877	3033
2878		const NodeParseFn = fn (Allocator, TokenIterator, Tree) Error!?Node;
2879
2880		fn ListParseFn(comptime L: type, comptime nodeParseFn: var) ParseFn(L) {
2881		return struct {
2882		pub fn parse(arena: Allocator, it: TokenIterator, tree: *Tree) !L {
2883		var list = L.init(arena);
2884		while (try nodeParseFn(arena, it, tree)) \|node\| {
2885		try list.push(node);
2886
2887		switch (it.peek().?.id) {
2888		.Comma => _ = nextToken(it),
2889		// all possible delimiters
2890		.Colon, .RParen, .RBrace, .RBracket => break,
2891		else => {
2892		// this is likely just a missing comma,
2893		// continue parsing this list and give an error
2894		try tree.errors.push(.{
2895		.ExpectedToken = .{ .token = it.index, .expected_id = .Comma },
2896		});
2897		},
2898		}
2899		}
2900		return list;
	3034	fn parseStringLiteralSingle(p: Parser) !?Node {
	3035	if (p.eatToken(.StringLiteral)) \|token\| {
	3036	const node = try p.arena.allocator.create(Node.StringLiteral);
	3037	node.* = .{
	3038	.token = token,
	3039	};
	3040	return &node.base;
2901	3041	}
2902		}.parse;
2903		}
	3042	return null;
	3043	}
2904	3044
2905		fn SimpleBinOpParseFn(comptime token: Token.Id, comptime op: Node.InfixOp.Op) NodeParseFn {
2906		return struct {
2907		pub fn parse(arena: Allocator, it: TokenIterator, tree: Tree) Error!?Node {
2908		const op_token = if (token == .Keyword_and) switch (it.peek().?.id) {
2909		.Keyword_and => nextToken(it).index,
2910		.Invalid_ampersands => blk: {
2911		try tree.errors.push(.{
2912		.InvalidAnd = .{ .token = it.index },
2913		});
2914		break :blk nextToken(it).index;
2915		},
2916		else => return null,
2917		} else eatToken(it, token) orelse return null;
	3045	// string literal or multiline string literal
	3046	fn parseStringLiteral(p: Parser) !?Node {
	3047	if (try p.parseStringLiteralSingle()) \|node\| return node;
2918	3048
2919		const node = try arena.create(Node.InfixOp);
	3049	if (p.eatToken(.MultilineStringLiteralLine)) \|first_line\| {
	3050	const node = try p.arena.allocator.create(Node.MultilineStringLiteral);
2920	3051	node.* = .{
2921		.op_token = op_token,
2922		.lhs = undefined, // set by caller
2923		.op = op,
2924		.rhs = undefined, // set by caller
	3052	.lines = Node.MultilineStringLiteral.LineList{},
2925	3053	};
	3054	var lines_it = &node.lines.first;
	3055	lines_it = try p.llpush(TokenIndex, lines_it, first_line);
	3056	while (p.eatToken(.MultilineStringLiteralLine)) \|line\|
	3057	lines_it = try p.llpush(TokenIndex, lines_it, line);
	3058
2926	3059	return &node.base;
2927	3060	}
2928		}.parse;
2929		}
2930	3061
2931		// Helper parsers not included in the grammar
2932
2933		fn parseBuiltinCall(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2934		const token = eatToken(it, .Builtin) orelse return null;
2935		const params = (try parseFnCallArguments(arena, it, tree)) orelse {
2936		try tree.errors.push(.{
2937		.ExpectedParamList = .{ .token = it.index },
2938		});
	3062	return null;
	3063	}
2939	3064
2940		// lets pretend this was an identifier so we can continue parsing
2941		const node = try arena.create(Node.Identifier);
	3065	fn parseIntegerLiteral(p: Parser) !?Node {
	3066	const token = p.eatToken(.IntegerLiteral) orelse return null;
	3067	const node = try p.arena.allocator.create(Node.IntegerLiteral);
2942	3068	node.* = .{
2943	3069	.token = token,
2944	3070	};
2945	3071	return &node.base;
2946		};
2947		const node = try arena.create(Node.BuiltinCall);
2948		node.* = .{
2949		.builtin_token = token,
2950		.params = params.list,
2951		.rparen_token = params.rparen,
2952		};
2953		return &node.base;
2954		}
2955
2956		fn parseErrorTag(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2957		const doc_comments = try parseDocComment(arena, it, tree); // no need to rewind on failure
2958		const token = eatToken(it, .Identifier) orelse return null;
2959
2960		const node = try arena.create(Node.ErrorTag);
2961		node.* = .{
2962		.doc_comments = doc_comments,
2963		.name_token = token,
2964		};
2965		return &node.base;
2966		}
2967
2968		fn parseIdentifier(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2969		const token = eatToken(it, .Identifier) orelse return null;
2970		const node = try arena.create(Node.Identifier);
2971		node.* = .{
2972		.token = token,
2973		};
2974		return &node.base;
2975		}
2976
2977		fn parseVarType(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2978		const token = eatToken(it, .Keyword_var) orelse return null;
2979		const node = try arena.create(Node.VarType);
2980		node.* = .{
2981		.token = token,
2982		};
2983		return &node.base;
2984		}
2985
2986		fn createLiteral(arena: Allocator, comptime T: type, token: TokenIndex) !Node {
2987		const result = try arena.create(T);
2988		result.* = T{
2989		.base = Node{ .id = Node.typeToId(T) },
2990		.token = token,
2991		};
2992		return &result.base;
2993		}
	3072	}
2994	3073
2995		fn parseStringLiteralSingle(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
2996		if (eatToken(it, .StringLiteral)) \|token\| {
2997		const node = try arena.create(Node.StringLiteral);
	3074	fn parseFloatLiteral(p: Parser) !?Node {
	3075	const token = p.eatToken(.FloatLiteral) orelse return null;
	3076	const node = try p.arena.allocator.create(Node.FloatLiteral);
2998	3077	node.* = .{
2999	3078	.token = token,
3000	3079	};
3001	3080	return &node.base;
3002	3081	}
3003		return null;
3004		}
3005	3082
3006		// string literal or multiline string literal
3007		fn parseStringLiteral(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
3008		if (try parseStringLiteralSingle(arena, it, tree)) \|node\| return node;
3009
3010		if (eatToken(it, .MultilineStringLiteralLine)) \|first_line\| {
3011		const node = try arena.create(Node.MultilineStringLiteral);
	3083	fn parseTry(p: Parser) !?Node {
	3084	const token = p.eatToken(.Keyword_try) orelse return null;
	3085	const node = try p.arena.allocator.create(Node.PrefixOp);
3012	3086	node.* = .{
3013		.lines = Node.MultilineStringLiteral.LineList.init(arena),
	3087	.op_token = token,
	3088	.op = .Try,
	3089	.rhs = undefined, // set by caller
3014	3090	};
3015		try node.lines.push(first_line);
3016		while (eatToken(it, .MultilineStringLiteralLine)) \|line\|
3017		try node.lines.push(line);
	3091	return &node.base;
	3092	}
3018	3093
	3094	fn parseUse(p: Parser) !?Node {
	3095	const token = p.eatToken(.Keyword_usingnamespace) orelse return null;
	3096	const node = try p.arena.allocator.create(Node.Use);
	3097	node.* = .{
	3098	.doc_comments = null,
	3099	.visib_token = null,
	3100	.use_token = token,
	3101	.expr = try p.expectNode(parseExpr, .{
	3102	.ExpectedExpr = .{ .token = p.tok_i },
	3103	}),
	3104	.semicolon_token = try p.expectToken(.Semicolon),
	3105	};
3019	3106	return &node.base;
3020	3107	}
3021	3108
3022		return null;
3023		}
	3109	/// IfPrefix Body (KEYWORD_else Payload? Body)?
	3110	fn parseIf(p: Parser, bodyParseFn: NodeParseFn) !?Node {
	3111	const node = (try p.parseIfPrefix()) orelse return null;
	3112	const if_prefix = node.cast(Node.If).?;
3024	3113
3025		fn parseIntegerLiteral(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
3026		const token = eatToken(it, .IntegerLiteral) orelse return null;
3027		const node = try arena.create(Node.IntegerLiteral);
3028		node.* = .{
3029		.token = token,
3030		};
3031		return &node.base;
3032		}
	3114	if_prefix.body = try p.expectNode(bodyParseFn, .{
	3115	.InvalidToken = .{ .token = p.tok_i },
	3116	});
3033	3117
3034		fn parseFloatLiteral(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
3035		const token = eatToken(it, .FloatLiteral) orelse return null;
3036		const node = try arena.create(Node.FloatLiteral);
3037		node.* = .{
3038		.token = token,
3039		};
3040		return &node.base;
3041		}
	3118	const else_token = p.eatToken(.Keyword_else) orelse return node;
	3119	const payload = try p.parsePayload();
	3120	const else_expr = try p.expectNode(bodyParseFn, .{
	3121	.InvalidToken = .{ .token = p.tok_i },
	3122	});
	3123	const else_node = try p.arena.allocator.create(Node.Else);
	3124	else_node.* = .{
	3125	.else_token = else_token,
	3126	.payload = payload,
	3127	.body = else_expr,
	3128	};
	3129	if_prefix.@"else" = else_node;
3042	3130
3043		fn parseTry(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
3044		const token = eatToken(it, .Keyword_try) orelse return null;
3045		const node = try arena.create(Node.PrefixOp);
3046		node.* = .{
3047		.op_token = token,
3048		.op = .Try,
3049		.rhs = undefined, // set by caller
3050		};
3051		return &node.base;
3052		}
	3131	return node;
	3132	}
3053	3133
3054		fn parseUse(arena: Allocator, it: TokenIterator, tree: Tree) !?Node {
3055		const token = eatToken(it, .Keyword_usingnamespace) orelse return null;
3056		const node = try arena.create(Node.Use);
3057		node.* = .{
3058		.doc_comments = null,
3059		.visib_token = null,
3060		.use_token = token,
3061		.expr = try expectNode(arena, it, tree, parseExpr, .{
3062		.ExpectedExpr = .{ .token = it.index },
3063		}),
3064		.semicolon_token = try expectToken(it, tree, .Semicolon),
3065		};
3066		return &node.base;
3067		}
	3134	/// Eat a multiline doc comment
	3135	fn parseDocComment(p: Parser) !?Node.DocComment {
	3136	var lines = Node.DocComment.LineList{};
	3137	var lines_it = &lines.first;
3068	3138
3069		/// IfPrefix Body (KEYWORD_else Payload? Body)?
3070		fn parseIf(arena: Allocator, it: TokenIterator, tree: Tree, bodyParseFn: NodeParseFn) !?Node {
3071		const node = (try parseIfPrefix(arena, it, tree)) orelse return null;
3072		const if_prefix = node.cast(Node.If).?;
3073
3074		if_prefix.body = try expectNode(arena, it, tree, bodyParseFn, .{
3075		.InvalidToken = .{ .token = it.index },
3076		});
3077
3078		const else_token = eatToken(it, .Keyword_else) orelse return node;
3079		const payload = try parsePayload(arena, it, tree);
3080		const else_expr = try expectNode(arena, it, tree, bodyParseFn, .{
3081		.InvalidToken = .{ .token = it.index },
3082		});
3083		const else_node = try arena.create(Node.Else);
3084		else_node.* = .{
3085		.else_token = else_token,
3086		.payload = payload,
3087		.body = else_expr,
3088		};
3089		if_prefix.@"else" = else_node;
	3139	while (p.eatToken(.DocComment)) \|line\| {
	3140	lines_it = try p.llpush(TokenIndex, lines_it, line);
	3141	}
3090	3142
3091		return node;
3092		}
	3143	if (lines.first == null) return null;
3093	3144
3094		/// Eat a multiline doc comment
3095		fn parseDocComment(arena: Allocator, it: TokenIterator, tree: Tree) !?Node.DocComment {
3096		var lines = Node.DocComment.LineList.init(arena);
3097		while (eatToken(it, .DocComment)) \|line\| {
3098		try lines.push(line);
	3145	const node = try p.arena.allocator.create(Node.DocComment);
	3146	node.* = .{
	3147	.lines = lines,
	3148	};
	3149	return node;
3099	3150	}
3100	3151
3101		if (lines.len == 0) return null;
	3152	fn tokensOnSameLine(p: *Parser, token1: TokenIndex, token2: TokenIndex) bool {
	3153	return std.mem.indexOfScalar(u8, p.source[p.tokens[token1].end..p.tokens[token2].start], '\n') == null;
	3154	}
3102	3155
3103		const node = try arena.create(Node.DocComment);
3104		node.* = .{
3105		.lines = lines,
3106		};
3107		return node;
3108		}
	3156	/// Eat a single-line doc comment on the same line as another node
	3157	fn parseAppendedDocComment(p: Parser, after_token: TokenIndex) !?Node.DocComment {
	3158	const comment_token = p.eatToken(.DocComment) orelse return null;
	3159	if (p.tokensOnSameLine(after_token, comment_token)) {
	3160	var lines = Node.DocComment.LineList{};
	3161	_ = try p.llpush(TokenIndex, &lines.first, comment_token);
3109	3162
3110		/// Eat a single-line doc comment on the same line as another node
3111		fn parseAppendedDocComment(arena: Allocator, it: TokenIterator, tree: Tree, after_token: TokenIndex) !?Node.DocComment {
3112		const comment_token = eatToken(it, .DocComment) orelse return null;
3113		if (tree.tokensOnSameLine(after_token, comment_token)) {
3114		const node = try arena.create(Node.DocComment);
3115		node.* = .{
3116		.lines = Node.DocComment.LineList.init(arena),
3117		};
3118		try node.lines.push(comment_token);
3119		return node;
	3163	const node = try p.arena.allocator.create(Node.DocComment);
	3164	node.* = .{ .lines = lines };
	3165	return node;
	3166	}
	3167	p.putBackToken(comment_token);
	3168	return null;
3120	3169	}
3121		putBackToken(it, comment_token);
3122		return null;
3123		}
3124	3170
3125		/// Op* Child
3126		fn parsePrefixOpExpr(
3127		arena: *Allocator,
3128		it: *TokenIterator,
3129		tree: *Tree,
3130		opParseFn: NodeParseFn,
3131		childParseFn: NodeParseFn,
3132		) Error!?*Node {
3133		if (try opParseFn(arena, it, tree)) \|first_op\| {
3134		var rightmost_op = first_op;
3135		while (true) {
	3171	/// Op* Child
	3172	fn parsePrefixOpExpr(p: Parser, opParseFn: NodeParseFn, childParseFn: NodeParseFn) Error!?Node {
	3173	if (try opParseFn(p)) \|first_op\| {
	3174	var rightmost_op = first_op;
	3175	while (true) {
	3176	switch (rightmost_op.id) {
	3177	.PrefixOp => {
	3178	var prefix_op = rightmost_op.cast(Node.PrefixOp).?;
	3179	// If the token encountered was **, there will be two nodes
	3180	if (p.tokens[prefix_op.op_token].id == .AsteriskAsterisk) {
	3181	rightmost_op = prefix_op.rhs;
	3182	prefix_op = rightmost_op.cast(Node.PrefixOp).?;
	3183	}
	3184	if (try opParseFn(p)) \|rhs\| {
	3185	prefix_op.rhs = rhs;
	3186	rightmost_op = rhs;
	3187	} else break;
	3188	},
	3189	.AnyFrameType => {
	3190	const prom = rightmost_op.cast(Node.AnyFrameType).?;
	3191	if (try opParseFn(p)) \|rhs\| {
	3192	prom.result.?.return_type = rhs;
	3193	rightmost_op = rhs;
	3194	} else break;
	3195	},
	3196	else => unreachable,
	3197	}
	3198	}
	3199
	3200	// If any prefix op existed, a child node on the RHS is required
3136	3201	switch (rightmost_op.id) {
3137	3202	.PrefixOp => {
3138		var prefix_op = rightmost_op.cast(Node.PrefixOp).?;
3139		// If the token encountered was **, there will be two nodes
3140		if (tree.tokens.at(prefix_op.op_token).id == .AsteriskAsterisk) {
3141		rightmost_op = prefix_op.rhs;
3142		prefix_op = rightmost_op.cast(Node.PrefixOp).?;
3143		}
3144		if (try opParseFn(arena, it, tree)) \|rhs\| {
3145		prefix_op.rhs = rhs;
3146		rightmost_op = rhs;
3147		} else break;
	3203	const prefix_op = rightmost_op.cast(Node.PrefixOp).?;
	3204	prefix_op.rhs = try p.expectNode(childParseFn, .{
	3205	.InvalidToken = .{ .token = p.tok_i },
	3206	});
3148	3207	},
3149	3208	.AnyFrameType => {
3150	3209	const prom = rightmost_op.cast(Node.AnyFrameType).?;
3151		if (try opParseFn(arena, it, tree)) \|rhs\| {
3152		prom.result.?.return_type = rhs;
3153		rightmost_op = rhs;
3154		} else break;
	3210	prom.result.?.return_type = try p.expectNode(childParseFn, .{
	3211	.InvalidToken = .{ .token = p.tok_i },
	3212	});
3155	3213	},
3156	3214	else => unreachable,
3157	3215	}
3158		}
3159	3216
3160		// If any prefix op existed, a child node on the RHS is required
3161		switch (rightmost_op.id) {
3162		.PrefixOp => {
3163		const prefix_op = rightmost_op.cast(Node.PrefixOp).?;
3164		prefix_op.rhs = try expectNode(arena, it, tree, childParseFn, .{
3165		.InvalidToken = .{ .token = it.index },
3166		});
3167		},
3168		.AnyFrameType => {
3169		const prom = rightmost_op.cast(Node.AnyFrameType).?;
3170		prom.result.?.return_type = try expectNode(arena, it, tree, childParseFn, .{
3171		.InvalidToken = .{ .token = it.index },
3172		});
3173		},
3174		else => unreachable,
	3217	return first_op;
3175	3218	}
3176	3219
3177		return first_op;
	3220	// Otherwise, the child node is optional
	3221	return childParseFn(p);
3178	3222	}
3179	3223
3180		// Otherwise, the child node is optional
3181		return try childParseFn(arena, it, tree);
3182		}
	3224	/// Child (Op Child)*
	3225	/// Child (Op Child)?
	3226	fn parseBinOpExpr(
	3227	p: *Parser,
	3228	opParseFn: NodeParseFn,
	3229	childParseFn: NodeParseFn,
	3230	chain: enum {
	3231	Once,
	3232	Infinitely,
	3233	},
	3234	) Error!?*Node {
	3235	var res = (try childParseFn(p)) orelse return null;
3183	3236
3184		/// Child (Op Child)*
3185		/// Child (Op Child)?
3186		fn parseBinOpExpr(
3187		arena: *Allocator,
3188		it: *TokenIterator,
3189		tree: *Tree,
3190		opParseFn: NodeParseFn,
3191		childParseFn: NodeParseFn,
3192		chain: enum {
3193		Once,
3194		Infinitely,
3195		},
3196		) Error!?*Node {
3197		var res = (try childParseFn(arena, it, tree)) orelse return null;
3198
3199		while (try opParseFn(arena, it, tree)) \|node\| {
3200		const right = try expectNode(arena, it, tree, childParseFn, .{
3201		.InvalidToken = .{ .token = it.index },
3202		});
3203		const left = res;
3204		res = node;
	3237	while (try opParseFn(p)) \|node\| {
	3238	const right = try p.expectNode(childParseFn, .{
	3239	.InvalidToken = .{ .token = p.tok_i },
	3240	});
	3241	const left = res;
	3242	res = node;
3205	3243
3206		const op = node.cast(Node.InfixOp).?;
3207		op.*.lhs = left;
3208		op.*.rhs = right;
	3244	const op = node.cast(Node.InfixOp).?;
	3245	op.*.lhs = left;
	3246	op.*.rhs = right;
3209	3247
3210		switch (chain) {
3211		.Once => break,
3212		.Infinitely => continue,
	3248	switch (chain) {
	3249	.Once => break,
	3250	.Infinitely => continue,
	3251	}
3213	3252	}
	3253
	3254	return res;
3214	3255	}
3215	3256
3216		return res;
3217		}
	3257	fn createInfixOp(p: Parser, index: TokenIndex, op: Node.InfixOp.Op) !Node {
	3258	const node = try p.arena.allocator.create(Node.InfixOp);
	3259	node.* = .{
	3260	.op_token = index,
	3261	.lhs = undefined, // set by caller
	3262	.op = op,
	3263	.rhs = undefined, // set by caller
	3264	};
	3265	return &node.base;
	3266	}
3218	3267
3219		fn createInfixOp(arena: Allocator, index: TokenIndex, op: Node.InfixOp.Op) !Node {
3220		const node = try arena.create(Node.InfixOp);
3221		node.* = .{
3222		.op_token = index,
3223		.lhs = undefined, // set by caller
3224		.op = op,
3225		.rhs = undefined, // set by caller
3226		};
3227		return &node.base;
3228		}
	3268	fn eatToken(p: *Parser, id: Token.Id) ?TokenIndex {
	3269	return if (p.eatAnnotatedToken(id)) \|token\| token.index else null;
	3270	}
3229	3271
3230		fn eatToken(it: *TokenIterator, id: Token.Id) ?TokenIndex {
3231		return if (eatAnnotatedToken(it, id)) \|token\| token.index else null;
3232		}
	3272	fn eatAnnotatedToken(p: *Parser, id: Token.Id) ?AnnotatedToken {
	3273	return if (p.tokens[p.tok_i].id == id) p.nextToken() else null;
	3274	}
3233	3275
3234		fn eatAnnotatedToken(it: *TokenIterator, id: Token.Id) ?AnnotatedToken {
3235		return if (it.peek().?.id == id) nextToken(it) else null;
3236		}
	3276	fn expectToken(p: *Parser, id: Token.Id) Error!TokenIndex {
	3277	return (try p.expectTokenRecoverable(id)) orelse
	3278	error.ParseError;
	3279	}
3237	3280
3238		fn expectToken(it: TokenIterator, tree: Tree, id: Token.Id) Error!TokenIndex {
3239		return (try expectTokenRecoverable(it, tree, id)) orelse
3240		error.ParseError;
3241		}
	3281	fn expectTokenRecoverable(p: *Parser, id: Token.Id) !?TokenIndex {
	3282	const token = p.nextToken();
	3283	if (token.ptr.id != id) {
	3284	try p.errors.append(p.gpa, .{
	3285	.ExpectedToken = .{ .token = token.index, .expected_id = id },
	3286	});
	3287	// go back so that we can recover properly
	3288	p.putBackToken(token.index);
	3289	return null;
	3290	}
	3291	return token.index;
	3292	}
3242	3293
3243		fn expectTokenRecoverable(it: TokenIterator, tree: Tree, id: Token.Id) !?TokenIndex {
3244		const token = nextToken(it);
3245		if (token.ptr.id != id) {
3246		try tree.errors.push(.{
3247		.ExpectedToken = .{ .token = token.index, .expected_id = id },
3248		});
3249		// go back so that we can recover properly
3250		putBackToken(it, token.index);
3251		return null;
	3294	fn nextToken(p: *Parser) AnnotatedToken {
	3295	const result = AnnotatedToken{
	3296	.index = p.tok_i,
	3297	.ptr = &p.tokens[p.tok_i],
	3298	};
	3299	if (p.tokens[p.tok_i].id == .Eof) {
	3300	return result;
	3301	}
	3302	p.tok_i += 1;
	3303	assert(result.ptr.id != .LineComment);
	3304
	3305	while (true) {
	3306	const next_tok = p.tokens[p.tok_i];
	3307	if (next_tok.id != .LineComment) return result;
	3308	p.tok_i += 1;
	3309	}
	3310	}
	3311
	3312	fn putBackToken(p: *Parser, putting_back: TokenIndex) void {
	3313	while (p.tok_i > 0) {
	3314	p.tok_i -= 1;
	3315	const prev_tok = p.tokens[p.tok_i];
	3316	if (prev_tok.id == .LineComment) continue;
	3317	assert(putting_back == p.tok_i);
	3318	return;
	3319	}
3252	3320	}
3253		return token.index;
3254		}
3255	3321
3256		fn nextToken(it: *TokenIterator) AnnotatedToken {
3257		const result = AnnotatedToken{
3258		.index = it.index,
3259		.ptr = it.next().?,
	3322	const AnnotatedToken = struct {
	3323	index: TokenIndex,
	3324	ptr: *const Token,
3260	3325	};
3261		assert(result.ptr.id != .LineComment);
3262	3326
3263		while (true) {
3264		const next_tok = it.peek() orelse return result;
3265		if (next_tok.id != .LineComment) return result;
3266		_ = it.next();
	3327	fn expectNode(
	3328	p: *Parser,
	3329	parseFn: NodeParseFn,
	3330	/// if parsing fails
	3331	err: AstError,
	3332	) Error!*Node {
	3333	return (try p.expectNodeRecoverable(parseFn, err)) orelse return error.ParseError;
3267	3334	}
3268		}
3269	3335
3270		fn putBackToken(it: *TokenIterator, putting_back: TokenIndex) void {
3271		while (true) {
3272		const prev_tok = it.prev() orelse return;
3273		if (prev_tok.id == .LineComment) continue;
3274		assert(it.list.at(putting_back) == prev_tok);
3275		return;
	3336	fn expectNodeRecoverable(
	3337	p: *Parser,
	3338	parseFn: NodeParseFn,
	3339	/// if parsing fails
	3340	err: AstError,
	3341	) !?*Node {
	3342	return (try parseFn(p)) orelse {
	3343	try p.errors.append(p.gpa, err);
	3344	return null;
	3345	};
3276	3346	}
3277		}
3278
3279		const AnnotatedToken = struct {
3280		index: TokenIndex,
3281		ptr: *Token,
3282	3347	};
3283	3348
3284		fn expectNode(
3285		arena: *Allocator,
3286		it: *TokenIterator,
3287		tree: *Tree,
3288		parseFn: NodeParseFn,
3289		err: AstError, // if parsing fails
3290		) Error!*Node {
3291		return (try expectNodeRecoverable(arena, it, tree, parseFn, err)) orelse
3292		return error.ParseError;
	3349	fn ParseFn(comptime T: type) type {
	3350	return fn (p: *Parser) Error!T;
3293	3351	}
3294	3352
3295		fn expectNodeRecoverable(
3296		arena: *Allocator,
3297		it: *TokenIterator,
3298		tree: *Tree,
3299		parseFn: NodeParseFn,
3300		err: AstError, // if parsing fails
3301		) !?*Node {
3302		return (try parseFn(arena, it, tree)) orelse {
3303		try tree.errors.push(err);
3304		return null;
3305		};
3306		}
3307	3353
3308	3354	test "std.zig.parser" {
3309	3355	_ = @import("parser_test.zig");

lib/std/zig/parser_test.zig+3-6

...	...	@@ -3180,9 +3180,8 @@ fn testParse(source: []const u8, allocator: mem.Allocator, anything_changed: b
3180	3180	const tree = try std.zig.parse(allocator, source);
3181	3181	defer tree.deinit();
3182	3182
3183		var error_it = tree.errors.iterator(0);
3184		while (error_it.next()) \|parse_error\| {
3185		const token = tree.tokens.at(parse_error.loc());
	3183	for (tree.errors) \|*parse_error\| {
	3184	const token = tree.tokens[parse_error.loc()];
3186	3185	const loc = tree.tokenLocation(0, parse_error.loc());
3187	3186	try stderr.print("(memory buffer):{}:{}: error: ", .{ loc.line + 1, loc.column + 1 });
3188	3187	try tree.renderError(parse_error, stderr);
...	...	@@ -3271,8 +3270,6 @@ fn testError(source: []const u8, expected_errors: []const Error) !void {
3271	3270
3272	3271	std.testing.expect(tree.errors.len == expected_errors.len);
3273	3272	for (expected_errors) \|expected, i\| {
3274		const err = tree.errors.at(i);
3275
3276		std.testing.expect(expected == err.*);
	3273	std.testing.expect(expected == tree.errors[i]);
3277	3274	}
3278	3275	}

lib/std/zig/render.zig+62-65

...	...	@@ -67,24 +67,21 @@ fn renderRoot(
67	67	stream: var,
68	68	tree: *ast.Tree,
69	69	) (@TypeOf(stream).Error \|\| Error)!void {
70		var tok_it = tree.tokens.iterator(0);
71
72	70	// render all the line comments at the beginning of the file
73		while (tok_it.next()) \|token\| {
	71	for (tree.tokens) \|*token, i\| {
74	72	if (token.id != .LineComment) break;
75	73	try stream.print("{}\n", .{mem.trimRight(u8, tree.tokenSlicePtr(token), " ")});
76		if (tok_it.peek()) \|next_token\| {
77		const loc = tree.tokenLocationPtr(token.end, next_token);
78		if (loc.line >= 2) {
79		try stream.writeByte('\n');
80		}
	74	const next_token = &tree.tokens[i + 1];
	75	const loc = tree.tokenLocationPtr(token.end, next_token.*);
	76	if (loc.line >= 2) {
	77	try stream.writeByte('\n');
81	78	}
82	79	}
83	80
84	81	var start_col: usize = 0;
85		var it = tree.root_node.decls.iterator(0);
	82	var it = tree.root_node.decls.first orelse return;
86	83	while (true) {
87		var decl = (it.next() orelse return).*;
	84	var decl = it.data;
88	85
89	86	// This loop does the following:
90	87	//
...	...	@@ -103,7 +100,7 @@ fn renderRoot(
103	100
104	101	while (token_index != 0) {
105	102	token_index -= 1;
106		const token = tree.tokens.at(token_index);
	103	const token = tree.tokens[token_index];
107	104	switch (token.id) {
108	105	.LineComment => {},
109	106	.DocComment => {
...	...	@@ -133,17 +130,18 @@ fn renderRoot(
133	130	token_index = decl.firstToken();
134	131
135	132	while (!fmt_active) {
136		decl = (it.next() orelse {
	133	it = it.next orelse {
137	134	// If there's no next reformatted `decl`, just copy the
138	135	// remaining input tokens and bail out.
139		const start = tree.tokens.at(copy_start_token_index).start;
	136	const start = tree.tokens[copy_start_token_index].start;
140	137	try copyFixingWhitespace(stream, tree.source[start..]);
141	138	return;
142		}).*;
	139	};
	140	decl = it.data;
143	141	var decl_first_token_index = decl.firstToken();
144	142
145	143	while (token_index < decl_first_token_index) : (token_index += 1) {
146		const token = tree.tokens.at(token_index);
	144	const token = tree.tokens[token_index];
147	145	switch (token.id) {
148	146	.LineComment => {},
149	147	.Eof => unreachable,
...	...	@@ -163,7 +161,7 @@ fn renderRoot(
163	161	token_index = copy_end_token_index;
164	162	while (token_index != 0) {
165	163	token_index -= 1;
166		const token = tree.tokens.at(token_index);
	164	const token = tree.tokens[token_index];
167	165	switch (token.id) {
168	166	.LineComment => {},
169	167	.DocComment => {
...	...	@@ -174,15 +172,14 @@ fn renderRoot(
174	172	}
175	173	}
176	174
177		const start = tree.tokens.at(copy_start_token_index).start;
178		const end = tree.tokens.at(copy_end_token_index).start;
	175	const start = tree.tokens[copy_start_token_index].start;
	176	const end = tree.tokens[copy_end_token_index].start;
179	177	try copyFixingWhitespace(stream, tree.source[start..end]);
180	178	}
181	179
182	180	try renderTopLevelDecl(allocator, stream, tree, 0, &start_col, decl);
183		if (it.peek()) \|next_decl\| {
184		try renderExtraNewline(tree, stream, &start_col, next_decl.*);
185		}
	181	it = it.next orelse return;
	182	try renderExtraNewline(tree, stream, &start_col, it.data);
186	183	}
187	184	}
188	185
...	...	@@ -191,13 +188,13 @@ fn renderExtraNewline(tree: ast.Tree, stream: var, start_col: usize, node: *as
191	188	var prev_token = first_token;
192	189	if (prev_token == 0) return;
193	190	var newline_threshold: usize = 2;
194		while (tree.tokens.at(prev_token - 1).id == .DocComment) {
195		if (tree.tokenLocation(tree.tokens.at(prev_token - 1).end, prev_token).line == 1) {
	191	while (tree.tokens[prev_token - 1].id == .DocComment) {
	192	if (tree.tokenLocation(tree.tokens[prev_token - 1].end, prev_token).line == 1) {
196	193	newline_threshold += 1;
197	194	}
198	195	prev_token -= 1;
199	196	}
200		const prev_token_end = tree.tokens.at(prev_token - 1).end;
	197	const prev_token_end = tree.tokens[prev_token - 1].end;
201	198	const loc = tree.tokenLocation(prev_token_end, first_token);
202	199	if (loc.line >= newline_threshold) {
203	200	try stream.writeByte('\n');
...	...	@@ -262,7 +259,7 @@ fn renderContainerDecl(allocator: mem.Allocator, stream: var, tree: ast.Tree,
262	259
263	260	const src_has_trailing_comma = blk: {
264	261	const maybe_comma = tree.nextToken(field.lastToken());
265		break :blk tree.tokens.at(maybe_comma).id == .Comma;
	262	break :blk tree.tokens[maybe_comma].id == .Comma;
266	263	};
267	264
268	265	// The trailing comma is emitted at the end, but if it's not present
...	...	@@ -426,13 +423,13 @@ fn renderExpression(
426	423	try renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.lhs, op_space);
427	424
428	425	const after_op_space = blk: {
429		const loc = tree.tokenLocation(tree.tokens.at(infix_op_node.op_token).end, tree.nextToken(infix_op_node.op_token));
	426	const loc = tree.tokenLocation(tree.tokens[infix_op_node.op_token].end, tree.nextToken(infix_op_node.op_token));
430	427	break :blk if (loc.line == 0) op_space else Space.Newline;
431	428	};
432	429
433	430	try renderToken(tree, stream, infix_op_node.op_token, indent, start_col, after_op_space);
434	431	if (after_op_space == Space.Newline and
435		tree.tokens.at(tree.nextToken(infix_op_node.op_token)).id != .MultilineStringLiteralLine)
	432	tree.tokens[tree.nextToken(infix_op_node.op_token)].id != .MultilineStringLiteralLine)
436	433	{
437	434	try stream.writeByteNTimes(' ', indent + indent_delta);
438	435	start_col.* = indent + indent_delta;
...	...	@@ -453,10 +450,10 @@ fn renderExpression(
453	450
454	451	switch (prefix_op_node.op) {
455	452	.PtrType => \|ptr_info\| {
456		const op_tok_id = tree.tokens.at(prefix_op_node.op_token).id;
	453	const op_tok_id = tree.tokens[prefix_op_node.op_token].id;
457	454	switch (op_tok_id) {
458	455	.Asterisk, .AsteriskAsterisk => try stream.writeByte('*'),
459		.LBracket => if (tree.tokens.at(prefix_op_node.op_token + 2).id == .Identifier)
	456	.LBracket => if (tree.tokens[prefix_op_node.op_token + 2].id == .Identifier)
460	457	try stream.writeAll("[*c")
461	458	else
462	459	try stream.writeAll("[*"),
...	...	@@ -568,8 +565,8 @@ fn renderExpression(
568	565
569	566	try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
570	567
571		const starts_with_comment = tree.tokens.at(lbracket + 1).id == .LineComment;
572		const ends_with_comment = tree.tokens.at(rbracket - 1).id == .LineComment;
	568	const starts_with_comment = tree.tokens[lbracket + 1].id == .LineComment;
	569	const ends_with_comment = tree.tokens[rbracket - 1].id == .LineComment;
573	570	const new_indent = if (ends_with_comment) indent + indent_delta else indent;
574	571	const new_space = if (ends_with_comment) Space.Newline else Space.None;
575	572	try renderExpression(allocator, stream, tree, new_indent, start_col, array_info.len_expr, new_space);
...	...	@@ -630,7 +627,7 @@ fn renderExpression(
630	627
631	628	const src_has_trailing_comma = blk: {
632	629	const maybe_comma = tree.prevToken(suffix_op.rtoken);
633		break :blk tree.tokens.at(maybe_comma).id == .Comma;
	630	break :blk tree.tokens[maybe_comma].id == .Comma;
634	631	};
635	632
636	633	if (src_has_trailing_comma) {
...	...	@@ -682,8 +679,8 @@ fn renderExpression(
682	679	try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs.node, Space.None);
683	680	try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
684	681
685		const starts_with_comment = tree.tokens.at(lbracket + 1).id == .LineComment;
686		const ends_with_comment = tree.tokens.at(rbracket - 1).id == .LineComment;
	682	const starts_with_comment = tree.tokens[lbracket + 1].id == .LineComment;
	683	const ends_with_comment = tree.tokens[rbracket - 1].id == .LineComment;
687	684	const new_indent = if (ends_with_comment) indent + indent_delta else indent;
688	685	const new_space = if (ends_with_comment) Space.Newline else Space.None;
689	686	try renderExpression(allocator, stream, tree, new_indent, start_col, index_expr, new_space);
...	...	@@ -750,11 +747,11 @@ fn renderExpression(
750	747
751	748	const src_has_trailing_comma = blk: {
752	749	const maybe_comma = tree.prevToken(suffix_op.rtoken);
753		break :blk tree.tokens.at(maybe_comma).id == .Comma;
	750	break :blk tree.tokens[maybe_comma].id == .Comma;
754	751	};
755	752
756	753	const src_same_line = blk: {
757		const loc = tree.tokenLocation(tree.tokens.at(lbrace).end, suffix_op.rtoken);
	754	const loc = tree.tokenLocation(tree.tokens[lbrace].end, suffix_op.rtoken);
758	755	break :blk loc.line == 0;
759	756	};
760	757
...	...	@@ -858,7 +855,7 @@ fn renderExpression(
858	855	try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
859	856	return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
860	857	}
861		if (exprs.len == 1 and tree.tokens.at(exprs.at(0).*.lastToken() + 1).id == .RBrace) {
	858	if (exprs.len == 1 and tree.tokens[exprs.at(0).*.lastToken() + 1].id == .RBrace) {
862	859	const expr = exprs.at(0).*;
863	860
864	861	switch (suffix_op.lhs) {
...	...	@@ -883,17 +880,17 @@ fn renderExpression(
883	880	const expr = it.next().?.*;
884	881	if (it.peek()) \|next_expr\| {
885	882	const expr_last_token = expr.*.lastToken() + 1;
886		const loc = tree.tokenLocation(tree.tokens.at(expr_last_token).end, next_expr.*.firstToken());
	883	const loc = tree.tokenLocation(tree.tokens[expr_last_token].end, next_expr.*.firstToken());
887	884	if (loc.line != 0) break :blk count;
888	885	count += 1;
889	886	} else {
890	887	const expr_last_token = expr.*.lastToken();
891		const loc = tree.tokenLocation(tree.tokens.at(expr_last_token).end, suffix_op.rtoken);
	888	const loc = tree.tokenLocation(tree.tokens[expr_last_token].end, suffix_op.rtoken);
892	889	if (loc.line == 0) {
893	890	// all on one line
894	891	const src_has_trailing_comma = trailblk: {
895	892	const maybe_comma = tree.prevToken(suffix_op.rtoken);
896		break :trailblk tree.tokens.at(maybe_comma).id == .Comma;
	893	break :trailblk tree.tokens[maybe_comma].id == .Comma;
897	894	};
898	895	if (src_has_trailing_comma) {
899	896	break :blk 1; // force row size 1
...	...	@@ -933,7 +930,7 @@ fn renderExpression(
933	930
934	931	var new_indent = indent + indent_delta;
935	932
936		if (tree.tokens.at(tree.nextToken(lbrace)).id != .MultilineStringLiteralLine) {
	933	if (tree.tokens[tree.nextToken(lbrace)].id != .MultilineStringLiteralLine) {
937	934	try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline);
938	935	try stream.writeByteNTimes(' ', new_indent);
939	936	} else {
...	...	@@ -961,7 +958,7 @@ fn renderExpression(
961	958	}
962	959	col = 1;
963	960
964		if (tree.tokens.at(tree.nextToken(comma)).id != .MultilineStringLiteralLine) {
	961	if (tree.tokens[tree.nextToken(comma)].id != .MultilineStringLiteralLine) {
965	962	try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline); // ,
966	963	} else {
967	964	try renderToken(tree, stream, comma, new_indent, start_col, Space.None); // ,
...	...	@@ -1188,9 +1185,9 @@ fn renderExpression(
1188	1185	var maybe_comma = tree.prevToken(container_decl.lastToken());
1189	1186	// Doc comments for a field may also appear after the comma, eg.
1190	1187	// field_name: T, // comment attached to field_name
1191		if (tree.tokens.at(maybe_comma).id == .DocComment)
	1188	if (tree.tokens[maybe_comma].id == .DocComment)
1192	1189	maybe_comma = tree.prevToken(maybe_comma);
1193		break :blk tree.tokens.at(maybe_comma).id == .Comma;
	1190	break :blk tree.tokens[maybe_comma].id == .Comma;
1194	1191	};
1195	1192
1196	1193	// Check if the first declaration and the { are on the same line
...	...	@@ -1285,7 +1282,7 @@ fn renderExpression(
1285	1282
1286	1283	const src_has_trailing_comma = blk: {
1287	1284	const maybe_comma = tree.prevToken(err_set_decl.rbrace_token);
1288		break :blk tree.tokens.at(maybe_comma).id == .Comma;
	1285	break :blk tree.tokens[maybe_comma].id == .Comma;
1289	1286	};
1290	1287
1291	1288	if (src_has_trailing_comma) {
...	...	@@ -1317,7 +1314,7 @@ fn renderExpression(
1317	1314	try renderExpression(allocator, stream, tree, indent, start_col, node.*, Space.None);
1318	1315
1319	1316	const comma_token = tree.nextToken(node.*.lastToken());
1320		assert(tree.tokens.at(comma_token).id == .Comma);
	1317	assert(tree.tokens[comma_token].id == .Comma);
1321	1318	try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
1322	1319	try renderExtraNewline(tree, stream, start_col, next_node.*);
1323	1320	} else {
...	...	@@ -1342,7 +1339,7 @@ fn renderExpression(
1342	1339	const multiline_str_literal = @fieldParentPtr(ast.Node.MultilineStringLiteral, "base", base);
1343	1340
1344	1341	var skip_first_indent = true;
1345		if (tree.tokens.at(multiline_str_literal.firstToken() - 1).id != .LineComment) {
	1342	if (tree.tokens[multiline_str_literal.firstToken() - 1].id != .LineComment) {
1346	1343	try stream.print("\n", .{});
1347	1344	skip_first_indent = false;
1348	1345	}
...	...	@@ -1372,7 +1369,7 @@ fn renderExpression(
1372	1369	if (builtin_call.params.len < 2) break :blk false;
1373	1370	const last_node = builtin_call.params.at(builtin_call.params.len - 1).*;
1374	1371	const maybe_comma = tree.nextToken(last_node.lastToken());
1375		break :blk tree.tokens.at(maybe_comma).id == .Comma;
	1372	break :blk tree.tokens[maybe_comma].id == .Comma;
1376	1373	};
1377	1374
1378	1375	const lparen = tree.nextToken(builtin_call.builtin_token);
...	...	@@ -1410,7 +1407,7 @@ fn renderExpression(
1410	1407	const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", base);
1411	1408
1412	1409	if (fn_proto.visib_token) \|visib_token_index\| {
1413		const visib_token = tree.tokens.at(visib_token_index);
	1410	const visib_token = tree.tokens[visib_token_index];
1414	1411	assert(visib_token.id == .Keyword_pub or visib_token.id == .Keyword_export);
1415	1412
1416	1413	try renderToken(tree, stream, visib_token_index, indent, start_col, Space.Space); // pub
...	...	@@ -1433,7 +1430,7 @@ fn renderExpression(
1433	1430	try renderToken(tree, stream, fn_proto.fn_token, indent, start_col, Space.Space); // fn
1434	1431	break :blk tree.nextToken(fn_proto.fn_token);
1435	1432	};
1436		assert(tree.tokens.at(lparen).id == .LParen);
	1433	assert(tree.tokens[lparen].id == .LParen);
1437	1434
1438	1435	const rparen = tree.prevToken(
1439	1436	// the first token for the annotation expressions is the left
...	...	@@ -1449,10 +1446,10 @@ fn renderExpression(
1449	1446	.InferErrorSet => \|node\| tree.prevToken(node.firstToken()),
1450	1447	.Invalid => unreachable,
1451	1448	});
1452		assert(tree.tokens.at(rparen).id == .RParen);
	1449	assert(tree.tokens[rparen].id == .RParen);
1453	1450
1454	1451	const src_params_trailing_comma = blk: {
1455		const maybe_comma = tree.tokens.at(rparen - 1).id;
	1452	const maybe_comma = tree.tokens[rparen - 1].id;
1456	1453	break :blk maybe_comma == .Comma or maybe_comma == .LineComment;
1457	1454	};
1458	1455
...	...	@@ -1591,7 +1588,7 @@ fn renderExpression(
1591	1588	const src_has_trailing_comma = blk: {
1592	1589	const last_node = switch_case.items.at(switch_case.items.len - 1).*;
1593	1590	const maybe_comma = tree.nextToken(last_node.lastToken());
1594		break :blk tree.tokens.at(maybe_comma).id == .Comma;
	1591	break :blk tree.tokens[maybe_comma].id == .Comma;
1595	1592	};
1596	1593
1597	1594	if (switch_case.items.len == 1 or !src_has_trailing_comma) {
...	...	@@ -1940,7 +1937,7 @@ fn renderExpression(
1940	1937	try renderExpression(allocator, stream, tree, indent_extra, start_col, node, Space.Newline);
1941	1938	try stream.writeByteNTimes(' ', indent_once);
1942	1939	const comma_or_colon = tree.nextToken(node.lastToken());
1943		break :blk switch (tree.tokens.at(comma_or_colon).id) {
	1940	break :blk switch (tree.tokens[comma_or_colon].id) {
1944	1941	.Comma => tree.nextToken(comma_or_colon),
1945	1942	else => comma_or_colon,
1946	1943	};
...	...	@@ -1978,7 +1975,7 @@ fn renderExpression(
1978	1975	try renderExpression(allocator, stream, tree, indent_extra, start_col, node, Space.Newline);
1979	1976	try stream.writeByteNTimes(' ', indent_once);
1980	1977	const comma_or_colon = tree.nextToken(node.lastToken());
1981		break :blk switch (tree.tokens.at(comma_or_colon).id) {
	1978	break :blk switch (tree.tokens[comma_or_colon].id) {
1982	1979	.Comma => tree.nextToken(comma_or_colon),
1983	1980	else => comma_or_colon,
1984	1981	};
...	...	@@ -2174,7 +2171,7 @@ fn renderStatement(
2174	2171	try renderExpression(allocator, stream, tree, indent, start_col, base, Space.None);
2175	2172
2176	2173	const semicolon_index = tree.nextToken(base.lastToken());
2177		assert(tree.tokens.at(semicolon_index).id == .Semicolon);
	2174	assert(tree.tokens[semicolon_index].id == .Semicolon);
2178	2175	try renderToken(tree, stream, semicolon_index, indent, start_col, Space.Newline);
2179	2176	} else {
2180	2177	try renderExpression(allocator, stream, tree, indent, start_col, base, Space.Newline);
...	...	@@ -2212,13 +2209,13 @@ fn renderTokenOffset(
2212	2209	return;
2213	2210	}
2214	2211
2215		var token = tree.tokens.at(token_index);
	2212	var token = tree.tokens[token_index];
2216	2213	try stream.writeAll(mem.trimRight(u8, tree.tokenSlicePtr(token)[token_skip_bytes..], " "));
2217	2214
2218	2215	if (space == Space.NoComment)
2219	2216	return;
2220	2217
2221		var next_token = tree.tokens.at(token_index + 1);
	2218	var next_token = tree.tokens[token_index + 1];
2222	2219
2223	2220	if (space == Space.Comma) switch (next_token.id) {
2224	2221	.Comma => return renderToken(tree, stream, token_index + 1, indent, start_col, Space.Newline),
...	...	@@ -2227,7 +2224,7 @@ fn renderTokenOffset(
2227	2224	return renderToken(tree, stream, token_index + 1, indent, start_col, Space.Newline);
2228	2225	},
2229	2226	else => {
2230		if (token_index + 2 < tree.tokens.len and tree.tokens.at(token_index + 2).id == .MultilineStringLiteralLine) {
	2227	if (token_index + 2 < tree.tokens.len and tree.tokens[token_index + 2].id == .MultilineStringLiteralLine) {
2231	2228	try stream.writeAll(",");
2232	2229	return;
2233	2230	} else {
...	...	@@ -2244,7 +2241,7 @@ fn renderTokenOffset(
2244	2241	const loc = tree.tokenLocationPtr(token.end, next_token);
2245	2242	if (loc.line == 0) {
2246	2243	offset += 1;
2247		next_token = tree.tokens.at(token_index + offset);
	2244	next_token = tree.tokens[token_index + offset];
2248	2245	}
2249	2246	}
2250	2247
...	...	@@ -2277,7 +2274,7 @@ fn renderTokenOffset(
2277	2274	Space.Newline => {
2278	2275	offset += 1;
2279	2276	token = next_token;
2280		next_token = tree.tokens.at(token_index + offset);
	2277	next_token = tree.tokens[token_index + offset];
2281	2278	if (next_token.id != .LineComment) {
2282	2279	try stream.writeByte('\n');
2283	2280	start_col.* = 0;
...	...	@@ -2296,12 +2293,12 @@ fn renderTokenOffset(
2296	2293	try stream.print(" {}", .{mem.trimRight(u8, tree.tokenSlicePtr(next_token), " ")});
2297	2294	offset = 2;
2298	2295	token = next_token;
2299		next_token = tree.tokens.at(token_index + offset);
	2296	next_token = tree.tokens[token_index + offset];
2300	2297	if (next_token.id != .LineComment) {
2301	2298	switch (space) {
2302	2299	Space.None, Space.Space => {
2303	2300	try stream.writeByte('\n');
2304		const after_comment_token = tree.tokens.at(token_index + offset);
	2301	const after_comment_token = tree.tokens[token_index + offset];
2305	2302	const next_line_indent = switch (after_comment_token.id) {
2306	2303	.RParen, .RBrace, .RBracket => indent,
2307	2304	else => indent + indent_delta,
...	...	@@ -2342,7 +2339,7 @@ fn renderTokenOffset(
2342	2339
2343	2340	offset += 1;
2344	2341	token = next_token;
2345		next_token = tree.tokens.at(token_index + offset);
	2342	next_token = tree.tokens[token_index + offset];
2346	2343	if (next_token.id != .LineComment) {
2347	2344	switch (space) {
2348	2345	Space.Newline => {
...	...	@@ -2357,7 +2354,7 @@ fn renderTokenOffset(
2357	2354	Space.None, Space.Space => {
2358	2355	try stream.writeByte('\n');
2359	2356
2360		const after_comment_token = tree.tokens.at(token_index + offset);
	2357	const after_comment_token = tree.tokens[token_index + offset];
2361	2358	const next_line_indent = switch (after_comment_token.id) {
2362	2359	.RParen, .RBrace, .RBracket => blk: {
2363	2360	if (indent > indent_delta) {