authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-09-02 18:14:28-04:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2020-09-02 18:14:28-04:00
log405c7215a8054680a789cf94afe41fd66c7d61c7
treea528933363e18fb9ba1f805e5951f1130f0e779d
parent12ce6eb8f65e6de5920c713cf2767e4b8ba0f1d3
parentbb848dbeeec133b2ca1d6dc42fe9dd04b848b58a
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #6194 from LakeByTheWoods/fmt_indentation

Refactor zig fmt indentation. Remove indent from rendering code

8 files changed, 1132 insertions(+), 920 deletions(-)

lib/std/io.zig+9
......@@ -169,6 +169,15 @@ pub const BitOutStream = BitWriter;
169169/// Deprecated: use `bitWriter`
170170pub const bitOutStream = bitWriter;
171171
172pub const AutoIndentingStream = @import("io/auto_indenting_stream.zig").AutoIndentingStream;
173pub const autoIndentingStream = @import("io/auto_indenting_stream.zig").autoIndentingStream;
174
175pub const ChangeDetectionStream = @import("io/change_detection_stream.zig").ChangeDetectionStream;
176pub const changeDetectionStream = @import("io/change_detection_stream.zig").changeDetectionStream;
177
178pub const FindByteOutStream = @import("io/find_byte_out_stream.zig").FindByteOutStream;
179pub const findByteOutStream = @import("io/find_byte_out_stream.zig").findByteOutStream;
180
172181pub const Packing = @import("io/serialization.zig").Packing;
173182
174183pub const Serializer = @import("io/serialization.zig").Serializer;
lib/std/io/auto_indenting_stream.zig created+148
......@@ -0,0 +1,148 @@
1const std = @import("../std.zig");
2const io = std.io;
3const mem = std.mem;
4const assert = std.debug.assert;
5
6/// Automatically inserts indentation of written data by keeping
7/// track of the current indentation level
8pub fn AutoIndentingStream(comptime UnderlyingWriter: type) type {
9 return struct {
10 const Self = @This();
11 pub const Error = UnderlyingWriter.Error;
12 pub const Writer = io.Writer(*Self, Error, write);
13
14 underlying_writer: UnderlyingWriter,
15
16 indent_count: usize = 0,
17 indent_delta: usize,
18 current_line_empty: bool = true,
19 indent_one_shot_count: usize = 0, // automatically popped when applied
20 applied_indent: usize = 0, // the most recently applied indent
21 indent_next_line: usize = 0, // not used until the next line
22
23 pub fn writer(self: *Self) Writer {
24 return .{ .context = self };
25 }
26
27 pub fn write(self: *Self, bytes: []const u8) Error!usize {
28 if (bytes.len == 0)
29 return @as(usize, 0);
30
31 try self.applyIndent();
32 return self.writeNoIndent(bytes);
33 }
34
35 // Change the indent delta without changing the final indentation level
36 pub fn setIndentDelta(self: *Self, indent_delta: usize) void {
37 if (self.indent_delta == indent_delta) {
38 return;
39 } else if (self.indent_delta > indent_delta) {
40 assert(self.indent_delta % indent_delta == 0);
41 self.indent_count = self.indent_count * (self.indent_delta / indent_delta);
42 } else {
43 // assert that the current indentation (in spaces) in a multiple of the new delta
44 assert((self.indent_count * self.indent_delta) % indent_delta == 0);
45 self.indent_count = self.indent_count / (indent_delta / self.indent_delta);
46 }
47 self.indent_delta = indent_delta;
48 }
49
50 fn writeNoIndent(self: *Self, bytes: []const u8) Error!usize {
51 if (bytes.len == 0)
52 return @as(usize, 0);
53
54 try self.underlying_writer.writeAll(bytes);
55 if (bytes[bytes.len - 1] == '\n')
56 self.resetLine();
57 return bytes.len;
58 }
59
60 pub fn insertNewline(self: *Self) Error!void {
61 _ = try self.writeNoIndent("\n");
62 }
63
64 fn resetLine(self: *Self) void {
65 self.current_line_empty = true;
66 self.indent_next_line = 0;
67 }
68
69 /// Insert a newline unless the current line is blank
70 pub fn maybeInsertNewline(self: *Self) Error!void {
71 if (!self.current_line_empty)
72 try self.insertNewline();
73 }
74
75 /// Push default indentation
76 pub fn pushIndent(self: *Self) void {
77 // Doesn't actually write any indentation.
78 // Just primes the stream to be able to write the correct indentation if it needs to.
79 self.indent_count += 1;
80 }
81
82 /// Push an indent that is automatically popped after being applied
83 pub fn pushIndentOneShot(self: *Self) void {
84 self.indent_one_shot_count += 1;
85 self.pushIndent();
86 }
87
88 /// Turns all one-shot indents into regular indents
89 /// Returns number of indents that must now be manually popped
90 pub fn lockOneShotIndent(self: *Self) usize {
91 var locked_count = self.indent_one_shot_count;
92 self.indent_one_shot_count = 0;
93 return locked_count;
94 }
95
96 /// Push an indent that should not take effect until the next line
97 pub fn pushIndentNextLine(self: *Self) void {
98 self.indent_next_line += 1;
99 self.pushIndent();
100 }
101
102 pub fn popIndent(self: *Self) void {
103 assert(self.indent_count != 0);
104 self.indent_count -= 1;
105
106 if (self.indent_next_line > 0)
107 self.indent_next_line -= 1;
108 }
109
110 /// Writes ' ' bytes if the current line is empty
111 fn applyIndent(self: *Self) Error!void {
112 const current_indent = self.currentIndent();
113 if (self.current_line_empty and current_indent > 0) {
114 try self.underlying_writer.writeByteNTimes(' ', current_indent);
115 self.applied_indent = current_indent;
116 }
117
118 self.indent_count -= self.indent_one_shot_count;
119 self.indent_one_shot_count = 0;
120 self.current_line_empty = false;
121 }
122
123 /// Checks to see if the most recent indentation exceeds the currently pushed indents
124 pub fn isLineOverIndented(self: *Self) bool {
125 if (self.current_line_empty) return false;
126 return self.applied_indent > self.currentIndent();
127 }
128
129 fn currentIndent(self: *Self) usize {
130 var indent_current: usize = 0;
131 if (self.indent_count > 0) {
132 const indent_count = self.indent_count - self.indent_next_line;
133 indent_current = indent_count * self.indent_delta;
134 }
135 return indent_current;
136 }
137 };
138}
139
140pub fn autoIndentingStream(
141 indent_delta: usize,
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 };
148}
lib/std/io/change_detection_stream.zig created+55
......@@ -0,0 +1,55 @@
1const std = @import("../std.zig");
2const io = std.io;
3const mem = std.mem;
4const assert = std.debug.assert;
5
6/// Used to detect if the data written to a stream differs from a source buffer
7pub fn ChangeDetectionStream(comptime WriterType: type) type {
8 return struct {
9 const Self = @This();
10 pub const Error = WriterType.Error;
11 pub const Writer = io.Writer(*Self, Error, write);
12
13 anything_changed: bool,
14 underlying_writer: WriterType,
15 source_index: usize,
16 source: []const u8,
17
18 pub fn writer(self: *Self) Writer {
19 return .{ .context = self };
20 }
21
22 fn write(self: *Self, bytes: []const u8) Error!usize {
23 if (!self.anything_changed) {
24 const end = self.source_index + bytes.len;
25 if (end > self.source.len) {
26 self.anything_changed = true;
27 } else {
28 const src_slice = self.source[self.source_index..end];
29 self.source_index += bytes.len;
30 if (!mem.eql(u8, bytes, src_slice)) {
31 self.anything_changed = true;
32 }
33 }
34 }
35
36 return self.underlying_writer.write(bytes);
37 }
38
39 pub fn changeDetected(self: *Self) bool {
40 return self.anything_changed or (self.source_index != self.source.len);
41 }
42 };
43}
44
45pub fn changeDetectionStream(
46 source: []const u8,
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 };
55}
lib/std/io/find_byte_out_stream.zig created+40
......@@ -0,0 +1,40 @@
1const std = @import("../std.zig");
2const io = std.io;
3const assert = std.debug.assert;
4
5/// An OutStream that returns whether the given character has been written to it.
6/// The contents are not written to anything.
7pub fn FindByteOutStream(comptime UnderlyingWriter: type) type {
8 return struct {
9 const Self = @This();
10 pub const Error = UnderlyingWriter.Error;
11 pub const Writer = io.Writer(*Self, Error, write);
12
13 underlying_writer: UnderlyingWriter,
14 byte_found: bool,
15 byte: u8,
16
17 pub fn writer(self: *Self) Writer {
18 return .{ .context = self };
19 }
20
21 fn write(self: *Self, bytes: []const u8) Error!usize {
22 if (!self.byte_found) {
23 self.byte_found = blk: {
24 for (bytes) |b|
25 if (b == self.byte) break :blk true;
26 break :blk false;
27 };
28 }
29 return self.underlying_writer.write(bytes);
30 }
31 };
32}
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 };
40}
lib/std/target.zig+1-1
......@@ -101,7 +101,7 @@ pub const Target = struct {
101101
102102 /// Latest Windows version that the Zig Standard Library is aware of
103103 pub const latest = WindowsVersion.win10_20h1;
104
104
105105 pub const Range = struct {
106106 min: WindowsVersion,
107107 max: WindowsVersion,
lib/std/zig/parser_test.zig+114-6
......@@ -615,6 +615,17 @@ test "zig fmt: infix operator and then multiline string literal" {
615615 );
616616}
617617
618test "zig fmt: infix operator and then multiline string literal" {
619 try testCanonical(
620 \\const x = "" ++
621 \\ \\ hi0
622 \\ \\ hi1
623 \\ \\ hi2
624 \\;
625 \\
626 );
627}
628
618629test "zig fmt: C pointers" {
619630 try testCanonical(
620631 \\const Ptr = [*c]i32;
......@@ -885,6 +896,28 @@ test "zig fmt: 2nd arg multiline string" {
885896 );
886897}
887898
899test "zig fmt: 2nd arg multiline string many args" {
900 try testCanonical(
901 \\comptime {
902 \\ cases.addAsm("hello world linux x86_64",
903 \\ \\.text
904 \\ , "Hello, world!\n", "Hello, world!\n");
905 \\}
906 \\
907 );
908}
909
910test "zig fmt: final arg multiline string" {
911 try testCanonical(
912 \\comptime {
913 \\ cases.addAsm("hello world linux x86_64", "Hello, world!\n",
914 \\ \\.text
915 \\ );
916 \\}
917 \\
918 );
919}
920
888921test "zig fmt: if condition wraps" {
889922 try testTransform(
890923 \\comptime {
......@@ -915,6 +948,11 @@ test "zig fmt: if condition wraps" {
915948 \\ var a = if (a) |*f| x: {
916949 \\ break :x &a.b;
917950 \\ } else |err| err;
951 \\ var a = if (cond and
952 \\ cond) |*f|
953 \\ x: {
954 \\ break :x &a.b;
955 \\ } else |err| err;
918956 \\}
919957 ,
920958 \\comptime {
......@@ -951,6 +989,35 @@ test "zig fmt: if condition wraps" {
951989 \\ var a = if (a) |*f| x: {
952990 \\ break :x &a.b;
953991 \\ } else |err| err;
992 \\ var a = if (cond and
993 \\ cond) |*f|
994 \\ x: {
995 \\ break :x &a.b;
996 \\ } else |err| err;
997 \\}
998 \\
999 );
1000}
1001
1002test "zig fmt: if condition has line break but must not wrap" {
1003 try testCanonical(
1004 \\comptime {
1005 \\ if (self.user_input_options.put(
1006 \\ name,
1007 \\ UserInputOption{
1008 \\ .name = name,
1009 \\ .used = false,
1010 \\ },
1011 \\ ) catch unreachable) |*prev_value| {
1012 \\ foo();
1013 \\ bar();
1014 \\ }
1015 \\ if (put(
1016 \\ a,
1017 \\ b,
1018 \\ )) {
1019 \\ foo();
1020 \\ }
9541021 \\}
9551022 \\
9561023 );
......@@ -977,6 +1044,18 @@ test "zig fmt: if condition has line break but must not wrap" {
9771044 );
9781045}
9791046
1047test "zig fmt: function call with multiline argument" {
1048 try testCanonical(
1049 \\comptime {
1050 \\ self.user_input_options.put(name, UserInputOption{
1051 \\ .name = name,
1052 \\ .used = false,
1053 \\ });
1054 \\}
1055 \\
1056 );
1057}
1058
9801059test "zig fmt: same-line doc comment on variable declaration" {
9811060 try testTransform(
9821061 \\pub const MAP_ANONYMOUS = 0x1000; /// allocated from memory, swap space
......@@ -1228,7 +1307,7 @@ test "zig fmt: array literal with hint" {
12281307 \\const a = []u8{
12291308 \\ 1, 2,
12301309 \\ 3, //
1231 \\ 4,
1310 \\ 4,
12321311 \\ 5, 6,
12331312 \\ 7,
12341313 \\};
......@@ -1293,7 +1372,7 @@ test "zig fmt: multiline string parameter in fn call with trailing comma" {
12931372 \\ \\ZIG_C_HEADER_FILES {}
12941373 \\ \\ZIG_DIA_GUIDS_LIB {}
12951374 \\ \\
1296 \\ ,
1375 \\ ,
12971376 \\ std.cstr.toSliceConst(c.ZIG_CMAKE_BINARY_DIR),
12981377 \\ std.cstr.toSliceConst(c.ZIG_CXX_COMPILER),
12991378 \\ std.cstr.toSliceConst(c.ZIG_DIA_GUIDS_LIB),
......@@ -2885,20 +2964,20 @@ test "zig fmt: multiline string in array" {
28852964 try testCanonical(
28862965 \\const Foo = [][]const u8{
28872966 \\ \\aaa
2888 \\,
2967 \\ ,
28892968 \\ \\bbb
28902969 \\};
28912970 \\
28922971 \\fn bar() void {
28932972 \\ const Foo = [][]const u8{
28942973 \\ \\aaa
2895 \\ ,
2974 \\ ,
28962975 \\ \\bbb
28972976 \\ };
28982977 \\ const Bar = [][]const u8{ // comment here
28992978 \\ \\aaa
29002979 \\ \\
2901 \\ , // and another comment can go here
2980 \\ , // and another comment can go here
29022981 \\ \\bbb
29032982 \\ };
29042983 \\}
......@@ -3214,6 +3293,34 @@ test "zig fmt: C var args" {
32143293 );
32153294}
32163295
3296test "zig fmt: Only indent multiline string literals in function calls" {
3297 try testCanonical(
3298 \\test "zig fmt:" {
3299 \\ try testTransform(
3300 \\ \\const X = struct {
3301 \\ \\ foo: i32, bar: i8 };
3302 \\ ,
3303 \\ \\const X = struct {
3304 \\ \\ foo: i32, bar: i8
3305 \\ \\};
3306 \\ \\
3307 \\ );
3308 \\}
3309 \\
3310 );
3311}
3312
3313test "zig fmt: Don't add extra newline after if" {
3314 try testCanonical(
3315 \\pub fn atomicSymLink(allocator: *Allocator, existing_path: []const u8, new_path: []const u8) !void {
3316 \\ if (cwd().symLink(existing_path, new_path, .{})) {
3317 \\ return;
3318 \\ }
3319 \\}
3320 \\
3321 );
3322}
3323
32173324const std = @import("std");
32183325const mem = std.mem;
32193326const warn = std.debug.warn;
......@@ -3256,7 +3363,8 @@ fn testParse(source: []const u8, allocator: *mem.Allocator, anything_changed: *b
32563363 var buffer = std.ArrayList(u8).init(allocator);
32573364 errdefer buffer.deinit();
32583365
3259 anything_changed.* = try std.zig.render(allocator, buffer.outStream(), tree);
3366 const outStream = buffer.outStream();
3367 anything_changed.* = try std.zig.render(allocator, outStream, tree);
32603368 return buffer.toOwnedSlice();
32613369}
32623370fn testTransform(source: []const u8, expected_source: []const u8) !void {
lib/std/zig/render.zig+763-912
......@@ -6,10 +6,12 @@
66const std = @import("../std.zig");
77const assert = std.debug.assert;
88const mem = std.mem;
9const meta = std.meta;
910const ast = std.zig.ast;
1011const Token = std.zig.Token;
1112
1213const indent_delta = 4;
14const asm_indent_delta = 2;
1315
1416pub const Error = error{
1517 /// Ran out of memory allocating call stack frames to complete rendering.
......@@ -21,70 +23,32 @@ pub fn render(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree) (@Typ
2123 // cannot render an invalid tree
2224 std.debug.assert(tree.errors.len == 0);
2325
24 // make a passthrough stream that checks whether something changed
25 const MyStream = struct {
26 const MyStream = @This();
27 const StreamError = @TypeOf(stream).Error;
28
29 child_stream: @TypeOf(stream),
30 anything_changed: bool,
31 source_index: usize,
32 source: []const u8,
33
34 fn write(self: *MyStream, bytes: []const u8) StreamError!usize {
35 if (!self.anything_changed) {
36 const end = self.source_index + bytes.len;
37 if (end > self.source.len) {
38 self.anything_changed = true;
39 } else {
40 const src_slice = self.source[self.source_index..end];
41 self.source_index += bytes.len;
42 if (!mem.eql(u8, bytes, src_slice)) {
43 self.anything_changed = true;
44 }
45 }
46 }
47
48 return self.child_stream.write(bytes);
49 }
50 };
51 var my_stream = MyStream{
52 .child_stream = stream,
53 .anything_changed = false,
54 .source_index = 0,
55 .source = tree.source,
56 };
57 const my_stream_stream: std.io.Writer(*MyStream, MyStream.StreamError, MyStream.write) = .{
58 .context = &my_stream,
59 };
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());
6028
61 try renderRoot(allocator, my_stream_stream, tree);
29 try renderRoot(allocator, &auto_indenting_stream, tree);
6230
63 if (my_stream.source_index != my_stream.source.len) {
64 my_stream.anything_changed = true;
65 }
66
67 return my_stream.anything_changed;
31 return change_detection_stream.changeDetected();
6832}
6933
7034fn renderRoot(
7135 allocator: *mem.Allocator,
72 stream: anytype,
36 ais: anytype,
7337 tree: *ast.Tree,
74) (@TypeOf(stream).Error || Error)!void {
38) (@TypeOf(ais.*).Error || Error)!void {
39
7540 // render all the line comments at the beginning of the file
7641 for (tree.token_ids) |token_id, i| {
7742 if (token_id != .LineComment) break;
7843 const token_loc = tree.token_locs[i];
79 try stream.print("{}\n", .{mem.trimRight(u8, tree.tokenSliceLoc(token_loc), " ")});
44 try ais.writer().print("{}\n", .{mem.trimRight(u8, tree.tokenSliceLoc(token_loc), " ")});
8045 const next_token = tree.token_locs[i + 1];
8146 const loc = tree.tokenLocationLoc(token_loc.end, next_token);
8247 if (loc.line >= 2) {
83 try stream.writeByte('\n');
48 try ais.insertNewline();
8449 }
8550 }
8651
87 var start_col: usize = 0;
8852 var decl_i: ast.NodeIndex = 0;
8953 const root_decls = tree.root_node.decls();
9054
......@@ -145,7 +109,7 @@ fn renderRoot(
145109 // If there's no next reformatted `decl`, just copy the
146110 // remaining input tokens and bail out.
147111 const start = tree.token_locs[copy_start_token_index].start;
148 try copyFixingWhitespace(stream, tree.source[start..]);
112 try copyFixingWhitespace(ais, tree.source[start..]);
149113 return;
150114 }
151115 decl = root_decls[decl_i];
......@@ -186,26 +150,25 @@ fn renderRoot(
186150
187151 const start = tree.token_locs[copy_start_token_index].start;
188152 const end = tree.token_locs[copy_end_token_index].start;
189 try copyFixingWhitespace(stream, tree.source[start..end]);
153 try copyFixingWhitespace(ais, tree.source[start..end]);
190154 }
191155
192 try renderTopLevelDecl(allocator, stream, tree, 0, &start_col, decl);
156 try renderTopLevelDecl(allocator, ais, tree, decl);
193157 decl_i += 1;
194158 if (decl_i >= root_decls.len) return;
195 try renderExtraNewline(tree, stream, &start_col, root_decls[decl_i]);
159 try renderExtraNewline(tree, ais, root_decls[decl_i]);
196160 }
197161}
198162
199fn renderExtraNewline(tree: *ast.Tree, stream: anytype, start_col: *usize, node: *ast.Node) @TypeOf(stream).Error!void {
200 return renderExtraNewlineToken(tree, stream, start_col, node.firstToken());
163fn renderExtraNewline(tree: *ast.Tree, ais: anytype, node: *ast.Node) @TypeOf(ais.*).Error!void {
164 return renderExtraNewlineToken(tree, ais, node.firstToken());
201165}
202166
203167fn renderExtraNewlineToken(
204168 tree: *ast.Tree,
205 stream: anytype,
206 start_col: *usize,
169 ais: anytype,
207170 first_token: ast.TokenIndex,
208) @TypeOf(stream).Error!void {
171) @TypeOf(ais.*).Error!void {
209172 var prev_token = first_token;
210173 if (prev_token == 0) return;
211174 var newline_threshold: usize = 2;
......@@ -218,28 +181,27 @@ fn renderExtraNewlineToken(
218181 const prev_token_end = tree.token_locs[prev_token - 1].end;
219182 const loc = tree.tokenLocation(prev_token_end, first_token);
220183 if (loc.line >= newline_threshold) {
221 try stream.writeByte('\n');
222 start_col.* = 0;
184 try ais.insertNewline();
223185 }
224186}
225187
226fn renderTopLevelDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree, indent: usize, start_col: *usize, decl: *ast.Node) (@TypeOf(stream).Error || Error)!void {
227 try renderContainerDecl(allocator, stream, tree, indent, start_col, 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);
228190}
229191
230fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree, indent: usize, start_col: *usize, 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 {
231193 switch (decl.tag) {
232194 .FnProto => {
233195 const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
234196
235 try renderDocComments(tree, stream, fn_proto, fn_proto.getDocComments(), indent, start_col);
197 try renderDocComments(tree, ais, fn_proto, fn_proto.getDocComments());
236198
237199 if (fn_proto.getBodyNode()) |body_node| {
238 try renderExpression(allocator, stream, tree, indent, start_col, decl, .Space);
239 try renderExpression(allocator, stream, tree, indent, start_col, body_node, space);
200 try renderExpression(allocator, ais, tree, decl, .Space);
201 try renderExpression(allocator, ais, tree, body_node, space);
240202 } else {
241 try renderExpression(allocator, stream, tree, indent, start_col, decl, .None);
242 try renderToken(tree, stream, tree.nextToken(decl.lastToken()), indent, start_col, space);
203 try renderExpression(allocator, ais, tree, decl, .None);
204 try renderToken(tree, ais, tree.nextToken(decl.lastToken()), space);
243205 }
244206 },
245207
......@@ -247,35 +209,35 @@ fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tr
247209 const use_decl = @fieldParentPtr(ast.Node.Use, "base", decl);
248210
249211 if (use_decl.visib_token) |visib_token| {
250 try renderToken(tree, stream, visib_token, indent, start_col, .Space); // pub
212 try renderToken(tree, ais, visib_token, .Space); // pub
251213 }
252 try renderToken(tree, stream, use_decl.use_token, indent, start_col, .Space); // usingnamespace
253 try renderExpression(allocator, stream, tree, indent, start_col, use_decl.expr, .None);
254 try renderToken(tree, stream, use_decl.semicolon_token, indent, start_col, 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); // ;
255217 },
256218
257219 .VarDecl => {
258220 const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", decl);
259221
260 try renderDocComments(tree, stream, var_decl, var_decl.getDocComments(), indent, start_col);
261 try renderVarDecl(allocator, stream, tree, indent, start_col, var_decl);
222 try renderDocComments(tree, ais, var_decl, var_decl.getDocComments());
223 try renderVarDecl(allocator, ais, tree, var_decl);
262224 },
263225
264226 .TestDecl => {
265227 const test_decl = @fieldParentPtr(ast.Node.TestDecl, "base", decl);
266228
267 try renderDocComments(tree, stream, test_decl, test_decl.doc_comments, indent, start_col);
268 try renderToken(tree, stream, test_decl.test_token, indent, start_col, .Space);
269 try renderExpression(allocator, stream, tree, indent, start_col, test_decl.name, .Space);
270 try renderExpression(allocator, stream, tree, indent, start_col, 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);
271233 },
272234
273235 .ContainerField => {
274236 const field = @fieldParentPtr(ast.Node.ContainerField, "base", decl);
275237
276 try renderDocComments(tree, stream, field, field.doc_comments, indent, start_col);
238 try renderDocComments(tree, ais, field, field.doc_comments);
277239 if (field.comptime_token) |t| {
278 try renderToken(tree, stream, t, indent, start_col, .Space); // comptime
240 try renderToken(tree, ais, t, .Space); // comptime
279241 }
280242
281243 const src_has_trailing_comma = blk: {
......@@ -288,68 +250,67 @@ fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tr
288250 const last_token_space: Space = if (src_has_trailing_comma) .None else space;
289251
290252 if (field.type_expr == null and field.value_expr == null) {
291 try renderToken(tree, stream, field.name_token, indent, start_col, last_token_space); // name
253 try renderToken(tree, ais, field.name_token, last_token_space); // name
292254 } else if (field.type_expr != null and field.value_expr == null) {
293 try renderToken(tree, stream, field.name_token, indent, start_col, .None); // name
294 try renderToken(tree, stream, tree.nextToken(field.name_token), indent, start_col, .Space); // :
255 try renderToken(tree, ais, field.name_token, .None); // name
256 try renderToken(tree, ais, tree.nextToken(field.name_token), .Space); // :
295257
296258 if (field.align_expr) |align_value_expr| {
297 try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, .Space); // type
259 try renderExpression(allocator, ais, tree, field.type_expr.?, .Space); // type
298260 const lparen_token = tree.prevToken(align_value_expr.firstToken());
299261 const align_kw = tree.prevToken(lparen_token);
300262 const rparen_token = tree.nextToken(align_value_expr.lastToken());
301 try renderToken(tree, stream, align_kw, indent, start_col, .None); // align
302 try renderToken(tree, stream, lparen_token, indent, start_col, .None); // (
303 try renderExpression(allocator, stream, tree, indent, start_col, align_value_expr, .None); // alignment
304 try renderToken(tree, stream, rparen_token, indent, start_col, 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); // )
305267 } else {
306 try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, last_token_space); // type
268 try renderExpression(allocator, ais, tree, field.type_expr.?, last_token_space); // type
307269 }
308270 } else if (field.type_expr == null and field.value_expr != null) {
309 try renderToken(tree, stream, field.name_token, indent, start_col, .Space); // name
310 try renderToken(tree, stream, tree.nextToken(field.name_token), indent, start_col, .Space); // =
311 try renderExpression(allocator, stream, tree, indent, start_col, 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
312274 } else {
313 try renderToken(tree, stream, field.name_token, indent, start_col, .None); // name
314 try renderToken(tree, stream, tree.nextToken(field.name_token), indent, start_col, .Space); // :
275 try renderToken(tree, ais, field.name_token, .None); // name
276 try renderToken(tree, ais, tree.nextToken(field.name_token), .Space); // :
315277
316278 if (field.align_expr) |align_value_expr| {
317 try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, .Space); // type
279 try renderExpression(allocator, ais, tree, field.type_expr.?, .Space); // type
318280 const lparen_token = tree.prevToken(align_value_expr.firstToken());
319281 const align_kw = tree.prevToken(lparen_token);
320282 const rparen_token = tree.nextToken(align_value_expr.lastToken());
321 try renderToken(tree, stream, align_kw, indent, start_col, .None); // align
322 try renderToken(tree, stream, lparen_token, indent, start_col, .None); // (
323 try renderExpression(allocator, stream, tree, indent, start_col, align_value_expr, .None); // alignment
324 try renderToken(tree, stream, rparen_token, indent, start_col, .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); // )
325287 } else {
326 try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, .Space); // type
288 try renderExpression(allocator, ais, tree, field.type_expr.?, .Space); // type
327289 }
328 try renderToken(tree, stream, tree.prevToken(field.value_expr.?.firstToken()), indent, start_col, .Space); // =
329 try renderExpression(allocator, stream, tree, indent, start_col, 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
330292 }
331293
332294 if (src_has_trailing_comma) {
333295 const comma = tree.nextToken(field.lastToken());
334 try renderToken(tree, stream, comma, indent, start_col, space);
296 try renderToken(tree, ais, comma, space);
335297 }
336298 },
337299
338300 .Comptime => {
339301 assert(!decl.requireSemiColon());
340 try renderExpression(allocator, stream, tree, indent, start_col, decl, space);
302 try renderExpression(allocator, ais, tree, decl, space);
341303 },
342304
343305 .DocComment => {
344306 const comment = @fieldParentPtr(ast.Node.DocComment, "base", decl);
345307 const kind = tree.token_ids[comment.first_line];
346 try renderToken(tree, stream, comment.first_line, indent, start_col, .Newline);
308 try renderToken(tree, ais, comment.first_line, .Newline);
347309 var tok_i = comment.first_line + 1;
348310 while (true) : (tok_i += 1) {
349311 const tok_id = tree.token_ids[tok_i];
350312 if (tok_id == kind) {
351 try stream.writeByteNTimes(' ', indent);
352 try renderToken(tree, stream, tok_i, indent, start_col, .Newline);
313 try renderToken(tree, ais, tok_i, .Newline);
353314 } else if (tok_id == .LineComment) {
354315 continue;
355316 } else {
......@@ -363,13 +324,11 @@ fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tr
363324
364325fn renderExpression(
365326 allocator: *mem.Allocator,
366 stream: anytype,
327 ais: anytype,
367328 tree: *ast.Tree,
368 indent: usize,
369 start_col: *usize,
370329 base: *ast.Node,
371330 space: Space,
372) (@TypeOf(stream).Error || Error)!void {
331) (@TypeOf(ais.*).Error || Error)!void {
373332 switch (base.tag) {
374333 .Identifier,
375334 .IntegerLiteral,
......@@ -383,18 +342,18 @@ fn renderExpression(
383342 .UndefinedLiteral,
384343 => {
385344 const casted_node = base.cast(ast.Node.OneToken).?;
386 return renderToken(tree, stream, casted_node.token, indent, start_col, space);
345 return renderToken(tree, ais, casted_node.token, space);
387346 },
388347
389348 .AnyType => {
390349 const any_type = base.castTag(.AnyType).?;
391350 if (mem.eql(u8, tree.tokenSlice(any_type.token), "var")) {
392351 // TODO remove in next release cycle
393 try stream.writeAll("anytype");
394 if (space == .Comma) try stream.writeAll(",\n");
352 try ais.writer().writeAll("anytype");
353 if (space == .Comma) try ais.writer().writeAll(",\n");
395354 return;
396355 }
397 return renderToken(tree, stream, any_type.token, indent, start_col, space);
356 return renderToken(tree, ais, any_type.token, space);
398357 },
399358
400359 .Block, .LabeledBlock => {
......@@ -424,65 +383,65 @@ fn renderExpression(
424383 };
425384
426385 if (block.label) |label| {
427 try renderToken(tree, stream, label, indent, start_col, Space.None);
428 try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space);
386 try renderToken(tree, ais, label, Space.None);
387 try renderToken(tree, ais, tree.nextToken(label), Space.Space);
429388 }
430389
431390 if (block.statements.len == 0) {
432 try renderToken(tree, stream, block.lbrace, indent + indent_delta, start_col, Space.None);
433 return renderToken(tree, stream, block.rbrace, indent, start_col, space);
391 ais.pushIndentNextLine();
392 defer ais.popIndent();
393 try renderToken(tree, ais, block.lbrace, Space.None);
434394 } else {
435 const block_indent = indent + indent_delta;
436 try renderToken(tree, stream, block.lbrace, block_indent, start_col, Space.Newline);
395 ais.pushIndentNextLine();
396 defer ais.popIndent();
397
398 try renderToken(tree, ais, block.lbrace, Space.Newline);
437399
438400 for (block.statements) |statement, i| {
439 try stream.writeByteNTimes(' ', block_indent);
440 try renderStatement(allocator, stream, tree, block_indent, start_col, statement);
401 try renderStatement(allocator, ais, tree, statement);
441402
442403 if (i + 1 < block.statements.len) {
443 try renderExtraNewline(tree, stream, start_col, block.statements[i + 1]);
404 try renderExtraNewline(tree, ais, block.statements[i + 1]);
444405 }
445406 }
446
447 try stream.writeByteNTimes(' ', indent);
448 return renderToken(tree, stream, block.rbrace, indent, start_col, space);
449407 }
408 return renderToken(tree, ais, block.rbrace, space);
450409 },
451410
452411 .Defer => {
453412 const defer_node = @fieldParentPtr(ast.Node.Defer, "base", base);
454413
455 try renderToken(tree, stream, defer_node.defer_token, indent, start_col, Space.Space);
414 try renderToken(tree, ais, defer_node.defer_token, Space.Space);
456415 if (defer_node.payload) |payload| {
457 try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
416 try renderExpression(allocator, ais, tree, payload, Space.Space);
458417 }
459 return renderExpression(allocator, stream, tree, indent, start_col, defer_node.expr, space);
418 return renderExpression(allocator, ais, tree, defer_node.expr, space);
460419 },
461420 .Comptime => {
462421 const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", base);
463422
464 try renderToken(tree, stream, comptime_node.comptime_token, indent, start_col, Space.Space);
465 return renderExpression(allocator, stream, tree, indent, start_col, 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);
466425 },
467426 .Nosuspend => {
468427 const nosuspend_node = @fieldParentPtr(ast.Node.Nosuspend, "base", base);
469428 if (mem.eql(u8, tree.tokenSlice(nosuspend_node.nosuspend_token), "noasync")) {
470429 // TODO: remove this
471 try stream.writeAll("nosuspend ");
430 try ais.writer().writeAll("nosuspend ");
472431 } else {
473 try renderToken(tree, stream, nosuspend_node.nosuspend_token, indent, start_col, Space.Space);
432 try renderToken(tree, ais, nosuspend_node.nosuspend_token, Space.Space);
474433 }
475 return renderExpression(allocator, stream, tree, indent, start_col, nosuspend_node.expr, space);
434 return renderExpression(allocator, ais, tree, nosuspend_node.expr, space);
476435 },
477436
478437 .Suspend => {
479438 const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", base);
480439
481440 if (suspend_node.body) |body| {
482 try renderToken(tree, stream, suspend_node.suspend_token, indent, start_col, Space.Space);
483 return renderExpression(allocator, stream, tree, indent, start_col, body, space);
441 try renderToken(tree, ais, suspend_node.suspend_token, Space.Space);
442 return renderExpression(allocator, ais, tree, body, space);
484443 } else {
485 return renderToken(tree, stream, suspend_node.suspend_token, indent, start_col, space);
444 return renderToken(tree, ais, suspend_node.suspend_token, space);
486445 }
487446 },
488447
......@@ -490,26 +449,21 @@ fn renderExpression(
490449 const infix_op_node = @fieldParentPtr(ast.Node.Catch, "base", base);
491450
492451 const op_space = Space.Space;
493 try renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.lhs, op_space);
452 try renderExpression(allocator, ais, tree, infix_op_node.lhs, op_space);
494453
495454 const after_op_space = blk: {
496 const loc = tree.tokenLocation(tree.token_locs[infix_op_node.op_token].end, tree.nextToken(infix_op_node.op_token));
497 break :blk if (loc.line == 0) op_space else Space.Newline;
455 const same_line = tree.tokensOnSameLine(infix_op_node.op_token, tree.nextToken(infix_op_node.op_token));
456 break :blk if (same_line) op_space else Space.Newline;
498457 };
499458
500 try renderToken(tree, stream, infix_op_node.op_token, indent, start_col, after_op_space);
501 if (after_op_space == Space.Newline and
502 tree.token_ids[tree.nextToken(infix_op_node.op_token)] != .MultilineStringLiteralLine)
503 {
504 try stream.writeByteNTimes(' ', indent + indent_delta);
505 start_col.* = indent + indent_delta;
506 }
459 try renderToken(tree, ais, infix_op_node.op_token, after_op_space);
507460
508461 if (infix_op_node.payload) |payload| {
509 try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
462 try renderExpression(allocator, ais, tree, payload, Space.Space);
510463 }
511464
512 return renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.rhs, space);
465 ais.pushIndentOneShot();
466 return renderExpression(allocator, ais, tree, infix_op_node.rhs, space);
513467 },
514468
515469 .Add,
......@@ -561,22 +515,16 @@ fn renderExpression(
561515 .Period, .ErrorUnion, .Range => Space.None,
562516 else => Space.Space,
563517 };
564 try renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.lhs, op_space);
518 try renderExpression(allocator, ais, tree, infix_op_node.lhs, op_space);
565519
566520 const after_op_space = blk: {
567521 const loc = tree.tokenLocation(tree.token_locs[infix_op_node.op_token].end, tree.nextToken(infix_op_node.op_token));
568522 break :blk if (loc.line == 0) op_space else Space.Newline;
569523 };
570524
571 try renderToken(tree, stream, infix_op_node.op_token, indent, start_col, after_op_space);
572 if (after_op_space == Space.Newline and
573 tree.token_ids[tree.nextToken(infix_op_node.op_token)] != .MultilineStringLiteralLine)
574 {
575 try stream.writeByteNTimes(' ', indent + indent_delta);
576 start_col.* = indent + indent_delta;
577 }
578
579 return renderExpression(allocator, stream, tree, indent, start_col, 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);
580528 },
581529
582530 .BitNot,
......@@ -587,8 +535,8 @@ fn renderExpression(
587535 .AddressOf,
588536 => {
589537 const casted_node = @fieldParentPtr(ast.Node.SimplePrefixOp, "base", base);
590 try renderToken(tree, stream, casted_node.op_token, indent, start_col, Space.None);
591 return renderExpression(allocator, stream, tree, indent, start_col, 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);
592540 },
593541
594542 .Try,
......@@ -596,18 +544,16 @@ fn renderExpression(
596544 .Await,
597545 => {
598546 const casted_node = @fieldParentPtr(ast.Node.SimplePrefixOp, "base", base);
599 try renderToken(tree, stream, casted_node.op_token, indent, start_col, Space.Space);
600 return renderExpression(allocator, stream, tree, indent, start_col, 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);
601549 },
602550
603551 .ArrayType => {
604552 const array_type = @fieldParentPtr(ast.Node.ArrayType, "base", base);
605553 return renderArrayType(
606554 allocator,
607 stream,
555 ais,
608556 tree,
609 indent,
610 start_col,
611557 array_type.op_token,
612558 array_type.rhs,
613559 array_type.len_expr,
......@@ -619,10 +565,8 @@ fn renderExpression(
619565 const array_type = @fieldParentPtr(ast.Node.ArrayTypeSentinel, "base", base);
620566 return renderArrayType(
621567 allocator,
622 stream,
568 ais,
623569 tree,
624 indent,
625 start_col,
626570 array_type.op_token,
627571 array_type.rhs,
628572 array_type.len_expr,
......@@ -635,111 +579,111 @@ fn renderExpression(
635579 const ptr_type = @fieldParentPtr(ast.Node.PtrType, "base", base);
636580 const op_tok_id = tree.token_ids[ptr_type.op_token];
637581 switch (op_tok_id) {
638 .Asterisk, .AsteriskAsterisk => try stream.writeByte('*'),
582 .Asterisk, .AsteriskAsterisk => try ais.writer().writeByte('*'),
639583 .LBracket => if (tree.token_ids[ptr_type.op_token + 2] == .Identifier)
640 try stream.writeAll("[*c")
584 try ais.writer().writeAll("[*c")
641585 else
642 try stream.writeAll("[*"),
586 try ais.writer().writeAll("[*"),
643587 else => unreachable,
644588 }
645589 if (ptr_type.ptr_info.sentinel) |sentinel| {
646590 const colon_token = tree.prevToken(sentinel.firstToken());
647 try renderToken(tree, stream, colon_token, indent, start_col, Space.None); // :
591 try renderToken(tree, ais, colon_token, Space.None); // :
648592 const sentinel_space = switch (op_tok_id) {
649593 .LBracket => Space.None,
650594 else => Space.Space,
651595 };
652 try renderExpression(allocator, stream, tree, indent, start_col, sentinel, sentinel_space);
596 try renderExpression(allocator, ais, tree, sentinel, sentinel_space);
653597 }
654598 switch (op_tok_id) {
655599 .Asterisk, .AsteriskAsterisk => {},
656 .LBracket => try stream.writeByte(']'),
600 .LBracket => try ais.writer().writeByte(']'),
657601 else => unreachable,
658602 }
659603 if (ptr_type.ptr_info.allowzero_token) |allowzero_token| {
660 try renderToken(tree, stream, allowzero_token, indent, start_col, Space.Space); // allowzero
604 try renderToken(tree, ais, allowzero_token, Space.Space); // allowzero
661605 }
662606 if (ptr_type.ptr_info.align_info) |align_info| {
663607 const lparen_token = tree.prevToken(align_info.node.firstToken());
664608 const align_token = tree.prevToken(lparen_token);
665609
666 try renderToken(tree, stream, align_token, indent, start_col, Space.None); // align
667 try renderToken(tree, stream, lparen_token, indent, start_col, Space.None); // (
610 try renderToken(tree, ais, align_token, Space.None); // align
611 try renderToken(tree, ais, lparen_token, Space.None); // (
668612
669 try renderExpression(allocator, stream, tree, indent, start_col, align_info.node, Space.None);
613 try renderExpression(allocator, ais, tree, align_info.node, Space.None);
670614
671615 if (align_info.bit_range) |bit_range| {
672616 const colon1 = tree.prevToken(bit_range.start.firstToken());
673617 const colon2 = tree.prevToken(bit_range.end.firstToken());
674618
675 try renderToken(tree, stream, colon1, indent, start_col, Space.None); // :
676 try renderExpression(allocator, stream, tree, indent, start_col, bit_range.start, Space.None);
677 try renderToken(tree, stream, colon2, indent, start_col, Space.None); // :
678 try renderExpression(allocator, stream, tree, indent, start_col, 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);
679623
680624 const rparen_token = tree.nextToken(bit_range.end.lastToken());
681 try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
625 try renderToken(tree, ais, rparen_token, Space.Space); // )
682626 } else {
683627 const rparen_token = tree.nextToken(align_info.node.lastToken());
684 try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
628 try renderToken(tree, ais, rparen_token, Space.Space); // )
685629 }
686630 }
687631 if (ptr_type.ptr_info.const_token) |const_token| {
688 try renderToken(tree, stream, const_token, indent, start_col, Space.Space); // const
632 try renderToken(tree, ais, const_token, Space.Space); // const
689633 }
690634 if (ptr_type.ptr_info.volatile_token) |volatile_token| {
691 try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space); // volatile
635 try renderToken(tree, ais, volatile_token, Space.Space); // volatile
692636 }
693 return renderExpression(allocator, stream, tree, indent, start_col, ptr_type.rhs, space);
637 return renderExpression(allocator, ais, tree, ptr_type.rhs, space);
694638 },
695639
696640 .SliceType => {
697641 const slice_type = @fieldParentPtr(ast.Node.SliceType, "base", base);
698 try renderToken(tree, stream, slice_type.op_token, indent, start_col, Space.None); // [
642 try renderToken(tree, ais, slice_type.op_token, Space.None); // [
699643 if (slice_type.ptr_info.sentinel) |sentinel| {
700644 const colon_token = tree.prevToken(sentinel.firstToken());
701 try renderToken(tree, stream, colon_token, indent, start_col, Space.None); // :
702 try renderExpression(allocator, stream, tree, indent, start_col, sentinel, Space.None);
703 try renderToken(tree, stream, tree.nextToken(sentinel.lastToken()), indent, start_col, 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); // ]
704648 } else {
705 try renderToken(tree, stream, tree.nextToken(slice_type.op_token), indent, start_col, Space.None); // ]
649 try renderToken(tree, ais, tree.nextToken(slice_type.op_token), Space.None); // ]
706650 }
707651
708652 if (slice_type.ptr_info.allowzero_token) |allowzero_token| {
709 try renderToken(tree, stream, allowzero_token, indent, start_col, Space.Space); // allowzero
653 try renderToken(tree, ais, allowzero_token, Space.Space); // allowzero
710654 }
711655 if (slice_type.ptr_info.align_info) |align_info| {
712656 const lparen_token = tree.prevToken(align_info.node.firstToken());
713657 const align_token = tree.prevToken(lparen_token);
714658
715 try renderToken(tree, stream, align_token, indent, start_col, Space.None); // align
716 try renderToken(tree, stream, lparen_token, indent, start_col, Space.None); // (
659 try renderToken(tree, ais, align_token, Space.None); // align
660 try renderToken(tree, ais, lparen_token, Space.None); // (
717661
718 try renderExpression(allocator, stream, tree, indent, start_col, align_info.node, Space.None);
662 try renderExpression(allocator, ais, tree, align_info.node, Space.None);
719663
720664 if (align_info.bit_range) |bit_range| {
721665 const colon1 = tree.prevToken(bit_range.start.firstToken());
722666 const colon2 = tree.prevToken(bit_range.end.firstToken());
723667
724 try renderToken(tree, stream, colon1, indent, start_col, Space.None); // :
725 try renderExpression(allocator, stream, tree, indent, start_col, bit_range.start, Space.None);
726 try renderToken(tree, stream, colon2, indent, start_col, Space.None); // :
727 try renderExpression(allocator, stream, tree, indent, start_col, 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);
728672
729673 const rparen_token = tree.nextToken(bit_range.end.lastToken());
730 try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
674 try renderToken(tree, ais, rparen_token, Space.Space); // )
731675 } else {
732676 const rparen_token = tree.nextToken(align_info.node.lastToken());
733 try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
677 try renderToken(tree, ais, rparen_token, Space.Space); // )
734678 }
735679 }
736680 if (slice_type.ptr_info.const_token) |const_token| {
737 try renderToken(tree, stream, const_token, indent, start_col, Space.Space);
681 try renderToken(tree, ais, const_token, Space.Space);
738682 }
739683 if (slice_type.ptr_info.volatile_token) |volatile_token| {
740 try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space);
684 try renderToken(tree, ais, volatile_token, Space.Space);
741685 }
742 return renderExpression(allocator, stream, tree, indent, start_col, slice_type.rhs, space);
686 return renderExpression(allocator, ais, tree, slice_type.rhs, space);
743687 },
744688
745689 .ArrayInitializer, .ArrayInitializerDot => {
......@@ -768,27 +712,33 @@ fn renderExpression(
768712
769713 if (exprs.len == 0) {
770714 switch (lhs) {
771 .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
772 .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
715 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
716 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
717 }
718
719 {
720 ais.pushIndent();
721 defer ais.popIndent();
722 try renderToken(tree, ais, lbrace, Space.None);
773723 }
774 try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
775 return renderToken(tree, stream, rtoken, indent, start_col, space);
776 }
777724
778 if (exprs.len == 1 and tree.token_ids[exprs[0].lastToken() + 1] == .RBrace) {
725 return renderToken(tree, ais, rtoken, space);
726 }
727 if (exprs.len == 1 and tree.token_ids[exprs[0].*.lastToken() + 1] == .RBrace) {
779728 const expr = exprs[0];
729
780730 switch (lhs) {
781 .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
782 .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
731 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
732 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
783733 }
784 try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
785 try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
786 return renderToken(tree, stream, rtoken, indent, start_col, 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);
787737 }
788738
789739 switch (lhs) {
790 .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
791 .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
740 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
741 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
792742 }
793743
794744 // scan to find row size
......@@ -830,79 +780,70 @@ fn renderExpression(
830780 var expr_widths = widths[0 .. widths.len - row_size];
831781 var column_widths = widths[widths.len - row_size ..];
832782
833 // Null stream for counting the printed length of each expression
783 // Null ais for counting the printed length of each expression
834784 var counting_stream = std.io.countingOutStream(std.io.null_out_stream);
785 var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, counting_stream.writer());
835786
836787 for (exprs) |expr, i| {
837788 counting_stream.bytes_written = 0;
838 var dummy_col: usize = 0;
839 try renderExpression(allocator, counting_stream.outStream(), tree, indent, &dummy_col, expr, Space.None);
789 try renderExpression(allocator, &auto_indenting_stream, tree, expr, Space.None);
840790 const width = @intCast(usize, counting_stream.bytes_written);
841791 const col = i % row_size;
842792 column_widths[col] = std.math.max(column_widths[col], width);
843793 expr_widths[i] = width;
844794 }
845795
846 var new_indent = indent + indent_delta;
796 {
797 ais.pushIndentNextLine();
798 defer ais.popIndent();
799 try renderToken(tree, ais, lbrace, Space.Newline);
847800
848 if (tree.token_ids[tree.nextToken(lbrace)] != .MultilineStringLiteralLine) {
849 try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline);
850 try stream.writeByteNTimes(' ', new_indent);
851 } else {
852 new_indent -= indent_delta;
853 try renderToken(tree, stream, lbrace, new_indent, start_col, Space.None);
854 }
801 var col: usize = 1;
802 for (exprs) |expr, i| {
803 if (i + 1 < exprs.len) {
804 const next_expr = exprs[i + 1];
805 try renderExpression(allocator, ais, tree, expr, Space.None);
855806
856 var col: usize = 1;
857 for (exprs) |expr, i| {
858 if (i + 1 < exprs.len) {
859 const next_expr = exprs[i + 1];
860 try renderExpression(allocator, stream, tree, new_indent, start_col, expr, Space.None);
807 const comma = tree.nextToken(expr.*.lastToken());
861808
862 const comma = tree.nextToken(expr.lastToken());
809 if (col != row_size) {
810 try renderToken(tree, ais, comma, Space.Space); // ,
863811
864 if (col != row_size) {
865 try renderToken(tree, stream, comma, new_indent, start_col, Space.Space); // ,
812 const padding = column_widths[i % row_size] - expr_widths[i];
813 try ais.writer().writeByteNTimes(' ', padding);
866814
867 const padding = column_widths[i % row_size] - expr_widths[i];
868 try stream.writeByteNTimes(' ', padding);
815 col += 1;
816 continue;
817 }
818 col = 1;
869819
870 col += 1;
871 continue;
872 }
873 col = 1;
820 if (tree.token_ids[tree.nextToken(comma)] != .MultilineStringLiteralLine) {
821 try renderToken(tree, ais, comma, Space.Newline); // ,
822 } else {
823 try renderToken(tree, ais, comma, Space.None); // ,
824 }
874825
875 if (tree.token_ids[tree.nextToken(comma)] != .MultilineStringLiteralLine) {
876 try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline); // ,
826 try renderExtraNewline(tree, ais, next_expr);
877827 } else {
878 try renderToken(tree, stream, comma, new_indent, start_col, Space.None); // ,
879 }
880
881 try renderExtraNewline(tree, stream, start_col, next_expr);
882 if (next_expr.tag != .MultilineStringLiteral) {
883 try stream.writeByteNTimes(' ', new_indent);
828 try renderExpression(allocator, ais, tree, expr, Space.Comma); // ,
884829 }
885 } else {
886 try renderExpression(allocator, stream, tree, new_indent, start_col, expr, Space.Comma); // ,
887830 }
888831 }
889 if (exprs[exprs.len - 1].tag != .MultilineStringLiteral) {
890 try stream.writeByteNTimes(' ', indent);
891 }
892 return renderToken(tree, stream, rtoken, indent, start_col, space);
832 return renderToken(tree, ais, rtoken, space);
893833 } else {
894 try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
834 try renderToken(tree, ais, lbrace, Space.Space);
895835 for (exprs) |expr, i| {
896836 if (i + 1 < exprs.len) {
897 try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
898 const comma = tree.nextToken(expr.lastToken());
899 try renderToken(tree, stream, comma, indent, start_col, Space.Space); // ,
837 const next_expr = exprs[i + 1];
838 try renderExpression(allocator, ais, tree, expr, Space.None);
839 const comma = tree.nextToken(expr.*.lastToken());
840 try renderToken(tree, ais, comma, Space.Space); // ,
900841 } else {
901 try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.Space);
842 try renderExpression(allocator, ais, tree, expr, Space.Space);
902843 }
903844 }
904845
905 return renderToken(tree, stream, rtoken, indent, start_col, space);
846 return renderToken(tree, ais, rtoken, space);
906847 }
907848 },
908849
......@@ -932,11 +873,17 @@ fn renderExpression(
932873
933874 if (field_inits.len == 0) {
934875 switch (lhs) {
935 .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
936 .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
876 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
877 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
937878 }
938 try renderToken(tree, stream, lbrace, indent + indent_delta, start_col, Space.None);
939 return renderToken(tree, stream, rtoken, indent, start_col, space);
879
880 {
881 ais.pushIndentNextLine();
882 defer ais.popIndent();
883 try renderToken(tree, ais, lbrace, Space.None);
884 }
885
886 return renderToken(tree, ais, rtoken, space);
940887 }
941888
942889 const src_has_trailing_comma = blk: {
......@@ -952,9 +899,10 @@ fn renderExpression(
952899 const expr_outputs_one_line = blk: {
953900 // render field expressions until a LF is found
954901 for (field_inits) |field_init| {
955 var find_stream = FindByteOutStream.init('\n');
956 var dummy_col: usize = 0;
957 try renderExpression(allocator, find_stream.outStream(), tree, 0, &dummy_col, field_init, Space.None);
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());
904
905 try renderExpression(allocator, &auto_indenting_stream, tree, field_init, Space.None);
958906 if (find_stream.byte_found) break :blk false;
959907 }
960908 break :blk true;
......@@ -967,7 +915,6 @@ fn renderExpression(
967915 .StructInitializer,
968916 .StructInitializerDot,
969917 => break :blk,
970
971918 else => {},
972919 }
973920
......@@ -977,76 +924,78 @@ fn renderExpression(
977924 }
978925
979926 switch (lhs) {
980 .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
981 .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
927 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
928 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
982929 }
983 try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
984 try renderExpression(allocator, stream, tree, indent, start_col, &field_init.base, Space.Space);
985 return renderToken(tree, stream, rtoken, indent, start_col, 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);
986933 }
987934
988935 if (!src_has_trailing_comma and src_same_line and expr_outputs_one_line) {
989936 // render all on one line, no trailing comma
990937 switch (lhs) {
991 .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
992 .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
938 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
939 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
993940 }
994 try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
941 try renderToken(tree, ais, lbrace, Space.Space);
995942
996943 for (field_inits) |field_init, i| {
997944 if (i + 1 < field_inits.len) {
998 try renderExpression(allocator, stream, tree, indent, start_col, field_init, Space.None);
945 try renderExpression(allocator, ais, tree, field_init, Space.None);
999946
1000947 const comma = tree.nextToken(field_init.lastToken());
1001 try renderToken(tree, stream, comma, indent, start_col, Space.Space);
948 try renderToken(tree, ais, comma, Space.Space);
1002949 } else {
1003 try renderExpression(allocator, stream, tree, indent, start_col, field_init, Space.Space);
950 try renderExpression(allocator, ais, tree, field_init, Space.Space);
1004951 }
1005952 }
1006953
1007 return renderToken(tree, stream, rtoken, indent, start_col, space);
954 return renderToken(tree, ais, rtoken, space);
1008955 }
1009956
1010 const new_indent = indent + indent_delta;
957 {
958 switch (lhs) {
959 .dot => |dot| try renderToken(tree, ais, dot, Space.None),
960 .node => |node| try renderExpression(allocator, ais, tree, node, Space.None),
961 }
1011962
1012 switch (lhs) {
1013 .dot => |dot| try renderToken(tree, stream, dot, new_indent, start_col, Space.None),
1014 .node => |node| try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.None),
1015 }
1016 try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline);
963 ais.pushIndentNextLine();
964 defer ais.popIndent();
1017965
1018 for (field_inits) |field_init, i| {
1019 try stream.writeByteNTimes(' ', new_indent);
966 try renderToken(tree, ais, lbrace, Space.Newline);
1020967
1021 if (i + 1 < field_inits.len) {
1022 try renderExpression(allocator, stream, tree, new_indent, start_col, field_init, Space.None);
968 for (field_inits) |field_init, i| {
969 if (i + 1 < field_inits.len) {
970 const next_field_init = field_inits[i + 1];
971 try renderExpression(allocator, ais, tree, field_init, Space.None);
1023972
1024 const comma = tree.nextToken(field_init.lastToken());
1025 try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline);
973 const comma = tree.nextToken(field_init.lastToken());
974 try renderToken(tree, ais, comma, Space.Newline);
1026975
1027 try renderExtraNewline(tree, stream, start_col, field_inits[i + 1]);
1028 } else {
1029 try renderExpression(allocator, stream, tree, new_indent, start_col, field_init, Space.Comma);
976 try renderExtraNewline(tree, ais, next_field_init);
977 } else {
978 try renderExpression(allocator, ais, tree, field_init, Space.Comma);
979 }
1030980 }
1031981 }
1032982
1033 try stream.writeByteNTimes(' ', indent);
1034 return renderToken(tree, stream, rtoken, indent, start_col, space);
983 return renderToken(tree, ais, rtoken, space);
1035984 },
1036985
1037986 .Call => {
1038987 const call = @fieldParentPtr(ast.Node.Call, "base", base);
1039988 if (call.async_token) |async_token| {
1040 try renderToken(tree, stream, async_token, indent, start_col, Space.Space);
989 try renderToken(tree, ais, async_token, Space.Space);
1041990 }
1042991
1043 try renderExpression(allocator, stream, tree, indent, start_col, call.lhs, Space.None);
992 try renderExpression(allocator, ais, tree, call.lhs, Space.None);
1044993
1045994 const lparen = tree.nextToken(call.lhs.lastToken());
1046995
1047996 if (call.params_len == 0) {
1048 try renderToken(tree, stream, lparen, indent, start_col, Space.None);
1049 return renderToken(tree, stream, call.rtoken, indent, start_col, space);
997 try renderToken(tree, ais, lparen, Space.None);
998 return renderToken(tree, ais, call.rtoken, space);
1050999 }
10511000
10521001 const src_has_trailing_comma = blk: {
......@@ -1055,43 +1004,41 @@ fn renderExpression(
10551004 };
10561005
10571006 if (src_has_trailing_comma) {
1058 const new_indent = indent + indent_delta;
1059 try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline);
1007 try renderToken(tree, ais, lparen, Space.Newline);
10601008
10611009 const params = call.params();
10621010 for (params) |param_node, i| {
1063 const param_node_new_indent = if (param_node.tag == .MultilineStringLiteral) blk: {
1064 break :blk indent;
1065 } else blk: {
1066 try stream.writeByteNTimes(' ', new_indent);
1067 break :blk new_indent;
1068 };
1011 ais.pushIndent();
1012 defer ais.popIndent();
10691013
10701014 if (i + 1 < params.len) {
1071 try renderExpression(allocator, stream, tree, param_node_new_indent, start_col, param_node, Space.None);
1015 const next_node = params[i + 1];
1016 try renderExpression(allocator, ais, tree, param_node, Space.None);
10721017 const comma = tree.nextToken(param_node.lastToken());
1073 try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline); // ,
1074 try renderExtraNewline(tree, stream, start_col, params[i + 1]);
1018 try renderToken(tree, ais, comma, Space.Newline); // ,
1019 try renderExtraNewline(tree, ais, next_node);
10751020 } else {
1076 try renderExpression(allocator, stream, tree, param_node_new_indent, start_col, param_node, Space.Comma);
1077 try stream.writeByteNTimes(' ', indent);
1078 return renderToken(tree, stream, call.rtoken, indent, start_col, space);
1021 try renderExpression(allocator, ais, tree, param_node, Space.Comma);
10791022 }
10801023 }
1024 return renderToken(tree, ais, call.rtoken, space);
10811025 }
10821026
1083 try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
1027 try renderToken(tree, ais, lparen, Space.None); // (
10841028
10851029 const params = call.params();
10861030 for (params) |param_node, i| {
1087 try renderExpression(allocator, stream, tree, indent, start_col, param_node, Space.None);
1031 if (param_node.*.tag == .MultilineStringLiteral) ais.pushIndentOneShot();
1032
1033 try renderExpression(allocator, ais, tree, param_node, Space.None);
10881034
10891035 if (i + 1 < params.len) {
1036 const next_param = params[i + 1];
10901037 const comma = tree.nextToken(param_node.lastToken());
1091 try renderToken(tree, stream, comma, indent, start_col, Space.Space);
1038 try renderToken(tree, ais, comma, Space.Space);
10921039 }
10931040 }
1094 return renderToken(tree, stream, call.rtoken, indent, start_col, space);
1041 return renderToken(tree, ais, call.rtoken, space);
10951042 },
10961043
10971044 .ArrayAccess => {
......@@ -1100,26 +1047,25 @@ fn renderExpression(
11001047 const lbracket = tree.nextToken(suffix_op.lhs.lastToken());
11011048 const rbracket = tree.nextToken(suffix_op.index_expr.lastToken());
11021049
1103 try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
1104 try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
1050 try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
1051 try renderToken(tree, ais, lbracket, Space.None); // [
11051052
11061053 const starts_with_comment = tree.token_ids[lbracket + 1] == .LineComment;
11071054 const ends_with_comment = tree.token_ids[rbracket - 1] == .LineComment;
1108 const new_indent = if (ends_with_comment) indent + indent_delta else indent;
1109 const new_space = if (ends_with_comment) Space.Newline else Space.None;
1110 try renderExpression(allocator, stream, tree, new_indent, start_col, suffix_op.index_expr, new_space);
1111 if (starts_with_comment) {
1112 try stream.writeByte('\n');
1113 }
1114 if (ends_with_comment or starts_with_comment) {
1115 try stream.writeByteNTimes(' ', indent);
1055 {
1056 const new_space = if (ends_with_comment) Space.Newline else Space.None;
1057
1058 ais.pushIndent();
1059 defer ais.popIndent();
1060 try renderExpression(allocator, ais, tree, suffix_op.index_expr, new_space);
11161061 }
1117 return renderToken(tree, stream, rbracket, indent, start_col, space); // ]
1062 if (starts_with_comment) try ais.maybeInsertNewline();
1063 return renderToken(tree, ais, rbracket, space); // ]
11181064 },
1065
11191066 .Slice => {
11201067 const suffix_op = base.castTag(.Slice).?;
1121
1122 try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
1068 try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
11231069
11241070 const lbracket = tree.prevToken(suffix_op.start.firstToken());
11251071 const dotdot = tree.nextToken(suffix_op.start.lastToken());
......@@ -1129,32 +1075,33 @@ fn renderExpression(
11291075 const after_start_space = if (after_start_space_bool) Space.Space else Space.None;
11301076 const after_op_space = if (suffix_op.end != null) after_start_space else Space.None;
11311077
1132 try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
1133 try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.start, after_start_space);
1134 try renderToken(tree, stream, dotdot, indent, start_col, 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); // ..
11351081 if (suffix_op.end) |end| {
11361082 const after_end_space = if (suffix_op.sentinel != null) Space.Space else Space.None;
1137 try renderExpression(allocator, stream, tree, indent, start_col, end, after_end_space);
1083 try renderExpression(allocator, ais, tree, end, after_end_space);
11381084 }
11391085 if (suffix_op.sentinel) |sentinel| {
11401086 const colon = tree.prevToken(sentinel.firstToken());
1141 try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
1142 try renderExpression(allocator, stream, tree, indent, start_col, sentinel, Space.None);
1087 try renderToken(tree, ais, colon, Space.None); // :
1088 try renderExpression(allocator, ais, tree, sentinel, Space.None);
11431089 }
1144 return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // ]
1090 return renderToken(tree, ais, suffix_op.rtoken, space); // ]
11451091 },
1092
11461093 .Deref => {
11471094 const suffix_op = base.castTag(.Deref).?;
11481095
1149 try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
1150 return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // .*
1096 try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
1097 return renderToken(tree, ais, suffix_op.rtoken, space); // .*
11511098 },
11521099 .UnwrapOptional => {
11531100 const suffix_op = base.castTag(.UnwrapOptional).?;
11541101
1155 try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
1156 try renderToken(tree, stream, tree.prevToken(suffix_op.rtoken), indent, start_col, Space.None); // .
1157 return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, 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); // ?
11581105 },
11591106
11601107 .Break => {
......@@ -1163,145 +1110,152 @@ fn renderExpression(
11631110 const maybe_label = flow_expr.getLabel();
11641111
11651112 if (maybe_label == null and maybe_rhs == null) {
1166 return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space); // break
1113 return renderToken(tree, ais, flow_expr.ltoken, space); // break
11671114 }
11681115
1169 try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space); // break
1116 try renderToken(tree, ais, flow_expr.ltoken, Space.Space); // break
11701117 if (maybe_label) |label| {
11711118 const colon = tree.nextToken(flow_expr.ltoken);
1172 try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
1119 try renderToken(tree, ais, colon, Space.None); // :
11731120
11741121 if (maybe_rhs == null) {
1175 return renderToken(tree, stream, label, indent, start_col, space); // label
1122 return renderToken(tree, ais, label, space); // label
11761123 }
1177 try renderToken(tree, stream, label, indent, start_col, Space.Space); // label
1124 try renderToken(tree, ais, label, Space.Space); // label
11781125 }
1179 return renderExpression(allocator, stream, tree, indent, start_col, maybe_rhs.?, space);
1126 return renderExpression(allocator, ais, tree, maybe_rhs.?, space);
11801127 },
11811128
11821129 .Continue => {
11831130 const flow_expr = base.castTag(.Continue).?;
11841131 if (flow_expr.getLabel()) |label| {
1185 try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space); // continue
1132 try renderToken(tree, ais, flow_expr.ltoken, Space.Space); // continue
11861133 const colon = tree.nextToken(flow_expr.ltoken);
1187 try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
1188 return renderToken(tree, stream, label, indent, start_col, space); // label
1134 try renderToken(tree, ais, colon, Space.None); // :
1135 return renderToken(tree, ais, label, space); // label
11891136 } else {
1190 return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space); // continue
1137 return renderToken(tree, ais, flow_expr.ltoken, space); // continue
11911138 }
11921139 },
11931140
11941141 .Return => {
11951142 const flow_expr = base.castTag(.Return).?;
11961143 if (flow_expr.getRHS()) |rhs| {
1197 try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space);
1198 return renderExpression(allocator, stream, tree, indent, start_col, rhs, space);
1144 try renderToken(tree, ais, flow_expr.ltoken, Space.Space);
1145 return renderExpression(allocator, ais, tree, rhs, space);
11991146 } else {
1200 return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space);
1147 return renderToken(tree, ais, flow_expr.ltoken, space);
12011148 }
12021149 },
12031150
12041151 .Payload => {
12051152 const payload = @fieldParentPtr(ast.Node.Payload, "base", base);
12061153
1207 try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
1208 try renderExpression(allocator, stream, tree, indent, start_col, payload.error_symbol, Space.None);
1209 return renderToken(tree, stream, payload.rpipe, indent, start_col, 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);
12101157 },
12111158
12121159 .PointerPayload => {
12131160 const payload = @fieldParentPtr(ast.Node.PointerPayload, "base", base);
12141161
1215 try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
1162 try renderToken(tree, ais, payload.lpipe, Space.None);
12161163 if (payload.ptr_token) |ptr_token| {
1217 try renderToken(tree, stream, ptr_token, indent, start_col, Space.None);
1164 try renderToken(tree, ais, ptr_token, Space.None);
12181165 }
1219 try renderExpression(allocator, stream, tree, indent, start_col, payload.value_symbol, Space.None);
1220 return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
1166 try renderExpression(allocator, ais, tree, payload.value_symbol, Space.None);
1167 return renderToken(tree, ais, payload.rpipe, space);
12211168 },
12221169
12231170 .PointerIndexPayload => {
12241171 const payload = @fieldParentPtr(ast.Node.PointerIndexPayload, "base", base);
12251172
1226 try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
1173 try renderToken(tree, ais, payload.lpipe, Space.None);
12271174 if (payload.ptr_token) |ptr_token| {
1228 try renderToken(tree, stream, ptr_token, indent, start_col, Space.None);
1175 try renderToken(tree, ais, ptr_token, Space.None);
12291176 }
1230 try renderExpression(allocator, stream, tree, indent, start_col, payload.value_symbol, Space.None);
1177 try renderExpression(allocator, ais, tree, payload.value_symbol, Space.None);
12311178
12321179 if (payload.index_symbol) |index_symbol| {
12331180 const comma = tree.nextToken(payload.value_symbol.lastToken());
12341181
1235 try renderToken(tree, stream, comma, indent, start_col, Space.Space);
1236 try renderExpression(allocator, stream, tree, indent, start_col, index_symbol, Space.None);
1182 try renderToken(tree, ais, comma, Space.Space);
1183 try renderExpression(allocator, ais, tree, index_symbol, Space.None);
12371184 }
12381185
1239 return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
1186 return renderToken(tree, ais, payload.rpipe, space);
12401187 },
12411188
12421189 .GroupedExpression => {
12431190 const grouped_expr = @fieldParentPtr(ast.Node.GroupedExpression, "base", base);
12441191
1245 try renderToken(tree, stream, grouped_expr.lparen, indent, start_col, Space.None);
1246 try renderExpression(allocator, stream, tree, indent, start_col, grouped_expr.expr, Space.None);
1247 return renderToken(tree, stream, grouped_expr.rparen, indent, start_col, space);
1192 try renderToken(tree, ais, grouped_expr.lparen, Space.None);
1193 {
1194 ais.pushIndentOneShot();
1195 try renderExpression(allocator, ais, tree, grouped_expr.expr, Space.None);
1196 }
1197 return renderToken(tree, ais, grouped_expr.rparen, space);
12481198 },
12491199
12501200 .FieldInitializer => {
12511201 const field_init = @fieldParentPtr(ast.Node.FieldInitializer, "base", base);
12521202
1253 try renderToken(tree, stream, field_init.period_token, indent, start_col, Space.None); // .
1254 try renderToken(tree, stream, field_init.name_token, indent, start_col, Space.Space); // name
1255 try renderToken(tree, stream, tree.nextToken(field_init.name_token), indent, start_col, Space.Space); // =
1256 return renderExpression(allocator, stream, tree, indent, start_col, 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);
12571207 },
12581208
12591209 .ContainerDecl => {
12601210 const container_decl = @fieldParentPtr(ast.Node.ContainerDecl, "base", base);
12611211
12621212 if (container_decl.layout_token) |layout_token| {
1263 try renderToken(tree, stream, layout_token, indent, start_col, Space.Space);
1213 try renderToken(tree, ais, layout_token, Space.Space);
12641214 }
12651215
12661216 switch (container_decl.init_arg_expr) {
12671217 .None => {
1268 try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.Space); // union
1218 try renderToken(tree, ais, container_decl.kind_token, Space.Space); // union
12691219 },
12701220 .Enum => |enum_tag_type| {
1271 try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.None); // union
1221 try renderToken(tree, ais, container_decl.kind_token, Space.None); // union
12721222
12731223 const lparen = tree.nextToken(container_decl.kind_token);
12741224 const enum_token = tree.nextToken(lparen);
12751225
1276 try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
1277 try renderToken(tree, stream, enum_token, indent, start_col, Space.None); // enum
1226 try renderToken(tree, ais, lparen, Space.None); // (
1227 try renderToken(tree, ais, enum_token, Space.None); // enum
12781228
12791229 if (enum_tag_type) |expr| {
1280 try renderToken(tree, stream, tree.nextToken(enum_token), indent, start_col, Space.None); // (
1281 try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
1230 try renderToken(tree, ais, tree.nextToken(enum_token), Space.None); // (
1231 try renderExpression(allocator, ais, tree, expr, Space.None);
12821232
12831233 const rparen = tree.nextToken(expr.lastToken());
1284 try renderToken(tree, stream, rparen, indent, start_col, Space.None); // )
1285 try renderToken(tree, stream, tree.nextToken(rparen), indent, start_col, Space.Space); // )
1234 try renderToken(tree, ais, rparen, Space.None); // )
1235 try renderToken(tree, ais, tree.nextToken(rparen), Space.Space); // )
12861236 } else {
1287 try renderToken(tree, stream, tree.nextToken(enum_token), indent, start_col, Space.Space); // )
1237 try renderToken(tree, ais, tree.nextToken(enum_token), Space.Space); // )
12881238 }
12891239 },
12901240 .Type => |type_expr| {
1291 try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.None); // union
1241 try renderToken(tree, ais, container_decl.kind_token, Space.None); // union
12921242
12931243 const lparen = tree.nextToken(container_decl.kind_token);
12941244 const rparen = tree.nextToken(type_expr.lastToken());
12951245
1296 try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
1297 try renderExpression(allocator, stream, tree, indent, start_col, type_expr, Space.None);
1298 try renderToken(tree, stream, rparen, indent, start_col, 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); // )
12991249 },
13001250 }
13011251
13021252 if (container_decl.fields_and_decls_len == 0) {
1303 try renderToken(tree, stream, container_decl.lbrace_token, indent + indent_delta, start_col, Space.None); // {
1304 return renderToken(tree, stream, container_decl.rbrace_token, indent, start_col, space); // }
1253 {
1254 ais.pushIndentNextLine();
1255 defer ais.popIndent();
1256 try renderToken(tree, ais, container_decl.lbrace_token, Space.None); // {
1257 }
1258 return renderToken(tree, ais, container_decl.rbrace_token, space); // }
13051259 }
13061260
13071261 const src_has_trailing_comma = blk: {
......@@ -1332,43 +1286,39 @@ fn renderExpression(
13321286
13331287 if (src_has_trailing_comma or !src_has_only_fields) {
13341288 // One declaration per line
1335 const new_indent = indent + indent_delta;
1336 try renderToken(tree, stream, container_decl.lbrace_token, new_indent, start_col, .Newline); // {
1289 ais.pushIndentNextLine();
1290 defer ais.popIndent();
1291 try renderToken(tree, ais, container_decl.lbrace_token, .Newline); // {
13371292
13381293 for (fields_and_decls) |decl, i| {
1339 try stream.writeByteNTimes(' ', new_indent);
1340 try renderContainerDecl(allocator, stream, tree, new_indent, start_col, decl, .Newline);
1294 try renderContainerDecl(allocator, ais, tree, decl, .Newline);
13411295
13421296 if (i + 1 < fields_and_decls.len) {
1343 try renderExtraNewline(tree, stream, start_col, fields_and_decls[i + 1]);
1297 try renderExtraNewline(tree, ais, fields_and_decls[i + 1]);
13441298 }
13451299 }
1346
1347 try stream.writeByteNTimes(' ', indent);
13481300 } else if (src_has_newline) {
13491301 // All the declarations on the same line, but place the items on
13501302 // their own line
1351 try renderToken(tree, stream, container_decl.lbrace_token, indent, start_col, .Newline); // {
1303 try renderToken(tree, ais, container_decl.lbrace_token, .Newline); // {
13521304
1353 const new_indent = indent + indent_delta;
1354 try stream.writeByteNTimes(' ', new_indent);
1305 ais.pushIndent();
1306 defer ais.popIndent();
13551307
13561308 for (fields_and_decls) |decl, i| {
13571309 const space_after_decl: Space = if (i + 1 >= fields_and_decls.len) .Newline else .Space;
1358 try renderContainerDecl(allocator, stream, tree, new_indent, start_col, decl, space_after_decl);
1310 try renderContainerDecl(allocator, ais, tree, decl, space_after_decl);
13591311 }
1360
1361 try stream.writeByteNTimes(' ', indent);
13621312 } else {
13631313 // All the declarations on the same line
1364 try renderToken(tree, stream, container_decl.lbrace_token, indent, start_col, .Space); // {
1314 try renderToken(tree, ais, container_decl.lbrace_token, .Space); // {
13651315
13661316 for (fields_and_decls) |decl| {
1367 try renderContainerDecl(allocator, stream, tree, indent, start_col, decl, .Space);
1317 try renderContainerDecl(allocator, ais, tree, decl, .Space);
13681318 }
13691319 }
13701320
1371 return renderToken(tree, stream, container_decl.rbrace_token, indent, start_col, space); // }
1321 return renderToken(tree, ais, container_decl.rbrace_token, space); // }
13721322 },
13731323
13741324 .ErrorSetDecl => {
......@@ -1377,9 +1327,9 @@ fn renderExpression(
13771327 const lbrace = tree.nextToken(err_set_decl.error_token);
13781328
13791329 if (err_set_decl.decls_len == 0) {
1380 try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None);
1381 try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
1382 return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, 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);
13831333 }
13841334
13851335 if (err_set_decl.decls_len == 1) blk: {
......@@ -1393,13 +1343,13 @@ fn renderExpression(
13931343 break :blk;
13941344 }
13951345
1396 try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None); // error
1397 try renderToken(tree, stream, lbrace, indent, start_col, Space.None); // {
1398 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
1399 return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, 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); // }
14001350 }
14011351
1402 try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None); // error
1352 try renderToken(tree, ais, err_set_decl.error_token, Space.None); // error
14031353
14041354 const src_has_trailing_comma = blk: {
14051355 const maybe_comma = tree.prevToken(err_set_decl.rbrace_token);
......@@ -1407,72 +1357,66 @@ fn renderExpression(
14071357 };
14081358
14091359 if (src_has_trailing_comma) {
1410 try renderToken(tree, stream, lbrace, indent, start_col, Space.Newline); // {
1411 const new_indent = indent + indent_delta;
1412
1413 const decls = err_set_decl.decls();
1414 for (decls) |node, i| {
1415 try stream.writeByteNTimes(' ', new_indent);
1416
1417 if (i + 1 < decls.len) {
1418 try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.None);
1419 try renderToken(tree, stream, tree.nextToken(node.lastToken()), new_indent, start_col, Space.Newline); // ,
1420
1421 try renderExtraNewline(tree, stream, start_col, decls[i + 1]);
1422 } else {
1423 try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.Comma);
1360 {
1361 ais.pushIndent();
1362 defer ais.popIndent();
1363
1364 try renderToken(tree, ais, lbrace, Space.Newline); // {
1365 const decls = err_set_decl.decls();
1366 for (decls) |node, i| {
1367 if (i + 1 < decls.len) {
1368 try renderExpression(allocator, ais, tree, node, Space.None);
1369 try renderToken(tree, ais, tree.nextToken(node.lastToken()), Space.Newline); // ,
1370
1371 try renderExtraNewline(tree, ais, decls[i + 1]);
1372 } else {
1373 try renderExpression(allocator, ais, tree, node, Space.Comma);
1374 }
14241375 }
14251376 }
14261377
1427 try stream.writeByteNTimes(' ', indent);
1428 return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space); // }
1378 return renderToken(tree, ais, err_set_decl.rbrace_token, space); // }
14291379 } else {
1430 try renderToken(tree, stream, lbrace, indent, start_col, Space.Space); // {
1380 try renderToken(tree, ais, lbrace, Space.Space); // {
14311381
14321382 const decls = err_set_decl.decls();
14331383 for (decls) |node, i| {
14341384 if (i + 1 < decls.len) {
1435 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
1385 try renderExpression(allocator, ais, tree, node, Space.None);
14361386
14371387 const comma_token = tree.nextToken(node.lastToken());
14381388 assert(tree.token_ids[comma_token] == .Comma);
1439 try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
1440 try renderExtraNewline(tree, stream, start_col, decls[i + 1]);
1389 try renderToken(tree, ais, comma_token, Space.Space); // ,
1390 try renderExtraNewline(tree, ais, decls[i + 1]);
14411391 } else {
1442 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Space);
1392 try renderExpression(allocator, ais, tree, node, Space.Space);
14431393 }
14441394 }
14451395
1446 return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space); // }
1396 return renderToken(tree, ais, err_set_decl.rbrace_token, space); // }
14471397 }
14481398 },
14491399
14501400 .ErrorTag => {
14511401 const tag = @fieldParentPtr(ast.Node.ErrorTag, "base", base);
14521402
1453 try renderDocComments(tree, stream, tag, tag.doc_comments, indent, start_col);
1454 return renderToken(tree, stream, tag.name_token, indent, start_col, space); // name
1403 try renderDocComments(tree, ais, tag, tag.doc_comments);
1404 return renderToken(tree, ais, tag.name_token, space); // name
14551405 },
14561406
14571407 .MultilineStringLiteral => {
1458 // TODO: Don't indent in this function, but let the caller indent.
1459 // If this has been implemented, a lot of hacky solutions in i.e. ArrayInit and FunctionCall can be removed
14601408 const multiline_str_literal = @fieldParentPtr(ast.Node.MultilineStringLiteral, "base", base);
14611409
1462 var skip_first_indent = true;
1463 if (tree.token_ids[multiline_str_literal.firstToken() - 1] != .LineComment) {
1464 try stream.print("\n", .{});
1465 skip_first_indent = false;
1466 }
1467
1468 for (multiline_str_literal.lines()) |t| {
1469 if (!skip_first_indent) {
1470 try stream.writeByteNTimes(' ', indent + indent_delta);
1410 {
1411 const locked_indents = ais.lockOneShotIndent();
1412 defer {
1413 var i: u8 = 0;
1414 while (i < locked_indents) : (i += 1) ais.popIndent();
14711415 }
1472 try renderToken(tree, stream, t, indent, start_col, Space.None);
1473 skip_first_indent = false;
1416 try ais.maybeInsertNewline();
1417
1418 for (multiline_str_literal.lines()) |t| try renderToken(tree, ais, t, Space.None);
14741419 }
1475 try stream.writeByteNTimes(' ', indent);
14761420 },
14771421
14781422 .BuiltinCall => {
......@@ -1480,9 +1424,9 @@ fn renderExpression(
14801424
14811425 // TODO remove after 0.7.0 release
14821426 if (mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@OpaqueType"))
1483 return stream.writeAll("@Type(.Opaque)");
1427 return ais.writer().writeAll("@Type(.Opaque)");
14841428
1485 try renderToken(tree, stream, builtin_call.builtin_token, indent, start_col, Space.None); // @name
1429 try renderToken(tree, ais, builtin_call.builtin_token, Space.None); // @name
14861430
14871431 const src_params_trailing_comma = blk: {
14881432 if (builtin_call.params_len < 2) break :blk false;
......@@ -1494,31 +1438,30 @@ fn renderExpression(
14941438 const lparen = tree.nextToken(builtin_call.builtin_token);
14951439
14961440 if (!src_params_trailing_comma) {
1497 try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
1441 try renderToken(tree, ais, lparen, Space.None); // (
14981442
14991443 // render all on one line, no trailing comma
15001444 const params = builtin_call.params();
15011445 for (params) |param_node, i| {
1502 try renderExpression(allocator, stream, tree, indent, start_col, param_node, Space.None);
1446 try renderExpression(allocator, ais, tree, param_node, Space.None);
15031447
15041448 if (i + 1 < params.len) {
15051449 const comma_token = tree.nextToken(param_node.lastToken());
1506 try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
1450 try renderToken(tree, ais, comma_token, Space.Space); // ,
15071451 }
15081452 }
15091453 } else {
15101454 // one param per line
1511 const new_indent = indent + indent_delta;
1512 try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline); // (
1455 ais.pushIndent();
1456 defer ais.popIndent();
1457 try renderToken(tree, ais, lparen, Space.Newline); // (
15131458
15141459 for (builtin_call.params()) |param_node| {
1515 try stream.writeByteNTimes(' ', new_indent);
1516 try renderExpression(allocator, stream, tree, indent, start_col, param_node, Space.Comma);
1460 try renderExpression(allocator, ais, tree, param_node, Space.Comma);
15171461 }
1518 try stream.writeByteNTimes(' ', indent);
15191462 }
15201463
1521 return renderToken(tree, stream, builtin_call.rparen_token, indent, start_col, space); // )
1464 return renderToken(tree, ais, builtin_call.rparen_token, space); // )
15221465 },
15231466
15241467 .FnProto => {
......@@ -1528,24 +1471,24 @@ fn renderExpression(
15281471 const visib_token = tree.token_ids[visib_token_index];
15291472 assert(visib_token == .Keyword_pub or visib_token == .Keyword_export);
15301473
1531 try renderToken(tree, stream, visib_token_index, indent, start_col, Space.Space); // pub
1474 try renderToken(tree, ais, visib_token_index, Space.Space); // pub
15321475 }
15331476
15341477 if (fn_proto.getExternExportInlineToken()) |extern_export_inline_token| {
15351478 if (fn_proto.getIsExternPrototype() == null)
1536 try renderToken(tree, stream, extern_export_inline_token, indent, start_col, Space.Space); // extern/export/inline
1479 try renderToken(tree, ais, extern_export_inline_token, Space.Space); // extern/export/inline
15371480 }
15381481
15391482 if (fn_proto.getLibName()) |lib_name| {
1540 try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space);
1483 try renderExpression(allocator, ais, tree, lib_name, Space.Space);
15411484 }
15421485
15431486 const lparen = if (fn_proto.getNameToken()) |name_token| blk: {
1544 try renderToken(tree, stream, fn_proto.fn_token, indent, start_col, Space.Space); // fn
1545 try renderToken(tree, stream, name_token, indent, start_col, 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
15461489 break :blk tree.nextToken(name_token);
15471490 } else blk: {
1548 try renderToken(tree, stream, fn_proto.fn_token, indent, start_col, Space.Space); // fn
1491 try renderToken(tree, ais, fn_proto.fn_token, Space.Space); // fn
15491492 break :blk tree.nextToken(fn_proto.fn_token);
15501493 };
15511494 assert(tree.token_ids[lparen] == .LParen);
......@@ -1572,47 +1515,45 @@ fn renderExpression(
15721515 };
15731516
15741517 if (!src_params_trailing_comma) {
1575 try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
1518 try renderToken(tree, ais, lparen, Space.None); // (
15761519
15771520 // render all on one line, no trailing comma
15781521 for (fn_proto.params()) |param_decl, i| {
1579 try renderParamDecl(allocator, stream, tree, indent, start_col, param_decl, Space.None);
1522 try renderParamDecl(allocator, ais, tree, param_decl, Space.None);
15801523
15811524 if (i + 1 < fn_proto.params_len or fn_proto.getVarArgsToken() != null) {
15821525 const comma = tree.nextToken(param_decl.lastToken());
1583 try renderToken(tree, stream, comma, indent, start_col, Space.Space); // ,
1526 try renderToken(tree, ais, comma, Space.Space); // ,
15841527 }
15851528 }
15861529 if (fn_proto.getVarArgsToken()) |var_args_token| {
1587 try renderToken(tree, stream, var_args_token, indent, start_col, Space.None);
1530 try renderToken(tree, ais, var_args_token, Space.None);
15881531 }
15891532 } else {
15901533 // one param per line
1591 const new_indent = indent + indent_delta;
1592 try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline); // (
1534 ais.pushIndent();
1535 defer ais.popIndent();
1536 try renderToken(tree, ais, lparen, Space.Newline); // (
15931537
15941538 for (fn_proto.params()) |param_decl| {
1595 try stream.writeByteNTimes(' ', new_indent);
1596 try renderParamDecl(allocator, stream, tree, new_indent, start_col, param_decl, Space.Comma);
1539 try renderParamDecl(allocator, ais, tree, param_decl, Space.Comma);
15971540 }
15981541 if (fn_proto.getVarArgsToken()) |var_args_token| {
1599 try stream.writeByteNTimes(' ', new_indent);
1600 try renderToken(tree, stream, var_args_token, new_indent, start_col, Space.Comma);
1542 try renderToken(tree, ais, var_args_token, Space.Comma);
16011543 }
1602 try stream.writeByteNTimes(' ', indent);
16031544 }
16041545
1605 try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
1546 try renderToken(tree, ais, rparen, Space.Space); // )
16061547
16071548 if (fn_proto.getAlignExpr()) |align_expr| {
16081549 const align_rparen = tree.nextToken(align_expr.lastToken());
16091550 const align_lparen = tree.prevToken(align_expr.firstToken());
16101551 const align_kw = tree.prevToken(align_lparen);
16111552
1612 try renderToken(tree, stream, align_kw, indent, start_col, Space.None); // align
1613 try renderToken(tree, stream, align_lparen, indent, start_col, Space.None); // (
1614 try renderExpression(allocator, stream, tree, indent, start_col, align_expr, Space.None);
1615 try renderToken(tree, stream, align_rparen, indent, start_col, 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); // )
16161557 }
16171558
16181559 if (fn_proto.getSectionExpr()) |section_expr| {
......@@ -1620,10 +1561,10 @@ fn renderExpression(
16201561 const section_lparen = tree.prevToken(section_expr.firstToken());
16211562 const section_kw = tree.prevToken(section_lparen);
16221563
1623 try renderToken(tree, stream, section_kw, indent, start_col, Space.None); // section
1624 try renderToken(tree, stream, section_lparen, indent, start_col, Space.None); // (
1625 try renderExpression(allocator, stream, tree, indent, start_col, section_expr, Space.None);
1626 try renderToken(tree, stream, section_rparen, indent, start_col, 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); // )
16271568 }
16281569
16291570 if (fn_proto.getCallconvExpr()) |callconv_expr| {
......@@ -1631,23 +1572,23 @@ fn renderExpression(
16311572 const callconv_lparen = tree.prevToken(callconv_expr.firstToken());
16321573 const callconv_kw = tree.prevToken(callconv_lparen);
16331574
1634 try renderToken(tree, stream, callconv_kw, indent, start_col, Space.None); // callconv
1635 try renderToken(tree, stream, callconv_lparen, indent, start_col, Space.None); // (
1636 try renderExpression(allocator, stream, tree, indent, start_col, callconv_expr, Space.None);
1637 try renderToken(tree, stream, callconv_rparen, indent, start_col, 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); // )
16381579 } else if (fn_proto.getIsExternPrototype() != null) {
1639 try stream.writeAll("callconv(.C) ");
1580 try ais.writer().writeAll("callconv(.C) ");
16401581 } else if (fn_proto.getIsAsync() != null) {
1641 try stream.writeAll("callconv(.Async) ");
1582 try ais.writer().writeAll("callconv(.Async) ");
16421583 }
16431584
16441585 switch (fn_proto.return_type) {
16451586 .Explicit => |node| {
1646 return renderExpression(allocator, stream, tree, indent, start_col, node, space);
1587 return renderExpression(allocator, ais, tree, node, space);
16471588 },
16481589 .InferErrorSet => |node| {
1649 try renderToken(tree, stream, tree.prevToken(node.firstToken()), indent, start_col, Space.None); // !
1650 return renderExpression(allocator, stream, tree, indent, start_col, node, space);
1590 try renderToken(tree, ais, tree.prevToken(node.firstToken()), Space.None); // !
1591 return renderExpression(allocator, ais, tree, node, space);
16511592 },
16521593 .Invalid => unreachable,
16531594 }
......@@ -1657,11 +1598,11 @@ fn renderExpression(
16571598 const anyframe_type = @fieldParentPtr(ast.Node.AnyFrameType, "base", base);
16581599
16591600 if (anyframe_type.result) |result| {
1660 try renderToken(tree, stream, anyframe_type.anyframe_token, indent, start_col, Space.None); // anyframe
1661 try renderToken(tree, stream, result.arrow_token, indent, start_col, Space.None); // ->
1662 return renderExpression(allocator, stream, tree, indent, start_col, 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);
16631604 } else {
1664 return renderToken(tree, stream, anyframe_type.anyframe_token, indent, start_col, space); // anyframe
1605 return renderToken(tree, ais, anyframe_type.anyframe_token, space); // anyframe
16651606 }
16661607 },
16671608
......@@ -1670,38 +1611,38 @@ fn renderExpression(
16701611 .Switch => {
16711612 const switch_node = @fieldParentPtr(ast.Node.Switch, "base", base);
16721613
1673 try renderToken(tree, stream, switch_node.switch_token, indent, start_col, Space.Space); // switch
1674 try renderToken(tree, stream, tree.nextToken(switch_node.switch_token), indent, start_col, 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); // (
16751616
16761617 const rparen = tree.nextToken(switch_node.expr.lastToken());
16771618 const lbrace = tree.nextToken(rparen);
16781619
16791620 if (switch_node.cases_len == 0) {
1680 try renderExpression(allocator, stream, tree, indent, start_col, switch_node.expr, Space.None);
1681 try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
1682 try renderToken(tree, stream, lbrace, indent, start_col, Space.None); // {
1683 return renderToken(tree, stream, switch_node.rbrace, indent, start_col, 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); // }
16841625 }
16851626
1686 try renderExpression(allocator, stream, tree, indent, start_col, switch_node.expr, Space.None);
1687
1688 const new_indent = indent + indent_delta;
1627 try renderExpression(allocator, ais, tree, switch_node.expr, Space.None);
1628 try renderToken(tree, ais, rparen, Space.Space); // )
16891629
1690 try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
1691 try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline); // {
1630 {
1631 ais.pushIndentNextLine();
1632 defer ais.popIndent();
1633 try renderToken(tree, ais, lbrace, Space.Newline); // {
16921634
1693 const cases = switch_node.cases();
1694 for (cases) |node, i| {
1695 try stream.writeByteNTimes(' ', new_indent);
1696 try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.Comma);
1635 const cases = switch_node.cases();
1636 for (cases) |node, i| {
1637 try renderExpression(allocator, ais, tree, node, Space.Comma);
16971638
1698 if (i + 1 < cases.len) {
1699 try renderExtraNewline(tree, stream, start_col, cases[i + 1]);
1639 if (i + 1 < cases.len) {
1640 try renderExtraNewline(tree, ais, cases[i + 1]);
1641 }
17001642 }
17011643 }
17021644
1703 try stream.writeByteNTimes(' ', indent);
1704 return renderToken(tree, stream, switch_node.rbrace, indent, start_col, space); // }
1645 return renderToken(tree, ais, switch_node.rbrace, space); // }
17051646 },
17061647
17071648 .SwitchCase => {
......@@ -1718,43 +1659,41 @@ fn renderExpression(
17181659 const items = switch_case.items();
17191660 for (items) |node, i| {
17201661 if (i + 1 < items.len) {
1721 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
1662 try renderExpression(allocator, ais, tree, node, Space.None);
17221663
17231664 const comma_token = tree.nextToken(node.lastToken());
1724 try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
1725 try renderExtraNewline(tree, stream, start_col, items[i + 1]);
1665 try renderToken(tree, ais, comma_token, Space.Space); // ,
1666 try renderExtraNewline(tree, ais, items[i + 1]);
17261667 } else {
1727 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Space);
1668 try renderExpression(allocator, ais, tree, node, Space.Space);
17281669 }
17291670 }
17301671 } else {
17311672 const items = switch_case.items();
17321673 for (items) |node, i| {
17331674 if (i + 1 < items.len) {
1734 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
1675 try renderExpression(allocator, ais, tree, node, Space.None);
17351676
17361677 const comma_token = tree.nextToken(node.lastToken());
1737 try renderToken(tree, stream, comma_token, indent, start_col, Space.Newline); // ,
1738 try renderExtraNewline(tree, stream, start_col, items[i + 1]);
1739 try stream.writeByteNTimes(' ', indent);
1678 try renderToken(tree, ais, comma_token, Space.Newline); // ,
1679 try renderExtraNewline(tree, ais, items[i + 1]);
17401680 } else {
1741 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Comma);
1742 try stream.writeByteNTimes(' ', indent);
1681 try renderExpression(allocator, ais, tree, node, Space.Comma);
17431682 }
17441683 }
17451684 }
17461685
1747 try renderToken(tree, stream, switch_case.arrow_token, indent, start_col, Space.Space); // =>
1686 try renderToken(tree, ais, switch_case.arrow_token, Space.Space); // =>
17481687
17491688 if (switch_case.payload) |payload| {
1750 try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
1689 try renderExpression(allocator, ais, tree, payload, Space.Space);
17511690 }
17521691
1753 return renderExpression(allocator, stream, tree, indent, start_col, switch_case.expr, space);
1692 return renderExpression(allocator, ais, tree, switch_case.expr, space);
17541693 },
17551694 .SwitchElse => {
17561695 const switch_else = @fieldParentPtr(ast.Node.SwitchElse, "base", base);
1757 return renderToken(tree, stream, switch_else.token, indent, start_col, space);
1696 return renderToken(tree, ais, switch_else.token, space);
17581697 },
17591698 .Else => {
17601699 const else_node = @fieldParentPtr(ast.Node.Else, "base", base);
......@@ -1763,37 +1702,37 @@ fn renderExpression(
17631702 const same_line = body_is_block or tree.tokensOnSameLine(else_node.else_token, else_node.body.lastToken());
17641703
17651704 const after_else_space = if (same_line or else_node.payload != null) Space.Space else Space.Newline;
1766 try renderToken(tree, stream, else_node.else_token, indent, start_col, after_else_space);
1705 try renderToken(tree, ais, else_node.else_token, after_else_space);
17671706
17681707 if (else_node.payload) |payload| {
17691708 const payload_space = if (same_line) Space.Space else Space.Newline;
1770 try renderExpression(allocator, stream, tree, indent, start_col, payload, payload_space);
1709 try renderExpression(allocator, ais, tree, payload, payload_space);
17711710 }
17721711
17731712 if (same_line) {
1774 return renderExpression(allocator, stream, tree, indent, start_col, else_node.body, space);
1713 return renderExpression(allocator, ais, tree, else_node.body, space);
1714 } else {
1715 ais.pushIndent();
1716 defer ais.popIndent();
1717 return renderExpression(allocator, ais, tree, else_node.body, space);
17751718 }
1776
1777 try stream.writeByteNTimes(' ', indent + indent_delta);
1778 start_col.* = indent + indent_delta;
1779 return renderExpression(allocator, stream, tree, indent, start_col, else_node.body, space);
17801719 },
17811720
17821721 .While => {
17831722 const while_node = @fieldParentPtr(ast.Node.While, "base", base);
17841723
17851724 if (while_node.label) |label| {
1786 try renderToken(tree, stream, label, indent, start_col, Space.None); // label
1787 try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space); // :
1725 try renderToken(tree, ais, label, Space.None); // label
1726 try renderToken(tree, ais, tree.nextToken(label), Space.Space); // :
17881727 }
17891728
17901729 if (while_node.inline_token) |inline_token| {
1791 try renderToken(tree, stream, inline_token, indent, start_col, Space.Space); // inline
1730 try renderToken(tree, ais, inline_token, Space.Space); // inline
17921731 }
17931732
1794 try renderToken(tree, stream, while_node.while_token, indent, start_col, Space.Space); // while
1795 try renderToken(tree, stream, tree.nextToken(while_node.while_token), indent, start_col, Space.None); // (
1796 try renderExpression(allocator, stream, tree, indent, start_col, 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);
17971736
17981737 const cond_rparen = tree.nextToken(while_node.condition.lastToken());
17991738
......@@ -1815,12 +1754,12 @@ fn renderExpression(
18151754
18161755 {
18171756 const rparen_space = if (while_node.payload != null or while_node.continue_expr != null) Space.Space else block_start_space;
1818 try renderToken(tree, stream, cond_rparen, indent, start_col, rparen_space); // )
1757 try renderToken(tree, ais, cond_rparen, rparen_space); // )
18191758 }
18201759
18211760 if (while_node.payload) |payload| {
1822 const payload_space = if (while_node.continue_expr != null) Space.Space else block_start_space;
1823 try renderExpression(allocator, stream, tree, indent, start_col, payload, payload_space);
1761 const payload_space = Space.Space; //if (while_node.continue_expr != null) Space.Space else block_start_space;
1762 try renderExpression(allocator, ais, tree, payload, payload_space);
18241763 }
18251764
18261765 if (while_node.continue_expr) |continue_expr| {
......@@ -1828,29 +1767,22 @@ fn renderExpression(
18281767 const lparen = tree.prevToken(continue_expr.firstToken());
18291768 const colon = tree.prevToken(lparen);
18301769
1831 try renderToken(tree, stream, colon, indent, start_col, Space.Space); // :
1832 try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
1770 try renderToken(tree, ais, colon, Space.Space); // :
1771 try renderToken(tree, ais, lparen, Space.None); // (
18331772
1834 try renderExpression(allocator, stream, tree, indent, start_col, continue_expr, Space.None);
1773 try renderExpression(allocator, ais, tree, continue_expr, Space.None);
18351774
1836 try renderToken(tree, stream, rparen, indent, start_col, block_start_space); // )
1775 try renderToken(tree, ais, rparen, block_start_space); // )
18371776 }
18381777
1839 var new_indent = indent;
1840 if (block_start_space == Space.Newline) {
1841 new_indent += indent_delta;
1842 try stream.writeByteNTimes(' ', new_indent);
1843 start_col.* = new_indent;
1778 {
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);
18441782 }
18451783
1846 try renderExpression(allocator, stream, tree, indent, start_col, while_node.body, after_body_space);
1847
18481784 if (while_node.@"else") |@"else"| {
1849 if (after_body_space == Space.Newline) {
1850 try stream.writeByteNTimes(' ', indent);
1851 start_col.* = indent;
1852 }
1853 return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space);
1785 return renderExpression(allocator, ais, tree, &@"else".base, space);
18541786 }
18551787 },
18561788
......@@ -1858,17 +1790,17 @@ fn renderExpression(
18581790 const for_node = @fieldParentPtr(ast.Node.For, "base", base);
18591791
18601792 if (for_node.label) |label| {
1861 try renderToken(tree, stream, label, indent, start_col, Space.None); // label
1862 try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space); // :
1793 try renderToken(tree, ais, label, Space.None); // label
1794 try renderToken(tree, ais, tree.nextToken(label), Space.Space); // :
18631795 }
18641796
18651797 if (for_node.inline_token) |inline_token| {
1866 try renderToken(tree, stream, inline_token, indent, start_col, Space.Space); // inline
1798 try renderToken(tree, ais, inline_token, Space.Space); // inline
18671799 }
18681800
1869 try renderToken(tree, stream, for_node.for_token, indent, start_col, Space.Space); // for
1870 try renderToken(tree, stream, tree.nextToken(for_node.for_token), indent, start_col, Space.None); // (
1871 try renderExpression(allocator, stream, tree, indent, start_col, 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);
18721804
18731805 const rparen = tree.nextToken(for_node.array_expr.lastToken());
18741806
......@@ -1876,10 +1808,10 @@ fn renderExpression(
18761808 const src_one_line_to_body = !body_is_block and tree.tokensOnSameLine(rparen, for_node.body.firstToken());
18771809 const body_on_same_line = body_is_block or src_one_line_to_body;
18781810
1879 try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
1811 try renderToken(tree, ais, rparen, Space.Space); // )
18801812
18811813 const space_after_payload = if (body_on_same_line) Space.Space else Space.Newline;
1882 try renderExpression(allocator, stream, tree, indent, start_col, for_node.payload, space_after_payload); // |x|
1814 try renderExpression(allocator, ais, tree, for_node.payload, space_after_payload); // |x|
18831815
18841816 const space_after_body = blk: {
18851817 if (for_node.@"else") |@"else"| {
......@@ -1894,13 +1826,14 @@ fn renderExpression(
18941826 }
18951827 };
18961828
1897 const body_indent = if (body_on_same_line) indent else indent + indent_delta;
1898 if (!body_on_same_line) try stream.writeByteNTimes(' ', body_indent);
1899 try renderExpression(allocator, stream, tree, body_indent, start_col, for_node.body, space_after_body); // { body }
1829 {
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 }
1833 }
19001834
19011835 if (for_node.@"else") |@"else"| {
1902 if (space_after_body == Space.Newline) try stream.writeByteNTimes(' ', indent);
1903 return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space); // else
1836 return renderExpression(allocator, ais, tree, &@"else".base, space); // else
19041837 }
19051838 },
19061839
......@@ -1910,29 +1843,29 @@ fn renderExpression(
19101843 const lparen = tree.nextToken(if_node.if_token);
19111844 const rparen = tree.nextToken(if_node.condition.lastToken());
19121845
1913 try renderToken(tree, stream, if_node.if_token, indent, start_col, Space.Space); // if
1914 try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
1846 try renderToken(tree, ais, if_node.if_token, Space.Space); // if
1847 try renderToken(tree, ais, lparen, Space.None); // (
19151848
1916 try renderExpression(allocator, stream, tree, indent, start_col, if_node.condition, Space.None); // condition
1849 try renderExpression(allocator, ais, tree, if_node.condition, Space.None); // condition
19171850
19181851 const body_is_if_block = if_node.body.tag == .If;
19191852 const body_is_block = nodeIsBlock(if_node.body);
19201853
19211854 if (body_is_if_block) {
1922 try renderExtraNewline(tree, stream, start_col, if_node.body);
1855 try renderExtraNewline(tree, ais, if_node.body);
19231856 } else if (body_is_block) {
19241857 const after_rparen_space = if (if_node.payload == null) Space.BlockStart else Space.Space;
1925 try renderToken(tree, stream, rparen, indent, start_col, after_rparen_space); // )
1858 try renderToken(tree, ais, rparen, after_rparen_space); // )
19261859
19271860 if (if_node.payload) |payload| {
1928 try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.BlockStart); // |x|
1861 try renderExpression(allocator, ais, tree, payload, Space.BlockStart); // |x|
19291862 }
19301863
19311864 if (if_node.@"else") |@"else"| {
1932 try renderExpression(allocator, stream, tree, indent, start_col, if_node.body, Space.SpaceOrOutdent);
1933 return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space);
1865 try renderExpression(allocator, ais, tree, if_node.body, Space.SpaceOrOutdent);
1866 return renderExpression(allocator, ais, tree, &@"else".base, space);
19341867 } else {
1935 return renderExpression(allocator, stream, tree, indent, start_col, if_node.body, space);
1868 return renderExpression(allocator, ais, tree, if_node.body, space);
19361869 }
19371870 }
19381871
......@@ -1940,186 +1873,184 @@ fn renderExpression(
19401873
19411874 if (src_has_newline) {
19421875 const after_rparen_space = if (if_node.payload == null) Space.Newline else Space.Space;
1943 try renderToken(tree, stream, rparen, indent, start_col, after_rparen_space); // )
1876 try renderToken(tree, ais, rparen, after_rparen_space); // )
19441877
19451878 if (if_node.payload) |payload| {
1946 try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Newline);
1879 try renderExpression(allocator, ais, tree, payload, Space.Newline);
19471880 }
19481881
1949 const new_indent = indent + indent_delta;
1950 try stream.writeByteNTimes(' ', new_indent);
1951
19521882 if (if_node.@"else") |@"else"| {
19531883 const else_is_block = nodeIsBlock(@"else".body);
1954 try renderExpression(allocator, stream, tree, new_indent, start_col, if_node.body, Space.Newline);
1955 try stream.writeByteNTimes(' ', indent);
1884
1885 {
1886 ais.pushIndent();
1887 defer ais.popIndent();
1888 try renderExpression(allocator, ais, tree, if_node.body, Space.Newline);
1889 }
19561890
19571891 if (else_is_block) {
1958 try renderToken(tree, stream, @"else".else_token, indent, start_col, Space.Space); // else
1892 try renderToken(tree, ais, @"else".else_token, Space.Space); // else
19591893
19601894 if (@"else".payload) |payload| {
1961 try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
1895 try renderExpression(allocator, ais, tree, payload, Space.Space);
19621896 }
19631897
1964 return renderExpression(allocator, stream, tree, indent, start_col, @"else".body, space);
1898 return renderExpression(allocator, ais, tree, @"else".body, space);
19651899 } else {
19661900 const after_else_space = if (@"else".payload == null) Space.Newline else Space.Space;
1967 try renderToken(tree, stream, @"else".else_token, indent, start_col, after_else_space); // else
1901 try renderToken(tree, ais, @"else".else_token, after_else_space); // else
19681902
19691903 if (@"else".payload) |payload| {
1970 try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Newline);
1904 try renderExpression(allocator, ais, tree, payload, Space.Newline);
19711905 }
1972 try stream.writeByteNTimes(' ', new_indent);
19731906
1974 return renderExpression(allocator, stream, tree, new_indent, start_col, @"else".body, space);
1907 ais.pushIndent();
1908 defer ais.popIndent();
1909 return renderExpression(allocator, ais, tree, @"else".body, space);
19751910 }
19761911 } else {
1977 return renderExpression(allocator, stream, tree, new_indent, start_col, if_node.body, space);
1912 ais.pushIndent();
1913 defer ais.popIndent();
1914 return renderExpression(allocator, ais, tree, if_node.body, space);
19781915 }
19791916 }
19801917
1981 try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
1918 // Single line if statement
1919
1920 try renderToken(tree, ais, rparen, Space.Space); // )
19821921
19831922 if (if_node.payload) |payload| {
1984 try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
1923 try renderExpression(allocator, ais, tree, payload, Space.Space);
19851924 }
19861925
19871926 if (if_node.@"else") |@"else"| {
1988 try renderExpression(allocator, stream, tree, indent, start_col, if_node.body, Space.Space);
1989 try renderToken(tree, stream, @"else".else_token, indent, start_col, Space.Space);
1927 try renderExpression(allocator, ais, tree, if_node.body, Space.Space);
1928 try renderToken(tree, ais, @"else".else_token, Space.Space);
19901929
19911930 if (@"else".payload) |payload| {
1992 try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
1931 try renderExpression(allocator, ais, tree, payload, Space.Space);
19931932 }
19941933
1995 return renderExpression(allocator, stream, tree, indent, start_col, @"else".body, space);
1934 return renderExpression(allocator, ais, tree, @"else".body, space);
19961935 } else {
1997 return renderExpression(allocator, stream, tree, indent, start_col, if_node.body, space);
1936 return renderExpression(allocator, ais, tree, if_node.body, space);
19981937 }
19991938 },
20001939
20011940 .Asm => {
20021941 const asm_node = @fieldParentPtr(ast.Node.Asm, "base", base);
20031942
2004 try renderToken(tree, stream, asm_node.asm_token, indent, start_col, Space.Space); // asm
1943 try renderToken(tree, ais, asm_node.asm_token, Space.Space); // asm
20051944
20061945 if (asm_node.volatile_token) |volatile_token| {
2007 try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space); // volatile
2008 try renderToken(tree, stream, tree.nextToken(volatile_token), indent, start_col, Space.None); // (
1946 try renderToken(tree, ais, volatile_token, Space.Space); // volatile
1947 try renderToken(tree, ais, tree.nextToken(volatile_token), Space.None); // (
20091948 } else {
2010 try renderToken(tree, stream, tree.nextToken(asm_node.asm_token), indent, start_col, Space.None); // (
1949 try renderToken(tree, ais, tree.nextToken(asm_node.asm_token), Space.None); // (
20111950 }
20121951
2013 if (asm_node.outputs.len == 0 and asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
2014 try renderExpression(allocator, stream, tree, indent, start_col, asm_node.template, Space.None);
2015 return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
2016 }
1952 asmblk: {
1953 ais.pushIndent();
1954 defer ais.popIndent();
20171955
2018 try renderExpression(allocator, stream, tree, indent, start_col, asm_node.template, Space.Newline);
1956 if (asm_node.outputs.len == 0 and asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
1957 try renderExpression(allocator, ais, tree, asm_node.template, Space.None);
1958 break :asmblk;
1959 }
20191960
2020 const indent_once = indent + indent_delta;
1961 try renderExpression(allocator, ais, tree, asm_node.template, Space.Newline);
20211962
2022 if (asm_node.template.tag == .MultilineStringLiteral) {
2023 // After rendering a multiline string literal the cursor is
2024 // already offset by indent
2025 try stream.writeByteNTimes(' ', indent_delta);
2026 } else {
2027 try stream.writeByteNTimes(' ', indent_once);
2028 }
1963 ais.setIndentDelta(asm_indent_delta);
1964 defer ais.setIndentDelta(indent_delta);
20291965
2030 const colon1 = tree.nextToken(asm_node.template.lastToken());
2031 const indent_extra = indent_once + 2;
1966 const colon1 = tree.nextToken(asm_node.template.lastToken());
20321967
2033 const colon2 = if (asm_node.outputs.len == 0) blk: {
2034 try renderToken(tree, stream, colon1, indent, start_col, Space.Newline); // :
2035 try stream.writeByteNTimes(' ', indent_once);
1968 const colon2 = if (asm_node.outputs.len == 0) blk: {
1969 try renderToken(tree, ais, colon1, Space.Newline); // :
20361970
2037 break :blk tree.nextToken(colon1);
2038 } else blk: {
2039 try renderToken(tree, stream, colon1, indent, start_col, Space.Space); // :
2040
2041 for (asm_node.outputs) |*asm_output, i| {
2042 if (i + 1 < asm_node.outputs.len) {
2043 const next_asm_output = asm_node.outputs[i + 1];
2044 try renderAsmOutput(allocator, stream, tree, indent_extra, start_col, asm_output, Space.None);
2045
2046 const comma = tree.prevToken(next_asm_output.firstToken());
2047 try renderToken(tree, stream, comma, indent_extra, start_col, Space.Newline); // ,
2048 try renderExtraNewlineToken(tree, stream, start_col, next_asm_output.firstToken());
2049
2050 try stream.writeByteNTimes(' ', indent_extra);
2051 } else if (asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
2052 try renderAsmOutput(allocator, stream, tree, indent_extra, start_col, asm_output, Space.Newline);
2053 try stream.writeByteNTimes(' ', indent);
2054 return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
2055 } else {
2056 try renderAsmOutput(allocator, stream, tree, indent_extra, start_col, asm_output, Space.Newline);
2057 try stream.writeByteNTimes(' ', indent_once);
2058 const comma_or_colon = tree.nextToken(asm_output.lastToken());
2059 break :blk switch (tree.token_ids[comma_or_colon]) {
2060 .Comma => tree.nextToken(comma_or_colon),
2061 else => comma_or_colon,
2062 };
2063 }
2064 }
2065 unreachable;
2066 };
1971 break :blk tree.nextToken(colon1);
1972 } else blk: {
1973 try renderToken(tree, ais, colon1, Space.Space); // :
20671974
2068 const colon3 = if (asm_node.inputs.len == 0) blk: {
2069 try renderToken(tree, stream, colon2, indent, start_col, Space.Newline); // :
2070 try stream.writeByteNTimes(' ', indent_once);
1975 ais.pushIndent();
1976 defer ais.popIndent();
20711977
2072 break :blk tree.nextToken(colon2);
2073 } else blk: {
2074 try renderToken(tree, stream, colon2, indent, start_col, Space.Space); // :
2075
2076 for (asm_node.inputs) |*asm_input, i| {
2077 if (i + 1 < asm_node.inputs.len) {
2078 const next_asm_input = &asm_node.inputs[i + 1];
2079 try renderAsmInput(allocator, stream, tree, indent_extra, start_col, asm_input, Space.None);
2080
2081 const comma = tree.prevToken(next_asm_input.firstToken());
2082 try renderToken(tree, stream, comma, indent_extra, start_col, Space.Newline); // ,
2083 try renderExtraNewlineToken(tree, stream, start_col, next_asm_input.firstToken());
2084
2085 try stream.writeByteNTimes(' ', indent_extra);
2086 } else if (asm_node.clobbers.len == 0) {
2087 try renderAsmInput(allocator, stream, tree, indent_extra, start_col, asm_input, Space.Newline);
2088 try stream.writeByteNTimes(' ', indent);
2089 return renderToken(tree, stream, asm_node.rparen, indent, start_col, space); // )
2090 } else {
2091 try renderAsmInput(allocator, stream, tree, indent_extra, start_col, asm_input, Space.Newline);
2092 try stream.writeByteNTimes(' ', indent_once);
2093 const comma_or_colon = tree.nextToken(asm_input.lastToken());
2094 break :blk switch (tree.token_ids[comma_or_colon]) {
2095 .Comma => tree.nextToken(comma_or_colon),
2096 else => comma_or_colon,
2097 };
1978 for (asm_node.outputs) |*asm_output, i| {
1979 if (i + 1 < asm_node.outputs.len) {
1980 const next_asm_output = asm_node.outputs[i + 1];
1981 try renderAsmOutput(allocator, ais, tree, asm_output, Space.None);
1982
1983 const comma = tree.prevToken(next_asm_output.firstToken());
1984 try renderToken(tree, ais, comma, Space.Newline); // ,
1985 try renderExtraNewlineToken(tree, ais, next_asm_output.firstToken());
1986 } else if (asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
1987 try renderAsmOutput(allocator, ais, tree, asm_output, Space.Newline);
1988 break :asmblk;
1989 } else {
1990 try renderAsmOutput(allocator, ais, tree, asm_output, Space.Newline);
1991 const comma_or_colon = tree.nextToken(asm_output.lastToken());
1992 break :blk switch (tree.token_ids[comma_or_colon]) {
1993 .Comma => tree.nextToken(comma_or_colon),
1994 else => comma_or_colon,
1995 };
1996 }
20981997 }
2099 }
2100 unreachable;
2101 };
1998 unreachable;
1999 };
21022000
2103 try renderToken(tree, stream, colon3, indent, start_col, Space.Space); // :
2001 const colon3 = if (asm_node.inputs.len == 0) blk: {
2002 try renderToken(tree, ais, colon2, Space.Newline); // :
2003 break :blk tree.nextToken(colon2);
2004 } else blk: {
2005 try renderToken(tree, ais, colon2, Space.Space); // :
2006 ais.pushIndent();
2007 defer ais.popIndent();
2008 for (asm_node.inputs) |*asm_input, i| {
2009 if (i + 1 < asm_node.inputs.len) {
2010 const next_asm_input = &asm_node.inputs[i + 1];
2011 try renderAsmInput(allocator, ais, tree, asm_input, Space.None);
2012
2013 const comma = tree.prevToken(next_asm_input.firstToken());
2014 try renderToken(tree, ais, comma, Space.Newline); // ,
2015 try renderExtraNewlineToken(tree, ais, next_asm_input.firstToken());
2016 } else if (asm_node.clobbers.len == 0) {
2017 try renderAsmInput(allocator, ais, tree, asm_input, Space.Newline);
2018 break :asmblk;
2019 } else {
2020 try renderAsmInput(allocator, ais, tree, asm_input, Space.Newline);
2021 const comma_or_colon = tree.nextToken(asm_input.lastToken());
2022 break :blk switch (tree.token_ids[comma_or_colon]) {
2023 .Comma => tree.nextToken(comma_or_colon),
2024 else => comma_or_colon,
2025 };
2026 }
2027 }
2028 unreachable;
2029 };
21042030
2105 for (asm_node.clobbers) |clobber_node, i| {
2106 if (i + 1 >= asm_node.clobbers.len) {
2107 try renderExpression(allocator, stream, tree, indent_extra, start_col, clobber_node, Space.Newline);
2108 try stream.writeByteNTimes(' ', indent);
2109 return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
2110 } else {
2111 try renderExpression(allocator, stream, tree, indent_extra, start_col, clobber_node, Space.None);
2112 const comma = tree.nextToken(clobber_node.lastToken());
2113 try renderToken(tree, stream, comma, indent_once, start_col, Space.Space); // ,
2031 try renderToken(tree, ais, colon3, Space.Space); // :
2032 ais.pushIndent();
2033 defer ais.popIndent();
2034 for (asm_node.clobbers) |clobber_node, i| {
2035 if (i + 1 >= asm_node.clobbers.len) {
2036 try renderExpression(allocator, ais, tree, clobber_node, Space.Newline);
2037 break :asmblk;
2038 } else {
2039 try renderExpression(allocator, ais, tree, clobber_node, Space.None);
2040 const comma = tree.nextToken(clobber_node.lastToken());
2041 try renderToken(tree, ais, comma, Space.Space); // ,
2042 }
21142043 }
21152044 }
2045
2046 return renderToken(tree, ais, asm_node.rparen, space);
21162047 },
21172048
21182049 .EnumLiteral => {
21192050 const enum_literal = @fieldParentPtr(ast.Node.EnumLiteral, "base", base);
21202051
2121 try renderToken(tree, stream, enum_literal.dot, indent, start_col, Space.None); // .
2122 return renderToken(tree, stream, enum_literal.name, indent, start_col, space); // name
2052 try renderToken(tree, ais, enum_literal.dot, Space.None); // .
2053 return renderToken(tree, ais, enum_literal.name, space); // name
21232054 },
21242055
21252056 .ContainerField,
......@@ -2133,118 +2064,115 @@ fn renderExpression(
21332064
21342065fn renderArrayType(
21352066 allocator: *mem.Allocator,
2136 stream: anytype,
2067 ais: anytype,
21372068 tree: *ast.Tree,
2138 indent: usize,
2139 start_col: *usize,
21402069 lbracket: ast.TokenIndex,
21412070 rhs: *ast.Node,
21422071 len_expr: *ast.Node,
21432072 opt_sentinel: ?*ast.Node,
21442073 space: Space,
2145) (@TypeOf(stream).Error || Error)!void {
2074) (@TypeOf(ais.*).Error || Error)!void {
21462075 const rbracket = tree.nextToken(if (opt_sentinel) |sentinel|
21472076 sentinel.lastToken()
21482077 else
21492078 len_expr.lastToken());
21502079
2151 try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
2152
21532080 const starts_with_comment = tree.token_ids[lbracket + 1] == .LineComment;
21542081 const ends_with_comment = tree.token_ids[rbracket - 1] == .LineComment;
2155 const new_indent = if (ends_with_comment) indent + indent_delta else indent;
21562082 const new_space = if (ends_with_comment) Space.Newline else Space.None;
2157 try renderExpression(allocator, stream, tree, new_indent, start_col, len_expr, new_space);
2158 if (starts_with_comment) {
2159 try stream.writeByte('\n');
2160 }
2161 if (ends_with_comment or starts_with_comment) {
2162 try stream.writeByteNTimes(' ', indent);
2163 }
2164 if (opt_sentinel) |sentinel| {
2165 const colon_token = tree.prevToken(sentinel.firstToken());
2166 try renderToken(tree, stream, colon_token, indent, start_col, Space.None); // :
2167 try renderExpression(allocator, stream, tree, indent, start_col, sentinel, Space.None);
2083 {
2084 const do_indent = (starts_with_comment or ends_with_comment);
2085 if (do_indent) ais.pushIndent();
2086 defer if (do_indent) ais.popIndent();
2087
2088 try renderToken(tree, ais, lbracket, Space.None); // [
2089 try renderExpression(allocator, ais, tree, len_expr, new_space);
2090
2091 if (starts_with_comment) {
2092 try ais.maybeInsertNewline();
2093 }
2094 if (opt_sentinel) |sentinel| {
2095 const colon_token = tree.prevToken(sentinel.firstToken());
2096 try renderToken(tree, ais, colon_token, Space.None); // :
2097 try renderExpression(allocator, ais, tree, sentinel, Space.None);
2098 }
2099 if (starts_with_comment) {
2100 try ais.maybeInsertNewline();
2101 }
21682102 }
2169 try renderToken(tree, stream, rbracket, indent, start_col, Space.None); // ]
2103 try renderToken(tree, ais, rbracket, Space.None); // ]
21702104
2171 return renderExpression(allocator, stream, tree, indent, start_col, rhs, space);
2105 return renderExpression(allocator, ais, tree, rhs, space);
21722106}
21732107
21742108fn renderAsmOutput(
21752109 allocator: *mem.Allocator,
2176 stream: anytype,
2110 ais: anytype,
21772111 tree: *ast.Tree,
2178 indent: usize,
2179 start_col: *usize,
21802112 asm_output: *const ast.Node.Asm.Output,
21812113 space: Space,
2182) (@TypeOf(stream).Error || Error)!void {
2183 try stream.writeAll("[");
2184 try renderExpression(allocator, stream, tree, indent, start_col, asm_output.symbolic_name, Space.None);
2185 try stream.writeAll("] ");
2186 try renderExpression(allocator, stream, tree, indent, start_col, asm_output.constraint, Space.None);
2187 try stream.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(" (");
21882120
21892121 switch (asm_output.kind) {
21902122 ast.Node.Asm.Output.Kind.Variable => |variable_name| {
2191 try renderExpression(allocator, stream, tree, indent, start_col, &variable_name.base, Space.None);
2123 try renderExpression(allocator, ais, tree, &variable_name.base, Space.None);
21922124 },
21932125 ast.Node.Asm.Output.Kind.Return => |return_type| {
2194 try stream.writeAll("-> ");
2195 try renderExpression(allocator, stream, tree, indent, start_col, return_type, Space.None);
2126 try ais.writer().writeAll("-> ");
2127 try renderExpression(allocator, ais, tree, return_type, Space.None);
21962128 },
21972129 }
21982130
2199 return renderToken(tree, stream, asm_output.lastToken(), indent, start_col, space); // )
2131 return renderToken(tree, ais, asm_output.lastToken(), space); // )
22002132}
22012133
22022134fn renderAsmInput(
22032135 allocator: *mem.Allocator,
2204 stream: anytype,
2136 ais: anytype,
22052137 tree: *ast.Tree,
2206 indent: usize,
2207 start_col: *usize,
22082138 asm_input: *const ast.Node.Asm.Input,
22092139 space: Space,
2210) (@TypeOf(stream).Error || Error)!void {
2211 try stream.writeAll("[");
2212 try renderExpression(allocator, stream, tree, indent, start_col, asm_input.symbolic_name, Space.None);
2213 try stream.writeAll("] ");
2214 try renderExpression(allocator, stream, tree, indent, start_col, asm_input.constraint, Space.None);
2215 try stream.writeAll(" (");
2216 try renderExpression(allocator, stream, tree, indent, start_col, asm_input.expr, Space.None);
2217 return renderToken(tree, stream, asm_input.lastToken(), indent, start_col, 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); // )
22182148}
22192149
22202150fn renderVarDecl(
22212151 allocator: *mem.Allocator,
2222 stream: anytype,
2152 ais: anytype,
22232153 tree: *ast.Tree,
2224 indent: usize,
2225 start_col: *usize,
22262154 var_decl: *ast.Node.VarDecl,
2227) (@TypeOf(stream).Error || Error)!void {
2155) (@TypeOf(ais.*).Error || Error)!void {
22282156 if (var_decl.getVisibToken()) |visib_token| {
2229 try renderToken(tree, stream, visib_token, indent, start_col, Space.Space); // pub
2157 try renderToken(tree, ais, visib_token, Space.Space); // pub
22302158 }
22312159
22322160 if (var_decl.getExternExportToken()) |extern_export_token| {
2233 try renderToken(tree, stream, extern_export_token, indent, start_col, Space.Space); // extern
2161 try renderToken(tree, ais, extern_export_token, Space.Space); // extern
22342162
22352163 if (var_decl.getLibName()) |lib_name| {
2236 try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space); // "lib"
2164 try renderExpression(allocator, ais, tree, lib_name, Space.Space); // "lib"
22372165 }
22382166 }
22392167
22402168 if (var_decl.getComptimeToken()) |comptime_token| {
2241 try renderToken(tree, stream, comptime_token, indent, start_col, Space.Space); // comptime
2169 try renderToken(tree, ais, comptime_token, Space.Space); // comptime
22422170 }
22432171
22442172 if (var_decl.getThreadLocalToken()) |thread_local_token| {
2245 try renderToken(tree, stream, thread_local_token, indent, start_col, Space.Space); // threadlocal
2173 try renderToken(tree, ais, thread_local_token, Space.Space); // threadlocal
22462174 }
2247 try renderToken(tree, stream, var_decl.mut_token, indent, start_col, Space.Space); // var
2175 try renderToken(tree, ais, var_decl.mut_token, Space.Space); // var
22482176
22492177 const name_space = if (var_decl.getTypeNode() == null and
22502178 (var_decl.getAlignNode() != null or
......@@ -2253,95 +2181,92 @@ fn renderVarDecl(
22532181 Space.Space
22542182 else
22552183 Space.None;
2256 try renderToken(tree, stream, var_decl.name_token, indent, start_col, name_space);
2184 try renderToken(tree, ais, var_decl.name_token, name_space);
22572185
22582186 if (var_decl.getTypeNode()) |type_node| {
2259 try renderToken(tree, stream, tree.nextToken(var_decl.name_token), indent, start_col, Space.Space);
2187 try renderToken(tree, ais, tree.nextToken(var_decl.name_token), Space.Space);
22602188 const s = if (var_decl.getAlignNode() != null or
22612189 var_decl.getSectionNode() != null or
22622190 var_decl.getInitNode() != null) Space.Space else Space.None;
2263 try renderExpression(allocator, stream, tree, indent, start_col, type_node, s);
2191 try renderExpression(allocator, ais, tree, type_node, s);
22642192 }
22652193
22662194 if (var_decl.getAlignNode()) |align_node| {
22672195 const lparen = tree.prevToken(align_node.firstToken());
22682196 const align_kw = tree.prevToken(lparen);
22692197 const rparen = tree.nextToken(align_node.lastToken());
2270 try renderToken(tree, stream, align_kw, indent, start_col, Space.None); // align
2271 try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
2272 try renderExpression(allocator, stream, tree, indent, start_col, 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);
22732201 const s = if (var_decl.getSectionNode() != null or var_decl.getInitNode() != null) Space.Space else Space.None;
2274 try renderToken(tree, stream, rparen, indent, start_col, s); // )
2202 try renderToken(tree, ais, rparen, s); // )
22752203 }
22762204
22772205 if (var_decl.getSectionNode()) |section_node| {
22782206 const lparen = tree.prevToken(section_node.firstToken());
22792207 const section_kw = tree.prevToken(lparen);
22802208 const rparen = tree.nextToken(section_node.lastToken());
2281 try renderToken(tree, stream, section_kw, indent, start_col, Space.None); // linksection
2282 try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
2283 try renderExpression(allocator, stream, tree, indent, start_col, 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);
22842212 const s = if (var_decl.getInitNode() != null) Space.Space else Space.None;
2285 try renderToken(tree, stream, rparen, indent, start_col, s); // )
2213 try renderToken(tree, ais, rparen, s); // )
22862214 }
22872215
22882216 if (var_decl.getInitNode()) |init_node| {
22892217 const s = if (init_node.tag == .MultilineStringLiteral) Space.None else Space.Space;
2290 try renderToken(tree, stream, var_decl.getEqToken().?, indent, start_col, s); // =
2291 try renderExpression(allocator, stream, tree, indent, start_col, 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);
22922221 }
22932222
2294 try renderToken(tree, stream, var_decl.semicolon_token, indent, start_col, Space.Newline);
2223 try renderToken(tree, ais, var_decl.semicolon_token, Space.Newline);
22952224}
22962225
22972226fn renderParamDecl(
22982227 allocator: *mem.Allocator,
2299 stream: anytype,
2228 ais: anytype,
23002229 tree: *ast.Tree,
2301 indent: usize,
2302 start_col: *usize,
23032230 param_decl: ast.Node.FnProto.ParamDecl,
23042231 space: Space,
2305) (@TypeOf(stream).Error || Error)!void {
2306 try renderDocComments(tree, stream, param_decl, param_decl.doc_comments, indent, start_col);
2232) (@TypeOf(ais.*).Error || Error)!void {
2233 try renderDocComments(tree, ais, param_decl, param_decl.doc_comments);
23072234
23082235 if (param_decl.comptime_token) |comptime_token| {
2309 try renderToken(tree, stream, comptime_token, indent, start_col, Space.Space);
2236 try renderToken(tree, ais, comptime_token, Space.Space);
23102237 }
23112238 if (param_decl.noalias_token) |noalias_token| {
2312 try renderToken(tree, stream, noalias_token, indent, start_col, Space.Space);
2239 try renderToken(tree, ais, noalias_token, Space.Space);
23132240 }
23142241 if (param_decl.name_token) |name_token| {
2315 try renderToken(tree, stream, name_token, indent, start_col, Space.None);
2316 try renderToken(tree, stream, tree.nextToken(name_token), indent, start_col, Space.Space); // :
2242 try renderToken(tree, ais, name_token, Space.None);
2243 try renderToken(tree, ais, tree.nextToken(name_token), Space.Space); // :
23172244 }
23182245 switch (param_decl.param_type) {
2319 .any_type, .type_expr => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, space),
2246 .any_type, .type_expr => |node| try renderExpression(allocator, ais, tree, node, space),
23202247 }
23212248}
23222249
23232250fn renderStatement(
23242251 allocator: *mem.Allocator,
2325 stream: anytype,
2252 ais: anytype,
23262253 tree: *ast.Tree,
2327 indent: usize,
2328 start_col: *usize,
23292254 base: *ast.Node,
2330) (@TypeOf(stream).Error || Error)!void {
2255) (@TypeOf(ais.*).Error || Error)!void {
23312256 switch (base.tag) {
23322257 .VarDecl => {
23332258 const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", base);
2334 try renderVarDecl(allocator, stream, tree, indent, start_col, var_decl);
2259 try renderVarDecl(allocator, ais, tree, var_decl);
23352260 },
23362261 else => {
23372262 if (base.requireSemiColon()) {
2338 try renderExpression(allocator, stream, tree, indent, start_col, base, Space.None);
2263 try renderExpression(allocator, ais, tree, base, Space.None);
23392264
23402265 const semicolon_index = tree.nextToken(base.lastToken());
23412266 assert(tree.token_ids[semicolon_index] == .Semicolon);
2342 try renderToken(tree, stream, semicolon_index, indent, start_col, Space.Newline);
2267 try renderToken(tree, ais, semicolon_index, Space.Newline);
23432268 } else {
2344 try renderExpression(allocator, stream, tree, indent, start_col, base, Space.Newline);
2269 try renderExpression(allocator, ais, tree, base, Space.Newline);
23452270 }
23462271 },
23472272 }
......@@ -2360,24 +2285,19 @@ const Space = enum {
23602285
23612286fn renderTokenOffset(
23622287 tree: *ast.Tree,
2363 stream: anytype,
2288 ais: anytype,
23642289 token_index: ast.TokenIndex,
2365 indent: usize,
2366 start_col: *usize,
23672290 space: Space,
23682291 token_skip_bytes: usize,
2369) (@TypeOf(stream).Error || Error)!void {
2292) (@TypeOf(ais.*).Error || Error)!void {
23702293 if (space == Space.BlockStart) {
2371 if (start_col.* < indent + indent_delta)
2372 return renderToken(tree, stream, token_index, indent, start_col, Space.Space);
2373 try renderToken(tree, stream, token_index, indent, start_col, Space.Newline);
2374 try stream.writeByteNTimes(' ', indent);
2375 start_col.* = indent;
2376 return;
2294 // If placing the lbrace on the current line would cause an uggly gap then put the lbrace on the next line
2295 const new_space = if (ais.isLineOverIndented()) Space.Newline else Space.Space;
2296 return renderToken(tree, ais, token_index, new_space);
23772297 }
23782298
23792299 var token_loc = tree.token_locs[token_index];
2380 try stream.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..], " "));
23812301
23822302 if (space == Space.NoComment)
23832303 return;
......@@ -2386,20 +2306,20 @@ fn renderTokenOffset(
23862306 var next_token_loc = tree.token_locs[token_index + 1];
23872307
23882308 if (space == Space.Comma) switch (next_token_id) {
2389 .Comma => return renderToken(tree, stream, token_index + 1, indent, start_col, Space.Newline),
2309 .Comma => return renderToken(tree, ais, token_index + 1, Space.Newline),
23902310 .LineComment => {
2391 try stream.writeAll(", ");
2392 return renderToken(tree, stream, token_index + 1, indent, start_col, Space.Newline);
2311 try ais.writer().writeAll(", ");
2312 return renderToken(tree, ais, token_index + 1, Space.Newline);
23932313 },
23942314 else => {
23952315 if (token_index + 2 < tree.token_ids.len and
23962316 tree.token_ids[token_index + 2] == .MultilineStringLiteralLine)
23972317 {
2398 try stream.writeAll(",");
2318 try ais.writer().writeAll(",");
23992319 return;
24002320 } else {
2401 try stream.writeAll(",\n");
2402 start_col.* = 0;
2321 try ais.writer().writeAll(",");
2322 try ais.insertNewline();
24032323 return;
24042324 }
24052325 },
......@@ -2423,15 +2343,14 @@ fn renderTokenOffset(
24232343 if (next_token_id == .MultilineStringLiteralLine) {
24242344 return;
24252345 } else {
2426 try stream.writeAll("\n");
2427 start_col.* = 0;
2346 try ais.insertNewline();
24282347 return;
24292348 }
24302349 },
24312350 Space.Space, Space.SpaceOrOutdent => {
24322351 if (next_token_id == .MultilineStringLiteralLine)
24332352 return;
2434 try stream.writeByte(' ');
2353 try ais.writer().writeByte(' ');
24352354 return;
24362355 },
24372356 Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
......@@ -2448,8 +2367,7 @@ fn renderTokenOffset(
24482367 next_token_id = tree.token_ids[token_index + offset];
24492368 next_token_loc = tree.token_locs[token_index + offset];
24502369 if (next_token_id != .LineComment) {
2451 try stream.writeByte('\n');
2452 start_col.* = 0;
2370 try ais.insertNewline();
24532371 return;
24542372 }
24552373 },
......@@ -2462,7 +2380,7 @@ fn renderTokenOffset(
24622380
24632381 var loc = tree.tokenLocationLoc(token_loc.end, next_token_loc);
24642382 if (loc.line == 0) {
2465 try stream.print(" {}", .{mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " ")});
2383 try ais.writer().print(" {}", .{mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " ")});
24662384 offset = 2;
24672385 token_loc = next_token_loc;
24682386 next_token_loc = tree.token_locs[token_index + offset];
......@@ -2470,26 +2388,16 @@ fn renderTokenOffset(
24702388 if (next_token_id != .LineComment) {
24712389 switch (space) {
24722390 Space.None, Space.Space => {
2473 try stream.writeByte('\n');
2474 const after_comment_token = tree.token_ids[token_index + offset];
2475 const next_line_indent = switch (after_comment_token) {
2476 .RParen, .RBrace, .RBracket => indent,
2477 else => indent + indent_delta,
2478 };
2479 try stream.writeByteNTimes(' ', next_line_indent);
2480 start_col.* = next_line_indent;
2391 try ais.insertNewline();
24812392 },
24822393 Space.SpaceOrOutdent => {
2483 try stream.writeByte('\n');
2484 try stream.writeByteNTimes(' ', indent);
2485 start_col.* = indent;
2394 try ais.insertNewline();
24862395 },
24872396 Space.Newline => {
24882397 if (next_token_id == .MultilineStringLiteralLine) {
24892398 return;
24902399 } else {
2491 try stream.writeAll("\n");
2492 start_col.* = 0;
2400 try ais.insertNewline();
24932401 return;
24942402 }
24952403 },
......@@ -2505,10 +2413,9 @@ fn renderTokenOffset(
25052413 // translate-c doesn't generate correct newlines
25062414 // in generated code (loc.line == 0) so treat that case
25072415 // as though there was meant to be a newline between the tokens
2508 const newline_count = if (loc.line <= 1) @as(u8, 1) else @as(u8, 2);
2509 try stream.writeByteNTimes('\n', newline_count);
2510 try stream.writeByteNTimes(' ', indent);
2511 try stream.writeAll(mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " "));
2416 var newline_count = if (loc.line <= 1) @as(u8, 1) else @as(u8, 2);
2417 while (newline_count > 0) : (newline_count -= 1) try ais.insertNewline();
2418 try ais.writer().writeAll(mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " "));
25122419
25132420 offset += 1;
25142421 token_loc = next_token_loc;
......@@ -2520,32 +2427,15 @@ fn renderTokenOffset(
25202427 if (next_token_id == .MultilineStringLiteralLine) {
25212428 return;
25222429 } else {
2523 try stream.writeAll("\n");
2524 start_col.* = 0;
2430 try ais.insertNewline();
25252431 return;
25262432 }
25272433 },
25282434 Space.None, Space.Space => {
2529 try stream.writeByte('\n');
2530
2531 const after_comment_token = tree.token_ids[token_index + offset];
2532 const next_line_indent = switch (after_comment_token) {
2533 .RParen, .RBrace, .RBracket => blk: {
2534 if (indent > indent_delta) {
2535 break :blk indent - indent_delta;
2536 } else {
2537 break :blk 0;
2538 }
2539 },
2540 else => indent,
2541 };
2542 try stream.writeByteNTimes(' ', next_line_indent);
2543 start_col.* = next_line_indent;
2435 try ais.insertNewline();
25442436 },
25452437 Space.SpaceOrOutdent => {
2546 try stream.writeByte('\n');
2547 try stream.writeByteNTimes(' ', indent);
2548 start_col.* = indent;
2438 try ais.insertNewline();
25492439 },
25502440 Space.NoNewline => {},
25512441 Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
......@@ -2558,46 +2448,38 @@ fn renderTokenOffset(
25582448
25592449fn renderToken(
25602450 tree: *ast.Tree,
2561 stream: anytype,
2451 ais: anytype,
25622452 token_index: ast.TokenIndex,
2563 indent: usize,
2564 start_col: *usize,
25652453 space: Space,
2566) (@TypeOf(stream).Error || Error)!void {
2567 return renderTokenOffset(tree, stream, token_index, indent, start_col, space, 0);
2454) (@TypeOf(ais.*).Error || Error)!void {
2455 return renderTokenOffset(tree, ais, token_index, space, 0);
25682456}
25692457
25702458fn renderDocComments(
25712459 tree: *ast.Tree,
2572 stream: anytype,
2460 ais: anytype,
25732461 node: anytype,
25742462 doc_comments: ?*ast.Node.DocComment,
2575 indent: usize,
2576 start_col: *usize,
2577) (@TypeOf(stream).Error || Error)!void {
2463) (@TypeOf(ais.*).Error || Error)!void {
25782464 const comment = doc_comments orelse return;
2579 return renderDocCommentsToken(tree, stream, comment, node.firstToken(), indent, start_col);
2465 return renderDocCommentsToken(tree, ais, comment, node.firstToken());
25802466}
25812467
25822468fn renderDocCommentsToken(
25832469 tree: *ast.Tree,
2584 stream: anytype,
2470 ais: anytype,
25852471 comment: *ast.Node.DocComment,
25862472 first_token: ast.TokenIndex,
2587 indent: usize,
2588 start_col: *usize,
2589) (@TypeOf(stream).Error || Error)!void {
2473) (@TypeOf(ais.*).Error || Error)!void {
25902474 var tok_i = comment.first_line;
25912475 while (true) : (tok_i += 1) {
25922476 switch (tree.token_ids[tok_i]) {
25932477 .DocComment, .ContainerDocComment => {
25942478 if (comment.first_line < first_token) {
2595 try renderToken(tree, stream, tok_i, indent, start_col, Space.Newline);
2596 try stream.writeByteNTimes(' ', indent);
2479 try renderToken(tree, ais, tok_i, Space.Newline);
25972480 } else {
2598 try renderToken(tree, stream, tok_i, indent, start_col, Space.NoComment);
2599 try stream.writeAll("\n");
2600 try stream.writeByteNTimes(' ', indent);
2481 try renderToken(tree, ais, tok_i, Space.NoComment);
2482 try ais.insertNewline();
26012483 }
26022484 },
26032485 .LineComment => continue,
......@@ -2669,41 +2551,10 @@ fn nodeCausesSliceOpSpace(base: *ast.Node) bool {
26692551 };
26702552}
26712553
2672/// A `std.io.OutStream` that returns whether the given character has been written to it.
2673/// The contents are not written to anything.
2674const FindByteOutStream = struct {
2675 byte_found: bool,
2676 byte: u8,
2677
2678 pub const Error = error{};
2679 pub const OutStream = std.io.OutStream(*FindByteOutStream, Error, write);
2680
2681 pub fn init(byte: u8) FindByteOutStream {
2682 return FindByteOutStream{
2683 .byte = byte,
2684 .byte_found = false,
2685 };
2686 }
2687
2688 pub fn write(self: *FindByteOutStream, bytes: []const u8) Error!usize {
2689 if (self.byte_found) return bytes.len;
2690 self.byte_found = blk: {
2691 for (bytes) |b|
2692 if (b == self.byte) break :blk true;
2693 break :blk false;
2694 };
2695 return bytes.len;
2696 }
2697
2698 pub fn outStream(self: *FindByteOutStream) OutStream {
2699 return .{ .context = self };
2700 }
2701};
2702
2703fn copyFixingWhitespace(stream: anytype, slice: []const u8) @TypeOf(stream).Error!void {
2554fn copyFixingWhitespace(ais: anytype, slice: []const u8) @TypeOf(ais.*).Error!void {
27042555 for (slice) |byte| switch (byte) {
2705 '\t' => try stream.writeAll(" "),
2556 '\t' => try ais.writer().writeAll(" "),
27062557 '\r' => {},
2707 else => try stream.writeByte(byte),
2558 else => try ais.writer().writeByte(byte),
27082559 };
27092560}
src-self-hosted/main.zig+2-1
......@@ -839,7 +839,8 @@ fn fmtPathFile(
839839 // As a heuristic, we make enough capacity for the same as the input source.
840840 try fmt.out_buffer.ensureCapacity(source_code.len);
841841 fmt.out_buffer.items.len = 0;
842 const anything_changed = try std.zig.render(fmt.gpa, fmt.out_buffer.writer(), tree);
842 const writer = fmt.out_buffer.writer();
843 const anything_changed = try std.zig.render(fmt.gpa, writer, tree);
843844 if (!anything_changed)
844845 return; // Good thing we didn't waste any file system access on this.
845846