Commit 779247ba114492a28287bc2026719091b7022e1d | zig

author	Jimmi Holst Christensen <jhc@dismail.de> 2018-04-04 23:36:55+02:00
committer	Jimmi Holst Christensen <jhc@dismail.de> 2018-04-04 23:36:55+02:00
log	779247ba114492a28287bc2026719091b7022e1d
tree	b36eec7a6977f50582d6d934d9db446e6310ee76
parent	744416ce0cd23c84e33965fc8171c0d1aea0659c

std.zig Major Refactor

* parser now parses expression like the C++ compiler does
* This makes initializers work
* Added control flow expression (only return is parsed)
* Added catch parsing (It doesn't quite work)
* The parse can now specify states as optional.
  * The parse will roll back on error if states are optional
  * This can be overriden by State.Required

3 files changed, 1071 insertions(+), 678 deletions(-)

std
- zig

std/zig/ast.zig+58-2

...	@@ -24,6 +24,7 @@ pub const Node = struct {	...	@@ -24,6 +24,7 @@ pub const Node = struct {
24	PrefixOp,	24	PrefixOp,
25	SuffixOp,	25	SuffixOp,
26	GroupedExpression,	26	GroupedExpression,
		27	ControlFlowExpression,
27	FieldInitializer,	28	FieldInitializer,
28	IntegerLiteral,	29	IntegerLiteral,
29	FloatLiteral,	30	FloatLiteral,
...	@@ -58,6 +59,7 @@ pub const Node = struct {	...	@@ -58,6 +59,7 @@ pub const Node = struct {
58	Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).iterate(index),	59	Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).iterate(index),
59	Id.SuffixOp => @fieldParentPtr(NodeSuffixOp, "base", base).iterate(index),	60	Id.SuffixOp => @fieldParentPtr(NodeSuffixOp, "base", base).iterate(index),
60	Id.GroupedExpression => @fieldParentPtr(NodeGroupedExpression, "base", base).iterate(index),	61	Id.GroupedExpression => @fieldParentPtr(NodeGroupedExpression, "base", base).iterate(index),
		62	Id.ControlFlowExpression => @fieldParentPtr(NodeControlFlowExpression, "base", base).iterate(index),
61	Id.FieldInitializer => @fieldParentPtr(NodeFieldInitializer, "base", base).iterate(index),	63	Id.FieldInitializer => @fieldParentPtr(NodeFieldInitializer, "base", base).iterate(index),
62	Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).iterate(index),	64	Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).iterate(index),
63	Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).iterate(index),	65	Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).iterate(index),
...	@@ -93,6 +95,7 @@ pub const Node = struct {	...	@@ -93,6 +95,7 @@ pub const Node = struct {
93	Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).firstToken(),	95	Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).firstToken(),
94	Id.SuffixOp => @fieldParentPtr(NodeSuffixOp, "base", base).firstToken(),	96	Id.SuffixOp => @fieldParentPtr(NodeSuffixOp, "base", base).firstToken(),
95	Id.GroupedExpression => @fieldParentPtr(NodeGroupedExpression, "base", base).firstToken(),	97	Id.GroupedExpression => @fieldParentPtr(NodeGroupedExpression, "base", base).firstToken(),
		98	Id.ControlFlowExpression => @fieldParentPtr(NodeControlFlowExpression, "base", base).firstToken(),
96	Id.FieldInitializer => @fieldParentPtr(NodeFieldInitializer, "base", base).firstToken(),	99	Id.FieldInitializer => @fieldParentPtr(NodeFieldInitializer, "base", base).firstToken(),
97	Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).firstToken(),	100	Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).firstToken(),
98	Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).firstToken(),	101	Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).firstToken(),
...	@@ -128,6 +131,7 @@ pub const Node = struct {	...	@@ -128,6 +131,7 @@ pub const Node = struct {
128	Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).lastToken(),	131	Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).lastToken(),
129	Id.SuffixOp => @fieldParentPtr(NodeSuffixOp, "base", base).lastToken(),	132	Id.SuffixOp => @fieldParentPtr(NodeSuffixOp, "base", base).lastToken(),
130	Id.GroupedExpression => @fieldParentPtr(NodeGroupedExpression, "base", base).lastToken(),	133	Id.GroupedExpression => @fieldParentPtr(NodeGroupedExpression, "base", base).lastToken(),
		134	Id.ControlFlowExpression => @fieldParentPtr(NodeControlFlowExpression, "base", base).lastToken(),
131	Id.FieldInitializer => @fieldParentPtr(NodeFieldInitializer, "base", base).lastToken(),	135	Id.FieldInitializer => @fieldParentPtr(NodeFieldInitializer, "base", base).lastToken(),
132	Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).lastToken(),	136	Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).lastToken(),
133	Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).lastToken(),	137	Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).lastToken(),
...	@@ -531,7 +535,7 @@ pub const NodeInfixOp = struct {	...	@@ -531,7 +535,7 @@ pub const NodeInfixOp = struct {
531	op: InfixOp,	535	op: InfixOp,
532	rhs: &Node,	536	rhs: &Node,
533		537
534	const InfixOp = enum {	538	const InfixOp = union(enum) {
535	Add,	539	Add,
536	AddWrap,	540	AddWrap,
537	ArrayCat,	541	ArrayCat,
...	@@ -558,6 +562,7 @@ pub const NodeInfixOp = struct {	...	@@ -558,6 +562,7 @@ pub const NodeInfixOp = struct {
558	BitXor,	562	BitXor,
559	BoolAnd,	563	BoolAnd,
560	BoolOr,	564	BoolOr,
		565	Catch: ?&NodeIdentifier,
561	Div,	566	Div,
562	EqualEqual,	567	EqualEqual,
563	ErrorUnion,	568	ErrorUnion,
...	@@ -651,9 +656,9 @@ pub const NodePrefixOp = struct {	...	@@ -651,9 +656,9 @@ pub const NodePrefixOp = struct {
651	BitNot,	656	BitNot,
652	BoolNot,	657	BoolNot,
653	Deref,	658	Deref,
		659	MaybeType,
654	Negation,	660	Negation,
655	NegationWrap,	661	NegationWrap,
656	Return,
657	ArrayType: &Node,	662	ArrayType: &Node,
658	SliceType: AddrOfInfo,	663	SliceType: AddrOfInfo,
659	Try,	664	Try,
...	@@ -754,6 +759,7 @@ pub const NodeSuffixOp = struct {	...	@@ -754,6 +759,7 @@ pub const NodeSuffixOp = struct {
754	const CallInfo = struct {	759	const CallInfo = struct {
755	params: ArrayList(&Node),	760	params: ArrayList(&Node),
756	is_async: bool,	761	is_async: bool,
		762	allocator: ?&Node,
757	};	763	};
758		764
759	const SliceRange = struct {	765	const SliceRange = struct {
...	@@ -831,6 +837,56 @@ pub const NodeGroupedExpression = struct {	...	@@ -831,6 +837,56 @@ pub const NodeGroupedExpression = struct {
831	}	837	}
832	};	838	};
833		839
		840	pub const NodeControlFlowExpression = struct {
		841	base: Node,
		842	ltoken: Token,
		843	kind: Kind,
		844	rhs: ?&Node,
		845
		846	const Kind = union(enum) {
		847	Break: ?Token,
		848	Continue: ?Token,
		849	Return,
		850	};
		851
		852	pub fn iterate(self: &NodeControlFlowExpression, index: usize) ?&Node {
		853	var i = index;
		854
		855	if (self.rhs) \|rhs\| {
		856	if (i < 1) return rhs;
		857	i -= 1;
		858	}
		859
		860	return null;
		861	}
		862
		863	pub fn firstToken(self: &NodeControlFlowExpression) Token {
		864	return self.ltoken;
		865	}
		866
		867	pub fn lastToken(self: &NodeControlFlowExpression) Token {
		868	if (self.rhs) \|rhs\| {
		869	return rhs.lastToken();
		870	}
		871
		872	switch (self.kind) {
		873	Kind.Break => \|maybe_blk_token\| {
		874	if (maybe_blk_token) \|blk_token\| {
		875	return blk_token;
		876	}
		877	},
		878	Kind.Continue => \|maybe_blk_token\| {
		879	if (maybe_blk_token) \|blk_token\| {
		880	return blk_token;
		881	}
		882	},
		883	Kind.Return => return self.ltoken,
		884	}
		885
		886	return self.ltoken;
		887	}
		888	};
		889
834	pub const NodeIntegerLiteral = struct {	890	pub const NodeIntegerLiteral = struct {
835	base: Node,	891	base: Node,
836	token: Token,	892	token: Token,

std/zig/parser.zig+1003-676

...	@@ -60,6 +60,7 @@ pub const Parser = struct {	...	@@ -60,6 +60,7 @@ pub const Parser = struct {
60	};	60	};
61		61
62	const ContainerExternCtx = struct {	62	const ContainerExternCtx = struct {
		63	dest_ptr: DestPtr,
63	ltoken: Token,	64	ltoken: Token,
64	layout: ast.NodeContainerDecl.Layout,	65	layout: ast.NodeContainerDecl.Layout,
65	};	66	};
...	@@ -67,13 +68,18 @@ pub const Parser = struct {	...	@@ -67,13 +68,18 @@ pub const Parser = struct {
67	const DestPtr = union(enum) {	68	const DestPtr = union(enum) {
68	Field: &&ast.Node,	69	Field: &&ast.Node,
69	NullableField: &?&ast.Node,	70	NullableField: &?&ast.Node,
70	List: &ArrayList(&ast.Node),
71		71
72	pub fn store(self: &const DestPtr, value: &ast.Node) !void {	72	pub fn store(self: &const DestPtr, value: &ast.Node) void {
73	switch (*self) {	73	switch (*self) {
74	DestPtr.Field => \|ptr\| *ptr = value,	74	DestPtr.Field => \|ptr\| *ptr = value,
75	DestPtr.NullableField => \|ptr\| *ptr = value,	75	DestPtr.NullableField => \|ptr\| *ptr = value,
76	DestPtr.List => \|list\| try list.append(value),	76	}
		77	}
		78
		79	pub fn get(self: &const DestPtr) &ast.Node {
		80	switch (*self) {
		81	DestPtr.Field => \|ptr\| return *ptr,
		82	DestPtr.NullableField => \|ptr\| return ??*ptr,
77	}	83	}
78	}	84	}
79	};	85	};
...	@@ -97,19 +103,13 @@ pub const Parser = struct {	...	@@ -97,19 +103,13 @@ pub const Parser = struct {
97	TopLevelDecl: TopLevelDeclCtx,	103	TopLevelDecl: TopLevelDeclCtx,
98	ContainerExtern: ContainerExternCtx,	104	ContainerExtern: ContainerExternCtx,
99	ContainerDecl: &ast.NodeContainerDecl,	105	ContainerDecl: &ast.NodeContainerDecl,
100	Expression: DestPtr,
101	ExpectOperand,
102	Operand: &ast.Node,
103	AfterOperand,
104	InfixOp: &ast.NodeInfixOp,
105	PrefixOp: &ast.NodePrefixOp,
106	SuffixOp: &ast.NodeSuffixOp,
107	SliceOrArrayAccess: &ast.NodeSuffixOp,	106	SliceOrArrayAccess: &ast.NodeSuffixOp,
108	AddrOfModifiers: &ast.NodePrefixOp.AddrOfInfo,	107	AddrOfModifiers: &ast.NodePrefixOp.AddrOfInfo,
109	TypeExpr: DestPtr,
110	VarDecl: &ast.NodeVarDecl,	108	VarDecl: &ast.NodeVarDecl,
111	VarDeclAlign: &ast.NodeVarDecl,	109	VarDeclAlign: &ast.NodeVarDecl,
112	VarDeclEq: &ast.NodeVarDecl,	110	VarDeclEq: &ast.NodeVarDecl,
		111	IfToken: @TagType(Token.Id),
		112	IfTokenSave: ExpectTokenSave,
113	ExpectToken: @TagType(Token.Id),	113	ExpectToken: @TagType(Token.Id),
114	ExpectTokenSave: ExpectTokenSave,	114	ExpectTokenSave: ExpectTokenSave,
115	FnProto: &ast.NodeFnProto,	115	FnProto: &ast.NodeFnProto,
...	@@ -125,6 +125,48 @@ pub const Parser = struct {	...	@@ -125,6 +125,48 @@ pub const Parser = struct {
125	FieldInitListItemOrEnd: ListState(&ast.NodeFieldInitializer),	125	FieldInitListItemOrEnd: ListState(&ast.NodeFieldInitializer),
126	FieldInitListCommaOrEnd: ListState(&ast.NodeFieldInitializer),	126	FieldInitListCommaOrEnd: ListState(&ast.NodeFieldInitializer),
127	FieldListCommaOrEnd: &ast.NodeContainerDecl,	127	FieldListCommaOrEnd: &ast.NodeContainerDecl,
		128
		129	/// A state that can be appended before any other State. If an error occures,
		130	/// the parser will first try looking for the closest optional state. If an
		131	/// optional state is found, the parser will revert to the state it was in
		132	/// when the optional was added. This will polute the arena allocator with
		133	/// "leaked" nodes. TODO: Figure out if it's nessesary to handle leaked nodes.
		134	Optional: Parser,
		135
		136	/// Optional can be reverted by adding the Required state to the stack.
		137	Required,
		138
		139	Expression: DestPtr,
		140	AssignmentExpressionBegin: DestPtr,
		141	AssignmentExpressionEnd: DestPtr,
		142	UnwrapExpressionBegin: DestPtr,
		143	UnwrapExpressionEnd: DestPtr,
		144	BoolOrExpressionBegin: DestPtr,
		145	BoolOrExpressionEnd: DestPtr,
		146	BoolAndExpressionBegin: DestPtr,
		147	BoolAndExpressionEnd: DestPtr,
		148	ComparisonExpressionBegin: DestPtr,
		149	ComparisonExpressionEnd: DestPtr,
		150	BinaryOrExpressionBegin: DestPtr,
		151	BinaryOrExpressionEnd: DestPtr,
		152	BinaryXorExpressionBegin: DestPtr,
		153	BinaryXorExpressionEnd: DestPtr,
		154	BinaryAndExpressionBegin: DestPtr,
		155	BinaryAndExpressionEnd: DestPtr,
		156	BitShiftExpressionBegin: DestPtr,
		157	BitShiftExpressionEnd: DestPtr,
		158	AdditionExpressionBegin: DestPtr,
		159	AdditionExpressionEnd: DestPtr,
		160	MultiplyExpressionBegin: DestPtr,
		161	MultiplyExpressionEnd: DestPtr,
		162	CurlySuffixExpressionBegin: DestPtr,
		163	CurlySuffixExpressionEnd: DestPtr,
		164	TypeExprBegin: DestPtr,
		165	TypeExprEnd: DestPtr,
		166	PrefixOpExpression: DestPtr,
		167	SuffixOpExpressionBegin: DestPtr,
		168	SuffixOpExpressionEnd: DestPtr,
		169	PrimaryExpression: DestPtr,
128	};	170	};
129		171
130	/// Returns an AST tree, allocated with the parser's allocator.	172	/// Returns an AST tree, allocated with the parser's allocator.
...	@@ -193,12 +235,16 @@ pub const Parser = struct {	...	@@ -193,12 +235,16 @@ pub const Parser = struct {
193	stack.append(State.TopLevel) catch unreachable;	235	stack.append(State.TopLevel) catch unreachable;
194		236
195	const name_token = self.getNextToken();	237	const name_token = self.getNextToken();
196	if (name_token.id != Token.Id.StringLiteral)	238	if (name_token.id != Token.Id.StringLiteral) {
197	return self.parseError(token, "expected {}, found {}", @tagName(Token.Id.StringLiteral), @tagName(name_token.id));	239	try self.parseError(&stack, token, "expected {}, found {}", @tagName(Token.Id.StringLiteral), @tagName(name_token.id));
		240	continue;
		241	}
198		242
199	const lbrace = self.getNextToken();	243	const lbrace = self.getNextToken();
200	if (lbrace.id != Token.Id.LBrace)	244	if (lbrace.id != Token.Id.LBrace) {
201	return self.parseError(token, "expected {}, found {}", @tagName(Token.Id.LBrace), @tagName(name_token.id));	245	try self.parseError(&stack, token, "expected {}, found {}", @tagName(Token.Id.LBrace), @tagName(name_token.id));
		246	continue;
		247	}
202		248
203	const name = try self.createStringLiteral(arena, name_token);	249	const name = try self.createStringLiteral(arena, name_token);
204	const block = try self.createBlock(arena, token);	250	const block = try self.createBlock(arena, token);
...	@@ -284,28 +330,35 @@ pub const Parser = struct {	...	@@ -284,28 +330,35 @@ pub const Parser = struct {
284	continue;	330	continue;
285	},	331	},
286	Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {	332	Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {
287	const fn_token = try self.eatToken(Token.Id.Keyword_fn);
288	// TODO shouldn't need this cast	333	// TODO shouldn't need this cast
289	const fn_proto = try self.createAttachFnProto(arena, ctx.decls, fn_token,	334	const fn_proto = try self.createAttachFnProto(arena, ctx.decls, undefined,
290	ctx.extern_token, ctx.lib_name, (?Token)(token), (?Token)(null), (?Token)(null));	335	ctx.extern_token, ctx.lib_name, (?Token)(token), (?Token)(null), (?Token)(null));
291	try stack.append(State { .FnDef = fn_proto });	336	try stack.append(State { .FnDef = fn_proto });
292	try stack.append(State { .FnProto = fn_proto });	337	try stack.append(State { .FnProto = fn_proto });
		338	try stack.append(State {
		339	.ExpectTokenSave = ExpectTokenSave {
		340	.id = Token.Id.Keyword_fn,
		341	.ptr = &fn_proto.fn_token,
		342	}
		343	});
		344	continue;
		345	},
		346	else => {
		347	try self.parseError(&stack, token, "expected variable declaration or function, found {}", @tagName(token.id));
293	continue;	348	continue;
294	},	349	},
295	else => return self.parseError(token, "expected variable declaration or function, found {}", @tagName(token.id)),
296	}	350	}
297	},	351	},
298	State.VarDecl => \|var_decl\| {	352	State.VarDecl => \|var_decl\| {
299	var_decl.name_token = try self.eatToken(Token.Id.Identifier);
300	stack.append(State { .VarDeclAlign = var_decl }) catch unreachable;	353	stack.append(State { .VarDeclAlign = var_decl }) catch unreachable;
301		354	try stack.append(State { .TypeExprBegin = DestPtr {.NullableField = &var_decl.type_node} });
302	const next_token = self.getNextToken();	355	try stack.append(State { .IfToken = Token.Id.Colon });
303	if (next_token.id == Token.Id.Colon) {	356	try stack.append(State {
304	try stack.append(State { .TypeExpr = DestPtr {.NullableField = &var_decl.type_node} });	357	.ExpectTokenSave = ExpectTokenSave {
305	continue;	358	.id = Token.Id.Identifier,
306	}	359	.ptr = &var_decl.name_token,
307		360	}
308	self.putBackToken(next_token);	361	});
309	continue;	362	continue;
310	},	363	},
311	State.VarDeclAlign => \|var_decl\| {	364	State.VarDeclAlign => \|var_decl\| {
...	@@ -313,9 +366,9 @@ pub const Parser = struct {	...	@@ -313,9 +366,9 @@ pub const Parser = struct {
313		366
314	const next_token = self.getNextToken();	367	const next_token = self.getNextToken();
315	if (next_token.id == Token.Id.Keyword_align) {	368	if (next_token.id == Token.Id.Keyword_align) {
316	_ = try self.eatToken(Token.Id.LParen);
317	try stack.append(State { .ExpectToken = Token.Id.RParen });	369	try stack.append(State { .ExpectToken = Token.Id.RParen });
318	try stack.append(State { .Expression = DestPtr{.NullableField = &var_decl.align_node} });	370	try stack.append(State { .Expression = DestPtr{.NullableField = &var_decl.align_node} });
		371	try stack.append(State { .ExpectToken = Token.Id.LParen });
319	continue;	372	continue;
320	}	373	}
321		374
...	@@ -341,7 +394,8 @@ pub const Parser = struct {	...	@@ -341,7 +394,8 @@ pub const Parser = struct {
341	var_decl.semicolon_token = token;	394	var_decl.semicolon_token = token;
342	continue;	395	continue;
343	}	396	}
344	return self.parseError(token, "expected '=' or ';', found {}", @tagName(token.id));	397	try self.parseError(&stack, token, "expected '=' or ';', found {}", @tagName(token.id));
		398	continue;
345	},	399	},
346		400
347	State.ContainerExtern => \|ctx\| {	401	State.ContainerExtern => \|ctx\| {
...	@@ -357,20 +411,20 @@ pub const Parser = struct {	...	@@ -357,20 +411,20 @@ pub const Parser = struct {
357	Token.Id.Keyword_union => ast.NodeContainerDecl.Kind.Union,	411	Token.Id.Keyword_union => ast.NodeContainerDecl.Kind.Union,
358	Token.Id.Keyword_enum => ast.NodeContainerDecl.Kind.Enum,	412	Token.Id.Keyword_enum => ast.NodeContainerDecl.Kind.Enum,
359	else => {	413	else => {
360	return self.parseError(token, "expected {}, {} or {}, found {}",	414	try self.parseError(&stack, token, "expected {}, {} or {}, found {}",
361	@tagName(Token.Id.Keyword_struct),	415	@tagName(Token.Id.Keyword_struct),
362	@tagName(Token.Id.Keyword_union),	416	@tagName(Token.Id.Keyword_union),
363	@tagName(Token.Id.Keyword_enum),	417	@tagName(Token.Id.Keyword_enum),
364	@tagName(token.id));	418	@tagName(token.id));
		419	continue;
365	},	420	},
366	},	421	},
367	.init_arg_expr = undefined,	422	.init_arg_expr = undefined,
368	.fields_and_decls = ArrayList(&ast.Node).init(arena),	423	.fields_and_decls = ArrayList(&ast.Node).init(arena),
369	.rbrace_token = undefined,	424	.rbrace_token = undefined,
370	};	425	};
		426	ctx.dest_ptr.store(&node.base);
371		427
372	try stack.append(State { .Operand = &node.base });
373	try stack.append(State.AfterOperand);
374	try stack.append(State { .ContainerDecl = node });	428	try stack.append(State { .ContainerDecl = node });
375	try stack.append(State { .ExpectToken = Token.Id.LBrace });	429	try stack.append(State { .ExpectToken = Token.Id.LBrace });
376		430
...	@@ -496,144 +550,569 @@ pub const Parser = struct {	...	@@ -496,144 +550,569 @@ pub const Parser = struct {
496	},	550	},
497		551
498	State.ExpectToken => \|token_id\| {	552	State.ExpectToken => \|token_id\| {
499	_ = try self.eatToken(token_id);	553	_ = (try self.eatToken(&stack, token_id)) ?? continue;
500	continue;	554	continue;
501	},	555	},
502		556
503	State.ExpectTokenSave => \|expect_token_save\| {	557	State.ExpectTokenSave => \|expect_token_save\| {
504	*expect_token_save.ptr = try self.eatToken(expect_token_save.id);	558	*expect_token_save.ptr = (try self.eatToken(&stack, expect_token_save.id)) ?? continue;
505	continue;	559	continue;
506	},	560	},
507		561
508	State.Expression => \|dest_ptr\| {	562	State.IfToken => \|token_id\| {
509	// save the dest_ptr for later	563	const token = self.getNextToken();
510	stack.append(state) catch unreachable;	564	if (@TagType(Token.Id)(token.id) != token_id) {
511	try stack.append(State.ExpectOperand);	565	self.putBackToken(token);
		566	_ = stack.pop();
		567	continue;
		568	}
		569	continue;
		570	},
		571
		572	State.IfTokenSave => \|if_token_save\| {
		573	const token = self.getNextToken();
		574	if (@TagType(Token.Id)(token.id) != if_token_save.id) {
		575	self.putBackToken(token);
		576	_ = stack.pop();
		577	continue;
		578	}
		579
		580	*if_token_save.ptr = token;
512	continue;	581	continue;
513	},	582	},
514	State.ExpectOperand => {	583
515	// we'll either get an operand (like 1 or x),	584	State.Optional,
516	// or a prefix operator (like ~ or return).	585	State.Required => { },
		586
		587	State.Expression => \|dest_ptr\| {
517	const token = self.getNextToken();	588	const token = self.getNextToken();
518	switch (token.id) {	589	switch (token.id) {
		590	Token.Id.Keyword_try => {
		591	const node = try self.createPrefixOp(arena, token, ast.NodePrefixOp.PrefixOp.Try);
		592	dest_ptr.store(&node.base);
		593
		594	stack.append(State { .Expression = DestPtr { .Field = &node.rhs } }) catch unreachable;
		595	continue;
		596	},
519	Token.Id.Keyword_return => {	597	Token.Id.Keyword_return => {
520	try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,	598	const node = try self.createControlFlowExpr(arena, token, ast.NodeControlFlowExpression.Kind.Return);
521	ast.NodePrefixOp.PrefixOp.Return) });	599	dest_ptr.store(&node.base);
522	try stack.append(State.ExpectOperand);	600
		601	stack.append(State { .Optional = *self }) catch unreachable;
		602	try stack.append(State { .Expression = DestPtr { .NullableField = &node.rhs } });
523	continue;	603	continue;
524	},	604	},
525	Token.Id.Keyword_try => {	605	Token.Id.Keyword_break => {
526	try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,	606	@panic("TODO: break");
527	ast.NodePrefixOp.PrefixOp.Try) });	607	},
528	try stack.append(State.ExpectOperand);	608	Token.Id.Keyword_continue => {
		609	@panic("TODO: break");
		610	},
		611	Token.Id.Keyword_cancel => {
		612	@panic("TODO: cancel");
		613	},
		614	Token.Id.Keyword_resume => {
		615	@panic("TODO: resume");
		616	},
		617	Token.Id.Keyword_await => {
		618	@panic("TODO: await");
		619	},
		620	Token.Id.Keyword_suspend => {
		621	@panic("TODO: suspend");
		622	},
		623	else => {
		624	self.putBackToken(token);
		625	stack.append(State { .AssignmentExpressionBegin = dest_ptr }) catch unreachable;
		626	continue;
		627	}
		628	}
		629	},
		630
		631	State.AssignmentExpressionBegin => \|dest_ptr\| {
		632	try stack.append(State { .AssignmentExpressionEnd = dest_ptr });
		633	stack.append(State { .UnwrapExpressionBegin = dest_ptr }) catch unreachable;
		634	continue;
		635	},
		636
		637	State.AssignmentExpressionEnd => \|dest_ptr\| {
		638	const token = self.getNextToken();
		639	if (tokenIdToAssignment(token.id)) \|ass_id\| {
		640	const node = try self.createInfixOp(arena, token, ass_id);
		641	node.lhs = dest_ptr.get();
		642	dest_ptr.store(&node.base);
		643
		644	stack.append(State { .AssignmentExpressionEnd = dest_ptr }) catch unreachable;
		645	try stack.append(State { .UnwrapExpressionBegin = DestPtr { .Field = &node.rhs } });
		646	continue;
		647	} else {
		648	self.putBackToken(token);
		649	continue;
		650	}
		651	},
		652
		653	State.UnwrapExpressionBegin => \|dest_ptr\| {
		654	stack.append(State { .UnwrapExpressionEnd = dest_ptr }) catch unreachable;
		655	try stack.append(State { .BoolOrExpressionBegin = dest_ptr });
		656	continue;
		657	},
		658
		659	State.UnwrapExpressionEnd => \|dest_ptr\| {
		660	const token = self.getNextToken();
		661	switch (token.id) {
		662	Token.Id.Keyword_catch => {
		663	const node = try self.createInfixOp(arena, token, ast.NodeInfixOp.InfixOp { .Catch = null });
		664	node.lhs = dest_ptr.get();
		665	dest_ptr.store(&node.base);
		666
		667	stack.append(State { .UnwrapExpressionEnd = dest_ptr }) catch unreachable;
		668	try stack.append(State { .Expression = DestPtr { .Field = &node.rhs } });
		669
		670	const next = self.getNextToken();
		671	if (next.id != Token.Id.Pipe) {
		672	self.putBackToken(next);
		673	continue;
		674	}
		675
		676	node.op.Catch = try self.createIdentifier(arena, undefined);
		677	try stack.append(State { .ExpectToken = Token.Id.Pipe });
		678	try stack.append(State {
		679	.ExpectTokenSave = ExpectTokenSave {
		680	.id = Token.Id.Identifier,
		681	.ptr = &(??node.op.Catch).name_token
		682	}
		683	});
529	continue;	684	continue;
530	},	685	},
531	Token.Id.Minus => {	686	Token.Id.QuestionMarkQuestionMark => {
532	try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,	687	const node = try self.createInfixOp(arena, token, ast.NodeInfixOp.InfixOp.UnwrapMaybe);
533	ast.NodePrefixOp.PrefixOp.Negation) });	688	node.lhs = dest_ptr.get();
534	try stack.append(State.ExpectOperand);	689	dest_ptr.store(&node.base);
		690
		691	stack.append(State { .UnwrapExpressionEnd = dest_ptr }) catch unreachable;
		692	try stack.append(State { .Expression = DestPtr { .Field = &node.rhs } });
535	continue;	693	continue;
536	},	694	},
537	Token.Id.MinusPercent => {	695	else => {
538	try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,	696	self.putBackToken(token);
539	ast.NodePrefixOp.PrefixOp.NegationWrap) });
540	try stack.append(State.ExpectOperand);
541	continue;	697	continue;
542	},	698	},
543	Token.Id.Tilde => {	699	}
544	try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,	700	},
545	ast.NodePrefixOp.PrefixOp.BitNot) });	701
546	try stack.append(State.ExpectOperand);	702	State.BoolOrExpressionBegin => \|dest_ptr\| {
		703	stack.append(State { .BoolOrExpressionEnd = dest_ptr }) catch unreachable;
		704	try stack.append(State { .BoolAndExpressionBegin = dest_ptr });
		705	continue;
		706	},
		707
		708	State.BoolOrExpressionEnd => \|dest_ptr\| {
		709	const token = self.getNextToken();
		710	switch (token.id) {
		711	Token.Id.Keyword_or => {
		712	const node = try self.createInfixOp(arena, token, ast.NodeInfixOp.InfixOp.BoolOr);
		713	node.lhs = dest_ptr.get();
		714	dest_ptr.store(&node.base);
		715
		716	stack.append(State { .BoolOrExpressionEnd = dest_ptr }) catch unreachable;
		717	try stack.append(State { .BoolAndExpressionBegin = DestPtr { .Field = &node.rhs } });
547	continue;	718	continue;
548	},	719	},
549	Token.Id.QuestionMarkQuestionMark => {	720	else => {
550	try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,	721	self.putBackToken(token);
551	ast.NodePrefixOp.PrefixOp.UnwrapMaybe) });
552	try stack.append(State.ExpectOperand);
553	continue;	722	continue;
554	},	723	},
555	Token.Id.Bang => {	724	}
556	try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,	725	},
557	ast.NodePrefixOp.PrefixOp.BoolNot) });	726
558	try stack.append(State.ExpectOperand);	727	State.BoolAndExpressionBegin => \|dest_ptr\| {
		728	stack.append(State { .BoolAndExpressionEnd = dest_ptr }) catch unreachable;
		729	try stack.append(State { .ComparisonExpressionBegin = dest_ptr });
		730	continue;
		731	},
		732
		733	State.BoolAndExpressionEnd => \|dest_ptr\| {
		734	const token = self.getNextToken();
		735	switch (token.id) {
		736	Token.Id.Keyword_and => {
		737	const node = try self.createInfixOp(arena, token, ast.NodeInfixOp.InfixOp.BoolAnd);
		738	node.lhs = dest_ptr.get();
		739	dest_ptr.store(&node.base);
		740
		741	stack.append(State { .BoolAndExpressionEnd = dest_ptr }) catch unreachable;
		742	try stack.append(State { .ComparisonExpressionBegin = DestPtr { .Field = &node.rhs } });
559	continue;	743	continue;
560	},	744	},
561	Token.Id.Asterisk => {	745	else => {
562	try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,	746	self.putBackToken(token);
563	ast.NodePrefixOp.PrefixOp.Deref) });
564	try stack.append(State.ExpectOperand);
565	continue;	747	continue;
566	},	748	},
567	Token.Id.LBracket => {	749	}
568	const rbracket_token = self.getNextToken();	750	},
569	if (rbracket_token.id == Token.Id.RBracket) {
570	const prefix_op = try self.createPrefixOp(arena, token, ast.NodePrefixOp.PrefixOp{
571	.SliceType = ast.NodePrefixOp.AddrOfInfo {
572	.align_expr = null,
573	.bit_offset_start_token = null,
574	.bit_offset_end_token = null,
575	.const_token = null,
576	.volatile_token = null,
577	}
578	});
579	try stack.append(State { .PrefixOp = prefix_op });
580	try stack.append(State.ExpectOperand);
581	try stack.append(State { .AddrOfModifiers = &prefix_op.op.AddrOf });
582	continue;
583	}
584		751
585	self.putBackToken(rbracket_token);	752	State.ComparisonExpressionBegin => \|dest_ptr\| {
		753	stack.append(State { .ComparisonExpressionEnd = dest_ptr }) catch unreachable;
		754	try stack.append(State { .BinaryOrExpressionBegin = dest_ptr });
		755	continue;
		756	},
586		757
587	const prefix_op = try self.createPrefixOp(arena, token, ast.NodePrefixOp.PrefixOp{	758	State.ComparisonExpressionEnd => \|dest_ptr\| {
588	.ArrayType = undefined,	759	const token = self.getNextToken();
589	});	760	if (tokenIdToComparison(token.id)) \|comp_id\| {
590	try stack.append(State { .PrefixOp = prefix_op });	761	const node = try self.createInfixOp(arena, token, comp_id);
591	try stack.append(State.ExpectOperand);	762	node.lhs = dest_ptr.get();
592	try stack.append(State { .ExpectToken = Token.Id.RBracket });	763	dest_ptr.store(&node.base);
593	try stack.append(State { .Expression = DestPtr { .Field = &prefix_op.op.ArrayType } });	764
		765	stack.append(State { .ComparisonExpressionEnd = dest_ptr }) catch unreachable;
		766	try stack.append(State { .BinaryOrExpressionBegin = DestPtr { .Field = &node.rhs } });
		767	continue;
		768	} else {
		769	self.putBackToken(token);
		770	continue;
		771	}
		772	},
		773
		774	State.BinaryOrExpressionBegin => \|dest_ptr\| {
		775	stack.append(State { .BinaryOrExpressionEnd = dest_ptr }) catch unreachable;
		776	try stack.append(State { .BinaryXorExpressionBegin = dest_ptr });
		777	continue;
		778	},
		779
		780	State.BinaryOrExpressionEnd => \|dest_ptr\| {
		781	const token = self.getNextToken();
		782	switch (token.id) {
		783	Token.Id.Pipe => {
		784	const node = try self.createInfixOp(arena, token, ast.NodeInfixOp.InfixOp.BitOr);
		785	node.lhs = dest_ptr.get();
		786	dest_ptr.store(&node.base);
594		787
		788	stack.append(State { .BinaryOrExpressionEnd = dest_ptr }) catch unreachable;
		789	try stack.append(State { .BinaryXorExpressionBegin = DestPtr { .Field = &node.rhs } });
		790	continue;
		791	},
		792	else => {
		793	self.putBackToken(token);
		794	continue;
		795	},
		796	}
		797	},
		798
		799	State.BinaryXorExpressionBegin => \|dest_ptr\| {
		800	stack.append(State { .BinaryXorExpressionEnd = dest_ptr }) catch unreachable;
		801	try stack.append(State { .BinaryAndExpressionBegin = dest_ptr });
		802	continue;
		803	},
		804
		805	State.BinaryXorExpressionEnd => \|dest_ptr\| {
		806	const token = self.getNextToken();
		807	switch (token.id) {
		808	Token.Id.Caret => {
		809	const node = try self.createInfixOp(arena, token, ast.NodeInfixOp.InfixOp.BitXor);
		810	node.lhs = dest_ptr.get();
		811	dest_ptr.store(&node.base);
		812
		813	stack.append(State { .BinaryXorExpressionEnd = dest_ptr }) catch unreachable;
		814	try stack.append(State { .BinaryAndExpressionBegin = DestPtr { .Field = &node.rhs } });
		815	continue;
595	},	816	},
		817	else => {
		818	self.putBackToken(token);
		819	continue;
		820	},
		821	}
		822	},
		823
		824	State.BinaryAndExpressionBegin => \|dest_ptr\| {
		825	stack.append(State { .BinaryAndExpressionEnd = dest_ptr }) catch unreachable;
		826	try stack.append(State { .BitShiftExpressionBegin = dest_ptr });
		827	continue;
		828	},
		829
		830	State.BinaryAndExpressionEnd => \|dest_ptr\| {
		831	const token = self.getNextToken();
		832	switch (token.id) {
596	Token.Id.Ampersand => {	833	Token.Id.Ampersand => {
597	const prefix_op = try self.createPrefixOp(arena, token, ast.NodePrefixOp.PrefixOp{	834	const node = try self.createInfixOp(arena, token, ast.NodeInfixOp.InfixOp.BitAnd);
598	.AddrOf = ast.NodePrefixOp.AddrOfInfo {	835	node.lhs = dest_ptr.get();
599	.align_expr = null,	836	dest_ptr.store(&node.base);
600	.bit_offset_start_token = null,	837
601	.bit_offset_end_token = null,	838	stack.append(State { .BinaryAndExpressionEnd = dest_ptr }) catch unreachable;
602	.const_token = null,	839	try stack.append(State { .BitShiftExpressionBegin = DestPtr { .Field = &node.rhs } });
603	.volatile_token = null,	840	continue;
		841	},
		842	else => {
		843	self.putBackToken(token);
		844	continue;
		845	},
		846	}
		847	},
		848
		849	State.BitShiftExpressionBegin => \|dest_ptr\| {
		850	stack.append(State { .BitShiftExpressionEnd = dest_ptr }) catch unreachable;
		851	try stack.append(State { .AdditionExpressionBegin = dest_ptr });
		852	continue;
		853	},
		854
		855	State.BitShiftExpressionEnd => \|dest_ptr\| {
		856	const token = self.getNextToken();
		857	if (tokenIdToBitShift(token.id)) \|bitshift_id\| {
		858	const node = try self.createInfixOp(arena, token, bitshift_id);
		859	node.lhs = dest_ptr.get();
		860	dest_ptr.store(&node.base);
		861
		862	stack.append(State { .BitShiftExpressionEnd = dest_ptr }) catch unreachable;
		863	try stack.append(State { .AdditionExpressionBegin = DestPtr { .Field = &node.rhs } });
		864	continue;
		865	} else {
		866	self.putBackToken(token);
		867	continue;
		868	}
		869	},
		870
		871	State.AdditionExpressionBegin => \|dest_ptr\| {
		872	stack.append(State { .AdditionExpressionEnd = dest_ptr }) catch unreachable;
		873	try stack.append(State { .MultiplyExpressionBegin = dest_ptr });
		874	continue;
		875	},
		876
		877	State.AdditionExpressionEnd => \|dest_ptr\| {
		878	const token = self.getNextToken();
		879	if (tokenIdToAddition(token.id)) \|add_id\| {
		880	const node = try self.createInfixOp(arena, token, add_id);
		881	node.lhs = dest_ptr.get();
		882	dest_ptr.store(&node.base);
		883
		884	stack.append(State { .AdditionExpressionEnd = dest_ptr }) catch unreachable;
		885	try stack.append(State { .MultiplyExpressionBegin = DestPtr { .Field = &node.rhs } });
		886	continue;
		887	} else {
		888	self.putBackToken(token);
		889	continue;
		890	}
		891	},
		892
		893	State.MultiplyExpressionBegin => \|dest_ptr\| {
		894	stack.append(State { .MultiplyExpressionEnd = dest_ptr }) catch unreachable;
		895	try stack.append(State { .CurlySuffixExpressionBegin = dest_ptr });
		896	continue;
		897	},
		898
		899	State.MultiplyExpressionEnd => \|dest_ptr\| {
		900	const token = self.getNextToken();
		901	if (tokenIdToMultiply(token.id)) \|mult_id\| {
		902	const node = try self.createInfixOp(arena, token, mult_id);
		903	node.lhs = dest_ptr.get();
		904	dest_ptr.store(&node.base);
		905
		906	stack.append(State { .MultiplyExpressionEnd = dest_ptr }) catch unreachable;
		907	try stack.append(State { .CurlySuffixExpressionBegin = DestPtr { .Field = &node.rhs } });
		908	continue;
		909	} else {
		910	self.putBackToken(token);
		911	continue;
		912	}
		913	},
		914
		915	State.CurlySuffixExpressionBegin => \|dest_ptr\| {
		916	stack.append(State { .CurlySuffixExpressionEnd = dest_ptr }) catch unreachable;
		917	try stack.append(State { .TypeExprBegin = dest_ptr });
		918	continue;
		919	},
		920
		921	State.CurlySuffixExpressionEnd => \|dest_ptr\| {
		922	const token = self.getNextToken();
		923	if (token.id != Token.Id.LBrace) {
		924	self.putBackToken(token);
		925	continue;
		926	}
		927
		928	const next = self.getNextToken();
		929	self.putBackToken(token);
		930	switch (next.id) {
		931	Token.Id.Period => {
		932	const node = try self.createSuffixOp(arena, ast.NodeSuffixOp.SuffixOp {
		933	.StructInitializer = ArrayList(&ast.NodeFieldInitializer).init(arena),
		934	});
		935	node.lhs = dest_ptr.get();
		936	dest_ptr.store(&node.base);
		937
		938	stack.append(State { .CurlySuffixExpressionEnd = dest_ptr }) catch unreachable;
		939	try stack.append(State {
		940	.FieldInitListItemOrEnd = ListState(&ast.NodeFieldInitializer) {
		941	.list = &node.op.StructInitializer,
		942	.end = Token.Id.RBrace,
		943	.ptr = &node.rtoken,
604	}	944	}
605	});	945	});
606	try stack.append(State { .PrefixOp = prefix_op });
607	try stack.append(State.ExpectOperand);
608	try stack.append(State { .AddrOfModifiers = &prefix_op.op.AddrOf });
609	continue;	946	continue;
610	},	947	},
611	Token.Id.Identifier => {	948	else => {
		949	const node = try self.createSuffixOp(arena, ast.NodeSuffixOp.SuffixOp {
		950	.ArrayInitializer = ArrayList(&ast.Node).init(arena),
		951	});
		952	node.lhs = dest_ptr.get();
		953	dest_ptr.store(&node.base);
		954
		955	stack.append(State { .CurlySuffixExpressionEnd = dest_ptr }) catch unreachable;
612	try stack.append(State {	956	try stack.append(State {
613	.Operand = &(try self.createIdentifier(arena, token)).base	957	.ExprListItemOrEnd = ListState(&ast.Node) {
		958	.list = &node.op.ArrayInitializer,
		959	.end = Token.Id.RBrace,
		960	.ptr = &node.rtoken,
		961	}
614	});	962	});
615	try stack.append(State.AfterOperand);
616	continue;	963	continue;
617	},	964	},
618	Token.Id.IntegerLiteral => {	965	}
		966	},
		967
		968	State.TypeExprBegin => \|dest_ptr\| {
		969	const token = self.getNextToken();
		970	if (token.id == Token.Id.Keyword_var) {
		971	@panic("TODO param with type var");
		972	}
		973	self.putBackToken(token);
		974
		975	stack.append(State { .TypeExprEnd = dest_ptr }) catch unreachable;
		976	try stack.append(State { .PrefixOpExpression = dest_ptr });
		977	continue;
		978	},
		979
		980	State.TypeExprEnd => \|dest_ptr\| {
		981	const token = self.getNextToken();
		982	switch (token.id) {
		983	Token.Id.Bang => {
		984	const node = try self.createInfixOp(arena, token, ast.NodeInfixOp.InfixOp.ErrorUnion);
		985	node.lhs = dest_ptr.get();
		986	dest_ptr.store(&node.base);
		987
		988	stack.append(State { .TypeExprEnd = dest_ptr }) catch unreachable;
		989	try stack.append(State { .PrefixOpExpression = DestPtr { .Field = &node.rhs } });
		990	continue;
		991	},
		992	else => {
		993	self.putBackToken(token);
		994	continue;
		995	},
		996	}
		997	},
		998
		999	State.PrefixOpExpression => \|dest_ptr\| {
		1000	const token = self.getNextToken();
		1001	if (tokenIdToPrefixOp(token.id)) \|prefix_id\| {
		1002	const node = try self.createPrefixOp(arena, token, prefix_id);
		1003	dest_ptr.store(&node.base);
		1004
		1005	stack.append(State { .TypeExprBegin = DestPtr { .Field = &node.rhs } }) catch unreachable;
		1006	if (node.op == ast.NodePrefixOp.PrefixOp.AddrOf) {
		1007	try stack.append(State { .AddrOfModifiers = &node.op.AddrOf });
		1008	}
		1009	continue;
		1010	} else {
		1011	self.putBackToken(token);
		1012	stack.append(State { .SuffixOpExpressionBegin = dest_ptr }) catch unreachable;
		1013	continue;
		1014	}
		1015	},
		1016
		1017	State.SuffixOpExpressionBegin => \|dest_ptr\| {
		1018	const token = self.getNextToken();
		1019	switch (token.id) {
		1020	Token.Id.Keyword_async => {
		1021	@panic("TODO: Parse async");
		1022	},
		1023	else => {
		1024	self.putBackToken(token);
		1025	stack.append(State { .SuffixOpExpressionEnd = dest_ptr }) catch unreachable;
		1026	try stack.append(State { .PrimaryExpression = dest_ptr });
		1027	continue;
		1028	}
		1029	}
		1030	},
		1031
		1032	State.SuffixOpExpressionEnd => \|dest_ptr\| {
		1033	const token = self.getNextToken();
		1034	switch (token.id) {
		1035	Token.Id.LParen => {
		1036	const node = try self.createSuffixOp(arena, ast.NodeSuffixOp.SuffixOp {
		1037	.Call = ast.NodeSuffixOp.CallInfo {
		1038	.params = ArrayList(&ast.Node).init(arena),
		1039	.is_async = false, // TODO: ASYNC
		1040	.allocator = null,
		1041	}
		1042	});
		1043	node.lhs = dest_ptr.get();
		1044	dest_ptr.store(&node.base);
		1045
		1046	stack.append(State { .SuffixOpExpressionEnd = dest_ptr }) catch unreachable;
619	try stack.append(State {	1047	try stack.append(State {
620	.Operand = &(try self.createIntegerLiteral(arena, token)).base	1048	.ExprListItemOrEnd = ListState(&ast.Node) {
		1049	.list = &node.op.Call.params,
		1050	.end = Token.Id.RParen,
		1051	.ptr = &node.rtoken,
		1052	}
621	});	1053	});
622	try stack.append(State.AfterOperand);	1054	continue;
		1055	},
		1056	Token.Id.LBracket => {
		1057	const node = try arena.create(ast.NodeSuffixOp);
		1058	*node = ast.NodeSuffixOp {
		1059	.base = self.initNode(ast.Node.Id.SuffixOp),
		1060	.lhs = undefined,
		1061	.op = ast.NodeSuffixOp.SuffixOp {
		1062	.ArrayAccess = undefined,
		1063	},
		1064	.rtoken = undefined,
		1065	};
		1066	node.lhs = dest_ptr.get();
		1067	dest_ptr.store(&node.base);
		1068
		1069	stack.append(State { .SuffixOpExpressionEnd = dest_ptr }) catch unreachable;
		1070	try stack.append(State { .SliceOrArrayAccess = node });
		1071	try stack.append(State { .Expression = DestPtr { .Field = &node.op.ArrayAccess }});
		1072	continue;
		1073	},
		1074	Token.Id.Period => {
		1075	const node = try self.createInfixOp(arena, token, ast.NodeInfixOp.InfixOp.Period);
		1076	node.lhs = dest_ptr.get();
		1077	dest_ptr.store(&node.base);
		1078
		1079	stack.append(State { .SuffixOpExpressionEnd = dest_ptr }) catch unreachable;
		1080	try stack.append(State { .SuffixOpExpressionBegin = DestPtr { .Field = &node.rhs }});
		1081	continue;
		1082	},
		1083	else => {
		1084	self.putBackToken(token);
		1085	continue;
		1086	},
		1087	}
		1088	},
		1089
		1090	State.PrimaryExpression => \|dest_ptr\| {
		1091	const token = self.getNextToken();
		1092	switch (token.id) {
		1093	Token.Id.IntegerLiteral => {
		1094	dest_ptr.store(&(try self.createIntegerLiteral(arena, token)).base);
623	continue;	1095	continue;
624	},	1096	},
625	Token.Id.FloatLiteral => {	1097	Token.Id.FloatLiteral => {
626	try stack.append(State {	1098	dest_ptr.store(&(try self.createFloatLiteral(arena, token)).base);
627	.Operand = &(try self.createFloatLiteral(arena, token)).base	1099	continue;
628	});	1100	},
629	try stack.append(State.AfterOperand);	1101	Token.Id.StringLiteral => {
		1102	dest_ptr.store(&(try self.createStringLiteral(arena, token)).base);
		1103	continue;
		1104	},
		1105	Token.Id.CharLiteral => {
		1106	const node = try arena.create(ast.NodeCharLiteral);
		1107	*node = ast.NodeCharLiteral {
		1108	.base = self.initNode(ast.Node.Id.CharLiteral),
		1109	.token = token,
		1110	};
		1111	dest_ptr.store(&node.base);
630	continue;	1112	continue;
631	},	1113	},
632	Token.Id.Keyword_undefined => {	1114	Token.Id.Keyword_undefined => {
633	try stack.append(State {	1115	dest_ptr.store(&(try self.createUndefined(arena, token)).base);
634	.Operand = &(try self.createUndefined(arena, token)).base
635	});
636	try stack.append(State.AfterOperand);
637	continue;	1116	continue;
638	},	1117	},
639	Token.Id.Keyword_true, Token.Id.Keyword_false => {	1118	Token.Id.Keyword_true, Token.Id.Keyword_false => {
...	@@ -642,10 +1121,7 @@ pub const Parser = struct {	...	@@ -642,10 +1121,7 @@ pub const Parser = struct {
642	.base = self.initNode(ast.Node.Id.BoolLiteral),	1121	.base = self.initNode(ast.Node.Id.BoolLiteral),
643	.token = token,	1122	.token = token,
644	};	1123	};
645	try stack.append(State {	1124	dest_ptr.store(&node.base);
646	.Operand = &node.base
647	});
648	try stack.append(State.AfterOperand);
649	continue;	1125	continue;
650	},	1126	},
651	Token.Id.Keyword_null => {	1127	Token.Id.Keyword_null => {
...	@@ -654,10 +1130,7 @@ pub const Parser = struct {	...	@@ -654,10 +1130,7 @@ pub const Parser = struct {
654	.base = self.initNode(ast.Node.Id.NullLiteral),	1130	.base = self.initNode(ast.Node.Id.NullLiteral),
655	.token = token,	1131	.token = token,
656	};	1132	};
657	try stack.append(State {	1133	dest_ptr.store(&node.base);
658	.Operand = &node.base
659	});
660	try stack.append(State.AfterOperand);
661	continue;	1134	continue;
662	},	1135	},
663	Token.Id.Keyword_this => {	1136	Token.Id.Keyword_this => {
...	@@ -666,10 +1139,7 @@ pub const Parser = struct {	...	@@ -666,10 +1139,7 @@ pub const Parser = struct {
666	.base = self.initNode(ast.Node.Id.ThisLiteral),	1139	.base = self.initNode(ast.Node.Id.ThisLiteral),
667	.token = token,	1140	.token = token,
668	};	1141	};
669	try stack.append(State {	1142	dest_ptr.store(&node.base);
670	.Operand = &node.base
671	});
672	try stack.append(State.AfterOperand);
673	continue;	1143	continue;
674	},	1144	},
675	Token.Id.Keyword_unreachable => {	1145	Token.Id.Keyword_unreachable => {
...	@@ -678,12 +1148,97 @@ pub const Parser = struct {	...	@@ -678,12 +1148,97 @@ pub const Parser = struct {
678	.base = self.initNode(ast.Node.Id.Unreachable),	1148	.base = self.initNode(ast.Node.Id.Unreachable),
679	.token = token,	1149	.token = token,
680	};	1150	};
		1151	dest_ptr.store(&node.base);
		1152	continue;
		1153	},
		1154	Token.Id.MultilineStringLiteralLine => {
		1155	const node = try arena.create(ast.NodeMultilineStringLiteral);
		1156	*node = ast.NodeMultilineStringLiteral {
		1157	.base = self.initNode(ast.Node.Id.MultilineStringLiteral),
		1158	.tokens = ArrayList(Token).init(arena),
		1159	};
		1160	dest_ptr.store(&node.base);
		1161	try node.tokens.append(token);
		1162
		1163	while (true) {
		1164	const multiline_str = self.getNextToken();
		1165	if (multiline_str.id != Token.Id.MultilineStringLiteralLine) {
		1166	self.putBackToken(multiline_str);
		1167	break;
		1168	}
		1169
		1170	try node.tokens.append(multiline_str);
		1171	}
		1172	continue;
		1173	},
		1174	Token.Id.LParen => {
		1175	const node = try arena.create(ast.NodeGroupedExpression);
		1176	*node = ast.NodeGroupedExpression {
		1177	.base = self.initNode(ast.Node.Id.GroupedExpression),
		1178	.lparen = token,
		1179	.expr = undefined,
		1180	.rparen = undefined,
		1181	};
		1182	dest_ptr.store(&node.base);
681	try stack.append(State {	1183	try stack.append(State {
682	.Operand = &node.base	1184	.ExpectTokenSave = ExpectTokenSave {
		1185	.id = Token.Id.RParen,
		1186	.ptr = &node.rparen,
		1187	}
683	});	1188	});
684	try stack.append(State.AfterOperand);	1189	try stack.append(State { .Expression = DestPtr { .Field = &node.expr } });
		1190	continue;
		1191	},
		1192	Token.Id.Identifier => {
		1193	dest_ptr.store(&(try self.createIdentifier(arena, token)).base);
		1194	continue;
		1195	},
		1196	Token.Id.Builtin => {
		1197	const node = try arena.create(ast.NodeBuiltinCall);
		1198	*node = ast.NodeBuiltinCall {
		1199	.base = self.initNode(ast.Node.Id.BuiltinCall),
		1200	.builtin_token = token,
		1201	.params = ArrayList(&ast.Node).init(arena),
		1202	.rparen_token = undefined,
		1203	};
		1204	dest_ptr.store(&node.base);
		1205	try stack.append(State {
		1206	.ExprListItemOrEnd = ListState(&ast.Node) {
		1207	.list = &node.params,
		1208	.end = Token.Id.RParen,
		1209	.ptr = &node.rparen_token,
		1210	}
		1211	});
		1212	try stack.append(State { .ExpectToken = Token.Id.LParen, });
685	continue;	1213	continue;
686	},	1214	},
		1215	Token.Id.LBracket => {
		1216	const rbracket_token = self.getNextToken();
		1217	if (rbracket_token.id == Token.Id.RBracket) {
		1218	const node = try self.createPrefixOp(arena, token, ast.NodePrefixOp.PrefixOp{
		1219	.SliceType = ast.NodePrefixOp.AddrOfInfo {
		1220	.align_expr = null,
		1221	.bit_offset_start_token = null,
		1222	.bit_offset_end_token = null,
		1223	.const_token = null,
		1224	.volatile_token = null,
		1225	}
		1226	});
		1227	dest_ptr.store(&node.base);
		1228	try stack.append(State { .AddrOfModifiers = &node.op.AddrOf });
		1229	continue;
		1230	}
		1231
		1232	self.putBackToken(rbracket_token);
		1233
		1234	const node = try self.createPrefixOp(arena, token, ast.NodePrefixOp.PrefixOp{
		1235	.ArrayType = undefined,
		1236	});
		1237	dest_ptr.store(&node.base);
		1238	try stack.append(State { .ExpectToken = Token.Id.RBracket });
		1239	try stack.append(State { .Expression = DestPtr { .Field = &node.op.ArrayType } });
		1240
		1241	},
687	Token.Id.Keyword_error => {	1242	Token.Id.Keyword_error => {
688	const next = self.getNextToken();	1243	const next = self.getNextToken();
689		1244
...	@@ -694,10 +1249,7 @@ pub const Parser = struct {	...	@@ -694,10 +1249,7 @@ pub const Parser = struct {
694	.base = self.initNode(ast.Node.Id.ErrorType),	1249	.base = self.initNode(ast.Node.Id.ErrorType),
695	.token = token,	1250	.token = token,
696	};	1251	};
697	try stack.append(State {	1252	dest_ptr.store(&node.base);
698	.Operand = &node.base
699	});
700	try stack.append(State.AfterOperand);
701	continue;	1253	continue;
702	}	1254	}
703		1255
...	@@ -708,6 +1260,7 @@ pub const Parser = struct {	...	@@ -708,6 +1260,7 @@ pub const Parser = struct {
708	.decls = ArrayList(&ast.NodeIdentifier).init(arena),	1260	.decls = ArrayList(&ast.NodeIdentifier).init(arena),
709	.rbrace_token = undefined,	1261	.rbrace_token = undefined,
710	};	1262	};
		1263	dest_ptr.store(&node.base);
711		1264
712	while (true) {	1265	while (true) {
713	const t = self.getNextToken();	1266	const t = self.getNextToken();
...	@@ -722,10 +1275,11 @@ pub const Parser = struct {	...	@@ -722,10 +1275,11 @@ pub const Parser = struct {
722	);	1275	);
723	},	1276	},
724	else => {	1277	else => {
725	return self.parseError(token, "expected {} or {}, found {}",	1278	try self.parseError(&stack, token, "expected {} or {}, found {}",
726	@tagName(Token.Id.RBrace),	1279	@tagName(Token.Id.RBrace),
727	@tagName(Token.Id.Identifier),	1280	@tagName(Token.Id.Identifier),
728	@tagName(token.id));	1281	@tagName(token.id));
		1282	continue;
729	}	1283	}
730	}	1284	}
731		1285
...	@@ -737,23 +1291,20 @@ pub const Parser = struct {	...	@@ -737,23 +1291,20 @@ pub const Parser = struct {
737	},	1291	},
738	Token.Id.Comma => continue,	1292	Token.Id.Comma => continue,
739	else => {	1293	else => {
740	return self.parseError(token, "expected {} or {}, found {}",	1294	try self.parseError(&stack, token, "expected {} or {}, found {}",
741	@tagName(Token.Id.RBrace),	1295	@tagName(Token.Id.RBrace),
742	@tagName(Token.Id.Comma),	1296	@tagName(Token.Id.Comma),
743	@tagName(token.id));	1297	@tagName(token.id));
		1298	continue;
744	}	1299	}
745	}	1300	}
746	}	1301	}
747
748	try stack.append(State {
749	.Operand = &node.base
750	});
751	try stack.append(State.AfterOperand);
752	continue;	1302	continue;
753	},	1303	},
754	Token.Id.Keyword_packed => {	1304	Token.Id.Keyword_packed => {
755	try stack.append(State {	1305	try stack.append(State {
756	.ContainerExtern = ContainerExternCtx {	1306	.ContainerExtern = ContainerExternCtx {
		1307	.dest_ptr = dest_ptr,
757	.ltoken = token,	1308	.ltoken = token,
758	.layout = ast.NodeContainerDecl.Layout.Packed,	1309	.layout = ast.NodeContainerDecl.Layout.Packed,
759	},	1310	},
...	@@ -762,109 +1313,35 @@ pub const Parser = struct {	...	@@ -762,109 +1313,35 @@ pub const Parser = struct {
762	Token.Id.Keyword_extern => {	1313	Token.Id.Keyword_extern => {
763	try stack.append(State {	1314	try stack.append(State {
764	.ContainerExtern = ContainerExternCtx {	1315	.ContainerExtern = ContainerExternCtx {
		1316	.dest_ptr = dest_ptr,
765	.ltoken = token,	1317	.ltoken = token,
766	.layout = ast.NodeContainerDecl.Layout.Extern,	1318	.layout = ast.NodeContainerDecl.Layout.Extern,
767	},	1319	},
768	});	1320	});
769	},	1321	},
770	Token.Id.Keyword_struct, Token.Id.Keyword_union, Token.Id.Keyword_enum => {	1322	Token.Id.Keyword_struct, Token.Id.Keyword_union, Token.Id.Keyword_enum => {
771	self.putBackToken(token);	1323	self.putBackToken(token);
772	try stack.append(State {
773	.ContainerExtern = ContainerExternCtx {
774	.ltoken = token,
775	.layout = ast.NodeContainerDecl.Layout.Auto,
776	},
777	});
778	},
779	Token.Id.Builtin => {
780	const node = try arena.create(ast.NodeBuiltinCall);
781	*node = ast.NodeBuiltinCall {
782	.base = self.initNode(ast.Node.Id.BuiltinCall),
783	.builtin_token = token,
784	.params = ArrayList(&ast.Node).init(arena),
785	.rparen_token = undefined,
786	};
787	try stack.append(State {
788	.Operand = &node.base
789	});
790	try stack.append(State.AfterOperand);
791	try stack.append(State {
792	.ExprListItemOrEnd = ListState(&ast.Node) {
793	.list = &node.params,
794	.end = Token.Id.RParen,
795	.ptr = &node.rparen_token,
796	}
797	});
798	try stack.append(State { .ExpectToken = Token.Id.LParen, });
799	continue;
800	},
801	Token.Id.StringLiteral => {
802	const node = try self.createStringLiteral(arena, token);
803	try stack.append(State {
804	.Operand = &node.base
805	});
806	try stack.append(State.AfterOperand);
807	continue;
808	},
809	Token.Id.CharLiteral => {
810	const node = try arena.create(ast.NodeCharLiteral);
811	*node = ast.NodeCharLiteral {
812	.base = self.initNode(ast.Node.Id.CharLiteral),
813	.token = token,
814	};
815	try stack.append(State {
816	.Operand = &node.base
817	});
818	try stack.append(State.AfterOperand);
819	continue;
820	},
821	Token.Id.MultilineStringLiteralLine => {
822	const node = try arena.create(ast.NodeMultilineStringLiteral);
823	*node = ast.NodeMultilineStringLiteral {
824	.base = self.initNode(ast.Node.Id.MultilineStringLiteral),
825	.tokens = ArrayList(Token).init(arena),
826	};
827	try node.tokens.append(token);
828
829	while (true) {
830	const multiline_str = self.getNextToken();
831	if (multiline_str.id != Token.Id.MultilineStringLiteralLine) {
832	self.putBackToken(multiline_str);
833	break;
834	}
835
836	try node.tokens.append(multiline_str);
837	}
838
839	try stack.append(State {
840	.Operand = &node.base
841	});
842	try stack.append(State.AfterOperand);
843	continue;
844	},
845	Token.Id.LParen => {
846	const node = try arena.create(ast.NodeGroupedExpression);
847	*node = ast.NodeGroupedExpression {
848	.base = self.initNode(ast.Node.Id.GroupedExpression),
849	.lparen = token,
850	.expr = undefined,
851	.rparen = undefined,
852	};
853	try stack.append(State {
854	.Operand = &node.base
855	});
856	try stack.append(State.AfterOperand);
857	try stack.append(State {	1324	try stack.append(State {
858	.ExpectTokenSave = ExpectTokenSave {	1325	.ContainerExtern = ContainerExternCtx {
859	.id = Token.Id.RParen,	1326	.dest_ptr = dest_ptr,
860	.ptr = &node.rparen,	1327	.ltoken = token,
861	}	1328	.layout = ast.NodeContainerDecl.Layout.Auto,
		1329	},
862	});	1330	});
863	try stack.append(State { .Expression = DestPtr { .Field = &node.expr } });
864	continue;
865	},	1331	},
866		1332	Token.Id.LBrace => {
867	else => return self.parseError(token, "expected primary expression, found {}", @tagName(token.id)),	1333	@panic("TODO: Block expr");
		1334	},
		1335	Token.Id.Keyword_fn => {
		1336	@panic("TODO: fn proto");
		1337	},
		1338	Token.Id.Keyword_asm => {
		1339	@panic("TODO: inline asm");
		1340	},
		1341	else => {
		1342	try self.parseError(&stack, token, "expected primary expression, found {}", @tagName(token.id));
		1343	continue;
		1344	}
868	}	1345	}
869	},	1346	},
870		1347
...	@@ -880,8 +1357,6 @@ pub const Parser = struct {	...	@@ -880,8 +1357,6 @@ pub const Parser = struct {
880	.end = undefined,	1357	.end = undefined,
881	}	1358	}
882	};	1359	};
883	try stack.append(State { .SuffixOp = node });
884	try stack.append(State.AfterOperand);
885		1360
886	const rbracket_token = self.getNextToken();	1361	const rbracket_token = self.getNextToken();
887	if (rbracket_token.id != Token.Id.RBracket) {	1362	if (rbracket_token.id != Token.Id.RBracket) {
...	@@ -900,161 +1375,12 @@ pub const Parser = struct {	...	@@ -900,161 +1375,12 @@ pub const Parser = struct {
900	},	1375	},
901	Token.Id.RBracket => {	1376	Token.Id.RBracket => {
902	node.rtoken = token;	1377	node.rtoken = token;
903	try stack.append(State { .SuffixOp = node });
904	try stack.append(State.AfterOperand);
905	continue;	1378	continue;
906	},	1379	},
907	else => return self.parseError(token, "expected ']' or '..', found {}", @tagName(token.id))	1380	else => {
908	}	1381	try self.parseError(&stack, token, "expected ']' or '..', found {}", @tagName(token.id));
909	},
910
911	State.AfterOperand => {
912	// we'll either get an infix operator (like != or ^),
913	// or a postfix operator (like () or {}),
914	// otherwise this expression is done (like on a ; or else).
915	var token = self.getNextToken();
916	if (tokenIdToInfixOp(token.id)) \|infix_id\| {
917	try stack.append(State {
918	.InfixOp = try self.createInfixOp(arena, token, infix_id)
919	});
920	try stack.append(State.ExpectOperand);
921	continue;	1382	continue;
922
923	} else if (token.id == Token.Id.LParen) {
924	const node = try self.createSuffixOp(arena, ast.NodeSuffixOp.SuffixOp {
925	.Call = ast.NodeSuffixOp.CallInfo {
926	.params = ArrayList(&ast.Node).init(arena),
927	.is_async = false, // TODO: ASYNC
928	}
929	});
930	try stack.append(State { .SuffixOp = node });
931	try stack.append(State.AfterOperand);
932	try stack.append(State {
933	.ExprListItemOrEnd = ListState(&ast.Node) {
934	.list = &node.op.Call.params,
935	.end = Token.Id.RParen,
936	.ptr = &node.rtoken,
937	}
938	});
939	continue;
940
941	} else if (token.id == Token.Id.LBracket) {
942	const node = try arena.create(ast.NodeSuffixOp);
943	*node = ast.NodeSuffixOp {
944	.base = self.initNode(ast.Node.Id.SuffixOp),
945	.lhs = undefined,
946	.op = ast.NodeSuffixOp.SuffixOp {
947	.ArrayAccess = undefined,
948	},
949	.rtoken = undefined,
950	};
951	try stack.append(State { .SliceOrArrayAccess = node });
952	try stack.append(State { .Expression = DestPtr { .Field = &node.op.ArrayAccess }});
953	continue;
954
955	// TODO: This is the initializer parsing code. It doesn't work because of
956	// the ambiguity between function bodies and initializers:
957	// fn main() void {} or fn main() (void {})
958	} else if (false) { //(token.id == Token.Id.LBrace) {
959	const next = self.getNextToken();
960
961	switch (next.id) {
962	Token.Id.Period => {
963	self.putBackToken(token);
964
965	const node = try self.createSuffixOp(arena, ast.NodeSuffixOp.SuffixOp {
966	.StructInitializer = ArrayList(&ast.NodeFieldInitializer).init(arena),
967	});
968
969	try stack.append(State {
970	.FieldInitListItemOrEnd = ListState(&ast.NodeFieldInitializer) {
971	.list = &node.op.StructInitializer,
972	.end = Token.Id.RBrace,
973	.ptr = &node.rtoken,
974	}
975	});
976	continue;
977	},
978	else => {
979	self.putBackToken(token);
980
981	const node = try self.createSuffixOp(arena, ast.NodeSuffixOp.SuffixOp {
982	.ArrayInitializer = ArrayList(&ast.Node).init(arena),
983	});
984
985	try stack.append(State {
986	.ExprListItemOrEnd = ListState(&ast.Node) {
987	.list = &node.op.ArrayInitializer,
988	.end = Token.Id.RBrace,
989	.ptr = &node.rtoken,
990	}
991	});
992	continue;
993	},
994	}
995
996	// TODO: Parse postfix operator
997	} else {
998	// no postfix/infix operator after this operand.
999	self.putBackToken(token);
1000
1001	var expression = popSuffixOp(&stack);
1002	while (true) {
1003	const s = stack.pop();
1004	if (s == State.Expression) {
1005	const dest_ptr = s.Expression;
1006	// we're done
1007	try dest_ptr.store(expression);
1008	break;
1009	}
1010
1011	var placement_ptr = &expression;
1012	var rhs : &&ast.Node = undefined;
1013	const node = blk: {
1014	switch (s) {
1015	State.InfixOp => \|infix_op\| {
1016	infix_op.lhs = popSuffixOp(&stack);
1017	infix_op.rhs = expression;
1018	rhs = &infix_op.rhs;
1019	break :blk &infix_op.base;
1020	},
1021	State.PrefixOp => \|prefix_op\| {
1022	prefix_op.rhs = expression;
1023	rhs = &prefix_op.rhs;
1024	break :blk &prefix_op.base;
1025	},
1026	else => unreachable,
1027	}
1028	};
1029	const node_perc = precedence(node);
1030
1031	while (true) {
1032	const perc = precedence(*placement_ptr);
1033
1034	if (node_perc > perc) {
1035	*placement_ptr = node;
1036	break;
1037	}
1038
1039	switch ((*placement_ptr).id) {
1040	ast.Node.Id.SuffixOp => {
1041	const suffix_op = @fieldParentPtr(ast.NodeSuffixOp, "base", *placement_ptr);
1042	placement_ptr = &suffix_op.lhs;
1043	*rhs = suffix_op.lhs;
1044	},
1045	ast.Node.Id.InfixOp => {
1046	const infix_op = @fieldParentPtr(ast.NodeInfixOp, "base", *placement_ptr);
1047	placement_ptr = &infix_op.lhs;
1048	*rhs = infix_op.lhs;
1049	},
1050	else => {
1051	*placement_ptr = node;
1052	break;
1053	},
1054	}
1055	}
1056	}	1383	}
1057	continue;
1058	}	1384	}
1059	},	1385	},
1060		1386
...	@@ -1069,7 +1395,7 @@ pub const Parser = struct {	...	@@ -1069,7 +1395,7 @@ pub const Parser = struct {
1069		1395
1070	self.putBackToken(token);	1396	self.putBackToken(token);
1071	stack.append(State { .ExprListCommaOrEnd = list_state }) catch unreachable;	1397	stack.append(State { .ExprListCommaOrEnd = list_state }) catch unreachable;
1072	try stack.append(State { .Expression = DestPtr{.List = list_state.list} });	1398	try stack.append(State { .Expression = DestPtr{ .Field = try list_state.list.addOne() } });
1073	},	1399	},
1074		1400
1075	State.FieldInitListItemOrEnd => \|list_state\| {	1401	State.FieldInitListItemOrEnd => \|list_state\| {
...	@@ -1130,21 +1456,30 @@ pub const Parser = struct {	...	@@ -1130,21 +1456,30 @@ pub const Parser = struct {
1130	switch (token.id) {	1456	switch (token.id) {
1131	Token.Id.Keyword_align => {	1457	Token.Id.Keyword_align => {
1132	stack.append(state) catch unreachable;	1458	stack.append(state) catch unreachable;
1133	if (addr_of_info.align_expr != null) return self.parseError(token, "multiple align qualifiers");	1459	if (addr_of_info.align_expr != null) {
1134	_ = try self.eatToken(Token.Id.LParen);	1460	try self.parseError(&stack, token, "multiple align qualifiers");
		1461	continue;
		1462	}
1135	try stack.append(State { .ExpectToken = Token.Id.RParen });	1463	try stack.append(State { .ExpectToken = Token.Id.RParen });
1136	try stack.append(State { .Expression = DestPtr{.NullableField = &addr_of_info.align_expr} });	1464	try stack.append(State { .Expression = DestPtr{.NullableField = &addr_of_info.align_expr} });
		1465	try stack.append(State { .ExpectToken = Token.Id.LParen });
1137	continue;	1466	continue;
1138	},	1467	},
1139	Token.Id.Keyword_const => {	1468	Token.Id.Keyword_const => {
1140	stack.append(state) catch unreachable;	1469	stack.append(state) catch unreachable;
1141	if (addr_of_info.const_token != null) return self.parseError(token, "duplicate qualifier: const");	1470	if (addr_of_info.const_token != null) {
		1471	try self.parseError(&stack, token, "duplicate qualifier: const");
		1472	continue;
		1473	}
1142	addr_of_info.const_token = token;	1474	addr_of_info.const_token = token;
1143	continue;	1475	continue;
1144	},	1476	},
1145	Token.Id.Keyword_volatile => {	1477	Token.Id.Keyword_volatile => {
1146	stack.append(state) catch unreachable;	1478	stack.append(state) catch unreachable;
1147	if (addr_of_info.volatile_token != null) return self.parseError(token, "duplicate qualifier: volatile");	1479	if (addr_of_info.volatile_token != null) {
		1480	try self.parseError(&stack, token, "duplicate qualifier: volatile");
		1481	continue;
		1482	}
1148	addr_of_info.volatile_token = token;	1483	addr_of_info.volatile_token = token;
1149	continue;	1484	continue;
1150	},	1485	},
...	@@ -1155,17 +1490,6 @@ pub const Parser = struct {	...	@@ -1155,17 +1490,6 @@ pub const Parser = struct {
1155	}	1490	}
1156	},	1491	},
1157		1492
1158	State.TypeExpr => \|dest_ptr\| {
1159	const token = self.getNextToken();
1160	if (token.id == Token.Id.Keyword_var) {
1161	@panic("TODO param with type var");
1162	}
1163	self.putBackToken(token);
1164
1165	stack.append(State { .Expression = dest_ptr }) catch unreachable;
1166	continue;
1167	},
1168
1169	State.FnProto => \|fn_proto\| {	1493	State.FnProto => \|fn_proto\| {
1170	stack.append(State { .FnProtoAlign = fn_proto }) catch unreachable;	1494	stack.append(State { .FnProtoAlign = fn_proto }) catch unreachable;
1171	try stack.append(State { .ParamDecl = fn_proto });	1495	try stack.append(State { .ParamDecl = fn_proto });
...	@@ -1201,14 +1525,14 @@ pub const Parser = struct {	...	@@ -1201,14 +1525,14 @@ pub const Parser = struct {
1201	Token.Id.Bang => {	1525	Token.Id.Bang => {
1202	fn_proto.return_type = ast.NodeFnProto.ReturnType { .InferErrorSet = undefined };	1526	fn_proto.return_type = ast.NodeFnProto.ReturnType { .InferErrorSet = undefined };
1203	stack.append(State {	1527	stack.append(State {
1204	.TypeExpr = DestPtr {.Field = &fn_proto.return_type.InferErrorSet},	1528	.TypeExprBegin = DestPtr {.Field = &fn_proto.return_type.InferErrorSet},
1205	}) catch unreachable;	1529	}) catch unreachable;
1206	},	1530	},
1207	else => {	1531	else => {
1208	self.putBackToken(token);	1532	self.putBackToken(token);
1209	fn_proto.return_type = ast.NodeFnProto.ReturnType { .Explicit = undefined };	1533	fn_proto.return_type = ast.NodeFnProto.ReturnType { .Explicit = undefined };
1210	stack.append(State {	1534	stack.append(State {
1211	.TypeExpr = DestPtr {.Field = &fn_proto.return_type.Explicit},	1535	.TypeExprBegin = DestPtr {.Field = &fn_proto.return_type.Explicit},
1212	}) catch unreachable;	1536	}) catch unreachable;
1213	},	1537	},
1214	}	1538	}
...	@@ -1251,7 +1575,7 @@ pub const Parser = struct {	...	@@ -1251,7 +1575,7 @@ pub const Parser = struct {
1251	stack.append(State { .ParamDecl = fn_proto }) catch unreachable;	1575	stack.append(State { .ParamDecl = fn_proto }) catch unreachable;
1252	try stack.append(State.ParamDeclComma);	1576	try stack.append(State.ParamDeclComma);
1253	try stack.append(State {	1577	try stack.append(State {
1254	.TypeExpr = DestPtr {.Field = &param_decl.type_node}	1578	.TypeExprBegin = DestPtr {.Field = &param_decl.type_node}
1255	});	1579	});
1256	continue;	1580	continue;
1257	},	1581	},
...	@@ -1264,7 +1588,10 @@ pub const Parser = struct {	...	@@ -1264,7 +1588,10 @@ pub const Parser = struct {
1264	continue;	1588	continue;
1265	},	1589	},
1266	Token.Id.Comma => continue,	1590	Token.Id.Comma => continue,
1267	else => return self.parseError(token, "expected ',' or ')', found {}", @tagName(token.id)),	1591	else => {
		1592	try self.parseError(&stack, token, "expected ',' or ')', found {}", @tagName(token.id));
		1593	continue;
		1594	},
1268	}	1595	}
1269	},	1596	},
1270		1597
...	@@ -1278,7 +1605,10 @@ pub const Parser = struct {	...	@@ -1278,7 +1605,10 @@ pub const Parser = struct {
1278	continue;	1605	continue;
1279	},	1606	},
1280	Token.Id.Semicolon => continue,	1607	Token.Id.Semicolon => continue,
1281	else => return self.parseError(token, "expected ';' or '{{', found {}", @tagName(token.id)),	1608	else => {
		1609	try self.parseError(&stack, token, "expected ';' or '{{', found {}", @tagName(token.id));
		1610	continue;
		1611	},
1282	}	1612	}
1283	},	1613	},
1284		1614
...	@@ -1329,112 +1659,13 @@ pub const Parser = struct {	...	@@ -1329,112 +1659,13 @@ pub const Parser = struct {
1329	}	1659	}
1330		1660
1331	stack.append(State { .ExpectToken = Token.Id.Semicolon }) catch unreachable;	1661	stack.append(State { .ExpectToken = Token.Id.Semicolon }) catch unreachable;
1332	try stack.append(State { .Expression = DestPtr{.List = &block.statements} });	1662	try stack.append(State { .Expression = DestPtr{.Field = try block.statements.addOne() } });
1333	continue;	1663	continue;
1334	},	1664	},
1335
1336	// These are data, not control flow.
1337	State.InfixOp => unreachable,
1338	State.PrefixOp => unreachable,
1339	State.SuffixOp => unreachable,
1340	State.Operand => unreachable,
1341	}	1665	}
1342	}	1666	}
1343	}	1667	}
1344		1668
1345	fn precedence(node: &ast.Node) u8 {
1346	switch (node.id) {
1347	ast.Node.Id.PrefixOp => {
1348	const prefix_op = @fieldParentPtr(ast.NodePrefixOp, "base", node);
1349	switch (prefix_op.op) {
1350	ast.NodePrefixOp.PrefixOp.ArrayType,
1351	ast.NodePrefixOp.PrefixOp.SliceType => return 1,
1352
1353	ast.NodePrefixOp.PrefixOp.BoolNot,
1354	ast.NodePrefixOp.PrefixOp.Negation,
1355	ast.NodePrefixOp.PrefixOp.NegationWrap,
1356	ast.NodePrefixOp.PrefixOp.BitNot,
1357	ast.NodePrefixOp.PrefixOp.Deref,
1358	ast.NodePrefixOp.PrefixOp.AddrOf,
1359	ast.NodePrefixOp.PrefixOp.UnwrapMaybe => return 3,
1360
1361	ast.NodePrefixOp.PrefixOp.Try,
1362	ast.NodePrefixOp.PrefixOp.Return => return 255,
1363	}
1364	},
1365	ast.Node.Id.SuffixOp => {
1366	const suffix_op = @fieldParentPtr(ast.NodeSuffixOp, "base", node);
1367	switch (suffix_op.op) {
1368	ast.NodeSuffixOp.SuffixOp.Call,
1369	ast.NodeSuffixOp.SuffixOp.Slice,
1370	ast.NodeSuffixOp.SuffixOp.ArrayAccess => return 2,
1371
1372	ast.NodeSuffixOp.SuffixOp.ArrayInitializer,
1373	ast.NodeSuffixOp.SuffixOp.StructInitializer => return 5,
1374	}
1375	},
1376	ast.Node.Id.InfixOp => {
1377	const infix_op = @fieldParentPtr(ast.NodeInfixOp, "base", node);
1378	switch (infix_op.op) {
1379	ast.NodeInfixOp.InfixOp.Period => return 2,
1380
1381	ast.NodeInfixOp.InfixOp.ErrorUnion => return 4,
1382
1383	ast.NodeInfixOp.InfixOp.Div,
1384	ast.NodeInfixOp.InfixOp.ArrayMult,
1385	ast.NodeInfixOp.InfixOp.Mod,
1386	ast.NodeInfixOp.InfixOp.Mult,
1387	ast.NodeInfixOp.InfixOp.MultWrap => return 6,
1388
1389	ast.NodeInfixOp.InfixOp.Add,
1390	ast.NodeInfixOp.InfixOp.AddWrap,
1391	ast.NodeInfixOp.InfixOp.ArrayCat,
1392	ast.NodeInfixOp.InfixOp.Sub,
1393	ast.NodeInfixOp.InfixOp.SubWrap => return 7,
1394
1395	ast.NodeInfixOp.InfixOp.BitShiftLeft,
1396	ast.NodeInfixOp.InfixOp.BitShiftRight => return 8,
1397
1398	ast.NodeInfixOp.InfixOp.BitAnd => return 9,
1399
1400	ast.NodeInfixOp.InfixOp.BitXor => return 10,
1401
1402	ast.NodeInfixOp.InfixOp.BitOr => return 11,
1403
1404	ast.NodeInfixOp.InfixOp.EqualEqual,
1405	ast.NodeInfixOp.InfixOp.BangEqual,
1406	ast.NodeInfixOp.InfixOp.GreaterOrEqual,
1407	ast.NodeInfixOp.InfixOp.GreaterThan,
1408	ast.NodeInfixOp.InfixOp.LessOrEqual,
1409	ast.NodeInfixOp.InfixOp.LessThan => return 12,
1410
1411	ast.NodeInfixOp.InfixOp.BoolAnd => return 13,
1412
1413	ast.NodeInfixOp.InfixOp.BoolOr => return 14,
1414
1415	ast.NodeInfixOp.InfixOp.UnwrapMaybe => return 15,
1416
1417	ast.NodeInfixOp.InfixOp.Assign,
1418	ast.NodeInfixOp.InfixOp.AssignBitAnd,
1419	ast.NodeInfixOp.InfixOp.AssignBitOr,
1420	ast.NodeInfixOp.InfixOp.AssignBitShiftLeft,
1421	ast.NodeInfixOp.InfixOp.AssignBitShiftRight,
1422	ast.NodeInfixOp.InfixOp.AssignBitXor,
1423	ast.NodeInfixOp.InfixOp.AssignDiv,
1424	ast.NodeInfixOp.InfixOp.AssignMinus,
1425	ast.NodeInfixOp.InfixOp.AssignMinusWrap,
1426	ast.NodeInfixOp.InfixOp.AssignMod,
1427	ast.NodeInfixOp.InfixOp.AssignPlus,
1428	ast.NodeInfixOp.InfixOp.AssignPlusWrap,
1429	ast.NodeInfixOp.InfixOp.AssignTimes,
1430	ast.NodeInfixOp.InfixOp.AssignTimesWarp,
1431	ast.NodeInfixOp.InfixOp.MergeErrorSets => return 16,
1432	}
1433	},
1434	else => return 0,
1435	}
1436	}
1437
1438	fn commaOrEnd(self: &Parser, stack: &ArrayList(State), end: &const Token.Id, ptr: &Token, state_after_comma: &const State) !void {	1669	fn commaOrEnd(self: &Parser, stack: &ArrayList(State), end: &const Token.Id, ptr: &Token, state_after_comma: &const State) !void {
1439	var token = self.getNextToken();	1670	var token = self.getNextToken();
1440	switch (token.id) {	1671	switch (token.id) {
...	@@ -1448,74 +1679,104 @@ pub const Parser = struct {	...	@@ -1448,74 +1679,104 @@ pub const Parser = struct {
1448	return;	1679	return;
1449	}	1680	}
1450		1681
1451	return self.parseError(token, "expected ',' or {}, found {}", @tagName(*end), @tagName(token.id));	1682	try self.parseError(stack, token, "expected ',' or {}, found {}", @tagName(*end), @tagName(token.id));
1452	},	1683	},
1453	}	1684	}
1454	}	1685	}
1455		1686
1456	fn popSuffixOp(stack: &ArrayList(State)) &ast.Node {	1687	fn tokenIdToAssignment(id: &const Token.Id) ?ast.NodeInfixOp.InfixOp {
1457	var expression: &ast.Node = undefined;	1688	// TODO: We have to cast all cases because of this:
1458	var left_leaf_ptr: &&ast.Node = &expression;	1689	// error: expected type '?InfixOp', found '?@TagType(InfixOp)'
1459	while (true) {	1690	return switch (*id) {
1460	switch (stack.pop()) {	1691	Token.Id.AmpersandEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignBitAnd),
1461	State.SuffixOp => \|suffix_op\| {	1692	Token.Id.AngleBracketAngleBracketLeftEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignBitShiftLeft),
1462	*left_leaf_ptr = &suffix_op.base;	1693	Token.Id.AngleBracketAngleBracketRightEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignBitShiftRight),
1463	left_leaf_ptr = &suffix_op.lhs;	1694	Token.Id.AsteriskEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignTimes),
1464	},	1695	Token.Id.AsteriskPercentEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignTimesWarp),
1465	State.Operand => \|operand\| {	1696	Token.Id.CaretEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignBitXor),
1466	*left_leaf_ptr = operand;	1697	Token.Id.Equal => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.Assign),
1467	break;	1698	Token.Id.MinusEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignMinus),
1468	},	1699	Token.Id.MinusPercentEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignMinusWrap),
1469	else => unreachable,	1700	Token.Id.PercentEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignMod),
1470	}	1701	Token.Id.PipeEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignBitOr),
1471	}	1702	Token.Id.PlusEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignPlus),
		1703	Token.Id.PlusPercentEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignPlusWrap),
		1704	Token.Id.SlashEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AssignDiv),
		1705	else => null,
		1706	};
		1707	}
		1708
		1709	fn tokenIdToComparison(id: &const Token.Id) ?ast.NodeInfixOp.InfixOp {
		1710	// TODO: We have to cast all cases because of this:
		1711	// error: expected type '?InfixOp', found '?@TagType(InfixOp)'
		1712	return switch (*id) {
		1713	Token.Id.BangEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.BangEqual),
		1714	Token.Id.EqualEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.EqualEqual),
		1715	Token.Id.AngleBracketLeft => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.LessThan),
		1716	Token.Id.AngleBracketLeftEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.LessOrEqual),
		1717	Token.Id.AngleBracketRight => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.GreaterThan),
		1718	Token.Id.AngleBracketRightEqual => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.GreaterOrEqual),
		1719	else => null,
		1720	};
		1721	}
		1722
		1723	fn tokenIdToBitShift(id: &const Token.Id) ?ast.NodeInfixOp.InfixOp {
		1724	// TODO: We have to cast all cases because of this:
		1725	// error: expected type '?InfixOp', found '?@TagType(InfixOp)'
		1726	return switch (*id) {
		1727	Token.Id.AngleBracketAngleBracketLeft => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.BitShiftLeft),
		1728	Token.Id.AngleBracketAngleBracketRight => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.BitShiftRight),
		1729	else => null,
		1730	};
		1731	}
1472		1732
1473	return expression;	1733	fn tokenIdToAddition(id: &const Token.Id) ?ast.NodeInfixOp.InfixOp {
		1734	// TODO: We have to cast all cases because of this:
		1735	// error: expected type '?InfixOp', found '?@TagType(InfixOp)'
		1736	return switch (*id) {
		1737	Token.Id.Minus => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.Sub),
		1738	Token.Id.MinusPercent => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.SubWrap),
		1739	Token.Id.Plus => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.Add),
		1740	Token.Id.PlusPercent => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.AddWrap),
		1741	Token.Id.PlusPlus => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.ArrayCat),
		1742	else => null,
		1743	};
		1744	}
		1745
		1746	fn tokenIdToMultiply(id: &const Token.Id) ?ast.NodeInfixOp.InfixOp {
		1747	// TODO: We have to cast all cases because of this:
		1748	// error: expected type '?InfixOp', found '?@TagType(InfixOp)'
		1749	return switch (*id) {
		1750	Token.Id.Slash => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.Div),
		1751	Token.Id.Asterisk => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.Mult),
		1752	Token.Id.AsteriskAsterisk => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.ArrayMult),
		1753	Token.Id.AsteriskPercent => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.MultWrap),
		1754	Token.Id.Percent => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.Mod),
		1755	Token.Id.PipePipe => (ast.NodeInfixOp.InfixOp)(ast.NodeInfixOp.InfixOp.MergeErrorSets),
		1756	else => null,
		1757	};
1474	}	1758	}
1475		1759
1476	fn tokenIdToInfixOp(id: &const Token.Id) ?ast.NodeInfixOp.InfixOp {	1760	fn tokenIdToPrefixOp(id: &const Token.Id) ?ast.NodePrefixOp.PrefixOp {
		1761	// TODO: We have to cast all cases because of this:
		1762	// error: expected type '?InfixOp', found '?@TagType(InfixOp)'
1477	return switch (*id) {	1763	return switch (*id) {
1478	Token.Id.Ampersand => ast.NodeInfixOp.InfixOp.BitAnd,	1764	Token.Id.Bang => (ast.NodePrefixOp.PrefixOp)(ast.NodePrefixOp.PrefixOp.BoolNot),
1479	Token.Id.AmpersandEqual => ast.NodeInfixOp.InfixOp.AssignBitAnd,	1765	Token.Id.Tilde => (ast.NodePrefixOp.PrefixOp)(ast.NodePrefixOp.PrefixOp.BitNot),
1480	Token.Id.AngleBracketAngleBracketLeft => ast.NodeInfixOp.InfixOp.BitShiftLeft,	1766	Token.Id.Minus => (ast.NodePrefixOp.PrefixOp)(ast.NodePrefixOp.PrefixOp.Negation),
1481	Token.Id.AngleBracketAngleBracketLeftEqual => ast.NodeInfixOp.InfixOp.AssignBitShiftLeft,	1767	Token.Id.MinusPercent => (ast.NodePrefixOp.PrefixOp)(ast.NodePrefixOp.PrefixOp.NegationWrap),
1482	Token.Id.AngleBracketAngleBracketRight => ast.NodeInfixOp.InfixOp.BitShiftRight,	1768	Token.Id.Asterisk => (ast.NodePrefixOp.PrefixOp)(ast.NodePrefixOp.PrefixOp.Deref),
1483	Token.Id.AngleBracketAngleBracketRightEqual => ast.NodeInfixOp.InfixOp.AssignBitShiftRight,	1769	Token.Id.Ampersand => ast.NodePrefixOp.PrefixOp {
1484	Token.Id.AngleBracketLeft => ast.NodeInfixOp.InfixOp.LessThan,	1770	.AddrOf = ast.NodePrefixOp.AddrOfInfo {
1485	Token.Id.AngleBracketLeftEqual => ast.NodeInfixOp.InfixOp.LessOrEqual,	1771	.align_expr = null,
1486	Token.Id.AngleBracketRight => ast.NodeInfixOp.InfixOp.GreaterThan,	1772	.bit_offset_start_token = null,
1487	Token.Id.AngleBracketRightEqual => ast.NodeInfixOp.InfixOp.GreaterOrEqual,	1773	.bit_offset_end_token = null,
1488	Token.Id.Asterisk => ast.NodeInfixOp.InfixOp.Mult,	1774	.const_token = null,
1489	Token.Id.AsteriskAsterisk => ast.NodeInfixOp.InfixOp.ArrayMult,	1775	.volatile_token = null,
1490	Token.Id.AsteriskEqual => ast.NodeInfixOp.InfixOp.AssignTimes,	1776	},
1491	Token.Id.AsteriskPercent => ast.NodeInfixOp.InfixOp.MultWrap,	1777	},
1492	Token.Id.AsteriskPercentEqual => ast.NodeInfixOp.InfixOp.AssignTimesWarp,	1778	Token.Id.QuestionMark => (ast.NodePrefixOp.PrefixOp)(ast.NodePrefixOp.PrefixOp.MaybeType),
1493	Token.Id.Bang => ast.NodeInfixOp.InfixOp.ErrorUnion,	1779	Token.Id.QuestionMarkQuestionMark => (ast.NodePrefixOp.PrefixOp)(ast.NodePrefixOp.PrefixOp.UnwrapMaybe),
1494	Token.Id.BangEqual => ast.NodeInfixOp.InfixOp.BangEqual,
1495	Token.Id.Caret => ast.NodeInfixOp.InfixOp.BitXor,
1496	Token.Id.CaretEqual => ast.NodeInfixOp.InfixOp.AssignBitXor,
1497	Token.Id.Equal => ast.NodeInfixOp.InfixOp.Assign,
1498	Token.Id.EqualEqual => ast.NodeInfixOp.InfixOp.EqualEqual,
1499	Token.Id.Keyword_and => ast.NodeInfixOp.InfixOp.BoolAnd,
1500	Token.Id.Keyword_or => ast.NodeInfixOp.InfixOp.BoolOr,
1501	Token.Id.Minus => ast.NodeInfixOp.InfixOp.Sub,
1502	Token.Id.MinusEqual => ast.NodeInfixOp.InfixOp.AssignMinus,
1503	Token.Id.MinusPercent => ast.NodeInfixOp.InfixOp.SubWrap,
1504	Token.Id.MinusPercentEqual => ast.NodeInfixOp.InfixOp.AssignMinusWrap,
1505	Token.Id.Percent => ast.NodeInfixOp.InfixOp.Mod,
1506	Token.Id.PercentEqual => ast.NodeInfixOp.InfixOp.AssignMod,
1507	Token.Id.Period => ast.NodeInfixOp.InfixOp.Period,
1508	Token.Id.Pipe => ast.NodeInfixOp.InfixOp.BitOr,
1509	Token.Id.PipeEqual => ast.NodeInfixOp.InfixOp.AssignBitOr,
1510	Token.Id.PipePipe => ast.NodeInfixOp.InfixOp.MergeErrorSets,
1511	Token.Id.Plus => ast.NodeInfixOp.InfixOp.Add,
1512	Token.Id.PlusEqual => ast.NodeInfixOp.InfixOp.AssignPlus,
1513	Token.Id.PlusPercent => ast.NodeInfixOp.InfixOp.AddWrap,
1514	Token.Id.PlusPercentEqual => ast.NodeInfixOp.InfixOp.AssignPlusWrap,
1515	Token.Id.PlusPlus => ast.NodeInfixOp.InfixOp.ArrayCat,
1516	Token.Id.QuestionMarkQuestionMark => ast.NodeInfixOp.InfixOp.UnwrapMaybe,
1517	Token.Id.Slash => ast.NodeInfixOp.InfixOp.Div,
1518	Token.Id.SlashEqual => ast.NodeInfixOp.InfixOp.AssignDiv,
1519	else => null,	1780	else => null,
1520	};	1781	};
1521	}	1782	}
...	@@ -1637,6 +1898,19 @@ pub const Parser = struct {	...	@@ -1637,6 +1898,19 @@ pub const Parser = struct {
1637	return node;	1898	return node;
1638	}	1899	}
1639		1900
		1901	fn createControlFlowExpr(self: &Parser, arena: &mem.Allocator, ltoken: &const Token,
		1902	kind: &const ast.NodeControlFlowExpression.Kind) !&ast.NodeControlFlowExpression
		1903	{
		1904	const node = try arena.create(ast.NodeControlFlowExpression);
		1905	*node = ast.NodeControlFlowExpression {
		1906	.base = self.initNode(ast.Node.Id.ControlFlowExpression),
		1907	.ltoken = *ltoken,
		1908	.kind = *kind,
		1909	.rhs = undefined,
		1910	};
		1911	return node;
		1912	}
		1913
1640	fn createInfixOp(self: &Parser, arena: &mem.Allocator, op_token: &const Token, op: &const ast.NodeInfixOp.InfixOp) !&ast.NodeInfixOp {	1914	fn createInfixOp(self: &Parser, arena: &mem.Allocator, op_token: &const Token, op: &const ast.NodeInfixOp.InfixOp) !&ast.NodeInfixOp {
1641	const node = try arena.create(ast.NodeInfixOp);	1915	const node = try arena.create(ast.NodeInfixOp);
1642		1916
...	@@ -1752,37 +2026,54 @@ pub const Parser = struct {	...	@@ -1752,37 +2026,54 @@ pub const Parser = struct {
1752	return node;	2026	return node;
1753	}	2027	}
1754		2028
1755	fn parseError(self: &Parser, token: &const Token, comptime fmt: []const u8, args: ...) (error{ParseError}) {	2029	fn parseError(self: &Parser, stack: &ArrayList(State), token: &const Token, comptime fmt: []const u8, args: ...) !void {
1756	const loc = self.tokenizer.getTokenLocation(0, token);	2030	// Before reporting an error. We pop the stack to see if our state was optional
1757	warn("{}:{}:{}: error: " ++ fmt ++ "\n", self.source_file_name, loc.line + 1, loc.column + 1, args);	2031	self.revertIfOptional(stack) catch {
1758	warn("{}\n", self.tokenizer.buffer[loc.line_start..loc.line_end]);	2032	const loc = self.tokenizer.getTokenLocation(0, token);
1759	{	2033	warn("{}:{}:{}: error: " ++ fmt ++ "\n", self.source_file_name, loc.line + 1, loc.column + 1, args);
1760	var i: usize = 0;	2034	warn("{}\n", self.tokenizer.buffer[loc.line_start..loc.line_end]);
1761	while (i < loc.column) : (i += 1) {	2035	{
1762	warn(" ");	2036	var i: usize = 0;
		2037	while (i < loc.column) : (i += 1) {
		2038	warn(" ");
		2039	}
1763	}	2040	}
1764	}	2041	{
1765	{	2042	const caret_count = token.end - token.start;
1766	const caret_count = token.end - token.start;	2043	var i: usize = 0;
1767	var i: usize = 0;	2044	while (i < caret_count) : (i += 1) {
1768	while (i < caret_count) : (i += 1) {	2045	warn("~");
1769	warn("~");	2046	}
1770	}	2047	}
1771	}	2048	warn("\n");
1772	warn("\n");	2049	return error.ParseError;
1773	return error.ParseError;	2050	};
1774	}	2051	}
1775		2052
1776	fn expectToken(self: &Parser, token: &const Token, id: @TagType(Token.Id)) !void {	2053	fn eatToken(self: &Parser, stack: &ArrayList(State), id: @TagType(Token.Id)) !?Token {
		2054	const token = self.getNextToken();
1777	if (token.id != id) {	2055	if (token.id != id) {
1778	return self.parseError(token, "expected {}, found {}", @tagName(id), @tagName(token.id));	2056	try self.parseError(stack, token, "expected {}, found {}", @tagName(id), @tagName(token.id));
		2057	return null;
1779	}	2058	}
		2059	return token;
1780	}	2060	}
1781		2061
1782	fn eatToken(self: &Parser, id: @TagType(Token.Id)) !Token {	2062	fn revertIfOptional(self: &Parser, stack: &ArrayList(State)) !void {
1783	const token = self.getNextToken();	2063	while (stack.popOrNull()) \|state\| {
1784	try self.expectToken(token, id);	2064	switch (state) {
1785	return token;	2065	State.Optional => \|revert\| {
		2066	*self = state.Optional;
		2067	return;
		2068	},
		2069	State.Required => {
		2070	return error.StateRequired;
		2071	},
		2072	else => { }
		2073	}
		2074	}
		2075
		2076	return error.NoOptionalStateFound;
1786	}	2077	}
1787		2078
1788	fn putBackToken(self: &Parser, token: &const Token) void {	2079	fn putBackToken(self: &Parser, token: &const Token) void {
...	@@ -2054,51 +2345,62 @@ pub const Parser = struct {	...	@@ -2054,51 +2345,62 @@ pub const Parser = struct {
2054	ast.Node.Id.InfixOp => {	2345	ast.Node.Id.InfixOp => {
2055	const prefix_op_node = @fieldParentPtr(ast.NodeInfixOp, "base", base);	2346	const prefix_op_node = @fieldParentPtr(ast.NodeInfixOp, "base", base);
2056	try stack.append(RenderState { .Expression = prefix_op_node.rhs });	2347	try stack.append(RenderState { .Expression = prefix_op_node.rhs });
2057	const text = switch (prefix_op_node.op) {
2058	ast.NodeInfixOp.InfixOp.Add => " + ",
2059	ast.NodeInfixOp.InfixOp.AddWrap => " +% ",
2060	ast.NodeInfixOp.InfixOp.ArrayCat => " ++ ",
2061	ast.NodeInfixOp.InfixOp.ArrayMult => " ** ",
2062	ast.NodeInfixOp.InfixOp.Assign => " = ",
2063	ast.NodeInfixOp.InfixOp.AssignBitAnd => " &= ",
2064	ast.NodeInfixOp.InfixOp.AssignBitOr => " \|= ",
2065	ast.NodeInfixOp.InfixOp.AssignBitShiftLeft => " <<= ",
2066	ast.NodeInfixOp.InfixOp.AssignBitShiftRight => " >>= ",
2067	ast.NodeInfixOp.InfixOp.AssignBitXor => " ^= ",
2068	ast.NodeInfixOp.InfixOp.AssignDiv => " /= ",
2069	ast.NodeInfixOp.InfixOp.AssignMinus => " -= ",
2070	ast.NodeInfixOp.InfixOp.AssignMinusWrap => " -%= ",
2071	ast.NodeInfixOp.InfixOp.AssignMod => " %= ",
2072	ast.NodeInfixOp.InfixOp.AssignPlus => " += ",
2073	ast.NodeInfixOp.InfixOp.AssignPlusWrap => " +%= ",
2074	ast.NodeInfixOp.InfixOp.AssignTimes => " *= ",
2075	ast.NodeInfixOp.InfixOp.AssignTimesWarp => " *%= ",
2076	ast.NodeInfixOp.InfixOp.BangEqual => " != ",
2077	ast.NodeInfixOp.InfixOp.BitAnd => " & ",
2078	ast.NodeInfixOp.InfixOp.BitOr => " \| ",
2079	ast.NodeInfixOp.InfixOp.BitShiftLeft => " << ",
2080	ast.NodeInfixOp.InfixOp.BitShiftRight => " >> ",
2081	ast.NodeInfixOp.InfixOp.BitXor => " ^ ",
2082	ast.NodeInfixOp.InfixOp.BoolAnd => " and ",
2083	ast.NodeInfixOp.InfixOp.BoolOr => " or ",
2084	ast.NodeInfixOp.InfixOp.Div => " / ",
2085	ast.NodeInfixOp.InfixOp.EqualEqual => " == ",
2086	ast.NodeInfixOp.InfixOp.ErrorUnion => "!",
2087	ast.NodeInfixOp.InfixOp.GreaterOrEqual => " >= ",
2088	ast.NodeInfixOp.InfixOp.GreaterThan => " > ",
2089	ast.NodeInfixOp.InfixOp.LessOrEqual => " <= ",
2090	ast.NodeInfixOp.InfixOp.LessThan => " < ",
2091	ast.NodeInfixOp.InfixOp.MergeErrorSets => " \|\| ",
2092	ast.NodeInfixOp.InfixOp.Mod => " % ",
2093	ast.NodeInfixOp.InfixOp.Mult => " * ",
2094	ast.NodeInfixOp.InfixOp.MultWrap => " *% ",
2095	ast.NodeInfixOp.InfixOp.Period => ".",
2096	ast.NodeInfixOp.InfixOp.Sub => " - ",
2097	ast.NodeInfixOp.InfixOp.SubWrap => " -% ",
2098	ast.NodeInfixOp.InfixOp.UnwrapMaybe => " ?? ",
2099	};
2100		2348
2101	try stack.append(RenderState { .Text = text });	2349	if (prefix_op_node.op == ast.NodeInfixOp.InfixOp.Catch) {
		2350	if (prefix_op_node.op.Catch) \|payload\| {
		2351	try stack.append(RenderState { .Text = "\|" });
		2352	try stack.append(RenderState { .Expression = &payload.base });
		2353	try stack.append(RenderState { .Text = "\|" });
		2354	}
		2355	try stack.append(RenderState { .Text = " catch " });
		2356	} else {
		2357	const text = switch (prefix_op_node.op) {
		2358	ast.NodeInfixOp.InfixOp.Add => " + ",
		2359	ast.NodeInfixOp.InfixOp.AddWrap => " +% ",
		2360	ast.NodeInfixOp.InfixOp.ArrayCat => " ++ ",
		2361	ast.NodeInfixOp.InfixOp.ArrayMult => " ** ",
		2362	ast.NodeInfixOp.InfixOp.Assign => " = ",
		2363	ast.NodeInfixOp.InfixOp.AssignBitAnd => " &= ",
		2364	ast.NodeInfixOp.InfixOp.AssignBitOr => " \|= ",
		2365	ast.NodeInfixOp.InfixOp.AssignBitShiftLeft => " <<= ",
		2366	ast.NodeInfixOp.InfixOp.AssignBitShiftRight => " >>= ",
		2367	ast.NodeInfixOp.InfixOp.AssignBitXor => " ^= ",
		2368	ast.NodeInfixOp.InfixOp.AssignDiv => " /= ",
		2369	ast.NodeInfixOp.InfixOp.AssignMinus => " -= ",
		2370	ast.NodeInfixOp.InfixOp.AssignMinusWrap => " -%= ",
		2371	ast.NodeInfixOp.InfixOp.AssignMod => " %= ",
		2372	ast.NodeInfixOp.InfixOp.AssignPlus => " += ",
		2373	ast.NodeInfixOp.InfixOp.AssignPlusWrap => " +%= ",
		2374	ast.NodeInfixOp.InfixOp.AssignTimes => " *= ",
		2375	ast.NodeInfixOp.InfixOp.AssignTimesWarp => " *%= ",
		2376	ast.NodeInfixOp.InfixOp.BangEqual => " != ",
		2377	ast.NodeInfixOp.InfixOp.BitAnd => " & ",
		2378	ast.NodeInfixOp.InfixOp.BitOr => " \| ",
		2379	ast.NodeInfixOp.InfixOp.BitShiftLeft => " << ",
		2380	ast.NodeInfixOp.InfixOp.BitShiftRight => " >> ",
		2381	ast.NodeInfixOp.InfixOp.BitXor => " ^ ",
		2382	ast.NodeInfixOp.InfixOp.BoolAnd => " and ",
		2383	ast.NodeInfixOp.InfixOp.BoolOr => " or ",
		2384	ast.NodeInfixOp.InfixOp.Div => " / ",
		2385	ast.NodeInfixOp.InfixOp.EqualEqual => " == ",
		2386	ast.NodeInfixOp.InfixOp.ErrorUnion => "!",
		2387	ast.NodeInfixOp.InfixOp.GreaterOrEqual => " >= ",
		2388	ast.NodeInfixOp.InfixOp.GreaterThan => " > ",
		2389	ast.NodeInfixOp.InfixOp.LessOrEqual => " <= ",
		2390	ast.NodeInfixOp.InfixOp.LessThan => " < ",
		2391	ast.NodeInfixOp.InfixOp.MergeErrorSets => " \|\| ",
		2392	ast.NodeInfixOp.InfixOp.Mod => " % ",
		2393	ast.NodeInfixOp.InfixOp.Mult => " * ",
		2394	ast.NodeInfixOp.InfixOp.MultWrap => " *% ",
		2395	ast.NodeInfixOp.InfixOp.Period => ".",
		2396	ast.NodeInfixOp.InfixOp.Sub => " - ",
		2397	ast.NodeInfixOp.InfixOp.SubWrap => " -% ",
		2398	ast.NodeInfixOp.InfixOp.UnwrapMaybe => " ?? ",
		2399	else => unreachable,
		2400	};
		2401
		2402	try stack.append(RenderState { .Text = text });
		2403	}
2102	try stack.append(RenderState { .Expression = prefix_op_node.lhs });	2404	try stack.append(RenderState { .Expression = prefix_op_node.lhs });
2103	},	2405	},
2104	ast.Node.Id.PrefixOp => {	2406	ast.Node.Id.PrefixOp => {
...	@@ -2143,9 +2445,9 @@ pub const Parser = struct {	...	@@ -2143,9 +2445,9 @@ pub const Parser = struct {
2143	ast.NodePrefixOp.PrefixOp.Deref => try stream.write("*"),	2445	ast.NodePrefixOp.PrefixOp.Deref => try stream.write("*"),
2144	ast.NodePrefixOp.PrefixOp.Negation => try stream.write("-"),	2446	ast.NodePrefixOp.PrefixOp.Negation => try stream.write("-"),
2145	ast.NodePrefixOp.PrefixOp.NegationWrap => try stream.write("-%"),	2447	ast.NodePrefixOp.PrefixOp.NegationWrap => try stream.write("-%"),
2146	ast.NodePrefixOp.PrefixOp.Return => try stream.write("return "),
2147	ast.NodePrefixOp.PrefixOp.Try => try stream.write("try "),	2448	ast.NodePrefixOp.PrefixOp.Try => try stream.write("try "),
2148	ast.NodePrefixOp.PrefixOp.UnwrapMaybe => try stream.write("??"),	2449	ast.NodePrefixOp.PrefixOp.UnwrapMaybe => try stream.write("??"),
		2450	ast.NodePrefixOp.PrefixOp.MaybeType => try stream.write("?"),
2149	}	2451	}
2150	},	2452	},
2151	ast.Node.Id.SuffixOp => {	2453	ast.Node.Id.SuffixOp => {
...	@@ -2185,6 +2487,32 @@ pub const Parser = struct {	...	@@ -2185,6 +2487,32 @@ pub const Parser = struct {
2185		2487
2186	try stack.append(RenderState { .Expression = suffix_op.lhs });	2488	try stack.append(RenderState { .Expression = suffix_op.lhs });
2187	},	2489	},
		2490	ast.Node.Id.ControlFlowExpression => {
		2491	const flow_expr = @fieldParentPtr(ast.NodeControlFlowExpression, "base", base);
		2492	switch (flow_expr.kind) {
		2493	ast.NodeControlFlowExpression.Kind.Break => \|maybe_blk_token\| {
		2494	try stream.print("break");
		2495	if (maybe_blk_token) \|blk_token\| {
		2496	try stream.print(" :{}", self.tokenizer.getTokenSlice(blk_token));
		2497	}
		2498	},
		2499	ast.NodeControlFlowExpression.Kind.Continue => \|maybe_blk_token\| {
		2500	try stream.print("continue");
		2501	if (maybe_blk_token) \|blk_token\| {
		2502	try stream.print(" :{}", self.tokenizer.getTokenSlice(blk_token));
		2503	}
		2504	},
		2505	ast.NodeControlFlowExpression.Kind.Return => {
		2506	try stream.print("return");
		2507	},
		2508
		2509	}
		2510
		2511	if (flow_expr.rhs) \|rhs\| {
		2512	try stream.print(" ");
		2513	try stack.append(RenderState { .Expression = rhs });
		2514	}
		2515	},
2188	ast.Node.Id.GroupedExpression => {	2516	ast.Node.Id.GroupedExpression => {
2189	const grouped_expr = @fieldParentPtr(ast.NodeGroupedExpression, "base", base);	2517	const grouped_expr = @fieldParentPtr(ast.NodeGroupedExpression, "base", base);
2190	try stack.append(RenderState { .Text = ")"});	2518	try stack.append(RenderState { .Text = ")"});
...	@@ -2770,7 +3098,6 @@ test "zig fmt: values" {	...	@@ -2770,7 +3098,6 @@ test "zig fmt: values" {
2770	\\ error;	3098	\\ error;
2771	\\ this;	3099	\\ this;
2772	\\ unreachable;	3100	\\ unreachable;
2773	\\ suspend;
2774	\\}	3101	\\}
2775	\\	3102	\\
2776	);	3103	);
...	@@ -2906,6 +3233,38 @@ test "zig fmt: error set declaration" {	...	@@ -2906,6 +3233,38 @@ test "zig fmt: error set declaration" {
2906	);	3233	);
2907	}	3234	}
2908		3235
		3236	test "zig fmt: catch" {
		3237	try testCanonical(
		3238	\\test "catch" {
		3239	\\ const a: error!u8 = 0;
		3240	\\ _ = a catch return;
		3241	\\ _ = a catch \|err\| return;
		3242	\\}
		3243	\\
		3244	);
		3245	}
		3246
		3247	test "zig fmt: arrays" {
		3248	try testCanonical(
		3249	\\test "test array" {
		3250	\\ const a: [2]u8 = [2]u8{ 1, 2 };
		3251	\\ const a: [2]u8 = []u8{ 1, 2 };
		3252	\\ const a: [0]u8 = []u8{};
		3253	\\}
		3254	\\
		3255	);
		3256	}
		3257
		3258	test "zig fmt: container initializers" {
		3259	try testCanonical(
		3260	\\const a1 = []u8{ };
		3261	\\const a2 = []u8{ 1, 2, 3, 4 };
		3262	\\const s1 = S{ };
		3263	\\const s2 = S{ .a = 1, .b = 2, };
		3264	\\
		3265	);
		3266	}
		3267
2909	test "zig fmt: switch" {	3268	test "zig fmt: switch" {
2910	try testCanonical(	3269	try testCanonical(
2911	\\test "switch" {	3270	\\test "switch" {
...	@@ -3106,17 +3465,6 @@ test "zig fmt: defer" {	...	@@ -3106,17 +3465,6 @@ test "zig fmt: defer" {
3106	);	3465	);
3107	}	3466	}
3108		3467
3109	test "zig fmt: catch" {
3110	try testCanonical(
3111	\\test "catch" {
3112	\\ const a: error!u8 = 0;
3113	\\ _ = a catch return;
3114	\\ _ = a catch \|err\| return;
3115	\\}
3116	\\
3117	);
3118	}
3119
3120	test "zig fmt: comptime" {	3468	test "zig fmt: comptime" {
3121	try testCanonical(	3469	try testCanonical(
3122	\\fn a() u8 {	3470	\\fn a() u8 {
...	@@ -3201,27 +3549,6 @@ test "zig fmt: coroutines" {	...	@@ -3201,27 +3549,6 @@ test "zig fmt: coroutines" {
3201	);	3549	);
3202	}	3550	}
3203		3551
3204	test "zig fmt: arrays" {
3205	try testCanonical(
3206	\\test "test array" {
3207	\\ const a: [2]u8 = [2]u8{ 1, 2 };
3208	\\ const a: [2]u8 = []u8{ 1, 2 };
3209	\\ const a: [0]u8 = []u8{};
3210	\\}
3211	\\
3212	);
3213	}
3214
3215	test "zig fmt: container initializers" {
3216	try testCanonical(
3217	\\const a1 = []u8{ };
3218	\\const a2 = []u8{ 1, 2, 3, 4 };
3219	\\const s1 = S{ };
3220	\\const s2 = S{ .a = 1, .b = 2, };
3221	\\
3222	);
3223	}
3224
3225	test "zig fmt: zig fmt" {	3552	test "zig fmt: zig fmt" {
3226	try testCanonical(@embedFile("ast.zig"));	3553	try testCanonical(@embedFile("ast.zig"));
3227	try testCanonical(@embedFile("index.zig"));	3554	try testCanonical(@embedFile("index.zig"));

std/zig/tokenizer.zig+10

 @@ -15,8 +15,11 @@ pub const Token = struct {
         KeywordId{.bytes="align", .id = Id.Keyword_align},
         KeywordId{.bytes="and", .id = Id.Keyword_and},
         KeywordId{.bytes="asm", .id = Id.Keyword_asm},
+        KeywordId{.bytes="async", .id = Id.Keyword_async},
+        KeywordId{.bytes="await", .id = Id.Keyword_await},
         KeywordId{.bytes="break", .id = Id.Keyword_break},
         KeywordId{.bytes="catch", .id = Id.Keyword_catch},
+        KeywordId{.bytes="cancel", .id = Id.Keyword_cancel},
         KeywordId{.bytes="comptime", .id = Id.Keyword_comptime},
         KeywordId{.bytes="const", .id = Id.Keyword_const},
         KeywordId{.bytes="continue", .id = Id.Keyword_continue},
 @@ -37,10 +40,12 @@ pub const Token = struct {
         KeywordId{.bytes="or", .id = Id.Keyword_or},
         KeywordId{.bytes="packed", .id = Id.Keyword_packed},
         KeywordId{.bytes="pub", .id = Id.Keyword_pub},
+        KeywordId{.bytes="resume", .id = Id.Keyword_resume},
         KeywordId{.bytes="return", .id = Id.Keyword_return},
         KeywordId{.bytes="section", .id = Id.Keyword_section},
         KeywordId{.bytes="stdcallcc", .id = Id.Keyword_stdcallcc},
         KeywordId{.bytes="struct", .id = Id.Keyword_struct},
+        KeywordId{.bytes="suspend", .id = Id.Keyword_suspend},
         KeywordId{.bytes="switch", .id = Id.Keyword_switch},
         KeywordId{.bytes="test", .id = Id.Keyword_test},
         KeywordId{.bytes="this", .id = Id.Keyword_this},
 @@ -134,7 +139,10 @@ pub const Token = struct {
         Keyword_align,
         Keyword_and,
         Keyword_asm,
+        Keyword_async,
+        Keyword_await,
         Keyword_break,
+        Keyword_cancel,
         Keyword_catch,
         Keyword_comptime,
         Keyword_const,
 @@ -156,10 +164,12 @@ pub const Token = struct {
         Keyword_or,
         Keyword_packed,
         Keyword_pub,
+        Keyword_resume,
         Keyword_return,
         Keyword_section,
         Keyword_stdcallcc,
         Keyword_struct,
+        Keyword_suspend,
         Keyword_switch,
         Keyword_test,
         Keyword_this,