Commit ec261c5e8d569a7bf90a51638d41de6053f98e1a | zig

build.zig+1-18

...	@@ -125,7 +125,6 @@ pub fn build(b: *std.Build) !void {	...	@@ -125,7 +125,6 @@ pub fn build(b: *std.Build) !void {
125	const skip_darwin = b.option(bool, "skip-darwin", "Main test suite skips targets with darwin OSs") orelse false;	125	const skip_darwin = b.option(bool, "skip-darwin", "Main test suite skips targets with darwin OSs") orelse false;
126	const skip_linux = b.option(bool, "skip-linux", "Main test suite skips targets with linux OS") orelse false;	126	const skip_linux = b.option(bool, "skip-linux", "Main test suite skips targets with linux OS") orelse false;
127	const skip_llvm = b.option(bool, "skip-llvm", "Main test suite skips targets that use LLVM backend") orelse false;	127	const skip_llvm = b.option(bool, "skip-llvm", "Main test suite skips targets that use LLVM backend") orelse false;
128	const skip_test_incremental = b.option(bool, "skip-test-incremental", "Main test step omits dependency on test-incremental step") orelse false;
129		128
130	const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false;	129	const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false;
131		130
...	@@ -781,22 +780,6 @@ pub fn build(b: *std.Build) !void {	...	@@ -781,22 +780,6 @@ pub fn build(b: *std.Build) !void {
781	test_step.dependOn(check_oracle_step);	780	test_step.dependOn(check_oracle_step);
782	}	781	}
783		782
784	const test_incremental_step = b.step("test-incremental", "Run the incremental compilation test cases");
785	try tests.addIncrementalTests(b, test_incremental_step, .{
786	.test_filters = test_filters,
787	.test_target_filters = test_target_filters,
788	.skip_non_native = skip_non_native,
789	.skip_wasm = skip_wasm,
790	.skip_freebsd = skip_freebsd,
791	.skip_netbsd = skip_netbsd,
792	.skip_openbsd = skip_openbsd,
793	.skip_windows = skip_windows,
794	.skip_darwin = skip_darwin,
795	.skip_linux = skip_linux,
796	.skip_llvm = skip_llvm,
797	});
798	if (!skip_test_incremental) test_step.dependOn(test_incremental_step);
799
800	if (tests.addLibcTestNszTests(b, .{	783	if (tests.addLibcTestNszTests(b, .{
801	.optimize_modes = optimize_modes,	784	.optimize_modes = optimize_modes,
802	.test_filters = test_filters,	785	.test_filters = test_filters,
...	@@ -812,7 +795,7 @@ pub fn build(b: *std.Build) !void {	...	@@ -812,7 +795,7 @@ pub fn build(b: *std.Build) !void {
812	.target = b.graph.host,	795	.target = b.graph.host,
813	}),	796	}),
814	});	797	});
815	test_step.dependOn(try tests.addNewIncrementalTests(b, runner, .{	798	test_step.dependOn(try tests.addIncrementalTests(b, runner, .{
816	.test_filters = test_filters,	799	.test_filters = test_filters,
817	.test_target_filters = test_target_filters,	800	.test_target_filters = test_target_filters,
818	.skip_non_native = skip_non_native,	801	.skip_non_native = skip_non_native,

test/incremental/add_decl+45-18

 @@ -1,15 +1,21 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, foo);
 }
 const foo = "good morning\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="good morning\n"
+#}
+#update
+#check stdout {
+good morning
+#}
-#update=add new declaration
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, foo);
 @@ -17,10 +23,14 @@ pub fn main() !void {
 const foo = "good morning\n";
 const bar = "good evening\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="good morning\n"
+#}
+#update {
+add new declaration#}
+#check stdout {
+good morning
+#}
-#update=reference new declaration
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, bar);
 @@ -28,10 +38,14 @@ pub fn main() !void {
 const foo = "good morning\n";
 const bar = "good evening\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="good evening\n"
+#}
+#update {
+reference new declaration#}
+#check stdout {
+good evening
+#}
-#update=reference missing declaration
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, qux);
 @@ -39,10 +53,14 @@ pub fn main() !void {
 const foo = "good morning\n";
 const bar = "good evening\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:3:52: error: use of undeclared identifier 'qux'
+#}
+#update {
+reference missing declaration#}
+#check errors {
+main.zig:3:52: error: use of undeclared identifier 'qux'
+#}
-#update=add missing declaration
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, qux);
 @@ -51,14 +69,23 @@ const foo = "good morning\n";
 const bar = "good evening\n";
 const qux = "good night\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="good night\n"
+#}
+#update {
+add missing declaration#}
+#check stdout {
+good night
+#}
-#update=remove unused declarations
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, qux);
 }
 const qux = "good night\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="good night\n"
+#}
+#update {
+remove unused declarations#}
+#check stdout {
+good night
+#}

test/incremental/add_decl_namespaced+46-19

 @@ -1,15 +1,21 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @This().foo);
 }
 const foo = "good morning\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="good morning\n"
+#}
+#update
+#check stdout {
+good morning
+#}
-#update=add new declaration
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @This().foo);
 @@ -17,10 +23,14 @@ pub fn main() !void {
 const foo = "good morning\n";
 const bar = "good evening\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="good morning\n"
+#}
+#update {
+add new declaration#}
+#check stdout {
+good morning
+#}
-#update=reference new declaration
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @This().bar);
 @@ -28,10 +38,14 @@ pub fn main() !void {
 const foo = "good morning\n";
 const bar = "good evening\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="good evening\n"
+#}
+#update {
+reference new declaration#}
+#check stdout {
+good evening
+#}
-#update=reference missing declaration
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @This().qux);
 @@ -39,11 +53,15 @@ pub fn main() !void {
 const foo = "good morning\n";
 const bar = "good evening\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:3:59: error: root source file struct 'main' has no member named 'qux'
+#}
-#expect_error=main.zig:1:1: note: struct declared here
+#update {
+reference missing declaration#}
+#check errors {
+main.zig:3:59: error: root source file struct 'main' has no member named 'qux'
+main.zig:1:1: note: struct declared here
+#}
-#update=add missing declaration
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @This().qux);
 @@ -52,14 +70,23 @@ const foo = "good morning\n";
 const bar = "good evening\n";
 const qux = "good night\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="good night\n"
+#}
+#update {
+add missing declaration#}
+#check stdout {
+good night
+#}
-#update=remove unused declarations
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @This().qux);
 }
 const qux = "good night\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="good night\n"
+#}
+#update {
+remove unused declarations#}
+#check stdout {
+good night
+#}

test/incremental/add_field_and_nested_struct_uses_changed_decl+16-6

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() void {
     _ = @as(S, undefined);
 }
 @@ -9,9 +12,12 @@ const SomeType = u8;
 const S = struct {
     foo: struct { inner: SomeType },
 };
-#expect_stdout=""
+#}
-#update=add field to outer struct, change decl used by inner struct
+#update
-#file=main.zig
+#check stdout {
+#}
+#write main.zig {
 pub fn main() void {
     _ = @as(S, undefined);
 }
 @@ -22,4 +28,8 @@ const S = struct {
     foo: struct { inner: SomeType },
     bar: u32,
 };
-#expect_stdout=""
+#}
+#update {
+add field to outer struct, change decl used by inner struct#}
+#check stdout {
+#}

test/incremental/add_remove_struct_fields deleted-93

...	@@ -1,93 +0,0 @@
1	#update=initial version
2	#file=main.zig
3	const S = struct { x: u8 };
4	pub fn main(init: std.process.Init) !void {
5	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
6	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
7	error.WriteFailed => return stdout_writer.err.?,
8	};
9	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
10	error.WriteFailed => return stdout_writer.err.?,
11	};
12	}
13	fn printFieldCount(w: *Writer) Writer.Error!void {
14	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
15	}
16	fn printOneField(w: *Writer) Writer.Error!void {
17	const val: S = .{ .x = 100 };
18	try w.print("{d}\n", .{val.x});
19	}
20	const std = @import("std");
21	const Writer = std.Io.Writer;
22	#expect_stdout="1 100\n"
23
24	#update=add a field
25	#file=main.zig
26	const S = struct { x: u8, y: u16 = 200 };
27	pub fn main(init: std.process.Init) !void {
28	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
29	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
30	error.WriteFailed => return stdout_writer.err.?,
31	};
32	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
33	error.WriteFailed => return stdout_writer.err.?,
34	};
35	}
36	fn printFieldCount(w: *Writer) Writer.Error!void {
37	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
38	}
39	fn printOneField(w: *Writer) Writer.Error!void {
40	const val: S = .{ .x = 100 };
41	try w.print("{d}\n", .{val.x});
42	}
43	const std = @import("std");
44	const Writer = std.Io.Writer;
45	#expect_stdout="2 100\n"
46
47	#update=remove all fields
48	#file=main.zig
49	const S = struct {};
50	pub fn main(init: std.process.Init) !void {
51	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
52	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
53	error.WriteFailed => return stdout_writer.err.?,
54	};
55	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
56	error.WriteFailed => return stdout_writer.err.?,
57	};
58	}
59	fn printFieldCount(w: *Writer) Writer.Error!void {
60	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
61	}
62	fn printOneField(w: *Writer) Writer.Error!void {
63	const val: S = .{ .x = 100 };
64	try w.print("{d}\n", .{val.x});
65	}
66	const std = @import("std");
67	const Writer = std.Io.Writer;
68	#expect_error=main.zig:15:24: error: no field named 'x' in struct 'main.S'
69	#expect_error=main.zig:1:11: note: struct declared here
70
71	#update=remove reference to non-existent field
72	#file=main.zig
73	const S = struct {};
74	pub fn main(init: std.process.Init) !void {
75	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
76	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
77	error.WriteFailed => return stdout_writer.err.?,
78	};
79	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
80	error.WriteFailed => return stdout_writer.err.?,
81	};
82	}
83	fn printFieldCount(w: *Writer) Writer.Error!void {
84	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
85	}
86	fn printOneField(w: *Writer) Writer.Error!void {
87	//const val: S = .{ .x = 100 };
88	//try w.print("{d}\n", .{val.x});
89	try w.writeAll("<no fields>\n");
90	}
91	const std = @import("std");
92	const Writer = std.Io.Writer;
93	#expect_stdout="0 <no fields>\n"

test/incremental/add_remove_struct_fields/0/main.zig created+19

...	@@ -0,0 +1,19 @@
1	const S = struct { x: u8 };
2	pub fn main(init: std.process.Init) !void {
3	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
4	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
5	error.WriteFailed => return stdout_writer.err.?,
6	};
7	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
8	error.WriteFailed => return stdout_writer.err.?,
9	};
10	}
11	fn printFieldCount(w: *Writer) Writer.Error!void {
12	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
13	}
14	fn printOneField(w: *Writer) Writer.Error!void {
15	const val: S = .{ .x = 100 };
16	try w.print("{d}\n", .{val.x});
17	}
18	const std = @import("std");
19	const Writer = std.Io.Writer;

test/incremental/add_remove_struct_fields/1/main.zig created+19

...	@@ -0,0 +1,19 @@
1	const S = struct { x: u8, y: u16 = 200 };
2	pub fn main(init: std.process.Init) !void {
3	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
4	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
5	error.WriteFailed => return stdout_writer.err.?,
6	};
7	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
8	error.WriteFailed => return stdout_writer.err.?,
9	};
10	}
11	fn printFieldCount(w: *Writer) Writer.Error!void {
12	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
13	}
14	fn printOneField(w: *Writer) Writer.Error!void {
15	const val: S = .{ .x = 100 };
16	try w.print("{d}\n", .{val.x});
17	}
18	const std = @import("std");
19	const Writer = std.Io.Writer;

test/incremental/add_remove_struct_fields/2/main.zig created+19

...	@@ -0,0 +1,19 @@
1	const S = struct {};
2	pub fn main(init: std.process.Init) !void {
3	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
4	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
5	error.WriteFailed => return stdout_writer.err.?,
6	};
7	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
8	error.WriteFailed => return stdout_writer.err.?,
9	};
10	}
11	fn printFieldCount(w: *Writer) Writer.Error!void {
12	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
13	}
14	fn printOneField(w: *Writer) Writer.Error!void {
15	const val: S = .{ .x = 100 };
16	try w.print("{d}\n", .{val.x});
17	}
18	const std = @import("std");
19	const Writer = std.Io.Writer;

test/incremental/add_remove_struct_fields/3/main.zig created+20

...	@@ -0,0 +1,20 @@
1	const S = struct {};
2	pub fn main(init: std.process.Init) !void {
3	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
4	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
5	error.WriteFailed => return stdout_writer.err.?,
6	};
7	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
8	error.WriteFailed => return stdout_writer.err.?,
9	};
10	}
11	fn printFieldCount(w: *Writer) Writer.Error!void {
12	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
13	}
14	fn printOneField(w: *Writer) Writer.Error!void {
15	//const val: S = .{ .x = 100 };
16	//try w.print("{d}\n", .{val.x});
17	try w.writeAll("<no fields>\n");
18	}
19	const std = @import("std");
20	const Writer = std.Io.Writer;

test/incremental/add_remove_struct_fields/manifest created+31

...	@@ -0,0 +1,31 @@
1	#exe {
2	-Mroot=main.zig
3	#}
4
5	#write main.zig 0/main.zig
6	#update
7	#check stdout {
8	1 100
9	#}
10
11	#write main.zig 1/main.zig
12	#update {
13	add a field#}
14	#check stdout {
15	2 100
16	#}
17
18	#write main.zig 2/main.zig
19	#update {
20	remove all fields#}
21	#check errors {
22	main.zig:15:24: error: no field named 'x' in struct 'main.S'
23	main.zig:1:11: note: struct declared here
24	#}
25
26	#write main.zig 3/main.zig
27	#update {
28	remove reference to non-existent field#}
29	#check stdout {
30	0 <no fields>
31	#}

test/incremental/add_remove_toplevel_fields deleted-96

...	@@ -1,96 +0,0 @@
1	#update=initial version
2	#file=main.zig
3	const S = @This();
4	x: u8,
5	pub fn main(init: std.process.Init) !void {
6	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
7	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
8	error.WriteFailed => return stdout_writer.err.?,
9	};
10	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
11	error.WriteFailed => return stdout_writer.err.?,
12	};
13	}
14	fn printFieldCount(w: *Writer) Writer.Error!void {
15	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
16	}
17	fn printOneField(w: *Writer) Writer.Error!void {
18	const val: S = .{ .x = 100 };
19	try w.print("{d}\n", .{val.x});
20	}
21	const std = @import("std");
22	const Writer = std.Io.Writer;
23	#expect_stdout="1 100\n"
24
25	#update=add a field
26	#file=main.zig
27	const S = @This();
28	x: u8,
29	y: u16 = 200,
30	pub fn main(init: std.process.Init) !void {
31	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
32	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
33	error.WriteFailed => return stdout_writer.err.?,
34	};
35	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
36	error.WriteFailed => return stdout_writer.err.?,
37	};
38	}
39	fn printFieldCount(w: *Writer) Writer.Error!void {
40	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
41	}
42	fn printOneField(w: *Writer) Writer.Error!void {
43	const val: S = .{ .x = 100 };
44	try w.print("{d}\n", .{val.x});
45	}
46	const std = @import("std");
47	const Writer = std.Io.Writer;
48	#expect_stdout="2 100\n"
49
50	#update=remove all fields
51	#file=main.zig
52	const S = @This();
53	pub fn main(init: std.process.Init) !void {
54	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
55	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
56	error.WriteFailed => return stdout_writer.err.?,
57	};
58	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
59	error.WriteFailed => return stdout_writer.err.?,
60	};
61	}
62	fn printFieldCount(w: *Writer) Writer.Error!void {
63	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
64	}
65	fn printOneField(w: *Writer) Writer.Error!void {
66	const val: S = .{ .x = 100 };
67	try w.print("{d}\n", .{val.x});
68	}
69	const std = @import("std");
70	const Writer = std.Io.Writer;
71	#expect_error=main.zig:15:24: error: no field named 'x' in struct 'main'
72	#expect_error=main.zig:1:1: note: struct declared here
73
74	#update=remove reference to non-existent field
75	#file=main.zig
76	const S = @This();
77	pub fn main(init: std.process.Init) !void {
78	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
79	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
80	error.WriteFailed => return stdout_writer.err.?,
81	};
82	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
83	error.WriteFailed => return stdout_writer.err.?,
84	};
85	}
86	fn printFieldCount(w: *Writer) Writer.Error!void {
87	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
88	}
89	fn printOneField(w: *Writer) Writer.Error!void {
90	//const val: S = .{ .x = 100 };
91	//try w.print("{d}\n", .{val.x});
92	try w.writeAll("<no fields>\n");
93	}
94	const std = @import("std");
95	const Writer = std.Io.Writer;
96	#expect_stdout="0 <no fields>\n"

test/incremental/add_remove_toplevel_fields/0/main.zig created+20

...	@@ -0,0 +1,20 @@
1	const S = @This();
2	x: u8,
3	pub fn main(init: std.process.Init) !void {
4	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
5	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
6	error.WriteFailed => return stdout_writer.err.?,
7	};
8	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
9	error.WriteFailed => return stdout_writer.err.?,
10	};
11	}
12	fn printFieldCount(w: *Writer) Writer.Error!void {
13	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
14	}
15	fn printOneField(w: *Writer) Writer.Error!void {
16	const val: S = .{ .x = 100 };
17	try w.print("{d}\n", .{val.x});
18	}
19	const std = @import("std");
20	const Writer = std.Io.Writer;

test/incremental/add_remove_toplevel_fields/1/main.zig created+21

...	@@ -0,0 +1,21 @@
1	const S = @This();
2	x: u8,
3	y: u16 = 200,
4	pub fn main(init: std.process.Init) !void {
5	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
6	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
7	error.WriteFailed => return stdout_writer.err.?,
8	};
9	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
10	error.WriteFailed => return stdout_writer.err.?,
11	};
12	}
13	fn printFieldCount(w: *Writer) Writer.Error!void {
14	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
15	}
16	fn printOneField(w: *Writer) Writer.Error!void {
17	const val: S = .{ .x = 100 };
18	try w.print("{d}\n", .{val.x});
19	}
20	const std = @import("std");
21	const Writer = std.Io.Writer;

test/incremental/add_remove_toplevel_fields/2/main.zig created+19

...	@@ -0,0 +1,19 @@
1	const S = @This();
2	pub fn main(init: std.process.Init) !void {
3	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
4	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
5	error.WriteFailed => return stdout_writer.err.?,
6	};
7	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
8	error.WriteFailed => return stdout_writer.err.?,
9	};
10	}
11	fn printFieldCount(w: *Writer) Writer.Error!void {
12	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
13	}
14	fn printOneField(w: *Writer) Writer.Error!void {
15	const val: S = .{ .x = 100 };
16	try w.print("{d}\n", .{val.x});
17	}
18	const std = @import("std");
19	const Writer = std.Io.Writer;

test/incremental/add_remove_toplevel_fields/3/main.zig created+20

...	@@ -0,0 +1,20 @@
1	const S = @This();
2	pub fn main(init: std.process.Init) !void {
3	var stdout_writer = std.Io.File.stdout().writerStreaming(init.io, &.{});
4	printFieldCount(&stdout_writer.interface) catch \|err\| switch (err) {
5	error.WriteFailed => return stdout_writer.err.?,
6	};
7	printOneField(&stdout_writer.interface) catch \|err\| switch (err) {
8	error.WriteFailed => return stdout_writer.err.?,
9	};
10	}
11	fn printFieldCount(w: *Writer) Writer.Error!void {
12	try w.print("{d} ", .{@typeInfo(S).@"struct".field_names.len});
13	}
14	fn printOneField(w: *Writer) Writer.Error!void {
15	//const val: S = .{ .x = 100 };
16	//try w.print("{d}\n", .{val.x});
17	try w.writeAll("<no fields>\n");
18	}
19	const std = @import("std");
20	const Writer = std.Io.Writer;

test/incremental/add_remove_toplevel_fields/manifest created+31

...	@@ -0,0 +1,31 @@
1	#exe {
2	-Mroot=main.zig
3	#}
4
5	#write main.zig 0/main.zig
6	#update
7	#check stdout {
8	1 100
9	#}
10
11	#write main.zig 1/main.zig
12	#update {
13	add a field#}
14	#check stdout {
15	2 100
16	#}
17
18	#write main.zig 2/main.zig
19	#update {
20	remove all fields#}
21	#check errors {
22	main.zig:15:24: error: no field named 'x' in struct 'main'
23	main.zig:1:1: note: struct declared here
24	#}
25
26	#write main.zig 3/main.zig
27	#update {
28	remove reference to non-existent field#}
29	#check stdout {
30	0 <no fields>
31	#}

test/incremental/analysis_error_and_syntax_error+44-18

 @@ -1,38 +1,64 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() !void {
     @compileError("uh oh");
 }
-#expect_error=main.zig:2:5: error: uh oh
+#}
+#update
+#check errors {
+main.zig:2:5: error: uh oh
+#}
-#update=add parse error
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     @compileError("uh oh");
-#expect_error=main.zig:3:1: error: expected statement, found 'EOF'
+#}
+#update {
+add parse error#}
+#check errors {
+main.zig:3:1: error: expected statement, found 'EOF'
+#}
-#update=fix parse error
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     @compileError("uh oh");
 }
-#expect_error=main.zig:2:5: error: uh oh
+#}
+#update {
+fix parse error#}
+#check errors {
+main.zig:2:5: error: uh oh
+#}
-#update=add parse error again
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     @compileError("uh oh");
-#expect_error=main.zig:3:1: error: expected statement, found 'EOF'
+#}
+#update {
+add parse error again#}
+#check errors {
+main.zig:3:1: error: expected statement, found 'EOF'
+#}
-#update=comment @compileError call
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     //@compileError("uh oh");
-#expect_error=main.zig:3:1: error: expected statement, found 'EOF'
+#}
+#update {
+comment @compileError call#}
+#check errors {
+main.zig:3:1: error: expected statement, found 'EOF'
+#}
-#update=fix parse error again
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     //@compileError("uh oh");
 }
-#expect_stdout=""
+#}
+#update {
+fix parse error again#}
+#check stdout {
+#}

test/incremental/bad_import+28-12

 @@ -1,32 +1,48 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() !void {
     _ = @import("foo.zig");
     try std.Io.File.stdout().writeStreamingAll(io, "success\n");
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#file=foo.zig
+#}
+#write foo.zig {
 comptime {
     _ = @import("bad.zig");
 }
-#expect_error=bad.zig:1:1: error: unable to load "bad.zig": FileNotFound
+#}
-#expect_error=foo.zig:2:17: note: file imported here
+#update
+#check errors {
+bad.zig:1:1: error: unable to load "bad.zig": FileNotFound
+foo.zig:2:17: note: file imported here
+#}
-#update=change bad import
+#write foo.zig {
-#file=foo.zig
 comptime {
     _ = @import("this_is/not_real.zig");
 }
-#expect_error=this_is/not_real.zig:1:1: error: unable to load "not_real.zig": FileNotFound
+#}
-#expect_error=foo.zig:2:17: note: file imported here
+#update {
+change bad import#}
+#check errors {
+this_is/not_real.zig:1:1: error: unable to load "not_real.zig": FileNotFound
+foo.zig:2:17: note: file imported here
+#}
-#update=remove import of 'foo.zig'
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     //_ = @import("foo.zig");
     try std.Io.File.stdout().writeStreamingAll(io, "success\n");
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="success\n"
+#}
+#update {
+remove import of 'foo.zig'#}
+#check stdout {
+success
+#}

test/incremental/change_bitpack_backing_int+53-30

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const Foo = packed struct(u8) { a: u4, b: i4 };
 const Bar = packed union(u10) { a: u10, b: i10 };
 pub fn main() void {}
 @@ -11,13 +14,18 @@ comptime {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:5:5: error: found compile log statement
+#}
-#expect_error=main.zig:8:5: note: also here
+#update
-#expect_compile_log=@as(type, u8)
+#check errors {
-#expect_compile_log=@as(comptime_int, 10)
+main.zig:5:5: error: found compile log statement
+main.zig:8:5: note: also here
+Compile Log Output:
+@as(type, u8)
+@as(comptime_int, 10)
+#}
-#update=make backing types signed
+#write main.zig {
-#file=main.zig
 const Foo = packed struct(i8) { a: u4, b: i4 };
 const Bar = packed union(i10) { a: u10, b: i10 };
 pub fn main() void {}
 @@ -29,13 +37,19 @@ comptime {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:5:5: error: found compile log statement
+#}
-#expect_error=main.zig:8:5: note: also here
+#update {
-#expect_compile_log=@as(type, i8)
+make backing types signed#}
-#expect_compile_log=@as(comptime_int, 10)
+#check errors {
+main.zig:5:5: error: found compile log statement
+main.zig:8:5: note: also here
+Compile Log Output:
+@as(type, i8)
+@as(comptime_int, 10)
+#}
-#update=make backing types too small
+#write main.zig {
-#file=main.zig
 const Foo = packed struct(i5) { a: u4, b: i4 };
 const Bar = packed union(i8) { a: u10, b: i10 };
 pub fn main() void {}
 @@ -47,16 +61,20 @@ comptime {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:1:20: error: backing integer bit width does not match total bit width of fields
+#}
-#expect_error=main.zig:1:27: note: backing integer 'i5' has bit width '5'
+#update {
-#expect_error=main.zig:1:20: note: struct fields have total bit width '8'
+make backing types too small#}
-#expect_error=main.zig:2:35: error: field bit width does not match backing integer
+#check errors {
-#expect_error=main.zig:2:35: note: field type 'u10' has bit width '10'
+main.zig:1:20: error: backing integer bit width does not match total bit width of fields
-#expect_error=main.zig:2:26: note: backing integer 'i8' has bit width '8'
+main.zig:1:27: note: backing integer 'i5' has bit width '5'
-#expect_error=main.zig:2:35: note: all fields in a packed union must have the same bit width
+main.zig:1:20: note: struct fields have total bit width '8'
+main.zig:2:35: error: field bit width does not match backing integer
+main.zig:2:35: note: field type 'u10' has bit width '10'
+main.zig:2:26: note: backing integer 'i8' has bit width '8'
+main.zig:2:35: note: all fields in a packed union must have the same bit width
+#}
-#update=make backing types too big
+#write main.zig {
-#file=main.zig
 const Foo = packed struct(u10) { a: u4, b: i4 };
 const Bar = packed union(u32) { a: u10, b: i10 };
 pub fn main() void {}
 @@ -68,10 +86,15 @@ comptime {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:1:20: error: backing integer bit width does not match total bit width of fields
+#}
-#expect_error=main.zig:1:27: note: backing integer 'u10' has bit width '10'
+#update {
-#expect_error=main.zig:1:20: note: struct fields have total bit width '8'
+make backing types too big#}
-#expect_error=main.zig:2:36: error: field bit width does not match backing integer
+#check errors {
-#expect_error=main.zig:2:36: note: field type 'u10' has bit width '10'
+main.zig:1:20: error: backing integer bit width does not match total bit width of fields
-#expect_error=main.zig:2:26: note: backing integer 'u32' has bit width '32'
+main.zig:1:27: note: backing integer 'u10' has bit width '10'
-#expect_error=main.zig:2:36: note: all fields in a packed union must have the same bit width
+main.zig:1:20: note: struct fields have total bit width '8'
+main.zig:2:36: error: field bit width does not match backing integer
+main.zig:2:36: note: field type 'u10' has bit width '10'
+main.zig:2:26: note: backing integer 'u32' has bit width '32'
+main.zig:2:36: note: all fields in a packed union must have the same bit width
+#}

test/incremental/change_container_kind+94-41

 @@ -1,61 +1,114 @@
-#update=initial version, T is struct
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const T = @import("foo.zig").T;
 pub fn main() void {
     @compileLog(T);
     @compileLog(@tagName(@typeInfo(T)));
 }
-#file=foo.zig
+#}
+#write foo.zig {
 pub const T = struct { x: u8 };
-#expect_error=main.zig:3:5: error: found compile log statement
+#}
-#expect_compile_log=@as(type, foo.T)
+#update {
-#expect_compile_log=@as(*const [6:0]u8, "struct")
+T is struct#}
+#check errors {
+main.zig:3:5: error: found compile log statement
+Compile Log Output:
+@as(type, foo.T)
+@as(*const [6:0]u8, "struct")
+#}
-#update=T is union
+#write foo.zig {
-#file=foo.zig
 pub const T = union {};
-#expect_error=main.zig:3:5: error: found compile log statement
+#}
-#expect_compile_log=@as(type, foo.T)
+#update {
-#expect_compile_log=@as(*const [5:0]u8, "union")
+T is union#}
+#check errors {
+main.zig:3:5: error: found compile log statement
+Compile Log Output:
+@as(type, foo.T)
+@as(*const [5:0]u8, "union")
+#}
-#update=T is enum
+#write foo.zig {
-#file=foo.zig
 pub const T = enum {};
-#expect_error=main.zig:3:5: error: found compile log statement
+#}
-#expect_compile_log=@as(type, foo.T)
+#update {
-#expect_compile_log=@as(*const [4:0]u8, "enum")
+T is enum#}
+#check errors {
+main.zig:3:5: error: found compile log statement
-#update=T is opaque
+Compile Log Output:
-#file=foo.zig
+@as(type, foo.T)
+@as(*const [4:0]u8, "enum")
+#}
+#write foo.zig {
 pub const T = opaque {};
-#expect_error=main.zig:3:5: error: found compile log statement
+#}
-#expect_compile_log=@as(type, foo.T)
+#update {
-#expect_compile_log=@as(*const [6:0]u8, "opaque")
+T is opaque#}
+#check errors {
+main.zig:3:5: error: found compile log statement
+Compile Log Output:
+@as(type, foo.T)
+@as(*const [6:0]u8, "opaque")
+#}
-#update=T is packed struct
+#write foo.zig {
-#file=foo.zig
 pub const T = packed struct {};
-#expect_error=main.zig:3:5: error: found compile log statement
+#}
-#expect_compile_log=@as(type, foo.T)
+#update {
-#expect_compile_log=@as(*const [6:0]u8, "struct")
+T is packed struct#}
+#check errors {
+main.zig:3:5: error: found compile log statement
-#update=T is packed union
+Compile Log Output:
-#file=foo.zig
+@as(type, foo.T)
+@as(*const [6:0]u8, "struct")
+#}
+#write foo.zig {
 pub const T = packed union { x: void }; // packed unions need at least 1 field
-#expect_error=main.zig:3:5: error: found compile log statement
+#}
-#expect_compile_log=@as(type, foo.T)
+#update {
-#expect_compile_log=@as(*const [5:0]u8, "union")
+T is packed union#}
+#check errors {
+main.zig:3:5: error: found compile log statement
+Compile Log Output:
+@as(type, foo.T)
+@as(*const [5:0]u8, "union")
+#}
-#update=T is extern struct
+#write foo.zig {
-#file=foo.zig
 pub const T = extern struct {};
-#expect_error=main.zig:3:5: error: found compile log statement
+#}
-#expect_compile_log=@as(type, foo.T)
+#update {
-#expect_compile_log=@as(*const [6:0]u8, "struct")
+T is extern struct#}
+#check errors {
+main.zig:3:5: error: found compile log statement
-#update=T is extern union
+Compile Log Output:
-#file=foo.zig
+@as(type, foo.T)
+@as(*const [6:0]u8, "struct")
+#}
+#write foo.zig {
 pub const T = extern union { x: void }; // extern unions need at least 1 field
-#expect_error=main.zig:3:5: error: found compile log statement
+#}
-#expect_compile_log=@as(type, foo.T)
+#update {
-#expect_compile_log=@as(*const [5:0]u8, "union")
+T is extern union#}
+#check errors {
+main.zig:3:5: error: found compile log statement
+Compile Log Output:
+@as(type, foo.T)
+@as(*const [5:0]u8, "union")
+#}

test/incremental/change_embed_file+46-19

 @@ -1,45 +1,72 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 const string = @embedFile("string.txt");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, string);
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#file=string.txt
+#}
+#write string.txt {
+Hello, World!
+#}
+#update
+#check stdout {
 Hello, World!
-#expect_stdout="Hello, World!\n"
+#}
-#update=change file contents
+#write string.txt {
-#file=string.txt
 Hello again, World!
-#expect_stdout="Hello again, World!\n"
+#}
+#update {
+change file contents#}
+#check stdout {
+Hello again, World!
+#}
-#update=delete file
+#delete string.txt
-#rm_file=string.txt
+#update {
-#expect_error=main.zig:2:27: error: failed opening "string.txt": FileNotFound
+delete file#}
+#check errors {
+main.zig:2:27: error: failed opening "string.txt": FileNotFound
+#}
-#update=remove reference to file
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 const string = @embedFile("string.txt");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "a hardcoded string\n");
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="a hardcoded string\n"
+#}
+#update {
+remove reference to file#}
+#check stdout {
+a hardcoded string
+#}
-#update=re-introduce reference to file
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 const string = @embedFile("string.txt");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, string);
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:2:27: error: failed opening "string.txt": FileNotFound
+#}
+#update {
+re-introduce reference to file#}
+#check errors {
+main.zig:2:27: error: failed opening "string.txt": FileNotFound
+#}
-#update=recreate file
+#write string.txt {
-#file=string.txt
+We're back, World!
+#}
+#update {
+recreate file#}
+#check stdout {
 We're back, World!
-#expect_stdout="We're back, World!\n"
+#}

test/incremental/change_enum_tag_type deleted-93

...	@@ -1,93 +0,0 @@
1	#update=initial version
2	#file=main.zig
3	const Tag = u2;
4	const Foo = enum(Tag) {
5	a,
6	b,
7	c,
8	d,
9	};
10	pub fn main() !void {
11	var val: Foo = undefined;
12	val = .a;
13	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
14	try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
15	}
16	const std = @import("std");
17	const io = std.Io.Threaded.global_single_threaded.io();
18	#expect_stdout="a\n"
19	#update=too many enum fields
20	#file=main.zig
21	const Tag = u2;
22	const Foo = enum(Tag) {
23	a,
24	b,
25	c,
26	d,
27	e,
28	};
29	pub fn main() !void {
30	var val: Foo = undefined;
31	val = .a;
32	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
33	try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
34	}
35	comptime {
36	// These can't be true at the same time; analysis should stop as soon as it sees `Foo`
37	std.debug.assert(@intFromEnum(Foo.e) == 4);
38	std.debug.assert(@TypeOf(@intFromEnum(Foo.e)) == Tag);
39	}
40	const std = @import("std");
41	const io = std.Io.Threaded.global_single_threaded.io();
42	#expect_error=main.zig:7:5: error: enum tag value '4' too large for type 'u2'
43	#update=increase tag size
44	#file=main.zig
45	const Tag = u3;
46	const Foo = enum(Tag) {
47	a,
48	b,
49	c,
50	d,
51	e,
52	};
53	pub fn main() !void {
54	var val: Foo = undefined;
55	val = .a;
56	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
57	try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
58	}
59	const std = @import("std");
60	const io = std.Io.Threaded.global_single_threaded.io();
61	#expect_stdout="a\n"
62	#update=specify tag directly
63	#file=main.zig
64	const Foo = enum(u3) {
65	a,
66	b,
67	c,
68	d,
69	e,
70	};
71	pub fn main() !void {
72	@compileLog(@typeInfo(Foo).@"enum".tag_type);
73	}
74	const std = @import("std");
75	const io = std.Io.Threaded.global_single_threaded.io();
76	#expect_error=main.zig:9:5: error: found compile log statement
77	#expect_compile_log=@as(type, u3)
78	#update=change directly-specified tag type
79	#file=main.zig
80	const Foo = enum(u8) {
81	a,
82	b,
83	c,
84	d,
85	e,
86	};
87	pub fn main() !void {
88	@compileLog(@typeInfo(Foo).@"enum".tag_type);
89	}
90	const std = @import("std");
91	const io = std.Io.Threaded.global_single_threaded.io();
92	#expect_error=main.zig:9:5: error: found compile log statement
93	#expect_compile_log=@as(type, u8)

test/incremental/change_enum_tag_type/0/main.zig created+15

...	@@ -0,0 +1,15 @@
1	const Tag = u2;
2	const Foo = enum(Tag) {
3	a,
4	b,
5	c,
6	d,
7	};
8	pub fn main() !void {
9	var val: Foo = undefined;
10	val = .a;
11	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
12	try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
13	}
14	const std = @import("std");
15	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_enum_tag_type/1/main.zig created+21

...	@@ -0,0 +1,21 @@
1	const Tag = u2;
2	const Foo = enum(Tag) {
3	a,
4	b,
5	c,
6	d,
7	e,
8	};
9	pub fn main() !void {
10	var val: Foo = undefined;
11	val = .a;
12	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
13	try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
14	}
15	comptime {
16	// These can't be true at the same time; analysis should stop as soon as it sees `Foo`
17	std.debug.assert(@backingInt(Foo.e) == 4);
18	std.debug.assert(@TypeOf(@backingInt(Foo.e)) == Tag);
19	}
20	const std = @import("std");
21	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_enum_tag_type/2/main.zig created+16

...	@@ -0,0 +1,16 @@
1	const Tag = u3;
2	const Foo = enum(Tag) {
3	a,
4	b,
5	c,
6	d,
7	e,
8	};
9	pub fn main() !void {
10	var val: Foo = undefined;
11	val = .a;
12	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
13	try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
14	}
15	const std = @import("std");
16	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_enum_tag_type/3/main.zig created+12

...	@@ -0,0 +1,12 @@
1	const Foo = enum(u3) {
2	a,
3	b,
4	c,
5	d,
6	e,
7	};
8	pub fn main() !void {
9	@compileLog(@typeInfo(Foo).@"enum".tag_type);
10	}
11	const std = @import("std");
12	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_enum_tag_type/4/main.zig created+12

...	@@ -0,0 +1,12 @@
1	const Foo = enum(u8) {
2	a,
3	b,
4	c,
5	d,
6	e,
7	};
8	pub fn main() !void {
9	@compileLog(@typeInfo(Foo).@"enum".tag_type);
10	}
11	const std = @import("std");
12	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_enum_tag_type/manifest created+43

...	@@ -0,0 +1,43 @@
1	#exe {
2	-Mroot=main.zig
3	#}
4
5	#write main.zig 0/main.zig
6	#update
7	#check stdout {
8	a
9	#}
10
11	#write main.zig 1/main.zig
12	#update {
13	too many enum fields#}
14	#check errors {
15	main.zig:7:5: error: enum tag value '4' too large for type 'u2'
16	#}
17
18	#write main.zig 2/main.zig
19	#update {
20	increase tag size#}
21	#check stdout {
22	a
23	#}
24
25	#write main.zig 3/main.zig
26	#update {
27	specify tag directly#}
28	#check errors {
29	main.zig:9:5: error: found compile log statement
30
31	Compile Log Output:
32	@as(type, u3)
33	#}
34
35	#write main.zig 4/main.zig
36	#update {
37	change directly-specified tag type#}
38	#check errors {
39	main.zig:9:5: error: found compile log statement
40
41	Compile Log Output:
42	@as(type, u8)
43	#}

test/incremental/change_exports deleted-169

...	@@ -1,169 +0,0 @@
1	#update=initial version
2	#file=main.zig
3	export fn foo() void {}
4	const bar: u32 = 123;
5	const other: u32 = 456;
6	comptime {
7	@export(&bar, .{ .name = "bar" });
8	}
9	pub fn main() !void {
10	const S = struct {
11	extern fn foo() void;
12	extern const bar: u32;
13	};
14	S.foo();
15	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
16	try stdout_writer.interface.print("{}\n", .{S.bar});
17	}
18	const std = @import("std");
19	const io = std.Io.Threaded.global_single_threaded.io();
20	#expect_stdout="123\n"
21
22	#update=add conflict
23	#file=main.zig
24	export fn foo() void {}
25	const bar: u32 = 123;
26	const other: u32 = 456;
27	comptime {
28	@export(&bar, .{ .name = "bar" });
29	@export(&other, .{ .name = "foo" });
30	}
31	pub fn main() !void {
32	const S = struct {
33	extern fn foo() void;
34	extern const bar: u32;
35	extern const other: u32;
36	};
37	S.foo();
38	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
39	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
40	}
41	const std = @import("std");
42	const io = std.Io.Threaded.global_single_threaded.io();
43	#expect_error=main.zig:6:5: error: exported symbol collision: foo
44	#expect_error=main.zig:1:1: note: other symbol here
45
46	#update=resolve conflict
47	#file=main.zig
48	export fn foo() void {}
49	const bar: u32 = 123;
50	const other: u32 = 456;
51	comptime {
52	@export(&bar, .{ .name = "bar" });
53	@export(&other, .{ .name = "other" });
54	}
55	pub fn main() !void {
56	const S = struct {
57	extern fn foo() void;
58	extern const bar: u32;
59	extern const other: u32;
60	};
61	S.foo();
62	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
63	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
64	}
65	const std = @import("std");
66	const io = std.Io.Threaded.global_single_threaded.io();
67	#expect_stdout="123 456\n"
68
69	#update=put exports in decl
70	#file=main.zig
71	export fn foo() void {}
72	const bar: u32 = 123;
73	const other: u32 = 456;
74	const does_exports = {
75	@export(&bar, .{ .name = "bar" });
76	@export(&other, .{ .name = "other" });
77	};
78	comptime {
79	_ = does_exports;
80	}
81	pub fn main() !void {
82	const S = struct {
83	extern fn foo() void;
84	extern const bar: u32;
85	extern const other: u32;
86	};
87	S.foo();
88	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
89	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
90	}
91	const std = @import("std");
92	const io = std.Io.Threaded.global_single_threaded.io();
93	#expect_stdout="123 456\n"
94
95	#update=remove reference to exporting decl
96	#file=main.zig
97	export fn foo() void {}
98	const bar: u32 = 123;
99	const other: u32 = 456;
100	const does_exports = {
101	@export(&bar, .{ .name = "bar" });
102	@export(&other, .{ .name = "other" });
103	};
104	comptime {
105	//_ = does_exports;
106	}
107	pub fn main() !void {
108	const S = struct {
109	extern fn foo() void;
110	};
111	S.foo();
112	}
113	const std = @import("std");
114	#expect_stdout=""
115
116	#update=mark consts as export
117	#file=main.zig
118	export fn foo() void {}
119	export const bar: u32 = 123;
120	export const other: u32 = 456;
121	const does_exports = {
122	@export(&bar, .{ .name = "bar" });
123	@export(&other, .{ .name = "other" });
124	};
125	comptime {
126	//_ = does_exports;
127	}
128	pub fn main() !void {
129	const S = struct {
130	extern fn foo() void;
131	extern const bar: u32;
132	extern const other: u32;
133	};
134	S.foo();
135	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
136	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
137	}
138	const std = @import("std");
139	const io = std.Io.Threaded.global_single_threaded.io();
140	#expect_stdout="123 456\n"
141
142	#update=reintroduce reference to exporting decl, introducing conflict
143	#file=main.zig
144	export fn foo() void {}
145	export const bar: u32 = 123;
146	export const other: u32 = 456;
147	const does_exports = {
148	@export(&bar, .{ .name = "bar" });
149	@export(&other, .{ .name = "other" });
150	};
151	comptime {
152	_ = does_exports;
153	}
154	pub fn main() !void {
155	const S = struct {
156	extern fn foo() void;
157	extern const bar: u32;
158	extern const other: u32;
159	};
160	S.foo();
161	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
162	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
163	}
164	const std = @import("std");
165	const io = std.Io.Threaded.global_single_threaded.io();
166	#expect_error=main.zig:5:5: error: exported symbol collision: bar
167	#expect_error=main.zig:2:1: note: other symbol here
168	#expect_error=main.zig:6:5: error: exported symbol collision: other
169	#expect_error=main.zig:3:1: note: other symbol here

test/incremental/change_exports/0/main.zig created+17

...	@@ -0,0 +1,17 @@
1	export fn foo() void {}
2	const bar: u32 = 123;
3	const other: u32 = 456;
4	comptime {
5	@export(&bar, .{ .name = "bar" });
6	}
7	pub fn main() !void {
8	const S = struct {
9	extern fn foo() void;
10	extern const bar: u32;
11	};
12	S.foo();
13	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
14	try stdout_writer.interface.print("{}\n", .{S.bar});
15	}
16	const std = @import("std");
17	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_exports/1/main.zig created+19

...	@@ -0,0 +1,19 @@
1	export fn foo() void {}
2	const bar: u32 = 123;
3	const other: u32 = 456;
4	comptime {
5	@export(&bar, .{ .name = "bar" });
6	@export(&other, .{ .name = "foo" });
7	}
8	pub fn main() !void {
9	const S = struct {
10	extern fn foo() void;
11	extern const bar: u32;
12	extern const other: u32;
13	};
14	S.foo();
15	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
16	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
17	}
18	const std = @import("std");
19	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_exports/2/main.zig created+19

...	@@ -0,0 +1,19 @@
1	export fn foo() void {}
2	const bar: u32 = 123;
3	const other: u32 = 456;
4	comptime {
5	@export(&bar, .{ .name = "bar" });
6	@export(&other, .{ .name = "other" });
7	}
8	pub fn main() !void {
9	const S = struct {
10	extern fn foo() void;
11	extern const bar: u32;
12	extern const other: u32;
13	};
14	S.foo();
15	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
16	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
17	}
18	const std = @import("std");
19	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_exports/3/main.zig created+22

...	@@ -0,0 +1,22 @@
1	export fn foo() void {}
2	const bar: u32 = 123;
3	const other: u32 = 456;
4	const does_exports = {
5	@export(&bar, .{ .name = "bar" });
6	@export(&other, .{ .name = "other" });
7	};
8	comptime {
9	_ = does_exports;
10	}
11	pub fn main() !void {
12	const S = struct {
13	extern fn foo() void;
14	extern const bar: u32;
15	extern const other: u32;
16	};
17	S.foo();
18	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
19	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
20	}
21	const std = @import("std");
22	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_exports/4/main.zig created+17

...	@@ -0,0 +1,17 @@
1	export fn foo() void {}
2	const bar: u32 = 123;
3	const other: u32 = 456;
4	const does_exports = {
5	@export(&bar, .{ .name = "bar" });
6	@export(&other, .{ .name = "other" });
7	};
8	comptime {
9	//_ = does_exports;
10	}
11	pub fn main() !void {
12	const S = struct {
13	extern fn foo() void;
14	};
15	S.foo();
16	}
17	const std = @import("std");

test/incremental/change_exports/5/main.zig created+22

...	@@ -0,0 +1,22 @@
1	export fn foo() void {}
2	export const bar: u32 = 123;
3	export const other: u32 = 456;
4	const does_exports = {
5	@export(&bar, .{ .name = "bar" });
6	@export(&other, .{ .name = "other" });
7	};
8	comptime {
9	//_ = does_exports;
10	}
11	pub fn main() !void {
12	const S = struct {
13	extern fn foo() void;
14	extern const bar: u32;
15	extern const other: u32;
16	};
17	S.foo();
18	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
19	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
20	}
21	const std = @import("std");
22	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_exports/6/main.zig created+22

...	@@ -0,0 +1,22 @@
1	export fn foo() void {}
2	export const bar: u32 = 123;
3	export const other: u32 = 456;
4	const does_exports = {
5	@export(&bar, .{ .name = "bar" });
6	@export(&other, .{ .name = "other" });
7	};
8	comptime {
9	_ = does_exports;
10	}
11	pub fn main() !void {
12	const S = struct {
13	extern fn foo() void;
14	extern const bar: u32;
15	extern const other: u32;
16	};
17	S.foo();
18	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
19	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
20	}
21	const std = @import("std");
22	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_exports/manifest created+54

...	@@ -0,0 +1,54 @@
1	#exe {
2	-Mroot=main.zig
3	#}
4
5	#write main.zig 0/main.zig
6	#update
7	#check stdout {
8	123
9	#}
10
11	#write main.zig 1/main.zig
12	#update {
13	add conflict#}
14	#check errors {
15	main.zig:6:5: error: exported symbol collision: foo
16	main.zig:1:1: note: other symbol here
17	#}
18
19	#write main.zig 2/main.zig
20	#update {
21	resolve conflict#}
22	#check stdout {
23	123 456
24	#}
25
26	#write main.zig 3/main.zig
27	#update {
28	put exports in decl#}
29	#check stdout {
30	123 456
31	#}
32
33	#write main.zig 4/main.zig
34	#update {
35	remove reference to exporting decl#}
36	#check stdout {
37	#}
38
39	#write main.zig 5/main.zig
40	#update {
41	mark consts as export#}
42	#check stdout {
43	123 456
44	#}
45
46	#write main.zig 6/main.zig
47	#update {
48	reintroduce reference to exporting decl, introducing conflict#}
49	#check errors {
50	main.zig:5:5: error: exported symbol collision: bar
51	main.zig:2:1: note: other symbol here
52	main.zig:6:5: error: exported symbol collision: other
53	main.zig:3:1: note: other symbol here
54	#}

test/incremental/change_fn_type+24-9

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() !void {
     try foo(123);
 }
 @@ -9,10 +12,13 @@ fn foo(x: u8) !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="123\n"
+#}
+#update
+#check stdout {
+123
+#}
-#update=change function type
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     try foo(123);
 }
 @@ -22,10 +28,14 @@ fn foo(x: i64) !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="123\n"
+#}
+#update {
+change function type#}
+#check stdout {
+123
+#}
-#update=change function argument
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     try foo(-42);
 }
 @@ -35,4 +45,9 @@ fn foo(x: i64) !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="-42\n"
+#}
+#update {
+change function argument#}
+#check stdout {
+-42
+#}

test/incremental/change_generic_line_number+20-6

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
 fn Printer(message: []const u8) type {
 @@ -13,9 +16,14 @@ pub fn main() !void {
     try Printer("foo\n").print();
     try Printer("bar\n").print();
 }
-#expect_stdout="foo\nbar\n"
+#}
-#update=change line number
+#update
-#file=main.zig
+#check stdout {
+foo
+bar
+#}
+#write main.zig {
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
 @@ -30,4 +38,10 @@ pub fn main() !void {
     try Printer("foo\n").print();
     try Printer("bar\n").print();
 }
-#expect_stdout="foo\nbar\n"
+#}
+#update {
+change line number#}
+#check stdout {
+foo
+bar
+#}

test/incremental/change_line_number+18-6

 @@ -1,17 +1,29 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "foo\n");
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="foo\n"
+#}
-#update=change line number
+#update
-#file=main.zig
+#check stdout {
+foo
+#}
+#write main.zig {
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "foo\n");
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="foo\n"
+#}
+#update {
+change line number#}
+#check stdout {
+foo
+#}

test/incremental/change_module+49-23

 @@ -1,61 +1,87 @@
-#module=foo=foo.zig
+#exe {
+--dep foo -Mroot=main.zig
+-Mfoo=foo.zig
+#}
-#update=initial version
+#write main.zig {
-#file=main.zig
 pub fn main() void {
     _ = @import("foo");
     //_ = @import("other.zig");
 }
-#file=foo.zig
+#}
+#write foo.zig {
 comptime {
     _ = @import("other.zig");
 }
-#file=other.zig
+#}
+#write other.zig {
 fn f() void {
     @compileLog(@src().module);
 }
 comptime {
     f();
 }
-#expect_error=other.zig:2:5: error: found compile log statement
+#}
-#expect_compile_log=@as([:0]const u8, "foo"[0..3])
+#update
+#check errors {
+other.zig:2:5: error: found compile log statement
-#update=change module of other.zig
+Compile Log Output:
-#file=main.zig
+@as([:0]const u8, "foo"[0..3])
+#}
+#write main.zig {
 pub fn main() void {
     _ = @import("foo");
     _ = @import("other.zig");
 }
-#file=foo.zig
+#}
+#write foo.zig {
 comptime {
     //_ = @import("other.zig");
 }
-#expect_error=other.zig:2:5: error: found compile log statement
+#}
-#expect_compile_log=@as([:0]const u8, "root"[0..4])
+#update {
+change module of other.zig#}
+#check errors {
+other.zig:2:5: error: found compile log statement
+Compile Log Output:
+@as([:0]const u8, "root"[0..4])
+#}
-#update=put other.zig in both modules
+#write main.zig {
-#file=main.zig
 pub fn main() void {
     _ = @import("foo");
     _ = @import("other.zig");
 }
-#file=foo.zig
+#}
+#write foo.zig {
 comptime {
     _ = @import("other.zig");
 }
-#expect_error=other.zig:1:1: error: file exists in modules 'root' and 'foo'
+#}
-#expect_error=other.zig:1:1: note: files must belong to only one module
+#update {
-#expect_error=main.zig:3:17: note: file is imported here by the root of module 'root'
+put other.zig in both modules#}
-#expect_error=foo.zig:2:17: note: file is imported here by the root of module 'foo'
+#check errors {
+other.zig:1:1: error: file exists in modules 'root' and 'foo'
+other.zig:1:1: note: files must belong to only one module
+main.zig:3:17: note: file is imported here by the root of module 'root'
+foo.zig:2:17: note: file is imported here by the root of module 'foo'
+#}
-#update=put other.zig in no modules
+#write main.zig {
-#file=main.zig
 pub fn main() void {
     _ = @import("foo");
     //_ = @import("other.zig");
 }
-#file=foo.zig
+#}
+#write foo.zig {
 comptime {
     //_ = @import("other.zig");
 }
-#expect_stdout=""
+#}
+#update {
+put other.zig in no modules#}
+#check stdout {
+#}

test/incremental/change_panic_handler+24-9

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() !u8 {
     var a: u8 = undefined;
     a = 255;
 @@ -14,10 +17,13 @@ fn myPanic(msg: []const u8, _: ?usize) noreturn {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="panic message: integer overflow\n"
+#}
+#update
+#check stdout {
+panic message: integer overflow
+#}
-#update=change the panic handler body
+#write main.zig {
-#file=main.zig
 pub fn main() !u8 {
     var a: u8 = undefined;
     a = 255;
 @@ -32,10 +38,14 @@ fn myPanic(msg: []const u8, _: ?usize) noreturn {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="new panic message: integer overflow\n"
+#}
+#update {
+change the panic handler body#}
+#check stdout {
+new panic message: integer overflow
+#}
-#update=change the panic handler function value
+#write main.zig {
-#file=main.zig
 pub fn main() !u8 {
     var a: u8 = undefined;
     a = 255;
 @@ -50,4 +60,9 @@ fn myPanicNew(msg: []const u8, _: ?usize) noreturn {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="third panic message: integer overflow\n"
+#}
+#update {
+change the panic handler function value#}
+#check stdout {
+third panic message: integer overflow
+#}

test/incremental/change_panic_handler_explicit deleted-149

...	@@ -1,149 +0,0 @@
1	#update=initial version
2	#file=main.zig
3	pub fn main() !u8 {
4	var a: u8 = undefined;
5	a = 255;
6	_ = a + 1;
7	return 1;
8	}
9	const no_panic = std.debug.no_panic;
10	pub const panic = struct {
11	pub const call = myPanic;
12	pub fn integerOverflow() noreturn {
13	@panic("integer overflow");
14	}
15	pub const sentinelMismatch = no_panic.sentinelMismatch;
16	pub const unwrapError = no_panic.unwrapError;
17	pub const outOfBounds = no_panic.outOfBounds;
18	pub const startGreaterThanEnd = no_panic.startGreaterThanEnd;
19	pub const inactiveUnionField = no_panic.inactiveUnionField;
20	pub const sliceCastLenRemainder = no_panic.sliceCastLenRemainder;
21	pub const reachedUnreachable = no_panic.reachedUnreachable;
22	pub const unwrapNull = no_panic.unwrapNull;
23	pub const castToNull = no_panic.castToNull;
24	pub const incorrectAlignment = no_panic.incorrectAlignment;
25	pub const invalidErrorCode = no_panic.invalidErrorCode;
26	pub const unexpectedErrorCode = no_panic.unexpectedErrorCode;
27	pub const integerOutOfBounds = no_panic.integerOutOfBounds;
28	pub const shlOverflow = no_panic.shlOverflow;
29	pub const shrOverflow = no_panic.shrOverflow;
30	pub const divideByZero = no_panic.divideByZero;
31	pub const exactDivisionRemainder = no_panic.exactDivisionRemainder;
32	pub const integerPartOutOfBounds = no_panic.integerPartOutOfBounds;
33	pub const corruptSwitch = no_panic.corruptSwitch;
34	pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
35	pub const invalidEnumValue = no_panic.invalidEnumValue;
36	pub const forLenMismatch = no_panic.forLenMismatch;
37	pub const copyLenMismatch = no_panic.copyLenMismatch;
38	pub const memcpyAlias = no_panic.memcpyAlias;
39	pub const noreturnReturned = no_panic.noreturnReturned;
40	pub const loadUninstantiableType = no_panic.loadUninstantiableType;
41	};
42	fn myPanic(msg: []const u8, _: ?usize) noreturn {
43	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
44	stdout_writer.interface.print("panic message: {s}\n", .{msg}) catch {};
45	std.process.exit(0);
46	}
47	const std = @import("std");
48	const io = std.Io.Threaded.global_single_threaded.io();
49	#expect_stdout="panic message: integer overflow\n"
50
51	#update=change the panic handler body
52	#file=main.zig
53	pub fn main() !u8 {
54	var a: u8 = undefined;
55	a = 255;
56	_ = a + 1;
57	return 1;
58	}
59	const no_panic = std.debug.no_panic;
60	pub const panic = struct {
61	pub const call = myPanic;
62	pub fn integerOverflow() noreturn {
63	@panic("integer overflow");
64	}
65	pub const sentinelMismatch = no_panic.sentinelMismatch;
66	pub const unwrapError = no_panic.unwrapError;
67	pub const outOfBounds = no_panic.outOfBounds;
68	pub const startGreaterThanEnd = no_panic.startGreaterThanEnd;
69	pub const inactiveUnionField = no_panic.inactiveUnionField;
70	pub const sliceCastLenRemainder = no_panic.sliceCastLenRemainder;
71	pub const reachedUnreachable = no_panic.reachedUnreachable;
72	pub const unwrapNull = no_panic.unwrapNull;
73	pub const castToNull = no_panic.castToNull;
74	pub const incorrectAlignment = no_panic.incorrectAlignment;
75	pub const invalidErrorCode = no_panic.invalidErrorCode;
76	pub const unexpectedErrorCode = no_panic.unexpectedErrorCode;
77	pub const integerOutOfBounds = no_panic.integerOutOfBounds;
78	pub const shlOverflow = no_panic.shlOverflow;
79	pub const shrOverflow = no_panic.shrOverflow;
80	pub const divideByZero = no_panic.divideByZero;
81	pub const exactDivisionRemainder = no_panic.exactDivisionRemainder;
82	pub const integerPartOutOfBounds = no_panic.integerPartOutOfBounds;
83	pub const corruptSwitch = no_panic.corruptSwitch;
84	pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
85	pub const invalidEnumValue = no_panic.invalidEnumValue;
86	pub const forLenMismatch = no_panic.forLenMismatch;
87	pub const copyLenMismatch = no_panic.copyLenMismatch;
88	pub const memcpyAlias = no_panic.memcpyAlias;
89	pub const noreturnReturned = no_panic.noreturnReturned;
90	pub const loadUninstantiableType = no_panic.loadUninstantiableType;
91	};
92	fn myPanic(msg: []const u8, _: ?usize) noreturn {
93	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
94	stdout_writer.interface.print("new panic message: {s}\n", .{msg}) catch {};
95	std.process.exit(0);
96	}
97	const std = @import("std");
98	const io = std.Io.Threaded.global_single_threaded.io();
99	#expect_stdout="new panic message: integer overflow\n"
100
101	#update=change the panic handler function value
102	#file=main.zig
103	pub fn main() !u8 {
104	var a: u8 = undefined;
105	a = 255;
106	_ = a + 1;
107	return 1;
108	}
109	const no_panic = std.debug.no_panic;
110	pub const panic = struct {
111	pub const call = myPanicNew;
112	pub fn integerOverflow() noreturn {
113	@panic("integer overflow");
114	}
115	pub const sentinelMismatch = std.debug.no_panic.sentinelMismatch;
116	pub const unwrapError = std.debug.no_panic.unwrapError;
117	pub const outOfBounds = std.debug.no_panic.outOfBounds;
118	pub const startGreaterThanEnd = std.debug.no_panic.startGreaterThanEnd;
119	pub const inactiveUnionField = std.debug.no_panic.inactiveUnionField;
120	pub const sliceCastLenRemainder = no_panic.sliceCastLenRemainder;
121	pub const reachedUnreachable = no_panic.reachedUnreachable;
122	pub const unwrapNull = no_panic.unwrapNull;
123	pub const castToNull = no_panic.castToNull;
124	pub const incorrectAlignment = no_panic.incorrectAlignment;
125	pub const invalidErrorCode = no_panic.invalidErrorCode;
126	pub const unexpectedErrorCode = no_panic.unexpectedErrorCode;
127	pub const integerOutOfBounds = no_panic.integerOutOfBounds;
128	pub const shlOverflow = no_panic.shlOverflow;
129	pub const shrOverflow = no_panic.shrOverflow;
130	pub const divideByZero = no_panic.divideByZero;
131	pub const exactDivisionRemainder = no_panic.exactDivisionRemainder;
132	pub const integerPartOutOfBounds = no_panic.integerPartOutOfBounds;
133	pub const corruptSwitch = no_panic.corruptSwitch;
134	pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
135	pub const invalidEnumValue = no_panic.invalidEnumValue;
136	pub const forLenMismatch = no_panic.forLenMismatch;
137	pub const copyLenMismatch = no_panic.copyLenMismatch;
138	pub const memcpyAlias = no_panic.memcpyAlias;
139	pub const noreturnReturned = no_panic.noreturnReturned;
140	pub const loadUninstantiableType = no_panic.loadUninstantiableType;
141	};
142	fn myPanicNew(msg: []const u8, _: ?usize) noreturn {
143	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
144	stdout_writer.interface.print("third panic message: {s}\n", .{msg}) catch {};
145	std.process.exit(0);
146	}
147	const std = @import("std");
148	const io = std.Io.Threaded.global_single_threaded.io();
149	#expect_stdout="third panic message: integer overflow\n"

test/incremental/change_panic_handler_explicit/0/main.zig created+46

...	@@ -0,0 +1,46 @@
1	pub fn main() !u8 {
2	var a: u8 = undefined;
3	a = 255;
4	_ = a + 1;
5	return 1;
6	}
7	const no_panic = std.debug.no_panic;
8	pub const panic = struct {
9	pub const call = myPanic;
10	pub fn integerOverflow() noreturn {
11	@panic("integer overflow");
12	}
13	pub const sentinelMismatch = no_panic.sentinelMismatch;
14	pub const unwrapError = no_panic.unwrapError;
15	pub const outOfBounds = no_panic.outOfBounds;
16	pub const startGreaterThanEnd = no_panic.startGreaterThanEnd;
17	pub const inactiveUnionField = no_panic.inactiveUnionField;
18	pub const sliceCastLenRemainder = no_panic.sliceCastLenRemainder;
19	pub const reachedUnreachable = no_panic.reachedUnreachable;
20	pub const unwrapNull = no_panic.unwrapNull;
21	pub const castToNull = no_panic.castToNull;
22	pub const incorrectAlignment = no_panic.incorrectAlignment;
23	pub const invalidErrorCode = no_panic.invalidErrorCode;
24	pub const unexpectedErrorCode = no_panic.unexpectedErrorCode;
25	pub const integerOutOfBounds = no_panic.integerOutOfBounds;
26	pub const shlOverflow = no_panic.shlOverflow;
27	pub const shrOverflow = no_panic.shrOverflow;
28	pub const divideByZero = no_panic.divideByZero;
29	pub const exactDivisionRemainder = no_panic.exactDivisionRemainder;
30	pub const integerPartOutOfBounds = no_panic.integerPartOutOfBounds;
31	pub const corruptSwitch = no_panic.corruptSwitch;
32	pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
33	pub const invalidEnumValue = no_panic.invalidEnumValue;
34	pub const forLenMismatch = no_panic.forLenMismatch;
35	pub const copyLenMismatch = no_panic.copyLenMismatch;
36	pub const memcpyAlias = no_panic.memcpyAlias;
37	pub const noreturnReturned = no_panic.noreturnReturned;
38	pub const loadUninstantiableType = no_panic.loadUninstantiableType;
39	};
40	fn myPanic(msg: []const u8, _: ?usize) noreturn {
41	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
42	stdout_writer.interface.print("panic message: {s}\n", .{msg}) catch {};
43	std.process.exit(0);
44	}
45	const std = @import("std");
46	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_panic_handler_explicit/1/main.zig created+46

...	@@ -0,0 +1,46 @@
1	pub fn main() !u8 {
2	var a: u8 = undefined;
3	a = 255;
4	_ = a + 1;
5	return 1;
6	}
7	const no_panic = std.debug.no_panic;
8	pub const panic = struct {
9	pub const call = myPanic;
10	pub fn integerOverflow() noreturn {
11	@panic("integer overflow");
12	}
13	pub const sentinelMismatch = no_panic.sentinelMismatch;
14	pub const unwrapError = no_panic.unwrapError;
15	pub const outOfBounds = no_panic.outOfBounds;
16	pub const startGreaterThanEnd = no_panic.startGreaterThanEnd;
17	pub const inactiveUnionField = no_panic.inactiveUnionField;
18	pub const sliceCastLenRemainder = no_panic.sliceCastLenRemainder;
19	pub const reachedUnreachable = no_panic.reachedUnreachable;
20	pub const unwrapNull = no_panic.unwrapNull;
21	pub const castToNull = no_panic.castToNull;
22	pub const incorrectAlignment = no_panic.incorrectAlignment;
23	pub const invalidErrorCode = no_panic.invalidErrorCode;
24	pub const unexpectedErrorCode = no_panic.unexpectedErrorCode;
25	pub const integerOutOfBounds = no_panic.integerOutOfBounds;
26	pub const shlOverflow = no_panic.shlOverflow;
27	pub const shrOverflow = no_panic.shrOverflow;
28	pub const divideByZero = no_panic.divideByZero;
29	pub const exactDivisionRemainder = no_panic.exactDivisionRemainder;
30	pub const integerPartOutOfBounds = no_panic.integerPartOutOfBounds;
31	pub const corruptSwitch = no_panic.corruptSwitch;
32	pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
33	pub const invalidEnumValue = no_panic.invalidEnumValue;
34	pub const forLenMismatch = no_panic.forLenMismatch;
35	pub const copyLenMismatch = no_panic.copyLenMismatch;
36	pub const memcpyAlias = no_panic.memcpyAlias;
37	pub const noreturnReturned = no_panic.noreturnReturned;
38	pub const loadUninstantiableType = no_panic.loadUninstantiableType;
39	};
40	fn myPanic(msg: []const u8, _: ?usize) noreturn {
41	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
42	stdout_writer.interface.print("new panic message: {s}\n", .{msg}) catch {};
43	std.process.exit(0);
44	}
45	const std = @import("std");
46	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_panic_handler_explicit/2/main.zig created+46

...	@@ -0,0 +1,46 @@
1	pub fn main() !u8 {
2	var a: u8 = undefined;
3	a = 255;
4	_ = a + 1;
5	return 1;
6	}
7	const no_panic = std.debug.no_panic;
8	pub const panic = struct {
9	pub const call = myPanicNew;
10	pub fn integerOverflow() noreturn {
11	@panic("integer overflow");
12	}
13	pub const sentinelMismatch = no_panic.sentinelMismatch;
14	pub const unwrapError = no_panic.unwrapError;
15	pub const outOfBounds = no_panic.outOfBounds;
16	pub const startGreaterThanEnd = no_panic.startGreaterThanEnd;
17	pub const inactiveUnionField = no_panic.inactiveUnionField;
18	pub const sliceCastLenRemainder = no_panic.sliceCastLenRemainder;
19	pub const reachedUnreachable = no_panic.reachedUnreachable;
20	pub const unwrapNull = no_panic.unwrapNull;
21	pub const castToNull = no_panic.castToNull;
22	pub const incorrectAlignment = no_panic.incorrectAlignment;
23	pub const invalidErrorCode = no_panic.invalidErrorCode;
24	pub const unexpectedErrorCode = no_panic.unexpectedErrorCode;
25	pub const integerOutOfBounds = no_panic.integerOutOfBounds;
26	pub const shlOverflow = no_panic.shlOverflow;
27	pub const shrOverflow = no_panic.shrOverflow;
28	pub const divideByZero = no_panic.divideByZero;
29	pub const exactDivisionRemainder = no_panic.exactDivisionRemainder;
30	pub const integerPartOutOfBounds = no_panic.integerPartOutOfBounds;
31	pub const corruptSwitch = no_panic.corruptSwitch;
32	pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
33	pub const invalidEnumValue = no_panic.invalidEnumValue;
34	pub const forLenMismatch = no_panic.forLenMismatch;
35	pub const copyLenMismatch = no_panic.copyLenMismatch;
36	pub const memcpyAlias = no_panic.memcpyAlias;
37	pub const noreturnReturned = no_panic.noreturnReturned;
38	pub const loadUninstantiableType = no_panic.loadUninstantiableType;
39	};
40	fn myPanicNew(msg: []const u8, _: ?usize) noreturn {
41	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
42	stdout_writer.interface.print("third panic message: {s}\n", .{msg}) catch {};
43	std.process.exit(0);
44	}
45	const std = @import("std");
46	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental/change_panic_handler_explicit/manifest created+23

...	@@ -0,0 +1,23 @@
1	#exe {
2	-Mroot=main.zig
3	#}
4
5	#write main.zig 0/main.zig
6	#update
7	#check stdout {
8	panic message: integer overflow
9	#}
10
11	#write main.zig 1/main.zig
12	#update {
13	change the panic handler body#}
14	#check stdout {
15	new panic message: integer overflow
16	#}
17
18	#write main.zig 2/main.zig
19	#update {
20	change the panic handler function value#}
21	#check stdout {
22	third panic message: integer overflow
23	#}

test/incremental/change_reify_struct_field_type+16-6

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 fn getEnum(s: @Struct(.auto, null, &.{"field"}, &.{struct { tag: Enum }}, &.{.{}})) Enum {
     return s.field.tag;
 }
 @@ -8,9 +11,12 @@ pub fn main(init: std.process.Init) !void {
 }
 const Enum = enum { foo, bar };
 const std = @import("std");
-#expect_stdout="foo"
+#}
-#update=change field type
+#update
-#file=main.zig
+#check stdout {
+foo#}
+#write main.zig {
 fn getEnum(s: @Struct(.auto, null, &.{"field"}, &.{Enum}, &.{.{}})) Enum {
     return s.field;
 }
 @@ -19,4 +25,8 @@ pub fn main(init: std.process.Init) !void {
 }
 const Enum = enum { foo, bar };
 const std = @import("std");
-#expect_stdout="bar"
+#}
+#update {
+change field type#}
+#check stdout {
+bar#}

test/incremental/change_shift_op+18-6

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() !void {
     try foo(0x1300);
 }
 @@ -9,9 +12,13 @@ fn foo(x: u16) !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="0x3000\n"
+#}
-#update=change to right shift
+#update
-#file=main.zig
+#check stdout {
+0x3000
+#}
+#write main.zig {
 pub fn main() !void {
     try foo(0x1300);
 }
 @@ -21,4 +28,9 @@ fn foo(x: u16) !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="0x130\n"
+#}
+#update {
+change to right shift#}
+#check stdout {
+0x130
+#}

test/incremental/change_struct_same_fields+24-9

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const S = extern struct { x: u8, y: u8 };
 pub fn main() !void {
     const val: S = .{ .x = 100, .y = 200 };
 @@ -14,10 +17,13 @@ fn foo(val: *const S) !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="100 200\n"
+#}
+#update
+#check stdout {
+100 200
+#}
-#update=change struct layout
+#write main.zig {
-#file=main.zig
 const S = extern struct { x: u32, y: u32 };
 pub fn main() !void {
     const val: S = .{ .x = 100, .y = 200 };
 @@ -32,10 +38,14 @@ fn foo(val: *const S) !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="100 200\n"
+#}
+#update {
+change struct layout#}
+#check stdout {
+100 200
+#}
-#update=change values
+#write main.zig {
-#file=main.zig
 const S = extern struct { x: u32, y: u32 };
 pub fn main() !void {
     const val: S = .{ .x = 1234, .y = 5678 };
 @@ -50,4 +60,9 @@ fn foo(val: *const S) !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="1234 5678\n"
+#}
+#update {
+change values#}
+#check stdout {
+1234 5678
+#}

test/incremental/change_union_tag_type+25-10

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const A = enum(u8) { a };
 const B = enum(u8) { b };
 const Foo = union(A) { a: u8 };
 @@ -9,10 +12,13 @@ pub fn main(init: std.process.Init) !void {
     try stdout_writer.interface.print("{s}\n", .{field_name});
 }
 const std = @import("std");
-#expect_stdout="a\n"
+#}
+#update
+#check stdout {
+a
+#}
-#update=change tag type
+#write main.zig {
-#file=main.zig
 const A = enum(u8) { a };
 const B = enum(u8) { b };
 const Foo = union(B) { a: u8 };
 @@ -22,11 +28,15 @@ pub fn main(init: std.process.Init) !void {
     try stdout_writer.interface.print("{s}\n", .{field_name});
 }
 const std = @import("std");
-#expect_error=main.zig:3:24: error: no field named 'a' in enum 'main.B'
+#}
-#expect_error=main.zig:2:11: note: enum declared here
+#update {
+change tag type#}
+#check errors {
+main.zig:3:24: error: no field named 'a' in enum 'main.B'
+main.zig:2:11: note: enum declared here
+#}
-#update=change field name to match new tag type
+#write main.zig {
-#file=main.zig
 const A = enum(u8) { a };
 const B = enum(u8) { b };
 const Foo = union(B) { b: u8 };
 @@ -36,4 +46,9 @@ pub fn main(init: std.process.Init) !void {
     try stdout_writer.interface.print("{s}\n", .{field_name});
 }
 const std = @import("std");
-#expect_stdout="b\n"
+#}
+#update {
+change field name to match new tag type#}
+#check stdout {
+b
+#}

test/incremental/change_zon_file+48-21

 @@ -1,47 +1,74 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 const message: []const u8 = @import("message.zon");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, message);
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#file=message.zon
+#}
+#write message.zon {
 "Hello, World!\n"
-#expect_stdout="Hello, World!\n"
+#}
+#update
+#check stdout {
+Hello, World!
+#}
-#update=change ZON file contents
+#write message.zon {
-#file=message.zon
 "Hello again, World!\n"
-#expect_stdout="Hello again, World!\n"
+#}
+#update {
+change ZON file contents#}
+#check stdout {
+Hello again, World!
+#}
-#update=delete file
+#delete message.zon
-#rm_file=message.zon
+#update {
-#expect_error=message.zon:1:1: error: unable to load "message.zon": FileNotFound
+delete file#}
-#expect_error=main.zig:2:37: note: file imported here
+#check errors {
+message.zon:1:1: error: unable to load "message.zon": FileNotFound
+main.zig:2:37: note: file imported here
+#}
-#update=remove reference to ZON file
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 const message: []const u8 = @import("message.zon");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "a hardcoded string\n");
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=message.zon:1:1: error: unable to load "message.zon": FileNotFound
+#}
-#expect_error=main.zig:2:37: note: file imported here
+#update {
+remove reference to ZON file#}
+#check errors {
+message.zon:1:1: error: unable to load "message.zon": FileNotFound
+main.zig:2:37: note: file imported here
+#}
-#update=recreate ZON file
+#write message.zon {
-#file=message.zon
 "We're back, World!\n"
-#expect_stdout="a hardcoded string\n"
+#}
+#update {
+recreate ZON file#}
+#check stdout {
+a hardcoded string
+#}
-#update=re-introduce reference to ZON file
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 const message: []const u8 = @import("message.zon");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, message);
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="We're back, World!\n"
+#}
+#update {
+re-introduce reference to ZON file#}
+#check stdout {
+We're back, World!
+#}

test/incremental/change_zon_file_no_result_type+19-7

 @@ -1,21 +1,33 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @import("foo.zon").message);
 }
-#file=foo.zon
+#}
+#write foo.zon {
 .{
     .message = "Hello, World!\n",
     .a_number = 0,
 }
-#expect_stdout="Hello, World!\n"
+#}
+#update
+#check stdout {
+Hello, World!
+#}
-#update=change ZON file
+#write foo.zon {
-#file=foo.zon
 .{
     .message = "Hello again, World!\n",
     .b_number = 0,
 }
-#expect_stdout="Hello again, World!\n"
+#}
+#update {
+change ZON file#}
+#check stdout {
+Hello again, World!
+#}

test/incremental/compile_error_then_log+24-8

 @@ -1,5 +1,8 @@
-#update=initial version with compile error
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() void {}
 comptime {
     @compileError("this is an error");
 @@ -7,11 +10,17 @@ comptime {
 comptime {
     @compileLog("this is a log");
 }
-#expect_error=main.zig:3:5: error: this is an error
+#}
-#expect_compile_log=@as(*const [13:0]u8, "this is a log")
+#update {
+compile error#}
+#check errors {
+main.zig:3:5: error: this is an error
+Compile Log Output:
+@as(*const [13:0]u8, "this is a log")
+#}
-#update=remove the compile error
+#write main.zig {
-#file=main.zig
 pub fn main() void {}
 comptime {
     //@compileError("this is an error");
 @@ -19,5 +28,12 @@ comptime {
 comptime {
     @compileLog("this is a log");
 }
-#expect_error=main.zig:6:5: error: found compile log statement
+#}
-#expect_compile_log=@as(*const [13:0]u8, "this is a log")
+#update {
+remove the compile error#}
+#check errors {
+main.zig:6:5: error: found compile log statement
+Compile Log Output:
+@as(*const [13:0]u8, "this is a log")
+#}

test/incremental/compile_log+28-10

 @@ -1,28 +1,46 @@
-#update=initial version with no compile log
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Hello, World!\n"
+#}
+#update {
+no compile log#}
+#check stdout {
+Hello, World!
+#}
-#update=add compile log
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
     @compileLog("this is a log");
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:4:5: error: found compile log statement
+#}
-#expect_compile_log=@as(*const [13:0]u8, "this is a log")
+#update {
+add compile log#}
+#check errors {
+main.zig:4:5: error: found compile log statement
+Compile Log Output:
+@as(*const [13:0]u8, "this is a log")
+#}
-#update=remove compile log
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Hello, World!\n"
+#}
+#update {
+remove compile log#}
+#check stdout {
+Hello, World!
+#}

test/incremental/delete_comptime_decls+20-9

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() void {}
 comptime {
     var array = [_:0]u8{ 1, 2, 3, 4 };
 @@ -22,13 +25,16 @@ comptime {
     const slice = array[3..2];
     _ = slice;
 }
-#expect_error=main.zig:5:32: error: end index 6 out of bounds for slice of length 4 +1 (sentinel)
+#}
-#expect_error=main.zig:10:28: error: end index 6 out of bounds for array of length 4 +1 (sentinel)
+#update
-#expect_error=main.zig:15:28: error: end index 5 out of bounds for array of length 4
+#check errors {
-#expect_error=main.zig:20:25: error: start index 3 is larger than end index 2
+main.zig:5:32: error: end index 6 out of bounds for slice of length 4 +1 (sentinel)
+main.zig:10:28: error: end index 6 out of bounds for array of length 4 +1 (sentinel)
+main.zig:15:28: error: end index 5 out of bounds for array of length 4
+main.zig:20:25: error: start index 3 is larger than end index 2
+#}
-#update=delete and modify comptime decls
+#write main.zig {
-#file=main.zig
 pub fn main() void {}
 comptime {
     const x: [*c]u8 = null;
 @@ -37,4 +43,9 @@ comptime {
     const y = x[0..runtime_len];
     _ = y;
 }
-#expect_error=main.zig:6:16: error: slice of null pointer
+#}
+#update {
+delete and modify comptime decls#}
+#check errors {
+main.zig:6:16: error: slice of null pointer
+#}

test/incremental/dependency_on_type_of_inferred_global+17-6

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const foo = @as(u8, 123);
 comptime {
     // depends on value of `foo`
 @@ -10,9 +13,12 @@ comptime {
     if (@TypeOf(&foo) != *const u8) unreachable;
 }
 pub fn main() void {}
-#expect_stdout=""
+#}
-#update=change the type
+#update
-#file=main.zig
+#check stdout {
+#}
+#write main.zig {
 const foo = @as(u16, 123);
 comptime {
     // depends on value of `foo`
 @@ -23,4 +29,9 @@ comptime {
     if (@TypeOf(&foo) != *const u8) unreachable;
 }
 pub fn main() void {}
-#expect_error=main.zig:8:37: error: reached unreachable code
+#}
+#update {
+change the type#}
+#check errors {
+main.zig:8:37: error: reached unreachable code
+#}

test/incremental/do_nothing+19-7

 @@ -1,6 +1,11 @@
-// TODO: it'd be great if we could actually check that no analysis happened!
+#todo {
-#update=initial version
+it'd be great if we could actually check that no analysis happened!
-#file=main.zig
+#}
+#exe {
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() void {
     const ptr: *const O = @ptrFromInt(0x1000);
     _ = ptr;
 @@ -18,9 +23,12 @@ const O = opaque {
         _ = wrapper;
     }
 };
-#expect_stdout=""
+#}
-#update=do literally nothing
+#update
-#file=main.zig
+#check stdout {
+#}
+#write main.zig {
 pub fn main() void {
     const ptr: *const O = @ptrFromInt(0x1000);
     _ = ptr;
 @@ -38,4 +46,8 @@ const O = opaque {
         _ = wrapper;
     }
 };
-#expect_stdout=""
+#}
+#update {
+do literally nothing#}
+#check stdout {
+#}

test/incremental/fix_astgen_failure+37-13

 @@ -1,35 +1,59 @@
-#update=initial version with error
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() !void {
     try @import("foo.zig").hello();
 }
-#file=foo.zig
+#}
+#write foo.zig {
 pub fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
-#expect_error=foo.zig:2:9: error: use of undeclared identifier 'std'
+#}
-#update=fix the error
+#update {
-#file=foo.zig
+error#}
+#check errors {
+foo.zig:2:9: error: use of undeclared identifier 'std'
+#}
+#write foo.zig {
 const std = @import("std");
 pub fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Hello, World!\n"
+#}
-#update=add new error
+#update {
-#file=foo.zig
+fix the error#}
+#check stdout {
+Hello, World!
+#}
+#write foo.zig {
 const std = @import("std");
 pub fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, hello_str);
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=foo.zig:3:52: error: use of undeclared identifier 'hello_str'
+#}
-#update=fix the new error
+#update {
-#file=foo.zig
+add new error#}
+#check errors {
+foo.zig:3:52: error: use of undeclared identifier 'hello_str'
+#}
+#write foo.zig {
 const std = @import("std");
 const hello_str = "Hello, World! Again!\n";
 pub fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, hello_str);
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Hello, World! Again!\n"
+#}
+#update {
+fix the new error#}
+#check stdout {
+Hello, World! Again!
+#}

test/incremental/function_becomes_inline+25-9

 @@ -1,5 +1,8 @@
-#update=non-inline version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() !void {
     try foo();
 }
 @@ -8,10 +11,14 @@ fn foo() !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Hello, World!\n"
+#}
+#update {
+non-inline version#}
+#check stdout {
+Hello, World!
+#}
-#update=make function inline
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     try foo();
 }
 @@ -20,10 +27,14 @@ inline fn foo() !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Hello, World!\n"
+#}
+#update {
+make function inline#}
+#check stdout {
+Hello, World!
+#}
-#update=change string
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     try foo();
 }
 @@ -32,4 +43,9 @@ inline fn foo() !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Hello, `inline` World!\n"
+#}
+#update {
+change string#}
+#check stdout {
+Hello, `inline` World!
+#}

test/incremental/hello+18-6

 @@ -1,16 +1,28 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "good morning\n");
 }
-#expect_stdout="good morning\n"
+#}
-#update=change the string
+#update
-#file=main.zig
+#check stdout {
+good morning
+#}
+#write main.zig {
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "おはようございます\n");
 }
-#expect_stdout="おはようございます\n"
+#}
+#update {
+change the string#}
+#check stdout {
+おはようございます
+#}

test/incremental/increase_array_field_length+17-6

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const Big = struct { arr: [10]u8 };
 pub fn main(init: std.process.Init) !void {
     var big: Big = undefined;
 @@ -12,10 +15,13 @@ pub fn main(init: std.process.Init) !void {
     };
 }
 const std = @import("std");
-#expect_stdout="arr[9] = 234\n"
+#}
+#update
+#check stdout {
+arr[9] = 234
+#}
-#update=increase array length
+#write main.zig {
-#file=main.zig
 const Big = struct { arr: [1000]u8 };
 pub fn main(init: std.process.Init) !void {
     var big: Big = undefined;
 @@ -28,4 +34,9 @@ pub fn main(init: std.process.Init) !void {
     };
 }
 const std = @import("std");
-#expect_stdout="arr[999] = 234\n"
+#}
+#update {
+increase array length#}
+#check stdout {
+arr[999] = 234
+#}

test/incremental/make_decl_pub+20-8

 @@ -1,23 +1,35 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const foo = @import("foo.zig");
 pub fn main() !void {
     try foo.hello();
 }
-#file=foo.zig
+#}
+#write foo.zig {
 const std = @import("std");
 fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:3:12: error: 'hello' is not marked 'pub'
+#}
-#expect_error=foo.zig:2:1: note: declared here
+#update
+#check errors {
+main.zig:3:12: error: 'hello' is not marked 'pub'
+foo.zig:2:1: note: declared here
+#}
-#update=make hello pub
+#write foo.zig {
-#file=foo.zig
 const std = @import("std");
 pub fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Hello, World!\n"
+#}
+#update {
+make hello pub#}
+#check stdout {
+Hello, World!
+#}

test/incremental/modify_inline_fn+18-6

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 pub fn main() !void {
     const str = getStr();
 @@ -9,9 +12,13 @@ inline fn getStr() []const u8 {
     return "foo\n";
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="foo\n"
+#}
-#update=change the string
+#update
-#file=main.zig
+#check stdout {
+foo
+#}
+#write main.zig {
 const std = @import("std");
 pub fn main() !void {
     const str = getStr();
 @@ -21,4 +28,9 @@ inline fn getStr() []const u8 {
     return "bar\n";
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="bar\n"
+#}
+#update {
+change the string#}
+#check stdout {
+bar
+#}

test/incremental/move_src+17-6

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 pub fn main() !void {
     var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
 @@ -12,10 +15,13 @@ fn bar() u32 {
     return 123;
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="7 123\n"
+#}
+#update
+#check stdout {
+7 123
+#}
-#update=add newline
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
 @@ -29,4 +35,9 @@ fn bar() u32 {
     return 123;
 }
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="8 123\n"
+#}
+#update {
+add newline#}
+#check stdout {
+8 123
+#}

test/incremental/pointer_to_decl_with_astgen_error+22-9

 @@ -1,23 +1,36 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const foo = {};
 pub fn main() void {
     _ = &foo;
 }
-#expect_stdout=""
+#}
+#update
+#check stdout {
+#}
-#update=introduce use of undeclared identifier
+#write main.zig {
-#file=main.zig
 const foo = something;
 pub fn main() void {
     _ = &foo;
 }
-#expect_error=main.zig:1:13: error: use of undeclared identifier 'something'
+#}
+#update {
+introduce use of undeclared identifier#}
+#check errors {
+main.zig:1:13: error: use of undeclared identifier 'something'
+#}
-#update=revert use of undeclared identifier
+#write main.zig {
-#file=main.zig
 const foo = {};
 pub fn main() void {
     _ = &foo;
 }
-#expect_stdout=""
+#}
+#update {
+revert use of undeclared identifier#}
+#check stdout {
+#}

test/incremental/recursive_function_becomes_non_recursive+17-6

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub fn main() !void {
     try foo(false);
 }
 @@ -10,10 +13,13 @@ fn foo(recurse: bool) !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="non-recursive path\n"
+#}
+#update
+#check stdout {
+non-recursive path
+#}
-#update=eliminate recursion and change argument
+#write main.zig {
-#file=main.zig
 pub fn main() !void {
     try foo(true);
 }
 @@ -24,4 +30,9 @@ fn foo(recurse: bool) !void {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="x==1\n"
+#}
+#update {
+eliminate recursion and change argument#}
+#check stdout {
+x==1
+#}

test/incremental/remove_enum_field+21-9

 @@ -1,27 +1,39 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const MyEnum = enum(u8) {
     foo = 1,
     bar = 2,
 };
 pub fn main() !void {
     var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
-    try stdout_writer.interface.print("{}\n", .{@intFromEnum(MyEnum.foo)});
+    try stdout_writer.interface.print("{}\n", .{@backingInt(MyEnum.foo)});
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="1\n"
+#}
-#update=remove enum field
+#update
-#file=main.zig
+#check stdout {
+1
+#}
+#write main.zig {
 const MyEnum = enum(u8) {
     //foo = 1,
     bar = 2,
 };
 pub fn main() !void {
     var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
-    try stdout_writer.interface.print("{}\n", .{@intFromEnum(MyEnum.foo)});
+    try stdout_writer.interface.print("{}\n", .{@backingInt(MyEnum.foo)});
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:7:69: error: enum 'main.MyEnum' has no member named 'foo'
+#}
-#expect_error=main.zig:1:16: note: enum declared here
+#update {
+remove enum field#}
+#check errors {
+main.zig:7:68: error: enum 'main.MyEnum' has no member named 'foo'
+main.zig:1:16: note: enum declared here
+#}

test/incremental/remove_function_with_changed_callee+16-6

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
 @@ -23,9 +26,12 @@ fn bar(a: A) !void {
 pub fn main() !void {
     try foo();
 }
-#expect_stdout="0"
+#}
-#update=remove foo and change bar wasm function type
+#update
-#file=main.zig
+#check stdout {
+0#}
+#write main.zig {
 //! This update must preserve `bar` `InternPool.Index` value, while changing its wasm function type.
 //! If `foo` code is preserved in the binary without any changes, wasm type checking will fail.
 const std = @import("std");
 @@ -47,4 +53,8 @@ fn bar(a: A) !void {
 pub fn main() !void {
     try bar(.one);
 }
-#expect_stdout="1"
+#}
+#update {
+remove foo and change bar wasm function type#}
+#check stdout {
+1#}

test/incremental/remove_invalid_union_backing_enum+18-7

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const E = enum { a, b, c };
 const U = union(E) {
     a: i32,
 @@ -11,10 +14,14 @@ pub fn main() void {
     const u: U = .{ .a = 123 };
     _ = u;
 }
-#expect_error=main.zig:6:5: error: no field named 'd' in enum 'main.E'
+#}
-#expect_error=main.zig:1:11: note: enum declared here
+#update
-#update=remove invalid backing enum
+#check errors {
-#file=main.zig
+main.zig:6:5: error: no field named 'd' in enum 'main.E'
+main.zig:1:11: note: enum declared here
+#}
+#write main.zig {
 const U = union {
     a: i32,
     b: f64,
 @@ -25,4 +32,8 @@ pub fn main() void {
     const u: U = .{ .a = 123 };
     _ = u;
 }
-#expect_stdout=""
+#}
+#update {
+remove invalid backing enum#}
+#check stdout {
+#}

test/incremental/struct_reification_becomes_anon_init+17-6

 @@ -1,19 +1,30 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const Foo = @Struct(.auto, null, &.{"reified_field"}, &.{void}, &.{.{}});
 pub fn main(init: std.process.Init) !void {
     const field_name = @typeInfo(Foo).@"struct".field_names[0];
     try std.Io.File.stdout().writeStreamingAll(init.io, field_name ++ "\n");
 }
 const std = @import("std");
-#expect_stdout="reified_field\n"
+#}
+#update
+#check stdout {
+reified_field
+#}
-#update=change to `@TypeOf` anonymous init
+#write main.zig {
-#file=main.zig
 const Foo = @TypeOf(.{ .anon_field = 123 });
 pub fn main(init: std.process.Init) !void {
     const field_name = @typeInfo(Foo).@"struct".field_names[0];
     try std.Io.File.stdout().writeStreamingAll(init.io, field_name ++ "\n");
 }
 const std = @import("std");
-#expect_stdout="anon_field\n"
+#}
+#update {
+change to `@TypeOf` anonymous init#}
+#check stdout {
+anon_field
+#}

test/incremental/tag_name+23-9

 @@ -1,27 +1,41 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 var some_enum: enum { first, second } = .first;
 const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @tagName(some_enum));
 }
-#expect_stdout="first"
+#}
-#update=no change
+#update
-#file=main.zig
+#check stdout {
+first#}
+#write main.zig {
 const std = @import("std");
 var some_enum: enum { first, second } = .first;
 const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @tagName(some_enum));
 }
-#expect_stdout="first"
+#}
-#update=swap fields
+#update {
-#file=main.zig
+no change#}
+#check stdout {
+first#}
+#write main.zig {
 const std = @import("std");
 var some_enum: enum { second, first } = .first;
 const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @tagName(some_enum));
 }
-#expect_stdout="first"
+#}
+#update {
+swap fields#}
+#check stdout {
+first#}

test/incremental/temporary_analysis_error_in_generic_signature+25-10

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 //! The original repro here depends on re-analysis order, which depends on
 //! declaration order, so this exact declaration order must be used.
 const Foo = struct { x: u8 };
 @@ -11,10 +14,13 @@ fn bar(comptime x: u8) @This().Foo {
     return .{ .x = x };
 }
 const std = @import("std");
-#expect_stdout="Z\n"
+#}
+#update
+#check stdout {
+Z
+#}
-#update=change generic signature to use non-existent member
+#write main.zig {
-#file=main.zig
 //! The original repro here depends on re-analysis order, which depends on
 //! declaration order, so this exact declaration order must be used.
 const Foo = struct { x: u8 };
 @@ -26,11 +32,15 @@ fn bar(comptime x: u8) @This().FooAlias {
     return .{ .x = x };
 }
 const std = @import("std");
-#expect_error=main.zig:8:31: error: root source file struct 'main' has no member named 'FooAlias'
+#}
-#expect_error=main.zig:1:1: note: struct declared here
+#update {
+change generic signature to use non-existent member#}
+#check errors {
+main.zig:8:31: error: root source file struct 'main' has no member named 'FooAlias'
+main.zig:1:1: note: struct declared here
+#}
-#update=add that member, fixing the error
+#write main.zig {
-#file=main.zig
 //! The original repro here depends on re-analysis order, which depends on
 //! declaration order, so this exact declaration order must be used.
 const Foo = struct { x: u8 };
 @@ -43,4 +53,9 @@ fn bar(comptime x: u8) @This().FooAlias {
     return .{ .x = x };
 }
 const std = @import("std");
-#expect_stdout="Z\n"
+#}
+#update {
+add that member, fixing the error#}
+#check stdout {
+Z
+#}

test/incremental/temporary_parse_error+22-9

...	@@ -1,15 +1,28 @@	...	@@ -1,15 +1,28 @@
1	#update=initial version	1	#exe {
2	#file=main.zig	2	-Mroot=main.zig
		3	#}
		4
		5	#write main.zig {
3	const std = @import("std");	6	const std = @import("std");
4	pub fn main() !void {}	7	pub fn main() !void {}
5	#expect_stdout=""	8	#}
		9	#update
		10	#check stdout {
		11	#}
6		12
7	#update=introduce parse error	13	#write main.zig {
8	#file=main.zig
9	pub fn main() !void {	14	pub fn main() !void {
10	#expect_error=main.zig:2:1: error: expected statement, found 'EOF'	15	#}
		16	#update {
		17	introduce parse error#}
		18	#check errors {
		19	main.zig:2:1: error: expected statement, found 'EOF'
		20	#}
11		21
12	#update=fix parse error	22	#write main.zig {
13	#file=main.zig
14	pub fn main() !void {}	23	pub fn main() !void {}
15	#expect_stdout=""	24	#}
		25	#update {
		26	fix parse error#}
		27	#check stdout {
		28	#}

test/incremental/type_becomes_comptime_only+21-9

 @@ -1,5 +1,8 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const SomeType = u32;
 const S = struct {
     x: SomeType,
 @@ -9,10 +12,12 @@ pub fn main() void {
     const s: S = .{ .x = 456 };
     s.foo();
 }
-#expect_stdout=""
+#}
+#update
+#check stdout {
+#}
-#update=make S comptime-only
+#write main.zig {
-#file=main.zig
 const SomeType = comptime_int;
 const S = struct {
     x: SomeType,
 @@ -22,10 +27,13 @@ pub fn main() void {
     const s: S = .{ .x = 456 };
     s.foo();
 }
-#expect_stdout=""
+#}
+#update {
+make S comptime-only#}
+#check stdout {
+#}
-#update=make S runtime again
+#write main.zig {
-#file=main.zig
 const SomeType = u16;
 const S = struct {
     x: SomeType,
 @@ -35,4 +43,8 @@ pub fn main() void {
     const s: S = .{ .x = 456 };
     s.foo();
 }
-#expect_stdout=""
+#}
+#update {
+make S runtime again#}
+#check stdout {
+#}

test/incremental/type_dependency_loop+41-21

 @@ -1,50 +1,70 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 pub const A = struct { b: B };
 pub const B = struct { a: A };
 pub fn main() void {
     _ = @as(B, undefined);
 }
-#expect_error=:error: dependency loop with length 2
+#}
-#expect_error=main.zig:2:27: note: type 'main.B' depends on type 'main.A' for field declared here
+#update
-#expect_error=main.zig:1:27: note: type 'main.A' depends on type 'main.B' for field declared here
+#check errors {
-#expect_error=:note: eliminate any one of these dependencies to break the loop
+error: dependency loop with length 2
+    main.zig:2:27: note: type 'main.B' depends on type 'main.A' for field declared here
+    main.zig:1:27: note: type 'main.A' depends on type 'main.B' for field declared here
+    note: eliminate any one of these dependencies to break the loop
+#}
-#update=remove reference to dependency loop
+#write main.zig {
-#file=main.zig
 pub const A = struct { b: B };
 pub const B = struct { a: A };
 pub fn main() void {
     _ = B;
 }
-#expect_stdout=""
+#}
+#update {
+remove reference to dependency loop#}
+#check stdout {
+#}
-#update=change dependency loop without fixing it
+#write main.zig {
-#file=main.zig
 pub const A = struct { b: B };
 pub const B = struct { a: *align(@alignOf(A)) A };
 pub fn main() void {
     _ = B;
 }
-#expect_stdout=""
+#}
+#update {
+change dependency loop without fixing it#}
+#check stdout {
+#}
-#update=reference dependency loop again
+#write main.zig {
-#file=main.zig
 pub const A = struct { b: B };
 pub const B = struct { a: *align(@alignOf(A)) A };
 pub fn main() void {
     _ = @as(B, undefined);
 }
-#expect_error=:error: dependency loop with length 2
+#}
-#expect_error=main.zig:2:43: note: type 'main.B' depends on type 'main.A' for alignment query here
+#update {
-#expect_error=main.zig:1:27: note: type 'main.A' depends on type 'main.B' for field declared here
+reference dependency loop again#}
-#expect_error=:note: eliminate any one of these dependencies to break the loop
+#check errors {
+error: dependency loop with length 2
+    main.zig:2:43: note: type 'main.B' depends on type 'main.A' for alignment query here
+    main.zig:1:27: note: type 'main.A' depends on type 'main.B' for field declared here
+    note: eliminate any one of these dependencies to break the loop
+#}
-#update=fix dependency loop
+#write main.zig {
-#file=main.zig
 pub const A = struct { b: B };
 pub const B = struct { a: *A };
 pub fn main() void {
     _ = @as(B, undefined);
 }
-#expect_stdout=""
+#}
+#update {
+fix dependency loop#}
+#check stdout {
+#}

test/incremental/unreferenced_error+31-12

 @@ -1,25 +1,35 @@
-#update=initial version
+#exe {
-#file=main.zig
+-Mroot=main.zig
+#}
+#write main.zig {
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, a);
 }
 const a = "Hello, World!\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Hello, World!\n"
+#}
+#update
+#check stdout {
+Hello, World!
+#}
-#update=introduce compile error
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, a);
 }
 const a = @compileError("bad a");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:5:11: error: bad a
+#}
+#update {
+introduce compile error#}
+#check errors {
+main.zig:5:11: error: bad a
+#}
-#update=remove error reference
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, b);
 @@ -27,10 +37,14 @@ pub fn main() !void {
 const a = @compileError("bad a");
 const b = "Hi there!\n";
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Hi there!\n"
+#}
+#update {
+remove error reference#}
+#check stdout {
+Hi there!
+#}
-#update=introduce and remove reference to error
+#write main.zig {
-#file=main.zig
 const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, a);
 @@ -38,4 +52,9 @@ pub fn main() !void {
 const a = "Back to a\n";
 const b = @compileError("bad b");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_stdout="Back to a\n"
+#}
+#update {
+introduce and remove reference to error#}
+#check stdout {
+Back to a
+#}

test/incremental2/bad_import deleted-48

...	@@ -1,48 +0,0 @@
1	#exe {
2	-Mroot=main.zig
3	#}
4
5	#write main.zig {
6	pub fn main() !void {
7	_ = @import("foo.zig");
8	try std.Io.File.stdout().writeStreamingAll(io, "success\n");
9	}
10	const std = @import("std");
11	const io = std.Io.Threaded.global_single_threaded.io();
12	#}
13	#write foo.zig {
14	comptime {
15	_ = @import("bad.zig");
16	}
17	#}
18	#update
19	#check errors {
20	bad.zig:1:1: error: unable to load "bad.zig": FileNotFound
21	foo.zig:2:17: note: file imported here
22	#}
23
24	#write foo.zig {
25	comptime {
26	_ = @import("this_is/not_real.zig");
27	}
28	#}
29	#update {
30	change bad import#}
31	#check errors {
32	this_is/not_real.zig:1:1: error: unable to load "not_real.zig": FileNotFound
33	foo.zig:2:17: note: file imported here
34	#}
35
36	#write main.zig {
37	pub fn main() !void {
38	//_ = @import("foo.zig");
39	try std.Io.File.stdout().writeStreamingAll(io, "success\n");
40	}
41	const std = @import("std");
42	const io = std.Io.Threaded.global_single_threaded.io();
43	#}
44	#update {
45	remove import of 'foo.zig'#}
46	#check stdout {
47	success
48	#}

test/incremental2/change_panic_handler_explicit/0/main.zig deleted-46

...	@@ -1,46 +0,0 @@
1	pub fn main() !u8 {
2	var a: u8 = undefined;
3	a = 255;
4	_ = a + 1;
5	return 1;
6	}
7	const no_panic = std.debug.no_panic;
8	pub const panic = struct {
9	pub const call = myPanic;
10	pub fn integerOverflow() noreturn {
11	@panic("integer overflow");
12	}
13	pub const sentinelMismatch = no_panic.sentinelMismatch;
14	pub const unwrapError = no_panic.unwrapError;
15	pub const outOfBounds = no_panic.outOfBounds;
16	pub const startGreaterThanEnd = no_panic.startGreaterThanEnd;
17	pub const inactiveUnionField = no_panic.inactiveUnionField;
18	pub const sliceCastLenRemainder = no_panic.sliceCastLenRemainder;
19	pub const reachedUnreachable = no_panic.reachedUnreachable;
20	pub const unwrapNull = no_panic.unwrapNull;
21	pub const castToNull = no_panic.castToNull;
22	pub const incorrectAlignment = no_panic.incorrectAlignment;
23	pub const invalidErrorCode = no_panic.invalidErrorCode;
24	pub const unexpectedErrorCode = no_panic.unexpectedErrorCode;
25	pub const integerOutOfBounds = no_panic.integerOutOfBounds;
26	pub const shlOverflow = no_panic.shlOverflow;
27	pub const shrOverflow = no_panic.shrOverflow;
28	pub const divideByZero = no_panic.divideByZero;
29	pub const exactDivisionRemainder = no_panic.exactDivisionRemainder;
30	pub const integerPartOutOfBounds = no_panic.integerPartOutOfBounds;
31	pub const corruptSwitch = no_panic.corruptSwitch;
32	pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
33	pub const invalidEnumValue = no_panic.invalidEnumValue;
34	pub const forLenMismatch = no_panic.forLenMismatch;
35	pub const copyLenMismatch = no_panic.copyLenMismatch;
36	pub const memcpyAlias = no_panic.memcpyAlias;
37	pub const noreturnReturned = no_panic.noreturnReturned;
38	pub const loadUninstantiableType = no_panic.loadUninstantiableType;
39	};
40	fn myPanic(msg: []const u8, _: ?usize) noreturn {
41	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
42	stdout_writer.interface.print("panic message: {s}\n", .{msg}) catch {};
43	std.process.exit(0);
44	}
45	const std = @import("std");
46	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental2/change_panic_handler_explicit/1/main.zig deleted-46

...	@@ -1,46 +0,0 @@
1	pub fn main() !u8 {
2	var a: u8 = undefined;
3	a = 255;
4	_ = a + 1;
5	return 1;
6	}
7	const no_panic = std.debug.no_panic;
8	pub const panic = struct {
9	pub const call = myPanic;
10	pub fn integerOverflow() noreturn {
11	@panic("integer overflow");
12	}
13	pub const sentinelMismatch = no_panic.sentinelMismatch;
14	pub const unwrapError = no_panic.unwrapError;
15	pub const outOfBounds = no_panic.outOfBounds;
16	pub const startGreaterThanEnd = no_panic.startGreaterThanEnd;
17	pub const inactiveUnionField = no_panic.inactiveUnionField;
18	pub const sliceCastLenRemainder = no_panic.sliceCastLenRemainder;
19	pub const reachedUnreachable = no_panic.reachedUnreachable;
20	pub const unwrapNull = no_panic.unwrapNull;
21	pub const castToNull = no_panic.castToNull;
22	pub const incorrectAlignment = no_panic.incorrectAlignment;
23	pub const invalidErrorCode = no_panic.invalidErrorCode;
24	pub const unexpectedErrorCode = no_panic.unexpectedErrorCode;
25	pub const integerOutOfBounds = no_panic.integerOutOfBounds;
26	pub const shlOverflow = no_panic.shlOverflow;
27	pub const shrOverflow = no_panic.shrOverflow;
28	pub const divideByZero = no_panic.divideByZero;
29	pub const exactDivisionRemainder = no_panic.exactDivisionRemainder;
30	pub const integerPartOutOfBounds = no_panic.integerPartOutOfBounds;
31	pub const corruptSwitch = no_panic.corruptSwitch;
32	pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
33	pub const invalidEnumValue = no_panic.invalidEnumValue;
34	pub const forLenMismatch = no_panic.forLenMismatch;
35	pub const copyLenMismatch = no_panic.copyLenMismatch;
36	pub const memcpyAlias = no_panic.memcpyAlias;
37	pub const noreturnReturned = no_panic.noreturnReturned;
38	pub const loadUninstantiableType = no_panic.loadUninstantiableType;
39	};
40	fn myPanic(msg: []const u8, _: ?usize) noreturn {
41	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
42	stdout_writer.interface.print("new panic message: {s}\n", .{msg}) catch {};
43	std.process.exit(0);
44	}
45	const std = @import("std");
46	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental2/change_panic_handler_explicit/2/main.zig deleted-46

...	@@ -1,46 +0,0 @@
1	pub fn main() !u8 {
2	var a: u8 = undefined;
3	a = 255;
4	_ = a + 1;
5	return 1;
6	}
7	const no_panic = std.debug.no_panic;
8	pub const panic = struct {
9	pub const call = myPanicNew;
10	pub fn integerOverflow() noreturn {
11	@panic("integer overflow");
12	}
13	pub const sentinelMismatch = no_panic.sentinelMismatch;
14	pub const unwrapError = no_panic.unwrapError;
15	pub const outOfBounds = no_panic.outOfBounds;
16	pub const startGreaterThanEnd = no_panic.startGreaterThanEnd;
17	pub const inactiveUnionField = no_panic.inactiveUnionField;
18	pub const sliceCastLenRemainder = no_panic.sliceCastLenRemainder;
19	pub const reachedUnreachable = no_panic.reachedUnreachable;
20	pub const unwrapNull = no_panic.unwrapNull;
21	pub const castToNull = no_panic.castToNull;
22	pub const incorrectAlignment = no_panic.incorrectAlignment;
23	pub const invalidErrorCode = no_panic.invalidErrorCode;
24	pub const unexpectedErrorCode = no_panic.unexpectedErrorCode;
25	pub const integerOutOfBounds = no_panic.integerOutOfBounds;
26	pub const shlOverflow = no_panic.shlOverflow;
27	pub const shrOverflow = no_panic.shrOverflow;
28	pub const divideByZero = no_panic.divideByZero;
29	pub const exactDivisionRemainder = no_panic.exactDivisionRemainder;
30	pub const integerPartOutOfBounds = no_panic.integerPartOutOfBounds;
31	pub const corruptSwitch = no_panic.corruptSwitch;
32	pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
33	pub const invalidEnumValue = no_panic.invalidEnumValue;
34	pub const forLenMismatch = no_panic.forLenMismatch;
35	pub const copyLenMismatch = no_panic.copyLenMismatch;
36	pub const memcpyAlias = no_panic.memcpyAlias;
37	pub const noreturnReturned = no_panic.noreturnReturned;
38	pub const loadUninstantiableType = no_panic.loadUninstantiableType;
39	};
40	fn myPanicNew(msg: []const u8, _: ?usize) noreturn {
41	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &.{});
42	stdout_writer.interface.print("third panic message: {s}\n", .{msg}) catch {};
43	std.process.exit(0);
44	}
45	const std = @import("std");
46	const io = std.Io.Threaded.global_single_threaded.io();

test/incremental2/change_panic_handler_explicit/manifest deleted-23

...	@@ -1,23 +0,0 @@
1	#exe {
2	-Mroot=main.zig
3	#}
4
5	#write main.zig 0/main.zig
6	#update
7	#check stdout {
8	panic message: integer overflow
9	#}
10
11	#write main.zig 1/main.zig
12	#update {
13	change the panic handler body#}
14	#check stdout {
15	new panic message: integer overflow
16	#}
17
18	#write main.zig 2/main.zig
19	#update {
20	change the panic handler function value#}
21	#check stdout {
22	third panic message: integer overflow
23	#}

test/incremental2/hello deleted-28

...	@@ -1,28 +0,0 @@
1	#exe {
2	-Mroot=main.zig
3	#}
4
5	#write main.zig {
6	const std = @import("std");
7	const io = std.Io.Threaded.global_single_threaded.io();
8	pub fn main() !void {
9	try std.Io.File.stdout().writeStreamingAll(io, "good morning\n");
10	}
11	#}
12	#update
13	#check stdout {
14	good morning
15	#}
16
17	#write main.zig {
18	const std = @import("std");
19	const io = std.Io.Threaded.global_single_threaded.io();
20	pub fn main() !void {
21	try std.Io.File.stdout().writeStreamingAll(io, "おはようございます\n");
22	}
23	#}
24	#update {
25	change the string#}
26	#check stdout {
27	おはようございます
28	#}

test/src/runner.zig+14-5

 @@ -471,7 +471,7 @@ fn runTest(
             continue;
         }
         const cmd = std.meta.stringToEnum(
-            enum { skip, exe, lib, obj, write, delete, update, check },
+            enum { todo, skip, exe, lib, obj, write, delete, update, check },
             cmd_str,
         ) orelse return error.UnknownCommand;
         var maybe_arg = line_it.next();
 @@ -525,6 +525,7 @@ fn runTest(
         };
         defer cmd_prog_node.end();
         cmd: switch (cmd) {
+            .todo => _ = try contents_r.discardRemaining(),
             .skip => if (!allow_skip)
                 return error.NonInitialSkipCommand // #skip must appear first
             else if (std.mem.eql(u8, target_string, maybe_arg orelse return error.MissingArg))
 @@ -646,12 +647,12 @@ fn runTest(
                 update_num += 1;
             },
             .check => {
-                const expected = try contents_r.allocRemaining(gpa, .unlimited);
-                defer gpa.free(expected);
                 const check = std.meta.stringToEnum(
                     enum { errors, stdout, exit, lldb },
                     maybe_arg orelse return error.MissingCheckArg,
                 ) orelse return error.UnknownCheck;
+                const expected = try contents_r.allocRemaining(gpa, .unlimited);
+                defer gpa.free(expected);
                 const comp = &(compiler orelse return error.MissingCompiler);
                 if (comp.state != .update) return error.MissingUpdate;
 @@ -753,7 +754,9 @@ fn runTest(
                                     var error_aw: std.Io.Writer.Allocating = .init(gpa);
                                     defer error_aw.deinit();
                                     try error_bundle.renderToWriter(.{
+                                        .include_reference_trace = false,
                                         .include_source_line = false,
+                                        .include_log_text = true,
                                     }, &error_aw.writer);
                                     try std.testing.expectEqualStrings(expected, error_aw.written());
                                 },
 @@ -783,12 +786,18 @@ fn runTest(
             },
         }
         std.debug.assert(try contents_r.discardRemaining() == 0);
-        if (cmd != .skip) allow_skip = false;
+        switch (cmd) {
+            .todo, .skip => {},
+            else => allow_skip = false,
+        }
     } else |err| switch (err) {
         else => |e| return e,
         error.EndOfStream => if (skip_delimiter) return error.MissingDelimiter,
     }
-    if (compiler) |*comp| try comp.exit(io);
+    if (compiler) |*comp| {
+        if (comp.state != .idle) return error.MissingCheck;
+        try comp.exit(io);
+    }
 }
 const DelimitedReader = struct {
     const Io = std.Io;

test/tests.zig+3-96

...	@@ -3343,109 +3343,16 @@ const IncrementalTestOptions = struct {	...	@@ -3343,109 +3343,16 @@ const IncrementalTestOptions = struct {
3343	};	3343	};
3344		3344
3345	pub fn addIncrementalTests(	3345	pub fn addIncrementalTests(
3346	b: *std.Build,
3347	test_step: *Step,
3348	options: IncrementalTestOptions,
3349	) !void {
3350	const io = b.graph.io;
3351
3352	const incr_check = b.addExecutable(.{
3353	.name = "incr-check",
3354	.root_module = b.createModule(.{
3355	.root_source_file = b.path("tools/incr-check.zig"),
3356	.target = b.graph.host,
3357	.optimize = .debug,
3358	}),
3359	});
3360
3361	b.dependOnDirectoryContents(b.path("test/incremental"));
3362
3363	var dir = try b.root.openDir(io, "test/incremental", .{ .iterate = true });
3364	defer dir.close(io);
3365
3366	var it = try dir.walk(b.graph.arena);
3367	while (try it.next(io)) \|entry\| {
3368	if (isEditorFileName(entry.basename)) continue;
3369
3370	for (options.test_filters) \|test_filter\| {
3371	if (std.mem.find(u8, entry.path, test_filter)) \|_\| break;
3372	} else if (options.test_filters.len > 0) continue;
3373
3374	switch (entry.kind) {
3375	.file => {},
3376	.directory => {
3377	b.dependOnDirectoryContents(b.path(b.pathJoin(&.{ "test", "incremental", entry.path })));
3378	},
3379	else => continue,
3380	}
3381	b.dependOnFileContents(b.path(b.pathJoin(&.{ "test", "incremental", entry.path })));
3382
3383	for (incremental_targets) \|test_target\| {
3384	const resolved_target = b.resolveTargetQuery(test_target.target);
3385
3386	if (options.skip_non_native and !isNative(&resolved_target, &b.graph.host.result))
3387	continue;
3388
3389	const target = &resolved_target.result;
3390
3391	if (options.skip_wasm and target.cpu.arch.isWasm()) continue;
3392
3393	if (options.skip_freebsd and target.os.tag == .freebsd) continue;
3394	if (options.skip_netbsd and target.os.tag == .netbsd) continue;
3395	if (options.skip_openbsd and target.os.tag == .openbsd) continue;
3396	if (options.skip_windows and target.os.tag == .windows) continue;
3397	if (options.skip_darwin and target.os.tag.isDarwin()) continue;
3398	if (options.skip_linux and target.os.tag == .linux) continue;
3399
3400	if (options.skip_llvm and test_target.backend == .llvm) continue;
3401
3402	const target_str = b.fmt("{s}-{t}", .{
3403	resolved_target.query.zigTriple(b.allocator) catch @panic("OOM"),
3404	test_target.backend,
3405	});
3406
3407	if (options.test_target_filters.len > 0) {
3408	for (options.test_target_filters) \|filter\| {
3409	if (std.mem.find(u8, target_str, filter) != null) break;
3410	} else continue;
3411	}
3412
3413	const run = b.addRunArtifact(incr_check);
3414	run.setName(b.fmt("incr-check {s} '{s}'", .{ target_str, entry.basename }));
3415
3416	run.addArg(b.graph.zig_exe);
3417	run.addFileArg(b.path("test/incremental/").path(b, entry.path));
3418
3419	run.addArg("--zig-lib-dir");
3420	run.addDirectoryArg(.zig_lib);
3421
3422	run.addArgs(&.{ "--target", target_str });
3423
3424	run.addArg("--quiet"); // don't fill stderr telling us about skipped tests etc
3425
3426	run.addThirdPartyEnabledArgDarling(.{ .enabled = "-fdarling" });
3427	run.addThirdPartyEnabledArgQemu(.{ .enabled = "-fqemu" });
3428	run.addThirdPartyEnabledArgRosetta(.{ .enabled = "-frosetta" });
3429	run.addThirdPartyEnabledArgWasmtime(.{ .enabled = "-fwasmtime" });
3430	run.addThirdPartyEnabledArgWine(.{ .enabled = "-fwine" });
3431
3432	run.addCheck(.{ .expect_term = .{ .exited = 0 } });
3433	test_step.dependOn(&run.step);
3434	}
3435	}
3436	}
3437
3438	pub fn addNewIncrementalTests(
3439	b: *std.Build,	3346	b: *std.Build,
3440	runner: *std.Build.Step.Compile,	3347	runner: *std.Build.Step.Compile,
3441	options: IncrementalTestOptions,	3348	options: IncrementalTestOptions,
3442	) !*Step {	3349	) !*Step {
3443	const tests_step = b.step("test-new-incremental", "Run the new incremental compilation test cases");	3350	const tests_step = b.step("test-incremental", "Run the new incremental compilation test cases");
3444		3351
3445	const tests_path = b.path("test/incremental2");	3352	const tests_path = b.path("test/incremental");
3446	b.dependOnDirectoryContents(tests_path);	3353	b.dependOnDirectoryContents(tests_path);
3447		3354
3448	var tests_dir = try b.root.openDir(b.graph.io, "test/incremental2", .{ .iterate = true });	3355	var tests_dir = try b.root.openDir(b.graph.io, "test/incremental", .{ .iterate = true });
3449	defer tests_dir.close(b.graph.io);	3356	defer tests_dir.close(b.graph.io);
3450	var test_it = tests_dir.iterate();	3357	var test_it = tests_dir.iterate();
3451	while (try test_it.next(b.graph.io)) \|@"test"\| {	3358	while (try test_it.next(b.graph.io)) \|@"test"\| {

tools/incr-check.zig deleted-1032

...	@@ -1,1032 +0,0 @@
1	const std = @import("std");
2	const Io = std.Io;
3	const Dir = std.Io.Dir;
4	const Allocator = std.mem.Allocator;
5	const Cache = std.Build.Cache;
6
7	const usage =
8	\\Usage: incr-check <zig binary path> <input file> [options]
9	\\Options:
10	\\ --target triple-backend
11	\\ --quiet
12	\\ --zig-lib-dir /path/to/zig/lib
13	\\ --zig-cc-binary /path/to/zig
14	\\ -fqemu
15	\\ -fwine
16	\\ -fwasmtime
17	\\Debug Options:
18	\\ --preserve-tmp
19	\\ --debug-log foo
20	\\ --debug-link-snapshot
21	;
22
23	pub const std_options: std.Options = .{
24	.logFn = logImpl,
25	};
26	var log_cur_update: ?*const Case.Update = null;
27	fn logImpl(
28	comptime level: std.log.Level,
29	comptime scope: @EnumLiteral(),
30	comptime format: []const u8,
31	args: anytype,
32	) void {
33	const update = log_cur_update orelse {
34	return std.log.defaultLog(level, scope, format, args);
35	};
36	std.log.defaultLog(
37	level,
38	scope,
39	"['{s}'] " ++ format,
40	.{update.name} ++ args,
41	);
42	}
43
44	pub fn main(init: std.process.Init) !void {
45	const gpa = init.gpa;
46	const arena = init.arena.allocator();
47	const io = init.io;
48	const environ_map = init.environ_map;
49	const cwd_path = try std.process.currentPathAlloc(io, arena);
50
51	var opt_zig_exe: ?[]const u8 = null;
52	var opt_input_file_name: ?[]const u8 = null;
53	var opt_lib_dir: ?[]const u8 = null;
54	var opt_cc_zig: ?[]const u8 = null;
55	var opt_target: ?struct { std.Target.Query, Backend } = null;
56	var preserve_tmp = false;
57	var enable_qemu: bool = false;
58	var enable_wine: bool = false;
59	var enable_wasmtime: bool = false;
60	var enable_darling: bool = false;
61	var quiet: bool = false;
62
63	var debug_log_args: std.ArrayList([]const u8) = .empty;
64	var debug_link_snapshot = false;
65
66	var arg_it = try init.minimal.args.iterateAllocator(arena);
67	_ = arg_it.skip();
68	while (arg_it.next()) \|arg\| {
69	if (arg.len > 0 and arg[0] == '-') {
70	if (std.mem.eql(u8, arg, "--zig-lib-dir")) {
71	opt_lib_dir = arg_it.next() orelse badUsage("expected arg after --zig-lib-dir", .{});
72	} else if (std.mem.eql(u8, arg, "--target")) {
73	const str = arg_it.next() orelse badUsage("expected arg after --zig-cc-binary", .{});
74	opt_target = parseTargetQueryAndBackend(str, "");
75	} else if (std.mem.eql(u8, arg, "--quiet")) {
76	quiet = true;
77	} else if (std.mem.eql(u8, arg, "--debug-log")) {
78	try debug_log_args.append(
79	arena,
80	arg_it.next() orelse badUsage("expected arg after --debug-log", .{}),
81	);
82	} else if (std.mem.eql(u8, arg, "--debug-link-snapshot")) {
83	debug_link_snapshot = true;
84	} else if (std.mem.eql(u8, arg, "--preserve-tmp")) {
85	preserve_tmp = true;
86	} else if (std.mem.eql(u8, arg, "-fqemu")) {
87	enable_qemu = true;
88	} else if (std.mem.eql(u8, arg, "-fwine")) {
89	enable_wine = true;
90	} else if (std.mem.eql(u8, arg, "-fwasmtime")) {
91	enable_wasmtime = true;
92	} else if (std.mem.eql(u8, arg, "-fdarling")) {
93	enable_darling = true;
94	} else if (std.mem.eql(u8, arg, "--zig-cc-binary")) {
95	opt_cc_zig = arg_it.next() orelse badUsage("expected arg after --zig-cc-binary", .{});
96	} else {
97	badUsage("unknown option '{s}'", .{arg});
98	}
99	continue;
100	}
101	if (opt_zig_exe == null) {
102	opt_zig_exe = arg;
103	} else if (opt_input_file_name == null) {
104	opt_input_file_name = arg;
105	} else {
106	badUsage("unknown argument '{s}'\n{s}", .{ arg, usage });
107	}
108	}
109	const zig_exe = opt_zig_exe orelse badUsage("missing path to zig", .{});
110	const input_file_name = opt_input_file_name orelse badUsage("missing input file", .{});
111	const target_query, const backend = opt_target orelse badUsage("missing required option '--target'", .{});
112
113	if (backend == .cbe and opt_lib_dir == null) {
114	std.process.fatal("'--zig-lib-dir' required when using backend 'cbe'", .{});
115	}
116
117	const input_file_bytes = try Dir.cwd().readFileAlloc(io, input_file_name, arena, .limited(std.math.maxInt(u32)));
118	const case: Case = try .parse(arena, input_file_bytes);
119
120	for (case.skip_targets) \|skip\| {
121	if (target_query.eql(skip.query) and backend == skip.backend) {
122	if (!quiet) std.log.warn("skipping test because of a 'skip_target' match", .{});
123	return;
124	}
125	}
126
127	const target = try std.zig.system.resolveTargetQuery(io, target_query);
128
129	const prog_node = std.Progress.start(io, .{});
130	defer prog_node.end();
131
132	const rand_int = rand64(io);
133	const tmp_dir_path = "tmp_" ++ std.fmt.hex(rand_int);
134	var tmp_dir = try Dir.cwd().createDirPathOpen(io, tmp_dir_path, .{});
135	defer {
136	tmp_dir.close(io);
137	if (!preserve_tmp) {
138	Dir.cwd().deleteTree(io, tmp_dir_path) catch \|err\| {
139	std.log.warn("failed to delete tree '{s}': {t}", .{ tmp_dir_path, err });
140	};
141	}
142	}
143
144	// Convert paths to be relative to the cwd of the subprocess.
145	const resolved_zig_exe = try Dir.path.relative(arena, cwd_path, environ_map, tmp_dir_path, zig_exe);
146	const opt_resolved_lib_dir = if (opt_lib_dir) \|lib_dir\|
147	try Dir.path.relative(arena, cwd_path, environ_map, tmp_dir_path, lib_dir)
148	else
149	null;
150
151	const host = try std.zig.system.resolveTargetQuery(io, .{});
152
153	var child_args: std.ArrayList([]const u8) = .empty;
154	try child_args.appendSlice(arena, &.{
155	resolved_zig_exe, "build-exe",
156	"-fincremental", "-fno-ubsan-rt",
157	"-target", try target_query.zigTriple(arena),
158	"--cache-dir", ".local-cache",
159	"--global-cache-dir", ".global-cache",
160	});
161
162	if (opt_resolved_lib_dir) \|resolved_lib_dir\| {
163	try child_args.appendSlice(arena, &.{ "--zig-lib-dir", resolved_lib_dir });
164	}
165	switch (backend) {
166	.sema => try child_args.append(arena, "-fno-emit-bin"),
167	.selfhosted => try child_args.appendSlice(arena, &.{ "-fno-llvm", "-fno-lld" }),
168	.llvm => try child_args.appendSlice(arena, &.{ "-fllvm", "-flld" }),
169	.cbe => try child_args.appendSlice(arena, &.{ "-ofmt=c", "-lc" }),
170	}
171	for (debug_log_args.items) \|arg\| {
172	try child_args.appendSlice(arena, &.{ "--debug-log", arg });
173	}
174	if (debug_link_snapshot) {
175	try child_args.append(arena, "--debug-link-snapshot");
176	}
177	for (case.modules) \|mod\| {
178	try child_args.appendSlice(arena, &.{ "--dep", mod.name });
179	}
180	try child_args.append(arena, try std.fmt.allocPrint(arena, "-Mroot={s}", .{case.root_source_file}));
181	for (case.modules) \|mod\| {
182	try child_args.append(arena, try std.fmt.allocPrint(arena, "-M{s}={s}", .{ mod.name, mod.file }));
183	}
184	try child_args.append(arena, "--listen=-");
185
186	const zig_prog_node = prog_node.start("zig", 0);
187	defer zig_prog_node.end();
188
189	var cc_child_args: std.ArrayList([]const u8) = .empty;
190	if (backend == .cbe) {
191	const resolved_cc_zig_exe = if (opt_cc_zig) \|cc_zig_exe\|
192	try Dir.path.relative(arena, cwd_path, environ_map, tmp_dir_path, cc_zig_exe)
193	else
194	resolved_zig_exe;
195
196	try cc_child_args.appendSlice(arena, &.{
197	resolved_cc_zig_exe, "build-exe",
198	"-target", try target_query.zigTriple(arena),
199	"--cache-dir", ".local-cache",
200	"--global-cache-dir", ".global-cache",
201	"-I", opt_resolved_lib_dir.?, // verified earlier
202	"-lc",
203	});
204	}
205
206	const allow_compiler_stderr = debug_log_args.items.len != 0;
207
208	if (allow_compiler_stderr) {
209	const cmd: std.zig.SubprocessCommand = .{
210	.argv = child_args.items,
211	.cwd = tmp_dir_path,
212	};
213	std.log.scoped(.spawn).info("{f}", .{cmd});
214	}
215
216	var child = try std.process.spawn(io, .{
217	.argv = child_args.items,
218	.stdin = .pipe,
219	.stdout = .pipe,
220	.stderr = .pipe,
221	.progress_node = zig_prog_node,
222	.cwd = .{ .path = tmp_dir_path },
223	});
224	defer child.kill(io);
225
226	const updates_prog_node = prog_node.start("updates", case.updates.len);
227	defer updates_prog_node.end();
228
229	var eval: Eval = .{
230	.arena = arena,
231	.io = io,
232	.case = case,
233	.host = host,
234	.target = target,
235	.backend = backend,
236	.tmp_dir = tmp_dir,
237	.tmp_dir_path = tmp_dir_path,
238	.child = &child,
239	.allow_compiler_stderr = allow_compiler_stderr,
240	.quiet = quiet,
241	.preserve_tmp_on_fatal = preserve_tmp,
242	.cc_child_args = &cc_child_args,
243	.enable_qemu = enable_qemu,
244	.enable_wine = enable_wine,
245	.enable_wasmtime = enable_wasmtime,
246	.enable_darling = enable_darling,
247	};
248
249	var multi_reader_buffer: Io.File.MultiReader.Buffer(2) = undefined;
250	var multi_reader: Io.File.MultiReader = undefined;
251	multi_reader.init(gpa, io, multi_reader_buffer.toStreams(), &.{ child.stdout.?, child.stderr.? });
252	defer multi_reader.deinit();
253
254	var update_mtime = Io.Clock.real.now(io);
255	for (case.updates) \|update\| {
256	var update_prog_node = updates_prog_node.start(update.name, 0);
257	defer update_prog_node.end();
258
259	if (debug_log_args.items.len != 0) {
260	// Print a line separating the debug logs from the compiler in the stderr output.
261	std.log.scoped(.status).info("update: '{s}'", .{update.name});
262	}
263
264	log_cur_update = &update;
265	defer log_cur_update = null;
266
267	eval.write(update, update_mtime);
268	update_mtime = update_mtime.addDuration(.fromSeconds(5));
269	try eval.requestUpdate();
270	try eval.check(&multi_reader, update, update_prog_node);
271	}
272
273	try eval.end(&multi_reader);
274
275	waitChild(&child, &eval);
276	}
277
278	const Eval = struct {
279	arena: Allocator,
280	io: Io,
281	case: Case,
282	host: std.Target,
283	target: std.Target,
284	backend: Backend,
285	tmp_dir: Dir,
286	tmp_dir_path: []const u8,
287	child: *std.process.Child,
288	allow_compiler_stderr: bool,
289	quiet: bool,
290	preserve_tmp_on_fatal: bool,
291	/// When `backend == .cbe`, this contains the first few arguments to `zig cc` to build the generated binary.
292	/// The arguments `out.c in.c` must be appended before spawning the subprocess.
293	cc_child_args: *std.ArrayList([]const u8),
294
295	enable_qemu: bool,
296	enable_wine: bool,
297	enable_wasmtime: bool,
298	enable_darling: bool,
299
300	/// Currently this function assumes the previous updates have already been written.
301	fn write(eval: *Eval, update: Case.Update, mtime: Io.Timestamp) void {
302	const io = eval.io;
303	for (update.changes) \|full_contents\| {
304	var update_file = eval.tmp_dir.createFile(io, full_contents.name, .{}) catch \|err\| {
305	eval.fatal("failed to create update '{s}': {t}", .{ full_contents.name, err });
306	};
307	defer update_file.close(io);
308	update_file.writeStreamingAll(io, full_contents.bytes) catch \|err\| {
309	eval.fatal("failed to write update '{s}': {t}", .{ full_contents.name, err });
310	};
311	update_file.setTimestamps(io, .{ .modify_timestamp = .{ .new = mtime } }) catch \|err\| {
312	eval.fatal("failed to set mtime for '{s}': {t}", .{ full_contents.name, err });
313	};
314	}
315	for (update.deletes) \|doomed_name\| {
316	eval.tmp_dir.deleteFile(io, doomed_name) catch \|err\| {
317	eval.fatal("failed to delete '{s}': {t}", .{ doomed_name, err });
318	};
319	}
320	}
321
322	fn check(eval: Eval, mr: Io.File.MultiReader, update: Case.Update, prog_node: std.Progress.Node) !void {
323	const arena = eval.arena;
324	const stdout = mr.reader(0);
325	const stderr = mr.reader(1);
326
327	var client: std.zig.Client = .{
328	.in = stdout,
329	.out = undefined,
330	};
331
332	while (true) {
333	const header = client.receiveMessageWithMultiReader(mr, .none) catch \|err\| switch (err) {
334	error.Timeout => unreachable,
335	error.EndOfStream => break,
336	else => \|e\| return e,
337	};
338	const body = client.in.take(header.bytes_len) catch unreachable;
339
340	switch (header.tag) {
341	.error_bundle => {
342	const result_error_bundle = try std.zig.Server.allocErrorBundle(arena, body);
343	if (stderr.bufferedLen() > 0) {
344	if (eval.allow_compiler_stderr) {
345	std.log.info("error_bundle stderr:\n{s}", .{stderr.buffered()});
346	} else {
347	eval.fatal("error_bundle unexpected stderr:\n{s}", .{stderr.buffered()});
348	}
349	stderr.tossBuffered();
350	}
351	if (result_error_bundle.errorMessageCount() != 0) {
352	try eval.checkErrorOutcome(update, result_error_bundle);
353	}
354	// This message indicates the end of the update.
355	return;
356	},
357	.emit_digest => {
358	var r: std.Io.Reader = .fixed(body);
359	_ = r.takeStruct(std.zig.Server.Message.EmitDigest, .little) catch unreachable;
360
361	if (stderr.bufferedLen() > 0) {
362	if (eval.allow_compiler_stderr) {
363	std.log.info("emit_digest stderr:\n{s}", .{stderr.buffered()});
364	} else {
365	eval.fatal("emit_digest unexpected stderr:\n{s}", .{stderr.buffered()});
366	}
367	stderr.tossBuffered();
368	}
369	if (eval.backend == .sema) {
370	try eval.checkSuccessOutcome(update, null, prog_node);
371	continue;
372	}
373
374	const digest = r.takeArray(Cache.bin_digest_len) catch unreachable;
375	const result_dir = ".local-cache" ++ Dir.path.sep_str ++ "o" ++ Dir.path.sep_str ++ Cache.binToHex(digest.*);
376
377	const bin_name = try std.zig.EmitArtifact.bin.cacheName(arena, .{
378	.root_name = "root", // corresponds to the module name "root"
379	.cpu_arch = eval.target.cpu.arch,
380	.os_tag = eval.target.os.tag,
381	.ofmt = eval.target.ofmt,
382	.abi = eval.target.abi,
383	.output_mode = .Exe,
384	});
385	const bin_path = try Dir.path.join(arena, &.{ result_dir, bin_name });
386
387	try eval.checkSuccessOutcome(update, bin_path, prog_node);
388	},
389	else => {
390	// Ignore other messages.
391	},
392	}
393	}
394
395	const buffered_stderr = stderr.buffered();
396	if (buffered_stderr.len > 0) {
397	if (eval.allow_compiler_stderr) {
398	std.log.info("stderr:\n{s}", .{buffered_stderr});
399	} else {
400	eval.fatal("unexpected stderr:\n{s}", .{buffered_stderr});
401	}
402	}
403
404	waitChild(eval.child, eval);
405	eval.fatal("compiler failed to send terminating error_bundle", .{});
406	}
407
408	fn checkErrorOutcome(eval: *Eval, update: Case.Update, error_bundle: std.zig.ErrorBundle) !void {
409	const io = eval.io;
410	const expected = switch (update.outcome) {
411	.unknown => return,
412	.compile_errors => \|ce\| ce,
413	.stdout, .exit_code => {
414	try error_bundle.renderToStderr(io, .{}, .auto);
415	eval.fatal("unexpected compile errors", .{});
416	},
417	};
418
419	var expected_idx: usize = 0;
420
421	for (error_bundle.getMessages()) \|err_idx\| {
422	if (expected_idx == expected.errors.len) {
423	try error_bundle.renderToStderr(io, .{}, .auto);
424	eval.fatal("more errors than expected", .{});
425	}
426	try eval.checkOneError(error_bundle, expected.errors[expected_idx], false, err_idx);
427	expected_idx += 1;
428
429	for (error_bundle.getNotes(err_idx)) \|note_idx\| {
430	if (expected_idx == expected.errors.len) {
431	try error_bundle.renderToStderr(io, .{}, .auto);
432	eval.fatal("more error notes than expected", .{});
433	}
434	try eval.checkOneError(error_bundle, expected.errors[expected_idx], true, note_idx);
435	expected_idx += 1;
436	}
437	}
438
439	if (!std.mem.eql(u8, error_bundle.getCompileLogOutput(), expected.compile_log_output)) {
440	try error_bundle.renderToStderr(io, .{}, .auto);
441	eval.fatal("unexpected compile log output", .{});
442	}
443	}
444
445	fn checkOneError(
446	eval: *Eval,
447	eb: std.zig.ErrorBundle,
448	expected: Case.ExpectedError,
449	is_note: bool,
450	err_idx: std.zig.ErrorBundle.MessageIndex,
451	) Allocator.Error!void {
452	const io = eval.io;
453	const err = eb.getErrorMessage(err_idx);
454	if (err.count != 1) @panic("TODO error message with count>1");
455	const msg = eb.nullTerminatedString(err.msg);
456	const matches = matches: {
457	if (expected.is_note != is_note) break :matches false;
458	if (!std.mem.eql(u8, expected.msg, msg)) break :matches false;
459	if (err.src_loc == .none) {
460	break :matches expected.src == null;
461	}
462	const expected_src = expected.src orelse break :matches false;
463	const src = eb.getSourceLocation(err.src_loc);
464	const raw_filename = eb.nullTerminatedString(src.src_path);
465	// We need to replace backslashes for consistency between platforms.
466	const filename = name: {
467	if (std.mem.findScalar(u8, raw_filename, '\\') == null) break :name raw_filename;
468	const copied = try eval.arena.dupe(u8, raw_filename);
469	std.mem.replaceScalar(u8, copied, '\\', '/');
470	break :name copied;
471	};
472	if (!std.mem.eql(u8, expected_src.filename, filename)) break :matches false;
473	if (expected_src.line != src.line + 1) break :matches false;
474	if (expected_src.column != src.column + 1) break :matches false;
475	break :matches true;
476	};
477	if (!matches) {
478	eb.renderToStderr(io, .{}, .auto) catch {};
479	eval.fatal("compile error did not match expected error", .{});
480	}
481	}
482
483	fn checkSuccessOutcome(eval: *Eval, update: Case.Update, opt_emitted_path: ?[]const u8, prog_node: std.Progress.Node) !void {
484	switch (update.outcome) {
485	.unknown => return,
486	.compile_errors => eval.fatal("expected compile errors but compilation incorrectly succeeded", .{}),
487	.stdout, .exit_code => {},
488	}
489	const emitted_path = opt_emitted_path orelse {
490	std.debug.assert(eval.backend == .sema);
491	return;
492	};
493	const io = eval.io;
494
495	const binary_path = switch (eval.backend) {
496	.sema => unreachable,
497	.selfhosted, .llvm => emitted_path,
498	.cbe => bin: {
499	const rand_int = rand64(io);
500	const out_bin_name = "./out_" ++ std.fmt.hex(rand_int);
501	try eval.buildCOutput(emitted_path, out_bin_name, prog_node);
502	break :bin out_bin_name;
503	},
504	};
505
506	var argv_buf: [2][]const u8 = undefined;
507	const argv: []const []const u8, const is_foreign: bool = sw: switch (std.zig.system.getExternalExecutor(
508	io,
509	&eval.target,
510	.{
511	.link_libc = eval.backend == .cbe,
512	.host_cpu_arch = eval.host.cpu.arch,
513	.host_os_tag = eval.host.os.tag,
514	},
515	)) {
516	.bad_dl, .bad_os_or_cpu => {
517	// This binary cannot be executed on this host.
518	if (!eval.quiet) {
519	std.log.warn("skipping execution because host '{s}' cannot execute binaries for foreign target '{s}'", .{
520	try eval.host.zigTriple(eval.arena),
521	try eval.target.zigTriple(eval.arena),
522	});
523	}
524	return;
525	},
526	.native, .rosetta => argv: {
527	argv_buf[0] = binary_path;
528	break :argv .{ argv_buf[0..1], false };
529	},
530	.qemu => \|executor_cmd\| argv: {
531	if (eval.enable_qemu) {
532	argv_buf[0] = executor_cmd;
533	argv_buf[1] = binary_path;
534	break :argv .{ argv_buf[0..2], true };
535	} else {
536	continue :sw .bad_os_or_cpu;
537	}
538	},
539	.wine => \|executor_cmd\| argv: {
540	if (eval.enable_wine) {
541	argv_buf[0] = executor_cmd;
542	argv_buf[1] = binary_path;
543	break :argv .{ argv_buf[0..2], true };
544	} else {
545	continue :sw .bad_os_or_cpu;
546	}
547	},
548	.wasmtime => \|executor_cmd\| argv: {
549	if (eval.enable_wasmtime) {
550	argv_buf[0] = executor_cmd;
551	argv_buf[1] = binary_path;
552	break :argv .{ argv_buf[0..2], true };
553	} else {
554	continue :sw .bad_os_or_cpu;
555	}
556	},
557	.darling => \|executor_cmd\| argv: {
558	if (eval.enable_darling) {
559	argv_buf[0] = executor_cmd;
560	argv_buf[1] = binary_path;
561	break :argv .{ argv_buf[0..2], true };
562	} else {
563	continue :sw .bad_os_or_cpu;
564	}
565	},
566	};
567
568	const run_prog_node = prog_node.start("run generated executable", 0);
569	defer run_prog_node.end();
570
571	const result = std.process.run(eval.arena, io, .{
572	.argv = argv,
573	.cwd = .{ .path = eval.tmp_dir_path },
574	}) catch \|err\| {
575	if (is_foreign) {
576	// Chances are the foreign executor isn't available. Skip this evaluation.
577	if (!eval.quiet) {
578	std.log.warn("skipping execution of '{s}' via executor for foreign target '{s}': {t}", .{
579	binary_path,
580	try eval.target.zigTriple(eval.arena),
581	err,
582	});
583	}
584	return;
585	}
586	eval.fatal("failed to run the generated executable '{s}': {t}", .{ binary_path, err });
587	};
588
589	// Some executors (looking at you, Wine) like throwing some stderr in, just for fun.
590	// Therefore, we'll ignore stderr when using a foreign executor.
591	if (!is_foreign and result.stderr.len != 0) {
592	std.log.err("generated executable '{s}' had unexpected stderr:\n{s}", .{
593	binary_path, result.stderr,
594	});
595	}
596
597	switch (result.term) {
598	.exited => \|code\| switch (update.outcome) {
599	.unknown, .compile_errors => unreachable,
600	.stdout => \|expected_stdout\| {
601	if (code != 0) {
602	eval.fatal("generated executable '{s}' failed with code {d}", .{ binary_path, code });
603	}
604	try std.testing.expectEqualStrings(expected_stdout, result.stdout);
605	},
606	.exit_code => \|expected_code\| try std.testing.expectEqual(expected_code, code),
607	},
608	.signal => \|sig\| {
609	eval.fatal("generated executable '{s}' terminated with signal {t}", .{ binary_path, sig });
610	},
611	.stopped => \|sig\| {
612	eval.fatal("generated executable '{s}' stopped with signal {t}", .{ binary_path, sig });
613	},
614	.unknown => {
615	eval.fatal("generated executable '{s}' terminated unexpectedly", .{binary_path});
616	},
617	}
618
619	if (!is_foreign and result.stderr.len != 0) std.process.exit(1);
620	}
621
622	fn requestUpdate(eval: *Eval) !void {
623	const io = eval.io;
624
625	var w = eval.child.stdin.?.writerStreaming(io, &.{});
626	var client: std.zig.Client = .{
627	.in = undefined,
628	.out = &w.interface,
629	};
630	client.serveBodylessMessage(.update) catch \|err\| switch (err) {
631	error.WriteFailed => return w.err.?,
632	};
633	}
634
635	fn end(eval: Eval, mr: Io.File.MultiReader) !void {
636	requestExit(eval.child, eval);
637
638	var client: std.zig.Client = .{
639	.in = mr.reader(0),
640	.out = undefined,
641	};
642
643	while (true) {
644	const header = client.receiveMessageWithMultiReader(mr, .none) catch \|err\| switch (err) {
645	error.Timeout => unreachable,
646	error.EndOfStream => \|e\| {
647	if (client.in.bufferedLen() == 0) break;
648	return e;
649	},
650	else => \|e\| return e,
651	};
652	try client.in.discardAll(header.bytes_len);
653	}
654
655	const stderr = mr.reader(1).buffered();
656	if (stderr.len > 0) eval.fatal("unexpected stderr:\n{s}", .{stderr});
657	}
658
659	fn buildCOutput(eval: *Eval, c_path: []const u8, out_path: []const u8, prog_node: std.Progress.Node) !void {
660	std.debug.assert(eval.cc_child_args.items.len > 0);
661
662	const child_prog_node = prog_node.start("build cbe output", 0);
663	defer child_prog_node.end();
664
665	try eval.cc_child_args.append(eval.arena, try std.fmt.allocPrint(eval.arena, "-femit-bin={s}", .{out_path}));
666	try eval.cc_child_args.append(eval.arena, c_path);
667	defer eval.cc_child_args.items.len -= 2;
668
669	if (eval.allow_compiler_stderr) {
670	const cmd: std.zig.SubprocessCommand = .{
671	.argv = eval.cc_child_args.items,
672	.cwd = eval.tmp_dir_path,
673	};
674	std.log.scoped(.spawn).info("{f}", .{cmd});
675	}
676
677	const result = std.process.run(eval.arena, eval.io, .{
678	.argv = eval.cc_child_args.items,
679	.cwd = .{ .path = eval.tmp_dir_path },
680	.progress_node = child_prog_node,
681	}) catch \|err\| {
682	eval.fatal("failed to spawn zig cc for '{s}': {t}", .{ c_path, err });
683	};
684
685	if (result.term == .exited and result.term.exited == 0) return;
686
687	if (result.stderr.len != 0) {
688	std.log.err("zig cc stderr:\n{s}", .{result.stderr});
689	}
690	switch (result.term) {
691	.exited => \|code\| eval.fatal("zig cc for '{s}' failed with code {d}", .{ c_path, code }),
692	.signal => \|sig\| eval.fatal("zig cc for '{s}' terminated unexpectedly with signal {t}", .{ c_path, sig }),
693	.stopped => \|sig\| eval.fatal("zig cc for '{s}' stopped unexpectedly with signal {t}", .{ c_path, sig }),
694	.unknown => eval.fatal("zig cc for '{s}' terminated unexpectedly", .{c_path}),
695	}
696	}
697
698	fn fatal(eval: *Eval, comptime fmt: []const u8, args: anytype) noreturn {
699	const io = eval.io;
700	eval.tmp_dir.close(io);
701	if (!eval.preserve_tmp_on_fatal) {
702	// Kill the child since it holds an open handle to its CWD which is the tmp dir path
703	eval.child.kill(io);
704	Dir.cwd().deleteTree(io, eval.tmp_dir_path) catch \|err\| {
705	std.log.warn("failed to delete tree '{s}': {t}", .{ eval.tmp_dir_path, err });
706	};
707	}
708	std.process.fatal(fmt, args);
709	}
710	};
711
712	const Backend = enum {
713	/// Run semantic analysis only. Runtime output will not be tested, but we still verify
714	/// that compilation succeeds. Corresponds to `-fno-emit-bin`.
715	sema,
716	/// Use the self-hosted code generation backend for this target.
717	/// Corresponds to `-fno-llvm -fno-lld`.
718	selfhosted,
719	/// Use the LLVM backend.
720	/// Corresponds to `-fllvm -flld`.
721	llvm,
722	/// Use the C backend. The output is compiled with `zig cc`.
723	/// Corresponds to `-ofmt=c`.
724	cbe,
725	};
726
727	const Case = struct {
728	updates: []Update,
729	root_source_file: []const u8,
730	skip_targets: []const SkipTarget,
731	modules: []const Module,
732
733	const SkipTarget = struct {
734	query: std.Target.Query,
735	backend: Backend,
736	};
737
738	const Module = struct {
739	name: []const u8,
740	file: []const u8,
741	};
742
743	const Update = struct {
744	name: []const u8,
745	outcome: Outcome,
746	changes: []const FullContents = &.{},
747	deletes: []const []const u8 = &.{},
748	};
749
750	const FullContents = struct {
751	name: []const u8,
752	bytes: []const u8,
753	};
754
755	const Outcome = union(enum) {
756	unknown,
757	compile_errors: struct {
758	errors: []const ExpectedError,
759	compile_log_output: []const u8,
760	},
761	stdout: []const u8,
762	exit_code: u8,
763	};
764
765	const ExpectedError = struct {
766	is_note: bool,
767	msg: []const u8,
768	src: ?struct {
769	filename: []const u8,
770	line: u32,
771	column: u32,
772	},
773	};
774
775	fn parse(arena: Allocator, bytes: []const u8) !Case {
776	const fatal = std.process.fatal;
777
778	var skip_targets: std.ArrayList(SkipTarget) = .empty;
779	var modules: std.ArrayList(Module) = .empty;
780	var updates: std.ArrayList(Update) = .empty;
781	var changes: std.ArrayList(FullContents) = .empty;
782	var deletes: std.ArrayList([]const u8) = .empty;
783	var it = std.mem.splitScalar(u8, bytes, '\n');
784	var line_n: usize = 1;
785	var root_source_file: ?[]const u8 = null;
786	while (it.next()) \|line\| : (line_n += 1) {
787	if (std.mem.startsWith(u8, line, "#")) {
788	var line_it = std.mem.splitScalar(u8, line, '=');
789	const key = line_it.first()[1..];
790	const val = std.mem.trimEnd(u8, line_it.rest(), "\r"); // windows moment
791	if (val.len == 0) {
792	fatal("line {d}: missing value", .{line_n});
793	} else if (std.mem.eql(u8, key, "skip_target")) {
794	const query, const backend = parseTargetQueryAndBackend(
795	val,
796	try std.fmt.allocPrint(arena, "line {d}: ", .{line_n}),
797	);
798	try skip_targets.append(arena, .{
799	.query = query,
800	.backend = backend,
801	});
802	} else if (std.mem.eql(u8, key, "module")) {
803	const split_idx = std.mem.findScalar(u8, val, '=') orelse
804	fatal("line {d}: module does not include file", .{line_n});
805	const name = val[0..split_idx];
806	const file = val[split_idx + 1 ..];
807	try modules.append(arena, .{
808	.name = name,
809	.file = file,
810	});
811	} else if (std.mem.eql(u8, key, "update")) {
812	if (updates.items.len > 0) {
813	const last_update = &updates.items[updates.items.len - 1];
814	last_update.changes = try changes.toOwnedSlice(arena);
815	last_update.deletes = try deletes.toOwnedSlice(arena);
816	}
817	try updates.append(arena, .{
818	.name = val,
819	.outcome = .unknown,
820	});
821	} else if (std.mem.eql(u8, key, "file")) {
822	if (updates.items.len == 0) fatal("line {d}: file directive before update", .{line_n});
823
824	if (root_source_file == null)
825	root_source_file = val;
826
827	// Because Windows is so excellent, we need to convert CRLF to LF, so
828	// can't just slice into the input here. How delightful!
829	var src: std.ArrayList(u8) = .empty;
830
831	while (true) {
832	const next_line_raw = it.peek() orelse fatal("line {d}: unexpected EOF", .{line_n});
833	const next_line = std.mem.trimEnd(u8, next_line_raw, "\r");
834	if (std.mem.startsWith(u8, next_line, "#")) break;
835
836	_ = it.next();
837	line_n += 1;
838
839	try src.ensureUnusedCapacity(arena, next_line.len + 1);
840	src.appendSliceAssumeCapacity(next_line);
841	src.appendAssumeCapacity('\n');
842	}
843
844	try changes.append(arena, .{
845	.name = val,
846	.bytes = src.items,
847	});
848	} else if (std.mem.eql(u8, key, "rm_file")) {
849	if (updates.items.len == 0) fatal("line {d}: rm_file directive before update", .{line_n});
850	try deletes.append(arena, val);
851	} else if (std.mem.eql(u8, key, "expect_stdout")) {
852	if (updates.items.len == 0) fatal("line {d}: expect directive before update", .{line_n});
853	const last_update = &updates.items[updates.items.len - 1];
854	if (last_update.outcome != .unknown) fatal("line {d}: conflicting expect directive", .{line_n});
855	last_update.outcome = .{
856	.stdout = std.zig.string_literal.parseAlloc(arena, val) catch \|err\| {
857	fatal("line {d}: bad string literal: {t}", .{ line_n, err });
858	},
859	};
860	} else if (std.mem.eql(u8, key, "expect_error")) {
861	if (updates.items.len == 0) fatal("line {d}: expect directive before update", .{line_n});
862	const last_update = &updates.items[updates.items.len - 1];
863	if (last_update.outcome != .unknown) fatal("line {d}: conflicting expect directive", .{line_n});
864
865	var errors: std.ArrayList(ExpectedError) = .empty;
866	try errors.append(arena, parseExpectedError(val, line_n));
867	while (true) {
868	const next_line = it.peek() orelse break;
869	if (!std.mem.startsWith(u8, next_line, "#")) break;
870	var new_line_it = std.mem.splitScalar(u8, next_line, '=');
871	const new_key = new_line_it.first()[1..];
872	const new_val = std.mem.trimEnd(u8, new_line_it.rest(), "\r");
873	if (new_val.len == 0) break;
874	if (!std.mem.eql(u8, new_key, "expect_error")) break;
875
876	_ = it.next();
877	line_n += 1;
878	try errors.append(arena, parseExpectedError(new_val, line_n));
879	}
880
881	var compile_log_output: std.ArrayList(u8) = .empty;
882	while (true) {
883	const next_line = it.peek() orelse break;
884	if (!std.mem.startsWith(u8, next_line, "#")) break;
885	var new_line_it = std.mem.splitScalar(u8, next_line, '=');
886	const new_key = new_line_it.first()[1..];
887	const new_val = std.mem.trimEnd(u8, new_line_it.rest(), "\r");
888	if (new_val.len == 0) break;
889	if (!std.mem.eql(u8, new_key, "expect_compile_log")) break;
890
891	_ = it.next();
892	line_n += 1;
893	try compile_log_output.ensureUnusedCapacity(arena, new_val.len + 1);
894	compile_log_output.appendSliceAssumeCapacity(new_val);
895	compile_log_output.appendAssumeCapacity('\n');
896	}
897
898	last_update.outcome = .{ .compile_errors = .{
899	.errors = errors.items,
900	.compile_log_output = compile_log_output.items,
901	} };
902	} else if (std.mem.eql(u8, key, "expect_compile_log")) {
903	fatal("line {d}: 'expect_compile_log' must immediately follow 'expect_error'", .{line_n});
904	} else {
905	fatal("line {d}: unrecognized key '{s}'", .{ line_n, key });
906	}
907	}
908	}
909
910	if (changes.items.len > 0) {
911	const last_update = &updates.items[updates.items.len - 1];
912	last_update.changes = changes.items; // arena so no need for toOwnedSlice
913	last_update.deletes = deletes.items;
914	}
915
916	return .{
917	.updates = updates.items,
918	.root_source_file = root_source_file orelse fatal("missing root source file", .{}),
919	.skip_targets = skip_targets.items, // arena so no need for toOwnedSlice
920	.modules = modules.items,
921	};
922	}
923	};
924
925	fn requestExit(child: std.process.Child, eval: Eval) void {
926	if (child.stdin == null) return;
927	const io = eval.io;
928
929	var w = eval.child.stdin.?.writerStreaming(io, &.{});
930	var client: std.zig.Client = .{
931	.in = undefined,
932	.out = &w.interface,
933	};
934	client.serveBodylessMessage(.exit) catch \|err\| switch (err) {
935	error.WriteFailed => switch (w.err.?) {
936	error.BrokenPipe => {},
937	else => \|e\| eval.fatal("failed to send exit: {t}", .{e}),
938	},
939	};
940
941	// Send EOF to stdin.
942	child.stdin.?.close(io);
943	child.stdin = null;
944	}
945
946	fn waitChild(child: std.process.Child, eval: Eval) void {
947	const io = eval.io;
948	requestExit(child, eval);
949	const term = child.wait(io) catch \|err\| eval.fatal("child process failed: {t}", .{err});
950	switch (term) {
951	.exited => \|code\| if (code != 0) eval.fatal("compiler failed with code {d}", .{code}),
952	.signal => \|sig\| eval.fatal("compiler terminated with signal {t}", .{sig}),
953	.stopped => \|sig\| eval.fatal("compiler stopped unexpectedly with signal {t}", .{sig}),
954	.unknown => eval.fatal("compiler terminated unexpectedly", .{}),
955	}
956	}
957
958	fn parseExpectedError(str: []const u8, l: usize) Case.ExpectedError {
959	// #expect_error=foo.zig:1:2: error: the error message
960	// #expect_error=foo.zig:1:2: note: and a note
961
962	const fatal = std.process.fatal;
963
964	var it = std.mem.splitScalar(u8, str, ':');
965	const filename = it.first();
966	const line_str, const column_str = if (filename.len > 0) .{
967	it.next() orelse fatal("line {d}: incomplete error specification", .{l}),
968	it.next() orelse fatal("line {d}: incomplete error specification", .{l}),
969	} else .{ undefined, undefined };
970	const error_or_note_str = std.mem.trim(
971	u8,
972	it.next() orelse fatal("line {d}: incomplete error specification", .{l}),
973	" ",
974	);
975
976	const is_note = if (std.mem.eql(u8, error_or_note_str, "error"))
977	false
978	else if (std.mem.eql(u8, error_or_note_str, "note"))
979	true
980	else
981	fatal("line {d}: expeted 'error' or 'note', found '{s}'", .{ l, error_or_note_str });
982
983	const message = std.mem.trim(u8, it.rest(), " ");
984	if (message.len == 0) fatal("line {d}: empty error message", .{l});
985
986	return .{
987	.is_note = is_note,
988	.msg = message,
989	.src = if (filename.len == 0) null else .{
990	.filename = filename,
991	.line = std.fmt.parseInt(u32, line_str, 10) catch
992	fatal("line {d}: invalid line number '{s}'", .{ l, line_str }),
993	.column = std.fmt.parseInt(u32, column_str, 10) catch
994	fatal("line {d}: invalid column number '{s}'", .{ l, column_str }),
995	},
996	};
997	}
998
999	fn rand64(io: Io) u64 {
1000	var x: u64 = undefined;
1001	io.random(@ptrCast(&x));
1002	return x;
1003	}
1004
1005	/// Calls `std.process.fatal` on error. The error messages are prefixed with `err_prefix`.
1006	fn parseTargetQueryAndBackend(input_str: []const u8, err_prefix: []const u8) struct { std.Target.Query, Backend } {
1007	const fatal = std.process.fatal;
1008
1009	const split_idx = std.mem.findScalarLast(u8, input_str, '-') orelse
1010	fatal("{s}target does not include backend", .{err_prefix});
1011
1012	const query = input_str[0..split_idx];
1013
1014	const backend_str = input_str[split_idx + 1 ..];
1015	const backend: Backend = std.meta.stringToEnum(Backend, backend_str) orelse
1016	fatal("{s}invalid backend '{s}'", .{ err_prefix, backend_str });
1017
1018	const parsed_query = std.Build.parseTargetQuery(.{
1019	.arch_os_abi = query,
1020	.object_format = switch (backend) {
1021	.sema, .selfhosted, .llvm => null,
1022	.cbe => "c",
1023	},
1024	}) catch fatal("{s}invalid target query '{s}'", .{ err_prefix, query });
1025
1026	return .{ parsed_query, backend };
1027	}
1028
1029	fn badUsage(comptime fmt: []const u8, args: anytype) noreturn {
1030	std.log.err(fmt ++ "\n{s}", args ++ .{usage});
1031	std.process.exit(1);
1032	}

author	Jacob Young <jacobly@ziglang.org> 2026-09-19 06:52:35-04:00
committer	Jacob Young <jacobly@ziglang.org> 2026-09-26 19:08:50-04:00
log	ec261c5e8d569a7bf90a51638d41de6053f98e1a
tree	7688c129c251adce9d1cb547a697fe9d72a7a3ce
parent	4e4e8902e5bec12befd191b6ce412d60ced819f4

test-incremental: convert tests to new format