Commit 9501ea688f414c3c8af473f9f6ba471ed2c1953e | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-09-09 18:49:05-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-09-09 18:49:05-07:00
log	9501ea688f414c3c8af473f9f6ba471ed2c1953e
tree	20517cb77a078c0a9057379ffe57605c7345042d
parent	57390999894a74f289a6eace6deed6c17b65f298

stage2: --autofix proof-of-concept

 * Introduce the `--autofix` CLI flag when building an executable,
   object, or library.
 * Refactor std.zig.render to use a struct parameter to make it easier
   to add/remove fields from the struct.
 * Introduce a "Fixups" concept to std.zig.render which can perform
   edits while rendering code, while leaving the Ast read-only.
 * Add a fixup for adding a discard after a variable declaration.
 * Update the Module code to check for fixable errors after AstGen
   lowering.

Improvements that need to be made before this can be merged:

 * Introduce an error for "pointless discard" and a fixup for it so that
   --autofix can undo the effects of itself when a variable becomes
   used.
 * Support local variables as well as local constants.
 * Support captures in addition to local variables and constants.
 * Integrate properly with incremental compilation.
 * Integrate with the Zig build system.
 * Distinguish between AstGen errors that can be autofixed and those
   that cannot.
 * Remove std.debug.print statements.
 * Only perform fixups when all errors are autofixable errors. However,
   suppress all autofixable errors when reporting errors with --autofix.

The purpose of this feature is to satisfy two use cases that
traditionally have been at odds:

 * Some people want the guarantee that all Zig code they read has the
   property that there are no unused locals.
 * Some people find no value from such errors and want to not have to
   deal with them.

The problem with an `--allow-unused` flag is that people from the second
group will use it, and then some projects will fail to compile without
the flag enabled.

I like to think of Zig as having "inline warnings". The warnings are
there, inside your source code, next to the relevant lines, ready to be
noticed by diffs, code reviews, and when refactoring.

`--autofix` is a way for Zig to automatically insert inline warnings for
those who wish to iterate quickly on a messy codebase.

5 files changed, 817 insertions(+), 673 deletions(-)

lib
- std
  - zig
    Ast.zig
    render.zig
src

lib/std/zig/Ast.zig+8-1

...	...	@@ -17,6 +17,7 @@ const testing = std.testing;
17	17	const mem = std.mem;
18	18	const Token = std.zig.Token;
19	19	const Ast = @This();
	20	const private_render = @import("./render.zig");
20	21
21	22	pub const TokenIndex = u32;
22	23	pub const ByteOffset = u32;
...	...	@@ -60,8 +61,14 @@ pub fn render(tree: Ast, gpa: mem.Allocator) RenderError![]u8 {
60	61	return buffer.toOwnedSlice();
61	62	}
62	63
	64	pub const Fixups = private_render.Fixups;
	65
63	66	pub fn renderToArrayList(tree: Ast, buffer: *std.ArrayList(u8)) RenderError!void {
64		return @import("./render.zig").renderTree(buffer, tree);
	67	return private_render.renderTree(buffer, tree, .{});
	68	}
	69
	70	pub fn renderWithFixups(tree: Ast, buffer: *std.ArrayList(u8), fixups: Fixups) RenderError!void {
	71	return private_render.renderTree(buffer, tree, fixups);
65	72	}
66	73
67	74	/// Returns an extra offset for column and byte offset of errors that

lib/std/zig/render.zig+676-618

...	...	@@ -13,44 +13,73 @@ pub const Error = Ast.RenderError;
13	13
14	14	const Ais = AutoIndentingStream(std.ArrayList(u8).Writer);
15	15
16		pub fn renderTree(buffer: *std.ArrayList(u8), tree: Ast) Error!void {
	16	pub const Fixups = struct {
	17	/// The key is the mut token (`var`/`const`) of the variable declaration
	18	/// that should have a `_ = foo;` inserted afterwards.
	19	unused_var_decls: std.AutoHashMapUnmanaged(Ast.TokenIndex, void) = .{},
	20
	21	pub fn count(f: Fixups) usize {
	22	return f.unused_var_decls.count();
	23	}
	24
	25	pub fn deinit(f: *Fixups, gpa: Allocator) void {
	26	f.unused_var_decls.deinit(gpa);
	27	f.* = undefined;
	28	}
	29	};
	30
	31	const Render = struct {
	32	gpa: Allocator,
	33	ais: *Ais,
	34	tree: Ast,
	35	fixups: Fixups,
	36	};
	37
	38	pub fn renderTree(buffer: *std.ArrayList(u8), tree: Ast, fixups: Fixups) Error!void {
17	39	assert(tree.errors.len == 0); // Cannot render an invalid tree.
18	40	var auto_indenting_stream = Ais{
19	41	.indent_delta = indent_delta,
20	42	.underlying_writer = buffer.writer(),
21	43	};
22		const ais = &auto_indenting_stream;
	44	var r: Render = .{
	45	.gpa = buffer.allocator,
	46	.ais = &auto_indenting_stream,
	47	.tree = tree,
	48	.fixups = fixups,
	49	};
23	50
24	51	// Render all the line comments at the beginning of the file.
25	52	const comment_end_loc = tree.tokens.items(.start)[0];
26		_ = try renderComments(ais, tree, 0, comment_end_loc);
	53	_ = try renderComments(r, 0, comment_end_loc);
27	54
28	55	if (tree.tokens.items(.tag)[0] == .container_doc_comment) {
29		try renderContainerDocComments(ais, tree, 0);
	56	try renderContainerDocComments(r, 0);
30	57	}
31	58
32		try renderMembers(buffer.allocator, ais, tree, tree.rootDecls());
	59	try renderMembers(r, tree.rootDecls());
33	60
34		if (ais.disabled_offset) \|disabled_offset\| {
35		try writeFixingWhitespace(ais.underlying_writer, tree.source[disabled_offset..]);
	61	if (r.ais.disabled_offset) \|disabled_offset\| {
	62	try writeFixingWhitespace(r.ais.underlying_writer, tree.source[disabled_offset..]);
36	63	}
37	64	}
38	65
39	66	/// Render all members in the given slice, keeping empty lines where appropriate
40		fn renderMembers(gpa: Allocator, ais: *Ais, tree: Ast, members: []const Ast.Node.Index) Error!void {
	67	fn renderMembers(r: Render, members: []const Ast.Node.Index) Error!void {
41	68	if (members.len == 0) return;
42		try renderMember(gpa, ais, tree, members[0], .newline);
	69	try renderMember(r, members[0], .newline);
43	70	for (members[1..]) \|member\| {
44		try renderExtraNewline(ais, tree, member);
45		try renderMember(gpa, ais, tree, member, .newline);
	71	try renderExtraNewline(r, member);
	72	try renderMember(r, member, .newline);
46	73	}
47	74	}
48	75
49		fn renderMember(gpa: Allocator, ais: *Ais, tree: Ast, decl: Ast.Node.Index, space: Space) Error!void {
	76	fn renderMember(r: Render, decl: Ast.Node.Index, space: Space) Error!void {
	77	const tree = r.tree;
	78	const ais = r.ais;
50	79	const token_tags = tree.tokens.items(.tag);
51	80	const main_tokens = tree.nodes.items(.main_token);
52	81	const datas = tree.nodes.items(.data);
53		try renderDocComments(ais, tree, tree.firstToken(decl));
	82	try renderDocComments(r, tree.firstToken(decl));
54	83	switch (tree.nodes.items(.tag)[decl]) {
55	84	.fn_decl => {
56	85	// Some examples:
...	...	@@ -78,7 +107,7 @@ fn renderMember(gpa: Allocator, ais: *Ais, tree: Ast, decl: Ast.Node.Index, spac
78	107	}
79	108	}
80	109	while (i < fn_token) : (i += 1) {
81		try renderToken(ais, tree, i, .space);
	110	try renderToken(r, i, .space);
82	111	}
83	112	switch (tree.nodes.items(.tag)[fn_proto]) {
84	113	.fn_proto_one, .fn_proto => {
...	...	@@ -96,8 +125,8 @@ fn renderMember(gpa: Allocator, ais: *Ais, tree: Ast, decl: Ast.Node.Index, spac
96	125	else => unreachable,
97	126	}
98	127	assert(datas[decl].rhs != 0);
99		try renderExpression(gpa, ais, tree, fn_proto, .space);
100		return renderExpression(gpa, ais, tree, datas[decl].rhs, space);
	128	try renderExpression(r, fn_proto, .space);
	129	return renderExpression(r, datas[decl].rhs, space);
101	130	},
102	131	.fn_proto_simple,
103	132	.fn_proto_multi,
...	...	@@ -126,42 +155,42 @@ fn renderMember(gpa: Allocator, ais: *Ais, tree: Ast, decl: Ast.Node.Index, spac
126	155	}
127	156	}
128	157	while (i < fn_token) : (i += 1) {
129		try renderToken(ais, tree, i, .space);
	158	try renderToken(r, i, .space);
130	159	}
131		try renderExpression(gpa, ais, tree, decl, .none);
132		return renderToken(ais, tree, tree.lastToken(decl) + 1, space); // semicolon
	160	try renderExpression(r, decl, .none);
	161	return renderToken(r, tree.lastToken(decl) + 1, space); // semicolon
133	162	},
134	163
135	164	.@"usingnamespace" => {
136	165	const main_token = main_tokens[decl];
137	166	const expr = datas[decl].lhs;
138	167	if (main_token > 0 and token_tags[main_token - 1] == .keyword_pub) {
139		try renderToken(ais, tree, main_token - 1, .space); // pub
	168	try renderToken(r, main_token - 1, .space); // pub
140	169	}
141		try renderToken(ais, tree, main_token, .space); // usingnamespace
142		try renderExpression(gpa, ais, tree, expr, .none);
143		return renderToken(ais, tree, tree.lastToken(expr) + 1, space); // ;
	170	try renderToken(r, main_token, .space); // usingnamespace
	171	try renderExpression(r, expr, .none);
	172	return renderToken(r, tree.lastToken(expr) + 1, space); // ;
144	173	},
145	174
146		.global_var_decl => return renderVarDecl(gpa, ais, tree, tree.globalVarDecl(decl)),
147		.local_var_decl => return renderVarDecl(gpa, ais, tree, tree.localVarDecl(decl)),
148		.simple_var_decl => return renderVarDecl(gpa, ais, tree, tree.simpleVarDecl(decl)),
149		.aligned_var_decl => return renderVarDecl(gpa, ais, tree, tree.alignedVarDecl(decl)),
	175	.global_var_decl => return renderVarDecl(r, tree.globalVarDecl(decl)),
	176	.local_var_decl => return renderVarDecl(r, tree.localVarDecl(decl)),
	177	.simple_var_decl => return renderVarDecl(r, tree.simpleVarDecl(decl)),
	178	.aligned_var_decl => return renderVarDecl(r, tree.alignedVarDecl(decl)),
150	179
151	180	.test_decl => {
152	181	const test_token = main_tokens[decl];
153		try renderToken(ais, tree, test_token, .space);
	182	try renderToken(r, test_token, .space);
154	183	const test_name_tag = token_tags[test_token + 1];
155	184	if (test_name_tag == .string_literal or test_name_tag == .identifier) {
156		try renderToken(ais, tree, test_token + 1, .space);
	185	try renderToken(r, test_token + 1, .space);
157	186	}
158		try renderExpression(gpa, ais, tree, datas[decl].rhs, space);
	187	try renderExpression(r, datas[decl].rhs, space);
159	188	},
160	189
161		.container_field_init => return renderContainerField(gpa, ais, tree, tree.containerFieldInit(decl), space),
162		.container_field_align => return renderContainerField(gpa, ais, tree, tree.containerFieldAlign(decl), space),
163		.container_field => return renderContainerField(gpa, ais, tree, tree.containerField(decl), space),
164		.@"comptime" => return renderExpression(gpa, ais, tree, decl, space),
	190	.container_field_init => return renderContainerField(r, tree.containerFieldInit(decl), space),
	191	.container_field_align => return renderContainerField(r, tree.containerFieldAlign(decl), space),
	192	.container_field => return renderContainerField(r, tree.containerField(decl), space),
	193	.@"comptime" => return renderExpression(r, decl, space),
165	194
166	195	.root => unreachable,
167	196	else => unreachable,
...	...	@@ -169,16 +198,18 @@ fn renderMember(gpa: Allocator, ais: *Ais, tree: Ast, decl: Ast.Node.Index, spac
169	198	}
170	199
171	200	/// Render all expressions in the slice, keeping empty lines where appropriate
172		fn renderExpressions(gpa: Allocator, ais: *Ais, tree: Ast, expressions: []const Ast.Node.Index, space: Space) Error!void {
	201	fn renderExpressions(r: Render, expressions: []const Ast.Node.Index, space: Space) Error!void {
173	202	if (expressions.len == 0) return;
174		try renderExpression(gpa, ais, tree, expressions[0], space);
	203	try renderExpression(r, expressions[0], space);
175	204	for (expressions[1..]) \|expression\| {
176		try renderExtraNewline(ais, tree, expression);
177		try renderExpression(gpa, ais, tree, expression, space);
	205	try renderExtraNewline(r, expression);
	206	try renderExpression(r, expression, space);
178	207	}
179	208	}
180	209
181		fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index, space: Space) Error!void {
	210	fn renderExpression(r: Render, node: Ast.Node.Index, space: Space) Error!void {
	211	const tree = r.tree;
	212	const ais = r.ais;
182	213	const token_tags = tree.tokens.items(.tag);
183	214	const main_tokens = tree.nodes.items(.main_token);
184	215	const node_tags = tree.nodes.items(.tag);
...	...	@@ -196,7 +227,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
196	227	try ais.writer().writeAll(lexeme);
197	228	}
198	229
199		return renderSpace(ais, tree, token_index, lexeme.len, space);
	230	return renderSpace(r, token_index, lexeme.len, space);
200	231	},
201	232
202	233	.integer_literal,
...	...	@@ -205,29 +236,29 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
205	236	.unreachable_literal,
206	237	.anyframe_literal,
207	238	.string_literal,
208		=> return renderToken(ais, tree, main_tokens[node], space),
	239	=> return renderToken(r, main_tokens[node], space),
209	240
210	241	.multiline_string_literal => {
211	242	var locked_indents = ais.lockOneShotIndent();
212	243	try ais.maybeInsertNewline();
213	244
214	245	var i = datas[node].lhs;
215		while (i <= datas[node].rhs) : (i += 1) try renderToken(ais, tree, i, .newline);
	246	while (i <= datas[node].rhs) : (i += 1) try renderToken(r, i, .newline);
216	247
217	248	while (locked_indents > 0) : (locked_indents -= 1) ais.popIndent();
218	249
219	250	switch (space) {
220	251	.none, .space, .newline, .skip => {},
221		.semicolon => if (token_tags[i] == .semicolon) try renderToken(ais, tree, i, .newline),
222		.comma => if (token_tags[i] == .comma) try renderToken(ais, tree, i, .newline),
223		.comma_space => if (token_tags[i] == .comma) try renderToken(ais, tree, i, .space),
	252	.semicolon => if (token_tags[i] == .semicolon) try renderToken(r, i, .newline),
	253	.comma => if (token_tags[i] == .comma) try renderToken(r, i, .newline),
	254	.comma_space => if (token_tags[i] == .comma) try renderToken(r, i, .space),
224	255	}
225	256	},
226	257
227	258	.error_value => {
228		try renderToken(ais, tree, main_tokens[node], .none);
229		try renderToken(ais, tree, main_tokens[node] + 1, .none);
230		return renderToken(ais, tree, main_tokens[node] + 2, space);
	259	try renderToken(r, main_tokens[node], .none);
	260	try renderToken(r, main_tokens[node] + 1, .none);
	261	return renderToken(r, main_tokens[node] + 2, space);
231	262	},
232	263
233	264	.block_two,
...	...	@@ -235,18 +266,18 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
235	266	=> {
236	267	const statements = [2]Ast.Node.Index{ datas[node].lhs, datas[node].rhs };
237	268	if (datas[node].lhs == 0) {
238		return renderBlock(gpa, ais, tree, node, statements[0..0], space);
	269	return renderBlock(r, node, statements[0..0], space);
239	270	} else if (datas[node].rhs == 0) {
240		return renderBlock(gpa, ais, tree, node, statements[0..1], space);
	271	return renderBlock(r, node, statements[0..1], space);
241	272	} else {
242		return renderBlock(gpa, ais, tree, node, statements[0..2], space);
	273	return renderBlock(r, node, statements[0..2], space);
243	274	}
244	275	},
245	276	.block,
246	277	.block_semicolon,
247	278	=> {
248	279	const statements = tree.extra_data[datas[node].lhs..datas[node].rhs];
249		return renderBlock(gpa, ais, tree, node, statements, space);
	280	return renderBlock(r, node, statements, space);
250	281	},
251	282
252	283	.@"errdefer" => {
...	...	@@ -254,33 +285,33 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
254	285	const payload_token = datas[node].lhs;
255	286	const expr = datas[node].rhs;
256	287
257		try renderToken(ais, tree, defer_token, .space);
	288	try renderToken(r, defer_token, .space);
258	289	if (payload_token != 0) {
259		try renderToken(ais, tree, payload_token - 1, .none); // \|
260		try renderToken(ais, tree, payload_token, .none); // identifier
261		try renderToken(ais, tree, payload_token + 1, .space); // \|
	290	try renderToken(r, payload_token - 1, .none); // \|
	291	try renderToken(r, payload_token, .none); // identifier
	292	try renderToken(r, payload_token + 1, .space); // \|
262	293	}
263		return renderExpression(gpa, ais, tree, expr, space);
	294	return renderExpression(r, expr, space);
264	295	},
265	296
266	297	.@"defer" => {
267	298	const defer_token = main_tokens[node];
268	299	const expr = datas[node].rhs;
269		try renderToken(ais, tree, defer_token, .space);
270		return renderExpression(gpa, ais, tree, expr, space);
	300	try renderToken(r, defer_token, .space);
	301	return renderExpression(r, expr, space);
271	302	},
272	303	.@"comptime", .@"nosuspend" => {
273	304	const comptime_token = main_tokens[node];
274	305	const block = datas[node].lhs;
275		try renderToken(ais, tree, comptime_token, .space);
276		return renderExpression(gpa, ais, tree, block, space);
	306	try renderToken(r, comptime_token, .space);
	307	return renderExpression(r, block, space);
277	308	},
278	309
279	310	.@"suspend" => {
280	311	const suspend_token = main_tokens[node];
281	312	const body = datas[node].lhs;
282		try renderToken(ais, tree, suspend_token, .space);
283		return renderExpression(gpa, ais, tree, body, space);
	313	try renderToken(r, suspend_token, .space);
	314	return renderExpression(r, body, space);
284	315	},
285	316
286	317	.@"catch" => {
...	...	@@ -290,27 +321,27 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
290	321	const same_line = tree.tokensOnSameLine(main_token, fallback_first);
291	322	const after_op_space = if (same_line) Space.space else Space.newline;
292	323
293		try renderExpression(gpa, ais, tree, datas[node].lhs, .space); // target
	324	try renderExpression(r, datas[node].lhs, .space); // target
294	325
295	326	if (token_tags[fallback_first - 1] == .pipe) {
296		try renderToken(ais, tree, main_token, .space); // catch keyword
297		try renderToken(ais, tree, main_token + 1, .none); // pipe
298		try renderToken(ais, tree, main_token + 2, .none); // payload identifier
299		try renderToken(ais, tree, main_token + 3, after_op_space); // pipe
	327	try renderToken(r, main_token, .space); // catch keyword
	328	try renderToken(r, main_token + 1, .none); // pipe
	329	try renderToken(r, main_token + 2, .none); // payload identifier
	330	try renderToken(r, main_token + 3, after_op_space); // pipe
300	331	} else {
301	332	assert(token_tags[fallback_first - 1] == .keyword_catch);
302		try renderToken(ais, tree, main_token, after_op_space); // catch keyword
	333	try renderToken(r, main_token, after_op_space); // catch keyword
303	334	}
304	335
305	336	ais.pushIndentOneShot();
306		try renderExpression(gpa, ais, tree, datas[node].rhs, space); // fallback
	337	try renderExpression(r, datas[node].rhs, space); // fallback
307	338	},
308	339
309	340	.field_access => {
310	341	const main_token = main_tokens[node];
311	342	const field_access = datas[node];
312	343
313		try renderExpression(gpa, ais, tree, field_access.lhs, .none);
	344	try renderExpression(r, field_access.lhs, .none);
314	345
315	346	// Allow a line break between the lhs and the dot if the lhs and rhs
316	347	// are on different lines.
...	...	@@ -321,7 +352,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
321	352	ais.pushIndentOneShot();
322	353	}
323	354
324		try renderToken(ais, tree, main_token, .none);
	355	try renderToken(r, main_token, .none);
325	356
326	357	// This check ensures that zag() is indented in the following example:
327	358	// const x = foo
...	...	@@ -332,16 +363,16 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
332	363	ais.pushIndentOneShot();
333	364	}
334	365
335		return renderToken(ais, tree, field_access.rhs, space);
	366	return renderToken(r, field_access.rhs, space);
336	367	},
337	368
338	369	.error_union,
339	370	.switch_range,
340	371	=> {
341	372	const infix = datas[node];
342		try renderExpression(gpa, ais, tree, infix.lhs, .none);
343		try renderToken(ais, tree, main_tokens[node], .none);
344		return renderExpression(gpa, ais, tree, infix.rhs, space);
	373	try renderExpression(r, infix.lhs, .none);
	374	try renderToken(r, main_tokens[node], .none);
	375	return renderExpression(r, infix.rhs, space);
345	376	},
346	377
347	378	.add,
...	...	@@ -393,17 +424,17 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
393	424	.@"orelse",
394	425	=> {
395	426	const infix = datas[node];
396		try renderExpression(gpa, ais, tree, infix.lhs, .space);
	427	try renderExpression(r, infix.lhs, .space);
397	428	const op_token = main_tokens[node];
398	429	if (tree.tokensOnSameLine(op_token, op_token + 1)) {
399		try renderToken(ais, tree, op_token, .space);
	430	try renderToken(r, op_token, .space);
400	431	} else {
401	432	ais.pushIndent();
402		try renderToken(ais, tree, op_token, .newline);
	433	try renderToken(r, op_token, .newline);
403	434	ais.popIndent();
404	435	}
405	436	ais.pushIndentOneShot();
406		return renderExpression(gpa, ais, tree, infix.rhs, space);
	437	return renderExpression(r, infix.rhs, space);
407	438	},
408	439
409	440	.bit_not,
...	...	@@ -413,66 +444,66 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
413	444	.optional_type,
414	445	.address_of,
415	446	=> {
416		try renderToken(ais, tree, main_tokens[node], .none);
417		return renderExpression(gpa, ais, tree, datas[node].lhs, space);
	447	try renderToken(r, main_tokens[node], .none);
	448	return renderExpression(r, datas[node].lhs, space);
418	449	},
419	450
420	451	.@"try",
421	452	.@"resume",
422	453	.@"await",
423	454	=> {
424		try renderToken(ais, tree, main_tokens[node], .space);
425		return renderExpression(gpa, ais, tree, datas[node].lhs, space);
	455	try renderToken(r, main_tokens[node], .space);
	456	return renderExpression(r, datas[node].lhs, space);
426	457	},
427	458
428		.array_type => return renderArrayType(gpa, ais, tree, tree.arrayType(node), space),
429		.array_type_sentinel => return renderArrayType(gpa, ais, tree, tree.arrayTypeSentinel(node), space),
	459	.array_type => return renderArrayType(r, tree.arrayType(node), space),
	460	.array_type_sentinel => return renderArrayType(r, tree.arrayTypeSentinel(node), space),
430	461
431		.ptr_type_aligned => return renderPtrType(gpa, ais, tree, tree.ptrTypeAligned(node), space),
432		.ptr_type_sentinel => return renderPtrType(gpa, ais, tree, tree.ptrTypeSentinel(node), space),
433		.ptr_type => return renderPtrType(gpa, ais, tree, tree.ptrType(node), space),
434		.ptr_type_bit_range => return renderPtrType(gpa, ais, tree, tree.ptrTypeBitRange(node), space),
	462	.ptr_type_aligned => return renderPtrType(r, tree.ptrTypeAligned(node), space),
	463	.ptr_type_sentinel => return renderPtrType(r, tree.ptrTypeSentinel(node), space),
	464	.ptr_type => return renderPtrType(r, tree.ptrType(node), space),
	465	.ptr_type_bit_range => return renderPtrType(r, tree.ptrTypeBitRange(node), space),
435	466
436	467	.array_init_one, .array_init_one_comma => {
437	468	var elements: [1]Ast.Node.Index = undefined;
438		return renderArrayInit(gpa, ais, tree, tree.arrayInitOne(&elements, node), space);
	469	return renderArrayInit(r, tree.arrayInitOne(&elements, node), space);
439	470	},
440	471	.array_init_dot_two, .array_init_dot_two_comma => {
441	472	var elements: [2]Ast.Node.Index = undefined;
442		return renderArrayInit(gpa, ais, tree, tree.arrayInitDotTwo(&elements, node), space);
	473	return renderArrayInit(r, tree.arrayInitDotTwo(&elements, node), space);
443	474	},
444	475	.array_init_dot,
445	476	.array_init_dot_comma,
446		=> return renderArrayInit(gpa, ais, tree, tree.arrayInitDot(node), space),
	477	=> return renderArrayInit(r, tree.arrayInitDot(node), space),
447	478	.array_init,
448	479	.array_init_comma,
449		=> return renderArrayInit(gpa, ais, tree, tree.arrayInit(node), space),
	480	=> return renderArrayInit(r, tree.arrayInit(node), space),
450	481
451	482	.struct_init_one, .struct_init_one_comma => {
452	483	var fields: [1]Ast.Node.Index = undefined;
453		return renderStructInit(gpa, ais, tree, node, tree.structInitOne(&fields, node), space);
	484	return renderStructInit(r, node, tree.structInitOne(&fields, node), space);
454	485	},
455	486	.struct_init_dot_two, .struct_init_dot_two_comma => {
456	487	var fields: [2]Ast.Node.Index = undefined;
457		return renderStructInit(gpa, ais, tree, node, tree.structInitDotTwo(&fields, node), space);
	488	return renderStructInit(r, node, tree.structInitDotTwo(&fields, node), space);
458	489	},
459	490	.struct_init_dot,
460	491	.struct_init_dot_comma,
461		=> return renderStructInit(gpa, ais, tree, node, tree.structInitDot(node), space),
	492	=> return renderStructInit(r, node, tree.structInitDot(node), space),
462	493	.struct_init,
463	494	.struct_init_comma,
464		=> return renderStructInit(gpa, ais, tree, node, tree.structInit(node), space),
	495	=> return renderStructInit(r, node, tree.structInit(node), space),
465	496
466	497	.call_one, .call_one_comma, .async_call_one, .async_call_one_comma => {
467	498	var params: [1]Ast.Node.Index = undefined;
468		return renderCall(gpa, ais, tree, tree.callOne(&params, node), space);
	499	return renderCall(r, tree.callOne(&params, node), space);
469	500	},
470	501
471	502	.call,
472	503	.call_comma,
473	504	.async_call,
474	505	.async_call_comma,
475		=> return renderCall(gpa, ais, tree, tree.callFull(node), space),
	506	=> return renderCall(r, tree.callFull(node), space),
476	507
477	508	.array_access => {
478	509	const suffix = datas[node];
...	...	@@ -480,27 +511,27 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
480	511	const rbracket = tree.lastToken(suffix.rhs) + 1;
481	512	const one_line = tree.tokensOnSameLine(lbracket, rbracket);
482	513	const inner_space = if (one_line) Space.none else Space.newline;
483		try renderExpression(gpa, ais, tree, suffix.lhs, .none);
	514	try renderExpression(r, suffix.lhs, .none);
484	515	ais.pushIndentNextLine();
485		try renderToken(ais, tree, lbracket, inner_space); // [
486		try renderExpression(gpa, ais, tree, suffix.rhs, inner_space);
	516	try renderToken(r, lbracket, inner_space); // [
	517	try renderExpression(r, suffix.rhs, inner_space);
487	518	ais.popIndent();
488		return renderToken(ais, tree, rbracket, space); // ]
	519	return renderToken(r, rbracket, space); // ]
489	520	},
490	521
491		.slice_open => return renderSlice(gpa, ais, tree, node, tree.sliceOpen(node), space),
492		.slice => return renderSlice(gpa, ais, tree, node, tree.slice(node), space),
493		.slice_sentinel => return renderSlice(gpa, ais, tree, node, tree.sliceSentinel(node), space),
	522	.slice_open => return renderSlice(r, node, tree.sliceOpen(node), space),
	523	.slice => return renderSlice(r, node, tree.slice(node), space),
	524	.slice_sentinel => return renderSlice(r, node, tree.sliceSentinel(node), space),
494	525
495	526	.deref => {
496		try renderExpression(gpa, ais, tree, datas[node].lhs, .none);
497		return renderToken(ais, tree, main_tokens[node], space);
	527	try renderExpression(r, datas[node].lhs, .none);
	528	return renderToken(r, main_tokens[node], space);
498	529	},
499	530
500	531	.unwrap_optional => {
501		try renderExpression(gpa, ais, tree, datas[node].lhs, .none);
502		try renderToken(ais, tree, main_tokens[node], .none);
503		return renderToken(ais, tree, datas[node].rhs, space);
	532	try renderExpression(r, datas[node].lhs, .none);
	533	try renderToken(r, main_tokens[node], .none);
	534	return renderToken(r, datas[node].rhs, space);
504	535	},
505	536
506	537	.@"break" => {
...	...	@@ -508,19 +539,19 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
508	539	const label_token = datas[node].lhs;
509	540	const target = datas[node].rhs;
510	541	if (label_token == 0 and target == 0) {
511		try renderToken(ais, tree, main_token, space); // break keyword
	542	try renderToken(r, main_token, space); // break keyword
512	543	} else if (label_token == 0 and target != 0) {
513		try renderToken(ais, tree, main_token, .space); // break keyword
514		try renderExpression(gpa, ais, tree, target, space);
	544	try renderToken(r, main_token, .space); // break keyword
	545	try renderExpression(r, target, space);
515	546	} else if (label_token != 0 and target == 0) {
516		try renderToken(ais, tree, main_token, .space); // break keyword
517		try renderToken(ais, tree, label_token - 1, .none); // colon
518		try renderToken(ais, tree, label_token, space); // identifier
	547	try renderToken(r, main_token, .space); // break keyword
	548	try renderToken(r, label_token - 1, .none); // colon
	549	try renderToken(r, label_token, space); // identifier
519	550	} else if (label_token != 0 and target != 0) {
520		try renderToken(ais, tree, main_token, .space); // break keyword
521		try renderToken(ais, tree, label_token - 1, .none); // colon
522		try renderToken(ais, tree, label_token, .space); // identifier
523		try renderExpression(gpa, ais, tree, target, space);
	551	try renderToken(r, main_token, .space); // break keyword
	552	try renderToken(r, label_token - 1, .none); // colon
	553	try renderToken(r, label_token, .space); // identifier
	554	try renderExpression(r, target, space);
524	555	}
525	556	},
526	557
...	...	@@ -528,136 +559,136 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
528	559	const main_token = main_tokens[node];
529	560	const label = datas[node].lhs;
530	561	if (label != 0) {
531		try renderToken(ais, tree, main_token, .space); // continue
532		try renderToken(ais, tree, label - 1, .none); // :
533		return renderToken(ais, tree, label, space); // label
	562	try renderToken(r, main_token, .space); // continue
	563	try renderToken(r, label - 1, .none); // :
	564	return renderToken(r, label, space); // label
534	565	} else {
535		return renderToken(ais, tree, main_token, space); // continue
	566	return renderToken(r, main_token, space); // continue
536	567	}
537	568	},
538	569
539	570	.@"return" => {
540	571	if (datas[node].lhs != 0) {
541		try renderToken(ais, tree, main_tokens[node], .space);
542		try renderExpression(gpa, ais, tree, datas[node].lhs, space);
	572	try renderToken(r, main_tokens[node], .space);
	573	try renderExpression(r, datas[node].lhs, space);
543	574	} else {
544		try renderToken(ais, tree, main_tokens[node], space);
	575	try renderToken(r, main_tokens[node], space);
545	576	}
546	577	},
547	578
548	579	.grouped_expression => {
549		try renderToken(ais, tree, main_tokens[node], .none); // lparen
	580	try renderToken(r, main_tokens[node], .none); // lparen
550	581	ais.pushIndentOneShot();
551		try renderExpression(gpa, ais, tree, datas[node].lhs, .none);
552		return renderToken(ais, tree, datas[node].rhs, space); // rparen
	582	try renderExpression(r, datas[node].lhs, .none);
	583	return renderToken(r, datas[node].rhs, space); // rparen
553	584	},
554	585
555	586	.container_decl,
556	587	.container_decl_trailing,
557		=> return renderContainerDecl(gpa, ais, tree, node, tree.containerDecl(node), space),
	588	=> return renderContainerDecl(r, node, tree.containerDecl(node), space),
558	589
559	590	.container_decl_two, .container_decl_two_trailing => {
560	591	var buffer: [2]Ast.Node.Index = undefined;
561		return renderContainerDecl(gpa, ais, tree, node, tree.containerDeclTwo(&buffer, node), space);
	592	return renderContainerDecl(r, node, tree.containerDeclTwo(&buffer, node), space);
562	593	},
563	594	.container_decl_arg,
564	595	.container_decl_arg_trailing,
565		=> return renderContainerDecl(gpa, ais, tree, node, tree.containerDeclArg(node), space),
	596	=> return renderContainerDecl(r, node, tree.containerDeclArg(node), space),
566	597
567	598	.tagged_union,
568	599	.tagged_union_trailing,
569		=> return renderContainerDecl(gpa, ais, tree, node, tree.taggedUnion(node), space),
	600	=> return renderContainerDecl(r, node, tree.taggedUnion(node), space),
570	601
571	602	.tagged_union_two, .tagged_union_two_trailing => {
572	603	var buffer: [2]Ast.Node.Index = undefined;
573		return renderContainerDecl(gpa, ais, tree, node, tree.taggedUnionTwo(&buffer, node), space);
	604	return renderContainerDecl(r, node, tree.taggedUnionTwo(&buffer, node), space);
574	605	},
575	606	.tagged_union_enum_tag,
576	607	.tagged_union_enum_tag_trailing,
577		=> return renderContainerDecl(gpa, ais, tree, node, tree.taggedUnionEnumTag(node), space),
	608	=> return renderContainerDecl(r, node, tree.taggedUnionEnumTag(node), space),
578	609
579	610	.error_set_decl => {
580	611	const error_token = main_tokens[node];
581	612	const lbrace = error_token + 1;
582	613	const rbrace = datas[node].rhs;
583	614
584		try renderToken(ais, tree, error_token, .none);
	615	try renderToken(r, error_token, .none);
585	616
586	617	if (lbrace + 1 == rbrace) {
587	618	// There is nothing between the braces so render condensed: `error{}`
588		try renderToken(ais, tree, lbrace, .none);
589		return renderToken(ais, tree, rbrace, space);
	619	try renderToken(r, lbrace, .none);
	620	return renderToken(r, rbrace, space);
590	621	} else if (lbrace + 2 == rbrace and token_tags[lbrace + 1] == .identifier) {
591	622	// There is exactly one member and no trailing comma or
592	623	// comments, so render without surrounding spaces: `error{Foo}`
593		try renderToken(ais, tree, lbrace, .none);
594		try renderToken(ais, tree, lbrace + 1, .none); // identifier
595		return renderToken(ais, tree, rbrace, space);
	624	try renderToken(r, lbrace, .none);
	625	try renderToken(r, lbrace + 1, .none); // identifier
	626	return renderToken(r, rbrace, space);
596	627	} else if (token_tags[rbrace - 1] == .comma) {
597	628	// There is a trailing comma so render each member on a new line.
598	629	ais.pushIndentNextLine();
599		try renderToken(ais, tree, lbrace, .newline);
	630	try renderToken(r, lbrace, .newline);
600	631	var i = lbrace + 1;
601	632	while (i < rbrace) : (i += 1) {
602		if (i > lbrace + 1) try renderExtraNewlineToken(ais, tree, i);
	633	if (i > lbrace + 1) try renderExtraNewlineToken(r, i);
603	634	switch (token_tags[i]) {
604		.doc_comment => try renderToken(ais, tree, i, .newline),
605		.identifier => try renderToken(ais, tree, i, .comma),
	635	.doc_comment => try renderToken(r, i, .newline),
	636	.identifier => try renderToken(r, i, .comma),
606	637	.comma => {},
607	638	else => unreachable,
608	639	}
609	640	}
610	641	ais.popIndent();
611		return renderToken(ais, tree, rbrace, space);
	642	return renderToken(r, rbrace, space);
612	643	} else {
613	644	// There is no trailing comma so render everything on one line.
614		try renderToken(ais, tree, lbrace, .space);
	645	try renderToken(r, lbrace, .space);
615	646	var i = lbrace + 1;
616	647	while (i < rbrace) : (i += 1) {
617	648	switch (token_tags[i]) {
618	649	.doc_comment => unreachable, // TODO
619		.identifier => try renderToken(ais, tree, i, .comma_space),
	650	.identifier => try renderToken(r, i, .comma_space),
620	651	.comma => {},
621	652	else => unreachable,
622	653	}
623	654	}
624		return renderToken(ais, tree, rbrace, space);
	655	return renderToken(r, rbrace, space);
625	656	}
626	657	},
627	658
628	659	.builtin_call_two, .builtin_call_two_comma => {
629	660	if (datas[node].lhs == 0) {
630		return renderBuiltinCall(gpa, ais, tree, main_tokens[node], &.{}, space);
	661	return renderBuiltinCall(r, main_tokens[node], &.{}, space);
631	662	} else if (datas[node].rhs == 0) {
632		return renderBuiltinCall(gpa, ais, tree, main_tokens[node], &.{datas[node].lhs}, space);
	663	return renderBuiltinCall(r, main_tokens[node], &.{datas[node].lhs}, space);
633	664	} else {
634		return renderBuiltinCall(gpa, ais, tree, main_tokens[node], &.{ datas[node].lhs, datas[node].rhs }, space);
	665	return renderBuiltinCall(r, main_tokens[node], &.{ datas[node].lhs, datas[node].rhs }, space);
635	666	}
636	667	},
637	668	.builtin_call, .builtin_call_comma => {
638	669	const params = tree.extra_data[datas[node].lhs..datas[node].rhs];
639		return renderBuiltinCall(gpa, ais, tree, main_tokens[node], params, space);
	670	return renderBuiltinCall(r, main_tokens[node], params, space);
640	671	},
641	672
642	673	.fn_proto_simple => {
643	674	var params: [1]Ast.Node.Index = undefined;
644		return renderFnProto(gpa, ais, tree, tree.fnProtoSimple(&params, node), space);
	675	return renderFnProto(r, tree.fnProtoSimple(&params, node), space);
645	676	},
646		.fn_proto_multi => return renderFnProto(gpa, ais, tree, tree.fnProtoMulti(node), space),
	677	.fn_proto_multi => return renderFnProto(r, tree.fnProtoMulti(node), space),
647	678	.fn_proto_one => {
648	679	var params: [1]Ast.Node.Index = undefined;
649		return renderFnProto(gpa, ais, tree, tree.fnProtoOne(&params, node), space);
	680	return renderFnProto(r, tree.fnProtoOne(&params, node), space);
650	681	},
651		.fn_proto => return renderFnProto(gpa, ais, tree, tree.fnProto(node), space),
	682	.fn_proto => return renderFnProto(r, tree.fnProto(node), space),
652	683
653	684	.anyframe_type => {
654	685	const main_token = main_tokens[node];
655	686	if (datas[node].rhs != 0) {
656		try renderToken(ais, tree, main_token, .none); // anyframe
657		try renderToken(ais, tree, main_token + 1, .none); // ->
658		return renderExpression(gpa, ais, tree, datas[node].rhs, space);
	687	try renderToken(r, main_token, .none); // anyframe
	688	try renderToken(r, main_token + 1, .none); // ->
	689	return renderExpression(r, datas[node].rhs, space);
659	690	} else {
660		return renderToken(ais, tree, main_token, space); // anyframe
	691	return renderToken(r, main_token, space); // anyframe
661	692	}
662	693	},
663	694
...	...	@@ -670,40 +701,40 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
670	701	const cases = tree.extra_data[extra.start..extra.end];
671	702	const rparen = tree.lastToken(condition) + 1;
672	703
673		try renderToken(ais, tree, switch_token, .space); // switch keyword
674		try renderToken(ais, tree, switch_token + 1, .none); // lparen
675		try renderExpression(gpa, ais, tree, condition, .none); // condtion expression
676		try renderToken(ais, tree, rparen, .space); // rparen
	704	try renderToken(r, switch_token, .space); // switch keyword
	705	try renderToken(r, switch_token + 1, .none); // lparen
	706	try renderExpression(r, condition, .none); // condtion expression
	707	try renderToken(r, rparen, .space); // rparen
677	708
678	709	ais.pushIndentNextLine();
679	710	if (cases.len == 0) {
680		try renderToken(ais, tree, rparen + 1, .none); // lbrace
	711	try renderToken(r, rparen + 1, .none); // lbrace
681	712	} else {
682		try renderToken(ais, tree, rparen + 1, .newline); // lbrace
683		try renderExpressions(gpa, ais, tree, cases, .comma);
	713	try renderToken(r, rparen + 1, .newline); // lbrace
	714	try renderExpressions(r, cases, .comma);
684	715	}
685	716	ais.popIndent();
686		return renderToken(ais, tree, tree.lastToken(node), space); // rbrace
	717	return renderToken(r, tree.lastToken(node), space); // rbrace
687	718	},
688	719
689		.switch_case_one => return renderSwitchCase(gpa, ais, tree, tree.switchCaseOne(node), space),
690		.switch_case => return renderSwitchCase(gpa, ais, tree, tree.switchCase(node), space),
	720	.switch_case_one => return renderSwitchCase(r, tree.switchCaseOne(node), space),
	721	.switch_case => return renderSwitchCase(r, tree.switchCase(node), space),
691	722
692		.while_simple => return renderWhile(gpa, ais, tree, tree.whileSimple(node), space),
693		.while_cont => return renderWhile(gpa, ais, tree, tree.whileCont(node), space),
694		.@"while" => return renderWhile(gpa, ais, tree, tree.whileFull(node), space),
695		.for_simple => return renderWhile(gpa, ais, tree, tree.forSimple(node), space),
696		.@"for" => return renderWhile(gpa, ais, tree, tree.forFull(node), space),
	723	.while_simple => return renderWhile(r, tree.whileSimple(node), space),
	724	.while_cont => return renderWhile(r, tree.whileCont(node), space),
	725	.@"while" => return renderWhile(r, tree.whileFull(node), space),
	726	.for_simple => return renderWhile(r, tree.forSimple(node), space),
	727	.@"for" => return renderWhile(r, tree.forFull(node), space),
697	728
698		.if_simple => return renderIf(gpa, ais, tree, tree.ifSimple(node), space),
699		.@"if" => return renderIf(gpa, ais, tree, tree.ifFull(node), space),
	729	.if_simple => return renderIf(r, tree.ifSimple(node), space),
	730	.@"if" => return renderIf(r, tree.ifFull(node), space),
700	731
701		.asm_simple => return renderAsm(gpa, ais, tree, tree.asmSimple(node), space),
702		.@"asm" => return renderAsm(gpa, ais, tree, tree.asmFull(node), space),
	732	.asm_simple => return renderAsm(r, tree.asmSimple(node), space),
	733	.@"asm" => return renderAsm(r, tree.asmFull(node), space),
703	734
704	735	.enum_literal => {
705		try renderToken(ais, tree, main_tokens[node] - 1, .none); // .
706		return renderToken(ais, tree, main_tokens[node], space); // name
	736	try renderToken(r, main_tokens[node] - 1, .none); // .
	737	return renderToken(r, main_tokens[node], space); // name
707	738	},
708	739
709	740	.fn_decl => unreachable,
...	...	@@ -723,34 +754,29 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
723	754	}
724	755
725	756	fn renderArrayType(
726		gpa: Allocator,
727		ais: *Ais,
728		tree: Ast,
	757	r: Render,
729	758	array_type: Ast.full.ArrayType,
730	759	space: Space,
731	760	) Error!void {
	761	const tree = r.tree;
	762	const ais = r.ais;
732	763	const rbracket = tree.firstToken(array_type.ast.elem_type) - 1;
733	764	const one_line = tree.tokensOnSameLine(array_type.ast.lbracket, rbracket);
734	765	const inner_space = if (one_line) Space.none else Space.newline;
735	766	ais.pushIndentNextLine();
736		try renderToken(ais, tree, array_type.ast.lbracket, inner_space); // lbracket
737		try renderExpression(gpa, ais, tree, array_type.ast.elem_count, inner_space);
	767	try renderToken(r, array_type.ast.lbracket, inner_space); // lbracket
	768	try renderExpression(r, array_type.ast.elem_count, inner_space);
738	769	if (array_type.ast.sentinel != 0) {
739		try renderToken(ais, tree, tree.firstToken(array_type.ast.sentinel) - 1, inner_space); // colon
740		try renderExpression(gpa, ais, tree, array_type.ast.sentinel, inner_space);
	770	try renderToken(r, tree.firstToken(array_type.ast.sentinel) - 1, inner_space); // colon
	771	try renderExpression(r, array_type.ast.sentinel, inner_space);
741	772	}
742	773	ais.popIndent();
743		try renderToken(ais, tree, rbracket, .none); // rbracket
744		return renderExpression(gpa, ais, tree, array_type.ast.elem_type, space);
	774	try renderToken(r, rbracket, .none); // rbracket
	775	return renderExpression(r, array_type.ast.elem_type, space);
745	776	}
746	777
747		fn renderPtrType(
748		gpa: Allocator,
749		ais: *Ais,
750		tree: Ast,
751		ptr_type: Ast.full.PtrType,
752		space: Space,
753		) Error!void {
	778	fn renderPtrType(r: Render, ptr_type: Ast.full.PtrType, space: Space) Error!void {
	779	const tree = r.tree;
754	780	switch (ptr_type.size) {
755	781	.One => {
756	782	// Since ** tokens exist and the same token is shared by two
...	...	@@ -761,90 +787,89 @@ fn renderPtrType(
761	787	if (tree.tokens.items(.tag)[ptr_type.ast.main_token] == .asterisk_asterisk and
762	788	ptr_type.ast.main_token == tree.nodes.items(.main_token)[ptr_type.ast.child_type])
763	789	{
764		return renderExpression(gpa, ais, tree, ptr_type.ast.child_type, space);
	790	return renderExpression(r, ptr_type.ast.child_type, space);
765	791	}
766		try renderToken(ais, tree, ptr_type.ast.main_token, .none); // asterisk
	792	try renderToken(r, ptr_type.ast.main_token, .none); // asterisk
767	793	},
768	794	.Many => {
769	795	if (ptr_type.ast.sentinel == 0) {
770		try renderToken(ais, tree, ptr_type.ast.main_token - 1, .none); // lbracket
771		try renderToken(ais, tree, ptr_type.ast.main_token, .none); // asterisk
772		try renderToken(ais, tree, ptr_type.ast.main_token + 1, .none); // rbracket
	796	try renderToken(r, ptr_type.ast.main_token - 1, .none); // lbracket
	797	try renderToken(r, ptr_type.ast.main_token, .none); // asterisk
	798	try renderToken(r, ptr_type.ast.main_token + 1, .none); // rbracket
773	799	} else {
774		try renderToken(ais, tree, ptr_type.ast.main_token - 1, .none); // lbracket
775		try renderToken(ais, tree, ptr_type.ast.main_token, .none); // asterisk
776		try renderToken(ais, tree, ptr_type.ast.main_token + 1, .none); // colon
777		try renderExpression(gpa, ais, tree, ptr_type.ast.sentinel, .none);
778		try renderToken(ais, tree, tree.lastToken(ptr_type.ast.sentinel) + 1, .none); // rbracket
	800	try renderToken(r, ptr_type.ast.main_token - 1, .none); // lbracket
	801	try renderToken(r, ptr_type.ast.main_token, .none); // asterisk
	802	try renderToken(r, ptr_type.ast.main_token + 1, .none); // colon
	803	try renderExpression(r, ptr_type.ast.sentinel, .none);
	804	try renderToken(r, tree.lastToken(ptr_type.ast.sentinel) + 1, .none); // rbracket
779	805	}
780	806	},
781	807	.C => {
782		try renderToken(ais, tree, ptr_type.ast.main_token - 1, .none); // lbracket
783		try renderToken(ais, tree, ptr_type.ast.main_token, .none); // asterisk
784		try renderToken(ais, tree, ptr_type.ast.main_token + 1, .none); // c
785		try renderToken(ais, tree, ptr_type.ast.main_token + 2, .none); // rbracket
	808	try renderToken(r, ptr_type.ast.main_token - 1, .none); // lbracket
	809	try renderToken(r, ptr_type.ast.main_token, .none); // asterisk
	810	try renderToken(r, ptr_type.ast.main_token + 1, .none); // c
	811	try renderToken(r, ptr_type.ast.main_token + 2, .none); // rbracket
786	812	},
787	813	.Slice => {
788	814	if (ptr_type.ast.sentinel == 0) {
789		try renderToken(ais, tree, ptr_type.ast.main_token, .none); // lbracket
790		try renderToken(ais, tree, ptr_type.ast.main_token + 1, .none); // rbracket
	815	try renderToken(r, ptr_type.ast.main_token, .none); // lbracket
	816	try renderToken(r, ptr_type.ast.main_token + 1, .none); // rbracket
791	817	} else {
792		try renderToken(ais, tree, ptr_type.ast.main_token, .none); // lbracket
793		try renderToken(ais, tree, ptr_type.ast.main_token + 1, .none); // colon
794		try renderExpression(gpa, ais, tree, ptr_type.ast.sentinel, .none);
795		try renderToken(ais, tree, tree.lastToken(ptr_type.ast.sentinel) + 1, .none); // rbracket
	818	try renderToken(r, ptr_type.ast.main_token, .none); // lbracket
	819	try renderToken(r, ptr_type.ast.main_token + 1, .none); // colon
	820	try renderExpression(r, ptr_type.ast.sentinel, .none);
	821	try renderToken(r, tree.lastToken(ptr_type.ast.sentinel) + 1, .none); // rbracket
796	822	}
797	823	},
798	824	}
799	825
800	826	if (ptr_type.allowzero_token) \|allowzero_token\| {
801		try renderToken(ais, tree, allowzero_token, .space);
	827	try renderToken(r, allowzero_token, .space);
802	828	}
803	829
804	830	if (ptr_type.ast.align_node != 0) {
805	831	const align_first = tree.firstToken(ptr_type.ast.align_node);
806		try renderToken(ais, tree, align_first - 2, .none); // align
807		try renderToken(ais, tree, align_first - 1, .none); // lparen
808		try renderExpression(gpa, ais, tree, ptr_type.ast.align_node, .none);
	832	try renderToken(r, align_first - 2, .none); // align
	833	try renderToken(r, align_first - 1, .none); // lparen
	834	try renderExpression(r, ptr_type.ast.align_node, .none);
809	835	if (ptr_type.ast.bit_range_start != 0) {
810	836	assert(ptr_type.ast.bit_range_end != 0);
811		try renderToken(ais, tree, tree.firstToken(ptr_type.ast.bit_range_start) - 1, .none); // colon
812		try renderExpression(gpa, ais, tree, ptr_type.ast.bit_range_start, .none);
813		try renderToken(ais, tree, tree.firstToken(ptr_type.ast.bit_range_end) - 1, .none); // colon
814		try renderExpression(gpa, ais, tree, ptr_type.ast.bit_range_end, .none);
815		try renderToken(ais, tree, tree.lastToken(ptr_type.ast.bit_range_end) + 1, .space); // rparen
	837	try renderToken(r, tree.firstToken(ptr_type.ast.bit_range_start) - 1, .none); // colon
	838	try renderExpression(r, ptr_type.ast.bit_range_start, .none);
	839	try renderToken(r, tree.firstToken(ptr_type.ast.bit_range_end) - 1, .none); // colon
	840	try renderExpression(r, ptr_type.ast.bit_range_end, .none);
	841	try renderToken(r, tree.lastToken(ptr_type.ast.bit_range_end) + 1, .space); // rparen
816	842	} else {
817		try renderToken(ais, tree, tree.lastToken(ptr_type.ast.align_node) + 1, .space); // rparen
	843	try renderToken(r, tree.lastToken(ptr_type.ast.align_node) + 1, .space); // rparen
818	844	}
819	845	}
820	846
821	847	if (ptr_type.ast.addrspace_node != 0) {
822	848	const addrspace_first = tree.firstToken(ptr_type.ast.addrspace_node);
823		try renderToken(ais, tree, addrspace_first - 2, .none); // addrspace
824		try renderToken(ais, tree, addrspace_first - 1, .none); // lparen
825		try renderExpression(gpa, ais, tree, ptr_type.ast.addrspace_node, .none);
826		try renderToken(ais, tree, tree.lastToken(ptr_type.ast.addrspace_node) + 1, .space); // rparen
	849	try renderToken(r, addrspace_first - 2, .none); // addrspace
	850	try renderToken(r, addrspace_first - 1, .none); // lparen
	851	try renderExpression(r, ptr_type.ast.addrspace_node, .none);
	852	try renderToken(r, tree.lastToken(ptr_type.ast.addrspace_node) + 1, .space); // rparen
827	853	}
828	854
829	855	if (ptr_type.const_token) \|const_token\| {
830		try renderToken(ais, tree, const_token, .space);
	856	try renderToken(r, const_token, .space);
831	857	}
832	858
833	859	if (ptr_type.volatile_token) \|volatile_token\| {
834		try renderToken(ais, tree, volatile_token, .space);
	860	try renderToken(r, volatile_token, .space);
835	861	}
836	862
837		try renderExpression(gpa, ais, tree, ptr_type.ast.child_type, space);
	863	try renderExpression(r, ptr_type.ast.child_type, space);
838	864	}
839	865
840	866	fn renderSlice(
841		gpa: Allocator,
842		ais: *Ais,
843		tree: Ast,
	867	r: Render,
844	868	slice_node: Ast.Node.Index,
845	869	slice: Ast.full.Slice,
846	870	space: Space,
847	871	) Error!void {
	872	const tree = r.tree;
848	873	const node_tags = tree.nodes.items(.tag);
849	874	const after_start_space_bool = nodeCausesSliceOpSpace(node_tags[slice.ast.start]) or
850	875	if (slice.ast.end != 0) nodeCausesSliceOpSpace(node_tags[slice.ast.end]) else false;
...	...	@@ -853,33 +878,32 @@ fn renderSlice(
853	878	after_start_space
854	879	else if (slice.ast.sentinel != 0) Space.space else Space.none;
855	880
856		try renderExpression(gpa, ais, tree, slice.ast.sliced, .none);
857		try renderToken(ais, tree, slice.ast.lbracket, .none); // lbracket
	881	try renderExpression(r, slice.ast.sliced, .none);
	882	try renderToken(r, slice.ast.lbracket, .none); // lbracket
858	883
859	884	const start_last = tree.lastToken(slice.ast.start);
860		try renderExpression(gpa, ais, tree, slice.ast.start, after_start_space);
861		try renderToken(ais, tree, start_last + 1, after_dots_space); // ellipsis2 ("..")
	885	try renderExpression(r, slice.ast.start, after_start_space);
	886	try renderToken(r, start_last + 1, after_dots_space); // ellipsis2 ("..")
862	887
863	888	if (slice.ast.end != 0) {
864	889	const after_end_space = if (slice.ast.sentinel != 0) Space.space else Space.none;
865		try renderExpression(gpa, ais, tree, slice.ast.end, after_end_space);
	890	try renderExpression(r, slice.ast.end, after_end_space);
866	891	}
867	892
868	893	if (slice.ast.sentinel != 0) {
869		try renderToken(ais, tree, tree.firstToken(slice.ast.sentinel) - 1, .none); // colon
870		try renderExpression(gpa, ais, tree, slice.ast.sentinel, .none);
	894	try renderToken(r, tree.firstToken(slice.ast.sentinel) - 1, .none); // colon
	895	try renderExpression(r, slice.ast.sentinel, .none);
871	896	}
872	897
873		try renderToken(ais, tree, tree.lastToken(slice_node), space); // rbracket
	898	try renderToken(r, tree.lastToken(slice_node), space); // rbracket
874	899	}
875	900
876	901	fn renderAsmOutput(
877		gpa: Allocator,
878		ais: *Ais,
879		tree: Ast,
	902	r: Render,
880	903	asm_output: Ast.Node.Index,
881	904	space: Space,
882	905	) Error!void {
	906	const tree = r.tree;
883	907	const token_tags = tree.tokens.items(.tag);
884	908	const node_tags = tree.nodes.items(.tag);
885	909	const main_tokens = tree.nodes.items(.main_token);
...	...	@@ -887,66 +911,79 @@ fn renderAsmOutput(
887	911	assert(node_tags[asm_output] == .asm_output);
888	912	const symbolic_name = main_tokens[asm_output];
889	913
890		try renderToken(ais, tree, symbolic_name - 1, .none); // lbracket
891		try renderToken(ais, tree, symbolic_name, .none); // ident
892		try renderToken(ais, tree, symbolic_name + 1, .space); // rbracket
893		try renderToken(ais, tree, symbolic_name + 2, .space); // "constraint"
894		try renderToken(ais, tree, symbolic_name + 3, .none); // lparen
	914	try renderToken(r, symbolic_name - 1, .none); // lbracket
	915	try renderToken(r, symbolic_name, .none); // ident
	916	try renderToken(r, symbolic_name + 1, .space); // rbracket
	917	try renderToken(r, symbolic_name + 2, .space); // "constraint"
	918	try renderToken(r, symbolic_name + 3, .none); // lparen
895	919
896	920	if (token_tags[symbolic_name + 4] == .arrow) {
897		try renderToken(ais, tree, symbolic_name + 4, .space); // ->
898		try renderExpression(gpa, ais, tree, datas[asm_output].lhs, Space.none);
899		return renderToken(ais, tree, datas[asm_output].rhs, space); // rparen
	921	try renderToken(r, symbolic_name + 4, .space); // ->
	922	try renderExpression(r, datas[asm_output].lhs, Space.none);
	923	return renderToken(r, datas[asm_output].rhs, space); // rparen
900	924	} else {
901		try renderToken(ais, tree, symbolic_name + 4, .none); // ident
902		return renderToken(ais, tree, symbolic_name + 5, space); // rparen
	925	try renderToken(r, symbolic_name + 4, .none); // ident
	926	return renderToken(r, symbolic_name + 5, space); // rparen
903	927	}
904	928	}
905	929
906	930	fn renderAsmInput(
907		gpa: Allocator,
908		ais: *Ais,
909		tree: Ast,
	931	r: Render,
910	932	asm_input: Ast.Node.Index,
911	933	space: Space,
912	934	) Error!void {
	935	const tree = r.tree;
913	936	const node_tags = tree.nodes.items(.tag);
914	937	const main_tokens = tree.nodes.items(.main_token);
915	938	const datas = tree.nodes.items(.data);
916	939	assert(node_tags[asm_input] == .asm_input);
917	940	const symbolic_name = main_tokens[asm_input];
918	941
919		try renderToken(ais, tree, symbolic_name - 1, .none); // lbracket
920		try renderToken(ais, tree, symbolic_name, .none); // ident
921		try renderToken(ais, tree, symbolic_name + 1, .space); // rbracket
922		try renderToken(ais, tree, symbolic_name + 2, .space); // "constraint"
923		try renderToken(ais, tree, symbolic_name + 3, .none); // lparen
924		try renderExpression(gpa, ais, tree, datas[asm_input].lhs, Space.none);
925		return renderToken(ais, tree, datas[asm_input].rhs, space); // rparen
	942	try renderToken(r, symbolic_name - 1, .none); // lbracket
	943	try renderToken(r, symbolic_name, .none); // ident
	944	try renderToken(r, symbolic_name + 1, .space); // rbracket
	945	try renderToken(r, symbolic_name + 2, .space); // "constraint"
	946	try renderToken(r, symbolic_name + 3, .none); // lparen
	947	try renderExpression(r, datas[asm_input].lhs, Space.none);
	948	return renderToken(r, datas[asm_input].rhs, space); // rparen
	949	}
	950
	951	fn renderVarDecl(r: Render, var_decl: Ast.full.VarDecl) Error!void {
	952	try renderVarDeclWithoutFixups(r, var_decl);
	953	if (r.fixups.unused_var_decls.contains(var_decl.ast.mut_token)) {
	954	// Discard the variable like this: `_ = foo;`
	955	const w = r.ais.writer();
	956	try w.writeAll("_ = ");
	957	try w.writeAll(tokenSliceForRender(r.tree, var_decl.ast.mut_token + 1));
	958	try w.writeAll(";\n");
	959	}
926	960	}
927	961
928		fn renderVarDecl(gpa: Allocator, ais: *Ais, tree: Ast, var_decl: Ast.full.VarDecl) Error!void {
	962	fn renderVarDeclWithoutFixups(r: Render, var_decl: Ast.full.VarDecl) Error!void {
	963	const tree = r.tree;
	964	const ais = r.ais;
	965
929	966	if (var_decl.visib_token) \|visib_token\| {
930		try renderToken(ais, tree, visib_token, Space.space); // pub
	967	try renderToken(r, visib_token, Space.space); // pub
931	968	}
932	969
933	970	if (var_decl.extern_export_token) \|extern_export_token\| {
934		try renderToken(ais, tree, extern_export_token, Space.space); // extern
	971	try renderToken(r, extern_export_token, Space.space); // extern
935	972
936	973	if (var_decl.lib_name) \|lib_name\| {
937		try renderToken(ais, tree, lib_name, Space.space); // "lib"
	974	try renderToken(r, lib_name, Space.space); // "lib"
938	975	}
939	976	}
940	977
941	978	if (var_decl.threadlocal_token) \|thread_local_token\| {
942		try renderToken(ais, tree, thread_local_token, Space.space); // threadlocal
	979	try renderToken(r, thread_local_token, Space.space); // threadlocal
943	980	}
944	981
945	982	if (var_decl.comptime_token) \|comptime_token\| {
946		try renderToken(ais, tree, comptime_token, Space.space); // comptime
	983	try renderToken(r, comptime_token, Space.space); // comptime
947	984	}
948	985
949		try renderToken(ais, tree, var_decl.ast.mut_token, .space); // var
	986	try renderToken(r, var_decl.ast.mut_token, .space); // var
950	987
951	988	const name_space = if (var_decl.ast.type_node == 0 and
952	989	(var_decl.ast.align_node != 0 or
...	...	@@ -956,18 +993,18 @@ fn renderVarDecl(gpa: Allocator, ais: *Ais, tree: Ast, var_decl: Ast.full.VarDec
956	993	Space.space
957	994	else
958	995	Space.none;
959		try renderToken(ais, tree, var_decl.ast.mut_token + 1, name_space); // name
	996	try renderToken(r, var_decl.ast.mut_token + 1, name_space); // name
960	997
961	998	if (var_decl.ast.type_node != 0) {
962		try renderToken(ais, tree, var_decl.ast.mut_token + 2, Space.space); // :
	999	try renderToken(r, var_decl.ast.mut_token + 2, Space.space); // :
963	1000	if (var_decl.ast.align_node != 0 or var_decl.ast.addrspace_node != 0 or
964	1001	var_decl.ast.section_node != 0 or var_decl.ast.init_node != 0)
965	1002	{
966		try renderExpression(gpa, ais, tree, var_decl.ast.type_node, .space);
	1003	try renderExpression(r, var_decl.ast.type_node, .space);
967	1004	} else {
968		try renderExpression(gpa, ais, tree, var_decl.ast.type_node, .none);
	1005	try renderExpression(r, var_decl.ast.type_node, .none);
969	1006	const semicolon = tree.lastToken(var_decl.ast.type_node) + 1;
970		return renderToken(ais, tree, semicolon, Space.newline); // ;
	1007	return renderToken(r, semicolon, Space.newline); // ;
971	1008	}
972	1009	}
973	1010
...	...	@@ -975,16 +1012,16 @@ fn renderVarDecl(gpa: Allocator, ais: *Ais, tree: Ast, var_decl: Ast.full.VarDec
975	1012	const lparen = tree.firstToken(var_decl.ast.align_node) - 1;
976	1013	const align_kw = lparen - 1;
977	1014	const rparen = tree.lastToken(var_decl.ast.align_node) + 1;
978		try renderToken(ais, tree, align_kw, Space.none); // align
979		try renderToken(ais, tree, lparen, Space.none); // (
980		try renderExpression(gpa, ais, tree, var_decl.ast.align_node, Space.none);
	1015	try renderToken(r, align_kw, Space.none); // align
	1016	try renderToken(r, lparen, Space.none); // (
	1017	try renderExpression(r, var_decl.ast.align_node, Space.none);
981	1018	if (var_decl.ast.addrspace_node != 0 or var_decl.ast.section_node != 0 or
982	1019	var_decl.ast.init_node != 0)
983	1020	{
984		try renderToken(ais, tree, rparen, .space); // )
	1021	try renderToken(r, rparen, .space); // )
985	1022	} else {
986		try renderToken(ais, tree, rparen, .none); // )
987		return renderToken(ais, tree, rparen + 1, Space.newline); // ;
	1023	try renderToken(r, rparen, .none); // )
	1024	return renderToken(r, rparen + 1, Space.newline); // ;
988	1025	}
989	1026	}
990	1027
...	...	@@ -992,14 +1029,14 @@ fn renderVarDecl(gpa: Allocator, ais: *Ais, tree: Ast, var_decl: Ast.full.VarDec
992	1029	const lparen = tree.firstToken(var_decl.ast.addrspace_node) - 1;
993	1030	const addrspace_kw = lparen - 1;
994	1031	const rparen = tree.lastToken(var_decl.ast.addrspace_node) + 1;
995		try renderToken(ais, tree, addrspace_kw, Space.none); // addrspace
996		try renderToken(ais, tree, lparen, Space.none); // (
997		try renderExpression(gpa, ais, tree, var_decl.ast.addrspace_node, Space.none);
	1032	try renderToken(r, addrspace_kw, Space.none); // addrspace
	1033	try renderToken(r, lparen, Space.none); // (
	1034	try renderExpression(r, var_decl.ast.addrspace_node, Space.none);
998	1035	if (var_decl.ast.section_node != 0 or var_decl.ast.init_node != 0) {
999		try renderToken(ais, tree, rparen, .space); // )
	1036	try renderToken(r, rparen, .space); // )
1000	1037	} else {
1001		try renderToken(ais, tree, rparen, .none); // )
1002		return renderToken(ais, tree, rparen + 1, Space.newline); // ;
	1038	try renderToken(r, rparen, .none); // )
	1039	return renderToken(r, rparen + 1, Space.newline); // ;
1003	1040	}
1004	1041	}
1005	1042
...	...	@@ -1007,14 +1044,14 @@ fn renderVarDecl(gpa: Allocator, ais: *Ais, tree: Ast, var_decl: Ast.full.VarDec
1007	1044	const lparen = tree.firstToken(var_decl.ast.section_node) - 1;
1008	1045	const section_kw = lparen - 1;
1009	1046	const rparen = tree.lastToken(var_decl.ast.section_node) + 1;
1010		try renderToken(ais, tree, section_kw, Space.none); // linksection
1011		try renderToken(ais, tree, lparen, Space.none); // (
1012		try renderExpression(gpa, ais, tree, var_decl.ast.section_node, Space.none);
	1047	try renderToken(r, section_kw, Space.none); // linksection
	1048	try renderToken(r, lparen, Space.none); // (
	1049	try renderExpression(r, var_decl.ast.section_node, Space.none);
1013	1050	if (var_decl.ast.init_node != 0) {
1014		try renderToken(ais, tree, rparen, .space); // )
	1051	try renderToken(r, rparen, .space); // )
1015	1052	} else {
1016		try renderToken(ais, tree, rparen, .none); // )
1017		return renderToken(ais, tree, rparen + 1, Space.newline); // ;
	1053	try renderToken(r, rparen, .none); // )
	1054	return renderToken(r, rparen + 1, Space.newline); // ;
1018	1055	}
1019	1056	}
1020	1057
...	...	@@ -1023,17 +1060,17 @@ fn renderVarDecl(gpa: Allocator, ais: *Ais, tree: Ast, var_decl: Ast.full.VarDec
1023	1060	const eq_space: Space = if (tree.tokensOnSameLine(eq_token, eq_token + 1)) .space else .newline;
1024	1061	{
1025	1062	ais.pushIndent();
1026		try renderToken(ais, tree, eq_token, eq_space); // =
	1063	try renderToken(r, eq_token, eq_space); // =
1027	1064	ais.popIndent();
1028	1065	}
1029	1066	ais.pushIndentOneShot();
1030		return renderExpression(gpa, ais, tree, var_decl.ast.init_node, .semicolon); // ;
	1067	return renderExpression(r, var_decl.ast.init_node, .semicolon); // ;
1031	1068	}
1032		return renderToken(ais, tree, var_decl.ast.mut_token + 2, .newline); // ;
	1069	return renderToken(r, var_decl.ast.mut_token + 2, .newline); // ;
1033	1070	}
1034	1071
1035		fn renderIf(gpa: Allocator, ais: *Ais, tree: Ast, if_node: Ast.full.If, space: Space) Error!void {
1036		return renderWhile(gpa, ais, tree, .{
	1072	fn renderIf(r: Render, if_node: Ast.full.If, space: Space) Error!void {
	1073	return renderWhile(r, .{
1037	1074	.ast = .{
1038	1075	.while_token = if_node.ast.if_token,
1039	1076	.cond_expr = if_node.ast.cond_expr,
...	...	@@ -1051,41 +1088,43 @@ fn renderIf(gpa: Allocator, ais: *Ais, tree: Ast, if_node: Ast.full.If, space: S
1051	1088
1052	1089	/// Note that this function is additionally used to render if and for expressions, with
1053	1090	/// respective values set to null.
1054		fn renderWhile(gpa: Allocator, ais: *Ais, tree: Ast, while_node: Ast.full.While, space: Space) Error!void {
	1091	fn renderWhile(r: Render, while_node: Ast.full.While, space: Space) Error!void {
	1092	const tree = r.tree;
	1093	const ais = r.ais;
1055	1094	const node_tags = tree.nodes.items(.tag);
1056	1095	const token_tags = tree.tokens.items(.tag);
1057	1096
1058	1097	if (while_node.label_token) \|label\| {
1059		try renderToken(ais, tree, label, .none); // label
1060		try renderToken(ais, tree, label + 1, .space); // :
	1098	try renderToken(r, label, .none); // label
	1099	try renderToken(r, label + 1, .space); // :
1061	1100	}
1062	1101
1063	1102	if (while_node.inline_token) \|inline_token\| {
1064		try renderToken(ais, tree, inline_token, .space); // inline
	1103	try renderToken(r, inline_token, .space); // inline
1065	1104	}
1066	1105
1067		try renderToken(ais, tree, while_node.ast.while_token, .space); // if/for/while
1068		try renderToken(ais, tree, while_node.ast.while_token + 1, .none); // lparen
1069		try renderExpression(gpa, ais, tree, while_node.ast.cond_expr, .none); // condition
	1106	try renderToken(r, while_node.ast.while_token, .space); // if/for/while
	1107	try renderToken(r, while_node.ast.while_token + 1, .none); // lparen
	1108	try renderExpression(r, while_node.ast.cond_expr, .none); // condition
1070	1109
1071	1110	var last_prefix_token = tree.lastToken(while_node.ast.cond_expr) + 1; // rparen
1072	1111
1073	1112	if (while_node.payload_token) \|payload_token\| {
1074		try renderToken(ais, tree, last_prefix_token, .space);
1075		try renderToken(ais, tree, payload_token - 1, .none); // \|
	1113	try renderToken(r, last_prefix_token, .space);
	1114	try renderToken(r, payload_token - 1, .none); // \|
1076	1115	const ident = blk: {
1077	1116	if (token_tags[payload_token] == .asterisk) {
1078		try renderToken(ais, tree, payload_token, .none); // *
	1117	try renderToken(r, payload_token, .none); // *
1079	1118	break :blk payload_token + 1;
1080	1119	} else {
1081	1120	break :blk payload_token;
1082	1121	}
1083	1122	};
1084		try renderToken(ais, tree, ident, .none); // identifier
	1123	try renderToken(r, ident, .none); // identifier
1085	1124	const pipe = blk: {
1086	1125	if (token_tags[ident + 1] == .comma) {
1087		try renderToken(ais, tree, ident + 1, .space); // ,
1088		try renderToken(ais, tree, ident + 2, .none); // index
	1126	try renderToken(r, ident + 1, .space); // ,
	1127	try renderToken(r, ident + 2, .none); // index
1089	1128	break :blk ident + 3;
1090	1129	} else {
1091	1130	break :blk ident + 1;
...	...	@@ -1095,11 +1134,11 @@ fn renderWhile(gpa: Allocator, ais: *Ais, tree: Ast, while_node: Ast.full.While,
1095	1134	}
1096	1135
1097	1136	if (while_node.ast.cont_expr != 0) {
1098		try renderToken(ais, tree, last_prefix_token, .space);
	1137	try renderToken(r, last_prefix_token, .space);
1099	1138	const lparen = tree.firstToken(while_node.ast.cont_expr) - 1;
1100		try renderToken(ais, tree, lparen - 1, .space); // :
1101		try renderToken(ais, tree, lparen, .none); // lparen
1102		try renderExpression(gpa, ais, tree, while_node.ast.cont_expr, .none);
	1139	try renderToken(r, lparen - 1, .space); // :
	1140	try renderToken(r, lparen, .none); // lparen
	1141	try renderExpression(r, while_node.ast.cont_expr, .none);
1103	1142	last_prefix_token = tree.lastToken(while_node.ast.cont_expr) + 1; // rparen
1104	1143	}
1105	1144
...	...	@@ -1108,27 +1147,27 @@ fn renderWhile(gpa: Allocator, ais: *Ais, tree: Ast, while_node: Ast.full.While,
1108	1147	!tree.tokensOnSameLine(last_prefix_token, tree.firstToken(while_node.ast.then_expr));
1109	1148	if (indent_then_expr or (then_expr_is_block and ais.isLineOverIndented())) {
1110	1149	ais.pushIndentNextLine();
1111		try renderToken(ais, tree, last_prefix_token, .newline);
	1150	try renderToken(r, last_prefix_token, .newline);
1112	1151	ais.popIndent();
1113	1152	} else {
1114		try renderToken(ais, tree, last_prefix_token, .space);
	1153	try renderToken(r, last_prefix_token, .space);
1115	1154	}
1116	1155
1117	1156	if (while_node.ast.else_expr != 0) {
1118	1157	if (indent_then_expr) {
1119	1158	ais.pushIndent();
1120		try renderExpression(gpa, ais, tree, while_node.ast.then_expr, .newline);
	1159	try renderExpression(r, while_node.ast.then_expr, .newline);
1121	1160	ais.popIndent();
1122	1161	} else {
1123		try renderExpression(gpa, ais, tree, while_node.ast.then_expr, .space);
	1162	try renderExpression(r, while_node.ast.then_expr, .space);
1124	1163	}
1125	1164
1126	1165	var last_else_token = while_node.else_token;
1127	1166
1128	1167	if (while_node.error_token) \|error_token\| {
1129		try renderToken(ais, tree, while_node.else_token, .space); // else
1130		try renderToken(ais, tree, error_token - 1, .none); // \|
1131		try renderToken(ais, tree, error_token, .none); // identifier
	1168	try renderToken(r, while_node.else_token, .space); // else
	1169	try renderToken(r, error_token - 1, .none); // \|
	1170	try renderToken(r, error_token, .none); // identifier
1132	1171	last_else_token = error_token + 1; // \|
1133	1172	}
1134	1173
...	...	@@ -1137,111 +1176,107 @@ fn renderWhile(gpa: Allocator, ais: *Ais, tree: Ast, while_node: Ast.full.While,
1137	1176	!nodeIsIfForWhileSwitch(node_tags[while_node.ast.else_expr]);
1138	1177	if (indent_else_expr) {
1139	1178	ais.pushIndentNextLine();
1140		try renderToken(ais, tree, last_else_token, .newline);
	1179	try renderToken(r, last_else_token, .newline);
1141	1180	ais.popIndent();
1142		try renderExpressionIndented(gpa, ais, tree, while_node.ast.else_expr, space);
	1181	try renderExpressionIndented(r, while_node.ast.else_expr, space);
1143	1182	} else {
1144		try renderToken(ais, tree, last_else_token, .space);
1145		try renderExpression(gpa, ais, tree, while_node.ast.else_expr, space);
	1183	try renderToken(r, last_else_token, .space);
	1184	try renderExpression(r, while_node.ast.else_expr, space);
1146	1185	}
1147	1186	} else {
1148	1187	if (indent_then_expr) {
1149		try renderExpressionIndented(gpa, ais, tree, while_node.ast.then_expr, space);
	1188	try renderExpressionIndented(r, while_node.ast.then_expr, space);
1150	1189	} else {
1151		try renderExpression(gpa, ais, tree, while_node.ast.then_expr, space);
	1190	try renderExpression(r, while_node.ast.then_expr, space);
1152	1191	}
1153	1192	}
1154	1193	}
1155	1194
1156		fn renderContainerField(
1157		gpa: Allocator,
1158		ais: *Ais,
1159		tree: Ast,
1160		field: Ast.full.ContainerField,
1161		space: Space,
1162		) Error!void {
	1195	fn renderContainerField(r: Render, field: Ast.full.ContainerField, space: Space) Error!void {
	1196	const tree = r.tree;
	1197	const ais = r.ais;
1163	1198	if (field.comptime_token) \|t\| {
1164		try renderToken(ais, tree, t, .space); // comptime
	1199	try renderToken(r, t, .space); // comptime
1165	1200	}
1166	1201	if (field.ast.type_expr == 0 and field.ast.value_expr == 0) {
1167		return renderTokenComma(ais, tree, field.ast.name_token, space); // name
	1202	return renderTokenComma(r, field.ast.name_token, space); // name
1168	1203	}
1169	1204	if (field.ast.type_expr != 0 and field.ast.value_expr == 0) {
1170		try renderToken(ais, tree, field.ast.name_token, .none); // name
1171		try renderToken(ais, tree, field.ast.name_token + 1, .space); // :
	1205	try renderToken(r, field.ast.name_token, .none); // name
	1206	try renderToken(r, field.ast.name_token + 1, .space); // :
1172	1207
1173	1208	if (field.ast.align_expr != 0) {
1174		try renderExpression(gpa, ais, tree, field.ast.type_expr, .space); // type
	1209	try renderExpression(r, field.ast.type_expr, .space); // type
1175	1210	const align_token = tree.firstToken(field.ast.align_expr) - 2;
1176		try renderToken(ais, tree, align_token, .none); // align
1177		try renderToken(ais, tree, align_token + 1, .none); // (
1178		try renderExpression(gpa, ais, tree, field.ast.align_expr, .none); // alignment
	1211	try renderToken(r, align_token, .none); // align
	1212	try renderToken(r, align_token + 1, .none); // (
	1213	try renderExpression(r, field.ast.align_expr, .none); // alignment
1179	1214	const rparen = tree.lastToken(field.ast.align_expr) + 1;
1180		return renderTokenComma(ais, tree, rparen, space); // )
	1215	return renderTokenComma(r, rparen, space); // )
1181	1216	} else {
1182		return renderExpressionComma(gpa, ais, tree, field.ast.type_expr, space); // type
	1217	return renderExpressionComma(r, field.ast.type_expr, space); // type
1183	1218	}
1184	1219	}
1185	1220	if (field.ast.type_expr == 0 and field.ast.value_expr != 0) {
1186		try renderToken(ais, tree, field.ast.name_token, .space); // name
1187		try renderToken(ais, tree, field.ast.name_token + 1, .space); // =
1188		return renderExpressionComma(gpa, ais, tree, field.ast.value_expr, space); // value
	1221	try renderToken(r, field.ast.name_token, .space); // name
	1222	try renderToken(r, field.ast.name_token + 1, .space); // =
	1223	return renderExpressionComma(r, field.ast.value_expr, space); // value
1189	1224	}
1190	1225
1191		try renderToken(ais, tree, field.ast.name_token, .none); // name
1192		try renderToken(ais, tree, field.ast.name_token + 1, .space); // :
1193		try renderExpression(gpa, ais, tree, field.ast.type_expr, .space); // type
	1226	try renderToken(r, field.ast.name_token, .none); // name
	1227	try renderToken(r, field.ast.name_token + 1, .space); // :
	1228	try renderExpression(r, field.ast.type_expr, .space); // type
1194	1229
1195	1230	if (field.ast.align_expr != 0) {
1196	1231	const lparen_token = tree.firstToken(field.ast.align_expr) - 1;
1197	1232	const align_kw = lparen_token - 1;
1198	1233	const rparen_token = tree.lastToken(field.ast.align_expr) + 1;
1199		try renderToken(ais, tree, align_kw, .none); // align
1200		try renderToken(ais, tree, lparen_token, .none); // (
1201		try renderExpression(gpa, ais, tree, field.ast.align_expr, .none); // alignment
1202		try renderToken(ais, tree, rparen_token, .space); // )
	1234	try renderToken(r, align_kw, .none); // align
	1235	try renderToken(r, lparen_token, .none); // (
	1236	try renderExpression(r, field.ast.align_expr, .none); // alignment
	1237	try renderToken(r, rparen_token, .space); // )
1203	1238	}
1204	1239	const eq_token = tree.firstToken(field.ast.value_expr) - 1;
1205	1240	const eq_space: Space = if (tree.tokensOnSameLine(eq_token, eq_token + 1)) .space else .newline;
1206	1241	{
1207	1242	ais.pushIndent();
1208		try renderToken(ais, tree, eq_token, eq_space); // =
	1243	try renderToken(r, eq_token, eq_space); // =
1209	1244	ais.popIndent();
1210	1245	}
1211	1246
1212	1247	if (eq_space == .space)
1213		return renderExpressionComma(gpa, ais, tree, field.ast.value_expr, space); // value
	1248	return renderExpressionComma(r, field.ast.value_expr, space); // value
1214	1249
1215	1250	const token_tags = tree.tokens.items(.tag);
1216	1251	const maybe_comma = tree.lastToken(field.ast.value_expr) + 1;
1217	1252
1218	1253	if (token_tags[maybe_comma] == .comma) {
1219	1254	ais.pushIndent();
1220		try renderExpression(gpa, ais, tree, field.ast.value_expr, .none); // value
	1255	try renderExpression(r, field.ast.value_expr, .none); // value
1221	1256	ais.popIndent();
1222		try renderToken(ais, tree, maybe_comma, .newline);
	1257	try renderToken(r, maybe_comma, .newline);
1223	1258	} else {
1224	1259	ais.pushIndent();
1225		try renderExpression(gpa, ais, tree, field.ast.value_expr, space); // value
	1260	try renderExpression(r, field.ast.value_expr, space); // value
1226	1261	ais.popIndent();
1227	1262	}
1228	1263	}
1229	1264
1230	1265	fn renderBuiltinCall(
1231		gpa: Allocator,
1232		ais: *Ais,
1233		tree: Ast,
	1266	r: Render,
1234	1267	builtin_token: Ast.TokenIndex,
1235	1268	params: []const Ast.Node.Index,
1236	1269	space: Space,
1237	1270	) Error!void {
	1271	const tree = r.tree;
	1272	const ais = r.ais;
1238	1273	const token_tags = tree.tokens.items(.tag);
1239	1274
1240		try renderToken(ais, tree, builtin_token, .none); // @name
	1275	try renderToken(r, builtin_token, .none); // @name
1241	1276
1242	1277	if (params.len == 0) {
1243		try renderToken(ais, tree, builtin_token + 1, .none); // (
1244		return renderToken(ais, tree, builtin_token + 2, space); // )
	1278	try renderToken(r, builtin_token + 1, .none); // (
	1279	return renderToken(r, builtin_token + 2, space); // )
1245	1280	}
1246	1281
1247	1282	const last_param = params[params.len - 1];
...	...	@@ -1249,7 +1284,7 @@ fn renderBuiltinCall(
1249	1284
1250	1285	if (token_tags[after_last_param_token] != .comma) {
1251	1286	// Render all on one line, no trailing comma.
1252		try renderToken(ais, tree, builtin_token + 1, .none); // (
	1287	try renderToken(r, builtin_token + 1, .none); // (
1253	1288
1254	1289	for (params) \|param_node, i\| {
1255	1290	const first_param_token = tree.firstToken(param_node);
...	...	@@ -1258,39 +1293,41 @@ fn renderBuiltinCall(
1258	1293	{
1259	1294	ais.pushIndentOneShot();
1260	1295	}
1261		try renderExpression(gpa, ais, tree, param_node, .none);
	1296	try renderExpression(r, param_node, .none);
1262	1297
1263	1298	if (i + 1 < params.len) {
1264	1299	const comma_token = tree.lastToken(param_node) + 1;
1265		try renderToken(ais, tree, comma_token, .space); // ,
	1300	try renderToken(r, comma_token, .space); // ,
1266	1301	}
1267	1302	}
1268		return renderToken(ais, tree, after_last_param_token, space); // )
	1303	return renderToken(r, after_last_param_token, space); // )
1269	1304	} else {
1270	1305	// Render one param per line.
1271	1306	ais.pushIndent();
1272		try renderToken(ais, tree, builtin_token + 1, Space.newline); // (
	1307	try renderToken(r, builtin_token + 1, Space.newline); // (
1273	1308
1274	1309	for (params) \|param_node\| {
1275		try renderExpression(gpa, ais, tree, param_node, .comma);
	1310	try renderExpression(r, param_node, .comma);
1276	1311	}
1277	1312	ais.popIndent();
1278	1313
1279		return renderToken(ais, tree, after_last_param_token + 1, space); // )
	1314	return renderToken(r, after_last_param_token + 1, space); // )
1280	1315	}
1281	1316	}
1282	1317
1283		fn renderFnProto(gpa: Allocator, ais: *Ais, tree: Ast, fn_proto: Ast.full.FnProto, space: Space) Error!void {
	1318	fn renderFnProto(r: Render, fn_proto: Ast.full.FnProto, space: Space) Error!void {
	1319	const tree = r.tree;
	1320	const ais = r.ais;
1284	1321	const token_tags = tree.tokens.items(.tag);
1285	1322	const token_starts = tree.tokens.items(.start);
1286	1323
1287	1324	const after_fn_token = fn_proto.ast.fn_token + 1;
1288	1325	const lparen = if (token_tags[after_fn_token] == .identifier) blk: {
1289		try renderToken(ais, tree, fn_proto.ast.fn_token, .space); // fn
1290		try renderToken(ais, tree, after_fn_token, .none); // name
	1326	try renderToken(r, fn_proto.ast.fn_token, .space); // fn
	1327	try renderToken(r, after_fn_token, .none); // name
1291	1328	break :blk after_fn_token + 1;
1292	1329	} else blk: {
1293		try renderToken(ais, tree, fn_proto.ast.fn_token, .space); // fn
	1330	try renderToken(r, fn_proto.ast.fn_token, .space); // fn
1294	1331	break :blk fn_proto.ast.fn_token + 1;
1295	1332	};
1296	1333	assert(token_tags[lparen] == .l_paren);
...	...	@@ -1342,7 +1379,7 @@ fn renderFnProto(gpa: Allocator, ais: *Ais, tree: Ast, fn_proto: Ast.full.FnProt
1342	1379	const trailing_comma = token_tags[rparen - 1] == .comma;
1343	1380	if (!trailing_comma and !hasComment(tree, lparen, rparen)) {
1344	1381	// Render all on one line, no trailing comma.
1345		try renderToken(ais, tree, lparen, .none); // (
	1382	try renderToken(r, lparen, .none); // (
1346	1383
1347	1384	var param_i: usize = 0;
1348	1385	var last_param_token = lparen;
...	...	@@ -1350,25 +1387,25 @@ fn renderFnProto(gpa: Allocator, ais: *Ais, tree: Ast, fn_proto: Ast.full.FnProt
1350	1387	last_param_token += 1;
1351	1388	switch (token_tags[last_param_token]) {
1352	1389	.doc_comment => {
1353		try renderToken(ais, tree, last_param_token, .newline);
	1390	try renderToken(r, last_param_token, .newline);
1354	1391	continue;
1355	1392	},
1356	1393	.ellipsis3 => {
1357		try renderToken(ais, tree, last_param_token, .none); // ...
	1394	try renderToken(r, last_param_token, .none); // ...
1358	1395	break;
1359	1396	},
1360	1397	.keyword_noalias, .keyword_comptime => {
1361		try renderToken(ais, tree, last_param_token, .space);
	1398	try renderToken(r, last_param_token, .space);
1362	1399	last_param_token += 1;
1363	1400	},
1364	1401	.identifier => {},
1365	1402	.keyword_anytype => {
1366		try renderToken(ais, tree, last_param_token, .none); // anytype
	1403	try renderToken(r, last_param_token, .none); // anytype
1367	1404	continue;
1368	1405	},
1369	1406	.r_paren => break,
1370	1407	.comma => {
1371		try renderToken(ais, tree, last_param_token, .space); // ,
	1408	try renderToken(r, last_param_token, .space); // ,
1372	1409	continue;
1373	1410	},
1374	1411	else => {}, // Parameter type without a name.
...	...	@@ -1376,24 +1413,24 @@ fn renderFnProto(gpa: Allocator, ais: *Ais, tree: Ast, fn_proto: Ast.full.FnProt
1376	1413	if (token_tags[last_param_token] == .identifier and
1377	1414	token_tags[last_param_token + 1] == .colon)
1378	1415	{
1379		try renderToken(ais, tree, last_param_token, .none); // name
	1416	try renderToken(r, last_param_token, .none); // name
1380	1417	last_param_token += 1;
1381		try renderToken(ais, tree, last_param_token, .space); // :
	1418	try renderToken(r, last_param_token, .space); // :
1382	1419	last_param_token += 1;
1383	1420	}
1384	1421	if (token_tags[last_param_token] == .keyword_anytype) {
1385		try renderToken(ais, tree, last_param_token, .none); // anytype
	1422	try renderToken(r, last_param_token, .none); // anytype
1386	1423	continue;
1387	1424	}
1388	1425	const param = fn_proto.ast.params[param_i];
1389	1426	param_i += 1;
1390		try renderExpression(gpa, ais, tree, param, .none);
	1427	try renderExpression(r, param, .none);
1391	1428	last_param_token = tree.lastToken(param);
1392	1429	}
1393	1430	} else {
1394	1431	// One param per line.
1395	1432	ais.pushIndent();
1396		try renderToken(ais, tree, lparen, .newline); // (
	1433	try renderToken(r, lparen, .newline); // (
1397	1434
1398	1435	var param_i: usize = 0;
1399	1436	var last_param_token = lparen;
...	...	@@ -1401,20 +1438,20 @@ fn renderFnProto(gpa: Allocator, ais: *Ais, tree: Ast, fn_proto: Ast.full.FnProt
1401	1438	last_param_token += 1;
1402	1439	switch (token_tags[last_param_token]) {
1403	1440	.doc_comment => {
1404		try renderToken(ais, tree, last_param_token, .newline);
	1441	try renderToken(r, last_param_token, .newline);
1405	1442	continue;
1406	1443	},
1407	1444	.ellipsis3 => {
1408		try renderToken(ais, tree, last_param_token, .comma); // ...
	1445	try renderToken(r, last_param_token, .comma); // ...
1409	1446	break;
1410	1447	},
1411	1448	.keyword_noalias, .keyword_comptime => {
1412		try renderToken(ais, tree, last_param_token, .space);
	1449	try renderToken(r, last_param_token, .space);
1413	1450	last_param_token += 1;
1414	1451	},
1415	1452	.identifier => {},
1416	1453	.keyword_anytype => {
1417		try renderToken(ais, tree, last_param_token, .comma); // anytype
	1454	try renderToken(r, last_param_token, .comma); // anytype
1418	1455	if (token_tags[last_param_token + 1] == .comma)
1419	1456	last_param_token += 1;
1420	1457	continue;
...	...	@@ -1425,56 +1462,56 @@ fn renderFnProto(gpa: Allocator, ais: *Ais, tree: Ast, fn_proto: Ast.full.FnProt
1425	1462	if (token_tags[last_param_token] == .identifier and
1426	1463	token_tags[last_param_token + 1] == .colon)
1427	1464	{
1428		try renderToken(ais, tree, last_param_token, .none); // name
	1465	try renderToken(r, last_param_token, .none); // name
1429	1466	last_param_token += 1;
1430		try renderToken(ais, tree, last_param_token, .space); // :
	1467	try renderToken(r, last_param_token, .space); // :
1431	1468	last_param_token += 1;
1432	1469	}
1433	1470	if (token_tags[last_param_token] == .keyword_anytype) {
1434		try renderToken(ais, tree, last_param_token, .comma); // anytype
	1471	try renderToken(r, last_param_token, .comma); // anytype
1435	1472	if (token_tags[last_param_token + 1] == .comma)
1436	1473	last_param_token += 1;
1437	1474	continue;
1438	1475	}
1439	1476	const param = fn_proto.ast.params[param_i];
1440	1477	param_i += 1;
1441		try renderExpression(gpa, ais, tree, param, .comma);
	1478	try renderExpression(r, param, .comma);
1442	1479	last_param_token = tree.lastToken(param);
1443	1480	if (token_tags[last_param_token + 1] == .comma) last_param_token += 1;
1444	1481	}
1445	1482	ais.popIndent();
1446	1483	}
1447	1484
1448		try renderToken(ais, tree, rparen, .space); // )
	1485	try renderToken(r, rparen, .space); // )
1449	1486
1450	1487	if (fn_proto.ast.align_expr != 0) {
1451	1488	const align_lparen = tree.firstToken(fn_proto.ast.align_expr) - 1;
1452	1489	const align_rparen = tree.lastToken(fn_proto.ast.align_expr) + 1;
1453	1490
1454		try renderToken(ais, tree, align_lparen - 1, .none); // align
1455		try renderToken(ais, tree, align_lparen, .none); // (
1456		try renderExpression(gpa, ais, tree, fn_proto.ast.align_expr, .none);
1457		try renderToken(ais, tree, align_rparen, .space); // )
	1491	try renderToken(r, align_lparen - 1, .none); // align
	1492	try renderToken(r, align_lparen, .none); // (
	1493	try renderExpression(r, fn_proto.ast.align_expr, .none);
	1494	try renderToken(r, align_rparen, .space); // )
1458	1495	}
1459	1496
1460	1497	if (fn_proto.ast.addrspace_expr != 0) {
1461	1498	const align_lparen = tree.firstToken(fn_proto.ast.addrspace_expr) - 1;
1462	1499	const align_rparen = tree.lastToken(fn_proto.ast.addrspace_expr) + 1;
1463	1500
1464		try renderToken(ais, tree, align_lparen - 1, .none); // addrspace
1465		try renderToken(ais, tree, align_lparen, .none); // (
1466		try renderExpression(gpa, ais, tree, fn_proto.ast.addrspace_expr, .none);
1467		try renderToken(ais, tree, align_rparen, .space); // )
	1501	try renderToken(r, align_lparen - 1, .none); // addrspace
	1502	try renderToken(r, align_lparen, .none); // (
	1503	try renderExpression(r, fn_proto.ast.addrspace_expr, .none);
	1504	try renderToken(r, align_rparen, .space); // )
1468	1505	}
1469	1506
1470	1507	if (fn_proto.ast.section_expr != 0) {
1471	1508	const section_lparen = tree.firstToken(fn_proto.ast.section_expr) - 1;
1472	1509	const section_rparen = tree.lastToken(fn_proto.ast.section_expr) + 1;
1473	1510
1474		try renderToken(ais, tree, section_lparen - 1, .none); // section
1475		try renderToken(ais, tree, section_lparen, .none); // (
1476		try renderExpression(gpa, ais, tree, fn_proto.ast.section_expr, .none);
1477		try renderToken(ais, tree, section_rparen, .space); // )
	1511	try renderToken(r, section_lparen - 1, .none); // section
	1512	try renderToken(r, section_lparen, .none); // (
	1513	try renderExpression(r, fn_proto.ast.section_expr, .none);
	1514	try renderToken(r, section_rparen, .space); // )
1478	1515	}
1479	1516
1480	1517	const is_callconv_inline = mem.eql(u8, "Inline", tree.tokenSlice(tree.nodes.items(.main_token)[fn_proto.ast.callconv_expr]));
...	...	@@ -1483,25 +1520,24 @@ fn renderFnProto(gpa: Allocator, ais: *Ais, tree: Ast, fn_proto: Ast.full.FnProt
1483	1520	const callconv_lparen = tree.firstToken(fn_proto.ast.callconv_expr) - 1;
1484	1521	const callconv_rparen = tree.lastToken(fn_proto.ast.callconv_expr) + 1;
1485	1522
1486		try renderToken(ais, tree, callconv_lparen - 1, .none); // callconv
1487		try renderToken(ais, tree, callconv_lparen, .none); // (
1488		try renderExpression(gpa, ais, tree, fn_proto.ast.callconv_expr, .none);
1489		try renderToken(ais, tree, callconv_rparen, .space); // )
	1523	try renderToken(r, callconv_lparen - 1, .none); // callconv
	1524	try renderToken(r, callconv_lparen, .none); // (
	1525	try renderExpression(r, fn_proto.ast.callconv_expr, .none);
	1526	try renderToken(r, callconv_rparen, .space); // )
1490	1527	}
1491	1528
1492	1529	if (token_tags[maybe_bang] == .bang) {
1493		try renderToken(ais, tree, maybe_bang, .none); // !
	1530	try renderToken(r, maybe_bang, .none); // !
1494	1531	}
1495		return renderExpression(gpa, ais, tree, fn_proto.ast.return_type, space);
	1532	return renderExpression(r, fn_proto.ast.return_type, space);
1496	1533	}
1497	1534
1498	1535	fn renderSwitchCase(
1499		gpa: Allocator,
1500		ais: *Ais,
1501		tree: Ast,
	1536	r: Render,
1502	1537	switch_case: Ast.full.SwitchCase,
1503	1538	space: Space,
1504	1539	) Error!void {
	1540	const tree = r.tree;
1505	1541	const node_tags = tree.nodes.items(.tag);
1506	1542	const token_tags = tree.tokens.items(.tag);
1507	1543	const trailing_comma = token_tags[switch_case.ast.arrow_token - 1] == .comma;
...	...	@@ -1512,17 +1548,17 @@ fn renderSwitchCase(
1512	1548
1513	1549	// Render everything before the arrow
1514	1550	if (switch_case.ast.values.len == 0) {
1515		try renderToken(ais, tree, switch_case.ast.arrow_token - 1, .space); // else keyword
	1551	try renderToken(r, switch_case.ast.arrow_token - 1, .space); // else keyword
1516	1552	} else if (switch_case.ast.values.len == 1 and !has_comment_before_arrow) {
1517	1553	// render on one line and drop the trailing comma if any
1518		try renderExpression(gpa, ais, tree, switch_case.ast.values[0], .space);
	1554	try renderExpression(r, switch_case.ast.values[0], .space);
1519	1555	} else if (trailing_comma or has_comment_before_arrow) {
1520	1556	// Render each value on a new line
1521		try renderExpressions(gpa, ais, tree, switch_case.ast.values, .comma);
	1557	try renderExpressions(r, switch_case.ast.values, .comma);
1522	1558	} else {
1523	1559	// Render on one line
1524	1560	for (switch_case.ast.values) \|value_expr\| {
1525		try renderExpression(gpa, ais, tree, value_expr, .comma_space);
	1561	try renderExpression(r, value_expr, .comma_space);
1526	1562	}
1527	1563	}
1528	1564
...	...	@@ -1533,31 +1569,31 @@ fn renderSwitchCase(
1533	1569	else
1534	1570	Space.space;
1535	1571	const after_arrow_space: Space = if (switch_case.payload_token == null) pre_target_space else .space;
1536		try renderToken(ais, tree, switch_case.ast.arrow_token, after_arrow_space);
	1572	try renderToken(r, switch_case.ast.arrow_token, after_arrow_space);
1537	1573
1538	1574	if (switch_case.payload_token) \|payload_token\| {
1539		try renderToken(ais, tree, payload_token - 1, .none); // pipe
	1575	try renderToken(r, payload_token - 1, .none); // pipe
1540	1576	if (token_tags[payload_token] == .asterisk) {
1541		try renderToken(ais, tree, payload_token, .none); // asterisk
1542		try renderToken(ais, tree, payload_token + 1, .none); // identifier
1543		try renderToken(ais, tree, payload_token + 2, pre_target_space); // pipe
	1577	try renderToken(r, payload_token, .none); // asterisk
	1578	try renderToken(r, payload_token + 1, .none); // identifier
	1579	try renderToken(r, payload_token + 2, pre_target_space); // pipe
1544	1580	} else {
1545		try renderToken(ais, tree, payload_token, .none); // identifier
1546		try renderToken(ais, tree, payload_token + 1, pre_target_space); // pipe
	1581	try renderToken(r, payload_token, .none); // identifier
	1582	try renderToken(r, payload_token + 1, pre_target_space); // pipe
1547	1583	}
1548	1584	}
1549	1585
1550		try renderExpression(gpa, ais, tree, switch_case.ast.target_expr, space);
	1586	try renderExpression(r, switch_case.ast.target_expr, space);
1551	1587	}
1552	1588
1553	1589	fn renderBlock(
1554		gpa: Allocator,
1555		ais: *Ais,
1556		tree: Ast,
	1590	r: Render,
1557	1591	block_node: Ast.Node.Index,
1558	1592	statements: []const Ast.Node.Index,
1559	1593	space: Space,
1560	1594	) Error!void {
	1595	const tree = r.tree;
	1596	const ais = r.ais;
1561	1597	const token_tags = tree.tokens.items(.tag);
1562	1598	const node_tags = tree.nodes.items(.tag);
1563	1599	const lbrace = tree.nodes.items(.main_token)[block_node];
...	...	@@ -1565,50 +1601,50 @@ fn renderBlock(
1565	1601	if (token_tags[lbrace - 1] == .colon and
1566	1602	token_tags[lbrace - 2] == .identifier)
1567	1603	{
1568		try renderToken(ais, tree, lbrace - 2, .none);
1569		try renderToken(ais, tree, lbrace - 1, .space);
	1604	try renderToken(r, lbrace - 2, .none);
	1605	try renderToken(r, lbrace - 1, .space);
1570	1606	}
1571	1607
1572	1608	ais.pushIndentNextLine();
1573	1609	if (statements.len == 0) {
1574		try renderToken(ais, tree, lbrace, .none);
	1610	try renderToken(r, lbrace, .none);
1575	1611	} else {
1576		try renderToken(ais, tree, lbrace, .newline);
	1612	try renderToken(r, lbrace, .newline);
1577	1613	for (statements) \|stmt, i\| {
1578		if (i != 0) try renderExtraNewline(ais, tree, stmt);
	1614	if (i != 0) try renderExtraNewline(r, stmt);
1579	1615	switch (node_tags[stmt]) {
1580		.global_var_decl => try renderVarDecl(gpa, ais, tree, tree.globalVarDecl(stmt)),
1581		.local_var_decl => try renderVarDecl(gpa, ais, tree, tree.localVarDecl(stmt)),
1582		.simple_var_decl => try renderVarDecl(gpa, ais, tree, tree.simpleVarDecl(stmt)),
1583		.aligned_var_decl => try renderVarDecl(gpa, ais, tree, tree.alignedVarDecl(stmt)),
1584		else => try renderExpression(gpa, ais, tree, stmt, .semicolon),
	1616	.global_var_decl => try renderVarDecl(r, tree.globalVarDecl(stmt)),
	1617	.local_var_decl => try renderVarDecl(r, tree.localVarDecl(stmt)),
	1618	.simple_var_decl => try renderVarDecl(r, tree.simpleVarDecl(stmt)),
	1619	.aligned_var_decl => try renderVarDecl(r, tree.alignedVarDecl(stmt)),
	1620	else => try renderExpression(r, stmt, .semicolon),
1585	1621	}
1586	1622	}
1587	1623	}
1588	1624	ais.popIndent();
1589	1625
1590		try renderToken(ais, tree, tree.lastToken(block_node), space); // rbrace
	1626	try renderToken(r, tree.lastToken(block_node), space); // rbrace
1591	1627	}
1592	1628
1593	1629	fn renderStructInit(
1594		gpa: Allocator,
1595		ais: *Ais,
1596		tree: Ast,
	1630	r: Render,
1597	1631	struct_node: Ast.Node.Index,
1598	1632	struct_init: Ast.full.StructInit,
1599	1633	space: Space,
1600	1634	) Error!void {
	1635	const tree = r.tree;
	1636	const ais = r.ais;
1601	1637	const token_tags = tree.tokens.items(.tag);
1602	1638	if (struct_init.ast.type_expr == 0) {
1603		try renderToken(ais, tree, struct_init.ast.lbrace - 1, .none); // .
	1639	try renderToken(r, struct_init.ast.lbrace - 1, .none); // .
1604	1640	} else {
1605		try renderExpression(gpa, ais, tree, struct_init.ast.type_expr, .none); // T
	1641	try renderExpression(r, struct_init.ast.type_expr, .none); // T
1606	1642	}
1607	1643	if (struct_init.ast.fields.len == 0) {
1608	1644	ais.pushIndentNextLine();
1609		try renderToken(ais, tree, struct_init.ast.lbrace, .none); // lbrace
	1645	try renderToken(r, struct_init.ast.lbrace, .none); // lbrace
1610	1646	ais.popIndent();
1611		return renderToken(ais, tree, struct_init.ast.lbrace + 1, space); // rbrace
	1647	return renderToken(r, struct_init.ast.lbrace + 1, space); // rbrace
1612	1648	}
1613	1649
1614	1650	const rbrace = tree.lastToken(struct_node);
...	...	@@ -1616,59 +1652,60 @@ fn renderStructInit(
1616	1652	if (trailing_comma or hasComment(tree, struct_init.ast.lbrace, rbrace)) {
1617	1653	// Render one field init per line.
1618	1654	ais.pushIndentNextLine();
1619		try renderToken(ais, tree, struct_init.ast.lbrace, .newline);
	1655	try renderToken(r, struct_init.ast.lbrace, .newline);
1620	1656
1621		try renderToken(ais, tree, struct_init.ast.lbrace + 1, .none); // .
1622		try renderToken(ais, tree, struct_init.ast.lbrace + 2, .space); // name
1623		try renderToken(ais, tree, struct_init.ast.lbrace + 3, .space); // =
1624		try renderExpression(gpa, ais, tree, struct_init.ast.fields[0], .comma);
	1657	try renderToken(r, struct_init.ast.lbrace + 1, .none); // .
	1658	try renderToken(r, struct_init.ast.lbrace + 2, .space); // name
	1659	try renderToken(r, struct_init.ast.lbrace + 3, .space); // =
	1660	try renderExpression(r, struct_init.ast.fields[0], .comma);
1625	1661
1626	1662	for (struct_init.ast.fields[1..]) \|field_init\| {
1627	1663	const init_token = tree.firstToken(field_init);
1628		try renderExtraNewlineToken(ais, tree, init_token - 3);
1629		try renderToken(ais, tree, init_token - 3, .none); // .
1630		try renderToken(ais, tree, init_token - 2, .space); // name
1631		try renderToken(ais, tree, init_token - 1, .space); // =
1632		try renderExpression(gpa, ais, tree, field_init, .comma);
	1664	try renderExtraNewlineToken(r, init_token - 3);
	1665	try renderToken(r, init_token - 3, .none); // .
	1666	try renderToken(r, init_token - 2, .space); // name
	1667	try renderToken(r, init_token - 1, .space); // =
	1668	try renderExpression(r, field_init, .comma);
1633	1669	}
1634	1670
1635	1671	ais.popIndent();
1636	1672	} else {
1637	1673	// Render all on one line, no trailing comma.
1638		try renderToken(ais, tree, struct_init.ast.lbrace, .space);
	1674	try renderToken(r, struct_init.ast.lbrace, .space);
1639	1675
1640	1676	for (struct_init.ast.fields) \|field_init\| {
1641	1677	const init_token = tree.firstToken(field_init);
1642		try renderToken(ais, tree, init_token - 3, .none); // .
1643		try renderToken(ais, tree, init_token - 2, .space); // name
1644		try renderToken(ais, tree, init_token - 1, .space); // =
1645		try renderExpression(gpa, ais, tree, field_init, .comma_space);
	1678	try renderToken(r, init_token - 3, .none); // .
	1679	try renderToken(r, init_token - 2, .space); // name
	1680	try renderToken(r, init_token - 1, .space); // =
	1681	try renderExpression(r, field_init, .comma_space);
1646	1682	}
1647	1683	}
1648	1684
1649		return renderToken(ais, tree, rbrace, space);
	1685	return renderToken(r, rbrace, space);
1650	1686	}
1651	1687
1652	1688	fn renderArrayInit(
1653		gpa: Allocator,
1654		ais: *Ais,
1655		tree: Ast,
	1689	r: Render,
1656	1690	array_init: Ast.full.ArrayInit,
1657	1691	space: Space,
1658	1692	) Error!void {
	1693	const tree = r.tree;
	1694	const ais = r.ais;
	1695	const gpa = r.gpa;
1659	1696	const token_tags = tree.tokens.items(.tag);
1660	1697
1661	1698	if (array_init.ast.type_expr == 0) {
1662		try renderToken(ais, tree, array_init.ast.lbrace - 1, .none); // .
	1699	try renderToken(r, array_init.ast.lbrace - 1, .none); // .
1663	1700	} else {
1664		try renderExpression(gpa, ais, tree, array_init.ast.type_expr, .none); // T
	1701	try renderExpression(r, array_init.ast.type_expr, .none); // T
1665	1702	}
1666	1703
1667	1704	if (array_init.ast.elements.len == 0) {
1668	1705	ais.pushIndentNextLine();
1669		try renderToken(ais, tree, array_init.ast.lbrace, .none); // lbrace
	1706	try renderToken(r, array_init.ast.lbrace, .none); // lbrace
1670	1707	ais.popIndent();
1671		return renderToken(ais, tree, array_init.ast.lbrace + 1, space); // rbrace
	1708	return renderToken(r, array_init.ast.lbrace + 1, space); // rbrace
1672	1709	}
1673	1710
1674	1711	const last_elem = array_init.ast.elements[array_init.ast.elements.len - 1];
...	...	@@ -1683,9 +1720,9 @@ fn renderArrayInit(
1683	1720	if (token_tags[first_token] != .multiline_string_literal_line and
1684	1721	!anythingBetween(tree, last_elem_token, rbrace))
1685	1722	{
1686		try renderToken(ais, tree, array_init.ast.lbrace, .none);
1687		try renderExpression(gpa, ais, tree, only_elem, .none);
1688		return renderToken(ais, tree, rbrace, space);
	1723	try renderToken(r, array_init.ast.lbrace, .none);
	1724	try renderExpression(r, only_elem, .none);
	1725	return renderToken(r, rbrace, space);
1689	1726	}
1690	1727	}
1691	1728
...	...	@@ -1696,19 +1733,19 @@ fn renderArrayInit(
1696	1733	// Render all on one line, no trailing comma.
1697	1734	if (array_init.ast.elements.len == 1) {
1698	1735	// If there is only one element, we don't use spaces
1699		try renderToken(ais, tree, array_init.ast.lbrace, .none);
1700		try renderExpression(gpa, ais, tree, array_init.ast.elements[0], .none);
	1736	try renderToken(r, array_init.ast.lbrace, .none);
	1737	try renderExpression(r, array_init.ast.elements[0], .none);
1701	1738	} else {
1702		try renderToken(ais, tree, array_init.ast.lbrace, .space);
	1739	try renderToken(r, array_init.ast.lbrace, .space);
1703	1740	for (array_init.ast.elements) \|elem\| {
1704		try renderExpression(gpa, ais, tree, elem, .comma_space);
	1741	try renderExpression(r, elem, .comma_space);
1705	1742	}
1706	1743	}
1707		return renderToken(ais, tree, last_elem_token + 1, space); // rbrace
	1744	return renderToken(r, last_elem_token + 1, space); // rbrace
1708	1745	}
1709	1746
1710	1747	ais.pushIndentNextLine();
1711		try renderToken(ais, tree, array_init.ast.lbrace, .newline);
	1748	try renderToken(r, array_init.ast.lbrace, .newline);
1712	1749
1713	1750	var expr_index: usize = 0;
1714	1751	while (true) {
...	...	@@ -1764,6 +1801,12 @@ fn renderArrayInit(
1764	1801	.indent_delta = indent_delta,
1765	1802	.underlying_writer = sub_expr_buffer.writer(),
1766	1803	};
	1804	var sub_render: Render = .{
	1805	.gpa = r.gpa,
	1806	.ais = &auto_indenting_stream,
	1807	.tree = r.tree,
	1808	.fixups = r.fixups,
	1809	};
1767	1810
1768	1811	// Calculate size of columns in current section
1769	1812	var column_counter: usize = 0;
...	...	@@ -1774,7 +1817,7 @@ fn renderArrayInit(
1774	1817	sub_expr_buffer_starts[i] = start;
1775	1818
1776	1819	if (i + 1 < section_exprs.len) {
1777		try renderExpression(gpa, &auto_indenting_stream, tree, expr, .none);
	1820	try renderExpression(sub_render, expr, .none);
1778	1821	const width = sub_expr_buffer.items.len - start;
1779	1822	const this_contains_newline = mem.indexOfScalar(u8, sub_expr_buffer.items[start..], '\n') != null;
1780	1823	contains_newline = contains_newline or this_contains_newline;
...	...	@@ -1794,7 +1837,7 @@ fn renderArrayInit(
1794	1837	column_counter = 0;
1795	1838	}
1796	1839	} else {
1797		try renderExpression(gpa, &auto_indenting_stream, tree, expr, .comma);
	1840	try renderExpression(sub_render, expr, .comma);
1798	1841	const width = sub_expr_buffer.items.len - start - 2;
1799	1842	const this_contains_newline = mem.indexOfScalar(u8, sub_expr_buffer.items[start .. sub_expr_buffer.items.len - 1], '\n') != null;
1800	1843	contains_newline = contains_newline or this_contains_newline;
...	...	@@ -1839,7 +1882,7 @@ fn renderArrayInit(
1839	1882	if (column_counter != row_size - 1) {
1840	1883	if (!expr_newlines[i] and !expr_newlines[i + 1]) {
1841	1884	// Neither the current or next expression is multiline
1842		try renderToken(ais, tree, comma, .space); // ,
	1885	try renderToken(r, comma, .space); // ,
1843	1886	assert(column_widths[column_counter % row_size] >= expr_widths[i]);
1844	1887	const padding = column_widths[column_counter % row_size] - expr_widths[i];
1845	1888	try ais.writer().writeByteNTimes(' ', padding);
...	...	@@ -1850,13 +1893,13 @@ fn renderArrayInit(
1850	1893	}
1851	1894
1852	1895	if (single_line and row_size != 1) {
1853		try renderToken(ais, tree, comma, .space); // ,
	1896	try renderToken(r, comma, .space); // ,
1854	1897	continue;
1855	1898	}
1856	1899
1857	1900	column_counter = 0;
1858		try renderToken(ais, tree, comma, .newline); // ,
1859		try renderExtraNewline(ais, tree, next_expr);
	1901	try renderToken(r, comma, .newline); // ,
	1902	try renderExtraNewline(r, next_expr);
1860	1903	}
1861	1904	}
1862	1905
...	...	@@ -1865,49 +1908,49 @@ fn renderArrayInit(
1865	1908	}
1866	1909
1867	1910	ais.popIndent();
1868		return renderToken(ais, tree, rbrace, space); // rbrace
	1911	return renderToken(r, rbrace, space); // rbrace
1869	1912	}
1870	1913
1871	1914	fn renderContainerDecl(
1872		gpa: Allocator,
1873		ais: *Ais,
1874		tree: Ast,
	1915	r: Render,
1875	1916	container_decl_node: Ast.Node.Index,
1876	1917	container_decl: Ast.full.ContainerDecl,
1877	1918	space: Space,
1878	1919	) Error!void {
	1920	const tree = r.tree;
	1921	const ais = r.ais;
1879	1922	const token_tags = tree.tokens.items(.tag);
1880	1923	const node_tags = tree.nodes.items(.tag);
1881	1924
1882	1925	if (container_decl.layout_token) \|layout_token\| {
1883		try renderToken(ais, tree, layout_token, .space);
	1926	try renderToken(r, layout_token, .space);
1884	1927	}
1885	1928
1886	1929	var lbrace: Ast.TokenIndex = undefined;
1887	1930	if (container_decl.ast.enum_token) \|enum_token\| {
1888		try renderToken(ais, tree, container_decl.ast.main_token, .none); // union
1889		try renderToken(ais, tree, enum_token - 1, .none); // lparen
1890		try renderToken(ais, tree, enum_token, .none); // enum
	1931	try renderToken(r, container_decl.ast.main_token, .none); // union
	1932	try renderToken(r, enum_token - 1, .none); // lparen
	1933	try renderToken(r, enum_token, .none); // enum
1891	1934	if (container_decl.ast.arg != 0) {
1892		try renderToken(ais, tree, enum_token + 1, .none); // lparen
1893		try renderExpression(gpa, ais, tree, container_decl.ast.arg, .none);
	1935	try renderToken(r, enum_token + 1, .none); // lparen
	1936	try renderExpression(r, container_decl.ast.arg, .none);
1894	1937	const rparen = tree.lastToken(container_decl.ast.arg) + 1;
1895		try renderToken(ais, tree, rparen, .none); // rparen
1896		try renderToken(ais, tree, rparen + 1, .space); // rparen
	1938	try renderToken(r, rparen, .none); // rparen
	1939	try renderToken(r, rparen + 1, .space); // rparen
1897	1940	lbrace = rparen + 2;
1898	1941	} else {
1899		try renderToken(ais, tree, enum_token + 1, .space); // rparen
	1942	try renderToken(r, enum_token + 1, .space); // rparen
1900	1943	lbrace = enum_token + 2;
1901	1944	}
1902	1945	} else if (container_decl.ast.arg != 0) {
1903		try renderToken(ais, tree, container_decl.ast.main_token, .none); // union
1904		try renderToken(ais, tree, container_decl.ast.main_token + 1, .none); // lparen
1905		try renderExpression(gpa, ais, tree, container_decl.ast.arg, .none);
	1946	try renderToken(r, container_decl.ast.main_token, .none); // union
	1947	try renderToken(r, container_decl.ast.main_token + 1, .none); // lparen
	1948	try renderExpression(r, container_decl.ast.arg, .none);
1906	1949	const rparen = tree.lastToken(container_decl.ast.arg) + 1;
1907		try renderToken(ais, tree, rparen, .space); // rparen
	1950	try renderToken(r, rparen, .space); // rparen
1908	1951	lbrace = rparen + 1;
1909	1952	} else {
1910		try renderToken(ais, tree, container_decl.ast.main_token, .space); // union
	1953	try renderToken(r, container_decl.ast.main_token, .space); // union
1911	1954	lbrace = container_decl.ast.main_token + 1;
1912	1955	}
1913	1956
...	...	@@ -1915,13 +1958,13 @@ fn renderContainerDecl(
1915	1958	if (container_decl.ast.members.len == 0) {
1916	1959	ais.pushIndentNextLine();
1917	1960	if (token_tags[lbrace + 1] == .container_doc_comment) {
1918		try renderToken(ais, tree, lbrace, .newline); // lbrace
1919		try renderContainerDocComments(ais, tree, lbrace + 1);
	1961	try renderToken(r, lbrace, .newline); // lbrace
	1962	try renderContainerDocComments(r, lbrace + 1);
1920	1963	} else {
1921		try renderToken(ais, tree, lbrace, .none); // lbrace
	1964	try renderToken(r, lbrace, .none); // lbrace
1922	1965	}
1923	1966	ais.popIndent();
1924		return renderToken(ais, tree, rbrace, space); // rbrace
	1967	return renderToken(r, rbrace, space); // rbrace
1925	1968	}
1926	1969
1927	1970	const src_has_trailing_comma = token_tags[rbrace - 1] == .comma;
...	...	@@ -1947,52 +1990,52 @@ fn renderContainerDecl(
1947	1990	}
1948	1991
1949	1992	// Print all the declarations on the same line.
1950		try renderToken(ais, tree, lbrace, .space); // lbrace
	1993	try renderToken(r, lbrace, .space); // lbrace
1951	1994	for (container_decl.ast.members) \|member\| {
1952		try renderMember(gpa, ais, tree, member, .space);
	1995	try renderMember(r, member, .space);
1953	1996	}
1954		return renderToken(ais, tree, rbrace, space); // rbrace
	1997	return renderToken(r, rbrace, space); // rbrace
1955	1998	}
1956	1999
1957	2000	// One member per line.
1958	2001	ais.pushIndentNextLine();
1959		try renderToken(ais, tree, lbrace, .newline); // lbrace
	2002	try renderToken(r, lbrace, .newline); // lbrace
1960	2003	if (token_tags[lbrace + 1] == .container_doc_comment) {
1961		try renderContainerDocComments(ais, tree, lbrace + 1);
	2004	try renderContainerDocComments(r, lbrace + 1);
1962	2005	}
1963	2006	for (container_decl.ast.members) \|member, i\| {
1964		if (i != 0) try renderExtraNewline(ais, tree, member);
	2007	if (i != 0) try renderExtraNewline(r, member);
1965	2008	switch (tree.nodes.items(.tag)[member]) {
1966	2009	// For container fields, ensure a trailing comma is added if necessary.
1967	2010	.container_field_init,
1968	2011	.container_field_align,
1969	2012	.container_field,
1970		=> try renderMember(gpa, ais, tree, member, .comma),
	2013	=> try renderMember(r, member, .comma),
1971	2014
1972		else => try renderMember(gpa, ais, tree, member, .newline),
	2015	else => try renderMember(r, member, .newline),
1973	2016	}
1974	2017	}
1975	2018	ais.popIndent();
1976	2019
1977		return renderToken(ais, tree, rbrace, space); // rbrace
	2020	return renderToken(r, rbrace, space); // rbrace
1978	2021	}
1979	2022
1980	2023	fn renderAsm(
1981		gpa: Allocator,
1982		ais: *Ais,
1983		tree: Ast,
	2024	r: Render,
1984	2025	asm_node: Ast.full.Asm,
1985	2026	space: Space,
1986	2027	) Error!void {
	2028	const tree = r.tree;
	2029	const ais = r.ais;
1987	2030	const token_tags = tree.tokens.items(.tag);
1988	2031
1989		try renderToken(ais, tree, asm_node.ast.asm_token, .space); // asm
	2032	try renderToken(r, asm_node.ast.asm_token, .space); // asm
1990	2033
1991	2034	if (asm_node.volatile_token) \|volatile_token\| {
1992		try renderToken(ais, tree, volatile_token, .space); // volatile
1993		try renderToken(ais, tree, volatile_token + 1, .none); // lparen
	2035	try renderToken(r, volatile_token, .space); // volatile
	2036	try renderToken(r, volatile_token + 1, .none); // lparen
1994	2037	} else {
1995		try renderToken(ais, tree, asm_node.ast.asm_token + 1, .none); // lparen
	2038	try renderToken(r, asm_node.ast.asm_token + 1, .none); // lparen
1996	2039	}
1997	2040
1998	2041	if (asm_node.ast.items.len == 0) {
...	...	@@ -2000,27 +2043,27 @@ fn renderAsm(
2000	2043	if (asm_node.first_clobber) \|first_clobber\| {
2001	2044	// asm ("foo" ::: "a", "b")
2002	2045	// asm ("foo" ::: "a", "b",)
2003		try renderExpression(gpa, ais, tree, asm_node.ast.template, .space);
	2046	try renderExpression(r, asm_node.ast.template, .space);
2004	2047	// Render the three colons.
2005		try renderToken(ais, tree, first_clobber - 3, .none);
2006		try renderToken(ais, tree, first_clobber - 2, .none);
2007		try renderToken(ais, tree, first_clobber - 1, .space);
	2048	try renderToken(r, first_clobber - 3, .none);
	2049	try renderToken(r, first_clobber - 2, .none);
	2050	try renderToken(r, first_clobber - 1, .space);
2008	2051
2009	2052	var tok_i = first_clobber;
2010	2053	while (true) : (tok_i += 1) {
2011		try renderToken(ais, tree, tok_i, .none);
	2054	try renderToken(r, tok_i, .none);
2012	2055	tok_i += 1;
2013	2056	switch (token_tags[tok_i]) {
2014	2057	.r_paren => {
2015	2058	ais.popIndent();
2016		return renderToken(ais, tree, tok_i, space);
	2059	return renderToken(r, tok_i, space);
2017	2060	},
2018	2061	.comma => {
2019	2062	if (token_tags[tok_i + 1] == .r_paren) {
2020	2063	ais.popIndent();
2021		return renderToken(ais, tree, tok_i + 1, space);
	2064	return renderToken(r, tok_i + 1, space);
2022	2065	} else {
2023		try renderToken(ais, tree, tok_i, .space);
	2066	try renderToken(r, tok_i, .space);
2024	2067	}
2025	2068	},
2026	2069	else => unreachable,
...	...	@@ -2028,40 +2071,40 @@ fn renderAsm(
2028	2071	}
2029	2072	} else {
2030	2073	// asm ("foo")
2031		try renderExpression(gpa, ais, tree, asm_node.ast.template, .none);
	2074	try renderExpression(r, asm_node.ast.template, .none);
2032	2075	ais.popIndent();
2033		return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
	2076	return renderToken(r, asm_node.ast.rparen, space); // rparen
2034	2077	}
2035	2078	}
2036	2079
2037	2080	ais.pushIndent();
2038		try renderExpression(gpa, ais, tree, asm_node.ast.template, .newline);
	2081	try renderExpression(r, asm_node.ast.template, .newline);
2039	2082	ais.setIndentDelta(asm_indent_delta);
2040	2083	const colon1 = tree.lastToken(asm_node.ast.template) + 1;
2041	2084
2042	2085	const colon2 = if (asm_node.outputs.len == 0) colon2: {
2043		try renderToken(ais, tree, colon1, .newline); // :
	2086	try renderToken(r, colon1, .newline); // :
2044	2087	break :colon2 colon1 + 1;
2045	2088	} else colon2: {
2046		try renderToken(ais, tree, colon1, .space); // :
	2089	try renderToken(r, colon1, .space); // :
2047	2090
2048	2091	ais.pushIndent();
2049	2092	for (asm_node.outputs) \|asm_output, i\| {
2050	2093	if (i + 1 < asm_node.outputs.len) {
2051	2094	const next_asm_output = asm_node.outputs[i + 1];
2052		try renderAsmOutput(gpa, ais, tree, asm_output, .none);
	2095	try renderAsmOutput(r, asm_output, .none);
2053	2096
2054	2097	const comma = tree.firstToken(next_asm_output) - 1;
2055		try renderToken(ais, tree, comma, .newline); // ,
2056		try renderExtraNewlineToken(ais, tree, tree.firstToken(next_asm_output));
	2098	try renderToken(r, comma, .newline); // ,
	2099	try renderExtraNewlineToken(r, tree.firstToken(next_asm_output));
2057	2100	} else if (asm_node.inputs.len == 0 and asm_node.first_clobber == null) {
2058		try renderAsmOutput(gpa, ais, tree, asm_output, .comma);
	2101	try renderAsmOutput(r, asm_output, .comma);
2059	2102	ais.popIndent();
2060	2103	ais.setIndentDelta(indent_delta);
2061	2104	ais.popIndent();
2062		return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
	2105	return renderToken(r, asm_node.ast.rparen, space); // rparen
2063	2106	} else {
2064		try renderAsmOutput(gpa, ais, tree, asm_output, .comma);
	2107	try renderAsmOutput(r, asm_output, .comma);
2065	2108	const comma_or_colon = tree.lastToken(asm_output) + 1;
2066	2109	ais.popIndent();
2067	2110	break :colon2 switch (token_tags[comma_or_colon]) {
...	...	@@ -2073,27 +2116,27 @@ fn renderAsm(
2073	2116	};
2074	2117
2075	2118	const colon3 = if (asm_node.inputs.len == 0) colon3: {
2076		try renderToken(ais, tree, colon2, .newline); // :
	2119	try renderToken(r, colon2, .newline); // :
2077	2120	break :colon3 colon2 + 1;
2078	2121	} else colon3: {
2079		try renderToken(ais, tree, colon2, .space); // :
	2122	try renderToken(r, colon2, .space); // :
2080	2123	ais.pushIndent();
2081	2124	for (asm_node.inputs) \|asm_input, i\| {
2082	2125	if (i + 1 < asm_node.inputs.len) {
2083	2126	const next_asm_input = asm_node.inputs[i + 1];
2084		try renderAsmInput(gpa, ais, tree, asm_input, .none);
	2127	try renderAsmInput(r, asm_input, .none);
2085	2128
2086	2129	const first_token = tree.firstToken(next_asm_input);
2087		try renderToken(ais, tree, first_token - 1, .newline); // ,
2088		try renderExtraNewlineToken(ais, tree, first_token);
	2130	try renderToken(r, first_token - 1, .newline); // ,
	2131	try renderExtraNewlineToken(r, first_token);
2089	2132	} else if (asm_node.first_clobber == null) {
2090		try renderAsmInput(gpa, ais, tree, asm_input, .comma);
	2133	try renderAsmInput(r, asm_input, .comma);
2091	2134	ais.popIndent();
2092	2135	ais.setIndentDelta(indent_delta);
2093	2136	ais.popIndent();
2094		return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
	2137	return renderToken(r, asm_node.ast.rparen, space); // rparen
2095	2138	} else {
2096		try renderAsmInput(gpa, ais, tree, asm_input, .comma);
	2139	try renderAsmInput(r, asm_input, .comma);
2097	2140	const comma_or_colon = tree.lastToken(asm_input) + 1;
2098	2141	ais.popIndent();
2099	2142	break :colon3 switch (token_tags[comma_or_colon]) {
...	...	@@ -2105,7 +2148,7 @@ fn renderAsm(
2105	2148	unreachable;
2106	2149	};
2107	2150
2108		try renderToken(ais, tree, colon3, .space); // :
	2151	try renderToken(r, colon3, .space); // :
2109	2152	const first_clobber = asm_node.first_clobber.?;
2110	2153	var tok_i = first_clobber;
2111	2154	while (true) {
...	...	@@ -2113,20 +2156,20 @@ fn renderAsm(
2113	2156	.r_paren => {
2114	2157	ais.setIndentDelta(indent_delta);
2115	2158	ais.popIndent();
2116		try renderToken(ais, tree, tok_i, .newline);
2117		return renderToken(ais, tree, tok_i + 1, space);
	2159	try renderToken(r, tok_i, .newline);
	2160	return renderToken(r, tok_i + 1, space);
2118	2161	},
2119	2162	.comma => {
2120	2163	switch (token_tags[tok_i + 2]) {
2121	2164	.r_paren => {
2122	2165	ais.setIndentDelta(indent_delta);
2123	2166	ais.popIndent();
2124		try renderToken(ais, tree, tok_i, .newline);
2125		return renderToken(ais, tree, tok_i + 2, space);
	2167	try renderToken(r, tok_i, .newline);
	2168	return renderToken(r, tok_i + 2, space);
2126	2169	},
2127	2170	else => {
2128		try renderToken(ais, tree, tok_i, .none);
2129		try renderToken(ais, tree, tok_i + 1, .space);
	2171	try renderToken(r, tok_i, .none);
	2172	try renderToken(r, tok_i + 1, .space);
2130	2173	tok_i += 2;
2131	2174	},
2132	2175	}
...	...	@@ -2137,36 +2180,36 @@ fn renderAsm(
2137	2180	}
2138	2181
2139	2182	fn renderCall(
2140		gpa: Allocator,
2141		ais: *Ais,
2142		tree: Ast,
	2183	r: Render,
2143	2184	call: Ast.full.Call,
2144	2185	space: Space,
2145	2186	) Error!void {
	2187	const tree = r.tree;
	2188	const ais = r.ais;
2146	2189	const token_tags = tree.tokens.items(.tag);
2147	2190
2148	2191	if (call.async_token) \|async_token\| {
2149		try renderToken(ais, tree, async_token, .space);
	2192	try renderToken(r, async_token, .space);
2150	2193	}
2151		try renderExpression(gpa, ais, tree, call.ast.fn_expr, .none);
	2194	try renderExpression(r, call.ast.fn_expr, .none);
2152	2195
2153	2196	const lparen = call.ast.lparen;
2154	2197	const params = call.ast.params;
2155	2198	if (params.len == 0) {
2156	2199	ais.pushIndentNextLine();
2157		try renderToken(ais, tree, lparen, .none);
	2200	try renderToken(r, lparen, .none);
2158	2201	ais.popIndent();
2159		return renderToken(ais, tree, lparen + 1, space); // )
	2202	return renderToken(r, lparen + 1, space); // )
2160	2203	}
2161	2204
2162	2205	const last_param = params[params.len - 1];
2163	2206	const after_last_param_tok = tree.lastToken(last_param) + 1;
2164	2207	if (token_tags[after_last_param_tok] == .comma) {
2165	2208	ais.pushIndentNextLine();
2166		try renderToken(ais, tree, lparen, .newline); // (
	2209	try renderToken(r, lparen, .newline); // (
2167	2210	for (params) \|param_node, i\| {
2168	2211	if (i + 1 < params.len) {
2169		try renderExpression(gpa, ais, tree, param_node, .none);
	2212	try renderExpression(r, param_node, .none);
2170	2213
2171	2214	// Unindent the comma for multiline string literals.
2172	2215	const is_multiline_string =
...	...	@@ -2174,20 +2217,20 @@ fn renderCall(
2174	2217	if (is_multiline_string) ais.popIndent();
2175	2218
2176	2219	const comma = tree.lastToken(param_node) + 1;
2177		try renderToken(ais, tree, comma, .newline); // ,
	2220	try renderToken(r, comma, .newline); // ,
2178	2221
2179	2222	if (is_multiline_string) ais.pushIndent();
2180	2223
2181		try renderExtraNewline(ais, tree, params[i + 1]);
	2224	try renderExtraNewline(r, params[i + 1]);
2182	2225	} else {
2183		try renderExpression(gpa, ais, tree, param_node, .comma);
	2226	try renderExpression(r, param_node, .comma);
2184	2227	}
2185	2228	}
2186	2229	ais.popIndent();
2187		return renderToken(ais, tree, after_last_param_tok + 1, space); // )
	2230	return renderToken(r, after_last_param_tok + 1, space); // )
2188	2231	}
2189	2232
2190		try renderToken(ais, tree, lparen, .none); // (
	2233	try renderToken(r, lparen, .none); // (
2191	2234
2192	2235	for (params) \|param_node, i\| {
2193	2236	const first_param_token = tree.firstToken(param_node);
...	...	@@ -2196,23 +2239,25 @@ fn renderCall(
2196	2239	{
2197	2240	ais.pushIndentOneShot();
2198	2241	}
2199		try renderExpression(gpa, ais, tree, param_node, .none);
	2242	try renderExpression(r, param_node, .none);
2200	2243
2201	2244	if (i + 1 < params.len) {
2202	2245	const comma = tree.lastToken(param_node) + 1;
2203	2246	const next_multiline_string =
2204	2247	token_tags[tree.firstToken(params[i + 1])] == .multiline_string_literal_line;
2205	2248	const comma_space: Space = if (next_multiline_string) .none else .space;
2206		try renderToken(ais, tree, comma, comma_space);
	2249	try renderToken(r, comma, comma_space);
2207	2250	}
2208	2251	}
2209	2252
2210		return renderToken(ais, tree, after_last_param_tok, space); // )
	2253	return renderToken(r, after_last_param_tok, space); // )
2211	2254	}
2212	2255
2213	2256	/// Renders the given expression indented, popping the indent before rendering
2214	2257	/// any following line comments
2215		fn renderExpressionIndented(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index, space: Space) Error!void {
	2258	fn renderExpressionIndented(r: Render, node: Ast.Node.Index, space: Space) Error!void {
	2259	const tree = r.tree;
	2260	const ais = r.ais;
2216	2261	const token_starts = tree.tokens.items(.start);
2217	2262	const token_tags = tree.tokens.items(.tag);
2218	2263
...	...	@@ -2226,24 +2271,24 @@ fn renderExpressionIndented(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node
2226	2271	.semicolon => token_tags[last_token + 1] == .semicolon,
2227	2272	};
2228	2273
2229		try renderExpression(gpa, ais, tree, node, if (punctuation) .none else .skip);
	2274	try renderExpression(r, node, if (punctuation) .none else .skip);
2230	2275
2231	2276	switch (space) {
2232	2277	.none, .space, .newline, .skip => {},
2233	2278	.comma => {
2234	2279	if (token_tags[last_token + 1] == .comma) {
2235		try renderToken(ais, tree, last_token + 1, .skip);
	2280	try renderToken(r, last_token + 1, .skip);
2236	2281	last_token += 1;
2237	2282	} else {
2238	2283	try ais.writer().writeByte(',');
2239	2284	}
2240	2285	},
2241	2286	.comma_space => if (token_tags[last_token + 1] == .comma) {
2242		try renderToken(ais, tree, last_token + 1, .skip);
	2287	try renderToken(r, last_token + 1, .skip);
2243	2288	last_token += 1;
2244	2289	},
2245	2290	.semicolon => if (token_tags[last_token + 1] == .semicolon) {
2246		try renderToken(ais, tree, last_token + 1, .skip);
	2291	try renderToken(r, last_token + 1, .skip);
2247	2292	last_token += 1;
2248	2293	},
2249	2294	}
...	...	@@ -2253,7 +2298,7 @@ fn renderExpressionIndented(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node
2253	2298	if (space == .skip) return;
2254	2299
2255	2300	const comment_start = token_starts[last_token] + tokenSliceForRender(tree, last_token).len;
2256		const comment = try renderComments(ais, tree, comment_start, token_starts[last_token + 1]);
	2301	const comment = try renderComments(r, comment_start, token_starts[last_token + 1]);
2257	2302
2258	2303	if (!comment) switch (space) {
2259	2304	.none => {},
...	...	@@ -2270,27 +2315,29 @@ fn renderExpressionIndented(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node
2270	2315
2271	2316	/// Render an expression, and the comma that follows it, if it is present in the source.
2272	2317	/// If a comma is present, and `space` is `Space.comma`, render only a single comma.
2273		fn renderExpressionComma(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index, space: Space) Error!void {
	2318	fn renderExpressionComma(r: Render, node: Ast.Node.Index, space: Space) Error!void {
	2319	const tree = r.tree;
2274	2320	const token_tags = tree.tokens.items(.tag);
2275	2321	const maybe_comma = tree.lastToken(node) + 1;
2276	2322	if (token_tags[maybe_comma] == .comma and space != .comma) {
2277		try renderExpression(gpa, ais, tree, node, .none);
2278		return renderToken(ais, tree, maybe_comma, space);
	2323	try renderExpression(r, node, .none);
	2324	return renderToken(r, maybe_comma, space);
2279	2325	} else {
2280		return renderExpression(gpa, ais, tree, node, space);
	2326	return renderExpression(r, node, space);
2281	2327	}
2282	2328	}
2283	2329
2284	2330	/// Render a token, and the comma that follows it, if it is present in the source.
2285	2331	/// If a comma is present, and `space` is `Space.comma`, render only a single comma.
2286		fn renderTokenComma(ais: *Ais, tree: Ast, token: Ast.TokenIndex, space: Space) Error!void {
	2332	fn renderTokenComma(r: Render, token: Ast.TokenIndex, space: Space) Error!void {
	2333	const tree = r.tree;
2287	2334	const token_tags = tree.tokens.items(.tag);
2288	2335	const maybe_comma = token + 1;
2289	2336	if (token_tags[maybe_comma] == .comma and space != .comma) {
2290		try renderToken(ais, tree, token, .none);
2291		return renderToken(ais, tree, maybe_comma, space);
	2337	try renderToken(r, token, .none);
	2338	return renderToken(r, maybe_comma, space);
2292	2339	} else {
2293		return renderToken(ais, tree, token, space);
	2340	return renderToken(r, token, space);
2294	2341	}
2295	2342	}
2296	2343
...	...	@@ -2315,13 +2362,17 @@ const Space = enum {
2315	2362	skip,
2316	2363	};
2317	2364
2318		fn renderToken(ais: *Ais, tree: Ast, token_index: Ast.TokenIndex, space: Space) Error!void {
	2365	fn renderToken(r: Render, token_index: Ast.TokenIndex, space: Space) Error!void {
	2366	const tree = r.tree;
	2367	const ais = r.ais;
2319	2368	const lexeme = tokenSliceForRender(tree, token_index);
2320	2369	try ais.writer().writeAll(lexeme);
2321		try renderSpace(ais, tree, token_index, lexeme.len, space);
	2370	try renderSpace(r, token_index, lexeme.len, space);
2322	2371	}
2323	2372
2324		fn renderSpace(ais: *Ais, tree: Ast, token_index: Ast.TokenIndex, lexeme_len: usize, space: Space) Error!void {
	2373	fn renderSpace(r: Render, token_index: Ast.TokenIndex, lexeme_len: usize, space: Space) Error!void {
	2374	const tree = r.tree;
	2375	const ais = r.ais;
2325	2376	const token_tags = tree.tokens.items(.tag);
2326	2377	const token_starts = tree.tokens.items(.start);
2327	2378
...	...	@@ -2333,26 +2384,26 @@ fn renderSpace(ais: *Ais, tree: Ast, token_index: Ast.TokenIndex, lexeme_len: us
2333	2384	try ais.writer().writeByte(',');
2334	2385	}
2335	2386
2336		const comment = try renderComments(ais, tree, token_start + lexeme_len, token_starts[token_index + 1]);
	2387	const comment = try renderComments(r, token_start + lexeme_len, token_starts[token_index + 1]);
2337	2388	switch (space) {
2338	2389	.none => {},
2339	2390	.space => if (!comment) try ais.writer().writeByte(' '),
2340	2391	.newline => if (!comment) try ais.insertNewline(),
2341	2392
2342	2393	.comma => if (token_tags[token_index + 1] == .comma) {
2343		try renderToken(ais, tree, token_index + 1, .newline);
	2394	try renderToken(r, token_index + 1, .newline);
2344	2395	} else if (!comment) {
2345	2396	try ais.insertNewline();
2346	2397	},
2347	2398
2348	2399	.comma_space => if (token_tags[token_index + 1] == .comma) {
2349		try renderToken(ais, tree, token_index + 1, .space);
	2400	try renderToken(r, token_index + 1, .space);
2350	2401	} else if (!comment) {
2351	2402	try ais.writer().writeByte(' ');
2352	2403	},
2353	2404
2354	2405	.semicolon => if (token_tags[token_index + 1] == .semicolon) {
2355		try renderToken(ais, tree, token_index + 1, .newline);
	2406	try renderToken(r, token_index + 1, .newline);
2356	2407	} else if (!comment) {
2357	2408	try ais.insertNewline();
2358	2409	},
...	...	@@ -2395,7 +2446,10 @@ fn hasMultilineString(tree: Ast, start_token: Ast.TokenIndex, end_token: Ast.Tok
2395	2446
2396	2447	/// Assumes that start is the first byte past the previous token and
2397	2448	/// that end is the last byte before the next token.
2398		fn renderComments(ais: *Ais, tree: Ast, start: usize, end: usize) Error!bool {
	2449	fn renderComments(r: Render, start: usize, end: usize) Error!bool {
	2450	const tree = r.tree;
	2451	const ais = r.ais;
	2452
2399	2453	var index: usize = start;
2400	2454	while (mem.indexOf(u8, tree.source[index..end], "//")) \|offset\| {
2401	2455	const comment_start = index + offset;
...	...	@@ -2452,12 +2506,14 @@ fn renderComments(ais: *Ais, tree: Ast, start: usize, end: usize) Error!bool {
2452	2506	return index != start;
2453	2507	}
2454	2508
2455		fn renderExtraNewline(ais: *Ais, tree: Ast, node: Ast.Node.Index) Error!void {
2456		return renderExtraNewlineToken(ais, tree, tree.firstToken(node));
	2509	fn renderExtraNewline(r: Render, node: Ast.Node.Index) Error!void {
	2510	return renderExtraNewlineToken(r, r.tree.firstToken(node));
2457	2511	}
2458	2512
2459	2513	/// Check if there is an empty line immediately before the given token. If so, render it.
2460		fn renderExtraNewlineToken(ais: *Ais, tree: Ast, token_index: Ast.TokenIndex) Error!void {
	2514	fn renderExtraNewlineToken(r: Render, token_index: Ast.TokenIndex) Error!void {
	2515	const tree = r.tree;
	2516	const ais = r.ais;
2461	2517	const token_starts = tree.tokens.items(.start);
2462	2518	const token_start = token_starts[token_index];
2463	2519	if (token_start == 0) return;
...	...	@@ -2482,7 +2538,8 @@ fn renderExtraNewlineToken(ais: *Ais, tree: Ast, token_index: Ast.TokenIndex) Er
2482	2538
2483	2539	/// end_token is the token one past the last doc comment token. This function
2484	2540	/// searches backwards from there.
2485		fn renderDocComments(ais: *Ais, tree: Ast, end_token: Ast.TokenIndex) Error!void {
	2541	fn renderDocComments(r: Render, end_token: Ast.TokenIndex) Error!void {
	2542	const tree = r.tree;
2486	2543	// Search backwards for the first doc comment.
2487	2544	const token_tags = tree.tokens.items(.tag);
2488	2545	if (end_token == 0) return;
...	...	@@ -2503,27 +2560,28 @@ fn renderDocComments(ais: *Ais, tree: Ast, end_token: Ast.TokenIndex) Error!void
2503	2560	assert(prev_token_tag != .l_paren);
2504	2561
2505	2562	if (prev_token_tag != .l_brace) {
2506		try renderExtraNewlineToken(ais, tree, first_tok);
	2563	try renderExtraNewlineToken(r, first_tok);
2507	2564	}
2508	2565	}
2509	2566
2510	2567	while (token_tags[tok] == .doc_comment) : (tok += 1) {
2511		try renderToken(ais, tree, tok, .newline);
	2568	try renderToken(r, tok, .newline);
2512	2569	}
2513	2570	}
2514	2571
2515	2572	/// start_token is first container doc comment token.
2516		fn renderContainerDocComments(ais: *Ais, tree: Ast, start_token: Ast.TokenIndex) Error!void {
	2573	fn renderContainerDocComments(r: Render, start_token: Ast.TokenIndex) Error!void {
	2574	const tree = r.tree;
2517	2575	const token_tags = tree.tokens.items(.tag);
2518	2576	var tok = start_token;
2519	2577	while (token_tags[tok] == .container_doc_comment) : (tok += 1) {
2520		try renderToken(ais, tree, tok, .newline);
	2578	try renderToken(r, tok, .newline);
2521	2579	}
2522	2580	// Render extra newline if there is one between final container doc comment and
2523	2581	// the next token. If the next token is a doc comment, that code path
2524	2582	// will have its own logic to insert a newline.
2525	2583	if (token_tags[tok] != .doc_comment) {
2526		try renderExtraNewlineToken(ais, tree, tok);
	2584	try renderExtraNewlineToken(r, tok);
2527	2585	}
2528	2586	}
2529	2587

src/Compilation.zig+3

...	...	@@ -93,6 +93,7 @@ unwind_tables: bool,
93	93	test_evented_io: bool,
94	94	debug_compiler_runtime_libs: bool,
95	95	debug_compile_errors: bool,
	96	autofix: bool,
96	97	job_queued_compiler_rt_lib: bool = false,
97	98	job_queued_compiler_rt_obj: bool = false,
98	99	alloc_failure_occurred: bool = false,
...	...	@@ -856,6 +857,7 @@ pub const InitOptions = struct {
856	857	single_threaded: ?bool = null,
857	858	rdynamic: bool = false,
858	859	strip: bool = false,
	860	autofix: bool = false,
859	861	function_sections: bool = false,
860	862	no_builtin: bool = false,
861	863	is_native_os: bool,
...	...	@@ -1838,6 +1840,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1838	1840	.color = options.color,
1839	1841	.time_report = options.time_report,
1840	1842	.stack_report = options.stack_report,
	1843	.autofix = options.autofix,
1841	1844	.unwind_tables = unwind_tables,
1842	1845	.test_filter = options.test_filter,
1843	1846	.test_name_prefix = options.test_name_prefix,

src/Module.zig+125-54

...	...	@@ -3493,7 +3493,11 @@ pub fn astGenFile(mod: Module, file: File) !void {
3493	3493	const gpa = mod.gpa;
3494	3494
3495	3495	// In any case we need to examine the stat of the file to determine the course of action.
3496		var source_file = try file.pkg.root_src_directory.handle.openFile(file.sub_file_path, .{});
	3496	const want_autofix = comp.autofix and mod.main_pkg == file.pkg;
	3497	const open_flags: std.fs.File.OpenMode = if (want_autofix) .read_write else .read_only;
	3498	var source_file = try file.pkg.root_src_directory.handle.openFile(file.sub_file_path, .{
	3499	.mode = open_flags,
	3500	});
3497	3501	defer source_file.close();
3498	3502
3499	3503	const stat = try source_file.stat();
...	...	@@ -3643,12 +3647,17 @@ pub fn astGenFile(mod: Module, file: File) !void {
3643	3647
3644	3648	// TODO don't report compile errors until Sema @importFile
3645	3649	if (file.zir.hasCompileErrors()) {
	3650	file.status = .astgen_failure;
	3651
	3652	// If autofix is requested, treat this is a cache miss so that
	3653	// the autofix code has a chance to run.
	3654	if (want_autofix) break :cached;
	3655
3646	3656	{
3647	3657	comp.mutex.lock();
3648	3658	defer comp.mutex.unlock();
3649	3659	try mod.failed_files.putNoClobber(gpa, file, null);
3650	3660	}
3651		file.status = .astgen_failure;
3652	3661	return error.AnalysisFail;
3653	3662	}
3654	3663	return;
...	...	@@ -3726,72 +3735,134 @@ pub fn astGenFile(mod: Module, file: File) !void {
3726	3735	file.source = source;
3727	3736	file.source_loaded = true;
3728	3737
3729		file.tree = try std.zig.parse(gpa, source);
3730		defer if (!file.tree_loaded) file.tree.deinit(gpa);
3731
3732		if (file.tree.errors.len != 0) {
3733		const parse_err = file.tree.errors[0];
	3738	// This is purely to detect when the autofix mechanism has a bug and
	3739	// the autofix did not make the compile error go away.
	3740	var reparsing = false;
	3741	parse: while (true) {
	3742	file.tree = try std.zig.parse(gpa, file.source);
	3743	defer if (!file.tree_loaded) file.tree.deinit(gpa);
3734	3744
3735		var msg = std.ArrayList(u8).init(gpa);
3736		defer msg.deinit();
	3745	if (file.tree.errors.len != 0) {
	3746	const parse_err = file.tree.errors[0];
3737	3747
3738		const token_starts = file.tree.tokens.items(.start);
3739		const token_tags = file.tree.tokens.items(.tag);
	3748	var msg = std.ArrayList(u8).init(gpa);
	3749	defer msg.deinit();
3740	3750
3741		const extra_offset = file.tree.errorOffset(parse_err);
3742		try file.tree.renderError(parse_err, msg.writer());
3743		const err_msg = try gpa.create(ErrorMsg);
3744		err_msg.* = .{
3745		.src_loc = .{
3746		.file_scope = file,
3747		.parent_decl_node = 0,
3748		.lazy = if (extra_offset == 0) .{
3749		.token_abs = parse_err.token,
3750		} else .{
3751		.byte_abs = token_starts[parse_err.token] + extra_offset,
3752		},
3753		},
3754		.msg = msg.toOwnedSlice(),
3755		};
3756		if (token_tags[parse_err.token + @boolToInt(parse_err.token_is_prev)] == .invalid) {
3757		const bad_off = @intCast(u32, file.tree.tokenSlice(parse_err.token + @boolToInt(parse_err.token_is_prev)).len);
3758		const byte_abs = token_starts[parse_err.token + @boolToInt(parse_err.token_is_prev)] + bad_off;
3759		try mod.errNoteNonLazy(.{
3760		.file_scope = file,
3761		.parent_decl_node = 0,
3762		.lazy = .{ .byte_abs = byte_abs },
3763		}, err_msg, "invalid byte: '{'}'", .{std.zig.fmtEscapes(source[byte_abs..][0..1])});
3764		}
	3751	const token_starts = file.tree.tokens.items(.start);
	3752	const token_tags = file.tree.tokens.items(.tag);
3765	3753
3766		for (file.tree.errors[1..]) \|note\| {
3767		if (!note.is_note) break;
3768
3769		try file.tree.renderError(note, msg.writer());
3770		err_msg.notes = try mod.gpa.realloc(err_msg.notes, err_msg.notes.len + 1);
3771		err_msg.notes[err_msg.notes.len - 1] = .{
	3754	const extra_offset = file.tree.errorOffset(parse_err);
	3755	try file.tree.renderError(parse_err, msg.writer());
	3756	const err_msg = try gpa.create(ErrorMsg);
	3757	err_msg.* = .{
3772	3758	.src_loc = .{
3773	3759	.file_scope = file,
3774	3760	.parent_decl_node = 0,
3775		.lazy = .{ .token_abs = note.token },
	3761	.lazy = if (extra_offset == 0) .{
	3762	.token_abs = parse_err.token,
	3763	} else .{
	3764	.byte_abs = token_starts[parse_err.token] + extra_offset,
	3765	},
3776	3766	},
3777	3767	.msg = msg.toOwnedSlice(),
3778	3768	};
	3769	if (token_tags[parse_err.token + @boolToInt(parse_err.token_is_prev)] == .invalid) {
	3770	const bad_off = @intCast(u32, file.tree.tokenSlice(parse_err.token + @boolToInt(parse_err.token_is_prev)).len);
	3771	const byte_abs = token_starts[parse_err.token + @boolToInt(parse_err.token_is_prev)] + bad_off;
	3772	try mod.errNoteNonLazy(.{
	3773	.file_scope = file,
	3774	.parent_decl_node = 0,
	3775	.lazy = .{ .byte_abs = byte_abs },
	3776	}, err_msg, "invalid byte: '{'}'", .{std.zig.fmtEscapes(file.source[byte_abs..][0..1])});
	3777	}
	3778
	3779	for (file.tree.errors[1..]) \|note\| {
	3780	if (!note.is_note) break;
	3781
	3782	try file.tree.renderError(note, msg.writer());
	3783	err_msg.notes = try mod.gpa.realloc(err_msg.notes, err_msg.notes.len + 1);
	3784	err_msg.notes[err_msg.notes.len - 1] = .{
	3785	.src_loc = .{
	3786	.file_scope = file,
	3787	.parent_decl_node = 0,
	3788	.lazy = .{ .token_abs = note.token },
	3789	},
	3790	.msg = msg.toOwnedSlice(),
	3791	};
	3792	}
	3793
	3794	{
	3795	comp.mutex.lock();
	3796	defer comp.mutex.unlock();
	3797	try mod.failed_files.putNoClobber(gpa, file, err_msg);
	3798	}
	3799	file.status = .parse_failure;
	3800	return error.AnalysisFail;
3779	3801	}
	3802	file.tree_loaded = true;
3780	3803
3781		{
3782		comp.mutex.lock();
3783		defer comp.mutex.unlock();
3784		try mod.failed_files.putNoClobber(gpa, file, err_msg);
	3804	file.zir = try AstGen.generate(gpa, file.tree);
	3805	file.zir_loaded = true;
	3806	file.status = .success_zir;
	3807	log.debug("AstGen fresh success: {s}", .{file.sub_file_path});
	3808
	3809	if (want_autofix and file.zir.hasCompileErrors()) {
	3810	assert(!reparsing); // there are still compile errors after autofixing
	3811	const payload_index = file.zir.extra[@enumToInt(Zir.ExtraIndex.compile_errors)];
	3812	assert(payload_index != 0);
	3813	const header = file.zir.extraData(Zir.Inst.CompileErrors, payload_index);
	3814	const items_len = header.data.items_len;
	3815	var fixups: Ast.Fixups = .{};
	3816	defer fixups.deinit(gpa);
	3817	var extra_index = header.end;
	3818	var item_i: usize = 0;
	3819	while (item_i < items_len) : (item_i += 1) {
	3820	const item = file.zir.extraData(Zir.Inst.CompileErrors.Item, extra_index);
	3821	extra_index = item.end;
	3822	const msg = file.zir.nullTerminatedString(item.data.msg);
	3823	if (mem.eql(u8, msg, "unused local constant")) {
	3824	// goal: insert "_ = identifier;" after the variable declaration
	3825	const ident_token = item.data.token;
	3826	try fixups.unused_var_decls.put(gpa, ident_token - 1, {});
	3827	} else {
	3828	std.debug.print("found other ZIR error: '{s}'\n", .{msg});
	3829	}
	3830	}
	3831
	3832	if (fixups.count() > 0) {
	3833	var autofixed_source = std.ArrayList(u8).init(gpa);
	3834	defer autofixed_source.deinit();
	3835	try file.tree.renderWithFixups(&autofixed_source, fixups);
	3836
	3837	// Replace the file source with the fixed up source.
	3838	const new_source = try autofixed_source.toOwnedSliceSentinel(0);
	3839	gpa.free(file.source);
	3840	file.source = new_source;
	3841
	3842	// Overwrite the source file on disk with the fixed up source.
	3843	try source_file.pwriteAll(file.source, 0);
	3844
	3845	// If the fixed up source is smaller in bytes then we need to
	3846	// truncate the file.
	3847	if (file.stat.size > file.source.len) {
	3848	try source_file.setEndPos(file.source.len);
	3849	}
	3850
	3851	// Redo the stat so that next time we get a cache hit.
	3852	const new_stat = try source_file.stat();
	3853	file.stat = .{
	3854	.size = new_stat.size,
	3855	.inode = new_stat.inode,
	3856	.mtime = new_stat.mtime,
	3857	};
	3858
	3859	reparsing = true;
	3860	continue :parse;
	3861	}
3785	3862	}
3786		file.status = .parse_failure;
3787		return error.AnalysisFail;
3788		}
3789		file.tree_loaded = true;
3790	3863
3791		file.zir = try AstGen.generate(gpa, file.tree);
3792		file.zir_loaded = true;
3793		file.status = .success_zir;
3794		log.debug("AstGen fresh success: {s}", .{file.sub_file_path});
	3864	break :parse;
	3865	}
3795	3866
3796	3867	const safety_buffer = if (data_has_safety_tag)
3797	3868	try gpa.alloc([8]u8, file.zir.instructions.len)

src/main.zig+5

...	...	@@ -403,6 +403,7 @@ const usage_build_generic =
403	403	\\ -ffunction-sections Places each function in a separate section
404	404	\\ -fno-function-sections All functions go into same section
405	405	\\ --strip Omit debug symbols
	406	\\ --autofix Avoid some errors by allowing Zig to edit your code
406	407	\\ -ofmt=[mode] Override target object format
407	408	\\ elf Executable and Linking Format
408	409	\\ c C source code
...	...	@@ -629,6 +630,7 @@ fn buildOutputType(
629	630	var have_version = false;
630	631	var compatibility_version: ?std.builtin.Version = null;
631	632	var strip = false;
	633	var autofix = false;
632	634	var function_sections = false;
633	635	var no_builtin = false;
634	636	var watch = false;
...	...	@@ -1286,6 +1288,8 @@ fn buildOutputType(
1286	1288	emit_bin = .no;
1287	1289	} else if (mem.eql(u8, arg, "--strip")) {
1288	1290	strip = true;
	1291	} else if (mem.eql(u8, arg, "--autofix")) {
	1292	autofix = true;
1289	1293	} else if (mem.eql(u8, arg, "-fsingle-threaded")) {
1290	1294	single_threaded = true;
1291	1295	} else if (mem.eql(u8, arg, "-fno-single-threaded")) {
...	...	@@ -2944,6 +2948,7 @@ fn buildOutputType(
2944	2948	.stack_size_override = stack_size_override,
2945	2949	.image_base_override = image_base_override,
2946	2950	.strip = strip,
	2951	.autofix = autofix,
2947	2952	.single_threaded = single_threaded,
2948	2953	.function_sections = function_sections,
2949	2954	.no_builtin = no_builtin,