Commit 3235eb03f979cbcc38cbe8b69d55761079e6d864 | zig

author	Andrew Kelley <andrew@ziglang.org> 2018-04-29 19:23:19-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-04-29 19:23:19-04:00
log	3235eb03f979cbcc38cbe8b69d55761079e6d864
tree	aa890cfcf494377b2e9830498a279445a00717c5
parent	3fa0bed985b8de950859d4c482efe9cb30fdaf27

zig fmt: preserve same line comment after struct field

2 files changed, 1039 insertions(+), 1005 deletions(-)

std
- zig
  - parser.zig
  - parser_test.zig

std/zig/parser.zig+64-1005

...	...	@@ -376,7 +376,7 @@ pub const Parser = struct {
376	376	.body_node = &block.base,
377	377	});
378	378	try root_node.decls.append(&test_node.base);
379		stack.append(State { .Block = block }) catch unreachable;
	379	try stack.append(State { .Block = block });
380	380	try stack.append(State {
381	381	.ExpectTokenSave = ExpectTokenSave {
382	382	.id = Token.Id.LBrace,
...	...	@@ -616,14 +616,18 @@ pub const Parser = struct {
616	616	State.TopLevelExternOrField => \|ctx\| {
617	617	if (self.eatToken(Token.Id.Identifier)) \|identifier\| {
618	618	std.debug.assert(ctx.container_decl.kind == ast.Node.ContainerDecl.Kind.Struct);
619		const node = try self.createAttachNode(arena, &ctx.container_decl.fields_and_decls, ast.Node.StructField,
620		ast.Node.StructField {
621		.base = undefined,
622		.visib_token = ctx.visib_token,
623		.name_token = identifier,
624		.type_expr = undefined,
625		}
626		);
	619	const node = try arena.construct(ast.Node.StructField {
	620	.base = ast.Node {
	621	.id = ast.Node.Id.StructField,
	622	.before_comments = null,
	623	.same_line_comment = null,
	624	},
	625	.visib_token = ctx.visib_token,
	626	.name_token = identifier,
	627	.type_expr = undefined,
	628	});
	629	const node_ptr = try ctx.container_decl.fields_and_decls.addOne();
	630	*node_ptr = &node.base;
627	631
628	632	stack.append(State { .FieldListCommaOrEnd = ctx.container_decl }) catch unreachable;
629	633	try stack.append(State { .Expression = OptionalCtx { .Required = &node.type_expr } });
...	...	@@ -706,16 +710,20 @@ pub const Parser = struct {
706	710	Token.Id.Identifier => {
707	711	switch (container_decl.kind) {
708	712	ast.Node.ContainerDecl.Kind.Struct => {
709		const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.Node.StructField,
710		ast.Node.StructField {
711		.base = undefined,
712		.visib_token = null,
713		.name_token = token,
714		.type_expr = undefined,
715		}
716		);
	713	const node = try arena.construct(ast.Node.StructField {
	714	.base = ast.Node {
	715	.id = ast.Node.Id.StructField,
	716	.before_comments = null,
	717	.same_line_comment = null,
	718	},
	719	.visib_token = null,
	720	.name_token = token,
	721	.type_expr = undefined,
	722	});
	723	const node_ptr = try container_decl.fields_and_decls.addOne();
	724	*node_ptr = &node.base;
717	725
718		stack.append(State { .FieldListCommaOrEnd = container_decl }) catch unreachable;
	726	try stack.append(State { .FieldListCommaOrEnd = container_decl });
719	727	try stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.type_expr } });
720	728	try stack.append(State { .ExpectToken = Token.Id.Colon });
721	729	continue;
...	...	@@ -1336,23 +1344,7 @@ pub const Parser = struct {
1336	1344	},
1337	1345
1338	1346	State.LookForSameLineComment => \|node_ptr\| {
1339		const node = *node_ptr;
1340		const node_last_token = node.lastToken();
1341
1342		const line_comment_token = self.getNextToken();
1343		if (line_comment_token.id != Token.Id.LineComment) {
1344		self.putBackToken(line_comment_token);
1345		continue;
1346		}
1347
1348		const offset_loc = self.tokenizer.getTokenLocation(node_last_token.end, line_comment_token);
1349		const different_line = offset_loc.line != 0;
1350		if (different_line) {
1351		self.putBackToken(line_comment_token);
1352		continue;
1353		}
1354
1355		node.same_line_comment = try arena.construct(line_comment_token);
	1347	try self.lookForSameLineComment(arena, *node_ptr);
1356	1348	continue;
1357	1349	},
1358	1350
...	...	@@ -1463,14 +1455,16 @@ pub const Parser = struct {
1463	1455	continue;
1464	1456	}
1465	1457
1466		const node = try self.createNode(arena, ast.Node.FieldInitializer,
1467		ast.Node.FieldInitializer {
1468		.base = undefined,
1469		.period_token = undefined,
1470		.name_token = undefined,
1471		.expr = undefined,
1472		}
1473		);
	1458	const node = try arena.construct(ast.Node.FieldInitializer {
	1459	.base = ast.Node {
	1460	.id = ast.Node.Id.FieldInitializer,
	1461	.before_comments = null,
	1462	.same_line_comment = null,
	1463	},
	1464	.period_token = undefined,
	1465	.name_token = undefined,
	1466	.expr = undefined,
	1467	});
1474	1468	try list_state.list.append(node);
1475	1469
1476	1470	stack.append(State { .FieldInitListCommaOrEnd = list_state }) catch unreachable;
...	...	@@ -1504,7 +1498,8 @@ pub const Parser = struct {
1504	1498	container_decl.rbrace_token = end;
1505	1499	continue;
1506	1500	} else {
1507		stack.append(State { .ContainerDecl = container_decl }) catch unreachable;
	1501	try self.lookForSameLineComment(arena, container_decl.fields_and_decls.toSlice()[container_decl.fields_and_decls.len - 1]);
	1502	try stack.append(State { .ContainerDecl = container_decl });
1508	1503	continue;
1509	1504	}
1510	1505	},
...	...	@@ -2908,6 +2903,25 @@ pub const Parser = struct {
2908	2903	}
2909	2904	}
2910	2905
	2906	fn lookForSameLineComment(self: &Parser, arena: &mem.Allocator, node: &ast.Node) !void {
	2907	const node_last_token = node.lastToken();
	2908
	2909	const line_comment_token = self.getNextToken();
	2910	if (line_comment_token.id != Token.Id.LineComment) {
	2911	self.putBackToken(line_comment_token);
	2912	return;
	2913	}
	2914
	2915	const offset_loc = self.tokenizer.getTokenLocation(node_last_token.end, line_comment_token);
	2916	const different_line = offset_loc.line != 0;
	2917	if (different_line) {
	2918	self.putBackToken(line_comment_token);
	2919	return;
	2920	}
	2921
	2922	node.same_line_comment = try arena.construct(line_comment_token);
	2923	}
	2924
2911	2925	fn parseStringLiteral(self: &Parser, arena: &mem.Allocator, token: &const Token) !?&ast.Node {
2912	2926	switch (token.id) {
2913	2927	Token.Id.StringLiteral => {
...	...	@@ -3341,6 +3355,7 @@ pub const Parser = struct {
3341	3355	while (stack.popOrNull()) \|state\| {
3342	3356	switch (state) {
3343	3357	RenderState.TopLevelDecl => \|decl\| {
	3358	try stack.append(RenderState { .PrintSameLineComment = decl.same_line_comment } );
3344	3359	switch (decl.id) {
3345	3360	ast.Node.Id.FnProto => {
3346	3361	const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
...	...	@@ -3383,12 +3398,14 @@ pub const Parser = struct {
3383	3398	try stream.print("{} ", self.tokenizer.getTokenSlice(visib_token));
3384	3399	}
3385	3400	try stream.print("{}: ", self.tokenizer.getTokenSlice(field.name_token));
	3401	try stack.append(RenderState { .Text = "," });
3386	3402	try stack.append(RenderState { .Expression = field.type_expr});
3387	3403	},
3388	3404	ast.Node.Id.UnionTag => {
3389	3405	const tag = @fieldParentPtr(ast.Node.UnionTag, "base", decl);
3390	3406	try stream.print("{}", self.tokenizer.getTokenSlice(tag.name_token));
3391	3407
	3408	try stack.append(RenderState { .Text = "," });
3392	3409	if (tag.type_expr) \|type_expr\| {
3393	3410	try stream.print(": ");
3394	3411	try stack.append(RenderState { .Expression = type_expr});
...	...	@@ -3398,6 +3415,7 @@ pub const Parser = struct {
3398	3415	const tag = @fieldParentPtr(ast.Node.EnumTag, "base", decl);
3399	3416	try stream.print("{}", self.tokenizer.getTokenSlice(tag.name_token));
3400	3417
	3418	try stack.append(RenderState { .Text = "," });
3401	3419	if (tag.value) \|value\| {
3402	3420	try stream.print(" = ");
3403	3421	try stack.append(RenderState { .Expression = value});
...	...	@@ -3899,14 +3917,6 @@ pub const Parser = struct {
3899	3917	while (i != 0) {
3900	3918	i -= 1;
3901	3919	const node = fields_and_decls[i];
3902		switch (node.id) {
3903		ast.Node.Id.StructField,
3904		ast.Node.Id.UnionTag,
3905		ast.Node.Id.EnumTag => {
3906		try stack.append(RenderState { .Text = "," });
3907		},
3908		else => { }
3909		}
3910	3920	try stack.append(RenderState { .TopLevelDecl = node});
3911	3921	try stack.append(RenderState.PrintIndent);
3912	3922	try stack.append(RenderState {
...	...	@@ -4466,957 +4476,6 @@ pub const Parser = struct {
4466	4476
4467	4477	};
4468	4478
4469		var fixed_buffer_mem: [100 * 1024]u8 = undefined;
4470
4471		fn testParse(source: []const u8, allocator: &mem.Allocator) ![]u8 {
4472		var tokenizer = Tokenizer.init(source);
4473		var parser = Parser.init(&tokenizer, allocator, "(memory buffer)");
4474		defer parser.deinit();
4475
4476		var tree = try parser.parse();
4477		defer tree.deinit();
4478
4479		var buffer = try std.Buffer.initSize(allocator, 0);
4480		errdefer buffer.deinit();
4481
4482		var buffer_out_stream = io.BufferOutStream.init(&buffer);
4483		try parser.renderSource(&buffer_out_stream.stream, tree.root_node);
4484		return buffer.toOwnedSlice();
4485		}
4486
4487		fn testCanonical(source: []const u8) !void {
4488		const needed_alloc_count = x: {
4489		// Try it once with unlimited memory, make sure it works
4490		var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
4491		var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, @maxValue(usize));
4492		const result_source = try testParse(source, &failing_allocator.allocator);
4493		if (!mem.eql(u8, result_source, source)) {
4494		warn("\n====== expected this output: =========\n");
4495		warn("{}", source);
4496		warn("\n======== instead found this: =========\n");
4497		warn("{}", result_source);
4498		warn("\n======================================\n");
4499		return error.TestFailed;
4500		}
4501		failing_allocator.allocator.free(result_source);
4502		break :x failing_allocator.index;
4503		};
4504
4505		var fail_index: usize = 0;
4506		while (fail_index < needed_alloc_count) : (fail_index += 1) {
4507		var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
4508		var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, fail_index);
4509		if (testParse(source, &failing_allocator.allocator)) \|_\| {
4510		return error.NondeterministicMemoryUsage;
4511		} else \|err\| switch (err) {
4512		error.OutOfMemory => {
4513		if (failing_allocator.allocated_bytes != failing_allocator.freed_bytes) {
4514		warn("\nfail_index: {}/{}\nallocated bytes: {}\nfreed bytes: {}\nallocations: {}\ndeallocations: {}\n",
4515		fail_index, needed_alloc_count,
4516		failing_allocator.allocated_bytes, failing_allocator.freed_bytes,
4517		failing_allocator.index, failing_allocator.deallocations);
4518		return error.MemoryLeakDetected;
4519		}
4520		},
4521		error.ParseError => @panic("test failed"),
4522		}
4523		}
4524		}
4525
4526		test "zig fmt: array literal with 1 item on 1 line" {
4527		try testCanonical(
4528		\\var s = []const u64 {0} ** 25;
4529		\\
4530		);
4531		}
4532
4533		test "zig fmt: preserve same-line comment after a statement" {
4534		try testCanonical(
4535		\\test "" {
4536		\\ a = b;
4537		\\ debug.assert(H.digest_size <= H.block_size); // HMAC makes this assumption
4538		\\ a = b;
4539		\\}
4540		\\
4541		);
4542		}
4543
4544		test "zig fmt: preserve comments before global variables" {
4545		try testCanonical(
4546		\\/// Foo copies keys and values before they go into the map, and
4547		\\/// frees them when they get removed.
4548		\\pub const Foo = struct {};
4549		\\
4550		);
4551		}
4552
4553		test "zig fmt: preserve comments before statements" {
4554		try testCanonical(
4555		\\test "std" {
4556		\\ // statement comment
4557		\\ _ = @import("foo/bar.zig");
4558		\\}
4559		\\
4560		);
4561		}
4562
4563		test "zig fmt: preserve top level comments" {
4564		try testCanonical(
4565		\\// top level comment
4566		\\test "hi" {}
4567		\\
4568		);
4569		}
4570
4571		test "zig fmt: get stdout or fail" {
4572		try testCanonical(
4573		\\const std = @import("std");
4574		\\
4575		\\pub fn main() !void {
4576		\\ // If this program is run without stdout attached, exit with an error.
4577		\\ // another comment
4578		\\ var stdout_file = try std.io.getStdOut;
4579		\\}
4580		\\
4581		);
4582		}
4583
4584		test "zig fmt: preserve spacing" {
4585		try testCanonical(
4586		\\const std = @import("std");
4587		\\
4588		\\pub fn main() !void {
4589		\\ var stdout_file = try std.io.getStdOut;
4590		\\ var stdout_file = try std.io.getStdOut;
4591		\\
4592		\\ var stdout_file = try std.io.getStdOut;
4593		\\ var stdout_file = try std.io.getStdOut;
4594		\\}
4595		\\
4596		);
4597		}
4598
4599		test "zig fmt: return types" {
4600		try testCanonical(
4601		\\pub fn main() !void {}
4602		\\pub fn main() var {}
4603		\\pub fn main() i32 {}
4604		\\
4605		);
4606		}
4607
4608		test "zig fmt: imports" {
4609		try testCanonical(
4610		\\const std = @import("std");
4611		\\const std = @import();
4612		\\
4613		);
4614		}
4615
4616		test "zig fmt: global declarations" {
4617		try testCanonical(
4618		\\const a = b;
4619		\\pub const a = b;
4620		\\var a = b;
4621		\\pub var a = b;
4622		\\const a: i32 = b;
4623		\\pub const a: i32 = b;
4624		\\var a: i32 = b;
4625		\\pub var a: i32 = b;
4626		\\extern const a: i32 = b;
4627		\\pub extern const a: i32 = b;
4628		\\extern var a: i32 = b;
4629		\\pub extern var a: i32 = b;
4630		\\extern "a" const a: i32 = b;
4631		\\pub extern "a" const a: i32 = b;
4632		\\extern "a" var a: i32 = b;
4633		\\pub extern "a" var a: i32 = b;
4634		\\
4635		);
4636		}
4637
4638		test "zig fmt: extern declaration" {
4639		try testCanonical(
4640		\\extern var foo: c_int;
4641		\\
4642		);
4643		}
4644
4645		test "zig fmt: alignment" {
4646		try testCanonical(
4647		\\var foo: c_int align(1);
4648		\\
4649		);
4650		}
4651
4652		test "zig fmt: C main" {
4653		try testCanonical(
4654		\\fn main(argc: c_int, argv: &&u8) c_int {
4655		\\ const a = b;
4656		\\}
4657		\\
4658		);
4659		}
4660
4661		test "zig fmt: return" {
4662		try testCanonical(
4663		\\fn foo(argc: c_int, argv: &&u8) c_int {
4664		\\ return 0;
4665		\\}
4666		\\
4667		\\fn bar() void {
4668		\\ return;
4669		\\}
4670		\\
4671		);
4672		}
4673
4674		test "zig fmt: pointer attributes" {
4675		try testCanonical(
4676		\\extern fn f1(s: &align(&u8) u8) c_int;
4677		\\extern fn f2(s: &&align(1) &const &volatile u8) c_int;
4678		\\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
4679		\\extern fn f4(s: &align(1) const volatile u8) c_int;
4680		\\
4681		);
4682		}
4683
4684		test "zig fmt: slice attributes" {
4685		try testCanonical(
4686		\\extern fn f1(s: &align(&u8) u8) c_int;
4687		\\extern fn f2(s: &&align(1) &const &volatile u8) c_int;
4688		\\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
4689		\\extern fn f4(s: &align(1) const volatile u8) c_int;
4690		\\
4691		);
4692		}
4693
4694		test "zig fmt: test declaration" {
4695		try testCanonical(
4696		\\test "test name" {
4697		\\ const a = 1;
4698		\\ var b = 1;
4699		\\}
4700		\\
4701		);
4702		}
4703
4704		test "zig fmt: infix operators" {
4705		try testCanonical(
4706		\\test "infix operators" {
4707		\\ var i = undefined;
4708		\\ i = 2;
4709		\\ i *= 2;
4710		\\ i \|= 2;
4711		\\ i ^= 2;
4712		\\ i <<= 2;
4713		\\ i >>= 2;
4714		\\ i &= 2;
4715		\\ i *= 2;
4716		\\ i *%= 2;
4717		\\ i -= 2;
4718		\\ i -%= 2;
4719		\\ i += 2;
4720		\\ i +%= 2;
4721		\\ i /= 2;
4722		\\ i %= 2;
4723		\\ _ = i == i;
4724		\\ _ = i != i;
4725		\\ _ = i != i;
4726		\\ _ = i.i;
4727		\\ _ = i \|\| i;
4728		\\ _ = i!i;
4729		\\ _ = i ** i;
4730		\\ _ = i ++ i;
4731		\\ _ = i ?? i;
4732		\\ _ = i % i;
4733		\\ _ = i / i;
4734		\\ _ = i *% i;
4735		\\ _ = i * i;
4736		\\ _ = i -% i;
4737		\\ _ = i - i;
4738		\\ _ = i +% i;
4739		\\ _ = i + i;
4740		\\ _ = i << i;
4741		\\ _ = i >> i;
4742		\\ _ = i & i;
4743		\\ _ = i ^ i;
4744		\\ _ = i \| i;
4745		\\ _ = i >= i;
4746		\\ _ = i <= i;
4747		\\ _ = i > i;
4748		\\ _ = i < i;
4749		\\ _ = i and i;
4750		\\ _ = i or i;
4751		\\}
4752		\\
4753		);
4754		}
4755
4756		test "zig fmt: precedence" {
4757		try testCanonical(
4758		\\test "precedence" {
4759		\\ a!b();
4760		\\ (a!b)();
4761		\\ !a!b;
4762		\\ !(a!b);
4763		\\ !a{};
4764		\\ !(a{});
4765		\\ a + b{};
4766		\\ (a + b){};
4767		\\ a << b + c;
4768		\\ (a << b) + c;
4769		\\ a & b << c;
4770		\\ (a & b) << c;
4771		\\ a ^ b & c;
4772		\\ (a ^ b) & c;
4773		\\ a \| b ^ c;
4774		\\ (a \| b) ^ c;
4775		\\ a == b \| c;
4776		\\ (a == b) \| c;
4777		\\ a and b == c;
4778		\\ (a and b) == c;
4779		\\ a or b and c;
4780		\\ (a or b) and c;
4781		\\ (a or b) and c;
4782		\\}
4783		\\
4784		);
4785		}
4786
4787		test "zig fmt: prefix operators" {
4788		try testCanonical(
4789		\\test "prefix operators" {
4790		\\ try return --%~??!*&0;
4791		\\}
4792		\\
4793		);
4794		}
4795
4796		test "zig fmt: call expression" {
4797		try testCanonical(
4798		\\test "test calls" {
4799		\\ a();
4800		\\ a(1);
4801		\\ a(1, 2);
4802		\\ a(1, 2) + a(1, 2);
4803		\\}
4804		\\
4805		);
4806		}
4807
4808		test "zig fmt: var args" {
4809		try testCanonical(
4810		\\fn print(args: ...) void {}
4811		\\
4812		);
4813		}
4814
4815		test "zig fmt: var type" {
4816		try testCanonical(
4817		\\fn print(args: var) var {}
4818		\\const Var = var;
4819		\\const i: var = 0;
4820		\\
4821		);
4822		}
4823
4824		test "zig fmt: functions" {
4825		try testCanonical(
4826		\\extern fn puts(s: &const u8) c_int;
4827		\\extern "c" fn puts(s: &const u8) c_int;
4828		\\export fn puts(s: &const u8) c_int;
4829		\\inline fn puts(s: &const u8) c_int;
4830		\\pub extern fn puts(s: &const u8) c_int;
4831		\\pub extern "c" fn puts(s: &const u8) c_int;
4832		\\pub export fn puts(s: &const u8) c_int;
4833		\\pub inline fn puts(s: &const u8) c_int;
4834		\\pub extern fn puts(s: &const u8) align(2 + 2) c_int;
4835		\\pub extern "c" fn puts(s: &const u8) align(2 + 2) c_int;
4836		\\pub export fn puts(s: &const u8) align(2 + 2) c_int;
4837		\\pub inline fn puts(s: &const u8) align(2 + 2) c_int;
4838		\\
4839		);
4840		}
4841
4842		test "zig fmt: multiline string" {
4843		try testCanonical(
4844		\\const s =
4845		\\ \\ something
4846		\\ \\ something else
4847		\\ ;
4848		\\
4849		);
4850		}
4851
4852		test "zig fmt: values" {
4853		try testCanonical(
4854		\\test "values" {
4855		\\ 1;
4856		\\ 1.0;
4857		\\ "string";
4858		\\ c"cstring";
4859		\\ 'c';
4860		\\ true;
4861		\\ false;
4862		\\ null;
4863		\\ undefined;
4864		\\ error;
4865		\\ this;
4866		\\ unreachable;
4867		\\}
4868		\\
4869		);
4870		}
4871
4872		test "zig fmt: indexing" {
4873		try testCanonical(
4874		\\test "test index" {
4875		\\ a[0];
4876		\\ a[0 + 5];
4877		\\ a[0..];
4878		\\ a[0..5];
4879		\\ a[a[0]];
4880		\\ a[a[0..]];
4881		\\ a[a[0..5]];
4882		\\ a[a[0]..];
4883		\\ a[a[0..5]..];
4884		\\ a[a[0]..a[0]];
4885		\\ a[a[0..5]..a[0]];
4886		\\ a[a[0..5]..a[0..5]];
4887		\\}
4888		\\
4889		);
4890		}
4891
4892		test "zig fmt: struct declaration" {
4893		try testCanonical(
4894		\\const S = struct {
4895		\\ const Self = this;
4896		\\ f1: u8,
4897		\\ pub f3: u8,
4898		\\
4899		\\ fn method(self: &Self) Self {
4900		\\ return *self;
4901		\\ }
4902		\\
4903		\\ f2: u8,
4904		\\};
4905		\\
4906		\\const Ps = packed struct {
4907		\\ a: u8,
4908		\\ pub b: u8,
4909		\\
4910		\\ c: u8,
4911		\\};
4912		\\
4913		\\const Es = extern struct {
4914		\\ a: u8,
4915		\\ pub b: u8,
4916		\\
4917		\\ c: u8,
4918		\\};
4919		\\
4920		);
4921		}
4922
4923		test "zig fmt: enum declaration" {
4924		try testCanonical(
4925		\\const E = enum {
4926		\\ Ok,
4927		\\ SomethingElse = 0,
4928		\\};
4929		\\
4930		\\const E2 = enum(u8) {
4931		\\ Ok,
4932		\\ SomethingElse = 255,
4933		\\ SomethingThird,
4934		\\};
4935		\\
4936		\\const Ee = extern enum {
4937		\\ Ok,
4938		\\ SomethingElse,
4939		\\ SomethingThird,
4940		\\};
4941		\\
4942		\\const Ep = packed enum {
4943		\\ Ok,
4944		\\ SomethingElse,
4945		\\ SomethingThird,
4946		\\};
4947		\\
4948		);
4949		}
4950
4951		test "zig fmt: union declaration" {
4952		try testCanonical(
4953		\\const U = union {
4954		\\ Int: u8,
4955		\\ Float: f32,
4956		\\ None,
4957		\\ Bool: bool,
4958		\\};
4959		\\
4960		\\const Ue = union(enum) {
4961		\\ Int: u8,
4962		\\ Float: f32,
4963		\\ None,
4964		\\ Bool: bool,
4965		\\};
4966		\\
4967		\\const E = enum {
4968		\\ Int,
4969		\\ Float,
4970		\\ None,
4971		\\ Bool,
4972		\\};
4973		\\
4974		\\const Ue2 = union(E) {
4975		\\ Int: u8,
4976		\\ Float: f32,
4977		\\ None,
4978		\\ Bool: bool,
4979		\\};
4980		\\
4981		\\const Eu = extern union {
4982		\\ Int: u8,
4983		\\ Float: f32,
4984		\\ None,
4985		\\ Bool: bool,
4986		\\};
4987		\\
4988		);
4989		}
4990
4991		test "zig fmt: error set declaration" {
4992		try testCanonical(
4993		\\const E = error {
4994		\\ A,
4995		\\ B,
4996		\\
4997		\\ C,
4998		\\};
4999		\\
5000		);
5001		}
5002
5003		test "zig fmt: arrays" {
5004		try testCanonical(
5005		\\test "test array" {
5006		\\ const a: [2]u8 = [2]u8 {
5007		\\ 1,
5008		\\ 2,
5009		\\ };
5010		\\ const a: [2]u8 = []u8 {
5011		\\ 1,
5012		\\ 2,
5013		\\ };
5014		\\ const a: [0]u8 = []u8{};
5015		\\}
5016		\\
5017		);
5018		}
5019
5020		test "zig fmt: container initializers" {
5021		try testCanonical(
5022		\\const a1 = []u8{};
5023		\\const a2 = []u8 {
5024		\\ 1,
5025		\\ 2,
5026		\\ 3,
5027		\\ 4,
5028		\\};
5029		\\const s1 = S{};
5030		\\const s2 = S {
5031		\\ .a = 1,
5032		\\ .b = 2,
5033		\\};
5034		\\
5035		);
5036		}
5037
5038		test "zig fmt: catch" {
5039		try testCanonical(
5040		\\test "catch" {
5041		\\ const a: error!u8 = 0;
5042		\\ _ = a catch return;
5043		\\ _ = a catch \|err\| return;
5044		\\}
5045		\\
5046		);
5047		}
5048
5049		test "zig fmt: blocks" {
5050		try testCanonical(
5051		\\test "blocks" {
5052		\\ {
5053		\\ const a = 0;
5054		\\ const b = 0;
5055		\\ }
5056		\\
5057		\\ blk: {
5058		\\ const a = 0;
5059		\\ const b = 0;
5060		\\ }
5061		\\
5062		\\ const r = blk: {
5063		\\ const a = 0;
5064		\\ const b = 0;
5065		\\ };
5066		\\}
5067		\\
5068		);
5069		}
5070
5071		test "zig fmt: switch" {
5072		try testCanonical(
5073		\\test "switch" {
5074		\\ switch (0) {
5075		\\ 0 => {},
5076		\\ 1 => unreachable,
5077		\\ 2,
5078		\\ 3 => {},
5079		\\ 4 ... 7 => {},
5080		\\ 1 + 4 * 3 + 22 => {},
5081		\\ else => {
5082		\\ const a = 1;
5083		\\ const b = a;
5084		\\ },
5085		\\ }
5086		\\
5087		\\ const res = switch (0) {
5088		\\ 0 => 0,
5089		\\ 1 => 2,
5090		\\ 1 => a = 4,
5091		\\ else => 4,
5092		\\ };
5093		\\
5094		\\ const Union = union(enum) {
5095		\\ Int: i64,
5096		\\ Float: f64,
5097		\\ };
5098		\\
5099		\\ const u = Union {
5100		\\ .Int = 0,
5101		\\ };
5102		\\ switch (u) {
5103		\\ Union.Int => \|int\| {},
5104		\\ Union.Float => \|*float\| unreachable,
5105		\\ }
5106		\\}
5107		\\
5108		);
5109		}
5110
5111		test "zig fmt: while" {
5112		try testCanonical(
5113		\\test "while" {
5114		\\ while (10 < 1) {
5115		\\ unreachable;
5116		\\ }
5117		\\
5118		\\ while (10 < 1)
5119		\\ unreachable;
5120		\\
5121		\\ var i: usize = 0;
5122		\\ while (i < 10) : (i += 1) {
5123		\\ continue;
5124		\\ }
5125		\\
5126		\\ i = 0;
5127		\\ while (i < 10) : (i += 1)
5128		\\ continue;
5129		\\
5130		\\ i = 0;
5131		\\ var j: usize = 0;
5132		\\ while (i < 10) : ({
5133		\\ i += 1;
5134		\\ j += 1;
5135		\\ }) {
5136		\\ continue;
5137		\\ }
5138		\\
5139		\\ var a: ?u8 = 2;
5140		\\ while (a) \|v\| : (a = null) {
5141		\\ continue;
5142		\\ }
5143		\\
5144		\\ while (a) \|v\| : (a = null)
5145		\\ unreachable;
5146		\\
5147		\\ label: while (10 < 0) {
5148		\\ unreachable;
5149		\\ }
5150		\\
5151		\\ const res = while (0 < 10) {
5152		\\ break 7;
5153		\\ } else {
5154		\\ unreachable;
5155		\\ };
5156		\\
5157		\\ const res = while (0 < 10)
5158		\\ break 7
5159		\\ else
5160		\\ unreachable;
5161		\\
5162		\\ var a: error!u8 = 0;
5163		\\ while (a) \|v\| {
5164		\\ a = error.Err;
5165		\\ } else \|err\| {
5166		\\ i = 1;
5167		\\ }
5168		\\
5169		\\ comptime var k: usize = 0;
5170		\\ inline while (i < 10) : (i += 1)
5171		\\ j += 2;
5172		\\}
5173		\\
5174		);
5175		}
5176
5177		test "zig fmt: for" {
5178		try testCanonical(
5179		\\test "for" {
5180		\\ const a = []u8 {
5181		\\ 1,
5182		\\ 2,
5183		\\ 3,
5184		\\ };
5185		\\ for (a) \|v\| {
5186		\\ continue;
5187		\\ }
5188		\\
5189		\\ for (a) \|v\|
5190		\\ continue;
5191		\\
5192		\\ for (a) \|*v\|
5193		\\ continue;
5194		\\
5195		\\ for (a) \|v, i\| {
5196		\\ continue;
5197		\\ }
5198		\\
5199		\\ for (a) \|v, i\|
5200		\\ continue;
5201		\\
5202		\\ const res = for (a) \|v, i\| {
5203		\\ break v;
5204		\\ } else {
5205		\\ unreachable;
5206		\\ };
5207		\\
5208		\\ var num: usize = 0;
5209		\\ inline for (a) \|v, i\| {
5210		\\ num += v;
5211		\\ num += i;
5212		\\ }
5213		\\}
5214		\\
5215		);
5216		}
5217
5218		test "zig fmt: if" {
5219		try testCanonical(
5220		\\test "if" {
5221		\\ if (10 < 0) {
5222		\\ unreachable;
5223		\\ }
5224		\\
5225		\\ if (10 < 0) unreachable;
5226		\\
5227		\\ if (10 < 0) {
5228		\\ unreachable;
5229		\\ } else {
5230		\\ const a = 20;
5231		\\ }
5232		\\
5233		\\ if (10 < 0) {
5234		\\ unreachable;
5235		\\ } else if (5 < 0) {
5236		\\ unreachable;
5237		\\ } else {
5238		\\ const a = 20;
5239		\\ }
5240		\\
5241		\\ const is_world_broken = if (10 < 0) true else false;
5242		\\ const some_number = 1 + if (10 < 0) 2 else 3;
5243		\\
5244		\\ const a: ?u8 = 10;
5245		\\ const b: ?u8 = null;
5246		\\ if (a) \|v\| {
5247		\\ const some = v;
5248		\\ } else if (b) \|*v\| {
5249		\\ unreachable;
5250		\\ } else {
5251		\\ const some = 10;
5252		\\ }
5253		\\
5254		\\ const non_null_a = if (a) \|v\| v else 0;
5255		\\
5256		\\ const a_err: error!u8 = 0;
5257		\\ if (a_err) \|v\| {
5258		\\ const p = v;
5259		\\ } else \|err\| {
5260		\\ unreachable;
5261		\\ }
5262		\\}
5263		\\
5264		);
5265		}
5266
5267		test "zig fmt: defer" {
5268		try testCanonical(
5269		\\test "defer" {
5270		\\ var i: usize = 0;
5271		\\ defer i = 1;
5272		\\ defer {
5273		\\ i += 2;
5274		\\ i *= i;
5275		\\ }
5276		\\
5277		\\ errdefer i += 3;
5278		\\ errdefer {
5279		\\ i += 2;
5280		\\ i /= i;
5281		\\ }
5282		\\}
5283		\\
5284		);
5285		}
5286
5287		test "zig fmt: comptime" {
5288		try testCanonical(
5289		\\fn a() u8 {
5290		\\ return 5;
5291		\\}
5292		\\
5293		\\fn b(comptime i: u8) u8 {
5294		\\ return i;
5295		\\}
5296		\\
5297		\\const av = comptime a();
5298		\\const av2 = comptime blk: {
5299		\\ var res = a();
5300		\\ res *= b(2);
5301		\\ break :blk res;
5302		\\};
5303		\\
5304		\\comptime {
5305		\\ _ = a();
5306		\\}
5307		\\
5308		\\test "comptime" {
5309		\\ const av3 = comptime a();
5310		\\ const av4 = comptime blk: {
5311		\\ var res = a();
5312		\\ res *= a();
5313		\\ break :blk res;
5314		\\ };
5315		\\
5316		\\ comptime var i = 0;
5317		\\ comptime {
5318		\\ i = a();
5319		\\ i += b(i);
5320		\\ }
5321		\\}
5322		\\
5323		);
5324		}
5325
5326		test "zig fmt: fn type" {
5327		try testCanonical(
5328		\\fn a(i: u8) u8 {
5329		\\ return i + 1;
5330		\\}
5331		\\
5332		\\const a: fn(u8) u8 = undefined;
5333		\\const b: extern fn(u8) u8 = undefined;
5334		\\const c: nakedcc fn(u8) u8 = undefined;
5335		\\const ap: fn(u8) u8 = a;
5336		\\
5337		);
5338		}
5339
5340		test "zig fmt: inline asm" {
5341		try testCanonical(
5342		\\pub fn syscall1(number: usize, arg1: usize) usize {
5343		\\ return asm volatile ("syscall"
5344		\\ : [ret] "={rax}" (-> usize)
5345		\\ : [number] "{rax}" (number),
5346		\\ [arg1] "{rdi}" (arg1)
5347		\\ : "rcx", "r11");
5348		\\}
5349		\\
5350		);
5351		}
5352
5353		test "zig fmt: coroutines" {
5354		try testCanonical(
5355		\\async fn simpleAsyncFn() void {
5356		\\ const a = async a.b();
5357		\\ x += 1;
5358		\\ suspend;
5359		\\ x += 1;
5360		\\ suspend \|p\| {}
5361		\\ const p = async simpleAsyncFn() catch unreachable;
5362		\\ await p;
5363		\\}
5364		\\
5365		\\test "coroutine suspend, resume, cancel" {
5366		\\ const p = try async<std.debug.global_allocator> testAsyncSeq();
5367		\\ resume p;
5368		\\ cancel p;
5369		\\}
5370		\\
5371		);
5372		}
5373
5374		test "zig fmt: Block after if" {
5375		try testCanonical(
5376		\\test "Block after if" {
5377		\\ if (true) {
5378		\\ const a = 0;
5379		\\ }
5380		\\
5381		\\ {
5382		\\ const a = 0;
5383		\\ }
5384		\\}
5385		\\
5386		);
5387		}
5388
5389		test "zig fmt: use" {
5390		try testCanonical(
5391		\\use @import("std");
5392		\\pub use @import("std");
5393		\\
5394		);
5395		}
5396
5397		test "zig fmt: string identifier" {
5398		try testCanonical(
5399		\\const @"a b" = @"c d".@"e f";
5400		\\fn @"g h"() void {}
5401		\\
5402		);
5403		}
5404
5405		test "zig fmt: error return" {
5406		try testCanonical(
5407		\\fn err() error {
5408		\\ call();
5409		\\ return error.InvalidArgs;
5410		\\}
5411		\\
5412		);
5413		}
5414
5415		test "zig fmt: struct literals with fields on each line" {
5416		try testCanonical(
5417		\\var self = BufSet {
5418		\\ .hash_map = BufSetHashMap.init(a),
5419		\\};
5420		\\
5421		);
	4479	test "std.zig.parser" {
	4480	_ = @import("parser_test.zig");
5422	4481	}

std/zig/parser_test.zig created+975

...	...	@@ -0,0 +1,975 @@
	1	test "zig fmt: line comment after field decl" {
	2	try testCanonical(
	3	\\pub const dirent = extern struct {
	4	\\ d_name: u8,
	5	\\ d_name: u8, // comment 1
	6	\\ d_name: u8,
	7	\\ d_name: u8, // comment 2
	8	\\ d_name: u8,
	9	\\};
	10	\\
	11	);
	12	}
	13
	14	test "zig fmt: array literal with 1 item on 1 line" {
	15	try testCanonical(
	16	\\var s = []const u64 {0} ** 25;
	17	\\
	18	);
	19	}
	20
	21	test "zig fmt: preserve same-line comment after a statement" {
	22	try testCanonical(
	23	\\test "" {
	24	\\ a = b;
	25	\\ debug.assert(H.digest_size <= H.block_size); // HMAC makes this assumption
	26	\\ a = b;
	27	\\}
	28	\\
	29	);
	30	}
	31
	32	test "zig fmt: preserve comments before global variables" {
	33	try testCanonical(
	34	\\/// Foo copies keys and values before they go into the map, and
	35	\\/// frees them when they get removed.
	36	\\pub const Foo = struct {};
	37	\\
	38	);
	39	}
	40
	41	test "zig fmt: preserve comments before statements" {
	42	try testCanonical(
	43	\\test "std" {
	44	\\ // statement comment
	45	\\ _ = @import("foo/bar.zig");
	46	\\}
	47	\\
	48	);
	49	}
	50
	51	test "zig fmt: preserve top level comments" {
	52	try testCanonical(
	53	\\// top level comment
	54	\\test "hi" {}
	55	\\
	56	);
	57	}
	58
	59	test "zig fmt: get stdout or fail" {
	60	try testCanonical(
	61	\\const std = @import("std");
	62	\\
	63	\\pub fn main() !void {
	64	\\ // If this program is run without stdout attached, exit with an error.
	65	\\ // another comment
	66	\\ var stdout_file = try std.io.getStdOut;
	67	\\}
	68	\\
	69	);
	70	}
	71
	72	test "zig fmt: preserve spacing" {
	73	try testCanonical(
	74	\\const std = @import("std");
	75	\\
	76	\\pub fn main() !void {
	77	\\ var stdout_file = try std.io.getStdOut;
	78	\\ var stdout_file = try std.io.getStdOut;
	79	\\
	80	\\ var stdout_file = try std.io.getStdOut;
	81	\\ var stdout_file = try std.io.getStdOut;
	82	\\}
	83	\\
	84	);
	85	}
	86
	87	test "zig fmt: return types" {
	88	try testCanonical(
	89	\\pub fn main() !void {}
	90	\\pub fn main() var {}
	91	\\pub fn main() i32 {}
	92	\\
	93	);
	94	}
	95
	96	test "zig fmt: imports" {
	97	try testCanonical(
	98	\\const std = @import("std");
	99	\\const std = @import();
	100	\\
	101	);
	102	}
	103
	104	test "zig fmt: global declarations" {
	105	try testCanonical(
	106	\\const a = b;
	107	\\pub const a = b;
	108	\\var a = b;
	109	\\pub var a = b;
	110	\\const a: i32 = b;
	111	\\pub const a: i32 = b;
	112	\\var a: i32 = b;
	113	\\pub var a: i32 = b;
	114	\\extern const a: i32 = b;
	115	\\pub extern const a: i32 = b;
	116	\\extern var a: i32 = b;
	117	\\pub extern var a: i32 = b;
	118	\\extern "a" const a: i32 = b;
	119	\\pub extern "a" const a: i32 = b;
	120	\\extern "a" var a: i32 = b;
	121	\\pub extern "a" var a: i32 = b;
	122	\\
	123	);
	124	}
	125
	126	test "zig fmt: extern declaration" {
	127	try testCanonical(
	128	\\extern var foo: c_int;
	129	\\
	130	);
	131	}
	132
	133	test "zig fmt: alignment" {
	134	try testCanonical(
	135	\\var foo: c_int align(1);
	136	\\
	137	);
	138	}
	139
	140	test "zig fmt: C main" {
	141	try testCanonical(
	142	\\fn main(argc: c_int, argv: &&u8) c_int {
	143	\\ const a = b;
	144	\\}
	145	\\
	146	);
	147	}
	148
	149	test "zig fmt: return" {
	150	try testCanonical(
	151	\\fn foo(argc: c_int, argv: &&u8) c_int {
	152	\\ return 0;
	153	\\}
	154	\\
	155	\\fn bar() void {
	156	\\ return;
	157	\\}
	158	\\
	159	);
	160	}
	161
	162	test "zig fmt: pointer attributes" {
	163	try testCanonical(
	164	\\extern fn f1(s: &align(&u8) u8) c_int;
	165	\\extern fn f2(s: &&align(1) &const &volatile u8) c_int;
	166	\\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
	167	\\extern fn f4(s: &align(1) const volatile u8) c_int;
	168	\\
	169	);
	170	}
	171
	172	test "zig fmt: slice attributes" {
	173	try testCanonical(
	174	\\extern fn f1(s: &align(&u8) u8) c_int;
	175	\\extern fn f2(s: &&align(1) &const &volatile u8) c_int;
	176	\\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
	177	\\extern fn f4(s: &align(1) const volatile u8) c_int;
	178	\\
	179	);
	180	}
	181
	182	test "zig fmt: test declaration" {
	183	try testCanonical(
	184	\\test "test name" {
	185	\\ const a = 1;
	186	\\ var b = 1;
	187	\\}
	188	\\
	189	);
	190	}
	191
	192	test "zig fmt: infix operators" {
	193	try testCanonical(
	194	\\test "infix operators" {
	195	\\ var i = undefined;
	196	\\ i = 2;
	197	\\ i *= 2;
	198	\\ i \|= 2;
	199	\\ i ^= 2;
	200	\\ i <<= 2;
	201	\\ i >>= 2;
	202	\\ i &= 2;
	203	\\ i *= 2;
	204	\\ i *%= 2;
	205	\\ i -= 2;
	206	\\ i -%= 2;
	207	\\ i += 2;
	208	\\ i +%= 2;
	209	\\ i /= 2;
	210	\\ i %= 2;
	211	\\ _ = i == i;
	212	\\ _ = i != i;
	213	\\ _ = i != i;
	214	\\ _ = i.i;
	215	\\ _ = i \|\| i;
	216	\\ _ = i!i;
	217	\\ _ = i ** i;
	218	\\ _ = i ++ i;
	219	\\ _ = i ?? i;
	220	\\ _ = i % i;
	221	\\ _ = i / i;
	222	\\ _ = i *% i;
	223	\\ _ = i * i;
	224	\\ _ = i -% i;
	225	\\ _ = i - i;
	226	\\ _ = i +% i;
	227	\\ _ = i + i;
	228	\\ _ = i << i;
	229	\\ _ = i >> i;
	230	\\ _ = i & i;
	231	\\ _ = i ^ i;
	232	\\ _ = i \| i;
	233	\\ _ = i >= i;
	234	\\ _ = i <= i;
	235	\\ _ = i > i;
	236	\\ _ = i < i;
	237	\\ _ = i and i;
	238	\\ _ = i or i;
	239	\\}
	240	\\
	241	);
	242	}
	243
	244	test "zig fmt: precedence" {
	245	try testCanonical(
	246	\\test "precedence" {
	247	\\ a!b();
	248	\\ (a!b)();
	249	\\ !a!b;
	250	\\ !(a!b);
	251	\\ !a{};
	252	\\ !(a{});
	253	\\ a + b{};
	254	\\ (a + b){};
	255	\\ a << b + c;
	256	\\ (a << b) + c;
	257	\\ a & b << c;
	258	\\ (a & b) << c;
	259	\\ a ^ b & c;
	260	\\ (a ^ b) & c;
	261	\\ a \| b ^ c;
	262	\\ (a \| b) ^ c;
	263	\\ a == b \| c;
	264	\\ (a == b) \| c;
	265	\\ a and b == c;
	266	\\ (a and b) == c;
	267	\\ a or b and c;
	268	\\ (a or b) and c;
	269	\\ (a or b) and c;
	270	\\}
	271	\\
	272	);
	273	}
	274
	275	test "zig fmt: prefix operators" {
	276	try testCanonical(
	277	\\test "prefix operators" {
	278	\\ try return --%~??!*&0;
	279	\\}
	280	\\
	281	);
	282	}
	283
	284	test "zig fmt: call expression" {
	285	try testCanonical(
	286	\\test "test calls" {
	287	\\ a();
	288	\\ a(1);
	289	\\ a(1, 2);
	290	\\ a(1, 2) + a(1, 2);
	291	\\}
	292	\\
	293	);
	294	}
	295
	296	test "zig fmt: var args" {
	297	try testCanonical(
	298	\\fn print(args: ...) void {}
	299	\\
	300	);
	301	}
	302
	303	test "zig fmt: var type" {
	304	try testCanonical(
	305	\\fn print(args: var) var {}
	306	\\const Var = var;
	307	\\const i: var = 0;
	308	\\
	309	);
	310	}
	311
	312	test "zig fmt: functions" {
	313	try testCanonical(
	314	\\extern fn puts(s: &const u8) c_int;
	315	\\extern "c" fn puts(s: &const u8) c_int;
	316	\\export fn puts(s: &const u8) c_int;
	317	\\inline fn puts(s: &const u8) c_int;
	318	\\pub extern fn puts(s: &const u8) c_int;
	319	\\pub extern "c" fn puts(s: &const u8) c_int;
	320	\\pub export fn puts(s: &const u8) c_int;
	321	\\pub inline fn puts(s: &const u8) c_int;
	322	\\pub extern fn puts(s: &const u8) align(2 + 2) c_int;
	323	\\pub extern "c" fn puts(s: &const u8) align(2 + 2) c_int;
	324	\\pub export fn puts(s: &const u8) align(2 + 2) c_int;
	325	\\pub inline fn puts(s: &const u8) align(2 + 2) c_int;
	326	\\
	327	);
	328	}
	329
	330	test "zig fmt: multiline string" {
	331	try testCanonical(
	332	\\const s =
	333	\\ \\ something
	334	\\ \\ something else
	335	\\ ;
	336	\\
	337	);
	338	}
	339
	340	test "zig fmt: values" {
	341	try testCanonical(
	342	\\test "values" {
	343	\\ 1;
	344	\\ 1.0;
	345	\\ "string";
	346	\\ c"cstring";
	347	\\ 'c';
	348	\\ true;
	349	\\ false;
	350	\\ null;
	351	\\ undefined;
	352	\\ error;
	353	\\ this;
	354	\\ unreachable;
	355	\\}
	356	\\
	357	);
	358	}
	359
	360	test "zig fmt: indexing" {
	361	try testCanonical(
	362	\\test "test index" {
	363	\\ a[0];
	364	\\ a[0 + 5];
	365	\\ a[0..];
	366	\\ a[0..5];
	367	\\ a[a[0]];
	368	\\ a[a[0..]];
	369	\\ a[a[0..5]];
	370	\\ a[a[0]..];
	371	\\ a[a[0..5]..];
	372	\\ a[a[0]..a[0]];
	373	\\ a[a[0..5]..a[0]];
	374	\\ a[a[0..5]..a[0..5]];
	375	\\}
	376	\\
	377	);
	378	}
	379
	380	test "zig fmt: struct declaration" {
	381	try testCanonical(
	382	\\const S = struct {
	383	\\ const Self = this;
	384	\\ f1: u8,
	385	\\ pub f3: u8,
	386	\\
	387	\\ fn method(self: &Self) Self {
	388	\\ return *self;
	389	\\ }
	390	\\
	391	\\ f2: u8,
	392	\\};
	393	\\
	394	\\const Ps = packed struct {
	395	\\ a: u8,
	396	\\ pub b: u8,
	397	\\
	398	\\ c: u8,
	399	\\};
	400	\\
	401	\\const Es = extern struct {
	402	\\ a: u8,
	403	\\ pub b: u8,
	404	\\
	405	\\ c: u8,
	406	\\};
	407	\\
	408	);
	409	}
	410
	411	test "zig fmt: enum declaration" {
	412	try testCanonical(
	413	\\const E = enum {
	414	\\ Ok,
	415	\\ SomethingElse = 0,
	416	\\};
	417	\\
	418	\\const E2 = enum(u8) {
	419	\\ Ok,
	420	\\ SomethingElse = 255,
	421	\\ SomethingThird,
	422	\\};
	423	\\
	424	\\const Ee = extern enum {
	425	\\ Ok,
	426	\\ SomethingElse,
	427	\\ SomethingThird,
	428	\\};
	429	\\
	430	\\const Ep = packed enum {
	431	\\ Ok,
	432	\\ SomethingElse,
	433	\\ SomethingThird,
	434	\\};
	435	\\
	436	);
	437	}
	438
	439	test "zig fmt: union declaration" {
	440	try testCanonical(
	441	\\const U = union {
	442	\\ Int: u8,
	443	\\ Float: f32,
	444	\\ None,
	445	\\ Bool: bool,
	446	\\};
	447	\\
	448	\\const Ue = union(enum) {
	449	\\ Int: u8,
	450	\\ Float: f32,
	451	\\ None,
	452	\\ Bool: bool,
	453	\\};
	454	\\
	455	\\const E = enum {
	456	\\ Int,
	457	\\ Float,
	458	\\ None,
	459	\\ Bool,
	460	\\};
	461	\\
	462	\\const Ue2 = union(E) {
	463	\\ Int: u8,
	464	\\ Float: f32,
	465	\\ None,
	466	\\ Bool: bool,
	467	\\};
	468	\\
	469	\\const Eu = extern union {
	470	\\ Int: u8,
	471	\\ Float: f32,
	472	\\ None,
	473	\\ Bool: bool,
	474	\\};
	475	\\
	476	);
	477	}
	478
	479	test "zig fmt: error set declaration" {
	480	try testCanonical(
	481	\\const E = error {
	482	\\ A,
	483	\\ B,
	484	\\
	485	\\ C,
	486	\\};
	487	\\
	488	);
	489	}
	490
	491	test "zig fmt: arrays" {
	492	try testCanonical(
	493	\\test "test array" {
	494	\\ const a: [2]u8 = [2]u8 {
	495	\\ 1,
	496	\\ 2,
	497	\\ };
	498	\\ const a: [2]u8 = []u8 {
	499	\\ 1,
	500	\\ 2,
	501	\\ };
	502	\\ const a: [0]u8 = []u8{};
	503	\\}
	504	\\
	505	);
	506	}
	507
	508	test "zig fmt: container initializers" {
	509	try testCanonical(
	510	\\const a1 = []u8{};
	511	\\const a2 = []u8 {
	512	\\ 1,
	513	\\ 2,
	514	\\ 3,
	515	\\ 4,
	516	\\};
	517	\\const s1 = S{};
	518	\\const s2 = S {
	519	\\ .a = 1,
	520	\\ .b = 2,
	521	\\};
	522	\\
	523	);
	524	}
	525
	526	test "zig fmt: catch" {
	527	try testCanonical(
	528	\\test "catch" {
	529	\\ const a: error!u8 = 0;
	530	\\ _ = a catch return;
	531	\\ _ = a catch \|err\| return;
	532	\\}
	533	\\
	534	);
	535	}
	536
	537	test "zig fmt: blocks" {
	538	try testCanonical(
	539	\\test "blocks" {
	540	\\ {
	541	\\ const a = 0;
	542	\\ const b = 0;
	543	\\ }
	544	\\
	545	\\ blk: {
	546	\\ const a = 0;
	547	\\ const b = 0;
	548	\\ }
	549	\\
	550	\\ const r = blk: {
	551	\\ const a = 0;
	552	\\ const b = 0;
	553	\\ };
	554	\\}
	555	\\
	556	);
	557	}
	558
	559	test "zig fmt: switch" {
	560	try testCanonical(
	561	\\test "switch" {
	562	\\ switch (0) {
	563	\\ 0 => {},
	564	\\ 1 => unreachable,
	565	\\ 2,
	566	\\ 3 => {},
	567	\\ 4 ... 7 => {},
	568	\\ 1 + 4 * 3 + 22 => {},
	569	\\ else => {
	570	\\ const a = 1;
	571	\\ const b = a;
	572	\\ },
	573	\\ }
	574	\\
	575	\\ const res = switch (0) {
	576	\\ 0 => 0,
	577	\\ 1 => 2,
	578	\\ 1 => a = 4,
	579	\\ else => 4,
	580	\\ };
	581	\\
	582	\\ const Union = union(enum) {
	583	\\ Int: i64,
	584	\\ Float: f64,
	585	\\ };
	586	\\
	587	\\ const u = Union {
	588	\\ .Int = 0,
	589	\\ };
	590	\\ switch (u) {
	591	\\ Union.Int => \|int\| {},
	592	\\ Union.Float => \|*float\| unreachable,
	593	\\ }
	594	\\}
	595	\\
	596	);
	597	}
	598
	599	test "zig fmt: while" {
	600	try testCanonical(
	601	\\test "while" {
	602	\\ while (10 < 1) {
	603	\\ unreachable;
	604	\\ }
	605	\\
	606	\\ while (10 < 1)
	607	\\ unreachable;
	608	\\
	609	\\ var i: usize = 0;
	610	\\ while (i < 10) : (i += 1) {
	611	\\ continue;
	612	\\ }
	613	\\
	614	\\ i = 0;
	615	\\ while (i < 10) : (i += 1)
	616	\\ continue;
	617	\\
	618	\\ i = 0;
	619	\\ var j: usize = 0;
	620	\\ while (i < 10) : ({
	621	\\ i += 1;
	622	\\ j += 1;
	623	\\ }) {
	624	\\ continue;
	625	\\ }
	626	\\
	627	\\ var a: ?u8 = 2;
	628	\\ while (a) \|v\| : (a = null) {
	629	\\ continue;
	630	\\ }
	631	\\
	632	\\ while (a) \|v\| : (a = null)
	633	\\ unreachable;
	634	\\
	635	\\ label: while (10 < 0) {
	636	\\ unreachable;
	637	\\ }
	638	\\
	639	\\ const res = while (0 < 10) {
	640	\\ break 7;
	641	\\ } else {
	642	\\ unreachable;
	643	\\ };
	644	\\
	645	\\ const res = while (0 < 10)
	646	\\ break 7
	647	\\ else
	648	\\ unreachable;
	649	\\
	650	\\ var a: error!u8 = 0;
	651	\\ while (a) \|v\| {
	652	\\ a = error.Err;
	653	\\ } else \|err\| {
	654	\\ i = 1;
	655	\\ }
	656	\\
	657	\\ comptime var k: usize = 0;
	658	\\ inline while (i < 10) : (i += 1)
	659	\\ j += 2;
	660	\\}
	661	\\
	662	);
	663	}
	664
	665	test "zig fmt: for" {
	666	try testCanonical(
	667	\\test "for" {
	668	\\ const a = []u8 {
	669	\\ 1,
	670	\\ 2,
	671	\\ 3,
	672	\\ };
	673	\\ for (a) \|v\| {
	674	\\ continue;
	675	\\ }
	676	\\
	677	\\ for (a) \|v\|
	678	\\ continue;
	679	\\
	680	\\ for (a) \|*v\|
	681	\\ continue;
	682	\\
	683	\\ for (a) \|v, i\| {
	684	\\ continue;
	685	\\ }
	686	\\
	687	\\ for (a) \|v, i\|
	688	\\ continue;
	689	\\
	690	\\ const res = for (a) \|v, i\| {
	691	\\ break v;
	692	\\ } else {
	693	\\ unreachable;
	694	\\ };
	695	\\
	696	\\ var num: usize = 0;
	697	\\ inline for (a) \|v, i\| {
	698	\\ num += v;
	699	\\ num += i;
	700	\\ }
	701	\\}
	702	\\
	703	);
	704	}
	705
	706	test "zig fmt: if" {
	707	try testCanonical(
	708	\\test "if" {
	709	\\ if (10 < 0) {
	710	\\ unreachable;
	711	\\ }
	712	\\
	713	\\ if (10 < 0) unreachable;
	714	\\
	715	\\ if (10 < 0) {
	716	\\ unreachable;
	717	\\ } else {
	718	\\ const a = 20;
	719	\\ }
	720	\\
	721	\\ if (10 < 0) {
	722	\\ unreachable;
	723	\\ } else if (5 < 0) {
	724	\\ unreachable;
	725	\\ } else {
	726	\\ const a = 20;
	727	\\ }
	728	\\
	729	\\ const is_world_broken = if (10 < 0) true else false;
	730	\\ const some_number = 1 + if (10 < 0) 2 else 3;
	731	\\
	732	\\ const a: ?u8 = 10;
	733	\\ const b: ?u8 = null;
	734	\\ if (a) \|v\| {
	735	\\ const some = v;
	736	\\ } else if (b) \|*v\| {
	737	\\ unreachable;
	738	\\ } else {
	739	\\ const some = 10;
	740	\\ }
	741	\\
	742	\\ const non_null_a = if (a) \|v\| v else 0;
	743	\\
	744	\\ const a_err: error!u8 = 0;
	745	\\ if (a_err) \|v\| {
	746	\\ const p = v;
	747	\\ } else \|err\| {
	748	\\ unreachable;
	749	\\ }
	750	\\}
	751	\\
	752	);
	753	}
	754
	755	test "zig fmt: defer" {
	756	try testCanonical(
	757	\\test "defer" {
	758	\\ var i: usize = 0;
	759	\\ defer i = 1;
	760	\\ defer {
	761	\\ i += 2;
	762	\\ i *= i;
	763	\\ }
	764	\\
	765	\\ errdefer i += 3;
	766	\\ errdefer {
	767	\\ i += 2;
	768	\\ i /= i;
	769	\\ }
	770	\\}
	771	\\
	772	);
	773	}
	774
	775	test "zig fmt: comptime" {
	776	try testCanonical(
	777	\\fn a() u8 {
	778	\\ return 5;
	779	\\}
	780	\\
	781	\\fn b(comptime i: u8) u8 {
	782	\\ return i;
	783	\\}
	784	\\
	785	\\const av = comptime a();
	786	\\const av2 = comptime blk: {
	787	\\ var res = a();
	788	\\ res *= b(2);
	789	\\ break :blk res;
	790	\\};
	791	\\
	792	\\comptime {
	793	\\ _ = a();
	794	\\}
	795	\\
	796	\\test "comptime" {
	797	\\ const av3 = comptime a();
	798	\\ const av4 = comptime blk: {
	799	\\ var res = a();
	800	\\ res *= a();
	801	\\ break :blk res;
	802	\\ };
	803	\\
	804	\\ comptime var i = 0;
	805	\\ comptime {
	806	\\ i = a();
	807	\\ i += b(i);
	808	\\ }
	809	\\}
	810	\\
	811	);
	812	}
	813
	814	test "zig fmt: fn type" {
	815	try testCanonical(
	816	\\fn a(i: u8) u8 {
	817	\\ return i + 1;
	818	\\}
	819	\\
	820	\\const a: fn(u8) u8 = undefined;
	821	\\const b: extern fn(u8) u8 = undefined;
	822	\\const c: nakedcc fn(u8) u8 = undefined;
	823	\\const ap: fn(u8) u8 = a;
	824	\\
	825	);
	826	}
	827
	828	test "zig fmt: inline asm" {
	829	try testCanonical(
	830	\\pub fn syscall1(number: usize, arg1: usize) usize {
	831	\\ return asm volatile ("syscall"
	832	\\ : [ret] "={rax}" (-> usize)
	833	\\ : [number] "{rax}" (number),
	834	\\ [arg1] "{rdi}" (arg1)
	835	\\ : "rcx", "r11");
	836	\\}
	837	\\
	838	);
	839	}
	840
	841	test "zig fmt: coroutines" {
	842	try testCanonical(
	843	\\async fn simpleAsyncFn() void {
	844	\\ const a = async a.b();
	845	\\ x += 1;
	846	\\ suspend;
	847	\\ x += 1;
	848	\\ suspend \|p\| {}
	849	\\ const p = async simpleAsyncFn() catch unreachable;
	850	\\ await p;
	851	\\}
	852	\\
	853	\\test "coroutine suspend, resume, cancel" {
	854	\\ const p = try async<std.debug.global_allocator> testAsyncSeq();
	855	\\ resume p;
	856	\\ cancel p;
	857	\\}
	858	\\
	859	);
	860	}
	861
	862	test "zig fmt: Block after if" {
	863	try testCanonical(
	864	\\test "Block after if" {
	865	\\ if (true) {
	866	\\ const a = 0;
	867	\\ }
	868	\\
	869	\\ {
	870	\\ const a = 0;
	871	\\ }
	872	\\}
	873	\\
	874	);
	875	}
	876
	877	test "zig fmt: use" {
	878	try testCanonical(
	879	\\use @import("std");
	880	\\pub use @import("std");
	881	\\
	882	);
	883	}
	884
	885	test "zig fmt: string identifier" {
	886	try testCanonical(
	887	\\const @"a b" = @"c d".@"e f";
	888	\\fn @"g h"() void {}
	889	\\
	890	);
	891	}
	892
	893	test "zig fmt: error return" {
	894	try testCanonical(
	895	\\fn err() error {
	896	\\ call();
	897	\\ return error.InvalidArgs;
	898	\\}
	899	\\
	900	);
	901	}
	902
	903	test "zig fmt: struct literals with fields on each line" {
	904	try testCanonical(
	905	\\var self = BufSet {
	906	\\ .hash_map = BufSetHashMap.init(a),
	907	\\};
	908	\\
	909	);
	910	}
	911
	912	const std = @import("std");
	913	const mem = std.mem;
	914	const warn = std.debug.warn;
	915	const Tokenizer = std.zig.Tokenizer;
	916	const Parser = std.zig.Parser;
	917	const io = std.io;
	918
	919	var fixed_buffer_mem: [100 * 1024]u8 = undefined;
	920
	921	fn testParse(source: []const u8, allocator: &mem.Allocator) ![]u8 {
	922	var tokenizer = Tokenizer.init(source);
	923	var parser = Parser.init(&tokenizer, allocator, "(memory buffer)");
	924	defer parser.deinit();
	925
	926	var tree = try parser.parse();
	927	defer tree.deinit();
	928
	929	var buffer = try std.Buffer.initSize(allocator, 0);
	930	errdefer buffer.deinit();
	931
	932	var buffer_out_stream = io.BufferOutStream.init(&buffer);
	933	try parser.renderSource(&buffer_out_stream.stream, tree.root_node);
	934	return buffer.toOwnedSlice();
	935	}
	936
	937	fn testCanonical(source: []const u8) !void {
	938	const needed_alloc_count = x: {
	939	// Try it once with unlimited memory, make sure it works
	940	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
	941	var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, @maxValue(usize));
	942	const result_source = try testParse(source, &failing_allocator.allocator);
	943	if (!mem.eql(u8, result_source, source)) {
	944	warn("\n====== expected this output: =========\n");
	945	warn("{}", source);
	946	warn("\n======== instead found this: =========\n");
	947	warn("{}", result_source);
	948	warn("\n======================================\n");
	949	return error.TestFailed;
	950	}
	951	failing_allocator.allocator.free(result_source);
	952	break :x failing_allocator.index;
	953	};
	954
	955	var fail_index: usize = 0;
	956	while (fail_index < needed_alloc_count) : (fail_index += 1) {
	957	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
	958	var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, fail_index);
	959	if (testParse(source, &failing_allocator.allocator)) \|_\| {
	960	return error.NondeterministicMemoryUsage;
	961	} else \|err\| switch (err) {
	962	error.OutOfMemory => {
	963	if (failing_allocator.allocated_bytes != failing_allocator.freed_bytes) {
	964	warn("\nfail_index: {}/{}\nallocated bytes: {}\nfreed bytes: {}\nallocations: {}\ndeallocations: {}\n",
	965	fail_index, needed_alloc_count,
	966	failing_allocator.allocated_bytes, failing_allocator.freed_bytes,
	967	failing_allocator.index, failing_allocator.deallocations);
	968	return error.MemoryLeakDetected;
	969	}
	970	},
	971	error.ParseError => @panic("test failed"),
	972	}
	973	}
	974	}
	975