authorgravatar for lachlan@lakebythewoods.xyzLachlan Easton <lachlan@lakebythewoods.xyz> 2020-09-02 20:16:28+10:00
committergravatar for lachlan@lakebythewoods.xyzLachlan Easton <lachlan@lakebythewoods.xyz> 2020-09-02 20:16:28+10:00
logbb848dbeeec133b2ca1d6dc42fe9dd04b848b58a
treee1881f719b2c7fff7d09e9c867398fbdf6ed84bd
parent7841c9b7d105a62ccb55f4f6589d5ff31194a013

zig fmt: Patch rename stream to ais (auto indenting stream) & other small refactors

8 files changed, 653 insertions(+), 668 deletions(-)

lib/std/io/auto_indenting_stream.zig+11-13
......@@ -5,13 +5,13 @@ const assert = std.debug.assert;
55
66/// Automatically inserts indentation of written data by keeping
77/// track of the current indentation level
8pub fn AutoIndentingStream(comptime WriterType: type) type {
8pub fn AutoIndentingStream(comptime UnderlyingWriter: type) type {
99 return struct {
1010 const Self = @This();
11 pub const Error = WriterType.Error;
11 pub const Error = UnderlyingWriter.Error;
1212 pub const Writer = io.Writer(*Self, Error, write);
1313
14 writer_pointer: *WriterType,
14 underlying_writer: UnderlyingWriter,
1515
1616 indent_count: usize = 0,
1717 indent_delta: usize,
......@@ -20,10 +20,6 @@ pub fn AutoIndentingStream(comptime WriterType: type) type {
2020 applied_indent: usize = 0, // the most recently applied indent
2121 indent_next_line: usize = 0, // not used until the next line
2222
23 pub fn init(indent_delta: usize, writer_pointer: *WriterType) Self {
24 return Self{ .writer_pointer = writer_pointer, .indent_delta = indent_delta };
25 }
26
2723 pub fn writer(self: *Self) Writer {
2824 return .{ .context = self };
2925 }
......@@ -55,7 +51,7 @@ pub fn AutoIndentingStream(comptime WriterType: type) type {
5551 if (bytes.len == 0)
5652 return @as(usize, 0);
5753
58 try self.writer_pointer.writer().writeAll(bytes);
54 try self.underlying_writer.writeAll(bytes);
5955 if (bytes[bytes.len - 1] == '\n')
6056 self.resetLine();
6157 return bytes.len;
......@@ -115,7 +111,7 @@ pub fn AutoIndentingStream(comptime WriterType: type) type {
115111 fn applyIndent(self: *Self) Error!void {
116112 const current_indent = self.currentIndent();
117113 if (self.current_line_empty and current_indent > 0) {
118 try self.writer_pointer.writer().writeByteNTimes(' ', current_indent);
114 try self.underlying_writer.writeByteNTimes(' ', current_indent);
119115 self.applied_indent = current_indent;
120116 }
121117
......@@ -143,8 +139,10 @@ pub fn AutoIndentingStream(comptime WriterType: type) type {
143139
144140pub fn autoIndentingStream(
145141 indent_delta: usize,
146 underlying_stream: anytype,
147) AutoIndentingStream(@TypeOf(underlying_stream).Child) {
148 comptime assert(@typeInfo(@TypeOf(underlying_stream)) == .Pointer);
149 return AutoIndentingStream(@TypeOf(underlying_stream).Child).init(indent_delta, underlying_stream);
142 underlying_writer: anytype,
143) AutoIndentingStream(@TypeOf(underlying_writer)) {
144 return AutoIndentingStream(@TypeOf(underlying_writer)){
145 .underlying_writer = underlying_writer,
146 .indent_delta = indent_delta,
147 };
150148}
lib/std/io/change_detection_stream.zig+11-15
......@@ -10,19 +10,11 @@ pub fn ChangeDetectionStream(comptime WriterType: type) type {
1010 pub const Error = WriterType.Error;
1111 pub const Writer = io.Writer(*Self, Error, write);
1212
13 anything_changed: bool = false,
14 writer_pointer: *const WriterType,
13 anything_changed: bool,
14 underlying_writer: WriterType,
1515 source_index: usize,
1616 source: []const u8,
1717
18 pub fn init(source: []const u8, writer_pointer: *const WriterType) Self {
19 return Self{
20 .writer_pointer = writer_pointer,
21 .source_index = 0,
22 .source = source,
23 };
24 }
25
2618 pub fn writer(self: *Self) Writer {
2719 return .{ .context = self };
2820 }
......@@ -41,7 +33,7 @@ pub fn ChangeDetectionStream(comptime WriterType: type) type {
4133 }
4234 }
4335
44 return self.writer_pointer.write(bytes);
36 return self.underlying_writer.write(bytes);
4537 }
4638
4739 pub fn changeDetected(self: *Self) bool {
......@@ -52,8 +44,12 @@ pub fn ChangeDetectionStream(comptime WriterType: type) type {
5244
5345pub fn changeDetectionStream(
5446 source: []const u8,
55 underlying_stream: anytype,
56) ChangeDetectionStream(@TypeOf(underlying_stream).Child) {
57 comptime assert(@typeInfo(@TypeOf(underlying_stream)) == .Pointer);
58 return ChangeDetectionStream(@TypeOf(underlying_stream).Child).init(source, underlying_stream);
47 underlying_writer: anytype,
48) ChangeDetectionStream(@TypeOf(underlying_writer)) {
49 return ChangeDetectionStream(@TypeOf(underlying_writer)){
50 .anything_changed = false,
51 .underlying_writer = underlying_writer,
52 .source_index = 0,
53 .source = source,
54 };
5955}
lib/std/io/find_byte_out_stream.zig+11-15
......@@ -4,24 +4,16 @@ const assert = std.debug.assert;
44
55/// An OutStream that returns whether the given character has been written to it.
66/// The contents are not written to anything.
7pub fn FindByteOutStream(comptime WriterType: type) type {
7pub fn FindByteOutStream(comptime UnderlyingWriter: type) type {
88 return struct {
99 const Self = @This();
10 pub const Error = WriterType.Error;
10 pub const Error = UnderlyingWriter.Error;
1111 pub const Writer = io.Writer(*Self, Error, write);
1212
13 writer_pointer: *const WriterType,
13 underlying_writer: UnderlyingWriter,
1414 byte_found: bool,
1515 byte: u8,
1616
17 pub fn init(byte: u8, writer_pointer: *const WriterType) Self {
18 return Self{
19 .writer_pointer = writer_pointer,
20 .byte = byte,
21 .byte_found = false,
22 };
23 }
24
2517 pub fn writer(self: *Self) Writer {
2618 return .{ .context = self };
2719 }
......@@ -34,11 +26,15 @@ pub fn FindByteOutStream(comptime WriterType: type) type {
3426 break :blk false;
3527 };
3628 }
37 return self.writer_pointer.writer().write(bytes);
29 return self.underlying_writer.write(bytes);
3830 }
3931 };
4032}
41pub fn findByteOutStream(byte: u8, underlying_stream: anytype) FindByteOutStream(@TypeOf(underlying_stream).Child) {
42 comptime assert(@typeInfo(@TypeOf(underlying_stream)) == .Pointer);
43 return FindByteOutStream(@TypeOf(underlying_stream).Child).init(byte, underlying_stream);
33
34pub fn findByteOutStream(byte: u8, underlying_writer: anytype) FindByteOutStream(@TypeOf(underlying_writer)) {
35 return FindByteOutStream(@TypeOf(underlying_writer)){
36 .underlying_writer = underlying_writer,
37 .byte = byte,
38 .byte_found = false,
39 };
4440}
lib/std/io/writer.zig-4
......@@ -18,10 +18,6 @@ pub fn Writer(
1818 const Self = @This();
1919 pub const Error = WriteError;
2020
21 pub fn writer(self: *const Self) Self {
22 return self.*;
23 }
24
2521 pub fn write(self: Self, bytes: []const u8) Error!usize {
2622 return writeFn(self.context, bytes);
2723 }
lib/std/zig/parser_test.zig+1-1
......@@ -3364,7 +3364,7 @@ fn testParse(source: []const u8, allocator: *mem.Allocator, anything_changed: *b
33643364 errdefer buffer.deinit();
33653365
33663366 const outStream = buffer.outStream();
3367 anything_changed.* = try std.zig.render(allocator, &outStream, tree);
3367 anything_changed.* = try std.zig.render(allocator, outStream, tree);
33683368 return buffer.toOwnedSlice();
33693369}
33703370fn testTransform(source: []const u8, expected_source: []const u8) !void {
lib/std/zig/render.zig+614-615
......@@ -19,13 +19,12 @@ pub const Error = error{
1919};
2020
2121/// Returns whether anything changed
22pub fn render(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree) (meta.Child(@TypeOf(stream)).Error || Error)!bool {
22pub fn render(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree) (@TypeOf(stream).Error || Error)!bool {
2323 // cannot render an invalid tree
2424 std.debug.assert(tree.errors.len == 0);
2525
26 var s = stream.*;
27 var change_detection_stream = std.io.changeDetectionStream(tree.source, &s);
28 var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, &change_detection_stream);
26 var change_detection_stream = std.io.changeDetectionStream(tree.source, stream);
27 var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, change_detection_stream.writer());
2928
3029 try renderRoot(allocator, &auto_indenting_stream, tree);
3130
......@@ -34,19 +33,19 @@ pub fn render(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree) (meta
3433
3534fn renderRoot(
3635 allocator: *mem.Allocator,
37 stream: anytype,
36 ais: anytype,
3837 tree: *ast.Tree,
39) (@TypeOf(stream.*).Error || Error)!void {
38) (@TypeOf(ais.*).Error || Error)!void {
4039
4140 // render all the line comments at the beginning of the file
4241 for (tree.token_ids) |token_id, i| {
4342 if (token_id != .LineComment) break;
4443 const token_loc = tree.token_locs[i];
45 try stream.writer().print("{}\n", .{mem.trimRight(u8, tree.tokenSliceLoc(token_loc), " ")});
44 try ais.writer().print("{}\n", .{mem.trimRight(u8, tree.tokenSliceLoc(token_loc), " ")});
4645 const next_token = tree.token_locs[i + 1];
4746 const loc = tree.tokenLocationLoc(token_loc.end, next_token);
4847 if (loc.line >= 2) {
49 try stream.insertNewline();
48 try ais.insertNewline();
5049 }
5150 }
5251
......@@ -110,7 +109,7 @@ fn renderRoot(
110109 // If there's no next reformatted `decl`, just copy the
111110 // remaining input tokens and bail out.
112111 const start = tree.token_locs[copy_start_token_index].start;
113 try copyFixingWhitespace(stream, tree.source[start..]);
112 try copyFixingWhitespace(ais, tree.source[start..]);
114113 return;
115114 }
116115 decl = root_decls[decl_i];
......@@ -151,25 +150,25 @@ fn renderRoot(
151150
152151 const start = tree.token_locs[copy_start_token_index].start;
153152 const end = tree.token_locs[copy_end_token_index].start;
154 try copyFixingWhitespace(stream, tree.source[start..end]);
153 try copyFixingWhitespace(ais, tree.source[start..end]);
155154 }
156155
157 try renderTopLevelDecl(allocator, stream, tree, decl);
156 try renderTopLevelDecl(allocator, ais, tree, decl);
158157 decl_i += 1;
159158 if (decl_i >= root_decls.len) return;
160 try renderExtraNewline(tree, stream, root_decls[decl_i]);
159 try renderExtraNewline(tree, ais, root_decls[decl_i]);
161160 }
162161}
163162
164fn renderExtraNewline(tree: *ast.Tree, stream: anytype, node: *ast.Node) @TypeOf(stream.*).Error!void {
165 return renderExtraNewlineToken(tree, stream, node.firstToken());
163fn renderExtraNewline(tree: *ast.Tree, ais: anytype, node: *ast.Node) @TypeOf(ais.*).Error!void {
164 return renderExtraNewlineToken(tree, ais, node.firstToken());
166165}
167166
168167fn renderExtraNewlineToken(
169168 tree: *ast.Tree,
170 stream: anytype,
169 ais: anytype,
171170 first_token: ast.TokenIndex,
172) @TypeOf(stream.*).Error!void {
171) @TypeOf(ais.*).Error!void {
173172 var prev_token = first_token;
174173 if (prev_token == 0) return;
175174 var newline_threshold: usize = 2;
......@@ -182,27 +181,27 @@ fn renderExtraNewlineToken(
182181 const prev_token_end = tree.token_locs[prev_token - 1].end;
183182 const loc = tree.tokenLocation(prev_token_end, first_token);
184183 if (loc.line >= newline_threshold) {
185 try stream.insertNewline();
184 try ais.insertNewline();
186185 }
187186}
188187
189fn renderTopLevelDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree, decl: *ast.Node) (@TypeOf(stream.*).Error || Error)!void {
190 try renderContainerDecl(allocator, stream, tree, decl, .Newline);
188fn renderTopLevelDecl(allocator: *mem.Allocator, ais: anytype, tree: *ast.Tree, decl: *ast.Node) (@TypeOf(ais.*).Error || Error)!void {
189 try renderContainerDecl(allocator, ais, tree, decl, .Newline);
191190}
192191
193fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree, decl: *ast.Node, space: Space) (@TypeOf(stream.*).Error || Error)!void {
192fn renderContainerDecl(allocator: *mem.Allocator, ais: anytype, tree: *ast.Tree, decl: *ast.Node, space: Space) (@TypeOf(ais.*).Error || Error)!void {
194193 switch (decl.tag) {
195194 .FnProto => {
196195 const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
197196
198 try renderDocComments(tree, stream, fn_proto, fn_proto.getDocComments());
197 try renderDocComments(tree, ais, fn_proto, fn_proto.getDocComments());
199198
200199 if (fn_proto.getBodyNode()) |body_node| {
201 try renderExpression(allocator, stream, tree, decl, .Space);
202 try renderExpression(allocator, stream, tree, body_node, space);
200 try renderExpression(allocator, ais, tree, decl, .Space);
201 try renderExpression(allocator, ais, tree, body_node, space);
203202 } else {
204 try renderExpression(allocator, stream, tree, decl, .None);
205 try renderToken(tree, stream, tree.nextToken(decl.lastToken()), space);
203 try renderExpression(allocator, ais, tree, decl, .None);
204 try renderToken(tree, ais, tree.nextToken(decl.lastToken()), space);
206205 }
207206 },
208207
......@@ -210,35 +209,35 @@ fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tr
210209 const use_decl = @fieldParentPtr(ast.Node.Use, "base", decl);
211210
212211 if (use_decl.visib_token) |visib_token| {
213 try renderToken(tree, stream, visib_token, .Space); // pub
212 try renderToken(tree, ais, visib_token, .Space); // pub
214213 }
215 try renderToken(tree, stream, use_decl.use_token, .Space); // usingnamespace
216 try renderExpression(allocator, stream, tree, use_decl.expr, .None);
217 try renderToken(tree, stream, use_decl.semicolon_token, space); // ;
214 try renderToken(tree, ais, use_decl.use_token, .Space); // usingnamespace
215 try renderExpression(allocator, ais, tree, use_decl.expr, .None);
216 try renderToken(tree, ais, use_decl.semicolon_token, space); // ;
218217 },
219218
220219 .VarDecl => {
221220 const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", decl);
222221
223 try renderDocComments(tree, stream, var_decl, var_decl.getDocComments());
224 try renderVarDecl(allocator, stream, tree, var_decl);
222 try renderDocComments(tree, ais, var_decl, var_decl.getDocComments());
223 try renderVarDecl(allocator, ais, tree, var_decl);
225224 },
226225
227226 .TestDecl => {
228227 const test_decl = @fieldParentPtr(ast.Node.TestDecl, "base", decl);
229228
230 try renderDocComments(tree, stream, test_decl, test_decl.doc_comments);
231 try renderToken(tree, stream, test_decl.test_token, .Space);
232 try renderExpression(allocator, stream, tree, test_decl.name, .Space);
233 try renderExpression(allocator, stream, tree, test_decl.body_node, space);
229 try renderDocComments(tree, ais, test_decl, test_decl.doc_comments);
230 try renderToken(tree, ais, test_decl.test_token, .Space);
231 try renderExpression(allocator, ais, tree, test_decl.name, .Space);
232 try renderExpression(allocator, ais, tree, test_decl.body_node, space);
234233 },
235234
236235 .ContainerField => {
237236 const field = @fieldParentPtr(ast.Node.ContainerField, "base", decl);
238237
239 try renderDocComments(tree, stream, field, field.doc_comments);
238 try renderDocComments(tree, ais, field, field.doc_comments);
240239 if (field.comptime_token) |t| {
241 try renderToken(tree, stream, t, .Space); // comptime
240 try renderToken(tree, ais, t, .Space); // comptime
242241 }
243242
244243 const src_has_trailing_comma = blk: {
......@@ -251,67 +250,67 @@ fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tr
251250 const last_token_space: Space = if (src_has_trailing_comma) .None else space;
252251
253252 if (field.type_expr == null and field.value_expr == null) {
254 try renderToken(tree, stream, field.name_token, last_token_space); // name
253 try renderToken(tree, ais, field.name_token, last_token_space); // name
255254 } else if (field.type_expr != null and field.value_expr == null) {
256 try renderToken(tree, stream, field.name_token, .None); // name
257 try renderToken(tree, stream, tree.nextToken(field.name_token), .Space); // :
255 try renderToken(tree, ais, field.name_token, .None); // name
256 try renderToken(tree, ais, tree.nextToken(field.name_token), .Space); // :
258257
259258 if (field.align_expr) |align_value_expr| {
260 try renderExpression(allocator, stream, tree, field.type_expr.?, .Space); // type
259 try renderExpression(allocator, ais, tree, field.type_expr.?, .Space); // type
261260 const lparen_token = tree.prevToken(align_value_expr.firstToken());
262261 const align_kw = tree.prevToken(lparen_token);
263262 const rparen_token = tree.nextToken(align_value_expr.lastToken());
264 try renderToken(tree, stream, align_kw, .None); // align
265 try renderToken(tree, stream, lparen_token, .None); // (
266 try renderExpression(allocator, stream, tree, align_value_expr, .None); // alignment
267 try renderToken(tree, stream, rparen_token, last_token_space); // )
263 try renderToken(tree, ais, align_kw, .None); // align
264 try renderToken(tree, ais, lparen_token, .None); // (
265 try renderExpression(allocator, ais, tree, align_value_expr, .None); // alignment
266 try renderToken(tree, ais, rparen_token, last_token_space); // )
268267 } else {
269 try renderExpression(allocator, stream, tree, field.type_expr.?, last_token_space); // type
268 try renderExpression(allocator, ais, tree, field.type_expr.?, last_token_space); // type
270269 }
271270 } else if (field.type_expr == null and field.value_expr != null) {
272 try renderToken(tree, stream, field.name_token, .Space); // name
273 try renderToken(tree, stream, tree.nextToken(field.name_token), .Space); // =
274 try renderExpression(allocator, stream, tree, field.value_expr.?, last_token_space); // value
271 try renderToken(tree, ais, field.name_token, .Space); // name
272 try renderToken(tree, ais, tree.nextToken(field.name_token), .Space); // =
273 try renderExpression(allocator, ais, tree, field.value_expr.?, last_token_space); // value
275274 } else {
276 try renderToken(tree, stream, field.name_token, .None); // name
277 try renderToken(tree, stream, tree.nextToken(field.name_token), .Space); // :
275 try renderToken(tree, ais, field.name_token, .None); // name
276 try renderToken(tree, ais, tree.nextToken(field.name_token), .Space); // :
278277
279278 if (field.align_expr) |align_value_expr| {
280 try renderExpression(allocator, stream, tree, field.type_expr.?, .Space); // type
279 try renderExpression(allocator, ais, tree, field.type_expr.?, .Space); // type
281280 const lparen_token = tree.prevToken(align_value_expr.firstToken());
282281 const align_kw = tree.prevToken(lparen_token);
283282 const rparen_token = tree.nextToken(align_value_expr.lastToken());
284 try renderToken(tree, stream, align_kw, .None); // align
285 try renderToken(tree, stream, lparen_token, .None); // (
286 try renderExpression(allocator, stream, tree, align_value_expr, .None); // alignment
287 try renderToken(tree, stream, rparen_token, .Space); // )
283 try renderToken(tree, ais, align_kw, .None); // align
284 try renderToken(tree, ais, lparen_token, .None); // (
285 try renderExpression(allocator, ais, tree, align_value_expr, .None); // alignment
286 try renderToken(tree, ais, rparen_token, .Space); // )
288287 } else {
289 try renderExpression(allocator, stream, tree, field.type_expr.?, .Space); // type
288 try renderExpression(allocator, ais, tree, field.type_expr.?, .Space); // type
290289 }
291 try renderToken(tree, stream, tree.prevToken(field.value_expr.?.firstToken()), .Space); // =
292 try renderExpression(allocator, stream, tree, field.value_expr.?, last_token_space); // value
290 try renderToken(tree, ais, tree.prevToken(field.value_expr.?.firstToken()), .Space); // =
291 try renderExpression(allocator, ais, tree, field.value_expr.?, last_token_space); // value
293292 }
294293
295294 if (src_has_trailing_comma) {
296295 const comma = tree.nextToken(field.lastToken());
297 try renderToken(tree, stream, comma, space);
296 try renderToken(tree, ais, comma, space);
298297 }
299298 },
300299
301300 .Comptime => {
302301 assert(!decl.requireSemiColon());
303 try renderExpression(allocator, stream, tree, decl, space);
302 try renderExpression(allocator, ais, tree, decl, space);
304303 },
305304
306305 .DocComment => {
307306 const comment = @fieldParentPtr(ast.Node.DocComment, "base", decl);
308307 const kind = tree.token_ids[comment.first_line];
309 try renderToken(tree, stream, comment.first_line, .Newline);
308 try renderToken(tree, ais, comment.first_line, .Newline);
310309 var tok_i = comment.first_line + 1;
311310 while (true) : (tok_i += 1) {
312311 const tok_id = tree.token_ids[tok_i];
313312 if (tok_id == kind) {
314 try renderToken(tree, stream, tok_i, .Newline);
313 try renderToken(tree, ais, tok_i, .Newline);
315314 } else if (tok_id == .LineComment) {
316315 continue;
317316 } else {
......@@ -325,11 +324,11 @@ fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tr
325324
326325fn renderExpression(
327326 allocator: *mem.Allocator,
328 stream: anytype,
327 ais: anytype,
329328 tree: *ast.Tree,
330329 base: *ast.Node,
331330 space: Space,
332) (@TypeOf(stream.*).Error || Error)!void {
331) (@TypeOf(ais.*).Error || Error)!void {
333332 switch (base.tag) {
334333 .Identifier,
335334 .IntegerLiteral,
......@@ -343,18 +342,18 @@ fn renderExpression(
343342 .UndefinedLiteral,
344343 => {
345344 const casted_node = base.cast(ast.Node.OneToken).?;
346 return renderToken(tree, stream, casted_node.token, space);
345 return renderToken(tree, ais, casted_node.token, space);
347346 },
348347
349348 .AnyType => {
350349 const any_type = base.castTag(.AnyType).?;
351350 if (mem.eql(u8, tree.tokenSlice(any_type.token), "var")) {
352351 // TODO remove in next release cycle
353 try stream.writer().writeAll("anytype");
354 if (space == .Comma) try stream.writer().writeAll(",\n");
352 try ais.writer().writeAll("anytype");
353 if (space == .Comma) try ais.writer().writeAll(",\n");
355354 return;
356355 }
357 return renderToken(tree, stream, any_type.token, space);
356 return renderToken(tree, ais, any_type.token, space);
358357 },
359358
360359 .Block, .LabeledBlock => {
......@@ -384,65 +383,65 @@ fn renderExpression(
384383 };
385384
386385 if (block.label) |label| {
387 try renderToken(tree, stream, label, Space.None);
388 try renderToken(tree, stream, tree.nextToken(label), Space.Space);
386 try renderToken(tree, ais, label, Space.None);
387 try renderToken(tree, ais, tree.nextToken(label), Space.Space);
389388 }
390389
391390 if (block.statements.len == 0) {
392 stream.pushIndentNextLine();
393 defer stream.popIndent();
394 try renderToken(tree, stream, block.lbrace, Space.None);
391 ais.pushIndentNextLine();
392 defer ais.popIndent();
393 try renderToken(tree, ais, block.lbrace, Space.None);
395394 } else {
396 stream.pushIndentNextLine();
397 defer stream.popIndent();
395 ais.pushIndentNextLine();
396 defer ais.popIndent();
398397
399 try renderToken(tree, stream, block.lbrace, Space.Newline);
398 try renderToken(tree, ais, block.lbrace, Space.Newline);
400399
401400 for (block.statements) |statement, i| {
402 try renderStatement(allocator, stream, tree, statement);
401 try renderStatement(allocator, ais, tree, statement);
403402
404403 if (i + 1 < block.statements.len) {
405 try renderExtraNewline(tree, stream, block.statements[i + 1]);
404 try renderExtraNewline(tree, ais, block.statements[i + 1]);
406405 }
407406 }
408407 }
409 return renderToken(tree, stream, block.rbrace, space);
408 return renderToken(tree, ais, block.rbrace, space);
410409 },
411410
412411 .Defer => {
413412 const defer_node = @fieldParentPtr(ast.Node.Defer, "base", base);
414413
415 try renderToken(tree, stream, defer_node.defer_token, Space.Space);
414 try renderToken(tree, ais, defer_node.defer_token, Space.Space);
416415 if (defer_node.payload) |payload| {
417 try renderExpression(allocator, stream, tree, payload, Space.Space);
416 try renderExpression(allocator, ais, tree, payload, Space.Space);
418417 }
419 return renderExpression(allocator, stream, tree, defer_node.expr, space);
418 return renderExpression(allocator, ais, tree, defer_node.expr, space);
420419 },
421420 .Comptime => {
422421 const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", base);
423422
424 try renderToken(tree, stream, comptime_node.comptime_token, Space.Space);
425 return renderExpression(allocator, stream, tree, comptime_node.expr, space);
423 try renderToken(tree, ais, comptime_node.comptime_token, Space.Space);
424 return renderExpression(allocator, ais, tree, comptime_node.expr, space);
426425 },
427426 .Nosuspend => {
428427 const nosuspend_node = @fieldParentPtr(ast.Node.Nosuspend, "base", base);
429428 if (mem.eql(u8, tree.tokenSlice(nosuspend_node.nosuspend_token), "noasync")) {
430429 // TODO: remove this
431 try stream.writer().writeAll("nosuspend ");
430 try ais.writer().writeAll("nosuspend ");
432431 } else {
433 try renderToken(tree, stream, nosuspend_node.nosuspend_token, Space.Space);
432 try renderToken(tree, ais, nosuspend_node.nosuspend_token, Space.Space);
434433 }
435 return renderExpression(allocator, stream, tree, nosuspend_node.expr, space);
434 return renderExpression(allocator, ais, tree, nosuspend_node.expr, space);
436435 },
437436
438437 .Suspend => {
439438 const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", base);
440439
441440 if (suspend_node.body) |body| {
442 try renderToken(tree, stream, suspend_node.suspend_token, Space.Space);
443 return renderExpression(allocator, stream, tree, body, space);
441 try renderToken(tree, ais, suspend_node.suspend_token, Space.Space);
442 return renderExpression(allocator, ais, tree, body, space);
444443 } else {
445 return renderToken(tree, stream, suspend_node.suspend_token, space);
444 return renderToken(tree, ais, suspend_node.suspend_token, space);
446445 }
447446 },
448447
......@@ -450,21 +449,21 @@ fn renderExpression(
450449 const infix_op_node = @fieldParentPtr(ast.Node.Catch, "base", base);
451450
452451 const op_space = Space.Space;
453 try renderExpression(allocator, stream, tree, infix_op_node.lhs, op_space);
452 try renderExpression(allocator, ais, tree, infix_op_node.lhs, op_space);
454453
455454 const after_op_space = blk: {
456455 const same_line = tree.tokensOnSameLine(infix_op_node.op_token, tree.nextToken(infix_op_node.op_token));
457456 break :blk if (same_line) op_space else Space.Newline;
458457 };
459458
460 try renderToken(tree, stream, infix_op_node.op_token, after_op_space);
459 try renderToken(tree, ais, infix_op_node.op_token, after_op_space);
461460
462461 if (infix_op_node.payload) |payload| {
463 try renderExpression(allocator, stream, tree, payload, Space.Space);
462 try renderExpression(allocator, ais, tree, payload, Space.Space);
464463 }
465464
466 stream.pushIndentOneShot();
467 return renderExpression(allocator, stream, tree, infix_op_node.rhs, space);
465 ais.pushIndentOneShot();
466 return renderExpression(allocator, ais, tree, infix_op_node.rhs, space);
468467 },
469468
470469 .Add,
......@@ -516,16 +515,16 @@ fn renderExpression(
516515 .Period, .ErrorUnion, .Range => Space.None,
517516 else => Space.Space,
518517 };
519 try renderExpression(allocator, stream, tree, infix_op_node.lhs, op_space);
518 try renderExpression(allocator, ais, tree, infix_op_node.lhs, op_space);
520519
521520 const after_op_space = blk: {
522521 const loc = tree.tokenLocation(tree.token_locs[infix_op_node.op_token].end, tree.nextToken(infix_op_node.op_token));
523522 break :blk if (loc.line == 0) op_space else Space.Newline;
524523 };
525524
526 try renderToken(tree, stream, infix_op_node.op_token, after_op_space);
527 stream.pushIndentOneShot();
528 return renderExpression(allocator, stream, tree, infix_op_node.rhs, space);
525 try renderToken(tree, ais, infix_op_node.op_token, after_op_space);
526 ais.pushIndentOneShot();
527 return renderExpression(allocator, ais, tree, infix_op_node.rhs, space);
529528 },
530529
531530 .BitNot,
......@@ -536,8 +535,8 @@ fn renderExpression(
536535 .AddressOf,
537536 => {
538537 const casted_node = @fieldParentPtr(ast.Node.SimplePrefixOp, "base", base);
539 try renderToken(tree, stream, casted_node.op_token, Space.None);
540 return renderExpression(allocator, stream, tree, casted_node.rhs, space);
538 try renderToken(tree, ais, casted_node.op_token, Space.None);
539 return renderExpression(allocator, ais, tree, casted_node.rhs, space);
541540 },
542541
543542 .Try,
......@@ -545,15 +544,15 @@ fn renderExpression(
545544 .Await,
546545 => {
547546 const casted_node = @fieldParentPtr(ast.Node.SimplePrefixOp, "base", base);
548 try renderToken(tree, stream, casted_node.op_token, Space.Space);
549 return renderExpression(allocator, stream, tree, casted_node.rhs, space);
547 try renderToken(tree, ais, casted_node.op_token, Space.Space);
548 return renderExpression(allocator, ais, tree, casted_node.rhs, space);
550549 },
551550
552551 .ArrayType => {
553552 const array_type = @fieldParentPtr(ast.Node.ArrayType, "base", base);
554553 return renderArrayType(
555554 allocator,
556 stream,
555 ais,
557556 tree,
558557 array_type.op_token,
559558 array_type.rhs,
......@@ -566,7 +565,7 @@ fn renderExpression(
566565 const array_type = @fieldParentPtr(ast.Node.ArrayTypeSentinel, "base", base);
567566 return renderArrayType(
568567 allocator,
569 stream,
568 ais,
570569 tree,
571570 array_type.op_token,
572571 array_type.rhs,
......@@ -580,111 +579,111 @@ fn renderExpression(
580579 const ptr_type = @fieldParentPtr(ast.Node.PtrType, "base", base);
581580 const op_tok_id = tree.token_ids[ptr_type.op_token];
582581 switch (op_tok_id) {
583 .Asterisk, .AsteriskAsterisk => try stream.writer().writeByte('*'),
582 .Asterisk, .AsteriskAsterisk => try ais.writer().writeByte('*'),
584583 .LBracket => if (tree.token_ids[ptr_type.op_token + 2] == .Identifier)
585 try stream.writer().writeAll("[*c")
584 try ais.writer().writeAll("[*c")
586585 else
587 try stream.writer().writeAll("[*"),
586 try ais.writer().writeAll("[*"),
588587 else => unreachable,
589588 }
590589 if (ptr_type.ptr_info.sentinel) |sentinel| {
591590 const colon_token = tree.prevToken(sentinel.firstToken());
592 try renderToken(tree, stream, colon_token, Space.None); // :
591 try renderToken(tree, ais, colon_token, Space.None); // :
593592 const sentinel_space = switch (op_tok_id) {
594593 .LBracket => Space.None,
595594 else => Space.Space,
596595 };
597 try renderExpression(allocator, stream, tree, sentinel, sentinel_space);
596 try renderExpression(allocator, ais, tree, sentinel, sentinel_space);
598597 }
599598 switch (op_tok_id) {
600599 .Asterisk, .AsteriskAsterisk => {},
601 .LBracket => try stream.writer().writeByte(']'),
600 .LBracket => try ais.writer().writeByte(']'),
602601 else => unreachable,
603602 }
604603 if (ptr_type.ptr_info.allowzero_token) |allowzero_token| {
605 try renderToken(tree, stream, allowzero_token, Space.Space); // allowzero
604 try renderToken(tree, ais, allowzero_token, Space.Space); // allowzero
606605 }
607606 if (ptr_type.ptr_info.align_info) |align_info| {
608607 const lparen_token = tree.prevToken(align_info.node.firstToken());
609608 const align_token = tree.prevToken(lparen_token);
610609
611 try renderToken(tree, stream, align_token, Space.None); // align
612 try renderToken(tree, stream, lparen_token, Space.None); // (
610 try renderToken(tree, ais, align_token, Space.None); // align
611 try renderToken(tree, ais, lparen_token, Space.None); // (
613612
614 try renderExpression(allocator, stream, tree, align_info.node, Space.None);
613 try renderExpression(allocator, ais, tree, align_info.node, Space.None);
615614
616615 if (align_info.bit_range) |bit_range| {
617616 const colon1 = tree.prevToken(bit_range.start.firstToken());
618617 const colon2 = tree.prevToken(bit_range.end.firstToken());
619618
620 try renderToken(tree, stream, colon1, Space.None); // :
621 try renderExpression(allocator, stream, tree, bit_range.start, Space.None);
622 try renderToken(tree, stream, colon2, Space.None); // :
623 try renderExpression(allocator, stream, tree, bit_range.end, Space.None);
619 try renderToken(tree, ais, colon1, Space.None); // :
620 try renderExpression(allocator, ais, tree, bit_range.start, Space.None);
621 try renderToken(tree, ais, colon2, Space.None); // :
622 try renderExpression(allocator, ais, tree, bit_range.end, Space.None);
624623
625624 const rparen_token = tree.nextToken(bit_range.end.lastToken());
626 try renderToken(tree, stream, rparen_token, Space.Space); // )
625 try renderToken(tree, ais, rparen_token, Space.Space); // )
627626 } else {
628627 const rparen_token = tree.nextToken(align_info.node.lastToken());
629 try renderToken(tree, stream, rparen_token, Space.Space); // )
628 try renderToken(tree, ais, rparen_token, Space.Space); // )
630629 }
631630 }
632631 if (ptr_type.ptr_info.const_token) |const_token| {
633 try renderToken(tree, stream, const_token, Space.Space); // const
632 try renderToken(tree, ais, const_token, Space.Space); // const
634633 }
635634 if (ptr_type.ptr_info.volatile_token) |volatile_token| {
636 try renderToken(tree, stream, volatile_token, Space.Space); // volatile
635 try renderToken(tree, ais, volatile_token, Space.Space); // volatile
637636 }
638 return renderExpression(allocator, stream, tree, ptr_type.rhs, space);
637 return renderExpression(allocator, ais, tree, ptr_type.rhs, space);
639638 },
640639
641640 .SliceType => {
642641 const slice_type = @fieldParentPtr(ast.Node.SliceType, "base", base);
643 try renderToken(tree, stream, slice_type.op_token, Space.None); // [
642 try renderToken(tree, ais, slice_type.op_token, Space.None); // [
644643 if (slice_type.ptr_info.sentinel) |sentinel| {
645644 const colon_token = tree.prevToken(sentinel.firstToken());
646 try renderToken(tree, stream, colon_token, Space.None); // :
647 try renderExpression(allocator, stream, tree, sentinel, Space.None);
648 try renderToken(tree, stream, tree.nextToken(sentinel.lastToken()), Space.None); // ]
645 try renderToken(tree, ais, colon_token, Space.None); // :
646 try renderExpression(allocator, ais, tree, sentinel, Space.None);
647 try renderToken(tree, ais, tree.nextToken(sentinel.lastToken()), Space.None); // ]
649648 } else {
650 try renderToken(tree, stream, tree.nextToken(slice_type.op_token), Space.None); // ]
649 try renderToken(tree, ais, tree.nextToken(slice_type.op_token), Space.None); // ]
651650 }
652651
653652 if (slice_type.ptr_info.allowzero_token) |allowzero_token| {
654 try renderToken(tree, stream, allowzero_token, Space.Space); // allowzero
653 try renderToken(tree, ais, allowzero_token, Space.Space); // allowzero
655654 }
656655 if (slice_type.ptr_info.align_info) |align_info| {
657656 const lparen_token = tree.prevToken(align_info.node.firstToken());
658657 const align_token = tree.prevToken(lparen_token);
659658
660 try renderToken(tree, stream, align_token, Space.None); // align
661 try renderToken(tree, stream, lparen_token, Space.None); // (
659 try renderToken(tree, ais, align_token, Space.None); // align
660 try renderToken(tree, ais, lparen_token, Space.None); // (
662661
663 try renderExpression(allocator, stream, tree, align_info.node, Space.None);
662 try renderExpression(allocator, ais, tree, align_info.node, Space.None);
664663
665664 if (align_info.bit_range) |bit_range| {
666665 const colon1 = tree.prevToken(bit_range.start.firstToken());
667666 const colon2 = tree.prevToken(bit_range.end.firstToken());
668667
669 try renderToken(tree, stream, colon1, Space.None); // :
670 try renderExpression(allocator, stream, tree, bit_range.start, Space.None);
671 try renderToken(tree, stream, colon2, Space.None); // :
672 try renderExpression(allocator, stream, tree, bit_range.end, Space.None);
668 try renderToken(tree, ais, colon1, Space.None); // :
669 try renderExpression(allocator, ais, tree, bit_range.start, Space.None);
670 try renderToken(tree, ais, colon2, Space.None); // :
671 try renderExpression(allocator, ais, tree, bit_range.end, Space.None);
673672
674673 const rparen_token = tree.nextToken(bit_range.end.lastToken());
675 try renderToken(tree, stream, rparen_token, Space.Space); // )
674 try renderToken(tree, ais, rparen_token, Space.Space); // )
676675 } else {
677676 const rparen_token = tree.nextToken(align_info.node.lastToken());
678 try renderToken(tree, stream, rparen_token, Space.Space); // )
677 try renderToken(tree, ais, rparen_token, Space.Space); // )
679678 }
680679 }
681680 if (slice_type.ptr_info.const_token) |const_token| {
682 try renderToken(tree, stream, const_token, Space.Space);
681 try renderToken(tree, ais, const_token, Space.Space);
683682 }
684683 if (slice_type.ptr_info.volatile_token) |volatile_token| {
685 try renderToken(tree, stream, volatile_token, Space.Space);
684 try renderToken(tree, ais, volatile_token, Space.Space);
686685 }
687 return renderExpression(allocator, stream, tree, slice_type.rhs, space);
686 return renderExpression(allocator, ais, tree, slice_type.rhs, space);
688687 },
689688
690689 .ArrayInitializer, .ArrayInitializerDot => {
......@@ -713,33 +712,33 @@ fn renderExpression(
713712
714713 if (exprs.len == 0) {
715714 switch (lhs) {
716 .dot => |dot| try renderToken(tree, stream, dot, Space.None),
717 .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
715 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
716 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
718717 }
719718
720719 {
721 stream.pushIndent();
722 defer stream.popIndent();
723 try renderToken(tree, stream, lbrace, Space.None);
720 ais.pushIndent();
721 defer ais.popIndent();
722 try renderToken(tree, ais, lbrace, Space.None);
724723 }
725724
726 return renderToken(tree, stream, rtoken, space);
725 return renderToken(tree, ais, rtoken, space);
727726 }
728727 if (exprs.len == 1 and tree.token_ids[exprs[0].*.lastToken() + 1] == .RBrace) {
729728 const expr = exprs[0];
730729
731730 switch (lhs) {
732 .dot => |dot| try renderToken(tree, stream, dot, Space.None),
733 .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
731 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
732 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
734733 }
735 try renderToken(tree, stream, lbrace, Space.None);
736 try renderExpression(allocator, stream, tree, expr, Space.None);
737 return renderToken(tree, stream, rtoken, space);
734 try renderToken(tree, ais, lbrace, Space.None);
735 try renderExpression(allocator, ais, tree, expr, Space.None);
736 return renderToken(tree, ais, rtoken, space);
738737 }
739738
740739 switch (lhs) {
741 .dot => |dot| try renderToken(tree, stream, dot, Space.None),
742 .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
740 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
741 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
743742 }
744743
745744 // scan to find row size
......@@ -781,9 +780,9 @@ fn renderExpression(
781780 var expr_widths = widths[0 .. widths.len - row_size];
782781 var column_widths = widths[widths.len - row_size ..];
783782
784 // Null stream for counting the printed length of each expression
783 // Null ais for counting the printed length of each expression
785784 var counting_stream = std.io.countingOutStream(std.io.null_out_stream);
786 var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, &counting_stream);
785 var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, counting_stream.writer());
787786
788787 for (exprs) |expr, i| {
789788 counting_stream.bytes_written = 0;
......@@ -795,23 +794,23 @@ fn renderExpression(
795794 }
796795
797796 {
798 stream.pushIndentNextLine();
799 defer stream.popIndent();
800 try renderToken(tree, stream, lbrace, Space.Newline);
797 ais.pushIndentNextLine();
798 defer ais.popIndent();
799 try renderToken(tree, ais, lbrace, Space.Newline);
801800
802801 var col: usize = 1;
803802 for (exprs) |expr, i| {
804803 if (i + 1 < exprs.len) {
805804 const next_expr = exprs[i + 1];
806 try renderExpression(allocator, stream, tree, expr, Space.None);
805 try renderExpression(allocator, ais, tree, expr, Space.None);
807806
808807 const comma = tree.nextToken(expr.*.lastToken());
809808
810809 if (col != row_size) {
811 try renderToken(tree, stream, comma, Space.Space); // ,
810 try renderToken(tree, ais, comma, Space.Space); // ,
812811
813812 const padding = column_widths[i % row_size] - expr_widths[i];
814 try stream.writer().writeByteNTimes(' ', padding);
813 try ais.writer().writeByteNTimes(' ', padding);
815814
816815 col += 1;
817816 continue;
......@@ -819,32 +818,32 @@ fn renderExpression(
819818 col = 1;
820819
821820 if (tree.token_ids[tree.nextToken(comma)] != .MultilineStringLiteralLine) {
822 try renderToken(tree, stream, comma, Space.Newline); // ,
821 try renderToken(tree, ais, comma, Space.Newline); // ,
823822 } else {
824 try renderToken(tree, stream, comma, Space.None); // ,
823 try renderToken(tree, ais, comma, Space.None); // ,
825824 }
826825
827 try renderExtraNewline(tree, stream, next_expr);
826 try renderExtraNewline(tree, ais, next_expr);
828827 } else {
829 try renderExpression(allocator, stream, tree, expr, Space.Comma); // ,
828 try renderExpression(allocator, ais, tree, expr, Space.Comma); // ,
830829 }
831830 }
832831 }
833 return renderToken(tree, stream, rtoken, space);
832 return renderToken(tree, ais, rtoken, space);
834833 } else {
835 try renderToken(tree, stream, lbrace, Space.Space);
834 try renderToken(tree, ais, lbrace, Space.Space);
836835 for (exprs) |expr, i| {
837836 if (i + 1 < exprs.len) {
838837 const next_expr = exprs[i + 1];
839 try renderExpression(allocator, stream, tree, expr, Space.None);
838 try renderExpression(allocator, ais, tree, expr, Space.None);
840839 const comma = tree.nextToken(expr.*.lastToken());
841 try renderToken(tree, stream, comma, Space.Space); // ,
840 try renderToken(tree, ais, comma, Space.Space); // ,
842841 } else {
843 try renderExpression(allocator, stream, tree, expr, Space.Space);
842 try renderExpression(allocator, ais, tree, expr, Space.Space);
844843 }
845844 }
846845
847 return renderToken(tree, stream, rtoken, space);
846 return renderToken(tree, ais, rtoken, space);
848847 }
849848 },
850849
......@@ -874,17 +873,17 @@ fn renderExpression(
874873
875874 if (field_inits.len == 0) {
876875 switch (lhs) {
877 .dot => |dot| try renderToken(tree, stream, dot, Space.None),
878 .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
876 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
877 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
879878 }
880879
881880 {
882 stream.pushIndentNextLine();
883 defer stream.popIndent();
884 try renderToken(tree, stream, lbrace, Space.None);
881 ais.pushIndentNextLine();
882 defer ais.popIndent();
883 try renderToken(tree, ais, lbrace, Space.None);
885884 }
886885
887 return renderToken(tree, stream, rtoken, space);
886 return renderToken(tree, ais, rtoken, space);
888887 }
889888
890889 const src_has_trailing_comma = blk: {
......@@ -900,8 +899,8 @@ fn renderExpression(
900899 const expr_outputs_one_line = blk: {
901900 // render field expressions until a LF is found
902901 for (field_inits) |field_init| {
903 var find_stream = std.io.findByteOutStream('\n', &std.io.null_out_stream);
904 var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, &find_stream);
902 var find_stream = std.io.findByteOutStream('\n', std.io.null_out_stream);
903 var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, find_stream.writer());
905904
906905 try renderExpression(allocator, &auto_indenting_stream, tree, field_init, Space.None);
907906 if (find_stream.byte_found) break :blk false;
......@@ -925,78 +924,78 @@ fn renderExpression(
925924 }
926925
927926 switch (lhs) {
928 .dot => |dot| try renderToken(tree, stream, dot, Space.None),
929 .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
927 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
928 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
930929 }
931 try renderToken(tree, stream, lbrace, Space.Space);
932 try renderExpression(allocator, stream, tree, &field_init.base, Space.Space);
933 return renderToken(tree, stream, rtoken, space);
930 try renderToken(tree, ais, lbrace, Space.Space);
931 try renderExpression(allocator, ais, tree, &field_init.base, Space.Space);
932 return renderToken(tree, ais, rtoken, space);
934933 }
935934
936935 if (!src_has_trailing_comma and src_same_line and expr_outputs_one_line) {
937936 // render all on one line, no trailing comma
938937 switch (lhs) {
939 .dot => |dot| try renderToken(tree, stream, dot, Space.None),
940 .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
938 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
939 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
941940 }
942 try renderToken(tree, stream, lbrace, Space.Space);
941 try renderToken(tree, ais, lbrace, Space.Space);
943942
944943 for (field_inits) |field_init, i| {
945944 if (i + 1 < field_inits.len) {
946 try renderExpression(allocator, stream, tree, field_init, Space.None);
945 try renderExpression(allocator, ais, tree, field_init, Space.None);
947946
948947 const comma = tree.nextToken(field_init.lastToken());
949 try renderToken(tree, stream, comma, Space.Space);
948 try renderToken(tree, ais, comma, Space.Space);
950949 } else {
951 try renderExpression(allocator, stream, tree, field_init, Space.Space);
950 try renderExpression(allocator, ais, tree, field_init, Space.Space);
952951 }
953952 }
954953
955 return renderToken(tree, stream, rtoken, space);
954 return renderToken(tree, ais, rtoken, space);
956955 }
957956
958957 {
959958 switch (lhs) {
960 .dot => |dot| try renderToken(tree, stream, dot, Space.None),
961 .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
959 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
960 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
962961 }
963962
964 stream.pushIndentNextLine();
965 defer stream.popIndent();
963 ais.pushIndentNextLine();
964 defer ais.popIndent();
966965
967 try renderToken(tree, stream, lbrace, Space.Newline);
966 try renderToken(tree, ais, lbrace, Space.Newline);
968967
969968 for (field_inits) |field_init, i| {
970969 if (i + 1 < field_inits.len) {
971970 const next_field_init = field_inits[i + 1];
972 try renderExpression(allocator, stream, tree, field_init, Space.None);
971 try renderExpression(allocator, ais, tree, field_init, Space.None);
973972
974973 const comma = tree.nextToken(field_init.lastToken());
975 try renderToken(tree, stream, comma, Space.Newline);
974 try renderToken(tree, ais, comma, Space.Newline);
976975
977 try renderExtraNewline(tree, stream, next_field_init);
976 try renderExtraNewline(tree, ais, next_field_init);
978977 } else {
979 try renderExpression(allocator, stream, tree, field_init, Space.Comma);
978 try renderExpression(allocator, ais, tree, field_init, Space.Comma);
980979 }
981980 }
982981 }
983982
984 return renderToken(tree, stream, rtoken, space);
983 return renderToken(tree, ais, rtoken, space);
985984 },
986985
987986 .Call => {
988987 const call = @fieldParentPtr(ast.Node.Call, "base", base);
989988 if (call.async_token) |async_token| {
990 try renderToken(tree, stream, async_token, Space.Space);
989 try renderToken(tree, ais, async_token, Space.Space);
991990 }
992991
993 try renderExpression(allocator, stream, tree, call.lhs, Space.None);
992 try renderExpression(allocator, ais, tree, call.lhs, Space.None);
994993
995994 const lparen = tree.nextToken(call.lhs.lastToken());
996995
997996 if (call.params_len == 0) {
998 try renderToken(tree, stream, lparen, Space.None);
999 return renderToken(tree, stream, call.rtoken, space);
997 try renderToken(tree, ais, lparen, Space.None);
998 return renderToken(tree, ais, call.rtoken, space);
1000999 }
10011000
10021001 const src_has_trailing_comma = blk: {
......@@ -1005,41 +1004,41 @@ fn renderExpression(
10051004 };
10061005
10071006 if (src_has_trailing_comma) {
1008 try renderToken(tree, stream, lparen, Space.Newline);
1007 try renderToken(tree, ais, lparen, Space.Newline);
10091008
10101009 const params = call.params();
10111010 for (params) |param_node, i| {
1012 stream.pushIndent();
1013 defer stream.popIndent();
1011 ais.pushIndent();
1012 defer ais.popIndent();
10141013
10151014 if (i + 1 < params.len) {
10161015 const next_node = params[i + 1];
1017 try renderExpression(allocator, stream, tree, param_node, Space.None);
1016 try renderExpression(allocator, ais, tree, param_node, Space.None);
10181017 const comma = tree.nextToken(param_node.lastToken());
1019 try renderToken(tree, stream, comma, Space.Newline); // ,
1020 try renderExtraNewline(tree, stream, next_node);
1018 try renderToken(tree, ais, comma, Space.Newline); // ,
1019 try renderExtraNewline(tree, ais, next_node);
10211020 } else {
1022 try renderExpression(allocator, stream, tree, param_node, Space.Comma);
1021 try renderExpression(allocator, ais, tree, param_node, Space.Comma);
10231022 }
10241023 }
1025 return renderToken(tree, stream, call.rtoken, space);
1024 return renderToken(tree, ais, call.rtoken, space);
10261025 }
10271026
1028 try renderToken(tree, stream, lparen, Space.None); // (
1027 try renderToken(tree, ais, lparen, Space.None); // (
10291028
10301029 const params = call.params();
10311030 for (params) |param_node, i| {
1032 if (param_node.*.tag == .MultilineStringLiteral) stream.pushIndentOneShot();
1031 if (param_node.*.tag == .MultilineStringLiteral) ais.pushIndentOneShot();
10331032
1034 try renderExpression(allocator, stream, tree, param_node, Space.None);
1033 try renderExpression(allocator, ais, tree, param_node, Space.None);
10351034
10361035 if (i + 1 < params.len) {
10371036 const next_param = params[i + 1];
10381037 const comma = tree.nextToken(param_node.lastToken());
1039 try renderToken(tree, stream, comma, Space.Space);
1038 try renderToken(tree, ais, comma, Space.Space);
10401039 }
10411040 }
1042 return renderToken(tree, stream, call.rtoken, space);
1041 return renderToken(tree, ais, call.rtoken, space);
10431042 },
10441043
10451044 .ArrayAccess => {
......@@ -1048,25 +1047,25 @@ fn renderExpression(
10481047 const lbracket = tree.nextToken(suffix_op.lhs.lastToken());
10491048 const rbracket = tree.nextToken(suffix_op.index_expr.lastToken());
10501049
1051 try renderExpression(allocator, stream, tree, suffix_op.lhs, Space.None);
1052 try renderToken(tree, stream, lbracket, Space.None); // [
1050 try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
1051 try renderToken(tree, ais, lbracket, Space.None); // [
10531052
10541053 const starts_with_comment = tree.token_ids[lbracket + 1] == .LineComment;
10551054 const ends_with_comment = tree.token_ids[rbracket - 1] == .LineComment;
10561055 {
10571056 const new_space = if (ends_with_comment) Space.Newline else Space.None;
10581057
1059 stream.pushIndent();
1060 defer stream.popIndent();
1061 try renderExpression(allocator, stream, tree, suffix_op.index_expr, new_space);
1058 ais.pushIndent();
1059 defer ais.popIndent();
1060 try renderExpression(allocator, ais, tree, suffix_op.index_expr, new_space);
10621061 }
1063 if (starts_with_comment) try stream.maybeInsertNewline();
1064 return renderToken(tree, stream, rbracket, space); // ]
1062 if (starts_with_comment) try ais.maybeInsertNewline();
1063 return renderToken(tree, ais, rbracket, space); // ]
10651064 },
10661065
10671066 .Slice => {
10681067 const suffix_op = base.castTag(.Slice).?;
1069 try renderExpression(allocator, stream, tree, suffix_op.lhs, Space.None);
1068 try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
10701069
10711070 const lbracket = tree.prevToken(suffix_op.start.firstToken());
10721071 const dotdot = tree.nextToken(suffix_op.start.lastToken());
......@@ -1076,33 +1075,33 @@ fn renderExpression(
10761075 const after_start_space = if (after_start_space_bool) Space.Space else Space.None;
10771076 const after_op_space = if (suffix_op.end != null) after_start_space else Space.None;
10781077
1079 try renderToken(tree, stream, lbracket, Space.None); // [
1080 try renderExpression(allocator, stream, tree, suffix_op.start, after_start_space);
1081 try renderToken(tree, stream, dotdot, after_op_space); // ..
1078 try renderToken(tree, ais, lbracket, Space.None); // [
1079 try renderExpression(allocator, ais, tree, suffix_op.start, after_start_space);
1080 try renderToken(tree, ais, dotdot, after_op_space); // ..
10821081 if (suffix_op.end) |end| {
10831082 const after_end_space = if (suffix_op.sentinel != null) Space.Space else Space.None;
1084 try renderExpression(allocator, stream, tree, end, after_end_space);
1083 try renderExpression(allocator, ais, tree, end, after_end_space);
10851084 }
10861085 if (suffix_op.sentinel) |sentinel| {
10871086 const colon = tree.prevToken(sentinel.firstToken());
1088 try renderToken(tree, stream, colon, Space.None); // :
1089 try renderExpression(allocator, stream, tree, sentinel, Space.None);
1087 try renderToken(tree, ais, colon, Space.None); // :
1088 try renderExpression(allocator, ais, tree, sentinel, Space.None);
10901089 }
1091 return renderToken(tree, stream, suffix_op.rtoken, space); // ]
1090 return renderToken(tree, ais, suffix_op.rtoken, space); // ]
10921091 },
10931092
10941093 .Deref => {
10951094 const suffix_op = base.castTag(.Deref).?;
10961095
1097 try renderExpression(allocator, stream, tree, suffix_op.lhs, Space.None);
1098 return renderToken(tree, stream, suffix_op.rtoken, space); // .*
1096 try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
1097 return renderToken(tree, ais, suffix_op.rtoken, space); // .*
10991098 },
11001099 .UnwrapOptional => {
11011100 const suffix_op = base.castTag(.UnwrapOptional).?;
11021101
1103 try renderExpression(allocator, stream, tree, suffix_op.lhs, Space.None);
1104 try renderToken(tree, stream, tree.prevToken(suffix_op.rtoken), Space.None); // .
1105 return renderToken(tree, stream, suffix_op.rtoken, space); // ?
1102 try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
1103 try renderToken(tree, ais, tree.prevToken(suffix_op.rtoken), Space.None); // .
1104 return renderToken(tree, ais, suffix_op.rtoken, space); // ?
11061105 },
11071106
11081107 .Break => {
......@@ -1111,152 +1110,152 @@ fn renderExpression(
11111110 const maybe_label = flow_expr.getLabel();
11121111
11131112 if (maybe_label == null and maybe_rhs == null) {
1114 return renderToken(tree, stream, flow_expr.ltoken, space); // break
1113 return renderToken(tree, ais, flow_expr.ltoken, space); // break
11151114 }
11161115
1117 try renderToken(tree, stream, flow_expr.ltoken, Space.Space); // break
1116 try renderToken(tree, ais, flow_expr.ltoken, Space.Space); // break
11181117 if (maybe_label) |label| {
11191118 const colon = tree.nextToken(flow_expr.ltoken);
1120 try renderToken(tree, stream, colon, Space.None); // :
1119 try renderToken(tree, ais, colon, Space.None); // :
11211120
11221121 if (maybe_rhs == null) {
1123 return renderToken(tree, stream, label, space); // label
1122 return renderToken(tree, ais, label, space); // label
11241123 }
1125 try renderToken(tree, stream, label, Space.Space); // label
1124 try renderToken(tree, ais, label, Space.Space); // label
11261125 }
1127 return renderExpression(allocator, stream, tree, maybe_rhs.?, space);
1126 return renderExpression(allocator, ais, tree, maybe_rhs.?, space);
11281127 },
11291128
11301129 .Continue => {
11311130 const flow_expr = base.castTag(.Continue).?;
11321131 if (flow_expr.getLabel()) |label| {
1133 try renderToken(tree, stream, flow_expr.ltoken, Space.Space); // continue
1132 try renderToken(tree, ais, flow_expr.ltoken, Space.Space); // continue
11341133 const colon = tree.nextToken(flow_expr.ltoken);
1135 try renderToken(tree, stream, colon, Space.None); // :
1136 return renderToken(tree, stream, label, space); // label
1134 try renderToken(tree, ais, colon, Space.None); // :
1135 return renderToken(tree, ais, label, space); // label
11371136 } else {
1138 return renderToken(tree, stream, flow_expr.ltoken, space); // continue
1137 return renderToken(tree, ais, flow_expr.ltoken, space); // continue
11391138 }
11401139 },
11411140
11421141 .Return => {
11431142 const flow_expr = base.castTag(.Return).?;
11441143 if (flow_expr.getRHS()) |rhs| {
1145 try renderToken(tree, stream, flow_expr.ltoken, Space.Space);
1146 return renderExpression(allocator, stream, tree, rhs, space);
1144 try renderToken(tree, ais, flow_expr.ltoken, Space.Space);
1145 return renderExpression(allocator, ais, tree, rhs, space);
11471146 } else {
1148 return renderToken(tree, stream, flow_expr.ltoken, space);
1147 return renderToken(tree, ais, flow_expr.ltoken, space);
11491148 }
11501149 },
11511150
11521151 .Payload => {
11531152 const payload = @fieldParentPtr(ast.Node.Payload, "base", base);
11541153
1155 try renderToken(tree, stream, payload.lpipe, Space.None);
1156 try renderExpression(allocator, stream, tree, payload.error_symbol, Space.None);
1157 return renderToken(tree, stream, payload.rpipe, space);
1154 try renderToken(tree, ais, payload.lpipe, Space.None);
1155 try renderExpression(allocator, ais, tree, payload.error_symbol, Space.None);
1156 return renderToken(tree, ais, payload.rpipe, space);
11581157 },
11591158
11601159 .PointerPayload => {
11611160 const payload = @fieldParentPtr(ast.Node.PointerPayload, "base", base);
11621161
1163 try renderToken(tree, stream, payload.lpipe, Space.None);
1162 try renderToken(tree, ais, payload.lpipe, Space.None);
11641163 if (payload.ptr_token) |ptr_token| {
1165 try renderToken(tree, stream, ptr_token, Space.None);
1164 try renderToken(tree, ais, ptr_token, Space.None);
11661165 }
1167 try renderExpression(allocator, stream, tree, payload.value_symbol, Space.None);
1168 return renderToken(tree, stream, payload.rpipe, space);
1166 try renderExpression(allocator, ais, tree, payload.value_symbol, Space.None);
1167 return renderToken(tree, ais, payload.rpipe, space);
11691168 },
11701169
11711170 .PointerIndexPayload => {
11721171 const payload = @fieldParentPtr(ast.Node.PointerIndexPayload, "base", base);
11731172
1174 try renderToken(tree, stream, payload.lpipe, Space.None);
1173 try renderToken(tree, ais, payload.lpipe, Space.None);
11751174 if (payload.ptr_token) |ptr_token| {
1176 try renderToken(tree, stream, ptr_token, Space.None);
1175 try renderToken(tree, ais, ptr_token, Space.None);
11771176 }
1178 try renderExpression(allocator, stream, tree, payload.value_symbol, Space.None);
1177 try renderExpression(allocator, ais, tree, payload.value_symbol, Space.None);
11791178
11801179 if (payload.index_symbol) |index_symbol| {
11811180 const comma = tree.nextToken(payload.value_symbol.lastToken());
11821181
1183 try renderToken(tree, stream, comma, Space.Space);
1184 try renderExpression(allocator, stream, tree, index_symbol, Space.None);
1182 try renderToken(tree, ais, comma, Space.Space);
1183 try renderExpression(allocator, ais, tree, index_symbol, Space.None);
11851184 }
11861185
1187 return renderToken(tree, stream, payload.rpipe, space);
1186 return renderToken(tree, ais, payload.rpipe, space);
11881187 },
11891188
11901189 .GroupedExpression => {
11911190 const grouped_expr = @fieldParentPtr(ast.Node.GroupedExpression, "base", base);
11921191
1193 try renderToken(tree, stream, grouped_expr.lparen, Space.None);
1192 try renderToken(tree, ais, grouped_expr.lparen, Space.None);
11941193 {
1195 stream.pushIndentOneShot();
1196 try renderExpression(allocator, stream, tree, grouped_expr.expr, Space.None);
1194 ais.pushIndentOneShot();
1195 try renderExpression(allocator, ais, tree, grouped_expr.expr, Space.None);
11971196 }
1198 return renderToken(tree, stream, grouped_expr.rparen, space);
1197 return renderToken(tree, ais, grouped_expr.rparen, space);
11991198 },
12001199
12011200 .FieldInitializer => {
12021201 const field_init = @fieldParentPtr(ast.Node.FieldInitializer, "base", base);
12031202
1204 try renderToken(tree, stream, field_init.period_token, Space.None); // .
1205 try renderToken(tree, stream, field_init.name_token, Space.Space); // name
1206 try renderToken(tree, stream, tree.nextToken(field_init.name_token), Space.Space); // =
1207 return renderExpression(allocator, stream, tree, field_init.expr, space);
1203 try renderToken(tree, ais, field_init.period_token, Space.None); // .
1204 try renderToken(tree, ais, field_init.name_token, Space.Space); // name
1205 try renderToken(tree, ais, tree.nextToken(field_init.name_token), Space.Space); // =
1206 return renderExpression(allocator, ais, tree, field_init.expr, space);
12081207 },
12091208
12101209 .ContainerDecl => {
12111210 const container_decl = @fieldParentPtr(ast.Node.ContainerDecl, "base", base);
12121211
12131212 if (container_decl.layout_token) |layout_token| {
1214 try renderToken(tree, stream, layout_token, Space.Space);
1213 try renderToken(tree, ais, layout_token, Space.Space);
12151214 }
12161215
12171216 switch (container_decl.init_arg_expr) {
12181217 .None => {
1219 try renderToken(tree, stream, container_decl.kind_token, Space.Space); // union
1218 try renderToken(tree, ais, container_decl.kind_token, Space.Space); // union
12201219 },
12211220 .Enum => |enum_tag_type| {
1222 try renderToken(tree, stream, container_decl.kind_token, Space.None); // union
1221 try renderToken(tree, ais, container_decl.kind_token, Space.None); // union
12231222
12241223 const lparen = tree.nextToken(container_decl.kind_token);
12251224 const enum_token = tree.nextToken(lparen);
12261225
1227 try renderToken(tree, stream, lparen, Space.None); // (
1228 try renderToken(tree, stream, enum_token, Space.None); // enum
1226 try renderToken(tree, ais, lparen, Space.None); // (
1227 try renderToken(tree, ais, enum_token, Space.None); // enum
12291228
12301229 if (enum_tag_type) |expr| {
1231 try renderToken(tree, stream, tree.nextToken(enum_token), Space.None); // (
1232 try renderExpression(allocator, stream, tree, expr, Space.None);
1230 try renderToken(tree, ais, tree.nextToken(enum_token), Space.None); // (
1231 try renderExpression(allocator, ais, tree, expr, Space.None);
12331232
12341233 const rparen = tree.nextToken(expr.lastToken());
1235 try renderToken(tree, stream, rparen, Space.None); // )
1236 try renderToken(tree, stream, tree.nextToken(rparen), Space.Space); // )
1234 try renderToken(tree, ais, rparen, Space.None); // )
1235 try renderToken(tree, ais, tree.nextToken(rparen), Space.Space); // )
12371236 } else {
1238 try renderToken(tree, stream, tree.nextToken(enum_token), Space.Space); // )
1237 try renderToken(tree, ais, tree.nextToken(enum_token), Space.Space); // )
12391238 }
12401239 },
12411240 .Type => |type_expr| {
1242 try renderToken(tree, stream, container_decl.kind_token, Space.None); // union
1241 try renderToken(tree, ais, container_decl.kind_token, Space.None); // union
12431242
12441243 const lparen = tree.nextToken(container_decl.kind_token);
12451244 const rparen = tree.nextToken(type_expr.lastToken());
12461245
1247 try renderToken(tree, stream, lparen, Space.None); // (
1248 try renderExpression(allocator, stream, tree, type_expr, Space.None);
1249 try renderToken(tree, stream, rparen, Space.Space); // )
1246 try renderToken(tree, ais, lparen, Space.None); // (
1247 try renderExpression(allocator, ais, tree, type_expr, Space.None);
1248 try renderToken(tree, ais, rparen, Space.Space); // )
12501249 },
12511250 }
12521251
12531252 if (container_decl.fields_and_decls_len == 0) {
12541253 {
1255 stream.pushIndentNextLine();
1256 defer stream.popIndent();
1257 try renderToken(tree, stream, container_decl.lbrace_token, Space.None); // {
1254 ais.pushIndentNextLine();
1255 defer ais.popIndent();
1256 try renderToken(tree, ais, container_decl.lbrace_token, Space.None); // {
12581257 }
1259 return renderToken(tree, stream, container_decl.rbrace_token, space); // }
1258 return renderToken(tree, ais, container_decl.rbrace_token, space); // }
12601259 }
12611260
12621261 const src_has_trailing_comma = blk: {
......@@ -1287,39 +1286,39 @@ fn renderExpression(
12871286
12881287 if (src_has_trailing_comma or !src_has_only_fields) {
12891288 // One declaration per line
1290 stream.pushIndentNextLine();
1291 defer stream.popIndent();
1292 try renderToken(tree, stream, container_decl.lbrace_token, .Newline); // {
1289 ais.pushIndentNextLine();
1290 defer ais.popIndent();
1291 try renderToken(tree, ais, container_decl.lbrace_token, .Newline); // {
12931292
12941293 for (fields_and_decls) |decl, i| {
1295 try renderContainerDecl(allocator, stream, tree, decl, .Newline);
1294 try renderContainerDecl(allocator, ais, tree, decl, .Newline);
12961295
12971296 if (i + 1 < fields_and_decls.len) {
1298 try renderExtraNewline(tree, stream, fields_and_decls[i + 1]);
1297 try renderExtraNewline(tree, ais, fields_and_decls[i + 1]);
12991298 }
13001299 }
13011300 } else if (src_has_newline) {
13021301 // All the declarations on the same line, but place the items on
13031302 // their own line
1304 try renderToken(tree, stream, container_decl.lbrace_token, .Newline); // {
1303 try renderToken(tree, ais, container_decl.lbrace_token, .Newline); // {
13051304
1306 stream.pushIndent();
1307 defer stream.popIndent();
1305 ais.pushIndent();
1306 defer ais.popIndent();
13081307
13091308 for (fields_and_decls) |decl, i| {
13101309 const space_after_decl: Space = if (i + 1 >= fields_and_decls.len) .Newline else .Space;
1311 try renderContainerDecl(allocator, stream, tree, decl, space_after_decl);
1310 try renderContainerDecl(allocator, ais, tree, decl, space_after_decl);
13121311 }
13131312 } else {
13141313 // All the declarations on the same line
1315 try renderToken(tree, stream, container_decl.lbrace_token, .Space); // {
1314 try renderToken(tree, ais, container_decl.lbrace_token, .Space); // {
13161315
13171316 for (fields_and_decls) |decl| {
1318 try renderContainerDecl(allocator, stream, tree, decl, .Space);
1317 try renderContainerDecl(allocator, ais, tree, decl, .Space);
13191318 }
13201319 }
13211320
1322 return renderToken(tree, stream, container_decl.rbrace_token, space); // }
1321 return renderToken(tree, ais, container_decl.rbrace_token, space); // }
13231322 },
13241323
13251324 .ErrorSetDecl => {
......@@ -1328,9 +1327,9 @@ fn renderExpression(
13281327 const lbrace = tree.nextToken(err_set_decl.error_token);
13291328
13301329 if (err_set_decl.decls_len == 0) {
1331 try renderToken(tree, stream, err_set_decl.error_token, Space.None);
1332 try renderToken(tree, stream, lbrace, Space.None);
1333 return renderToken(tree, stream, err_set_decl.rbrace_token, space);
1330 try renderToken(tree, ais, err_set_decl.error_token, Space.None);
1331 try renderToken(tree, ais, lbrace, Space.None);
1332 return renderToken(tree, ais, err_set_decl.rbrace_token, space);
13341333 }
13351334
13361335 if (err_set_decl.decls_len == 1) blk: {
......@@ -1344,13 +1343,13 @@ fn renderExpression(
13441343 break :blk;
13451344 }
13461345
1347 try renderToken(tree, stream, err_set_decl.error_token, Space.None); // error
1348 try renderToken(tree, stream, lbrace, Space.None); // {
1349 try renderExpression(allocator, stream, tree, node, Space.None);
1350 return renderToken(tree, stream, err_set_decl.rbrace_token, space); // }
1346 try renderToken(tree, ais, err_set_decl.error_token, Space.None); // error
1347 try renderToken(tree, ais, lbrace, Space.None); // {
1348 try renderExpression(allocator, ais, tree, node, Space.None);
1349 return renderToken(tree, ais, err_set_decl.rbrace_token, space); // }
13511350 }
13521351
1353 try renderToken(tree, stream, err_set_decl.error_token, Space.None); // error
1352 try renderToken(tree, ais, err_set_decl.error_token, Space.None); // error
13541353
13551354 const src_has_trailing_comma = blk: {
13561355 const maybe_comma = tree.prevToken(err_set_decl.rbrace_token);
......@@ -1359,64 +1358,64 @@ fn renderExpression(
13591358
13601359 if (src_has_trailing_comma) {
13611360 {
1362 stream.pushIndent();
1363 defer stream.popIndent();
1361 ais.pushIndent();
1362 defer ais.popIndent();
13641363
1365 try renderToken(tree, stream, lbrace, Space.Newline); // {
1364 try renderToken(tree, ais, lbrace, Space.Newline); // {
13661365 const decls = err_set_decl.decls();
13671366 for (decls) |node, i| {
13681367 if (i + 1 < decls.len) {
1369 try renderExpression(allocator, stream, tree, node, Space.None);
1370 try renderToken(tree, stream, tree.nextToken(node.lastToken()), Space.Newline); // ,
1368 try renderExpression(allocator, ais, tree, node, Space.None);
1369 try renderToken(tree, ais, tree.nextToken(node.lastToken()), Space.Newline); // ,
13711370
1372 try renderExtraNewline(tree, stream, decls[i + 1]);
1371 try renderExtraNewline(tree, ais, decls[i + 1]);
13731372 } else {
1374 try renderExpression(allocator, stream, tree, node, Space.Comma);
1373 try renderExpression(allocator, ais, tree, node, Space.Comma);
13751374 }
13761375 }
13771376 }
13781377
1379 return renderToken(tree, stream, err_set_decl.rbrace_token, space); // }
1378 return renderToken(tree, ais, err_set_decl.rbrace_token, space); // }
13801379 } else {
1381 try renderToken(tree, stream, lbrace, Space.Space); // {
1380 try renderToken(tree, ais, lbrace, Space.Space); // {
13821381
13831382 const decls = err_set_decl.decls();
13841383 for (decls) |node, i| {
13851384 if (i + 1 < decls.len) {
1386 try renderExpression(allocator, stream, tree, node, Space.None);
1385 try renderExpression(allocator, ais, tree, node, Space.None);
13871386
13881387 const comma_token = tree.nextToken(node.lastToken());
13891388 assert(tree.token_ids[comma_token] == .Comma);
1390 try renderToken(tree, stream, comma_token, Space.Space); // ,
1391 try renderExtraNewline(tree, stream, decls[i + 1]);
1389 try renderToken(tree, ais, comma_token, Space.Space); // ,
1390 try renderExtraNewline(tree, ais, decls[i + 1]);
13921391 } else {
1393 try renderExpression(allocator, stream, tree, node, Space.Space);
1392 try renderExpression(allocator, ais, tree, node, Space.Space);
13941393 }
13951394 }
13961395
1397 return renderToken(tree, stream, err_set_decl.rbrace_token, space); // }
1396 return renderToken(tree, ais, err_set_decl.rbrace_token, space); // }
13981397 }
13991398 },
14001399
14011400 .ErrorTag => {
14021401 const tag = @fieldParentPtr(ast.Node.ErrorTag, "base", base);
14031402
1404 try renderDocComments(tree, stream, tag, tag.doc_comments);
1405 return renderToken(tree, stream, tag.name_token, space); // name
1403 try renderDocComments(tree, ais, tag, tag.doc_comments);
1404 return renderToken(tree, ais, tag.name_token, space); // name
14061405 },
14071406
14081407 .MultilineStringLiteral => {
14091408 const multiline_str_literal = @fieldParentPtr(ast.Node.MultilineStringLiteral, "base", base);
14101409
14111410 {
1412 const locked_indents = stream.lockOneShotIndent();
1411 const locked_indents = ais.lockOneShotIndent();
14131412 defer {
14141413 var i: u8 = 0;
1415 while (i < locked_indents) : (i += 1) stream.popIndent();
1414 while (i < locked_indents) : (i += 1) ais.popIndent();
14161415 }
1417 try stream.maybeInsertNewline();
1416 try ais.maybeInsertNewline();
14181417
1419 for (multiline_str_literal.lines()) |t| try renderToken(tree, stream, t, Space.None);
1418 for (multiline_str_literal.lines()) |t| try renderToken(tree, ais, t, Space.None);
14201419 }
14211420 },
14221421
......@@ -1425,9 +1424,9 @@ fn renderExpression(
14251424
14261425 // TODO remove after 0.7.0 release
14271426 if (mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@OpaqueType"))
1428 return stream.writer().writeAll("@Type(.Opaque)");
1427 return ais.writer().writeAll("@Type(.Opaque)");
14291428
1430 try renderToken(tree, stream, builtin_call.builtin_token, Space.None); // @name
1429 try renderToken(tree, ais, builtin_call.builtin_token, Space.None); // @name
14311430
14321431 const src_params_trailing_comma = blk: {
14331432 if (builtin_call.params_len < 2) break :blk false;
......@@ -1439,30 +1438,30 @@ fn renderExpression(
14391438 const lparen = tree.nextToken(builtin_call.builtin_token);
14401439
14411440 if (!src_params_trailing_comma) {
1442 try renderToken(tree, stream, lparen, Space.None); // (
1441 try renderToken(tree, ais, lparen, Space.None); // (
14431442
14441443 // render all on one line, no trailing comma
14451444 const params = builtin_call.params();
14461445 for (params) |param_node, i| {
1447 try renderExpression(allocator, stream, tree, param_node, Space.None);
1446 try renderExpression(allocator, ais, tree, param_node, Space.None);
14481447
14491448 if (i + 1 < params.len) {
14501449 const comma_token = tree.nextToken(param_node.lastToken());
1451 try renderToken(tree, stream, comma_token, Space.Space); // ,
1450 try renderToken(tree, ais, comma_token, Space.Space); // ,
14521451 }
14531452 }
14541453 } else {
14551454 // one param per line
1456 stream.pushIndent();
1457 defer stream.popIndent();
1458 try renderToken(tree, stream, lparen, Space.Newline); // (
1455 ais.pushIndent();
1456 defer ais.popIndent();
1457 try renderToken(tree, ais, lparen, Space.Newline); // (
14591458
14601459 for (builtin_call.params()) |param_node| {
1461 try renderExpression(allocator, stream, tree, param_node, Space.Comma);
1460 try renderExpression(allocator, ais, tree, param_node, Space.Comma);
14621461 }
14631462 }
14641463
1465 return renderToken(tree, stream, builtin_call.rparen_token, space); // )
1464 return renderToken(tree, ais, builtin_call.rparen_token, space); // )
14661465 },
14671466
14681467 .FnProto => {
......@@ -1472,24 +1471,24 @@ fn renderExpression(
14721471 const visib_token = tree.token_ids[visib_token_index];
14731472 assert(visib_token == .Keyword_pub or visib_token == .Keyword_export);
14741473
1475 try renderToken(tree, stream, visib_token_index, Space.Space); // pub
1474 try renderToken(tree, ais, visib_token_index, Space.Space); // pub
14761475 }
14771476
14781477 if (fn_proto.getExternExportInlineToken()) |extern_export_inline_token| {
14791478 if (fn_proto.getIsExternPrototype() == null)
1480 try renderToken(tree, stream, extern_export_inline_token, Space.Space); // extern/export/inline
1479 try renderToken(tree, ais, extern_export_inline_token, Space.Space); // extern/export/inline
14811480 }
14821481
14831482 if (fn_proto.getLibName()) |lib_name| {
1484 try renderExpression(allocator, stream, tree, lib_name, Space.Space);
1483 try renderExpression(allocator, ais, tree, lib_name, Space.Space);
14851484 }
14861485
14871486 const lparen = if (fn_proto.getNameToken()) |name_token| blk: {
1488 try renderToken(tree, stream, fn_proto.fn_token, Space.Space); // fn
1489 try renderToken(tree, stream, name_token, Space.None); // name
1487 try renderToken(tree, ais, fn_proto.fn_token, Space.Space); // fn
1488 try renderToken(tree, ais, name_token, Space.None); // name
14901489 break :blk tree.nextToken(name_token);
14911490 } else blk: {
1492 try renderToken(tree, stream, fn_proto.fn_token, Space.Space); // fn
1491 try renderToken(tree, ais, fn_proto.fn_token, Space.Space); // fn
14931492 break :blk tree.nextToken(fn_proto.fn_token);
14941493 };
14951494 assert(tree.token_ids[lparen] == .LParen);
......@@ -1516,45 +1515,45 @@ fn renderExpression(
15161515 };
15171516
15181517 if (!src_params_trailing_comma) {
1519 try renderToken(tree, stream, lparen, Space.None); // (
1518 try renderToken(tree, ais, lparen, Space.None); // (
15201519
15211520 // render all on one line, no trailing comma
15221521 for (fn_proto.params()) |param_decl, i| {
1523 try renderParamDecl(allocator, stream, tree, param_decl, Space.None);
1522 try renderParamDecl(allocator, ais, tree, param_decl, Space.None);
15241523
15251524 if (i + 1 < fn_proto.params_len or fn_proto.getVarArgsToken() != null) {
15261525 const comma = tree.nextToken(param_decl.lastToken());
1527 try renderToken(tree, stream, comma, Space.Space); // ,
1526 try renderToken(tree, ais, comma, Space.Space); // ,
15281527 }
15291528 }
15301529 if (fn_proto.getVarArgsToken()) |var_args_token| {
1531 try renderToken(tree, stream, var_args_token, Space.None);
1530 try renderToken(tree, ais, var_args_token, Space.None);
15321531 }
15331532 } else {
15341533 // one param per line
1535 stream.pushIndent();
1536 defer stream.popIndent();
1537 try renderToken(tree, stream, lparen, Space.Newline); // (
1534 ais.pushIndent();
1535 defer ais.popIndent();
1536 try renderToken(tree, ais, lparen, Space.Newline); // (
15381537
15391538 for (fn_proto.params()) |param_decl| {
1540 try renderParamDecl(allocator, stream, tree, param_decl, Space.Comma);
1539 try renderParamDecl(allocator, ais, tree, param_decl, Space.Comma);
15411540 }
15421541 if (fn_proto.getVarArgsToken()) |var_args_token| {
1543 try renderToken(tree, stream, var_args_token, Space.Comma);
1542 try renderToken(tree, ais, var_args_token, Space.Comma);
15441543 }
15451544 }
15461545
1547 try renderToken(tree, stream, rparen, Space.Space); // )
1546 try renderToken(tree, ais, rparen, Space.Space); // )
15481547
15491548 if (fn_proto.getAlignExpr()) |align_expr| {
15501549 const align_rparen = tree.nextToken(align_expr.lastToken());
15511550 const align_lparen = tree.prevToken(align_expr.firstToken());
15521551 const align_kw = tree.prevToken(align_lparen);
15531552
1554 try renderToken(tree, stream, align_kw, Space.None); // align
1555 try renderToken(tree, stream, align_lparen, Space.None); // (
1556 try renderExpression(allocator, stream, tree, align_expr, Space.None);
1557 try renderToken(tree, stream, align_rparen, Space.Space); // )
1553 try renderToken(tree, ais, align_kw, Space.None); // align
1554 try renderToken(tree, ais, align_lparen, Space.None); // (
1555 try renderExpression(allocator, ais, tree, align_expr, Space.None);
1556 try renderToken(tree, ais, align_rparen, Space.Space); // )
15581557 }
15591558
15601559 if (fn_proto.getSectionExpr()) |section_expr| {
......@@ -1562,10 +1561,10 @@ fn renderExpression(
15621561 const section_lparen = tree.prevToken(section_expr.firstToken());
15631562 const section_kw = tree.prevToken(section_lparen);
15641563
1565 try renderToken(tree, stream, section_kw, Space.None); // section
1566 try renderToken(tree, stream, section_lparen, Space.None); // (
1567 try renderExpression(allocator, stream, tree, section_expr, Space.None);
1568 try renderToken(tree, stream, section_rparen, Space.Space); // )
1564 try renderToken(tree, ais, section_kw, Space.None); // section
1565 try renderToken(tree, ais, section_lparen, Space.None); // (
1566 try renderExpression(allocator, ais, tree, section_expr, Space.None);
1567 try renderToken(tree, ais, section_rparen, Space.Space); // )
15691568 }
15701569
15711570 if (fn_proto.getCallconvExpr()) |callconv_expr| {
......@@ -1573,23 +1572,23 @@ fn renderExpression(
15731572 const callconv_lparen = tree.prevToken(callconv_expr.firstToken());
15741573 const callconv_kw = tree.prevToken(callconv_lparen);
15751574
1576 try renderToken(tree, stream, callconv_kw, Space.None); // callconv
1577 try renderToken(tree, stream, callconv_lparen, Space.None); // (
1578 try renderExpression(allocator, stream, tree, callconv_expr, Space.None);
1579 try renderToken(tree, stream, callconv_rparen, Space.Space); // )
1575 try renderToken(tree, ais, callconv_kw, Space.None); // callconv
1576 try renderToken(tree, ais, callconv_lparen, Space.None); // (
1577 try renderExpression(allocator, ais, tree, callconv_expr, Space.None);
1578 try renderToken(tree, ais, callconv_rparen, Space.Space); // )
15801579 } else if (fn_proto.getIsExternPrototype() != null) {
1581 try stream.writer().writeAll("callconv(.C) ");
1580 try ais.writer().writeAll("callconv(.C) ");
15821581 } else if (fn_proto.getIsAsync() != null) {
1583 try stream.writer().writeAll("callconv(.Async) ");
1582 try ais.writer().writeAll("callconv(.Async) ");
15841583 }
15851584
15861585 switch (fn_proto.return_type) {
15871586 .Explicit => |node| {
1588 return renderExpression(allocator, stream, tree, node, space);
1587 return renderExpression(allocator, ais, tree, node, space);
15891588 },
15901589 .InferErrorSet => |node| {
1591 try renderToken(tree, stream, tree.prevToken(node.firstToken()), Space.None); // !
1592 return renderExpression(allocator, stream, tree, node, space);
1590 try renderToken(tree, ais, tree.prevToken(node.firstToken()), Space.None); // !
1591 return renderExpression(allocator, ais, tree, node, space);
15931592 },
15941593 .Invalid => unreachable,
15951594 }
......@@ -1599,11 +1598,11 @@ fn renderExpression(
15991598 const anyframe_type = @fieldParentPtr(ast.Node.AnyFrameType, "base", base);
16001599
16011600 if (anyframe_type.result) |result| {
1602 try renderToken(tree, stream, anyframe_type.anyframe_token, Space.None); // anyframe
1603 try renderToken(tree, stream, result.arrow_token, Space.None); // ->
1604 return renderExpression(allocator, stream, tree, result.return_type, space);
1601 try renderToken(tree, ais, anyframe_type.anyframe_token, Space.None); // anyframe
1602 try renderToken(tree, ais, result.arrow_token, Space.None); // ->
1603 return renderExpression(allocator, ais, tree, result.return_type, space);
16051604 } else {
1606 return renderToken(tree, stream, anyframe_type.anyframe_token, space); // anyframe
1605 return renderToken(tree, ais, anyframe_type.anyframe_token, space); // anyframe
16071606 }
16081607 },
16091608
......@@ -1612,38 +1611,38 @@ fn renderExpression(
16121611 .Switch => {
16131612 const switch_node = @fieldParentPtr(ast.Node.Switch, "base", base);
16141613
1615 try renderToken(tree, stream, switch_node.switch_token, Space.Space); // switch
1616 try renderToken(tree, stream, tree.nextToken(switch_node.switch_token), Space.None); // (
1614 try renderToken(tree, ais, switch_node.switch_token, Space.Space); // switch
1615 try renderToken(tree, ais, tree.nextToken(switch_node.switch_token), Space.None); // (
16171616
16181617 const rparen = tree.nextToken(switch_node.expr.lastToken());
16191618 const lbrace = tree.nextToken(rparen);
16201619
16211620 if (switch_node.cases_len == 0) {
1622 try renderExpression(allocator, stream, tree, switch_node.expr, Space.None);
1623 try renderToken(tree, stream, rparen, Space.Space); // )
1624 try renderToken(tree, stream, lbrace, Space.None); // {
1625 return renderToken(tree, stream, switch_node.rbrace, space); // }
1621 try renderExpression(allocator, ais, tree, switch_node.expr, Space.None);
1622 try renderToken(tree, ais, rparen, Space.Space); // )
1623 try renderToken(tree, ais, lbrace, Space.None); // {
1624 return renderToken(tree, ais, switch_node.rbrace, space); // }
16261625 }
16271626
1628 try renderExpression(allocator, stream, tree, switch_node.expr, Space.None);
1629 try renderToken(tree, stream, rparen, Space.Space); // )
1627 try renderExpression(allocator, ais, tree, switch_node.expr, Space.None);
1628 try renderToken(tree, ais, rparen, Space.Space); // )
16301629
16311630 {
1632 stream.pushIndentNextLine();
1633 defer stream.popIndent();
1634 try renderToken(tree, stream, lbrace, Space.Newline); // {
1631 ais.pushIndentNextLine();
1632 defer ais.popIndent();
1633 try renderToken(tree, ais, lbrace, Space.Newline); // {
16351634
16361635 const cases = switch_node.cases();
16371636 for (cases) |node, i| {
1638 try renderExpression(allocator, stream, tree, node, Space.Comma);
1637 try renderExpression(allocator, ais, tree, node, Space.Comma);
16391638
16401639 if (i + 1 < cases.len) {
1641 try renderExtraNewline(tree, stream, cases[i + 1]);
1640 try renderExtraNewline(tree, ais, cases[i + 1]);
16421641 }
16431642 }
16441643 }
16451644
1646 return renderToken(tree, stream, switch_node.rbrace, space); // }
1645 return renderToken(tree, ais, switch_node.rbrace, space); // }
16471646 },
16481647
16491648 .SwitchCase => {
......@@ -1660,41 +1659,41 @@ fn renderExpression(
16601659 const items = switch_case.items();
16611660 for (items) |node, i| {
16621661 if (i + 1 < items.len) {
1663 try renderExpression(allocator, stream, tree, node, Space.None);
1662 try renderExpression(allocator, ais, tree, node, Space.None);
16641663
16651664 const comma_token = tree.nextToken(node.lastToken());
1666 try renderToken(tree, stream, comma_token, Space.Space); // ,
1667 try renderExtraNewline(tree, stream, items[i + 1]);
1665 try renderToken(tree, ais, comma_token, Space.Space); // ,
1666 try renderExtraNewline(tree, ais, items[i + 1]);
16681667 } else {
1669 try renderExpression(allocator, stream, tree, node, Space.Space);
1668 try renderExpression(allocator, ais, tree, node, Space.Space);
16701669 }
16711670 }
16721671 } else {
16731672 const items = switch_case.items();
16741673 for (items) |node, i| {
16751674 if (i + 1 < items.len) {
1676 try renderExpression(allocator, stream, tree, node, Space.None);
1675 try renderExpression(allocator, ais, tree, node, Space.None);
16771676
16781677 const comma_token = tree.nextToken(node.lastToken());
1679 try renderToken(tree, stream, comma_token, Space.Newline); // ,
1680 try renderExtraNewline(tree, stream, items[i + 1]);
1678 try renderToken(tree, ais, comma_token, Space.Newline); // ,
1679 try renderExtraNewline(tree, ais, items[i + 1]);
16811680 } else {
1682 try renderExpression(allocator, stream, tree, node, Space.Comma);
1681 try renderExpression(allocator, ais, tree, node, Space.Comma);
16831682 }
16841683 }
16851684 }
16861685
1687 try renderToken(tree, stream, switch_case.arrow_token, Space.Space); // =>
1686 try renderToken(tree, ais, switch_case.arrow_token, Space.Space); // =>
16881687
16891688 if (switch_case.payload) |payload| {
1690 try renderExpression(allocator, stream, tree, payload, Space.Space);
1689 try renderExpression(allocator, ais, tree, payload, Space.Space);
16911690 }
16921691
1693 return renderExpression(allocator, stream, tree, switch_case.expr, space);
1692 return renderExpression(allocator, ais, tree, switch_case.expr, space);
16941693 },
16951694 .SwitchElse => {
16961695 const switch_else = @fieldParentPtr(ast.Node.SwitchElse, "base", base);
1697 return renderToken(tree, stream, switch_else.token, space);
1696 return renderToken(tree, ais, switch_else.token, space);
16981697 },
16991698 .Else => {
17001699 const else_node = @fieldParentPtr(ast.Node.Else, "base", base);
......@@ -1703,19 +1702,19 @@ fn renderExpression(
17031702 const same_line = body_is_block or tree.tokensOnSameLine(else_node.else_token, else_node.body.lastToken());
17041703
17051704 const after_else_space = if (same_line or else_node.payload != null) Space.Space else Space.Newline;
1706 try renderToken(tree, stream, else_node.else_token, after_else_space);
1705 try renderToken(tree, ais, else_node.else_token, after_else_space);
17071706
17081707 if (else_node.payload) |payload| {
17091708 const payload_space = if (same_line) Space.Space else Space.Newline;
1710 try renderExpression(allocator, stream, tree, payload, payload_space);
1709 try renderExpression(allocator, ais, tree, payload, payload_space);
17111710 }
17121711
17131712 if (same_line) {
1714 return renderExpression(allocator, stream, tree, else_node.body, space);
1713 return renderExpression(allocator, ais, tree, else_node.body, space);
17151714 } else {
1716 stream.pushIndent();
1717 defer stream.popIndent();
1718 return renderExpression(allocator, stream, tree, else_node.body, space);
1715 ais.pushIndent();
1716 defer ais.popIndent();
1717 return renderExpression(allocator, ais, tree, else_node.body, space);
17191718 }
17201719 },
17211720
......@@ -1723,17 +1722,17 @@ fn renderExpression(
17231722 const while_node = @fieldParentPtr(ast.Node.While, "base", base);
17241723
17251724 if (while_node.label) |label| {
1726 try renderToken(tree, stream, label, Space.None); // label
1727 try renderToken(tree, stream, tree.nextToken(label), Space.Space); // :
1725 try renderToken(tree, ais, label, Space.None); // label
1726 try renderToken(tree, ais, tree.nextToken(label), Space.Space); // :
17281727 }
17291728
17301729 if (while_node.inline_token) |inline_token| {
1731 try renderToken(tree, stream, inline_token, Space.Space); // inline
1730 try renderToken(tree, ais, inline_token, Space.Space); // inline
17321731 }
17331732
1734 try renderToken(tree, stream, while_node.while_token, Space.Space); // while
1735 try renderToken(tree, stream, tree.nextToken(while_node.while_token), Space.None); // (
1736 try renderExpression(allocator, stream, tree, while_node.condition, Space.None);
1733 try renderToken(tree, ais, while_node.while_token, Space.Space); // while
1734 try renderToken(tree, ais, tree.nextToken(while_node.while_token), Space.None); // (
1735 try renderExpression(allocator, ais, tree, while_node.condition, Space.None);
17371736
17381737 const cond_rparen = tree.nextToken(while_node.condition.lastToken());
17391738
......@@ -1755,12 +1754,12 @@ fn renderExpression(
17551754
17561755 {
17571756 const rparen_space = if (while_node.payload != null or while_node.continue_expr != null) Space.Space else block_start_space;
1758 try renderToken(tree, stream, cond_rparen, rparen_space); // )
1757 try renderToken(tree, ais, cond_rparen, rparen_space); // )
17591758 }
17601759
17611760 if (while_node.payload) |payload| {
17621761 const payload_space = Space.Space; //if (while_node.continue_expr != null) Space.Space else block_start_space;
1763 try renderExpression(allocator, stream, tree, payload, payload_space);
1762 try renderExpression(allocator, ais, tree, payload, payload_space);
17641763 }
17651764
17661765 if (while_node.continue_expr) |continue_expr| {
......@@ -1768,22 +1767,22 @@ fn renderExpression(
17681767 const lparen = tree.prevToken(continue_expr.firstToken());
17691768 const colon = tree.prevToken(lparen);
17701769
1771 try renderToken(tree, stream, colon, Space.Space); // :
1772 try renderToken(tree, stream, lparen, Space.None); // (
1770 try renderToken(tree, ais, colon, Space.Space); // :
1771 try renderToken(tree, ais, lparen, Space.None); // (
17731772
1774 try renderExpression(allocator, stream, tree, continue_expr, Space.None);
1773 try renderExpression(allocator, ais, tree, continue_expr, Space.None);
17751774
1776 try renderToken(tree, stream, rparen, block_start_space); // )
1775 try renderToken(tree, ais, rparen, block_start_space); // )
17771776 }
17781777
17791778 {
1780 if (!body_is_block) stream.pushIndent();
1781 defer if (!body_is_block) stream.popIndent();
1782 try renderExpression(allocator, stream, tree, while_node.body, after_body_space);
1779 if (!body_is_block) ais.pushIndent();
1780 defer if (!body_is_block) ais.popIndent();
1781 try renderExpression(allocator, ais, tree, while_node.body, after_body_space);
17831782 }
17841783
17851784 if (while_node.@"else") |@"else"| {
1786 return renderExpression(allocator, stream, tree, &@"else".base, space);
1785 return renderExpression(allocator, ais, tree, &@"else".base, space);
17871786 }
17881787 },
17891788
......@@ -1791,17 +1790,17 @@ fn renderExpression(
17911790 const for_node = @fieldParentPtr(ast.Node.For, "base", base);
17921791
17931792 if (for_node.label) |label| {
1794 try renderToken(tree, stream, label, Space.None); // label
1795 try renderToken(tree, stream, tree.nextToken(label), Space.Space); // :
1793 try renderToken(tree, ais, label, Space.None); // label
1794 try renderToken(tree, ais, tree.nextToken(label), Space.Space); // :
17961795 }
17971796
17981797 if (for_node.inline_token) |inline_token| {
1799 try renderToken(tree, stream, inline_token, Space.Space); // inline
1798 try renderToken(tree, ais, inline_token, Space.Space); // inline
18001799 }
18011800
1802 try renderToken(tree, stream, for_node.for_token, Space.Space); // for
1803 try renderToken(tree, stream, tree.nextToken(for_node.for_token), Space.None); // (
1804 try renderExpression(allocator, stream, tree, for_node.array_expr, Space.None);
1801 try renderToken(tree, ais, for_node.for_token, Space.Space); // for
1802 try renderToken(tree, ais, tree.nextToken(for_node.for_token), Space.None); // (
1803 try renderExpression(allocator, ais, tree, for_node.array_expr, Space.None);
18051804
18061805 const rparen = tree.nextToken(for_node.array_expr.lastToken());
18071806
......@@ -1809,10 +1808,10 @@ fn renderExpression(
18091808 const src_one_line_to_body = !body_is_block and tree.tokensOnSameLine(rparen, for_node.body.firstToken());
18101809 const body_on_same_line = body_is_block or src_one_line_to_body;
18111810
1812 try renderToken(tree, stream, rparen, Space.Space); // )
1811 try renderToken(tree, ais, rparen, Space.Space); // )
18131812
18141813 const space_after_payload = if (body_on_same_line) Space.Space else Space.Newline;
1815 try renderExpression(allocator, stream, tree, for_node.payload, space_after_payload); // |x|
1814 try renderExpression(allocator, ais, tree, for_node.payload, space_after_payload); // |x|
18161815
18171816 const space_after_body = blk: {
18181817 if (for_node.@"else") |@"else"| {
......@@ -1828,13 +1827,13 @@ fn renderExpression(
18281827 };
18291828
18301829 {
1831 if (!body_on_same_line) stream.pushIndent();
1832 defer if (!body_on_same_line) stream.popIndent();
1833 try renderExpression(allocator, stream, tree, for_node.body, space_after_body); // { body }
1830 if (!body_on_same_line) ais.pushIndent();
1831 defer if (!body_on_same_line) ais.popIndent();
1832 try renderExpression(allocator, ais, tree, for_node.body, space_after_body); // { body }
18341833 }
18351834
18361835 if (for_node.@"else") |@"else"| {
1837 return renderExpression(allocator, stream, tree, &@"else".base, space); // else
1836 return renderExpression(allocator, ais, tree, &@"else".base, space); // else
18381837 }
18391838 },
18401839
......@@ -1844,29 +1843,29 @@ fn renderExpression(
18441843 const lparen = tree.nextToken(if_node.if_token);
18451844 const rparen = tree.nextToken(if_node.condition.lastToken());
18461845
1847 try renderToken(tree, stream, if_node.if_token, Space.Space); // if
1848 try renderToken(tree, stream, lparen, Space.None); // (
1846 try renderToken(tree, ais, if_node.if_token, Space.Space); // if
1847 try renderToken(tree, ais, lparen, Space.None); // (
18491848
1850 try renderExpression(allocator, stream, tree, if_node.condition, Space.None); // condition
1849 try renderExpression(allocator, ais, tree, if_node.condition, Space.None); // condition
18511850
18521851 const body_is_if_block = if_node.body.tag == .If;
18531852 const body_is_block = nodeIsBlock(if_node.body);
18541853
18551854 if (body_is_if_block) {
1856 try renderExtraNewline(tree, stream, if_node.body);
1855 try renderExtraNewline(tree, ais, if_node.body);
18571856 } else if (body_is_block) {
18581857 const after_rparen_space = if (if_node.payload == null) Space.BlockStart else Space.Space;
1859 try renderToken(tree, stream, rparen, after_rparen_space); // )
1858 try renderToken(tree, ais, rparen, after_rparen_space); // )
18601859
18611860 if (if_node.payload) |payload| {
1862 try renderExpression(allocator, stream, tree, payload, Space.BlockStart); // |x|
1861 try renderExpression(allocator, ais, tree, payload, Space.BlockStart); // |x|
18631862 }
18641863
18651864 if (if_node.@"else") |@"else"| {
1866 try renderExpression(allocator, stream, tree, if_node.body, Space.SpaceOrOutdent);
1867 return renderExpression(allocator, stream, tree, &@"else".base, space);
1865 try renderExpression(allocator, ais, tree, if_node.body, Space.SpaceOrOutdent);
1866 return renderExpression(allocator, ais, tree, &@"else".base, space);
18681867 } else {
1869 return renderExpression(allocator, stream, tree, if_node.body, space);
1868 return renderExpression(allocator, ais, tree, if_node.body, space);
18701869 }
18711870 }
18721871
......@@ -1874,121 +1873,121 @@ fn renderExpression(
18741873
18751874 if (src_has_newline) {
18761875 const after_rparen_space = if (if_node.payload == null) Space.Newline else Space.Space;
1877 try renderToken(tree, stream, rparen, after_rparen_space); // )
1876 try renderToken(tree, ais, rparen, after_rparen_space); // )
18781877
18791878 if (if_node.payload) |payload| {
1880 try renderExpression(allocator, stream, tree, payload, Space.Newline);
1879 try renderExpression(allocator, ais, tree, payload, Space.Newline);
18811880 }
18821881
18831882 if (if_node.@"else") |@"else"| {
18841883 const else_is_block = nodeIsBlock(@"else".body);
18851884
18861885 {
1887 stream.pushIndent();
1888 defer stream.popIndent();
1889 try renderExpression(allocator, stream, tree, if_node.body, Space.Newline);
1886 ais.pushIndent();
1887 defer ais.popIndent();
1888 try renderExpression(allocator, ais, tree, if_node.body, Space.Newline);
18901889 }
18911890
18921891 if (else_is_block) {
1893 try renderToken(tree, stream, @"else".else_token, Space.Space); // else
1892 try renderToken(tree, ais, @"else".else_token, Space.Space); // else
18941893
18951894 if (@"else".payload) |payload| {
1896 try renderExpression(allocator, stream, tree, payload, Space.Space);
1895 try renderExpression(allocator, ais, tree, payload, Space.Space);
18971896 }
18981897
1899 return renderExpression(allocator, stream, tree, @"else".body, space);
1898 return renderExpression(allocator, ais, tree, @"else".body, space);
19001899 } else {
19011900 const after_else_space = if (@"else".payload == null) Space.Newline else Space.Space;
1902 try renderToken(tree, stream, @"else".else_token, after_else_space); // else
1901 try renderToken(tree, ais, @"else".else_token, after_else_space); // else
19031902
19041903 if (@"else".payload) |payload| {
1905 try renderExpression(allocator, stream, tree, payload, Space.Newline);
1904 try renderExpression(allocator, ais, tree, payload, Space.Newline);
19061905 }
19071906
1908 stream.pushIndent();
1909 defer stream.popIndent();
1910 return renderExpression(allocator, stream, tree, @"else".body, space);
1907 ais.pushIndent();
1908 defer ais.popIndent();
1909 return renderExpression(allocator, ais, tree, @"else".body, space);
19111910 }
19121911 } else {
1913 stream.pushIndent();
1914 defer stream.popIndent();
1915 return renderExpression(allocator, stream, tree, if_node.body, space);
1912 ais.pushIndent();
1913 defer ais.popIndent();
1914 return renderExpression(allocator, ais, tree, if_node.body, space);
19161915 }
19171916 }
19181917
19191918 // Single line if statement
19201919
1921 try renderToken(tree, stream, rparen, Space.Space); // )
1920 try renderToken(tree, ais, rparen, Space.Space); // )
19221921
19231922 if (if_node.payload) |payload| {
1924 try renderExpression(allocator, stream, tree, payload, Space.Space);
1923 try renderExpression(allocator, ais, tree, payload, Space.Space);
19251924 }
19261925
19271926 if (if_node.@"else") |@"else"| {
1928 try renderExpression(allocator, stream, tree, if_node.body, Space.Space);
1929 try renderToken(tree, stream, @"else".else_token, Space.Space);
1927 try renderExpression(allocator, ais, tree, if_node.body, Space.Space);
1928 try renderToken(tree, ais, @"else".else_token, Space.Space);
19301929
19311930 if (@"else".payload) |payload| {
1932 try renderExpression(allocator, stream, tree, payload, Space.Space);
1931 try renderExpression(allocator, ais, tree, payload, Space.Space);
19331932 }
19341933
1935 return renderExpression(allocator, stream, tree, @"else".body, space);
1934 return renderExpression(allocator, ais, tree, @"else".body, space);
19361935 } else {
1937 return renderExpression(allocator, stream, tree, if_node.body, space);
1936 return renderExpression(allocator, ais, tree, if_node.body, space);
19381937 }
19391938 },
19401939
19411940 .Asm => {
19421941 const asm_node = @fieldParentPtr(ast.Node.Asm, "base", base);
19431942
1944 try renderToken(tree, stream, asm_node.asm_token, Space.Space); // asm
1943 try renderToken(tree, ais, asm_node.asm_token, Space.Space); // asm
19451944
19461945 if (asm_node.volatile_token) |volatile_token| {
1947 try renderToken(tree, stream, volatile_token, Space.Space); // volatile
1948 try renderToken(tree, stream, tree.nextToken(volatile_token), Space.None); // (
1946 try renderToken(tree, ais, volatile_token, Space.Space); // volatile
1947 try renderToken(tree, ais, tree.nextToken(volatile_token), Space.None); // (
19491948 } else {
1950 try renderToken(tree, stream, tree.nextToken(asm_node.asm_token), Space.None); // (
1949 try renderToken(tree, ais, tree.nextToken(asm_node.asm_token), Space.None); // (
19511950 }
19521951
19531952 asmblk: {
1954 stream.pushIndent();
1955 defer stream.popIndent();
1953 ais.pushIndent();
1954 defer ais.popIndent();
19561955
19571956 if (asm_node.outputs.len == 0 and asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
1958 try renderExpression(allocator, stream, tree, asm_node.template, Space.None);
1957 try renderExpression(allocator, ais, tree, asm_node.template, Space.None);
19591958 break :asmblk;
19601959 }
19611960
1962 try renderExpression(allocator, stream, tree, asm_node.template, Space.Newline);
1961 try renderExpression(allocator, ais, tree, asm_node.template, Space.Newline);
19631962
1964 stream.setIndentDelta(asm_indent_delta);
1965 defer stream.setIndentDelta(indent_delta);
1963 ais.setIndentDelta(asm_indent_delta);
1964 defer ais.setIndentDelta(indent_delta);
19661965
19671966 const colon1 = tree.nextToken(asm_node.template.lastToken());
19681967
19691968 const colon2 = if (asm_node.outputs.len == 0) blk: {
1970 try renderToken(tree, stream, colon1, Space.Newline); // :
1969 try renderToken(tree, ais, colon1, Space.Newline); // :
19711970
19721971 break :blk tree.nextToken(colon1);
19731972 } else blk: {
1974 try renderToken(tree, stream, colon1, Space.Space); // :
1973 try renderToken(tree, ais, colon1, Space.Space); // :
19751974
1976 stream.pushIndent();
1977 defer stream.popIndent();
1975 ais.pushIndent();
1976 defer ais.popIndent();
19781977
19791978 for (asm_node.outputs) |*asm_output, i| {
19801979 if (i + 1 < asm_node.outputs.len) {
19811980 const next_asm_output = asm_node.outputs[i + 1];
1982 try renderAsmOutput(allocator, stream, tree, asm_output, Space.None);
1981 try renderAsmOutput(allocator, ais, tree, asm_output, Space.None);
19831982
19841983 const comma = tree.prevToken(next_asm_output.firstToken());
1985 try renderToken(tree, stream, comma, Space.Newline); // ,
1986 try renderExtraNewlineToken(tree, stream, next_asm_output.firstToken());
1984 try renderToken(tree, ais, comma, Space.Newline); // ,
1985 try renderExtraNewlineToken(tree, ais, next_asm_output.firstToken());
19871986 } else if (asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
1988 try renderAsmOutput(allocator, stream, tree, asm_output, Space.Newline);
1987 try renderAsmOutput(allocator, ais, tree, asm_output, Space.Newline);
19891988 break :asmblk;
19901989 } else {
1991 try renderAsmOutput(allocator, stream, tree, asm_output, Space.Newline);
1990 try renderAsmOutput(allocator, ais, tree, asm_output, Space.Newline);
19921991 const comma_or_colon = tree.nextToken(asm_output.lastToken());
19931992 break :blk switch (tree.token_ids[comma_or_colon]) {
19941993 .Comma => tree.nextToken(comma_or_colon),
......@@ -2000,25 +1999,25 @@ fn renderExpression(
20001999 };
20012000
20022001 const colon3 = if (asm_node.inputs.len == 0) blk: {
2003 try renderToken(tree, stream, colon2, Space.Newline); // :
2002 try renderToken(tree, ais, colon2, Space.Newline); // :
20042003 break :blk tree.nextToken(colon2);
20052004 } else blk: {
2006 try renderToken(tree, stream, colon2, Space.Space); // :
2007 stream.pushIndent();
2008 defer stream.popIndent();
2005 try renderToken(tree, ais, colon2, Space.Space); // :
2006 ais.pushIndent();
2007 defer ais.popIndent();
20092008 for (asm_node.inputs) |*asm_input, i| {
20102009 if (i + 1 < asm_node.inputs.len) {
20112010 const next_asm_input = &asm_node.inputs[i + 1];
2012 try renderAsmInput(allocator, stream, tree, asm_input, Space.None);
2011 try renderAsmInput(allocator, ais, tree, asm_input, Space.None);
20132012
20142013 const comma = tree.prevToken(next_asm_input.firstToken());
2015 try renderToken(tree, stream, comma, Space.Newline); // ,
2016 try renderExtraNewlineToken(tree, stream, next_asm_input.firstToken());
2014 try renderToken(tree, ais, comma, Space.Newline); // ,
2015 try renderExtraNewlineToken(tree, ais, next_asm_input.firstToken());
20172016 } else if (asm_node.clobbers.len == 0) {
2018 try renderAsmInput(allocator, stream, tree, asm_input, Space.Newline);
2017 try renderAsmInput(allocator, ais, tree, asm_input, Space.Newline);
20192018 break :asmblk;
20202019 } else {
2021 try renderAsmInput(allocator, stream, tree, asm_input, Space.Newline);
2020 try renderAsmInput(allocator, ais, tree, asm_input, Space.Newline);
20222021 const comma_or_colon = tree.nextToken(asm_input.lastToken());
20232022 break :blk switch (tree.token_ids[comma_or_colon]) {
20242023 .Comma => tree.nextToken(comma_or_colon),
......@@ -2029,29 +2028,29 @@ fn renderExpression(
20292028 unreachable;
20302029 };
20312030
2032 try renderToken(tree, stream, colon3, Space.Space); // :
2033 stream.pushIndent();
2034 defer stream.popIndent();
2031 try renderToken(tree, ais, colon3, Space.Space); // :
2032 ais.pushIndent();
2033 defer ais.popIndent();
20352034 for (asm_node.clobbers) |clobber_node, i| {
20362035 if (i + 1 >= asm_node.clobbers.len) {
2037 try renderExpression(allocator, stream, tree, clobber_node, Space.Newline);
2036 try renderExpression(allocator, ais, tree, clobber_node, Space.Newline);
20382037 break :asmblk;
20392038 } else {
2040 try renderExpression(allocator, stream, tree, clobber_node, Space.None);
2039 try renderExpression(allocator, ais, tree, clobber_node, Space.None);
20412040 const comma = tree.nextToken(clobber_node.lastToken());
2042 try renderToken(tree, stream, comma, Space.Space); // ,
2041 try renderToken(tree, ais, comma, Space.Space); // ,
20432042 }
20442043 }
20452044 }
20462045
2047 return renderToken(tree, stream, asm_node.rparen, space);
2046 return renderToken(tree, ais, asm_node.rparen, space);
20482047 },
20492048
20502049 .EnumLiteral => {
20512050 const enum_literal = @fieldParentPtr(ast.Node.EnumLiteral, "base", base);
20522051
2053 try renderToken(tree, stream, enum_literal.dot, Space.None); // .
2054 return renderToken(tree, stream, enum_literal.name, space); // name
2052 try renderToken(tree, ais, enum_literal.dot, Space.None); // .
2053 return renderToken(tree, ais, enum_literal.name, space); // name
20552054 },
20562055
20572056 .ContainerField,
......@@ -2065,14 +2064,14 @@ fn renderExpression(
20652064
20662065fn renderArrayType(
20672066 allocator: *mem.Allocator,
2068 stream: anytype,
2067 ais: anytype,
20692068 tree: *ast.Tree,
20702069 lbracket: ast.TokenIndex,
20712070 rhs: *ast.Node,
20722071 len_expr: *ast.Node,
20732072 opt_sentinel: ?*ast.Node,
20742073 space: Space,
2075) (@TypeOf(stream.*).Error || Error)!void {
2074) (@TypeOf(ais.*).Error || Error)!void {
20762075 const rbracket = tree.nextToken(if (opt_sentinel) |sentinel|
20772076 sentinel.lastToken()
20782077 else
......@@ -2083,97 +2082,97 @@ fn renderArrayType(
20832082 const new_space = if (ends_with_comment) Space.Newline else Space.None;
20842083 {
20852084 const do_indent = (starts_with_comment or ends_with_comment);
2086 if (do_indent) stream.pushIndent();
2087 defer if (do_indent) stream.popIndent();
2085 if (do_indent) ais.pushIndent();
2086 defer if (do_indent) ais.popIndent();
20882087
2089 try renderToken(tree, stream, lbracket, Space.None); // [
2090 try renderExpression(allocator, stream, tree, len_expr, new_space);
2088 try renderToken(tree, ais, lbracket, Space.None); // [
2089 try renderExpression(allocator, ais, tree, len_expr, new_space);
20912090
20922091 if (starts_with_comment) {
2093 try stream.maybeInsertNewline();
2092 try ais.maybeInsertNewline();
20942093 }
20952094 if (opt_sentinel) |sentinel| {
20962095 const colon_token = tree.prevToken(sentinel.firstToken());
2097 try renderToken(tree, stream, colon_token, Space.None); // :
2098 try renderExpression(allocator, stream, tree, sentinel, Space.None);
2096 try renderToken(tree, ais, colon_token, Space.None); // :
2097 try renderExpression(allocator, ais, tree, sentinel, Space.None);
20992098 }
21002099 if (starts_with_comment) {
2101 try stream.maybeInsertNewline();
2100 try ais.maybeInsertNewline();
21022101 }
21032102 }
2104 try renderToken(tree, stream, rbracket, Space.None); // ]
2103 try renderToken(tree, ais, rbracket, Space.None); // ]
21052104
2106 return renderExpression(allocator, stream, tree, rhs, space);
2105 return renderExpression(allocator, ais, tree, rhs, space);
21072106}
21082107
21092108fn renderAsmOutput(
21102109 allocator: *mem.Allocator,
2111 stream: anytype,
2110 ais: anytype,
21122111 tree: *ast.Tree,
21132112 asm_output: *const ast.Node.Asm.Output,
21142113 space: Space,
2115) (@TypeOf(stream.*).Error || Error)!void {
2116 try stream.writer().writeAll("[");
2117 try renderExpression(allocator, stream, tree, asm_output.symbolic_name, Space.None);
2118 try stream.writer().writeAll("] ");
2119 try renderExpression(allocator, stream, tree, asm_output.constraint, Space.None);
2120 try stream.writer().writeAll(" (");
2114) (@TypeOf(ais.*).Error || Error)!void {
2115 try ais.writer().writeAll("[");
2116 try renderExpression(allocator, ais, tree, asm_output.symbolic_name, Space.None);
2117 try ais.writer().writeAll("] ");
2118 try renderExpression(allocator, ais, tree, asm_output.constraint, Space.None);
2119 try ais.writer().writeAll(" (");
21212120
21222121 switch (asm_output.kind) {
21232122 ast.Node.Asm.Output.Kind.Variable => |variable_name| {
2124 try renderExpression(allocator, stream, tree, &variable_name.base, Space.None);
2123 try renderExpression(allocator, ais, tree, &variable_name.base, Space.None);
21252124 },
21262125 ast.Node.Asm.Output.Kind.Return => |return_type| {
2127 try stream.writer().writeAll("-> ");
2128 try renderExpression(allocator, stream, tree, return_type, Space.None);
2126 try ais.writer().writeAll("-> ");
2127 try renderExpression(allocator, ais, tree, return_type, Space.None);
21292128 },
21302129 }
21312130
2132 return renderToken(tree, stream, asm_output.lastToken(), space); // )
2131 return renderToken(tree, ais, asm_output.lastToken(), space); // )
21332132}
21342133
21352134fn renderAsmInput(
21362135 allocator: *mem.Allocator,
2137 stream: anytype,
2136 ais: anytype,
21382137 tree: *ast.Tree,
21392138 asm_input: *const ast.Node.Asm.Input,
21402139 space: Space,
2141) (@TypeOf(stream.*).Error || Error)!void {
2142 try stream.writer().writeAll("[");
2143 try renderExpression(allocator, stream, tree, asm_input.symbolic_name, Space.None);
2144 try stream.writer().writeAll("] ");
2145 try renderExpression(allocator, stream, tree, asm_input.constraint, Space.None);
2146 try stream.writer().writeAll(" (");
2147 try renderExpression(allocator, stream, tree, asm_input.expr, Space.None);
2148 return renderToken(tree, stream, asm_input.lastToken(), space); // )
2140) (@TypeOf(ais.*).Error || Error)!void {
2141 try ais.writer().writeAll("[");
2142 try renderExpression(allocator, ais, tree, asm_input.symbolic_name, Space.None);
2143 try ais.writer().writeAll("] ");
2144 try renderExpression(allocator, ais, tree, asm_input.constraint, Space.None);
2145 try ais.writer().writeAll(" (");
2146 try renderExpression(allocator, ais, tree, asm_input.expr, Space.None);
2147 return renderToken(tree, ais, asm_input.lastToken(), space); // )
21492148}
21502149
21512150fn renderVarDecl(
21522151 allocator: *mem.Allocator,
2153 stream: anytype,
2152 ais: anytype,
21542153 tree: *ast.Tree,
21552154 var_decl: *ast.Node.VarDecl,
2156) (@TypeOf(stream.*).Error || Error)!void {
2155) (@TypeOf(ais.*).Error || Error)!void {
21572156 if (var_decl.getVisibToken()) |visib_token| {
2158 try renderToken(tree, stream, visib_token, Space.Space); // pub
2157 try renderToken(tree, ais, visib_token, Space.Space); // pub
21592158 }
21602159
21612160 if (var_decl.getExternExportToken()) |extern_export_token| {
2162 try renderToken(tree, stream, extern_export_token, Space.Space); // extern
2161 try renderToken(tree, ais, extern_export_token, Space.Space); // extern
21632162
21642163 if (var_decl.getLibName()) |lib_name| {
2165 try renderExpression(allocator, stream, tree, lib_name, Space.Space); // "lib"
2164 try renderExpression(allocator, ais, tree, lib_name, Space.Space); // "lib"
21662165 }
21672166 }
21682167
21692168 if (var_decl.getComptimeToken()) |comptime_token| {
2170 try renderToken(tree, stream, comptime_token, Space.Space); // comptime
2169 try renderToken(tree, ais, comptime_token, Space.Space); // comptime
21712170 }
21722171
21732172 if (var_decl.getThreadLocalToken()) |thread_local_token| {
2174 try renderToken(tree, stream, thread_local_token, Space.Space); // threadlocal
2173 try renderToken(tree, ais, thread_local_token, Space.Space); // threadlocal
21752174 }
2176 try renderToken(tree, stream, var_decl.mut_token, Space.Space); // var
2175 try renderToken(tree, ais, var_decl.mut_token, Space.Space); // var
21772176
21782177 const name_space = if (var_decl.getTypeNode() == null and
21792178 (var_decl.getAlignNode() != null or
......@@ -2182,92 +2181,92 @@ fn renderVarDecl(
21822181 Space.Space
21832182 else
21842183 Space.None;
2185 try renderToken(tree, stream, var_decl.name_token, name_space);
2184 try renderToken(tree, ais, var_decl.name_token, name_space);
21862185
21872186 if (var_decl.getTypeNode()) |type_node| {
2188 try renderToken(tree, stream, tree.nextToken(var_decl.name_token), Space.Space);
2187 try renderToken(tree, ais, tree.nextToken(var_decl.name_token), Space.Space);
21892188 const s = if (var_decl.getAlignNode() != null or
21902189 var_decl.getSectionNode() != null or
21912190 var_decl.getInitNode() != null) Space.Space else Space.None;
2192 try renderExpression(allocator, stream, tree, type_node, s);
2191 try renderExpression(allocator, ais, tree, type_node, s);
21932192 }
21942193
21952194 if (var_decl.getAlignNode()) |align_node| {
21962195 const lparen = tree.prevToken(align_node.firstToken());
21972196 const align_kw = tree.prevToken(lparen);
21982197 const rparen = tree.nextToken(align_node.lastToken());
2199 try renderToken(tree, stream, align_kw, Space.None); // align
2200 try renderToken(tree, stream, lparen, Space.None); // (
2201 try renderExpression(allocator, stream, tree, align_node, Space.None);
2198 try renderToken(tree, ais, align_kw, Space.None); // align
2199 try renderToken(tree, ais, lparen, Space.None); // (
2200 try renderExpression(allocator, ais, tree, align_node, Space.None);
22022201 const s = if (var_decl.getSectionNode() != null or var_decl.getInitNode() != null) Space.Space else Space.None;
2203 try renderToken(tree, stream, rparen, s); // )
2202 try renderToken(tree, ais, rparen, s); // )
22042203 }
22052204
22062205 if (var_decl.getSectionNode()) |section_node| {
22072206 const lparen = tree.prevToken(section_node.firstToken());
22082207 const section_kw = tree.prevToken(lparen);
22092208 const rparen = tree.nextToken(section_node.lastToken());
2210 try renderToken(tree, stream, section_kw, Space.None); // linksection
2211 try renderToken(tree, stream, lparen, Space.None); // (
2212 try renderExpression(allocator, stream, tree, section_node, Space.None);
2209 try renderToken(tree, ais, section_kw, Space.None); // linksection
2210 try renderToken(tree, ais, lparen, Space.None); // (
2211 try renderExpression(allocator, ais, tree, section_node, Space.None);
22132212 const s = if (var_decl.getInitNode() != null) Space.Space else Space.None;
2214 try renderToken(tree, stream, rparen, s); // )
2213 try renderToken(tree, ais, rparen, s); // )
22152214 }
22162215
22172216 if (var_decl.getInitNode()) |init_node| {
22182217 const s = if (init_node.tag == .MultilineStringLiteral) Space.None else Space.Space;
2219 try renderToken(tree, stream, var_decl.getEqToken().?, s); // =
2220 stream.pushIndentOneShot();
2221 try renderExpression(allocator, stream, tree, init_node, Space.None);
2218 try renderToken(tree, ais, var_decl.getEqToken().?, s); // =
2219 ais.pushIndentOneShot();
2220 try renderExpression(allocator, ais, tree, init_node, Space.None);
22222221 }
22232222
2224 try renderToken(tree, stream, var_decl.semicolon_token, Space.Newline);
2223 try renderToken(tree, ais, var_decl.semicolon_token, Space.Newline);
22252224}
22262225
22272226fn renderParamDecl(
22282227 allocator: *mem.Allocator,
2229 stream: anytype,
2228 ais: anytype,
22302229 tree: *ast.Tree,
22312230 param_decl: ast.Node.FnProto.ParamDecl,
22322231 space: Space,
2233) (@TypeOf(stream.*).Error || Error)!void {
2234 try renderDocComments(tree, stream, param_decl, param_decl.doc_comments);
2232) (@TypeOf(ais.*).Error || Error)!void {
2233 try renderDocComments(tree, ais, param_decl, param_decl.doc_comments);
22352234
22362235 if (param_decl.comptime_token) |comptime_token| {
2237 try renderToken(tree, stream, comptime_token, Space.Space);
2236 try renderToken(tree, ais, comptime_token, Space.Space);
22382237 }
22392238 if (param_decl.noalias_token) |noalias_token| {
2240 try renderToken(tree, stream, noalias_token, Space.Space);
2239 try renderToken(tree, ais, noalias_token, Space.Space);
22412240 }
22422241 if (param_decl.name_token) |name_token| {
2243 try renderToken(tree, stream, name_token, Space.None);
2244 try renderToken(tree, stream, tree.nextToken(name_token), Space.Space); // :
2242 try renderToken(tree, ais, name_token, Space.None);
2243 try renderToken(tree, ais, tree.nextToken(name_token), Space.Space); // :
22452244 }
22462245 switch (param_decl.param_type) {
2247 .any_type, .type_expr => |node| try renderExpression(allocator, stream, tree, node, space),
2246 .any_type, .type_expr => |node| try renderExpression(allocator, ais, tree, node, space),
22482247 }
22492248}
22502249
22512250fn renderStatement(
22522251 allocator: *mem.Allocator,
2253 stream: anytype,
2252 ais: anytype,
22542253 tree: *ast.Tree,
22552254 base: *ast.Node,
2256) (@TypeOf(stream.*).Error || Error)!void {
2255) (@TypeOf(ais.*).Error || Error)!void {
22572256 switch (base.tag) {
22582257 .VarDecl => {
22592258 const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", base);
2260 try renderVarDecl(allocator, stream, tree, var_decl);
2259 try renderVarDecl(allocator, ais, tree, var_decl);
22612260 },
22622261 else => {
22632262 if (base.requireSemiColon()) {
2264 try renderExpression(allocator, stream, tree, base, Space.None);
2263 try renderExpression(allocator, ais, tree, base, Space.None);
22652264
22662265 const semicolon_index = tree.nextToken(base.lastToken());
22672266 assert(tree.token_ids[semicolon_index] == .Semicolon);
2268 try renderToken(tree, stream, semicolon_index, Space.Newline);
2267 try renderToken(tree, ais, semicolon_index, Space.Newline);
22692268 } else {
2270 try renderExpression(allocator, stream, tree, base, Space.Newline);
2269 try renderExpression(allocator, ais, tree, base, Space.Newline);
22712270 }
22722271 },
22732272 }
......@@ -2286,19 +2285,19 @@ const Space = enum {
22862285
22872286fn renderTokenOffset(
22882287 tree: *ast.Tree,
2289 stream: anytype,
2288 ais: anytype,
22902289 token_index: ast.TokenIndex,
22912290 space: Space,
22922291 token_skip_bytes: usize,
2293) (@TypeOf(stream.*).Error || Error)!void {
2292) (@TypeOf(ais.*).Error || Error)!void {
22942293 if (space == Space.BlockStart) {
22952294 // If placing the lbrace on the current line would cause an uggly gap then put the lbrace on the next line
2296 const new_space = if (stream.isLineOverIndented()) Space.Newline else Space.Space;
2297 return renderToken(tree, stream, token_index, new_space);
2295 const new_space = if (ais.isLineOverIndented()) Space.Newline else Space.Space;
2296 return renderToken(tree, ais, token_index, new_space);
22982297 }
22992298
23002299 var token_loc = tree.token_locs[token_index];
2301 try stream.writer().writeAll(mem.trimRight(u8, tree.tokenSliceLoc(token_loc)[token_skip_bytes..], " "));
2300 try ais.writer().writeAll(mem.trimRight(u8, tree.tokenSliceLoc(token_loc)[token_skip_bytes..], " "));
23022301
23032302 if (space == Space.NoComment)
23042303 return;
......@@ -2307,20 +2306,20 @@ fn renderTokenOffset(
23072306 var next_token_loc = tree.token_locs[token_index + 1];
23082307
23092308 if (space == Space.Comma) switch (next_token_id) {
2310 .Comma => return renderToken(tree, stream, token_index + 1, Space.Newline),
2309 .Comma => return renderToken(tree, ais, token_index + 1, Space.Newline),
23112310 .LineComment => {
2312 try stream.writer().writeAll(", ");
2313 return renderToken(tree, stream, token_index + 1, Space.Newline);
2311 try ais.writer().writeAll(", ");
2312 return renderToken(tree, ais, token_index + 1, Space.Newline);
23142313 },
23152314 else => {
23162315 if (token_index + 2 < tree.token_ids.len and
23172316 tree.token_ids[token_index + 2] == .MultilineStringLiteralLine)
23182317 {
2319 try stream.writer().writeAll(",");
2318 try ais.writer().writeAll(",");
23202319 return;
23212320 } else {
2322 try stream.writer().writeAll(",");
2323 try stream.insertNewline();
2321 try ais.writer().writeAll(",");
2322 try ais.insertNewline();
23242323 return;
23252324 }
23262325 },
......@@ -2344,14 +2343,14 @@ fn renderTokenOffset(
23442343 if (next_token_id == .MultilineStringLiteralLine) {
23452344 return;
23462345 } else {
2347 try stream.insertNewline();
2346 try ais.insertNewline();
23482347 return;
23492348 }
23502349 },
23512350 Space.Space, Space.SpaceOrOutdent => {
23522351 if (next_token_id == .MultilineStringLiteralLine)
23532352 return;
2354 try stream.writer().writeByte(' ');
2353 try ais.writer().writeByte(' ');
23552354 return;
23562355 },
23572356 Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
......@@ -2368,7 +2367,7 @@ fn renderTokenOffset(
23682367 next_token_id = tree.token_ids[token_index + offset];
23692368 next_token_loc = tree.token_locs[token_index + offset];
23702369 if (next_token_id != .LineComment) {
2371 try stream.insertNewline();
2370 try ais.insertNewline();
23722371 return;
23732372 }
23742373 },
......@@ -2381,7 +2380,7 @@ fn renderTokenOffset(
23812380
23822381 var loc = tree.tokenLocationLoc(token_loc.end, next_token_loc);
23832382 if (loc.line == 0) {
2384 try stream.writer().print(" {}", .{mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " ")});
2383 try ais.writer().print(" {}", .{mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " ")});
23852384 offset = 2;
23862385 token_loc = next_token_loc;
23872386 next_token_loc = tree.token_locs[token_index + offset];
......@@ -2389,16 +2388,16 @@ fn renderTokenOffset(
23892388 if (next_token_id != .LineComment) {
23902389 switch (space) {
23912390 Space.None, Space.Space => {
2392 try stream.insertNewline();
2391 try ais.insertNewline();
23932392 },
23942393 Space.SpaceOrOutdent => {
2395 try stream.insertNewline();
2394 try ais.insertNewline();
23962395 },
23972396 Space.Newline => {
23982397 if (next_token_id == .MultilineStringLiteralLine) {
23992398 return;
24002399 } else {
2401 try stream.insertNewline();
2400 try ais.insertNewline();
24022401 return;
24032402 }
24042403 },
......@@ -2415,8 +2414,8 @@ fn renderTokenOffset(
24152414 // in generated code (loc.line == 0) so treat that case
24162415 // as though there was meant to be a newline between the tokens
24172416 var newline_count = if (loc.line <= 1) @as(u8, 1) else @as(u8, 2);
2418 while (newline_count > 0) : (newline_count -= 1) try stream.insertNewline();
2419 try stream.writer().writeAll(mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " "));
2417 while (newline_count > 0) : (newline_count -= 1) try ais.insertNewline();
2418 try ais.writer().writeAll(mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " "));
24202419
24212420 offset += 1;
24222421 token_loc = next_token_loc;
......@@ -2428,15 +2427,15 @@ fn renderTokenOffset(
24282427 if (next_token_id == .MultilineStringLiteralLine) {
24292428 return;
24302429 } else {
2431 try stream.insertNewline();
2430 try ais.insertNewline();
24322431 return;
24332432 }
24342433 },
24352434 Space.None, Space.Space => {
2436 try stream.insertNewline();
2435 try ais.insertNewline();
24372436 },
24382437 Space.SpaceOrOutdent => {
2439 try stream.insertNewline();
2438 try ais.insertNewline();
24402439 },
24412440 Space.NoNewline => {},
24422441 Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
......@@ -2449,38 +2448,38 @@ fn renderTokenOffset(
24492448
24502449fn renderToken(
24512450 tree: *ast.Tree,
2452 stream: anytype,
2451 ais: anytype,
24532452 token_index: ast.TokenIndex,
24542453 space: Space,
2455) (@TypeOf(stream.*).Error || Error)!void {
2456 return renderTokenOffset(tree, stream, token_index, space, 0);
2454) (@TypeOf(ais.*).Error || Error)!void {
2455 return renderTokenOffset(tree, ais, token_index, space, 0);
24572456}
24582457
24592458fn renderDocComments(
24602459 tree: *ast.Tree,
2461 stream: anytype,
2460 ais: anytype,
24622461 node: anytype,
24632462 doc_comments: ?*ast.Node.DocComment,
2464) (@TypeOf(stream.*).Error || Error)!void {
2463) (@TypeOf(ais.*).Error || Error)!void {
24652464 const comment = doc_comments orelse return;
2466 return renderDocCommentsToken(tree, stream, comment, node.firstToken());
2465 return renderDocCommentsToken(tree, ais, comment, node.firstToken());
24672466}
24682467
24692468fn renderDocCommentsToken(
24702469 tree: *ast.Tree,
2471 stream: anytype,
2470 ais: anytype,
24722471 comment: *ast.Node.DocComment,
24732472 first_token: ast.TokenIndex,
2474) (@TypeOf(stream.*).Error || Error)!void {
2473) (@TypeOf(ais.*).Error || Error)!void {
24752474 var tok_i = comment.first_line;
24762475 while (true) : (tok_i += 1) {
24772476 switch (tree.token_ids[tok_i]) {
24782477 .DocComment, .ContainerDocComment => {
24792478 if (comment.first_line < first_token) {
2480 try renderToken(tree, stream, tok_i, Space.Newline);
2479 try renderToken(tree, ais, tok_i, Space.Newline);
24812480 } else {
2482 try renderToken(tree, stream, tok_i, Space.NoComment);
2483 try stream.insertNewline();
2481 try renderToken(tree, ais, tok_i, Space.NoComment);
2482 try ais.insertNewline();
24842483 }
24852484 },
24862485 .LineComment => continue,
......@@ -2552,10 +2551,10 @@ fn nodeCausesSliceOpSpace(base: *ast.Node) bool {
25522551 };
25532552}
25542553
2555fn copyFixingWhitespace(stream: anytype, slice: []const u8) @TypeOf(stream.*).Error!void {
2554fn copyFixingWhitespace(ais: anytype, slice: []const u8) @TypeOf(ais.*).Error!void {
25562555 for (slice) |byte| switch (byte) {
2557 '\t' => try stream.writer().writeAll(" "),
2556 '\t' => try ais.writer().writeAll(" "),
25582557 '\r' => {},
2559 else => try stream.writer().writeByte(byte),
2558 else => try ais.writer().writeByte(byte),
25602559 };
25612560}
src-self-hosted/main.zig+4-4
......@@ -682,13 +682,13 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
682682 process.exit(1);
683683 }
684684 if (check_flag) {
685 const anything_changed = try std.zig.render(gpa, &io.null_out_stream, tree);
685 const anything_changed = try std.zig.render(gpa, io.null_out_stream, tree);
686686 const code = if (anything_changed) @as(u8, 1) else @as(u8, 0);
687687 process.exit(code);
688688 }
689689
690690 const stdout = io.getStdOut().outStream();
691 _ = try std.zig.render(gpa, &stdout, tree);
691 _ = try std.zig.render(gpa, stdout, tree);
692692 return;
693693 }
694694
......@@ -830,7 +830,7 @@ fn fmtPathFile(
830830 }
831831
832832 if (check_mode) {
833 const anything_changed = try std.zig.render(fmt.gpa, &io.null_out_stream, tree);
833 const anything_changed = try std.zig.render(fmt.gpa, io.null_out_stream, tree);
834834 if (anything_changed) {
835835 std.debug.print("{}\n", .{file_path});
836836 fmt.any_error = true;
......@@ -840,7 +840,7 @@ fn fmtPathFile(
840840 try fmt.out_buffer.ensureCapacity(source_code.len);
841841 fmt.out_buffer.items.len = 0;
842842 const writer = fmt.out_buffer.writer();
843 const anything_changed = try std.zig.render(fmt.gpa, &writer, tree);
843 const anything_changed = try std.zig.render(fmt.gpa, writer, tree);
844844 if (!anything_changed)
845845 return; // Good thing we didn't waste any file system access on this.
846846
src-self-hosted/stage2.zig+1-1
......@@ -151,7 +151,7 @@ export fn stage2_free_clang_errors(errors_ptr: [*]translate_c.ClangErrMsg, error
151151
152152export fn stage2_render_ast(tree: *ast.Tree, output_file: *FILE) Error {
153153 const c_out_stream = std.io.cOutStream(output_file);
154 _ = std.zig.render(std.heap.c_allocator, &c_out_stream, tree) catch |e| switch (e) {
154 _ = std.zig.render(std.heap.c_allocator, c_out_stream, tree) catch |e| switch (e) {
155155 error.WouldBlock => unreachable, // stage1 opens stuff in exclusively blocking mode
156156 error.NotOpenForWriting => unreachable,
157157 error.SystemResources => return .SystemResources,