Commit a72b9d403d
Changed files (9)
lib/std/io/auto_indenting_stream.zig
@@ -0,0 +1,135 @@
+const std = @import("../std.zig");
+const io = std.io;
+const mem = std.mem;
+const assert = std.debug.assert;
+
+pub fn AutoIndentingStream(comptime indent_delta: u8, comptime OutStreamType: type) type {
+ return struct {
+ const Self = @This();
+ pub const Error = OutStreamType.Error;
+ pub const OutStream = io.Writer(*Self, Error, write);
+
+ out_stream: *OutStreamType,
+ current_line_empty: bool = true,
+ indent_stack: [255]u8 = undefined,
+ indent_stack_top: u8 = 0,
+ indent_one_shot_count: u8 = 0, // automatically popped when applied
+ applied_indent: u8 = 0, // the most recently applied indent
+ indent_next_line: u8 = 0, // not used until the next line
+
+ pub fn init(out_stream: *OutStreamType) Self {
+ return Self{ .out_stream = out_stream };
+ }
+
+ pub fn writer(self: *Self) OutStream {
+ return .{ .context = self };
+ }
+
+ pub fn write(self: *Self, bytes: []const u8) Error!usize {
+ if (bytes.len == 0)
+ return @as(usize, 0);
+
+ try self.applyIndent();
+ return self.writeNoIndent(bytes);
+ }
+
+ fn writeNoIndent(self: *Self, bytes: []const u8) Error!usize {
+ try self.out_stream.outStream().writeAll(bytes);
+ if (bytes[bytes.len - 1] == '\n')
+ self.resetLine();
+ return bytes.len;
+ }
+
+ pub fn insertNewline(self: *Self) Error!void {
+ _ = try self.writeNoIndent("\n");
+ }
+
+ fn resetLine(self: *Self) void {
+ self.current_line_empty = true;
+ self.indent_next_line = 0;
+ }
+
+ /// Insert a newline unless the current line is blank
+ pub fn maybeInsertNewline(self: *Self) Error!void {
+ if (!self.current_line_empty)
+ try self.insertNewline();
+ }
+
+ /// Push default indentation
+ pub fn pushIndent(self: *Self) void {
+ // Doesn't actually write any indentation. Just primes the stream to be able to write the correct indentation if it needs to.
+ self.pushIndentN(indent_delta);
+ }
+
+ /// Push an indent of arbitrary width
+ pub fn pushIndentN(self: *Self, n: u8) void {
+ assert(self.indent_stack_top < std.math.maxInt(u8));
+ self.indent_stack[self.indent_stack_top] = n;
+ self.indent_stack_top += 1;
+ }
+
+ /// Push an indent that is automatically popped after being applied
+ pub fn pushIndentOneShot(self: *Self) void {
+ self.indent_one_shot_count += 1;
+ self.pushIndent();
+ }
+
+ /// Turns all one-shot indents into regular indents
+ /// Returns number of indents that must now be manually popped
+ pub fn lockOneShotIndent(self: *Self) u8 {
+ var locked_count = self.indent_one_shot_count;
+ self.indent_one_shot_count = 0;
+ return locked_count;
+ }
+
+ /// Push an indent that should not take effect until the next line
+ pub fn pushIndentNextLine(self: *Self) void {
+ self.indent_next_line += 1;
+ self.pushIndent();
+ }
+
+ pub fn popIndent(self: *Self) void {
+ assert(self.indent_stack_top != 0);
+ self.indent_stack_top -= 1;
+ self.indent_next_line = std.math.min(self.indent_stack_top, self.indent_next_line); // Tentative indent may have been popped before there was a newline
+ }
+
+ /// Writes ' ' bytes if the current line is empty
+ fn applyIndent(self: *Self) Error!void {
+ const current_indent = self.currentIndent();
+ if (self.current_line_empty and current_indent > 0) {
+ try self.out_stream.outStream().writeByteNTimes(' ', current_indent);
+ self.applied_indent = current_indent;
+ }
+
+ self.indent_stack_top -= self.indent_one_shot_count;
+ self.indent_one_shot_count = 0;
+ self.current_line_empty = false;
+ }
+
+ /// Checks to see if the most recent indentation exceeds the currently pushed indents
+ pub fn isLineOverIndented(self: *Self) bool {
+ if (self.current_line_empty) return false;
+ return self.applied_indent > self.currentIndent();
+ }
+
+ fn currentIndent(self: *Self) u8 {
+ var indent_current: u8 = 0;
+ if (self.indent_stack_top > 0) {
+ const stack_top = self.indent_stack_top - self.indent_next_line;
+ for (self.indent_stack[0..stack_top]) |indent| {
+ indent_current += indent;
+ }
+ }
+ return indent_current;
+ }
+ };
+}
+
+pub fn autoIndentingStream(
+ comptime indent_delta: u8,
+ underlying_stream: anytype,
+) AutoIndentingStream(indent_delta, @TypeOf(underlying_stream).Child) {
+ comptime assert(@typeInfo(@TypeOf(underlying_stream)) == .Pointer);
+ return AutoIndentingStream(indent_delta, @TypeOf(underlying_stream).Child).init(underlying_stream);
+}
lib/std/io/change_detection_stream.zig
@@ -0,0 +1,58 @@
+const std = @import("../std.zig");
+const io = std.io;
+const mem = std.mem;
+const assert = std.debug.assert;
+
+pub fn ChangeDetectionStream(comptime OutStreamType: type) type {
+ return struct {
+ const Self = @This();
+ pub const Error = OutStreamType.Error;
+ pub const OutStream = io.OutStream(*Self, Error, write);
+
+ anything_changed: bool = false,
+ out_stream: *OutStreamType,
+ source_index: usize,
+ source: []const u8,
+
+ pub fn init(source: []const u8, out_stream: *OutStreamType) Self {
+ return Self{
+ .out_stream = out_stream,
+ .source_index = 0,
+ .source = source,
+ };
+ }
+
+ pub fn outStream(self: *Self) OutStream {
+ return .{ .context = self };
+ }
+
+ fn write(self: *Self, bytes: []const u8) Error!usize {
+ if (!self.anything_changed) {
+ const end = self.source_index + bytes.len;
+ if (end > self.source.len) {
+ self.anything_changed = true;
+ } else {
+ const src_slice = self.source[self.source_index..end];
+ self.source_index += bytes.len;
+ if (!mem.eql(u8, bytes, src_slice)) {
+ self.anything_changed = true;
+ }
+ }
+ }
+
+ return self.out_stream.write(bytes);
+ }
+
+ pub fn changeDetected(self: *Self) bool {
+ return self.anything_changed or (self.source_index != self.source.len);
+ }
+ };
+}
+
+pub fn changeDetectionStream(
+ source: []const u8,
+ underlying_stream: anytype,
+) ChangeDetectionStream(@TypeOf(underlying_stream).Child) {
+ comptime assert(@typeInfo(@TypeOf(underlying_stream)) == .Pointer);
+ return ChangeDetectionStream(@TypeOf(underlying_stream).Child).init(source, underlying_stream);
+}
lib/std/io/find_byte_out_stream.zig
@@ -0,0 +1,44 @@
+const std = @import("../std.zig");
+const io = std.io;
+const assert = std.debug.assert;
+
+// An OutStream that returns whether the given character has been written to it.
+// The contents are not written to anything.
+pub fn FindByteOutStream(comptime OutStreamType: type) type {
+ return struct {
+ const Self = @This();
+ pub const Error = OutStreamType.Error;
+ pub const OutStream = io.OutStream(*Self, Error, write);
+
+ out_stream: *OutStreamType,
+ byte_found: bool,
+ byte: u8,
+
+ pub fn init(byte: u8, out_stream: *OutStreamType) Self {
+ return Self{
+ .out_stream = out_stream,
+ .byte = byte,
+ .byte_found = false,
+ };
+ }
+
+ pub fn outStream(self: *Self) OutStream {
+ return .{ .context = self };
+ }
+
+ fn write(self: *Self, bytes: []const u8) Error!usize {
+ if (!self.byte_found) {
+ self.byte_found = blk: {
+ for (bytes) |b|
+ if (b == self.byte) break :blk true;
+ break :blk false;
+ };
+ }
+ return self.out_stream.writer().write(bytes);
+ }
+ };
+}
+pub fn findByteOutStream(byte: u8, underlying_stream: anytype) FindByteOutStream(@TypeOf(underlying_stream).Child) {
+ comptime assert(@typeInfo(@TypeOf(underlying_stream)) == .Pointer);
+ return FindByteOutStream(@TypeOf(underlying_stream).Child).init(byte, underlying_stream);
+}
lib/std/io/writer.zig
@@ -18,6 +18,10 @@ pub fn Writer(
const Self = @This();
pub const Error = WriteError;
+ pub fn writer(self: *const Self) Self {
+ return self.*;
+ }
+
pub fn write(self: Self, bytes: []const u8) Error!usize {
return writeFn(self.context, bytes);
}
lib/std/zig/parser_test.zig
@@ -615,6 +615,17 @@ test "zig fmt: infix operator and then multiline string literal" {
);
}
+test "zig fmt: infix operator and then multiline string literal" {
+ try testCanonical(
+ \\const x = "" ++
+ \\ \\ hi0
+ \\ \\ hi1
+ \\ \\ hi2
+ \\;
+ \\
+ );
+}
+
test "zig fmt: C pointers" {
try testCanonical(
\\const Ptr = [*c]i32;
@@ -885,6 +896,28 @@ test "zig fmt: 2nd arg multiline string" {
);
}
+test "zig fmt: 2nd arg multiline string many args" {
+ try testCanonical(
+ \\comptime {
+ \\ cases.addAsm("hello world linux x86_64",
+ \\ \\.text
+ \\ , "Hello, world!\n", "Hello, world!\n");
+ \\}
+ \\
+ );
+}
+
+test "zig fmt: final arg multiline string" {
+ try testCanonical(
+ \\comptime {
+ \\ cases.addAsm("hello world linux x86_64", "Hello, world!\n",
+ \\ \\.text
+ \\ );
+ \\}
+ \\
+ );
+}
+
test "zig fmt: if condition wraps" {
try testTransform(
\\comptime {
@@ -915,6 +948,11 @@ test "zig fmt: if condition wraps" {
\\ var a = if (a) |*f| x: {
\\ break :x &a.b;
\\ } else |err| err;
+ \\ var a = if (cond and
+ \\ cond) |*f|
+ \\ x: {
+ \\ break :x &a.b;
+ \\ } else |err| err;
\\}
,
\\comptime {
@@ -951,6 +989,35 @@ test "zig fmt: if condition wraps" {
\\ var a = if (a) |*f| x: {
\\ break :x &a.b;
\\ } else |err| err;
+ \\ var a = if (cond and
+ \\ cond) |*f|
+ \\ x: {
+ \\ break :x &a.b;
+ \\ } else |err| err;
+ \\}
+ \\
+ );
+}
+
+test "zig fmt: if condition has line break but must not wrap" {
+ try testCanonical(
+ \\comptime {
+ \\ if (self.user_input_options.put(
+ \\ name,
+ \\ UserInputOption{
+ \\ .name = name,
+ \\ .used = false,
+ \\ },
+ \\ ) catch unreachable) |*prev_value| {
+ \\ foo();
+ \\ bar();
+ \\ }
+ \\ if (put(
+ \\ a,
+ \\ b,
+ \\ )) {
+ \\ foo();
+ \\ }
\\}
\\
);
@@ -977,6 +1044,18 @@ test "zig fmt: if condition has line break but must not wrap" {
);
}
+test "zig fmt: function call with multiline argument" {
+ try testCanonical(
+ \\comptime {
+ \\ self.user_input_options.put(name, UserInputOption{
+ \\ .name = name,
+ \\ .used = false,
+ \\ });
+ \\}
+ \\
+ );
+}
+
test "zig fmt: same-line doc comment on variable declaration" {
try testTransform(
\\pub const MAP_ANONYMOUS = 0x1000; /// allocated from memory, swap space
@@ -1228,7 +1307,7 @@ test "zig fmt: array literal with hint" {
\\const a = []u8{
\\ 1, 2,
\\ 3, //
- \\ 4,
+ \\ 4,
\\ 5, 6,
\\ 7,
\\};
@@ -1293,7 +1372,7 @@ test "zig fmt: multiline string parameter in fn call with trailing comma" {
\\ \\ZIG_C_HEADER_FILES {}
\\ \\ZIG_DIA_GUIDS_LIB {}
\\ \\
- \\ ,
+ \\ ,
\\ std.cstr.toSliceConst(c.ZIG_CMAKE_BINARY_DIR),
\\ std.cstr.toSliceConst(c.ZIG_CXX_COMPILER),
\\ std.cstr.toSliceConst(c.ZIG_DIA_GUIDS_LIB),
@@ -2885,20 +2964,20 @@ test "zig fmt: multiline string in array" {
try testCanonical(
\\const Foo = [][]const u8{
\\ \\aaa
- \\,
+ \\ ,
\\ \\bbb
\\};
\\
\\fn bar() void {
\\ const Foo = [][]const u8{
\\ \\aaa
- \\ ,
+ \\ ,
\\ \\bbb
\\ };
\\ const Bar = [][]const u8{ // comment here
\\ \\aaa
\\ \\
- \\ , // and another comment can go here
+ \\ , // and another comment can go here
\\ \\bbb
\\ };
\\}
@@ -3214,6 +3293,23 @@ test "zig fmt: C var args" {
);
}
+test "zig fmt: Only indent multiline string literals in function calls" {
+ try testCanonical(
+ \\test "zig fmt:" {
+ \\ try testTransform(
+ \\ \\const X = struct {
+ \\ \\ foo: i32, bar: i8 };
+ \\ ,
+ \\ \\const X = struct {
+ \\ \\ foo: i32, bar: i8
+ \\ \\};
+ \\ \\
+ \\ );
+ \\}
+ \\
+ );
+}
+
const std = @import("std");
const mem = std.mem;
const warn = std.debug.warn;
@@ -3256,7 +3352,8 @@ fn testParse(source: []const u8, allocator: *mem.Allocator, anything_changed: *b
var buffer = std.ArrayList(u8).init(allocator);
errdefer buffer.deinit();
- anything_changed.* = try std.zig.render(allocator, buffer.outStream(), tree);
+ const outStream = buffer.outStream();
+ anything_changed.* = try std.zig.render(allocator, &outStream, tree);
return buffer.toOwnedSlice();
}
fn testTransform(source: []const u8, expected_source: []const u8) !void {
lib/std/zig/render.zig
@@ -6,6 +6,7 @@
const std = @import("../std.zig");
const assert = std.debug.assert;
const mem = std.mem;
+const meta = std.meta;
const ast = std.zig.ast;
const Token = std.zig.Token;
@@ -17,74 +18,37 @@ pub const Error = error{
};
/// Returns whether anything changed
-pub fn render(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree) (@TypeOf(stream).Error || Error)!bool {
+pub fn render(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree) (meta.Child(@TypeOf(stream)).Error || Error)!bool {
// cannot render an invalid tree
std.debug.assert(tree.errors.len == 0);
- // make a passthrough stream that checks whether something changed
- const MyStream = struct {
- const MyStream = @This();
- const StreamError = @TypeOf(stream).Error;
-
- child_stream: @TypeOf(stream),
- anything_changed: bool,
- source_index: usize,
- source: []const u8,
-
- fn write(self: *MyStream, bytes: []const u8) StreamError!usize {
- if (!self.anything_changed) {
- const end = self.source_index + bytes.len;
- if (end > self.source.len) {
- self.anything_changed = true;
- } else {
- const src_slice = self.source[self.source_index..end];
- self.source_index += bytes.len;
- if (!mem.eql(u8, bytes, src_slice)) {
- self.anything_changed = true;
- }
- }
- }
-
- return self.child_stream.write(bytes);
- }
- };
- var my_stream = MyStream{
- .child_stream = stream,
- .anything_changed = false,
- .source_index = 0,
- .source = tree.source,
- };
- const my_stream_stream: std.io.Writer(*MyStream, MyStream.StreamError, MyStream.write) = .{
- .context = &my_stream,
- };
+ var s = stream.*;
+ var change_detection_stream = std.io.changeDetectionStream(tree.source, &s);
+ var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, &change_detection_stream);
- try renderRoot(allocator, my_stream_stream, tree);
+ try renderRoot(allocator, &auto_indenting_stream, tree);
- if (my_stream.source_index != my_stream.source.len) {
- my_stream.anything_changed = true;
- }
-
- return my_stream.anything_changed;
+ return change_detection_stream.changeDetected();
}
fn renderRoot(
allocator: *mem.Allocator,
stream: anytype,
tree: *ast.Tree,
-) (@TypeOf(stream).Error || Error)!void {
+) (@TypeOf(stream.*).Error || Error)!void {
+
// render all the line comments at the beginning of the file
for (tree.token_ids) |token_id, i| {
if (token_id != .LineComment) break;
const token_loc = tree.token_locs[i];
- try stream.print("{}\n", .{mem.trimRight(u8, tree.tokenSliceLoc(token_loc), " ")});
+ try stream.writer().print("{}\n", .{mem.trimRight(u8, tree.tokenSliceLoc(token_loc), " ")});
const next_token = tree.token_locs[i + 1];
const loc = tree.tokenLocationLoc(token_loc.end, next_token);
if (loc.line >= 2) {
- try stream.writeByte('\n');
+ try stream.insertNewline();
}
}
- var start_col: usize = 0;
var decl_i: ast.NodeIndex = 0;
const root_decls = tree.root_node.decls();
@@ -189,23 +153,22 @@ fn renderRoot(
try copyFixingWhitespace(stream, tree.source[start..end]);
}
- try renderTopLevelDecl(allocator, stream, tree, 0, &start_col, decl);
+ try renderTopLevelDecl(allocator, stream, tree, decl);
decl_i += 1;
if (decl_i >= root_decls.len) return;
- try renderExtraNewline(tree, stream, &start_col, root_decls[decl_i]);
+ try renderExtraNewline(tree, stream, root_decls[decl_i]);
}
}
-fn renderExtraNewline(tree: *ast.Tree, stream: anytype, start_col: *usize, node: *ast.Node) @TypeOf(stream).Error!void {
- return renderExtraNewlineToken(tree, stream, start_col, node.firstToken());
+fn renderExtraNewline(tree: *ast.Tree, stream: anytype, node: *ast.Node) @TypeOf(stream.*).Error!void {
+ return renderExtraNewlineToken(tree, stream, node.firstToken());
}
fn renderExtraNewlineToken(
tree: *ast.Tree,
stream: anytype,
- start_col: *usize,
first_token: ast.TokenIndex,
-) @TypeOf(stream).Error!void {
+) @TypeOf(stream.*).Error!void {
var prev_token = first_token;
if (prev_token == 0) return;
var newline_threshold: usize = 2;
@@ -218,28 +181,27 @@ fn renderExtraNewlineToken(
const prev_token_end = tree.token_locs[prev_token - 1].end;
const loc = tree.tokenLocation(prev_token_end, first_token);
if (loc.line >= newline_threshold) {
- try stream.writeByte('\n');
- start_col.* = 0;
+ try stream.insertNewline();
}
}
-fn renderTopLevelDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree, indent: usize, start_col: *usize, decl: *ast.Node) (@TypeOf(stream).Error || Error)!void {
- try renderContainerDecl(allocator, stream, tree, indent, start_col, decl, .Newline);
+fn renderTopLevelDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree, decl: *ast.Node) (@TypeOf(stream.*).Error || Error)!void {
+ try renderContainerDecl(allocator, stream, tree, decl, .Newline);
}
-fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree, indent: usize, start_col: *usize, decl: *ast.Node, space: Space) (@TypeOf(stream).Error || Error)!void {
+fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tree, decl: *ast.Node, space: Space) (@TypeOf(stream.*).Error || Error)!void {
switch (decl.tag) {
.FnProto => {
const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
- try renderDocComments(tree, stream, fn_proto, fn_proto.getTrailer("doc_comments"), indent, start_col);
+ try renderDocComments(tree, stream, fn_proto, fn_proto.getTrailer("doc_comments"));
if (fn_proto.getTrailer("body_node")) |body_node| {
- try renderExpression(allocator, stream, tree, indent, start_col, decl, .Space);
- try renderExpression(allocator, stream, tree, indent, start_col, body_node, space);
+ try renderExpression(allocator, stream, tree, decl, .Space);
+ try renderExpression(allocator, stream, tree, body_node, space);
} else {
- try renderExpression(allocator, stream, tree, indent, start_col, decl, .None);
- try renderToken(tree, stream, tree.nextToken(decl.lastToken()), indent, start_col, space);
+ try renderExpression(allocator, stream, tree, decl, .None);
+ try renderToken(tree, stream, tree.nextToken(decl.lastToken()), space);
}
},
@@ -247,35 +209,35 @@ fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tr
const use_decl = @fieldParentPtr(ast.Node.Use, "base", decl);
if (use_decl.visib_token) |visib_token| {
- try renderToken(tree, stream, visib_token, indent, start_col, .Space); // pub
+ try renderToken(tree, stream, visib_token, .Space); // pub
}
- try renderToken(tree, stream, use_decl.use_token, indent, start_col, .Space); // usingnamespace
- try renderExpression(allocator, stream, tree, indent, start_col, use_decl.expr, .None);
- try renderToken(tree, stream, use_decl.semicolon_token, indent, start_col, space); // ;
+ try renderToken(tree, stream, use_decl.use_token, .Space); // usingnamespace
+ try renderExpression(allocator, stream, tree, use_decl.expr, .None);
+ try renderToken(tree, stream, use_decl.semicolon_token, space); // ;
},
.VarDecl => {
const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", decl);
- try renderDocComments(tree, stream, var_decl, var_decl.getTrailer("doc_comments"), indent, start_col);
- try renderVarDecl(allocator, stream, tree, indent, start_col, var_decl);
+ try renderDocComments(tree, stream, var_decl, var_decl.getTrailer("doc_comments"));
+ try renderVarDecl(allocator, stream, tree, var_decl);
},
.TestDecl => {
const test_decl = @fieldParentPtr(ast.Node.TestDecl, "base", decl);
- try renderDocComments(tree, stream, test_decl, test_decl.doc_comments, indent, start_col);
- try renderToken(tree, stream, test_decl.test_token, indent, start_col, .Space);
- try renderExpression(allocator, stream, tree, indent, start_col, test_decl.name, .Space);
- try renderExpression(allocator, stream, tree, indent, start_col, test_decl.body_node, space);
+ try renderDocComments(tree, stream, test_decl, test_decl.doc_comments);
+ try renderToken(tree, stream, test_decl.test_token, .Space);
+ try renderExpression(allocator, stream, tree, test_decl.name, .Space);
+ try renderExpression(allocator, stream, tree, test_decl.body_node, space);
},
.ContainerField => {
const field = @fieldParentPtr(ast.Node.ContainerField, "base", decl);
- try renderDocComments(tree, stream, field, field.doc_comments, indent, start_col);
+ try renderDocComments(tree, stream, field, field.doc_comments);
if (field.comptime_token) |t| {
- try renderToken(tree, stream, t, indent, start_col, .Space); // comptime
+ try renderToken(tree, stream, t, .Space); // comptime
}
const src_has_trailing_comma = blk: {
@@ -288,68 +250,67 @@ fn renderContainerDecl(allocator: *mem.Allocator, stream: anytype, tree: *ast.Tr
const last_token_space: Space = if (src_has_trailing_comma) .None else space;
if (field.type_expr == null and field.value_expr == null) {
- try renderToken(tree, stream, field.name_token, indent, start_col, last_token_space); // name
+ try renderToken(tree, stream, field.name_token, last_token_space); // name
} else if (field.type_expr != null and field.value_expr == null) {
- try renderToken(tree, stream, field.name_token, indent, start_col, .None); // name
- try renderToken(tree, stream, tree.nextToken(field.name_token), indent, start_col, .Space); // :
+ try renderToken(tree, stream, field.name_token, .None); // name
+ try renderToken(tree, stream, tree.nextToken(field.name_token), .Space); // :
if (field.align_expr) |align_value_expr| {
- try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, .Space); // type
+ try renderExpression(allocator, stream, tree, field.type_expr.?, .Space); // type
const lparen_token = tree.prevToken(align_value_expr.firstToken());
const align_kw = tree.prevToken(lparen_token);
const rparen_token = tree.nextToken(align_value_expr.lastToken());
- try renderToken(tree, stream, align_kw, indent, start_col, .None); // align
- try renderToken(tree, stream, lparen_token, indent, start_col, .None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, align_value_expr, .None); // alignment
- try renderToken(tree, stream, rparen_token, indent, start_col, last_token_space); // )
+ try renderToken(tree, stream, align_kw, .None); // align
+ try renderToken(tree, stream, lparen_token, .None); // (
+ try renderExpression(allocator, stream, tree, align_value_expr, .None); // alignment
+ try renderToken(tree, stream, rparen_token, last_token_space); // )
} else {
- try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, last_token_space); // type
+ try renderExpression(allocator, stream, tree, field.type_expr.?, last_token_space); // type
}
} else if (field.type_expr == null and field.value_expr != null) {
- try renderToken(tree, stream, field.name_token, indent, start_col, .Space); // name
- try renderToken(tree, stream, tree.nextToken(field.name_token), indent, start_col, .Space); // =
- try renderExpression(allocator, stream, tree, indent, start_col, field.value_expr.?, last_token_space); // value
+ try renderToken(tree, stream, field.name_token, .Space); // name
+ try renderToken(tree, stream, tree.nextToken(field.name_token), .Space); // =
+ try renderExpression(allocator, stream, tree, field.value_expr.?, last_token_space); // value
} else {
- try renderToken(tree, stream, field.name_token, indent, start_col, .None); // name
- try renderToken(tree, stream, tree.nextToken(field.name_token), indent, start_col, .Space); // :
+ try renderToken(tree, stream, field.name_token, .None); // name
+ try renderToken(tree, stream, tree.nextToken(field.name_token), .Space); // :
if (field.align_expr) |align_value_expr| {
- try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, .Space); // type
+ try renderExpression(allocator, stream, tree, field.type_expr.?, .Space); // type
const lparen_token = tree.prevToken(align_value_expr.firstToken());
const align_kw = tree.prevToken(lparen_token);
const rparen_token = tree.nextToken(align_value_expr.lastToken());
- try renderToken(tree, stream, align_kw, indent, start_col, .None); // align
- try renderToken(tree, stream, lparen_token, indent, start_col, .None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, align_value_expr, .None); // alignment
- try renderToken(tree, stream, rparen_token, indent, start_col, .Space); // )
+ try renderToken(tree, stream, align_kw, .None); // align
+ try renderToken(tree, stream, lparen_token, .None); // (
+ try renderExpression(allocator, stream, tree, align_value_expr, .None); // alignment
+ try renderToken(tree, stream, rparen_token, .Space); // )
} else {
- try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, .Space); // type
+ try renderExpression(allocator, stream, tree, field.type_expr.?, .Space); // type
}
- try renderToken(tree, stream, tree.prevToken(field.value_expr.?.firstToken()), indent, start_col, .Space); // =
- try renderExpression(allocator, stream, tree, indent, start_col, field.value_expr.?, last_token_space); // value
+ try renderToken(tree, stream, tree.prevToken(field.value_expr.?.firstToken()), .Space); // =
+ try renderExpression(allocator, stream, tree, field.value_expr.?, last_token_space); // value
}
if (src_has_trailing_comma) {
const comma = tree.nextToken(field.lastToken());
- try renderToken(tree, stream, comma, indent, start_col, space);
+ try renderToken(tree, stream, comma, space);
}
},
.Comptime => {
assert(!decl.requireSemiColon());
- try renderExpression(allocator, stream, tree, indent, start_col, decl, space);
+ try renderExpression(allocator, stream, tree, decl, space);
},
.DocComment => {
const comment = @fieldParentPtr(ast.Node.DocComment, "base", decl);
const kind = tree.token_ids[comment.first_line];
- try renderToken(tree, stream, comment.first_line, indent, start_col, .Newline);
+ try renderToken(tree, stream, comment.first_line, .Newline);
var tok_i = comment.first_line + 1;
while (true) : (tok_i += 1) {
const tok_id = tree.token_ids[tok_i];
if (tok_id == kind) {
- try stream.writeByteNTimes(' ', indent);
- try renderToken(tree, stream, tok_i, indent, start_col, .Newline);
+ try renderToken(tree, stream, tok_i, .Newline);
} else if (tok_id == .LineComment) {
continue;
} else {
@@ -365,11 +326,9 @@ fn renderExpression(
allocator: *mem.Allocator,
stream: anytype,
tree: *ast.Tree,
- indent: usize,
- start_col: *usize,
base: *ast.Node,
space: Space,
-) (@TypeOf(stream).Error || Error)!void {
+) (@TypeOf(stream.*).Error || Error)!void {
switch (base.tag) {
.Identifier,
.IntegerLiteral,
@@ -383,18 +342,18 @@ fn renderExpression(
.UndefinedLiteral,
=> {
const casted_node = base.cast(ast.Node.OneToken).?;
- return renderToken(tree, stream, casted_node.token, indent, start_col, space);
+ return renderToken(tree, stream, casted_node.token, space);
},
.AnyType => {
const any_type = base.castTag(.AnyType).?;
if (mem.eql(u8, tree.tokenSlice(any_type.token), "var")) {
// TODO remove in next release cycle
- try stream.writeAll("anytype");
- if (space == .Comma) try stream.writeAll(",\n");
+ try stream.writer().writeAll("anytype");
+ if (space == .Comma) try stream.writer().writeAll(",\n");
return;
}
- return renderToken(tree, stream, any_type.token, indent, start_col, space);
+ return renderToken(tree, stream, any_type.token, space);
},
.Block, .LabeledBlock => {
@@ -424,65 +383,65 @@ fn renderExpression(
};
if (block.label) |label| {
- try renderToken(tree, stream, label, indent, start_col, Space.None);
- try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space);
+ try renderToken(tree, stream, label, Space.None);
+ try renderToken(tree, stream, tree.nextToken(label), Space.Space);
}
if (block.statements.len == 0) {
- try renderToken(tree, stream, block.lbrace, indent + indent_delta, start_col, Space.None);
- return renderToken(tree, stream, block.rbrace, indent, start_col, space);
+ stream.pushIndentNextLine();
+ defer stream.popIndent();
+ try renderToken(tree, stream, block.lbrace, Space.None);
} else {
- const block_indent = indent + indent_delta;
- try renderToken(tree, stream, block.lbrace, block_indent, start_col, Space.Newline);
+ stream.pushIndentNextLine();
+ defer stream.popIndent();
+
+ try renderToken(tree, stream, block.lbrace, Space.Newline);
for (block.statements) |statement, i| {
- try stream.writeByteNTimes(' ', block_indent);
- try renderStatement(allocator, stream, tree, block_indent, start_col, statement);
+ try renderStatement(allocator, stream, tree, statement);
if (i + 1 < block.statements.len) {
- try renderExtraNewline(tree, stream, start_col, block.statements[i + 1]);
+ try renderExtraNewline(tree, stream, block.statements[i + 1]);
}
}
-
- try stream.writeByteNTimes(' ', indent);
- return renderToken(tree, stream, block.rbrace, indent, start_col, space);
}
+ return renderToken(tree, stream, block.rbrace, space);
},
.Defer => {
const defer_node = @fieldParentPtr(ast.Node.Defer, "base", base);
- try renderToken(tree, stream, defer_node.defer_token, indent, start_col, Space.Space);
+ try renderToken(tree, stream, defer_node.defer_token, Space.Space);
if (defer_node.payload) |payload| {
- try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
+ try renderExpression(allocator, stream, tree, payload, Space.Space);
}
- return renderExpression(allocator, stream, tree, indent, start_col, defer_node.expr, space);
+ return renderExpression(allocator, stream, tree, defer_node.expr, space);
},
.Comptime => {
const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", base);
- try renderToken(tree, stream, comptime_node.comptime_token, indent, start_col, Space.Space);
- return renderExpression(allocator, stream, tree, indent, start_col, comptime_node.expr, space);
+ try renderToken(tree, stream, comptime_node.comptime_token, Space.Space);
+ return renderExpression(allocator, stream, tree, comptime_node.expr, space);
},
.Nosuspend => {
const nosuspend_node = @fieldParentPtr(ast.Node.Nosuspend, "base", base);
if (mem.eql(u8, tree.tokenSlice(nosuspend_node.nosuspend_token), "noasync")) {
// TODO: remove this
- try stream.writeAll("nosuspend ");
+ try stream.writer().writeAll("nosuspend ");
} else {
- try renderToken(tree, stream, nosuspend_node.nosuspend_token, indent, start_col, Space.Space);
+ try renderToken(tree, stream, nosuspend_node.nosuspend_token, Space.Space);
}
- return renderExpression(allocator, stream, tree, indent, start_col, nosuspend_node.expr, space);
+ return renderExpression(allocator, stream, tree, nosuspend_node.expr, space);
},
.Suspend => {
const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", base);
if (suspend_node.body) |body| {
- try renderToken(tree, stream, suspend_node.suspend_token, indent, start_col, Space.Space);
- return renderExpression(allocator, stream, tree, indent, start_col, body, space);
+ try renderToken(tree, stream, suspend_node.suspend_token, Space.Space);
+ return renderExpression(allocator, stream, tree, body, space);
} else {
- return renderToken(tree, stream, suspend_node.suspend_token, indent, start_col, space);
+ return renderToken(tree, stream, suspend_node.suspend_token, space);
}
},
@@ -490,26 +449,21 @@ fn renderExpression(
const infix_op_node = @fieldParentPtr(ast.Node.Catch, "base", base);
const op_space = Space.Space;
- try renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.lhs, op_space);
+ try renderExpression(allocator, stream, tree, infix_op_node.lhs, op_space);
const after_op_space = blk: {
- const loc = tree.tokenLocation(tree.token_locs[infix_op_node.op_token].end, tree.nextToken(infix_op_node.op_token));
- break :blk if (loc.line == 0) op_space else Space.Newline;
+ const same_line = tree.tokensOnSameLine(infix_op_node.op_token, tree.nextToken(infix_op_node.op_token));
+ break :blk if (same_line) op_space else Space.Newline;
};
- try renderToken(tree, stream, infix_op_node.op_token, indent, start_col, after_op_space);
- if (after_op_space == Space.Newline and
- tree.token_ids[tree.nextToken(infix_op_node.op_token)] != .MultilineStringLiteralLine)
- {
- try stream.writeByteNTimes(' ', indent + indent_delta);
- start_col.* = indent + indent_delta;
- }
+ try renderToken(tree, stream, infix_op_node.op_token, after_op_space);
if (infix_op_node.payload) |payload| {
- try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
+ try renderExpression(allocator, stream, tree, payload, Space.Space);
}
- return renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.rhs, space);
+ stream.pushIndentOneShot();
+ return renderExpression(allocator, stream, tree, infix_op_node.rhs, space);
},
.Add,
@@ -561,22 +515,16 @@ fn renderExpression(
.Period, .ErrorUnion, .Range => Space.None,
else => Space.Space,
};
- try renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.lhs, op_space);
+ try renderExpression(allocator, stream, tree, infix_op_node.lhs, op_space);
const after_op_space = blk: {
const loc = tree.tokenLocation(tree.token_locs[infix_op_node.op_token].end, tree.nextToken(infix_op_node.op_token));
break :blk if (loc.line == 0) op_space else Space.Newline;
};
- try renderToken(tree, stream, infix_op_node.op_token, indent, start_col, after_op_space);
- if (after_op_space == Space.Newline and
- tree.token_ids[tree.nextToken(infix_op_node.op_token)] != .MultilineStringLiteralLine)
- {
- try stream.writeByteNTimes(' ', indent + indent_delta);
- start_col.* = indent + indent_delta;
- }
-
- return renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.rhs, space);
+ try renderToken(tree, stream, infix_op_node.op_token, after_op_space);
+ stream.pushIndentOneShot();
+ return renderExpression(allocator, stream, tree, infix_op_node.rhs, space);
},
.BitNot,
@@ -587,8 +535,8 @@ fn renderExpression(
.AddressOf,
=> {
const casted_node = @fieldParentPtr(ast.Node.SimplePrefixOp, "base", base);
- try renderToken(tree, stream, casted_node.op_token, indent, start_col, Space.None);
- return renderExpression(allocator, stream, tree, indent, start_col, casted_node.rhs, space);
+ try renderToken(tree, stream, casted_node.op_token, Space.None);
+ return renderExpression(allocator, stream, tree, casted_node.rhs, space);
},
.Try,
@@ -596,8 +544,8 @@ fn renderExpression(
.Await,
=> {
const casted_node = @fieldParentPtr(ast.Node.SimplePrefixOp, "base", base);
- try renderToken(tree, stream, casted_node.op_token, indent, start_col, Space.Space);
- return renderExpression(allocator, stream, tree, indent, start_col, casted_node.rhs, space);
+ try renderToken(tree, stream, casted_node.op_token, Space.Space);
+ return renderExpression(allocator, stream, tree, casted_node.rhs, space);
},
.ArrayType => {
@@ -606,8 +554,6 @@ fn renderExpression(
allocator,
stream,
tree,
- indent,
- start_col,
array_type.op_token,
array_type.rhs,
array_type.len_expr,
@@ -621,8 +567,6 @@ fn renderExpression(
allocator,
stream,
tree,
- indent,
- start_col,
array_type.op_token,
array_type.rhs,
array_type.len_expr,
@@ -635,111 +579,111 @@ fn renderExpression(
const ptr_type = @fieldParentPtr(ast.Node.PtrType, "base", base);
const op_tok_id = tree.token_ids[ptr_type.op_token];
switch (op_tok_id) {
- .Asterisk, .AsteriskAsterisk => try stream.writeByte('*'),
+ .Asterisk, .AsteriskAsterisk => try stream.writer().writeByte('*'),
.LBracket => if (tree.token_ids[ptr_type.op_token + 2] == .Identifier)
- try stream.writeAll("[*c")
+ try stream.writer().writeAll("[*c")
else
- try stream.writeAll("[*"),
+ try stream.writer().writeAll("[*"),
else => unreachable,
}
if (ptr_type.ptr_info.sentinel) |sentinel| {
const colon_token = tree.prevToken(sentinel.firstToken());
- try renderToken(tree, stream, colon_token, indent, start_col, Space.None); // :
+ try renderToken(tree, stream, colon_token, Space.None); // :
const sentinel_space = switch (op_tok_id) {
.LBracket => Space.None,
else => Space.Space,
};
- try renderExpression(allocator, stream, tree, indent, start_col, sentinel, sentinel_space);
+ try renderExpression(allocator, stream, tree, sentinel, sentinel_space);
}
switch (op_tok_id) {
.Asterisk, .AsteriskAsterisk => {},
- .LBracket => try stream.writeByte(']'),
+ .LBracket => try stream.writer().writeByte(']'),
else => unreachable,
}
if (ptr_type.ptr_info.allowzero_token) |allowzero_token| {
- try renderToken(tree, stream, allowzero_token, indent, start_col, Space.Space); // allowzero
+ try renderToken(tree, stream, allowzero_token, Space.Space); // allowzero
}
if (ptr_type.ptr_info.align_info) |align_info| {
const lparen_token = tree.prevToken(align_info.node.firstToken());
const align_token = tree.prevToken(lparen_token);
- try renderToken(tree, stream, align_token, indent, start_col, Space.None); // align
- try renderToken(tree, stream, lparen_token, indent, start_col, Space.None); // (
+ try renderToken(tree, stream, align_token, Space.None); // align
+ try renderToken(tree, stream, lparen_token, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, align_info.node, Space.None);
+ try renderExpression(allocator, stream, tree, align_info.node, Space.None);
if (align_info.bit_range) |bit_range| {
const colon1 = tree.prevToken(bit_range.start.firstToken());
const colon2 = tree.prevToken(bit_range.end.firstToken());
- try renderToken(tree, stream, colon1, indent, start_col, Space.None); // :
- try renderExpression(allocator, stream, tree, indent, start_col, bit_range.start, Space.None);
- try renderToken(tree, stream, colon2, indent, start_col, Space.None); // :
- try renderExpression(allocator, stream, tree, indent, start_col, bit_range.end, Space.None);
+ try renderToken(tree, stream, colon1, Space.None); // :
+ try renderExpression(allocator, stream, tree, bit_range.start, Space.None);
+ try renderToken(tree, stream, colon2, Space.None); // :
+ try renderExpression(allocator, stream, tree, bit_range.end, Space.None);
const rparen_token = tree.nextToken(bit_range.end.lastToken());
- try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, rparen_token, Space.Space); // )
} else {
const rparen_token = tree.nextToken(align_info.node.lastToken());
- try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, rparen_token, Space.Space); // )
}
}
if (ptr_type.ptr_info.const_token) |const_token| {
- try renderToken(tree, stream, const_token, indent, start_col, Space.Space); // const
+ try renderToken(tree, stream, const_token, Space.Space); // const
}
if (ptr_type.ptr_info.volatile_token) |volatile_token| {
- try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space); // volatile
+ try renderToken(tree, stream, volatile_token, Space.Space); // volatile
}
- return renderExpression(allocator, stream, tree, indent, start_col, ptr_type.rhs, space);
+ return renderExpression(allocator, stream, tree, ptr_type.rhs, space);
},
.SliceType => {
const slice_type = @fieldParentPtr(ast.Node.SliceType, "base", base);
- try renderToken(tree, stream, slice_type.op_token, indent, start_col, Space.None); // [
+ try renderToken(tree, stream, slice_type.op_token, Space.None); // [
if (slice_type.ptr_info.sentinel) |sentinel| {
const colon_token = tree.prevToken(sentinel.firstToken());
- try renderToken(tree, stream, colon_token, indent, start_col, Space.None); // :
- try renderExpression(allocator, stream, tree, indent, start_col, sentinel, Space.None);
- try renderToken(tree, stream, tree.nextToken(sentinel.lastToken()), indent, start_col, Space.None); // ]
+ try renderToken(tree, stream, colon_token, Space.None); // :
+ try renderExpression(allocator, stream, tree, sentinel, Space.None);
+ try renderToken(tree, stream, tree.nextToken(sentinel.lastToken()), Space.None); // ]
} else {
- try renderToken(tree, stream, tree.nextToken(slice_type.op_token), indent, start_col, Space.None); // ]
+ try renderToken(tree, stream, tree.nextToken(slice_type.op_token), Space.None); // ]
}
if (slice_type.ptr_info.allowzero_token) |allowzero_token| {
- try renderToken(tree, stream, allowzero_token, indent, start_col, Space.Space); // allowzero
+ try renderToken(tree, stream, allowzero_token, Space.Space); // allowzero
}
if (slice_type.ptr_info.align_info) |align_info| {
const lparen_token = tree.prevToken(align_info.node.firstToken());
const align_token = tree.prevToken(lparen_token);
- try renderToken(tree, stream, align_token, indent, start_col, Space.None); // align
- try renderToken(tree, stream, lparen_token, indent, start_col, Space.None); // (
+ try renderToken(tree, stream, align_token, Space.None); // align
+ try renderToken(tree, stream, lparen_token, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, align_info.node, Space.None);
+ try renderExpression(allocator, stream, tree, align_info.node, Space.None);
if (align_info.bit_range) |bit_range| {
const colon1 = tree.prevToken(bit_range.start.firstToken());
const colon2 = tree.prevToken(bit_range.end.firstToken());
- try renderToken(tree, stream, colon1, indent, start_col, Space.None); // :
- try renderExpression(allocator, stream, tree, indent, start_col, bit_range.start, Space.None);
- try renderToken(tree, stream, colon2, indent, start_col, Space.None); // :
- try renderExpression(allocator, stream, tree, indent, start_col, bit_range.end, Space.None);
+ try renderToken(tree, stream, colon1, Space.None); // :
+ try renderExpression(allocator, stream, tree, bit_range.start, Space.None);
+ try renderToken(tree, stream, colon2, Space.None); // :
+ try renderExpression(allocator, stream, tree, bit_range.end, Space.None);
const rparen_token = tree.nextToken(bit_range.end.lastToken());
- try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, rparen_token, Space.Space); // )
} else {
const rparen_token = tree.nextToken(align_info.node.lastToken());
- try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, rparen_token, Space.Space); // )
}
}
if (slice_type.ptr_info.const_token) |const_token| {
- try renderToken(tree, stream, const_token, indent, start_col, Space.Space);
+ try renderToken(tree, stream, const_token, Space.Space);
}
if (slice_type.ptr_info.volatile_token) |volatile_token| {
- try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space);
+ try renderToken(tree, stream, volatile_token, Space.Space);
}
- return renderExpression(allocator, stream, tree, indent, start_col, slice_type.rhs, space);
+ return renderExpression(allocator, stream, tree, slice_type.rhs, space);
},
.ArrayInitializer, .ArrayInitializerDot => {
@@ -768,27 +712,33 @@ fn renderExpression(
if (exprs.len == 0) {
switch (lhs) {
- .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
- .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
+ .dot => |dot| try renderToken(tree, stream, dot, Space.None),
+ .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
+ }
+
+ {
+ stream.pushIndent();
+ defer stream.popIndent();
+ try renderToken(tree, stream, lbrace, Space.None);
}
- try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
- return renderToken(tree, stream, rtoken, indent, start_col, space);
- }
- if (exprs.len == 1 and tree.token_ids[exprs[0].lastToken() + 1] == .RBrace) {
+ return renderToken(tree, stream, rtoken, space);
+ }
+ if (exprs.len == 1 and tree.token_ids[exprs[0].*.lastToken() + 1] == .RBrace) {
const expr = exprs[0];
+
switch (lhs) {
- .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
- .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
+ .dot => |dot| try renderToken(tree, stream, dot, Space.None),
+ .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
}
- try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
- try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
- return renderToken(tree, stream, rtoken, indent, start_col, space);
+ try renderToken(tree, stream, lbrace, Space.None);
+ try renderExpression(allocator, stream, tree, expr, Space.None);
+ return renderToken(tree, stream, rtoken, space);
}
switch (lhs) {
- .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
- .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
+ .dot => |dot| try renderToken(tree, stream, dot, Space.None),
+ .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
}
// scan to find row size
@@ -832,77 +782,68 @@ fn renderExpression(
// Null stream for counting the printed length of each expression
var counting_stream = std.io.countingOutStream(std.io.null_out_stream);
+ var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, &counting_stream);
for (exprs) |expr, i| {
counting_stream.bytes_written = 0;
- var dummy_col: usize = 0;
- try renderExpression(allocator, counting_stream.outStream(), tree, indent, &dummy_col, expr, Space.None);
+ try renderExpression(allocator, &auto_indenting_stream, tree, expr, Space.None);
const width = @intCast(usize, counting_stream.bytes_written);
const col = i % row_size;
column_widths[col] = std.math.max(column_widths[col], width);
expr_widths[i] = width;
}
- var new_indent = indent + indent_delta;
+ {
+ stream.pushIndentNextLine();
+ defer stream.popIndent();
+ try renderToken(tree, stream, lbrace, Space.Newline);
- if (tree.token_ids[tree.nextToken(lbrace)] != .MultilineStringLiteralLine) {
- try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline);
- try stream.writeByteNTimes(' ', new_indent);
- } else {
- new_indent -= indent_delta;
- try renderToken(tree, stream, lbrace, new_indent, start_col, Space.None);
- }
+ var col: usize = 1;
+ for (exprs) |expr, i| {
+ if (i + 1 < exprs.len) {
+ const next_expr = exprs[i + 1];
+ try renderExpression(allocator, stream, tree, expr, Space.None);
- var col: usize = 1;
- for (exprs) |expr, i| {
- if (i + 1 < exprs.len) {
- const next_expr = exprs[i + 1];
- try renderExpression(allocator, stream, tree, new_indent, start_col, expr, Space.None);
+ const comma = tree.nextToken(expr.*.lastToken());
- const comma = tree.nextToken(expr.lastToken());
+ if (col != row_size) {
+ try renderToken(tree, stream, comma, Space.Space); // ,
- if (col != row_size) {
- try renderToken(tree, stream, comma, new_indent, start_col, Space.Space); // ,
+ const padding = column_widths[i % row_size] - expr_widths[i];
+ try stream.writer().writeByteNTimes(' ', padding);
- const padding = column_widths[i % row_size] - expr_widths[i];
- try stream.writeByteNTimes(' ', padding);
+ col += 1;
+ continue;
+ }
+ col = 1;
- col += 1;
- continue;
- }
- col = 1;
+ if (tree.token_ids[tree.nextToken(comma)] != .MultilineStringLiteralLine) {
+ try renderToken(tree, stream, comma, Space.Newline); // ,
+ } else {
+ try renderToken(tree, stream, comma, Space.None); // ,
+ }
- if (tree.token_ids[tree.nextToken(comma)] != .MultilineStringLiteralLine) {
- try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline); // ,
+ try renderExtraNewline(tree, stream, next_expr);
} else {
- try renderToken(tree, stream, comma, new_indent, start_col, Space.None); // ,
- }
-
- try renderExtraNewline(tree, stream, start_col, next_expr);
- if (next_expr.tag != .MultilineStringLiteral) {
- try stream.writeByteNTimes(' ', new_indent);
+ try renderExpression(allocator, stream, tree, expr, Space.Comma); // ,
}
- } else {
- try renderExpression(allocator, stream, tree, new_indent, start_col, expr, Space.Comma); // ,
}
}
- if (exprs[exprs.len - 1].tag != .MultilineStringLiteral) {
- try stream.writeByteNTimes(' ', indent);
- }
- return renderToken(tree, stream, rtoken, indent, start_col, space);
+ return renderToken(tree, stream, rtoken, space);
} else {
- try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
+ try renderToken(tree, stream, lbrace, Space.Space);
for (exprs) |expr, i| {
if (i + 1 < exprs.len) {
- try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
- const comma = tree.nextToken(expr.lastToken());
- try renderToken(tree, stream, comma, indent, start_col, Space.Space); // ,
+ const next_expr = exprs[i + 1];
+ try renderExpression(allocator, stream, tree, expr, Space.None);
+ const comma = tree.nextToken(expr.*.lastToken());
+ try renderToken(tree, stream, comma, Space.Space); // ,
} else {
- try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.Space);
+ try renderExpression(allocator, stream, tree, expr, Space.Space);
}
}
- return renderToken(tree, stream, rtoken, indent, start_col, space);
+ return renderToken(tree, stream, rtoken, space);
}
},
@@ -932,11 +873,17 @@ fn renderExpression(
if (field_inits.len == 0) {
switch (lhs) {
- .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
- .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
+ .dot => |dot| try renderToken(tree, stream, dot, Space.None),
+ .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
}
- try renderToken(tree, stream, lbrace, indent + indent_delta, start_col, Space.None);
- return renderToken(tree, stream, rtoken, indent, start_col, space);
+
+ {
+ stream.pushIndentNextLine();
+ defer stream.popIndent();
+ try renderToken(tree, stream, lbrace, Space.None);
+ }
+
+ return renderToken(tree, stream, rtoken, space);
}
const src_has_trailing_comma = blk: {
@@ -952,9 +899,10 @@ fn renderExpression(
const expr_outputs_one_line = blk: {
// render field expressions until a LF is found
for (field_inits) |field_init| {
- var find_stream = FindByteOutStream.init('\n');
- var dummy_col: usize = 0;
- try renderExpression(allocator, find_stream.outStream(), tree, 0, &dummy_col, field_init, Space.None);
+ var find_stream = std.io.findByteOutStream('\n', &std.io.null_out_stream);
+ var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, &find_stream);
+
+ try renderExpression(allocator, &auto_indenting_stream, tree, field_init, Space.None);
if (find_stream.byte_found) break :blk false;
}
break :blk true;
@@ -967,7 +915,6 @@ fn renderExpression(
.StructInitializer,
.StructInitializerDot,
=> break :blk,
-
else => {},
}
@@ -977,76 +924,78 @@ fn renderExpression(
}
switch (lhs) {
- .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
- .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
+ .dot => |dot| try renderToken(tree, stream, dot, Space.None),
+ .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
}
- try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
- try renderExpression(allocator, stream, tree, indent, start_col, &field_init.base, Space.Space);
- return renderToken(tree, stream, rtoken, indent, start_col, space);
+ try renderToken(tree, stream, lbrace, Space.Space);
+ try renderExpression(allocator, stream, tree, &field_init.base, Space.Space);
+ return renderToken(tree, stream, rtoken, space);
}
if (!src_has_trailing_comma and src_same_line and expr_outputs_one_line) {
// render all on one line, no trailing comma
switch (lhs) {
- .dot => |dot| try renderToken(tree, stream, dot, indent, start_col, Space.None),
- .node => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
+ .dot => |dot| try renderToken(tree, stream, dot, Space.None),
+ .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
}
- try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
+ try renderToken(tree, stream, lbrace, Space.Space);
for (field_inits) |field_init, i| {
if (i + 1 < field_inits.len) {
- try renderExpression(allocator, stream, tree, indent, start_col, field_init, Space.None);
+ try renderExpression(allocator, stream, tree, field_init, Space.None);
const comma = tree.nextToken(field_init.lastToken());
- try renderToken(tree, stream, comma, indent, start_col, Space.Space);
+ try renderToken(tree, stream, comma, Space.Space);
} else {
- try renderExpression(allocator, stream, tree, indent, start_col, field_init, Space.Space);
+ try renderExpression(allocator, stream, tree, field_init, Space.Space);
}
}
- return renderToken(tree, stream, rtoken, indent, start_col, space);
+ return renderToken(tree, stream, rtoken, space);
}
- const new_indent = indent + indent_delta;
+ {
+ switch (lhs) {
+ .dot => |dot| try renderToken(tree, stream, dot, Space.None),
+ .node => |node| try renderExpression(allocator, stream, tree, node, Space.None),
+ }
- switch (lhs) {
- .dot => |dot| try renderToken(tree, stream, dot, new_indent, start_col, Space.None),
- .node => |node| try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.None),
- }
- try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline);
+ stream.pushIndentNextLine();
+ defer stream.popIndent();
- for (field_inits) |field_init, i| {
- try stream.writeByteNTimes(' ', new_indent);
+ try renderToken(tree, stream, lbrace, Space.Newline);
- if (i + 1 < field_inits.len) {
- try renderExpression(allocator, stream, tree, new_indent, start_col, field_init, Space.None);
+ for (field_inits) |field_init, i| {
+ if (i + 1 < field_inits.len) {
+ const next_field_init = field_inits[i + 1];
+ try renderExpression(allocator, stream, tree, field_init, Space.None);
- const comma = tree.nextToken(field_init.lastToken());
- try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline);
+ const comma = tree.nextToken(field_init.lastToken());
+ try renderToken(tree, stream, comma, Space.Newline);
- try renderExtraNewline(tree, stream, start_col, field_inits[i + 1]);
- } else {
- try renderExpression(allocator, stream, tree, new_indent, start_col, field_init, Space.Comma);
+ try renderExtraNewline(tree, stream, next_field_init);
+ } else {
+ try renderExpression(allocator, stream, tree, field_init, Space.Comma);
+ }
}
}
- try stream.writeByteNTimes(' ', indent);
- return renderToken(tree, stream, rtoken, indent, start_col, space);
+ return renderToken(tree, stream, rtoken, space);
},
.Call => {
const call = @fieldParentPtr(ast.Node.Call, "base", base);
if (call.async_token) |async_token| {
- try renderToken(tree, stream, async_token, indent, start_col, Space.Space);
+ try renderToken(tree, stream, async_token, Space.Space);
}
- try renderExpression(allocator, stream, tree, indent, start_col, call.lhs, Space.None);
+ try renderExpression(allocator, stream, tree, call.lhs, Space.None);
const lparen = tree.nextToken(call.lhs.lastToken());
if (call.params_len == 0) {
- try renderToken(tree, stream, lparen, indent, start_col, Space.None);
- return renderToken(tree, stream, call.rtoken, indent, start_col, space);
+ try renderToken(tree, stream, lparen, Space.None);
+ return renderToken(tree, stream, call.rtoken, space);
}
const src_has_trailing_comma = blk: {
@@ -1055,43 +1004,41 @@ fn renderExpression(
};
if (src_has_trailing_comma) {
- const new_indent = indent + indent_delta;
- try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline);
+ try renderToken(tree, stream, lparen, Space.Newline);
const params = call.params();
for (params) |param_node, i| {
- const param_node_new_indent = if (param_node.tag == .MultilineStringLiteral) blk: {
- break :blk indent;
- } else blk: {
- try stream.writeByteNTimes(' ', new_indent);
- break :blk new_indent;
- };
+ stream.pushIndent();
+ defer stream.popIndent();
if (i + 1 < params.len) {
- try renderExpression(allocator, stream, tree, param_node_new_indent, start_col, param_node, Space.None);
+ const next_node = params[i + 1];
+ try renderExpression(allocator, stream, tree, param_node, Space.None);
const comma = tree.nextToken(param_node.lastToken());
- try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline); // ,
- try renderExtraNewline(tree, stream, start_col, params[i + 1]);
+ try renderToken(tree, stream, comma, Space.Newline); // ,
+ try renderExtraNewline(tree, stream, next_node);
} else {
- try renderExpression(allocator, stream, tree, param_node_new_indent, start_col, param_node, Space.Comma);
- try stream.writeByteNTimes(' ', indent);
- return renderToken(tree, stream, call.rtoken, indent, start_col, space);
+ try renderExpression(allocator, stream, tree, param_node, Space.Comma);
}
}
+ return renderToken(tree, stream, call.rtoken, space);
}
- try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
+ try renderToken(tree, stream, lparen, Space.None); // (
const params = call.params();
for (params) |param_node, i| {
- try renderExpression(allocator, stream, tree, indent, start_col, param_node, Space.None);
+ if (param_node.*.tag == .MultilineStringLiteral) stream.pushIndentOneShot();
+
+ try renderExpression(allocator, stream, tree, param_node, Space.None);
if (i + 1 < params.len) {
+ const next_param = params[i + 1];
const comma = tree.nextToken(param_node.lastToken());
- try renderToken(tree, stream, comma, indent, start_col, Space.Space);
+ try renderToken(tree, stream, comma, Space.Space);
}
}
- return renderToken(tree, stream, call.rtoken, indent, start_col, space);
+ return renderToken(tree, stream, call.rtoken, space);
},
.ArrayAccess => {
@@ -1100,26 +1047,25 @@ fn renderExpression(
const lbracket = tree.nextToken(suffix_op.lhs.lastToken());
const rbracket = tree.nextToken(suffix_op.index_expr.lastToken());
- try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
- try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
+ try renderExpression(allocator, stream, tree, suffix_op.lhs, Space.None);
+ try renderToken(tree, stream, lbracket, Space.None); // [
const starts_with_comment = tree.token_ids[lbracket + 1] == .LineComment;
const ends_with_comment = tree.token_ids[rbracket - 1] == .LineComment;
- const new_indent = if (ends_with_comment) indent + indent_delta else indent;
- const new_space = if (ends_with_comment) Space.Newline else Space.None;
- try renderExpression(allocator, stream, tree, new_indent, start_col, suffix_op.index_expr, new_space);
- if (starts_with_comment) {
- try stream.writeByte('\n');
- }
- if (ends_with_comment or starts_with_comment) {
- try stream.writeByteNTimes(' ', indent);
+ {
+ const new_space = if (ends_with_comment) Space.Newline else Space.None;
+
+ stream.pushIndent();
+ defer stream.popIndent();
+ try renderExpression(allocator, stream, tree, suffix_op.index_expr, new_space);
}
- return renderToken(tree, stream, rbracket, indent, start_col, space); // ]
+ if (starts_with_comment) try stream.maybeInsertNewline();
+ return renderToken(tree, stream, rbracket, space); // ]
},
+
.Slice => {
const suffix_op = base.castTag(.Slice).?;
-
- try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
+ try renderExpression(allocator, stream, tree, suffix_op.lhs, Space.None);
const lbracket = tree.prevToken(suffix_op.start.firstToken());
const dotdot = tree.nextToken(suffix_op.start.lastToken());
@@ -1129,32 +1075,33 @@ fn renderExpression(
const after_start_space = if (after_start_space_bool) Space.Space else Space.None;
const after_op_space = if (suffix_op.end != null) after_start_space else Space.None;
- try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
- try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.start, after_start_space);
- try renderToken(tree, stream, dotdot, indent, start_col, after_op_space); // ..
+ try renderToken(tree, stream, lbracket, Space.None); // [
+ try renderExpression(allocator, stream, tree, suffix_op.start, after_start_space);
+ try renderToken(tree, stream, dotdot, after_op_space); // ..
if (suffix_op.end) |end| {
const after_end_space = if (suffix_op.sentinel != null) Space.Space else Space.None;
- try renderExpression(allocator, stream, tree, indent, start_col, end, after_end_space);
+ try renderExpression(allocator, stream, tree, end, after_end_space);
}
if (suffix_op.sentinel) |sentinel| {
const colon = tree.prevToken(sentinel.firstToken());
- try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
- try renderExpression(allocator, stream, tree, indent, start_col, sentinel, Space.None);
+ try renderToken(tree, stream, colon, Space.None); // :
+ try renderExpression(allocator, stream, tree, sentinel, Space.None);
}
- return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // ]
+ return renderToken(tree, stream, suffix_op.rtoken, space); // ]
},
+
.Deref => {
const suffix_op = base.castTag(.Deref).?;
- try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
- return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // .*
+ try renderExpression(allocator, stream, tree, suffix_op.lhs, Space.None);
+ return renderToken(tree, stream, suffix_op.rtoken, space); // .*
},
.UnwrapOptional => {
const suffix_op = base.castTag(.UnwrapOptional).?;
- try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
- try renderToken(tree, stream, tree.prevToken(suffix_op.rtoken), indent, start_col, Space.None); // .
- return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // ?
+ try renderExpression(allocator, stream, tree, suffix_op.lhs, Space.None);
+ try renderToken(tree, stream, tree.prevToken(suffix_op.rtoken), Space.None); // .
+ return renderToken(tree, stream, suffix_op.rtoken, space); // ?
},
.Break => {
@@ -1163,145 +1110,152 @@ fn renderExpression(
const maybe_label = flow_expr.getLabel();
if (maybe_label == null and maybe_rhs == null) {
- return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space); // break
+ return renderToken(tree, stream, flow_expr.ltoken, space); // break
}
- try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space); // break
+ try renderToken(tree, stream, flow_expr.ltoken, Space.Space); // break
if (maybe_label) |label| {
const colon = tree.nextToken(flow_expr.ltoken);
- try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
+ try renderToken(tree, stream, colon, Space.None); // :
if (maybe_rhs == null) {
- return renderToken(tree, stream, label, indent, start_col, space); // label
+ return renderToken(tree, stream, label, space); // label
}
- try renderToken(tree, stream, label, indent, start_col, Space.Space); // label
+ try renderToken(tree, stream, label, Space.Space); // label
}
- return renderExpression(allocator, stream, tree, indent, start_col, maybe_rhs.?, space);
+ return renderExpression(allocator, stream, tree, maybe_rhs.?, space);
},
.Continue => {
const flow_expr = base.castTag(.Continue).?;
if (flow_expr.getLabel()) |label| {
- try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space); // continue
+ try renderToken(tree, stream, flow_expr.ltoken, Space.Space); // continue
const colon = tree.nextToken(flow_expr.ltoken);
- try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
- return renderToken(tree, stream, label, indent, start_col, space); // label
+ try renderToken(tree, stream, colon, Space.None); // :
+ return renderToken(tree, stream, label, space); // label
} else {
- return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space); // continue
+ return renderToken(tree, stream, flow_expr.ltoken, space); // continue
}
},
.Return => {
const flow_expr = base.castTag(.Return).?;
if (flow_expr.getRHS()) |rhs| {
- try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space);
- return renderExpression(allocator, stream, tree, indent, start_col, rhs, space);
+ try renderToken(tree, stream, flow_expr.ltoken, Space.Space);
+ return renderExpression(allocator, stream, tree, rhs, space);
} else {
- return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space);
+ return renderToken(tree, stream, flow_expr.ltoken, space);
}
},
.Payload => {
const payload = @fieldParentPtr(ast.Node.Payload, "base", base);
- try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
- try renderExpression(allocator, stream, tree, indent, start_col, payload.error_symbol, Space.None);
- return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
+ try renderToken(tree, stream, payload.lpipe, Space.None);
+ try renderExpression(allocator, stream, tree, payload.error_symbol, Space.None);
+ return renderToken(tree, stream, payload.rpipe, space);
},
.PointerPayload => {
const payload = @fieldParentPtr(ast.Node.PointerPayload, "base", base);
- try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
+ try renderToken(tree, stream, payload.lpipe, Space.None);
if (payload.ptr_token) |ptr_token| {
- try renderToken(tree, stream, ptr_token, indent, start_col, Space.None);
+ try renderToken(tree, stream, ptr_token, Space.None);
}
- try renderExpression(allocator, stream, tree, indent, start_col, payload.value_symbol, Space.None);
- return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
+ try renderExpression(allocator, stream, tree, payload.value_symbol, Space.None);
+ return renderToken(tree, stream, payload.rpipe, space);
},
.PointerIndexPayload => {
const payload = @fieldParentPtr(ast.Node.PointerIndexPayload, "base", base);
- try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
+ try renderToken(tree, stream, payload.lpipe, Space.None);
if (payload.ptr_token) |ptr_token| {
- try renderToken(tree, stream, ptr_token, indent, start_col, Space.None);
+ try renderToken(tree, stream, ptr_token, Space.None);
}
- try renderExpression(allocator, stream, tree, indent, start_col, payload.value_symbol, Space.None);
+ try renderExpression(allocator, stream, tree, payload.value_symbol, Space.None);
if (payload.index_symbol) |index_symbol| {
const comma = tree.nextToken(payload.value_symbol.lastToken());
- try renderToken(tree, stream, comma, indent, start_col, Space.Space);
- try renderExpression(allocator, stream, tree, indent, start_col, index_symbol, Space.None);
+ try renderToken(tree, stream, comma, Space.Space);
+ try renderExpression(allocator, stream, tree, index_symbol, Space.None);
}
- return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
+ return renderToken(tree, stream, payload.rpipe, space);
},
.GroupedExpression => {
const grouped_expr = @fieldParentPtr(ast.Node.GroupedExpression, "base", base);
- try renderToken(tree, stream, grouped_expr.lparen, indent, start_col, Space.None);
- try renderExpression(allocator, stream, tree, indent, start_col, grouped_expr.expr, Space.None);
- return renderToken(tree, stream, grouped_expr.rparen, indent, start_col, space);
+ try renderToken(tree, stream, grouped_expr.lparen, Space.None);
+ {
+ stream.pushIndentOneShot();
+ try renderExpression(allocator, stream, tree, grouped_expr.expr, Space.None);
+ }
+ return renderToken(tree, stream, grouped_expr.rparen, space);
},
.FieldInitializer => {
const field_init = @fieldParentPtr(ast.Node.FieldInitializer, "base", base);
- try renderToken(tree, stream, field_init.period_token, indent, start_col, Space.None); // .
- try renderToken(tree, stream, field_init.name_token, indent, start_col, Space.Space); // name
- try renderToken(tree, stream, tree.nextToken(field_init.name_token), indent, start_col, Space.Space); // =
- return renderExpression(allocator, stream, tree, indent, start_col, field_init.expr, space);
+ try renderToken(tree, stream, field_init.period_token, Space.None); // .
+ try renderToken(tree, stream, field_init.name_token, Space.Space); // name
+ try renderToken(tree, stream, tree.nextToken(field_init.name_token), Space.Space); // =
+ return renderExpression(allocator, stream, tree, field_init.expr, space);
},
.ContainerDecl => {
const container_decl = @fieldParentPtr(ast.Node.ContainerDecl, "base", base);
if (container_decl.layout_token) |layout_token| {
- try renderToken(tree, stream, layout_token, indent, start_col, Space.Space);
+ try renderToken(tree, stream, layout_token, Space.Space);
}
switch (container_decl.init_arg_expr) {
.None => {
- try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.Space); // union
+ try renderToken(tree, stream, container_decl.kind_token, Space.Space); // union
},
.Enum => |enum_tag_type| {
- try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.None); // union
+ try renderToken(tree, stream, container_decl.kind_token, Space.None); // union
const lparen = tree.nextToken(container_decl.kind_token);
const enum_token = tree.nextToken(lparen);
- try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
- try renderToken(tree, stream, enum_token, indent, start_col, Space.None); // enum
+ try renderToken(tree, stream, lparen, Space.None); // (
+ try renderToken(tree, stream, enum_token, Space.None); // enum
if (enum_tag_type) |expr| {
- try renderToken(tree, stream, tree.nextToken(enum_token), indent, start_col, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
+ try renderToken(tree, stream, tree.nextToken(enum_token), Space.None); // (
+ try renderExpression(allocator, stream, tree, expr, Space.None);
const rparen = tree.nextToken(expr.lastToken());
- try renderToken(tree, stream, rparen, indent, start_col, Space.None); // )
- try renderToken(tree, stream, tree.nextToken(rparen), indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, rparen, Space.None); // )
+ try renderToken(tree, stream, tree.nextToken(rparen), Space.Space); // )
} else {
- try renderToken(tree, stream, tree.nextToken(enum_token), indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, tree.nextToken(enum_token), Space.Space); // )
}
},
.Type => |type_expr| {
- try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.None); // union
+ try renderToken(tree, stream, container_decl.kind_token, Space.None); // union
const lparen = tree.nextToken(container_decl.kind_token);
const rparen = tree.nextToken(type_expr.lastToken());
- try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, type_expr, Space.None);
- try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, lparen, Space.None); // (
+ try renderExpression(allocator, stream, tree, type_expr, Space.None);
+ try renderToken(tree, stream, rparen, Space.Space); // )
},
}
if (container_decl.fields_and_decls_len == 0) {
- try renderToken(tree, stream, container_decl.lbrace_token, indent + indent_delta, start_col, Space.None); // {
- return renderToken(tree, stream, container_decl.rbrace_token, indent, start_col, space); // }
+ {
+ stream.pushIndentNextLine();
+ defer stream.popIndent();
+ try renderToken(tree, stream, container_decl.lbrace_token, Space.None); // {
+ }
+ return renderToken(tree, stream, container_decl.rbrace_token, space); // }
}
const src_has_trailing_comma = blk: {
@@ -1332,43 +1286,39 @@ fn renderExpression(
if (src_has_trailing_comma or !src_has_only_fields) {
// One declaration per line
- const new_indent = indent + indent_delta;
- try renderToken(tree, stream, container_decl.lbrace_token, new_indent, start_col, .Newline); // {
+ stream.pushIndentNextLine();
+ defer stream.popIndent();
+ try renderToken(tree, stream, container_decl.lbrace_token, .Newline); // {
for (fields_and_decls) |decl, i| {
- try stream.writeByteNTimes(' ', new_indent);
- try renderContainerDecl(allocator, stream, tree, new_indent, start_col, decl, .Newline);
+ try renderContainerDecl(allocator, stream, tree, decl, .Newline);
if (i + 1 < fields_and_decls.len) {
- try renderExtraNewline(tree, stream, start_col, fields_and_decls[i + 1]);
+ try renderExtraNewline(tree, stream, fields_and_decls[i + 1]);
}
}
-
- try stream.writeByteNTimes(' ', indent);
} else if (src_has_newline) {
// All the declarations on the same line, but place the items on
// their own line
- try renderToken(tree, stream, container_decl.lbrace_token, indent, start_col, .Newline); // {
+ try renderToken(tree, stream, container_decl.lbrace_token, .Newline); // {
- const new_indent = indent + indent_delta;
- try stream.writeByteNTimes(' ', new_indent);
+ stream.pushIndent();
+ defer stream.popIndent();
for (fields_and_decls) |decl, i| {
const space_after_decl: Space = if (i + 1 >= fields_and_decls.len) .Newline else .Space;
- try renderContainerDecl(allocator, stream, tree, new_indent, start_col, decl, space_after_decl);
+ try renderContainerDecl(allocator, stream, tree, decl, space_after_decl);
}
-
- try stream.writeByteNTimes(' ', indent);
} else {
// All the declarations on the same line
- try renderToken(tree, stream, container_decl.lbrace_token, indent, start_col, .Space); // {
+ try renderToken(tree, stream, container_decl.lbrace_token, .Space); // {
for (fields_and_decls) |decl| {
- try renderContainerDecl(allocator, stream, tree, indent, start_col, decl, .Space);
+ try renderContainerDecl(allocator, stream, tree, decl, .Space);
}
}
- return renderToken(tree, stream, container_decl.rbrace_token, indent, start_col, space); // }
+ return renderToken(tree, stream, container_decl.rbrace_token, space); // }
},
.ErrorSetDecl => {
@@ -1377,9 +1327,9 @@ fn renderExpression(
const lbrace = tree.nextToken(err_set_decl.error_token);
if (err_set_decl.decls_len == 0) {
- try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None);
- try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
- return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space);
+ try renderToken(tree, stream, err_set_decl.error_token, Space.None);
+ try renderToken(tree, stream, lbrace, Space.None);
+ return renderToken(tree, stream, err_set_decl.rbrace_token, space);
}
if (err_set_decl.decls_len == 1) blk: {
@@ -1393,13 +1343,13 @@ fn renderExpression(
break :blk;
}
- try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None); // error
- try renderToken(tree, stream, lbrace, indent, start_col, Space.None); // {
- try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
- return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space); // }
+ try renderToken(tree, stream, err_set_decl.error_token, Space.None); // error
+ try renderToken(tree, stream, lbrace, Space.None); // {
+ try renderExpression(allocator, stream, tree, node, Space.None);
+ return renderToken(tree, stream, err_set_decl.rbrace_token, space); // }
}
- try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None); // error
+ try renderToken(tree, stream, err_set_decl.error_token, Space.None); // error
const src_has_trailing_comma = blk: {
const maybe_comma = tree.prevToken(err_set_decl.rbrace_token);
@@ -1407,78 +1357,72 @@ fn renderExpression(
};
if (src_has_trailing_comma) {
- try renderToken(tree, stream, lbrace, indent, start_col, Space.Newline); // {
- const new_indent = indent + indent_delta;
-
- const decls = err_set_decl.decls();
- for (decls) |node, i| {
- try stream.writeByteNTimes(' ', new_indent);
-
- if (i + 1 < decls.len) {
- try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.None);
- try renderToken(tree, stream, tree.nextToken(node.lastToken()), new_indent, start_col, Space.Newline); // ,
-
- try renderExtraNewline(tree, stream, start_col, decls[i + 1]);
- } else {
- try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.Comma);
+ {
+ stream.pushIndent();
+ defer stream.popIndent();
+
+ try renderToken(tree, stream, lbrace, Space.Newline); // {
+ const decls = err_set_decl.decls();
+ for (decls) |node, i| {
+ if (i + 1 < decls.len) {
+ try renderExpression(allocator, stream, tree, node, Space.None);
+ try renderToken(tree, stream, tree.nextToken(node.lastToken()), Space.Newline); // ,
+
+ try renderExtraNewline(tree, stream, decls[i + 1]);
+ } else {
+ try renderExpression(allocator, stream, tree, node, Space.Comma);
+ }
}
}
- try stream.writeByteNTimes(' ', indent);
- return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space); // }
+ return renderToken(tree, stream, err_set_decl.rbrace_token, space); // }
} else {
- try renderToken(tree, stream, lbrace, indent, start_col, Space.Space); // {
+ try renderToken(tree, stream, lbrace, Space.Space); // {
const decls = err_set_decl.decls();
for (decls) |node, i| {
if (i + 1 < decls.len) {
- try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
+ try renderExpression(allocator, stream, tree, node, Space.None);
const comma_token = tree.nextToken(node.lastToken());
assert(tree.token_ids[comma_token] == .Comma);
- try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
- try renderExtraNewline(tree, stream, start_col, decls[i + 1]);
+ try renderToken(tree, stream, comma_token, Space.Space); // ,
+ try renderExtraNewline(tree, stream, decls[i + 1]);
} else {
- try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Space);
+ try renderExpression(allocator, stream, tree, node, Space.Space);
}
}
- return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space); // }
+ return renderToken(tree, stream, err_set_decl.rbrace_token, space); // }
}
},
.ErrorTag => {
const tag = @fieldParentPtr(ast.Node.ErrorTag, "base", base);
- try renderDocComments(tree, stream, tag, tag.doc_comments, indent, start_col);
- return renderToken(tree, stream, tag.name_token, indent, start_col, space); // name
+ try renderDocComments(tree, stream, tag, tag.doc_comments);
+ return renderToken(tree, stream, tag.name_token, space); // name
},
.MultilineStringLiteral => {
- // TODO: Don't indent in this function, but let the caller indent.
- // If this has been implemented, a lot of hacky solutions in i.e. ArrayInit and FunctionCall can be removed
const multiline_str_literal = @fieldParentPtr(ast.Node.MultilineStringLiteral, "base", base);
- var skip_first_indent = true;
- if (tree.token_ids[multiline_str_literal.firstToken() - 1] != .LineComment) {
- try stream.print("\n", .{});
- skip_first_indent = false;
- }
-
- for (multiline_str_literal.lines()) |t| {
- if (!skip_first_indent) {
- try stream.writeByteNTimes(' ', indent + indent_delta);
+ {
+ const locked_indents = stream.lockOneShotIndent();
+ defer {
+ var i: u8 = 0;
+ while (i < locked_indents) : (i += 1) stream.popIndent();
}
- try renderToken(tree, stream, t, indent, start_col, Space.None);
- skip_first_indent = false;
+ try stream.maybeInsertNewline();
+
+ for (multiline_str_literal.lines()) |t| try renderToken(tree, stream, t, Space.None);
}
- try stream.writeByteNTimes(' ', indent);
},
.BuiltinCall => {
const builtin_call = @fieldParentPtr(ast.Node.BuiltinCall, "base", base);
- try renderToken(tree, stream, builtin_call.builtin_token, indent, start_col, Space.None); // @name
+ try renderToken(tree, stream, builtin_call.builtin_token, Space.None); // @name
const src_params_trailing_comma = blk: {
if (builtin_call.params_len < 2) break :blk false;
@@ -1490,31 +1434,30 @@ fn renderExpression(
const lparen = tree.nextToken(builtin_call.builtin_token);
if (!src_params_trailing_comma) {
- try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
+ try renderToken(tree, stream, lparen, Space.None); // (
// render all on one line, no trailing comma
const params = builtin_call.params();
for (params) |param_node, i| {
- try renderExpression(allocator, stream, tree, indent, start_col, param_node, Space.None);
+ try renderExpression(allocator, stream, tree, param_node, Space.None);
if (i + 1 < params.len) {
const comma_token = tree.nextToken(param_node.lastToken());
- try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
+ try renderToken(tree, stream, comma_token, Space.Space); // ,
}
}
} else {
// one param per line
- const new_indent = indent + indent_delta;
- try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline); // (
+ stream.pushIndent();
+ defer stream.popIndent();
+ try renderToken(tree, stream, lparen, Space.Newline); // (
for (builtin_call.params()) |param_node| {
- try stream.writeByteNTimes(' ', new_indent);
- try renderExpression(allocator, stream, tree, indent, start_col, param_node, Space.Comma);
+ try renderExpression(allocator, stream, tree, param_node, Space.Comma);
}
- try stream.writeByteNTimes(' ', indent);
}
- return renderToken(tree, stream, builtin_call.rparen_token, indent, start_col, space); // )
+ return renderToken(tree, stream, builtin_call.rparen_token, space); // )
},
.FnProto => {
@@ -1524,24 +1467,24 @@ fn renderExpression(
const visib_token = tree.token_ids[visib_token_index];
assert(visib_token == .Keyword_pub or visib_token == .Keyword_export);
- try renderToken(tree, stream, visib_token_index, indent, start_col, Space.Space); // pub
+ try renderToken(tree, stream, visib_token_index, Space.Space); // pub
}
if (fn_proto.getTrailer("extern_export_inline_token")) |extern_export_inline_token| {
if (fn_proto.getTrailer("is_extern_prototype") == null)
- try renderToken(tree, stream, extern_export_inline_token, indent, start_col, Space.Space); // extern/export/inline
+ try renderToken(tree, stream, extern_export_inline_token, Space.Space); // extern/export/inline
}
if (fn_proto.getTrailer("lib_name")) |lib_name| {
- try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space);
+ try renderExpression(allocator, stream, tree, lib_name, Space.Space);
}
const lparen = if (fn_proto.getTrailer("name_token")) |name_token| blk: {
- try renderToken(tree, stream, fn_proto.fn_token, indent, start_col, Space.Space); // fn
- try renderToken(tree, stream, name_token, indent, start_col, Space.None); // name
+ try renderToken(tree, stream, fn_proto.fn_token, Space.Space); // fn
+ try renderToken(tree, stream, name_token, Space.None); // name
break :blk tree.nextToken(name_token);
} else blk: {
- try renderToken(tree, stream, fn_proto.fn_token, indent, start_col, Space.Space); // fn
+ try renderToken(tree, stream, fn_proto.fn_token, Space.Space); // fn
break :blk tree.nextToken(fn_proto.fn_token);
};
assert(tree.token_ids[lparen] == .LParen);
@@ -1568,47 +1511,45 @@ fn renderExpression(
};
if (!src_params_trailing_comma) {
- try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
+ try renderToken(tree, stream, lparen, Space.None); // (
// render all on one line, no trailing comma
for (fn_proto.params()) |param_decl, i| {
- try renderParamDecl(allocator, stream, tree, indent, start_col, param_decl, Space.None);
+ try renderParamDecl(allocator, stream, tree, param_decl, Space.None);
if (i + 1 < fn_proto.params_len or fn_proto.getTrailer("var_args_token") != null) {
const comma = tree.nextToken(param_decl.lastToken());
- try renderToken(tree, stream, comma, indent, start_col, Space.Space); // ,
+ try renderToken(tree, stream, comma, Space.Space); // ,
}
}
if (fn_proto.getTrailer("var_args_token")) |var_args_token| {
- try renderToken(tree, stream, var_args_token, indent, start_col, Space.None);
+ try renderToken(tree, stream, var_args_token, Space.None);
}
} else {
// one param per line
- const new_indent = indent + indent_delta;
- try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline); // (
+ stream.pushIndent();
+ defer stream.popIndent();
+ try renderToken(tree, stream, lparen, Space.Newline); // (
for (fn_proto.params()) |param_decl| {
- try stream.writeByteNTimes(' ', new_indent);
- try renderParamDecl(allocator, stream, tree, new_indent, start_col, param_decl, Space.Comma);
+ try renderParamDecl(allocator, stream, tree, param_decl, Space.Comma);
}
if (fn_proto.getTrailer("var_args_token")) |var_args_token| {
- try stream.writeByteNTimes(' ', new_indent);
- try renderToken(tree, stream, var_args_token, new_indent, start_col, Space.Comma);
+ try renderToken(tree, stream, var_args_token, Space.Comma);
}
- try stream.writeByteNTimes(' ', indent);
}
- try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, rparen, Space.Space); // )
if (fn_proto.getTrailer("align_expr")) |align_expr| {
const align_rparen = tree.nextToken(align_expr.lastToken());
const align_lparen = tree.prevToken(align_expr.firstToken());
const align_kw = tree.prevToken(align_lparen);
- try renderToken(tree, stream, align_kw, indent, start_col, Space.None); // align
- try renderToken(tree, stream, align_lparen, indent, start_col, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, align_expr, Space.None);
- try renderToken(tree, stream, align_rparen, indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, align_kw, Space.None); // align
+ try renderToken(tree, stream, align_lparen, Space.None); // (
+ try renderExpression(allocator, stream, tree, align_expr, Space.None);
+ try renderToken(tree, stream, align_rparen, Space.Space); // )
}
if (fn_proto.getTrailer("section_expr")) |section_expr| {
@@ -1616,10 +1557,10 @@ fn renderExpression(
const section_lparen = tree.prevToken(section_expr.firstToken());
const section_kw = tree.prevToken(section_lparen);
- try renderToken(tree, stream, section_kw, indent, start_col, Space.None); // section
- try renderToken(tree, stream, section_lparen, indent, start_col, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, section_expr, Space.None);
- try renderToken(tree, stream, section_rparen, indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, section_kw, Space.None); // section
+ try renderToken(tree, stream, section_lparen, Space.None); // (
+ try renderExpression(allocator, stream, tree, section_expr, Space.None);
+ try renderToken(tree, stream, section_rparen, Space.Space); // )
}
if (fn_proto.getTrailer("callconv_expr")) |callconv_expr| {
@@ -1627,23 +1568,23 @@ fn renderExpression(
const callconv_lparen = tree.prevToken(callconv_expr.firstToken());
const callconv_kw = tree.prevToken(callconv_lparen);
- try renderToken(tree, stream, callconv_kw, indent, start_col, Space.None); // callconv
- try renderToken(tree, stream, callconv_lparen, indent, start_col, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, callconv_expr, Space.None);
- try renderToken(tree, stream, callconv_rparen, indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, callconv_kw, Space.None); // callconv
+ try renderToken(tree, stream, callconv_lparen, Space.None); // (
+ try renderExpression(allocator, stream, tree, callconv_expr, Space.None);
+ try renderToken(tree, stream, callconv_rparen, Space.Space); // )
} else if (fn_proto.getTrailer("is_extern_prototype") != null) {
- try stream.writeAll("callconv(.C) ");
+ try stream.writer().writeAll("callconv(.C) ");
} else if (fn_proto.getTrailer("is_async") != null) {
- try stream.writeAll("callconv(.Async) ");
+ try stream.writer().writeAll("callconv(.Async) ");
}
switch (fn_proto.return_type) {
.Explicit => |node| {
- return renderExpression(allocator, stream, tree, indent, start_col, node, space);
+ return renderExpression(allocator, stream, tree, node, space);
},
.InferErrorSet => |node| {
- try renderToken(tree, stream, tree.prevToken(node.firstToken()), indent, start_col, Space.None); // !
- return renderExpression(allocator, stream, tree, indent, start_col, node, space);
+ try renderToken(tree, stream, tree.prevToken(node.firstToken()), Space.None); // !
+ return renderExpression(allocator, stream, tree, node, space);
},
.Invalid => unreachable,
}
@@ -1653,11 +1594,11 @@ fn renderExpression(
const anyframe_type = @fieldParentPtr(ast.Node.AnyFrameType, "base", base);
if (anyframe_type.result) |result| {
- try renderToken(tree, stream, anyframe_type.anyframe_token, indent, start_col, Space.None); // anyframe
- try renderToken(tree, stream, result.arrow_token, indent, start_col, Space.None); // ->
- return renderExpression(allocator, stream, tree, indent, start_col, result.return_type, space);
+ try renderToken(tree, stream, anyframe_type.anyframe_token, Space.None); // anyframe
+ try renderToken(tree, stream, result.arrow_token, Space.None); // ->
+ return renderExpression(allocator, stream, tree, result.return_type, space);
} else {
- return renderToken(tree, stream, anyframe_type.anyframe_token, indent, start_col, space); // anyframe
+ return renderToken(tree, stream, anyframe_type.anyframe_token, space); // anyframe
}
},
@@ -1666,38 +1607,38 @@ fn renderExpression(
.Switch => {
const switch_node = @fieldParentPtr(ast.Node.Switch, "base", base);
- try renderToken(tree, stream, switch_node.switch_token, indent, start_col, Space.Space); // switch
- try renderToken(tree, stream, tree.nextToken(switch_node.switch_token), indent, start_col, Space.None); // (
+ try renderToken(tree, stream, switch_node.switch_token, Space.Space); // switch
+ try renderToken(tree, stream, tree.nextToken(switch_node.switch_token), Space.None); // (
const rparen = tree.nextToken(switch_node.expr.lastToken());
const lbrace = tree.nextToken(rparen);
if (switch_node.cases_len == 0) {
- try renderExpression(allocator, stream, tree, indent, start_col, switch_node.expr, Space.None);
- try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
- try renderToken(tree, stream, lbrace, indent, start_col, Space.None); // {
- return renderToken(tree, stream, switch_node.rbrace, indent, start_col, space); // }
+ try renderExpression(allocator, stream, tree, switch_node.expr, Space.None);
+ try renderToken(tree, stream, rparen, Space.Space); // )
+ try renderToken(tree, stream, lbrace, Space.None); // {
+ return renderToken(tree, stream, switch_node.rbrace, space); // }
}
- try renderExpression(allocator, stream, tree, indent, start_col, switch_node.expr, Space.None);
-
- const new_indent = indent + indent_delta;
+ try renderExpression(allocator, stream, tree, switch_node.expr, Space.None);
+ try renderToken(tree, stream, rparen, Space.Space); // )
- try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
- try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline); // {
+ {
+ stream.pushIndentNextLine();
+ defer stream.popIndent();
+ try renderToken(tree, stream, lbrace, Space.Newline); // {
- const cases = switch_node.cases();
- for (cases) |node, i| {
- try stream.writeByteNTimes(' ', new_indent);
- try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.Comma);
+ const cases = switch_node.cases();
+ for (cases) |node, i| {
+ try renderExpression(allocator, stream, tree, node, Space.Comma);
- if (i + 1 < cases.len) {
- try renderExtraNewline(tree, stream, start_col, cases[i + 1]);
+ if (i + 1 < cases.len) {
+ try renderExtraNewline(tree, stream, cases[i + 1]);
+ }
}
}
- try stream.writeByteNTimes(' ', indent);
- return renderToken(tree, stream, switch_node.rbrace, indent, start_col, space); // }
+ return renderToken(tree, stream, switch_node.rbrace, space); // }
},
.SwitchCase => {
@@ -1714,43 +1655,41 @@ fn renderExpression(
const items = switch_case.items();
for (items) |node, i| {
if (i + 1 < items.len) {
- try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
+ try renderExpression(allocator, stream, tree, node, Space.None);
const comma_token = tree.nextToken(node.lastToken());
- try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
- try renderExtraNewline(tree, stream, start_col, items[i + 1]);
+ try renderToken(tree, stream, comma_token, Space.Space); // ,
+ try renderExtraNewline(tree, stream, items[i + 1]);
} else {
- try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Space);
+ try renderExpression(allocator, stream, tree, node, Space.Space);
}
}
} else {
const items = switch_case.items();
for (items) |node, i| {
if (i + 1 < items.len) {
- try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
+ try renderExpression(allocator, stream, tree, node, Space.None);
const comma_token = tree.nextToken(node.lastToken());
- try renderToken(tree, stream, comma_token, indent, start_col, Space.Newline); // ,
- try renderExtraNewline(tree, stream, start_col, items[i + 1]);
- try stream.writeByteNTimes(' ', indent);
+ try renderToken(tree, stream, comma_token, Space.Newline); // ,
+ try renderExtraNewline(tree, stream, items[i + 1]);
} else {
- try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Comma);
- try stream.writeByteNTimes(' ', indent);
+ try renderExpression(allocator, stream, tree, node, Space.Comma);
}
}
}
- try renderToken(tree, stream, switch_case.arrow_token, indent, start_col, Space.Space); // =>
+ try renderToken(tree, stream, switch_case.arrow_token, Space.Space); // =>
if (switch_case.payload) |payload| {
- try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
+ try renderExpression(allocator, stream, tree, payload, Space.Space);
}
- return renderExpression(allocator, stream, tree, indent, start_col, switch_case.expr, space);
+ return renderExpression(allocator, stream, tree, switch_case.expr, space);
},
.SwitchElse => {
const switch_else = @fieldParentPtr(ast.Node.SwitchElse, "base", base);
- return renderToken(tree, stream, switch_else.token, indent, start_col, space);
+ return renderToken(tree, stream, switch_else.token, space);
},
.Else => {
const else_node = @fieldParentPtr(ast.Node.Else, "base", base);
@@ -1759,37 +1698,37 @@ fn renderExpression(
const same_line = body_is_block or tree.tokensOnSameLine(else_node.else_token, else_node.body.lastToken());
const after_else_space = if (same_line or else_node.payload != null) Space.Space else Space.Newline;
- try renderToken(tree, stream, else_node.else_token, indent, start_col, after_else_space);
+ try renderToken(tree, stream, else_node.else_token, after_else_space);
if (else_node.payload) |payload| {
const payload_space = if (same_line) Space.Space else Space.Newline;
- try renderExpression(allocator, stream, tree, indent, start_col, payload, payload_space);
+ try renderExpression(allocator, stream, tree, payload, payload_space);
}
if (same_line) {
- return renderExpression(allocator, stream, tree, indent, start_col, else_node.body, space);
+ return renderExpression(allocator, stream, tree, else_node.body, space);
+ } else {
+ stream.pushIndent();
+ defer stream.popIndent();
+ return renderExpression(allocator, stream, tree, else_node.body, space);
}
-
- try stream.writeByteNTimes(' ', indent + indent_delta);
- start_col.* = indent + indent_delta;
- return renderExpression(allocator, stream, tree, indent, start_col, else_node.body, space);
},
.While => {
const while_node = @fieldParentPtr(ast.Node.While, "base", base);
if (while_node.label) |label| {
- try renderToken(tree, stream, label, indent, start_col, Space.None); // label
- try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space); // :
+ try renderToken(tree, stream, label, Space.None); // label
+ try renderToken(tree, stream, tree.nextToken(label), Space.Space); // :
}
if (while_node.inline_token) |inline_token| {
- try renderToken(tree, stream, inline_token, indent, start_col, Space.Space); // inline
+ try renderToken(tree, stream, inline_token, Space.Space); // inline
}
- try renderToken(tree, stream, while_node.while_token, indent, start_col, Space.Space); // while
- try renderToken(tree, stream, tree.nextToken(while_node.while_token), indent, start_col, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, while_node.condition, Space.None);
+ try renderToken(tree, stream, while_node.while_token, Space.Space); // while
+ try renderToken(tree, stream, tree.nextToken(while_node.while_token), Space.None); // (
+ try renderExpression(allocator, stream, tree, while_node.condition, Space.None);
const cond_rparen = tree.nextToken(while_node.condition.lastToken());
@@ -1811,12 +1750,12 @@ fn renderExpression(
{
const rparen_space = if (while_node.payload != null or while_node.continue_expr != null) Space.Space else block_start_space;
- try renderToken(tree, stream, cond_rparen, indent, start_col, rparen_space); // )
+ try renderToken(tree, stream, cond_rparen, rparen_space); // )
}
if (while_node.payload) |payload| {
- const payload_space = if (while_node.continue_expr != null) Space.Space else block_start_space;
- try renderExpression(allocator, stream, tree, indent, start_col, payload, payload_space);
+ const payload_space = Space.Space; //if (while_node.continue_expr != null) Space.Space else block_start_space;
+ try renderExpression(allocator, stream, tree, payload, payload_space);
}
if (while_node.continue_expr) |continue_expr| {
@@ -1824,29 +1763,22 @@ fn renderExpression(
const lparen = tree.prevToken(continue_expr.firstToken());
const colon = tree.prevToken(lparen);
- try renderToken(tree, stream, colon, indent, start_col, Space.Space); // :
- try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
+ try renderToken(tree, stream, colon, Space.Space); // :
+ try renderToken(tree, stream, lparen, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, continue_expr, Space.None);
+ try renderExpression(allocator, stream, tree, continue_expr, Space.None);
- try renderToken(tree, stream, rparen, indent, start_col, block_start_space); // )
+ try renderToken(tree, stream, rparen, block_start_space); // )
}
- var new_indent = indent;
- if (block_start_space == Space.Newline) {
- new_indent += indent_delta;
- try stream.writeByteNTimes(' ', new_indent);
- start_col.* = new_indent;
+ {
+ if (!body_is_block) stream.pushIndent();
+ defer if (!body_is_block) stream.popIndent();
+ try renderExpression(allocator, stream, tree, while_node.body, after_body_space);
}
- try renderExpression(allocator, stream, tree, indent, start_col, while_node.body, after_body_space);
-
if (while_node.@"else") |@"else"| {
- if (after_body_space == Space.Newline) {
- try stream.writeByteNTimes(' ', indent);
- start_col.* = indent;
- }
- return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space);
+ return renderExpression(allocator, stream, tree, &@"else".base, space);
}
},
@@ -1854,17 +1786,17 @@ fn renderExpression(
const for_node = @fieldParentPtr(ast.Node.For, "base", base);
if (for_node.label) |label| {
- try renderToken(tree, stream, label, indent, start_col, Space.None); // label
- try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space); // :
+ try renderToken(tree, stream, label, Space.None); // label
+ try renderToken(tree, stream, tree.nextToken(label), Space.Space); // :
}
if (for_node.inline_token) |inline_token| {
- try renderToken(tree, stream, inline_token, indent, start_col, Space.Space); // inline
+ try renderToken(tree, stream, inline_token, Space.Space); // inline
}
- try renderToken(tree, stream, for_node.for_token, indent, start_col, Space.Space); // for
- try renderToken(tree, stream, tree.nextToken(for_node.for_token), indent, start_col, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, for_node.array_expr, Space.None);
+ try renderToken(tree, stream, for_node.for_token, Space.Space); // for
+ try renderToken(tree, stream, tree.nextToken(for_node.for_token), Space.None); // (
+ try renderExpression(allocator, stream, tree, for_node.array_expr, Space.None);
const rparen = tree.nextToken(for_node.array_expr.lastToken());
@@ -1872,10 +1804,10 @@ fn renderExpression(
const src_one_line_to_body = !body_is_block and tree.tokensOnSameLine(rparen, for_node.body.firstToken());
const body_on_same_line = body_is_block or src_one_line_to_body;
- try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
+ try renderToken(tree, stream, rparen, Space.Space); // )
const space_after_payload = if (body_on_same_line) Space.Space else Space.Newline;
- try renderExpression(allocator, stream, tree, indent, start_col, for_node.payload, space_after_payload); // |x|
+ try renderExpression(allocator, stream, tree, for_node.payload, space_after_payload); // |x|
const space_after_body = blk: {
if (for_node.@"else") |@"else"| {
@@ -1890,13 +1822,14 @@ fn renderExpression(
}
};
- const body_indent = if (body_on_same_line) indent else indent + indent_delta;
- if (!body_on_same_line) try stream.writeByteNTimes(' ', body_indent);
- try renderExpression(allocator, stream, tree, body_indent, start_col, for_node.body, space_after_body); // { body }
+ {
+ if (!body_on_same_line) stream.pushIndent();
+ defer if (!body_on_same_line) stream.popIndent();
+ try renderExpression(allocator, stream, tree, for_node.body, space_after_body); // { body }
+ }
if (for_node.@"else") |@"else"| {
- if (space_after_body == Space.Newline) try stream.writeByteNTimes(' ', indent);
- return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space); // else
+ return renderExpression(allocator, stream, tree, &@"else".base, space); // else
}
},
@@ -1906,29 +1839,29 @@ fn renderExpression(
const lparen = tree.nextToken(if_node.if_token);
const rparen = tree.nextToken(if_node.condition.lastToken());
- try renderToken(tree, stream, if_node.if_token, indent, start_col, Space.Space); // if
- try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
+ try renderToken(tree, stream, if_node.if_token, Space.Space); // if
+ try renderToken(tree, stream, lparen, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, if_node.condition, Space.None); // condition
+ try renderExpression(allocator, stream, tree, if_node.condition, Space.None); // condition
const body_is_if_block = if_node.body.tag == .If;
const body_is_block = nodeIsBlock(if_node.body);
if (body_is_if_block) {
- try renderExtraNewline(tree, stream, start_col, if_node.body);
+ try renderExtraNewline(tree, stream, if_node.body);
} else if (body_is_block) {
const after_rparen_space = if (if_node.payload == null) Space.BlockStart else Space.Space;
- try renderToken(tree, stream, rparen, indent, start_col, after_rparen_space); // )
+ try renderToken(tree, stream, rparen, after_rparen_space); // )
if (if_node.payload) |payload| {
- try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.BlockStart); // |x|
+ try renderExpression(allocator, stream, tree, payload, Space.BlockStart); // |x|
}
if (if_node.@"else") |@"else"| {
- try renderExpression(allocator, stream, tree, indent, start_col, if_node.body, Space.SpaceOrOutdent);
- return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space);
+ try renderExpression(allocator, stream, tree, if_node.body, Space.SpaceOrOutdent);
+ return renderExpression(allocator, stream, tree, &@"else".base, space);
} else {
- return renderExpression(allocator, stream, tree, indent, start_col, if_node.body, space);
+ return renderExpression(allocator, stream, tree, if_node.body, space);
}
}
@@ -1936,186 +1869,181 @@ fn renderExpression(
if (src_has_newline) {
const after_rparen_space = if (if_node.payload == null) Space.Newline else Space.Space;
- try renderToken(tree, stream, rparen, indent, start_col, after_rparen_space); // )
+ try renderToken(tree, stream, rparen, after_rparen_space); // )
if (if_node.payload) |payload| {
- try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Newline);
+ try renderExpression(allocator, stream, tree, payload, Space.Newline);
}
- const new_indent = indent + indent_delta;
- try stream.writeByteNTimes(' ', new_indent);
-
if (if_node.@"else") |@"else"| {
const else_is_block = nodeIsBlock(@"else".body);
- try renderExpression(allocator, stream, tree, new_indent, start_col, if_node.body, Space.Newline);
- try stream.writeByteNTimes(' ', indent);
+
+ {
+ stream.pushIndent();
+ defer stream.popIndent();
+ try renderExpression(allocator, stream, tree, if_node.body, Space.Newline);
+ }
if (else_is_block) {
- try renderToken(tree, stream, @"else".else_token, indent, start_col, Space.Space); // else
+ try renderToken(tree, stream, @"else".else_token, Space.Space); // else
if (@"else".payload) |payload| {
- try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
+ try renderExpression(allocator, stream, tree, payload, Space.Space);
}
- return renderExpression(allocator, stream, tree, indent, start_col, @"else".body, space);
+ return renderExpression(allocator, stream, tree, @"else".body, space);
} else {
const after_else_space = if (@"else".payload == null) Space.Newline else Space.Space;
- try renderToken(tree, stream, @"else".else_token, indent, start_col, after_else_space); // else
+ try renderToken(tree, stream, @"else".else_token, after_else_space); // else
if (@"else".payload) |payload| {
- try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Newline);
+ try renderExpression(allocator, stream, tree, payload, Space.Newline);
}
- try stream.writeByteNTimes(' ', new_indent);
- return renderExpression(allocator, stream, tree, new_indent, start_col, @"else".body, space);
+ stream.pushIndent();
+ defer stream.popIndent();
+ return renderExpression(allocator, stream, tree, @"else".body, space);
}
} else {
- return renderExpression(allocator, stream, tree, new_indent, start_col, if_node.body, space);
+ stream.pushIndent();
+ defer stream.popIndent();
+ return renderExpression(allocator, stream, tree, if_node.body, space);
}
}
- try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
+ // Single line if statement
+
+ try renderToken(tree, stream, rparen, Space.Space); // )
if (if_node.payload) |payload| {
- try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
+ try renderExpression(allocator, stream, tree, payload, Space.Space);
}
if (if_node.@"else") |@"else"| {
- try renderExpression(allocator, stream, tree, indent, start_col, if_node.body, Space.Space);
- try renderToken(tree, stream, @"else".else_token, indent, start_col, Space.Space);
+ try renderExpression(allocator, stream, tree, if_node.body, Space.Space);
+ try renderToken(tree, stream, @"else".else_token, Space.Space);
if (@"else".payload) |payload| {
- try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
+ try renderExpression(allocator, stream, tree, payload, Space.Space);
}
- return renderExpression(allocator, stream, tree, indent, start_col, @"else".body, space);
+ return renderExpression(allocator, stream, tree, @"else".body, space);
} else {
- return renderExpression(allocator, stream, tree, indent, start_col, if_node.body, space);
+ return renderExpression(allocator, stream, tree, if_node.body, space);
}
},
.Asm => {
const asm_node = @fieldParentPtr(ast.Node.Asm, "base", base);
- try renderToken(tree, stream, asm_node.asm_token, indent, start_col, Space.Space); // asm
+ try renderToken(tree, stream, asm_node.asm_token, Space.Space); // asm
if (asm_node.volatile_token) |volatile_token| {
- try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space); // volatile
- try renderToken(tree, stream, tree.nextToken(volatile_token), indent, start_col, Space.None); // (
+ try renderToken(tree, stream, volatile_token, Space.Space); // volatile
+ try renderToken(tree, stream, tree.nextToken(volatile_token), Space.None); // (
} else {
- try renderToken(tree, stream, tree.nextToken(asm_node.asm_token), indent, start_col, Space.None); // (
+ try renderToken(tree, stream, tree.nextToken(asm_node.asm_token), Space.None); // (
}
- if (asm_node.outputs.len == 0 and asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
- try renderExpression(allocator, stream, tree, indent, start_col, asm_node.template, Space.None);
- return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
- }
+ asmblk: {
+ stream.pushIndent();
+ defer stream.popIndent();
- try renderExpression(allocator, stream, tree, indent, start_col, asm_node.template, Space.Newline);
+ if (asm_node.outputs.len == 0 and asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
+ try renderExpression(allocator, stream, tree, asm_node.template, Space.None);
+ break :asmblk;
+ }
- const indent_once = indent + indent_delta;
+ try renderExpression(allocator, stream, tree, asm_node.template, Space.Newline);
- if (asm_node.template.tag == .MultilineStringLiteral) {
- // After rendering a multiline string literal the cursor is
- // already offset by indent
- try stream.writeByteNTimes(' ', indent_delta);
- } else {
- try stream.writeByteNTimes(' ', indent_once);
- }
+ const colon1 = tree.nextToken(asm_node.template.lastToken());
- const colon1 = tree.nextToken(asm_node.template.lastToken());
- const indent_extra = indent_once + 2;
+ const colon2 = if (asm_node.outputs.len == 0) blk: {
+ try renderToken(tree, stream, colon1, Space.Newline); // :
- const colon2 = if (asm_node.outputs.len == 0) blk: {
- try renderToken(tree, stream, colon1, indent, start_col, Space.Newline); // :
- try stream.writeByteNTimes(' ', indent_once);
+ break :blk tree.nextToken(colon1);
+ } else blk: {
+ try renderToken(tree, stream, colon1, Space.Space); // :
- break :blk tree.nextToken(colon1);
- } else blk: {
- try renderToken(tree, stream, colon1, indent, start_col, Space.Space); // :
-
- for (asm_node.outputs) |*asm_output, i| {
- if (i + 1 < asm_node.outputs.len) {
- const next_asm_output = asm_node.outputs[i + 1];
- try renderAsmOutput(allocator, stream, tree, indent_extra, start_col, asm_output, Space.None);
-
- const comma = tree.prevToken(next_asm_output.firstToken());
- try renderToken(tree, stream, comma, indent_extra, start_col, Space.Newline); // ,
- try renderExtraNewlineToken(tree, stream, start_col, next_asm_output.firstToken());
-
- try stream.writeByteNTimes(' ', indent_extra);
- } else if (asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
- try renderAsmOutput(allocator, stream, tree, indent_extra, start_col, asm_output, Space.Newline);
- try stream.writeByteNTimes(' ', indent);
- return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
- } else {
- try renderAsmOutput(allocator, stream, tree, indent_extra, start_col, asm_output, Space.Newline);
- try stream.writeByteNTimes(' ', indent_once);
- const comma_or_colon = tree.nextToken(asm_output.lastToken());
- break :blk switch (tree.token_ids[comma_or_colon]) {
- .Comma => tree.nextToken(comma_or_colon),
- else => comma_or_colon,
- };
- }
- }
- unreachable;
- };
+ stream.pushIndentN(2);
+ defer stream.popIndent();
- const colon3 = if (asm_node.inputs.len == 0) blk: {
- try renderToken(tree, stream, colon2, indent, start_col, Space.Newline); // :
- try stream.writeByteNTimes(' ', indent_once);
+ for (asm_node.outputs) |*asm_output, i| {
+ if (i + 1 < asm_node.outputs.len) {
+ const next_asm_output = asm_node.outputs[i + 1];
+ try renderAsmOutput(allocator, stream, tree, asm_output, Space.None);
- break :blk tree.nextToken(colon2);
- } else blk: {
- try renderToken(tree, stream, colon2, indent, start_col, Space.Space); // :
-
- for (asm_node.inputs) |*asm_input, i| {
- if (i + 1 < asm_node.inputs.len) {
- const next_asm_input = &asm_node.inputs[i + 1];
- try renderAsmInput(allocator, stream, tree, indent_extra, start_col, asm_input, Space.None);
-
- const comma = tree.prevToken(next_asm_input.firstToken());
- try renderToken(tree, stream, comma, indent_extra, start_col, Space.Newline); // ,
- try renderExtraNewlineToken(tree, stream, start_col, next_asm_input.firstToken());
-
- try stream.writeByteNTimes(' ', indent_extra);
- } else if (asm_node.clobbers.len == 0) {
- try renderAsmInput(allocator, stream, tree, indent_extra, start_col, asm_input, Space.Newline);
- try stream.writeByteNTimes(' ', indent);
- return renderToken(tree, stream, asm_node.rparen, indent, start_col, space); // )
- } else {
- try renderAsmInput(allocator, stream, tree, indent_extra, start_col, asm_input, Space.Newline);
- try stream.writeByteNTimes(' ', indent_once);
- const comma_or_colon = tree.nextToken(asm_input.lastToken());
- break :blk switch (tree.token_ids[comma_or_colon]) {
- .Comma => tree.nextToken(comma_or_colon),
- else => comma_or_colon,
- };
+ const comma = tree.prevToken(next_asm_output.firstToken());
+ try renderToken(tree, stream, comma, Space.Newline); // ,
+ try renderExtraNewlineToken(tree, stream, next_asm_output.firstToken());
+ } else if (asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
+ try renderAsmOutput(allocator, stream, tree, asm_output, Space.Newline);
+ break :asmblk;
+ } else {
+ try renderAsmOutput(allocator, stream, tree, asm_output, Space.Newline);
+ const comma_or_colon = tree.nextToken(asm_output.lastToken());
+ break :blk switch (tree.token_ids[comma_or_colon]) {
+ .Comma => tree.nextToken(comma_or_colon),
+ else => comma_or_colon,
+ };
+ }
}
- }
- unreachable;
- };
+ unreachable;
+ };
- try renderToken(tree, stream, colon3, indent, start_col, Space.Space); // :
+ const colon3 = if (asm_node.inputs.len == 0) blk: {
+ try renderToken(tree, stream, colon2, Space.Newline); // :
+ break :blk tree.nextToken(colon2);
+ } else blk: {
+ try renderToken(tree, stream, colon2, Space.Space); // :
+ stream.pushIndentN(2);
+ defer stream.popIndent();
+ for (asm_node.inputs) |*asm_input, i| {
+ if (i + 1 < asm_node.inputs.len) {
+ const next_asm_input = &asm_node.inputs[i + 1];
+ try renderAsmInput(allocator, stream, tree, asm_input, Space.None);
+
+ const comma = tree.prevToken(next_asm_input.firstToken());
+ try renderToken(tree, stream, comma, Space.Newline); // ,
+ try renderExtraNewlineToken(tree, stream, next_asm_input.firstToken());
+ } else if (asm_node.clobbers.len == 0) {
+ try renderAsmInput(allocator, stream, tree, asm_input, Space.Newline);
+ break :asmblk;
+ } else {
+ try renderAsmInput(allocator, stream, tree, asm_input, Space.Newline);
+ const comma_or_colon = tree.nextToken(asm_input.lastToken());
+ break :blk switch (tree.token_ids[comma_or_colon]) {
+ .Comma => tree.nextToken(comma_or_colon),
+ else => comma_or_colon,
+ };
+ }
+ }
+ unreachable;
+ };
- for (asm_node.clobbers) |clobber_node, i| {
- if (i + 1 >= asm_node.clobbers.len) {
- try renderExpression(allocator, stream, tree, indent_extra, start_col, clobber_node, Space.Newline);
- try stream.writeByteNTimes(' ', indent);
- return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
- } else {
- try renderExpression(allocator, stream, tree, indent_extra, start_col, clobber_node, Space.None);
- const comma = tree.nextToken(clobber_node.lastToken());
- try renderToken(tree, stream, comma, indent_once, start_col, Space.Space); // ,
+ try renderToken(tree, stream, colon3, Space.Space); // :
+ stream.pushIndentN(2);
+ defer stream.popIndent();
+ for (asm_node.clobbers) |clobber_node, i| {
+ if (i + 1 >= asm_node.clobbers.len) {
+ try renderExpression(allocator, stream, tree, clobber_node, Space.Newline);
+ break :asmblk;
+ } else {
+ try renderExpression(allocator, stream, tree, clobber_node, Space.None);
+ const comma = tree.nextToken(clobber_node.lastToken());
+ try renderToken(tree, stream, comma, Space.Space); // ,
+ }
}
}
+
+ return renderToken(tree, stream, asm_node.rparen, space);
},
.EnumLiteral => {
const enum_literal = @fieldParentPtr(ast.Node.EnumLiteral, "base", base);
- try renderToken(tree, stream, enum_literal.dot, indent, start_col, Space.None); // .
- return renderToken(tree, stream, enum_literal.name, indent, start_col, space); // name
+ try renderToken(tree, stream, enum_literal.dot, Space.None); // .
+ return renderToken(tree, stream, enum_literal.name, space); // name
},
.ContainerField,
@@ -2131,116 +2059,113 @@ fn renderArrayType(
allocator: *mem.Allocator,
stream: anytype,
tree: *ast.Tree,
- indent: usize,
- start_col: *usize,
lbracket: ast.TokenIndex,
rhs: *ast.Node,
len_expr: *ast.Node,
opt_sentinel: ?*ast.Node,
space: Space,
-) (@TypeOf(stream).Error || Error)!void {
+) (@TypeOf(stream.*).Error || Error)!void {
const rbracket = tree.nextToken(if (opt_sentinel) |sentinel|
sentinel.lastToken()
else
len_expr.lastToken());
- try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
-
const starts_with_comment = tree.token_ids[lbracket + 1] == .LineComment;
const ends_with_comment = tree.token_ids[rbracket - 1] == .LineComment;
- const new_indent = if (ends_with_comment) indent + indent_delta else indent;
const new_space = if (ends_with_comment) Space.Newline else Space.None;
- try renderExpression(allocator, stream, tree, new_indent, start_col, len_expr, new_space);
- if (starts_with_comment) {
- try stream.writeByte('\n');
- }
- if (ends_with_comment or starts_with_comment) {
- try stream.writeByteNTimes(' ', indent);
- }
- if (opt_sentinel) |sentinel| {
- const colon_token = tree.prevToken(sentinel.firstToken());
- try renderToken(tree, stream, colon_token, indent, start_col, Space.None); // :
- try renderExpression(allocator, stream, tree, indent, start_col, sentinel, Space.None);
+ {
+ const do_indent = (starts_with_comment or ends_with_comment);
+ if (do_indent) stream.pushIndent();
+ defer if (do_indent) stream.popIndent();
+
+ try renderToken(tree, stream, lbracket, Space.None); // [
+ try renderExpression(allocator, stream, tree, len_expr, new_space);
+
+ if (starts_with_comment) {
+ try stream.maybeInsertNewline();
+ }
+ if (opt_sentinel) |sentinel| {
+ const colon_token = tree.prevToken(sentinel.firstToken());
+ try renderToken(tree, stream, colon_token, Space.None); // :
+ try renderExpression(allocator, stream, tree, sentinel, Space.None);
+ }
+ if (starts_with_comment) {
+ try stream.maybeInsertNewline();
+ }
}
- try renderToken(tree, stream, rbracket, indent, start_col, Space.None); // ]
+ try renderToken(tree, stream, rbracket, Space.None); // ]
- return renderExpression(allocator, stream, tree, indent, start_col, rhs, space);
+ return renderExpression(allocator, stream, tree, rhs, space);
}
fn renderAsmOutput(
allocator: *mem.Allocator,
stream: anytype,
tree: *ast.Tree,
- indent: usize,
- start_col: *usize,
asm_output: *const ast.Node.Asm.Output,
space: Space,
-) (@TypeOf(stream).Error || Error)!void {
- try stream.writeAll("[");
- try renderExpression(allocator, stream, tree, indent, start_col, asm_output.symbolic_name, Space.None);
- try stream.writeAll("] ");
- try renderExpression(allocator, stream, tree, indent, start_col, asm_output.constraint, Space.None);
- try stream.writeAll(" (");
+) (@TypeOf(stream.*).Error || Error)!void {
+ try stream.writer().writeAll("[");
+ try renderExpression(allocator, stream, tree, asm_output.symbolic_name, Space.None);
+ try stream.writer().writeAll("] ");
+ try renderExpression(allocator, stream, tree, asm_output.constraint, Space.None);
+ try stream.writer().writeAll(" (");
switch (asm_output.kind) {
ast.Node.Asm.Output.Kind.Variable => |variable_name| {
- try renderExpression(allocator, stream, tree, indent, start_col, &variable_name.base, Space.None);
+ try renderExpression(allocator, stream, tree, &variable_name.base, Space.None);
},
ast.Node.Asm.Output.Kind.Return => |return_type| {
- try stream.writeAll("-> ");
- try renderExpression(allocator, stream, tree, indent, start_col, return_type, Space.None);
+ try stream.writer().writeAll("-> ");
+ try renderExpression(allocator, stream, tree, return_type, Space.None);
},
}
- return renderToken(tree, stream, asm_output.lastToken(), indent, start_col, space); // )
+ return renderToken(tree, stream, asm_output.lastToken(), space); // )
}
fn renderAsmInput(
allocator: *mem.Allocator,
stream: anytype,
tree: *ast.Tree,
- indent: usize,
- start_col: *usize,
asm_input: *const ast.Node.Asm.Input,
space: Space,
-) (@TypeOf(stream).Error || Error)!void {
- try stream.writeAll("[");
- try renderExpression(allocator, stream, tree, indent, start_col, asm_input.symbolic_name, Space.None);
- try stream.writeAll("] ");
- try renderExpression(allocator, stream, tree, indent, start_col, asm_input.constraint, Space.None);
- try stream.writeAll(" (");
- try renderExpression(allocator, stream, tree, indent, start_col, asm_input.expr, Space.None);
- return renderToken(tree, stream, asm_input.lastToken(), indent, start_col, space); // )
+) (@TypeOf(stream.*).Error || Error)!void {
+ try stream.writer().writeAll("[");
+ try renderExpression(allocator, stream, tree, asm_input.symbolic_name, Space.None);
+ try stream.writer().writeAll("] ");
+ try renderExpression(allocator, stream, tree, asm_input.constraint, Space.None);
+ try stream.writer().writeAll(" (");
+ try renderExpression(allocator, stream, tree, asm_input.expr, Space.None);
+ return renderToken(tree, stream, asm_input.lastToken(), space); // )
}
fn renderVarDecl(
allocator: *mem.Allocator,
stream: anytype,
tree: *ast.Tree,
- indent: usize,
- start_col: *usize,
var_decl: *ast.Node.VarDecl,
-) (@TypeOf(stream).Error || Error)!void {
+) (@TypeOf(stream.*).Error || Error)!void {
if (var_decl.getTrailer("visib_token")) |visib_token| {
- try renderToken(tree, stream, visib_token, indent, start_col, Space.Space); // pub
+ try renderToken(tree, stream, visib_token, Space.Space); // pub
}
if (var_decl.getTrailer("extern_export_token")) |extern_export_token| {
- try renderToken(tree, stream, extern_export_token, indent, start_col, Space.Space); // extern
+ try renderToken(tree, stream, extern_export_token, Space.Space); // extern
if (var_decl.getTrailer("lib_name")) |lib_name| {
- try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space); // "lib"
+ try renderExpression(allocator, stream, tree, lib_name, Space.Space); // "lib"
}
}
if (var_decl.getTrailer("comptime_token")) |comptime_token| {
- try renderToken(tree, stream, comptime_token, indent, start_col, Space.Space); // comptime
+ try renderToken(tree, stream, comptime_token, Space.Space); // comptime
}
if (var_decl.getTrailer("thread_local_token")) |thread_local_token| {
- try renderToken(tree, stream, thread_local_token, indent, start_col, Space.Space); // threadlocal
+ try renderToken(tree, stream, thread_local_token, Space.Space); // threadlocal
}
- try renderToken(tree, stream, var_decl.mut_token, indent, start_col, Space.Space); // var
+ try renderToken(tree, stream, var_decl.mut_token, Space.Space); // var
const name_space = if (var_decl.getTrailer("type_node") == null and
(var_decl.getTrailer("align_node") != null or
@@ -2249,70 +2174,69 @@ fn renderVarDecl(
Space.Space
else
Space.None;
- try renderToken(tree, stream, var_decl.name_token, indent, start_col, name_space);
+ try renderToken(tree, stream, var_decl.name_token, name_space);
if (var_decl.getTrailer("type_node")) |type_node| {
- try renderToken(tree, stream, tree.nextToken(var_decl.name_token), indent, start_col, Space.Space);
+ try renderToken(tree, stream, tree.nextToken(var_decl.name_token), Space.Space);
const s = if (var_decl.getTrailer("align_node") != null or
var_decl.getTrailer("section_node") != null or
var_decl.getTrailer("init_node") != null) Space.Space else Space.None;
- try renderExpression(allocator, stream, tree, indent, start_col, type_node, s);
+ try renderExpression(allocator, stream, tree, type_node, s);
}
if (var_decl.getTrailer("align_node")) |align_node| {
const lparen = tree.prevToken(align_node.firstToken());
const align_kw = tree.prevToken(lparen);
const rparen = tree.nextToken(align_node.lastToken());
- try renderToken(tree, stream, align_kw, indent, start_col, Space.None); // align
- try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, align_node, Space.None);
+ try renderToken(tree, stream, align_kw, Space.None); // align
+ try renderToken(tree, stream, lparen, Space.None); // (
+ try renderExpression(allocator, stream, tree, align_node, Space.None);
const s = if (var_decl.getTrailer("section_node") != null or var_decl.getTrailer("init_node") != null) Space.Space else Space.None;
- try renderToken(tree, stream, rparen, indent, start_col, s); // )
+ try renderToken(tree, stream, rparen, s); // )
}
if (var_decl.getTrailer("section_node")) |section_node| {
const lparen = tree.prevToken(section_node.firstToken());
const section_kw = tree.prevToken(lparen);
const rparen = tree.nextToken(section_node.lastToken());
- try renderToken(tree, stream, section_kw, indent, start_col, Space.None); // linksection
- try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
- try renderExpression(allocator, stream, tree, indent, start_col, section_node, Space.None);
+ try renderToken(tree, stream, section_kw, Space.None); // linksection
+ try renderToken(tree, stream, lparen, Space.None); // (
+ try renderExpression(allocator, stream, tree, section_node, Space.None);
const s = if (var_decl.getTrailer("init_node") != null) Space.Space else Space.None;
- try renderToken(tree, stream, rparen, indent, start_col, s); // )
+ try renderToken(tree, stream, rparen, s); // )
}
if (var_decl.getTrailer("init_node")) |init_node| {
const s = if (init_node.tag == .MultilineStringLiteral) Space.None else Space.Space;
- try renderToken(tree, stream, var_decl.getTrailer("eq_token").?, indent, start_col, s); // =
- try renderExpression(allocator, stream, tree, indent, start_col, init_node, Space.None);
+ try renderToken(tree, stream, var_decl.getTrailer("eq_token").?, s); // =
+ stream.pushIndentOneShot();
+ try renderExpression(allocator, stream, tree, init_node, Space.None);
}
- try renderToken(tree, stream, var_decl.semicolon_token, indent, start_col, Space.Newline);
+ try renderToken(tree, stream, var_decl.semicolon_token, Space.Newline);
}
fn renderParamDecl(
allocator: *mem.Allocator,
stream: anytype,
tree: *ast.Tree,
- indent: usize,
- start_col: *usize,
param_decl: ast.Node.FnProto.ParamDecl,
space: Space,
-) (@TypeOf(stream).Error || Error)!void {
- try renderDocComments(tree, stream, param_decl, param_decl.doc_comments, indent, start_col);
+) (@TypeOf(stream.*).Error || Error)!void {
+ try renderDocComments(tree, stream, param_decl, param_decl.doc_comments);
if (param_decl.comptime_token) |comptime_token| {
- try renderToken(tree, stream, comptime_token, indent, start_col, Space.Space);
+ try renderToken(tree, stream, comptime_token, Space.Space);
}
if (param_decl.noalias_token) |noalias_token| {
- try renderToken(tree, stream, noalias_token, indent, start_col, Space.Space);
+ try renderToken(tree, stream, noalias_token, Space.Space);
}
if (param_decl.name_token) |name_token| {
- try renderToken(tree, stream, name_token, indent, start_col, Space.None);
- try renderToken(tree, stream, tree.nextToken(name_token), indent, start_col, Space.Space); // :
+ try renderToken(tree, stream, name_token, Space.None);
+ try renderToken(tree, stream, tree.nextToken(name_token), Space.Space); // :
}
switch (param_decl.param_type) {
- .any_type, .type_expr => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, space),
+ .any_type, .type_expr => |node| try renderExpression(allocator, stream, tree, node, space),
}
}
@@ -2320,24 +2244,22 @@ fn renderStatement(
allocator: *mem.Allocator,
stream: anytype,
tree: *ast.Tree,
- indent: usize,
- start_col: *usize,
base: *ast.Node,
-) (@TypeOf(stream).Error || Error)!void {
+) (@TypeOf(stream.*).Error || Error)!void {
switch (base.tag) {
.VarDecl => {
const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", base);
- try renderVarDecl(allocator, stream, tree, indent, start_col, var_decl);
+ try renderVarDecl(allocator, stream, tree, var_decl);
},
else => {
if (base.requireSemiColon()) {
- try renderExpression(allocator, stream, tree, indent, start_col, base, Space.None);
+ try renderExpression(allocator, stream, tree, base, Space.None);
const semicolon_index = tree.nextToken(base.lastToken());
assert(tree.token_ids[semicolon_index] == .Semicolon);
- try renderToken(tree, stream, semicolon_index, indent, start_col, Space.Newline);
+ try renderToken(tree, stream, semicolon_index, Space.Newline);
} else {
- try renderExpression(allocator, stream, tree, indent, start_col, base, Space.Newline);
+ try renderExpression(allocator, stream, tree, base, Space.Newline);
}
},
}
@@ -2358,22 +2280,17 @@ fn renderTokenOffset(
tree: *ast.Tree,
stream: anytype,
token_index: ast.TokenIndex,
- indent: usize,
- start_col: *usize,
space: Space,
token_skip_bytes: usize,
-) (@TypeOf(stream).Error || Error)!void {
+) (@TypeOf(stream.*).Error || Error)!void {
if (space == Space.BlockStart) {
- if (start_col.* < indent + indent_delta)
- return renderToken(tree, stream, token_index, indent, start_col, Space.Space);
- try renderToken(tree, stream, token_index, indent, start_col, Space.Newline);
- try stream.writeByteNTimes(' ', indent);
- start_col.* = indent;
- return;
+ // If placing the lbrace on the current line would cause an uggly gap then put the lbrace on the next line
+ const new_space = if (stream.isLineOverIndented()) Space.Newline else Space.Space;
+ return renderToken(tree, stream, token_index, new_space);
}
var token_loc = tree.token_locs[token_index];
- try stream.writeAll(mem.trimRight(u8, tree.tokenSliceLoc(token_loc)[token_skip_bytes..], " "));
+ try stream.writer().writeAll(mem.trimRight(u8, tree.tokenSliceLoc(token_loc)[token_skip_bytes..], " "));
if (space == Space.NoComment)
return;
@@ -2382,20 +2299,20 @@ fn renderTokenOffset(
var next_token_loc = tree.token_locs[token_index + 1];
if (space == Space.Comma) switch (next_token_id) {
- .Comma => return renderToken(tree, stream, token_index + 1, indent, start_col, Space.Newline),
+ .Comma => return renderToken(tree, stream, token_index + 1, Space.Newline),
.LineComment => {
- try stream.writeAll(", ");
- return renderToken(tree, stream, token_index + 1, indent, start_col, Space.Newline);
+ try stream.writer().writeAll(", ");
+ return renderToken(tree, stream, token_index + 1, Space.Newline);
},
else => {
if (token_index + 2 < tree.token_ids.len and
tree.token_ids[token_index + 2] == .MultilineStringLiteralLine)
{
- try stream.writeAll(",");
+ try stream.writer().writeAll(",");
return;
} else {
- try stream.writeAll(",\n");
- start_col.* = 0;
+ try stream.writer().writeAll(",");
+ try stream.insertNewline();
return;
}
},
@@ -2419,15 +2336,14 @@ fn renderTokenOffset(
if (next_token_id == .MultilineStringLiteralLine) {
return;
} else {
- try stream.writeAll("\n");
- start_col.* = 0;
+ try stream.insertNewline();
return;
}
},
Space.Space, Space.SpaceOrOutdent => {
if (next_token_id == .MultilineStringLiteralLine)
return;
- try stream.writeByte(' ');
+ try stream.writer().writeByte(' ');
return;
},
Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
@@ -2444,8 +2360,7 @@ fn renderTokenOffset(
next_token_id = tree.token_ids[token_index + offset];
next_token_loc = tree.token_locs[token_index + offset];
if (next_token_id != .LineComment) {
- try stream.writeByte('\n');
- start_col.* = 0;
+ try stream.insertNewline();
return;
}
},
@@ -2458,7 +2373,7 @@ fn renderTokenOffset(
var loc = tree.tokenLocationLoc(token_loc.end, next_token_loc);
if (loc.line == 0) {
- try stream.print(" {}", .{mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " ")});
+ try stream.writer().print(" {}", .{mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " ")});
offset = 2;
token_loc = next_token_loc;
next_token_loc = tree.token_locs[token_index + offset];
@@ -2466,26 +2381,16 @@ fn renderTokenOffset(
if (next_token_id != .LineComment) {
switch (space) {
Space.None, Space.Space => {
- try stream.writeByte('\n');
- const after_comment_token = tree.token_ids[token_index + offset];
- const next_line_indent = switch (after_comment_token) {
- .RParen, .RBrace, .RBracket => indent,
- else => indent + indent_delta,
- };
- try stream.writeByteNTimes(' ', next_line_indent);
- start_col.* = next_line_indent;
+ try stream.insertNewline();
},
Space.SpaceOrOutdent => {
- try stream.writeByte('\n');
- try stream.writeByteNTimes(' ', indent);
- start_col.* = indent;
+ try stream.insertNewline();
},
Space.Newline => {
if (next_token_id == .MultilineStringLiteralLine) {
return;
} else {
- try stream.writeAll("\n");
- start_col.* = 0;
+ try stream.insertNewline();
return;
}
},
@@ -2501,10 +2406,9 @@ fn renderTokenOffset(
// translate-c doesn't generate correct newlines
// in generated code (loc.line == 0) so treat that case
// as though there was meant to be a newline between the tokens
- const newline_count = if (loc.line <= 1) @as(u8, 1) else @as(u8, 2);
- try stream.writeByteNTimes('\n', newline_count);
- try stream.writeByteNTimes(' ', indent);
- try stream.writeAll(mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " "));
+ var newline_count = if (loc.line <= 1) @as(u8, 1) else @as(u8, 2);
+ while (newline_count > 0) : (newline_count -= 1) try stream.insertNewline();
+ try stream.writer().writeAll(mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " "));
offset += 1;
token_loc = next_token_loc;
@@ -2516,32 +2420,15 @@ fn renderTokenOffset(
if (next_token_id == .MultilineStringLiteralLine) {
return;
} else {
- try stream.writeAll("\n");
- start_col.* = 0;
+ try stream.insertNewline();
return;
}
},
Space.None, Space.Space => {
- try stream.writeByte('\n');
-
- const after_comment_token = tree.token_ids[token_index + offset];
- const next_line_indent = switch (after_comment_token) {
- .RParen, .RBrace, .RBracket => blk: {
- if (indent > indent_delta) {
- break :blk indent - indent_delta;
- } else {
- break :blk 0;
- }
- },
- else => indent,
- };
- try stream.writeByteNTimes(' ', next_line_indent);
- start_col.* = next_line_indent;
+ try stream.insertNewline();
},
Space.SpaceOrOutdent => {
- try stream.writeByte('\n');
- try stream.writeByteNTimes(' ', indent);
- start_col.* = indent;
+ try stream.insertNewline();
},
Space.NoNewline => {},
Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
@@ -2556,11 +2443,9 @@ fn renderToken(
tree: *ast.Tree,
stream: anytype,
token_index: ast.TokenIndex,
- indent: usize,
- start_col: *usize,
space: Space,
-) (@TypeOf(stream).Error || Error)!void {
- return renderTokenOffset(tree, stream, token_index, indent, start_col, space, 0);
+) (@TypeOf(stream.*).Error || Error)!void {
+ return renderTokenOffset(tree, stream, token_index, space, 0);
}
fn renderDocComments(
@@ -2568,11 +2453,9 @@ fn renderDocComments(
stream: anytype,
node: anytype,
doc_comments: ?*ast.Node.DocComment,
- indent: usize,
- start_col: *usize,
-) (@TypeOf(stream).Error || Error)!void {
+) (@TypeOf(stream.*).Error || Error)!void {
const comment = doc_comments orelse return;
- return renderDocCommentsToken(tree, stream, comment, node.firstToken(), indent, start_col);
+ return renderDocCommentsToken(tree, stream, comment, node.firstToken());
}
fn renderDocCommentsToken(
@@ -2580,20 +2463,16 @@ fn renderDocCommentsToken(
stream: anytype,
comment: *ast.Node.DocComment,
first_token: ast.TokenIndex,
- indent: usize,
- start_col: *usize,
-) (@TypeOf(stream).Error || Error)!void {
+) (@TypeOf(stream.*).Error || Error)!void {
var tok_i = comment.first_line;
while (true) : (tok_i += 1) {
switch (tree.token_ids[tok_i]) {
.DocComment, .ContainerDocComment => {
if (comment.first_line < first_token) {
- try renderToken(tree, stream, tok_i, indent, start_col, Space.Newline);
- try stream.writeByteNTimes(' ', indent);
+ try renderToken(tree, stream, tok_i, Space.Newline);
} else {
- try renderToken(tree, stream, tok_i, indent, start_col, Space.NoComment);
- try stream.writeAll("\n");
- try stream.writeByteNTimes(' ', indent);
+ try renderToken(tree, stream, tok_i, Space.NoComment);
+ try stream.insertNewline();
}
},
.LineComment => continue,
@@ -2665,41 +2544,10 @@ fn nodeCausesSliceOpSpace(base: *ast.Node) bool {
};
}
-/// A `std.io.OutStream` that returns whether the given character has been written to it.
-/// The contents are not written to anything.
-const FindByteOutStream = struct {
- byte_found: bool,
- byte: u8,
-
- pub const Error = error{};
- pub const OutStream = std.io.OutStream(*FindByteOutStream, Error, write);
-
- pub fn init(byte: u8) FindByteOutStream {
- return FindByteOutStream{
- .byte = byte,
- .byte_found = false,
- };
- }
-
- pub fn write(self: *FindByteOutStream, bytes: []const u8) Error!usize {
- if (self.byte_found) return bytes.len;
- self.byte_found = blk: {
- for (bytes) |b|
- if (b == self.byte) break :blk true;
- break :blk false;
- };
- return bytes.len;
- }
-
- pub fn outStream(self: *FindByteOutStream) OutStream {
- return .{ .context = self };
- }
-};
-
-fn copyFixingWhitespace(stream: anytype, slice: []const u8) @TypeOf(stream).Error!void {
+fn copyFixingWhitespace(stream: anytype, slice: []const u8) @TypeOf(stream.*).Error!void {
for (slice) |byte| switch (byte) {
- '\t' => try stream.writeAll(" "),
+ '\t' => try stream.writer().writeAll(" "),
'\r' => {},
- else => try stream.writeByte(byte),
+ else => try stream.writer().writeByte(byte),
};
}
lib/std/io.zig
@@ -169,6 +169,15 @@ pub const BitOutStream = BitWriter;
/// Deprecated: use `bitWriter`
pub const bitOutStream = bitWriter;
+pub const AutoIndentingStream = @import("io/auto_indenting_stream.zig").AutoIndentingStream;
+pub const autoIndentingStream = @import("io/auto_indenting_stream.zig").autoIndentingStream;
+
+pub const ChangeDetectionStream = @import("io/change_detection_stream.zig").ChangeDetectionStream;
+pub const changeDetectionStream = @import("io/change_detection_stream.zig").changeDetectionStream;
+
+pub const FindByteOutStream = @import("io/find_byte_out_stream.zig").FindByteOutStream;
+pub const findByteOutStream = @import("io/find_byte_out_stream.zig").findByteOutStream;
+
pub const Packing = @import("io/serialization.zig").Packing;
pub const Serializer = @import("io/serialization.zig").Serializer;
@@ -182,10 +191,10 @@ pub const BufferedAtomicFile = @import("io/buffered_atomic_file.zig").BufferedAt
pub const StreamSource = @import("io/stream_source.zig").StreamSource;
/// A Writer that doesn't write to anything.
-pub const null_writer = @as(NullWriter, .{ .context = {} });
+pub var null_writer = @as(NullWriter, .{ .context = {} });
/// Deprecated: use `null_writer`
-pub const null_out_stream = null_writer;
+pub var null_out_stream = null_writer;
const NullWriter = Writer(void, error{}, dummyWrite);
/// Deprecated: use NullWriter
src-self-hosted/main.zig
@@ -682,13 +682,13 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
process.exit(1);
}
if (check_flag) {
- const anything_changed = try std.zig.render(gpa, io.null_out_stream, tree);
+ const anything_changed = try std.zig.render(gpa, &io.null_out_stream, tree);
const code = if (anything_changed) @as(u8, 1) else @as(u8, 0);
process.exit(code);
}
const stdout = io.getStdOut().outStream();
- _ = try std.zig.render(gpa, stdout, tree);
+ _ = try std.zig.render(gpa, &stdout, tree);
return;
}
@@ -830,7 +830,7 @@ fn fmtPathFile(
}
if (check_mode) {
- const anything_changed = try std.zig.render(fmt.gpa, io.null_out_stream, tree);
+ const anything_changed = try std.zig.render(fmt.gpa, &io.null_out_stream, tree);
if (anything_changed) {
std.debug.print("{}\n", .{file_path});
fmt.any_error = true;
@@ -839,7 +839,8 @@ fn fmtPathFile(
// As a heuristic, we make enough capacity for the same as the input source.
try fmt.out_buffer.ensureCapacity(source_code.len);
fmt.out_buffer.items.len = 0;
- const anything_changed = try std.zig.render(fmt.gpa, fmt.out_buffer.writer(), tree);
+ const writer = fmt.out_buffer.writer();
+ const anything_changed = try std.zig.render(fmt.gpa, &writer, tree);
if (!anything_changed)
return; // Good thing we didn't waste any file system access on this.
src-self-hosted/stage2.zig
@@ -151,7 +151,7 @@ export fn stage2_free_clang_errors(errors_ptr: [*]translate_c.ClangErrMsg, error
export fn stage2_render_ast(tree: *ast.Tree, output_file: *FILE) Error {
const c_out_stream = std.io.cOutStream(output_file);
- _ = std.zig.render(std.heap.c_allocator, c_out_stream, tree) catch |e| switch (e) {
+ _ = std.zig.render(std.heap.c_allocator, &c_out_stream, tree) catch |e| switch (e) {
error.WouldBlock => unreachable, // stage1 opens stuff in exclusively blocking mode
error.NotOpenForWriting => unreachable,
error.SystemResources => return .SystemResources,