mirror of
https://github.com/ziglang/zig.git
synced 2025-12-06 14:23:09 +00:00
3ad9cb8b47
Currently `// zig fmt: off` does not work as there are two spaces after the `//` instead of one. This can cause confusion, so allow arbitrary whitespace before the `zig fmt: (off|on)` in the comment but trim this whitespace to the canonical single space in the output.
2737 lines
110 KiB
Zig
2737 lines
110 KiB
Zig
// SPDX-License-Identifier: MIT
|
|
// Copyright (c) 2015-2021 Zig Contributors
|
|
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
|
|
// The MIT license requires this copyright notice to be included in all copies
|
|
// and substantial portions of the software.
|
|
const std = @import("../std.zig");
|
|
const assert = std.debug.assert;
|
|
const mem = std.mem;
|
|
const Allocator = std.mem.Allocator;
|
|
const meta = std.meta;
|
|
const ast = std.zig.ast;
|
|
const Token = std.zig.Token;
|
|
|
|
const indent_delta = 4;
|
|
const asm_indent_delta = 2;
|
|
|
|
pub const Error = ast.Tree.RenderError;
|
|
|
|
const Ais = AutoIndentingStream(std.ArrayList(u8).Writer);
|
|
|
|
pub fn renderTree(buffer: *std.ArrayList(u8), tree: ast.Tree) Error!void {
|
|
assert(tree.errors.len == 0); // Cannot render an invalid tree.
|
|
var auto_indenting_stream = Ais{
|
|
.indent_delta = indent_delta,
|
|
.underlying_writer = buffer.writer(),
|
|
};
|
|
const ais = &auto_indenting_stream;
|
|
|
|
// Render all the line comments at the beginning of the file.
|
|
const comment_end_loc = tree.tokens.items(.start)[0];
|
|
_ = try renderComments(ais, tree, 0, comment_end_loc);
|
|
|
|
if (tree.tokens.items(.tag)[0] == .container_doc_comment) {
|
|
try renderContainerDocComments(ais, tree, 0);
|
|
}
|
|
|
|
try renderMembers(buffer.allocator, ais, tree, tree.rootDecls());
|
|
|
|
if (ais.disabled_offset) |disabled_offset| {
|
|
try writeFixingWhitespace(ais.underlying_writer, tree.source[disabled_offset..]);
|
|
}
|
|
}
|
|
|
|
/// Render all members in the given slice, keeping empty lines where appropriate
|
|
fn renderMembers(gpa: *Allocator, ais: *Ais, tree: ast.Tree, members: []const ast.Node.Index) Error!void {
|
|
if (members.len == 0) return;
|
|
try renderMember(gpa, ais, tree, members[0], .newline);
|
|
for (members[1..]) |member| {
|
|
try renderExtraNewline(ais, tree, member);
|
|
try renderMember(gpa, ais, tree, member, .newline);
|
|
}
|
|
}
|
|
|
|
fn renderMember(gpa: *Allocator, ais: *Ais, tree: ast.Tree, decl: ast.Node.Index, space: Space) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const main_tokens = tree.nodes.items(.main_token);
|
|
const datas = tree.nodes.items(.data);
|
|
try renderDocComments(ais, tree, tree.firstToken(decl));
|
|
switch (tree.nodes.items(.tag)[decl]) {
|
|
.fn_decl => {
|
|
// Some examples:
|
|
// pub extern "foo" fn ...
|
|
// export fn ...
|
|
const fn_proto = datas[decl].lhs;
|
|
const fn_token = main_tokens[fn_proto];
|
|
// Go back to the first token we should render here.
|
|
var i = fn_token;
|
|
while (i > 0) {
|
|
i -= 1;
|
|
switch (token_tags[i]) {
|
|
.keyword_extern,
|
|
.keyword_export,
|
|
.keyword_pub,
|
|
.string_literal,
|
|
.keyword_inline,
|
|
.keyword_noinline,
|
|
=> continue,
|
|
|
|
else => {
|
|
i += 1;
|
|
break;
|
|
},
|
|
}
|
|
}
|
|
while (i < fn_token) : (i += 1) {
|
|
if (token_tags[i] == .keyword_inline) {
|
|
// TODO remove this special case when 0.9.0 is released.
|
|
// See the commit that introduced this comment for more details.
|
|
continue;
|
|
}
|
|
try renderToken(ais, tree, i, .space);
|
|
}
|
|
assert(datas[decl].rhs != 0);
|
|
try renderExpression(gpa, ais, tree, fn_proto, .space);
|
|
return renderExpression(gpa, ais, tree, datas[decl].rhs, space);
|
|
},
|
|
.fn_proto_simple,
|
|
.fn_proto_multi,
|
|
.fn_proto_one,
|
|
.fn_proto,
|
|
=> {
|
|
// Extern function prototypes are parsed as these tags.
|
|
// Go back to the first token we should render here.
|
|
const fn_token = main_tokens[decl];
|
|
var i = fn_token;
|
|
while (i > 0) {
|
|
i -= 1;
|
|
switch (token_tags[i]) {
|
|
.keyword_extern,
|
|
.keyword_export,
|
|
.keyword_pub,
|
|
.string_literal,
|
|
.keyword_inline,
|
|
.keyword_noinline,
|
|
=> continue,
|
|
|
|
else => {
|
|
i += 1;
|
|
break;
|
|
},
|
|
}
|
|
}
|
|
while (i < fn_token) : (i += 1) {
|
|
try renderToken(ais, tree, i, .space);
|
|
}
|
|
try renderExpression(gpa, ais, tree, decl, .none);
|
|
return renderToken(ais, tree, tree.lastToken(decl) + 1, space); // semicolon
|
|
},
|
|
|
|
.@"usingnamespace" => {
|
|
const main_token = main_tokens[decl];
|
|
const expr = datas[decl].lhs;
|
|
if (main_token > 0 and token_tags[main_token - 1] == .keyword_pub) {
|
|
try renderToken(ais, tree, main_token - 1, .space); // pub
|
|
}
|
|
try renderToken(ais, tree, main_token, .space); // usingnamespace
|
|
try renderExpression(gpa, ais, tree, expr, .none);
|
|
return renderToken(ais, tree, tree.lastToken(expr) + 1, space); // ;
|
|
},
|
|
|
|
.global_var_decl => return renderVarDecl(gpa, ais, tree, tree.globalVarDecl(decl)),
|
|
.local_var_decl => return renderVarDecl(gpa, ais, tree, tree.localVarDecl(decl)),
|
|
.simple_var_decl => return renderVarDecl(gpa, ais, tree, tree.simpleVarDecl(decl)),
|
|
.aligned_var_decl => return renderVarDecl(gpa, ais, tree, tree.alignedVarDecl(decl)),
|
|
|
|
.test_decl => {
|
|
const test_token = main_tokens[decl];
|
|
try renderToken(ais, tree, test_token, .space);
|
|
if (token_tags[test_token + 1] == .string_literal) {
|
|
try renderToken(ais, tree, test_token + 1, .space);
|
|
}
|
|
try renderExpression(gpa, ais, tree, datas[decl].rhs, space);
|
|
},
|
|
|
|
.container_field_init => return renderContainerField(gpa, ais, tree, tree.containerFieldInit(decl), space),
|
|
.container_field_align => return renderContainerField(gpa, ais, tree, tree.containerFieldAlign(decl), space),
|
|
.container_field => return renderContainerField(gpa, ais, tree, tree.containerField(decl), space),
|
|
.@"comptime" => return renderExpression(gpa, ais, tree, decl, space),
|
|
|
|
.root => unreachable,
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
/// Render all expressions in the slice, keeping empty lines where appropriate
|
|
fn renderExpressions(gpa: *Allocator, ais: *Ais, tree: ast.Tree, expressions: []const ast.Node.Index, space: Space) Error!void {
|
|
if (expressions.len == 0) return;
|
|
try renderExpression(gpa, ais, tree, expressions[0], space);
|
|
for (expressions[1..]) |expression| {
|
|
try renderExtraNewline(ais, tree, expression);
|
|
try renderExpression(gpa, ais, tree, expression, space);
|
|
}
|
|
}
|
|
|
|
fn renderExpression(gpa: *Allocator, ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Space) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const main_tokens = tree.nodes.items(.main_token);
|
|
const node_tags = tree.nodes.items(.tag);
|
|
const datas = tree.nodes.items(.data);
|
|
switch (node_tags[node]) {
|
|
.identifier,
|
|
.integer_literal,
|
|
.float_literal,
|
|
.char_literal,
|
|
.true_literal,
|
|
.false_literal,
|
|
.null_literal,
|
|
.unreachable_literal,
|
|
.undefined_literal,
|
|
.anyframe_literal,
|
|
.string_literal,
|
|
=> return renderToken(ais, tree, main_tokens[node], space),
|
|
|
|
.multiline_string_literal => {
|
|
var locked_indents = ais.lockOneShotIndent();
|
|
try ais.maybeInsertNewline();
|
|
|
|
var i = datas[node].lhs;
|
|
while (i <= datas[node].rhs) : (i += 1) try renderToken(ais, tree, i, .newline);
|
|
|
|
while (locked_indents > 0) : (locked_indents -= 1) ais.popIndent();
|
|
|
|
switch (space) {
|
|
.none, .space, .newline, .skip => {},
|
|
.semicolon => if (token_tags[i] == .semicolon) try renderToken(ais, tree, i, .newline),
|
|
.comma => if (token_tags[i] == .comma) try renderToken(ais, tree, i, .newline),
|
|
.comma_space => if (token_tags[i] == .comma) try renderToken(ais, tree, i, .space),
|
|
}
|
|
},
|
|
|
|
.error_value => {
|
|
try renderToken(ais, tree, main_tokens[node], .none);
|
|
try renderToken(ais, tree, main_tokens[node] + 1, .none);
|
|
return renderToken(ais, tree, main_tokens[node] + 2, space);
|
|
},
|
|
|
|
.@"anytype" => return renderToken(ais, tree, main_tokens[node], space),
|
|
|
|
.block_two,
|
|
.block_two_semicolon,
|
|
=> {
|
|
const statements = [2]ast.Node.Index{ datas[node].lhs, datas[node].rhs };
|
|
if (datas[node].lhs == 0) {
|
|
return renderBlock(gpa, ais, tree, node, statements[0..0], space);
|
|
} else if (datas[node].rhs == 0) {
|
|
return renderBlock(gpa, ais, tree, node, statements[0..1], space);
|
|
} else {
|
|
return renderBlock(gpa, ais, tree, node, statements[0..2], space);
|
|
}
|
|
},
|
|
.block,
|
|
.block_semicolon,
|
|
=> {
|
|
const statements = tree.extra_data[datas[node].lhs..datas[node].rhs];
|
|
return renderBlock(gpa, ais, tree, node, statements, space);
|
|
},
|
|
|
|
.@"errdefer" => {
|
|
const defer_token = main_tokens[node];
|
|
const payload_token = datas[node].lhs;
|
|
const expr = datas[node].rhs;
|
|
|
|
try renderToken(ais, tree, defer_token, .space);
|
|
if (payload_token != 0) {
|
|
try renderToken(ais, tree, payload_token - 1, .none); // |
|
|
try renderToken(ais, tree, payload_token, .none); // identifier
|
|
try renderToken(ais, tree, payload_token + 1, .space); // |
|
|
}
|
|
return renderExpression(gpa, ais, tree, expr, space);
|
|
},
|
|
|
|
.@"defer" => {
|
|
const defer_token = main_tokens[node];
|
|
const expr = datas[node].rhs;
|
|
try renderToken(ais, tree, defer_token, .space);
|
|
return renderExpression(gpa, ais, tree, expr, space);
|
|
},
|
|
.@"comptime", .@"nosuspend" => {
|
|
const comptime_token = main_tokens[node];
|
|
const block = datas[node].lhs;
|
|
try renderToken(ais, tree, comptime_token, .space);
|
|
return renderExpression(gpa, ais, tree, block, space);
|
|
},
|
|
|
|
.@"suspend" => {
|
|
const suspend_token = main_tokens[node];
|
|
const body = datas[node].lhs;
|
|
if (body != 0) {
|
|
try renderToken(ais, tree, suspend_token, .space);
|
|
return renderExpression(gpa, ais, tree, body, space);
|
|
} else {
|
|
return renderToken(ais, tree, suspend_token, space);
|
|
}
|
|
},
|
|
|
|
.@"catch" => {
|
|
const main_token = main_tokens[node];
|
|
const fallback_first = tree.firstToken(datas[node].rhs);
|
|
|
|
const same_line = tree.tokensOnSameLine(main_token, fallback_first);
|
|
const after_op_space = if (same_line) Space.space else Space.newline;
|
|
|
|
try renderExpression(gpa, ais, tree, datas[node].lhs, .space); // target
|
|
|
|
if (token_tags[fallback_first - 1] == .pipe) {
|
|
try renderToken(ais, tree, main_token, .space); // catch keyword
|
|
try renderToken(ais, tree, main_token + 1, .none); // pipe
|
|
try renderToken(ais, tree, main_token + 2, .none); // payload identifier
|
|
try renderToken(ais, tree, main_token + 3, after_op_space); // pipe
|
|
} else {
|
|
assert(token_tags[fallback_first - 1] == .keyword_catch);
|
|
try renderToken(ais, tree, main_token, after_op_space); // catch keyword
|
|
}
|
|
|
|
ais.pushIndentOneShot();
|
|
try renderExpression(gpa, ais, tree, datas[node].rhs, space); // fallback
|
|
},
|
|
|
|
.field_access => {
|
|
const main_token = main_tokens[node];
|
|
const field_access = datas[node];
|
|
|
|
try renderExpression(gpa, ais, tree, field_access.lhs, .none);
|
|
|
|
// Allow a line break between the lhs and the dot if the lhs and rhs
|
|
// are on different lines.
|
|
const lhs_last_token = tree.lastToken(field_access.lhs);
|
|
const same_line = tree.tokensOnSameLine(lhs_last_token, main_token + 1);
|
|
if (!same_line) {
|
|
if (!hasComment(tree, lhs_last_token, main_token)) try ais.insertNewline();
|
|
ais.pushIndentOneShot();
|
|
}
|
|
|
|
try renderToken(ais, tree, main_token, .none);
|
|
|
|
// This check ensures that zag() is indented in the following example:
|
|
// const x = foo
|
|
// .bar()
|
|
// . // comment
|
|
// zag();
|
|
if (!same_line and hasComment(tree, main_token, main_token + 1)) {
|
|
ais.pushIndentOneShot();
|
|
}
|
|
|
|
return renderToken(ais, tree, field_access.rhs, space);
|
|
},
|
|
|
|
.error_union,
|
|
.switch_range,
|
|
=> {
|
|
const infix = datas[node];
|
|
try renderExpression(gpa, ais, tree, infix.lhs, .none);
|
|
try renderToken(ais, tree, main_tokens[node], .none);
|
|
return renderExpression(gpa, ais, tree, infix.rhs, space);
|
|
},
|
|
|
|
.add,
|
|
.add_wrap,
|
|
.array_cat,
|
|
.array_mult,
|
|
.assign,
|
|
.assign_bit_and,
|
|
.assign_bit_or,
|
|
.assign_bit_shift_left,
|
|
.assign_bit_shift_right,
|
|
.assign_bit_xor,
|
|
.assign_div,
|
|
.assign_sub,
|
|
.assign_sub_wrap,
|
|
.assign_mod,
|
|
.assign_add,
|
|
.assign_add_wrap,
|
|
.assign_mul,
|
|
.assign_mul_wrap,
|
|
.bang_equal,
|
|
.bit_and,
|
|
.bit_or,
|
|
.bit_shift_left,
|
|
.bit_shift_right,
|
|
.bit_xor,
|
|
.bool_and,
|
|
.bool_or,
|
|
.div,
|
|
.equal_equal,
|
|
.greater_or_equal,
|
|
.greater_than,
|
|
.less_or_equal,
|
|
.less_than,
|
|
.merge_error_sets,
|
|
.mod,
|
|
.mul,
|
|
.mul_wrap,
|
|
.sub,
|
|
.sub_wrap,
|
|
.@"orelse",
|
|
=> {
|
|
const infix = datas[node];
|
|
try renderExpression(gpa, ais, tree, infix.lhs, .space);
|
|
const op_token = main_tokens[node];
|
|
if (tree.tokensOnSameLine(op_token, op_token + 1)) {
|
|
try renderToken(ais, tree, op_token, .space);
|
|
} else {
|
|
ais.pushIndent();
|
|
try renderToken(ais, tree, op_token, .newline);
|
|
ais.popIndent();
|
|
}
|
|
ais.pushIndentOneShot();
|
|
return renderExpression(gpa, ais, tree, infix.rhs, space);
|
|
},
|
|
|
|
.bit_not,
|
|
.bool_not,
|
|
.negation,
|
|
.negation_wrap,
|
|
.optional_type,
|
|
.address_of,
|
|
=> {
|
|
try renderToken(ais, tree, main_tokens[node], .none);
|
|
return renderExpression(gpa, ais, tree, datas[node].lhs, space);
|
|
},
|
|
|
|
.@"try",
|
|
.@"resume",
|
|
.@"await",
|
|
=> {
|
|
try renderToken(ais, tree, main_tokens[node], .space);
|
|
return renderExpression(gpa, ais, tree, datas[node].lhs, space);
|
|
},
|
|
|
|
.array_type => return renderArrayType(gpa, ais, tree, tree.arrayType(node), space),
|
|
.array_type_sentinel => return renderArrayType(gpa, ais, tree, tree.arrayTypeSentinel(node), space),
|
|
|
|
.ptr_type_aligned => return renderPtrType(gpa, ais, tree, tree.ptrTypeAligned(node), space),
|
|
.ptr_type_sentinel => return renderPtrType(gpa, ais, tree, tree.ptrTypeSentinel(node), space),
|
|
.ptr_type => return renderPtrType(gpa, ais, tree, tree.ptrType(node), space),
|
|
.ptr_type_bit_range => return renderPtrType(gpa, ais, tree, tree.ptrTypeBitRange(node), space),
|
|
|
|
.array_init_one, .array_init_one_comma => {
|
|
var elements: [1]ast.Node.Index = undefined;
|
|
return renderArrayInit(gpa, ais, tree, tree.arrayInitOne(&elements, node), space);
|
|
},
|
|
.array_init_dot_two, .array_init_dot_two_comma => {
|
|
var elements: [2]ast.Node.Index = undefined;
|
|
return renderArrayInit(gpa, ais, tree, tree.arrayInitDotTwo(&elements, node), space);
|
|
},
|
|
.array_init_dot,
|
|
.array_init_dot_comma,
|
|
=> return renderArrayInit(gpa, ais, tree, tree.arrayInitDot(node), space),
|
|
.array_init,
|
|
.array_init_comma,
|
|
=> return renderArrayInit(gpa, ais, tree, tree.arrayInit(node), space),
|
|
|
|
.struct_init_one, .struct_init_one_comma => {
|
|
var fields: [1]ast.Node.Index = undefined;
|
|
return renderStructInit(gpa, ais, tree, node, tree.structInitOne(&fields, node), space);
|
|
},
|
|
.struct_init_dot_two, .struct_init_dot_two_comma => {
|
|
var fields: [2]ast.Node.Index = undefined;
|
|
return renderStructInit(gpa, ais, tree, node, tree.structInitDotTwo(&fields, node), space);
|
|
},
|
|
.struct_init_dot,
|
|
.struct_init_dot_comma,
|
|
=> return renderStructInit(gpa, ais, tree, node, tree.structInitDot(node), space),
|
|
.struct_init,
|
|
.struct_init_comma,
|
|
=> return renderStructInit(gpa, ais, tree, node, tree.structInit(node), space),
|
|
|
|
.call_one, .call_one_comma, .async_call_one, .async_call_one_comma => {
|
|
var params: [1]ast.Node.Index = undefined;
|
|
return renderCall(gpa, ais, tree, tree.callOne(¶ms, node), space);
|
|
},
|
|
|
|
.call,
|
|
.call_comma,
|
|
.async_call,
|
|
.async_call_comma,
|
|
=> return renderCall(gpa, ais, tree, tree.callFull(node), space),
|
|
|
|
.array_access => {
|
|
const suffix = datas[node];
|
|
const lbracket = tree.firstToken(suffix.rhs) - 1;
|
|
const rbracket = tree.lastToken(suffix.rhs) + 1;
|
|
const one_line = tree.tokensOnSameLine(lbracket, rbracket);
|
|
const inner_space = if (one_line) Space.none else Space.newline;
|
|
try renderExpression(gpa, ais, tree, suffix.lhs, .none);
|
|
ais.pushIndentNextLine();
|
|
try renderToken(ais, tree, lbracket, inner_space); // [
|
|
try renderExpression(gpa, ais, tree, suffix.rhs, inner_space);
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, rbracket, space); // ]
|
|
},
|
|
|
|
.slice_open => return renderSlice(gpa, ais, tree, tree.sliceOpen(node), space),
|
|
.slice => return renderSlice(gpa, ais, tree, tree.slice(node), space),
|
|
.slice_sentinel => return renderSlice(gpa, ais, tree, tree.sliceSentinel(node), space),
|
|
|
|
.deref => {
|
|
try renderExpression(gpa, ais, tree, datas[node].lhs, .none);
|
|
return renderToken(ais, tree, main_tokens[node], space);
|
|
},
|
|
|
|
.unwrap_optional => {
|
|
try renderExpression(gpa, ais, tree, datas[node].lhs, .none);
|
|
try renderToken(ais, tree, main_tokens[node], .none);
|
|
return renderToken(ais, tree, datas[node].rhs, space);
|
|
},
|
|
|
|
.@"break" => {
|
|
const main_token = main_tokens[node];
|
|
const label_token = datas[node].lhs;
|
|
const target = datas[node].rhs;
|
|
if (label_token == 0 and target == 0) {
|
|
try renderToken(ais, tree, main_token, space); // break keyword
|
|
} else if (label_token == 0 and target != 0) {
|
|
try renderToken(ais, tree, main_token, .space); // break keyword
|
|
try renderExpression(gpa, ais, tree, target, space);
|
|
} else if (label_token != 0 and target == 0) {
|
|
try renderToken(ais, tree, main_token, .space); // break keyword
|
|
try renderToken(ais, tree, label_token - 1, .none); // colon
|
|
try renderToken(ais, tree, label_token, space); // identifier
|
|
} else if (label_token != 0 and target != 0) {
|
|
try renderToken(ais, tree, main_token, .space); // break keyword
|
|
try renderToken(ais, tree, label_token - 1, .none); // colon
|
|
try renderToken(ais, tree, label_token, .space); // identifier
|
|
try renderExpression(gpa, ais, tree, target, space);
|
|
}
|
|
},
|
|
|
|
.@"continue" => {
|
|
const main_token = main_tokens[node];
|
|
const label = datas[node].lhs;
|
|
if (label != 0) {
|
|
try renderToken(ais, tree, main_token, .space); // continue
|
|
try renderToken(ais, tree, label - 1, .none); // :
|
|
return renderToken(ais, tree, label, space); // label
|
|
} else {
|
|
return renderToken(ais, tree, main_token, space); // continue
|
|
}
|
|
},
|
|
|
|
.@"return" => {
|
|
if (datas[node].lhs != 0) {
|
|
try renderToken(ais, tree, main_tokens[node], .space);
|
|
try renderExpression(gpa, ais, tree, datas[node].lhs, space);
|
|
} else {
|
|
try renderToken(ais, tree, main_tokens[node], space);
|
|
}
|
|
},
|
|
|
|
.grouped_expression => {
|
|
try renderToken(ais, tree, main_tokens[node], .none); // lparen
|
|
ais.pushIndentOneShot();
|
|
try renderExpression(gpa, ais, tree, datas[node].lhs, .none);
|
|
return renderToken(ais, tree, datas[node].rhs, space); // rparen
|
|
},
|
|
|
|
.container_decl,
|
|
.container_decl_trailing,
|
|
=> return renderContainerDecl(gpa, ais, tree, node, tree.containerDecl(node), space),
|
|
|
|
.container_decl_two, .container_decl_two_trailing => {
|
|
var buffer: [2]ast.Node.Index = undefined;
|
|
return renderContainerDecl(gpa, ais, tree, node, tree.containerDeclTwo(&buffer, node), space);
|
|
},
|
|
.container_decl_arg,
|
|
.container_decl_arg_trailing,
|
|
=> return renderContainerDecl(gpa, ais, tree, node, tree.containerDeclArg(node), space),
|
|
|
|
.tagged_union,
|
|
.tagged_union_trailing,
|
|
=> return renderContainerDecl(gpa, ais, tree, node, tree.taggedUnion(node), space),
|
|
|
|
.tagged_union_two, .tagged_union_two_trailing => {
|
|
var buffer: [2]ast.Node.Index = undefined;
|
|
return renderContainerDecl(gpa, ais, tree, node, tree.taggedUnionTwo(&buffer, node), space);
|
|
},
|
|
.tagged_union_enum_tag,
|
|
.tagged_union_enum_tag_trailing,
|
|
=> return renderContainerDecl(gpa, ais, tree, node, tree.taggedUnionEnumTag(node), space),
|
|
|
|
.error_set_decl => {
|
|
const error_token = main_tokens[node];
|
|
const lbrace = error_token + 1;
|
|
const rbrace = datas[node].rhs;
|
|
|
|
try renderToken(ais, tree, error_token, .none);
|
|
|
|
if (lbrace + 1 == rbrace) {
|
|
// There is nothing between the braces so render condensed: `error{}`
|
|
try renderToken(ais, tree, lbrace, .none);
|
|
return renderToken(ais, tree, rbrace, space);
|
|
} else if (lbrace + 2 == rbrace and token_tags[lbrace + 1] == .identifier) {
|
|
// There is exactly one member and no trailing comma or
|
|
// comments, so render without surrounding spaces: `error{Foo}`
|
|
try renderToken(ais, tree, lbrace, .none);
|
|
try renderToken(ais, tree, lbrace + 1, .none); // identifier
|
|
return renderToken(ais, tree, rbrace, space);
|
|
} else if (token_tags[rbrace - 1] == .comma) {
|
|
// There is a trailing comma so render each member on a new line.
|
|
ais.pushIndentNextLine();
|
|
try renderToken(ais, tree, lbrace, .newline);
|
|
var i = lbrace + 1;
|
|
while (i < rbrace) : (i += 1) {
|
|
if (i > lbrace + 1) try renderExtraNewlineToken(ais, tree, i);
|
|
switch (token_tags[i]) {
|
|
.doc_comment => try renderToken(ais, tree, i, .newline),
|
|
.identifier => try renderToken(ais, tree, i, .comma),
|
|
.comma => {},
|
|
else => unreachable,
|
|
}
|
|
}
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, rbrace, space);
|
|
} else {
|
|
// There is no trailing comma so render everything on one line.
|
|
try renderToken(ais, tree, lbrace, .space);
|
|
var i = lbrace + 1;
|
|
while (i < rbrace) : (i += 1) {
|
|
switch (token_tags[i]) {
|
|
.doc_comment => unreachable, // TODO
|
|
.identifier => try renderToken(ais, tree, i, .comma_space),
|
|
.comma => {},
|
|
else => unreachable,
|
|
}
|
|
}
|
|
return renderToken(ais, tree, rbrace, space);
|
|
}
|
|
},
|
|
|
|
.builtin_call_two, .builtin_call_two_comma => {
|
|
if (datas[node].lhs == 0) {
|
|
return renderBuiltinCall(gpa, ais, tree, main_tokens[node], &.{}, space);
|
|
} else if (datas[node].rhs == 0) {
|
|
return renderBuiltinCall(gpa, ais, tree, main_tokens[node], &.{datas[node].lhs}, space);
|
|
} else {
|
|
return renderBuiltinCall(gpa, ais, tree, main_tokens[node], &.{ datas[node].lhs, datas[node].rhs }, space);
|
|
}
|
|
},
|
|
.builtin_call, .builtin_call_comma => {
|
|
const params = tree.extra_data[datas[node].lhs..datas[node].rhs];
|
|
return renderBuiltinCall(gpa, ais, tree, main_tokens[node], params, space);
|
|
},
|
|
|
|
.fn_proto_simple => {
|
|
var params: [1]ast.Node.Index = undefined;
|
|
return renderFnProto(gpa, ais, tree, tree.fnProtoSimple(¶ms, node), space);
|
|
},
|
|
.fn_proto_multi => return renderFnProto(gpa, ais, tree, tree.fnProtoMulti(node), space),
|
|
.fn_proto_one => {
|
|
var params: [1]ast.Node.Index = undefined;
|
|
return renderFnProto(gpa, ais, tree, tree.fnProtoOne(¶ms, node), space);
|
|
},
|
|
.fn_proto => return renderFnProto(gpa, ais, tree, tree.fnProto(node), space),
|
|
|
|
.anyframe_type => {
|
|
const main_token = main_tokens[node];
|
|
if (datas[node].rhs != 0) {
|
|
try renderToken(ais, tree, main_token, .none); // anyframe
|
|
try renderToken(ais, tree, main_token + 1, .none); // ->
|
|
return renderExpression(gpa, ais, tree, datas[node].rhs, space);
|
|
} else {
|
|
return renderToken(ais, tree, main_token, space); // anyframe
|
|
}
|
|
},
|
|
|
|
.@"switch",
|
|
.switch_comma,
|
|
=> {
|
|
const switch_token = main_tokens[node];
|
|
const condition = datas[node].lhs;
|
|
const extra = tree.extraData(datas[node].rhs, ast.Node.SubRange);
|
|
const cases = tree.extra_data[extra.start..extra.end];
|
|
const rparen = tree.lastToken(condition) + 1;
|
|
|
|
try renderToken(ais, tree, switch_token, .space); // switch keyword
|
|
try renderToken(ais, tree, switch_token + 1, .none); // lparen
|
|
try renderExpression(gpa, ais, tree, condition, .none); // condtion expression
|
|
try renderToken(ais, tree, rparen, .space); // rparen
|
|
|
|
ais.pushIndentNextLine();
|
|
if (cases.len == 0) {
|
|
try renderToken(ais, tree, rparen + 1, .none); // lbrace
|
|
} else {
|
|
try renderToken(ais, tree, rparen + 1, .newline); // lbrace
|
|
try renderExpressions(gpa, ais, tree, cases, .comma);
|
|
}
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, tree.lastToken(node), space); // rbrace
|
|
},
|
|
|
|
.switch_case_one => return renderSwitchCase(gpa, ais, tree, tree.switchCaseOne(node), space),
|
|
.switch_case => return renderSwitchCase(gpa, ais, tree, tree.switchCase(node), space),
|
|
|
|
.while_simple => return renderWhile(gpa, ais, tree, tree.whileSimple(node), space),
|
|
.while_cont => return renderWhile(gpa, ais, tree, tree.whileCont(node), space),
|
|
.@"while" => return renderWhile(gpa, ais, tree, tree.whileFull(node), space),
|
|
.for_simple => return renderWhile(gpa, ais, tree, tree.forSimple(node), space),
|
|
.@"for" => return renderWhile(gpa, ais, tree, tree.forFull(node), space),
|
|
|
|
.if_simple => return renderIf(gpa, ais, tree, tree.ifSimple(node), space),
|
|
.@"if" => return renderIf(gpa, ais, tree, tree.ifFull(node), space),
|
|
|
|
.asm_simple => return renderAsm(gpa, ais, tree, tree.asmSimple(node), space),
|
|
.@"asm" => return renderAsm(gpa, ais, tree, tree.asmFull(node), space),
|
|
|
|
.enum_literal => {
|
|
try renderToken(ais, tree, main_tokens[node] - 1, .none); // .
|
|
return renderToken(ais, tree, main_tokens[node], space); // name
|
|
},
|
|
|
|
.fn_decl => unreachable,
|
|
.container_field => unreachable,
|
|
.container_field_init => unreachable,
|
|
.container_field_align => unreachable,
|
|
.root => unreachable,
|
|
.global_var_decl => unreachable,
|
|
.local_var_decl => unreachable,
|
|
.simple_var_decl => unreachable,
|
|
.aligned_var_decl => unreachable,
|
|
.@"usingnamespace" => unreachable,
|
|
.test_decl => unreachable,
|
|
.asm_output => unreachable,
|
|
.asm_input => unreachable,
|
|
}
|
|
}
|
|
|
|
fn renderArrayType(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
array_type: ast.full.ArrayType,
|
|
space: Space,
|
|
) Error!void {
|
|
const rbracket = tree.firstToken(array_type.ast.elem_type) - 1;
|
|
const one_line = tree.tokensOnSameLine(array_type.ast.lbracket, rbracket);
|
|
const inner_space = if (one_line) Space.none else Space.newline;
|
|
ais.pushIndentNextLine();
|
|
try renderToken(ais, tree, array_type.ast.lbracket, inner_space); // lbracket
|
|
try renderExpression(gpa, ais, tree, array_type.ast.elem_count, inner_space);
|
|
if (array_type.ast.sentinel) |sentinel| {
|
|
try renderToken(ais, tree, tree.firstToken(sentinel) - 1, inner_space); // colon
|
|
try renderExpression(gpa, ais, tree, sentinel, inner_space);
|
|
}
|
|
ais.popIndent();
|
|
try renderToken(ais, tree, rbracket, .none); // rbracket
|
|
return renderExpression(gpa, ais, tree, array_type.ast.elem_type, space);
|
|
}
|
|
|
|
fn renderPtrType(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
ptr_type: ast.full.PtrType,
|
|
space: Space,
|
|
) Error!void {
|
|
switch (ptr_type.size) {
|
|
.One => {
|
|
// Since ** tokens exist and the same token is shared by two
|
|
// nested pointer types, we check to see if we are the parent
|
|
// in such a relationship. If so, skip rendering anything for
|
|
// this pointer type and rely on the child to render our asterisk
|
|
// as well when it renders the ** token.
|
|
if (tree.tokens.items(.tag)[ptr_type.ast.main_token] == .asterisk_asterisk and
|
|
ptr_type.ast.main_token == tree.nodes.items(.main_token)[ptr_type.ast.child_type])
|
|
{
|
|
return renderExpression(gpa, ais, tree, ptr_type.ast.child_type, space);
|
|
}
|
|
try renderToken(ais, tree, ptr_type.ast.main_token, .none); // asterisk
|
|
},
|
|
.Many => {
|
|
if (ptr_type.ast.sentinel == 0) {
|
|
try renderToken(ais, tree, ptr_type.ast.main_token - 1, .none); // lbracket
|
|
try renderToken(ais, tree, ptr_type.ast.main_token, .none); // asterisk
|
|
try renderToken(ais, tree, ptr_type.ast.main_token + 1, .none); // rbracket
|
|
} else {
|
|
try renderToken(ais, tree, ptr_type.ast.main_token - 1, .none); // lbracket
|
|
try renderToken(ais, tree, ptr_type.ast.main_token, .none); // asterisk
|
|
try renderToken(ais, tree, ptr_type.ast.main_token + 1, .none); // colon
|
|
try renderExpression(gpa, ais, tree, ptr_type.ast.sentinel, .none);
|
|
try renderToken(ais, tree, tree.lastToken(ptr_type.ast.sentinel) + 1, .none); // rbracket
|
|
}
|
|
},
|
|
.C => {
|
|
try renderToken(ais, tree, ptr_type.ast.main_token - 1, .none); // lbracket
|
|
try renderToken(ais, tree, ptr_type.ast.main_token, .none); // asterisk
|
|
try renderToken(ais, tree, ptr_type.ast.main_token + 1, .none); // c
|
|
try renderToken(ais, tree, ptr_type.ast.main_token + 2, .none); // rbracket
|
|
},
|
|
.Slice => {
|
|
if (ptr_type.ast.sentinel == 0) {
|
|
try renderToken(ais, tree, ptr_type.ast.main_token, .none); // lbracket
|
|
try renderToken(ais, tree, ptr_type.ast.main_token + 1, .none); // rbracket
|
|
} else {
|
|
try renderToken(ais, tree, ptr_type.ast.main_token, .none); // lbracket
|
|
try renderToken(ais, tree, ptr_type.ast.main_token + 1, .none); // colon
|
|
try renderExpression(gpa, ais, tree, ptr_type.ast.sentinel, .none);
|
|
try renderToken(ais, tree, tree.lastToken(ptr_type.ast.sentinel) + 1, .none); // rbracket
|
|
}
|
|
},
|
|
}
|
|
|
|
if (ptr_type.allowzero_token) |allowzero_token| {
|
|
try renderToken(ais, tree, allowzero_token, .space);
|
|
}
|
|
|
|
if (ptr_type.ast.align_node != 0) {
|
|
const align_first = tree.firstToken(ptr_type.ast.align_node);
|
|
try renderToken(ais, tree, align_first - 2, .none); // align
|
|
try renderToken(ais, tree, align_first - 1, .none); // lparen
|
|
try renderExpression(gpa, ais, tree, ptr_type.ast.align_node, .none);
|
|
if (ptr_type.ast.bit_range_start != 0) {
|
|
assert(ptr_type.ast.bit_range_end != 0);
|
|
try renderToken(ais, tree, tree.firstToken(ptr_type.ast.bit_range_start) - 1, .none); // colon
|
|
try renderExpression(gpa, ais, tree, ptr_type.ast.bit_range_start, .none);
|
|
try renderToken(ais, tree, tree.firstToken(ptr_type.ast.bit_range_end) - 1, .none); // colon
|
|
try renderExpression(gpa, ais, tree, ptr_type.ast.bit_range_end, .none);
|
|
try renderToken(ais, tree, tree.lastToken(ptr_type.ast.bit_range_end) + 1, .space); // rparen
|
|
} else {
|
|
try renderToken(ais, tree, tree.lastToken(ptr_type.ast.align_node) + 1, .space); // rparen
|
|
}
|
|
}
|
|
|
|
if (ptr_type.const_token) |const_token| {
|
|
try renderToken(ais, tree, const_token, .space);
|
|
}
|
|
|
|
if (ptr_type.volatile_token) |volatile_token| {
|
|
try renderToken(ais, tree, volatile_token, .space);
|
|
}
|
|
|
|
try renderExpression(gpa, ais, tree, ptr_type.ast.child_type, space);
|
|
}
|
|
|
|
fn renderSlice(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
slice: ast.full.Slice,
|
|
space: Space,
|
|
) Error!void {
|
|
const node_tags = tree.nodes.items(.tag);
|
|
const after_start_space_bool = nodeCausesSliceOpSpace(node_tags[slice.ast.start]) or
|
|
if (slice.ast.end != 0) nodeCausesSliceOpSpace(node_tags[slice.ast.end]) else false;
|
|
const after_start_space = if (after_start_space_bool) Space.space else Space.none;
|
|
const after_dots_space = if (slice.ast.end != 0) after_start_space else Space.none;
|
|
|
|
try renderExpression(gpa, ais, tree, slice.ast.sliced, .none);
|
|
try renderToken(ais, tree, slice.ast.lbracket, .none); // lbracket
|
|
|
|
const start_last = tree.lastToken(slice.ast.start);
|
|
try renderExpression(gpa, ais, tree, slice.ast.start, after_start_space);
|
|
try renderToken(ais, tree, start_last + 1, after_dots_space); // ellipsis2 ("..")
|
|
if (slice.ast.end == 0) {
|
|
return renderToken(ais, tree, start_last + 2, space); // rbracket
|
|
}
|
|
|
|
const end_last = tree.lastToken(slice.ast.end);
|
|
const after_end_space = if (slice.ast.sentinel != 0) Space.space else Space.none;
|
|
try renderExpression(gpa, ais, tree, slice.ast.end, after_end_space);
|
|
if (slice.ast.sentinel == 0) {
|
|
return renderToken(ais, tree, end_last + 1, space); // rbracket
|
|
}
|
|
|
|
try renderToken(ais, tree, end_last + 1, .none); // colon
|
|
try renderExpression(gpa, ais, tree, slice.ast.sentinel, .none);
|
|
try renderToken(ais, tree, tree.lastToken(slice.ast.sentinel) + 1, space); // rbracket
|
|
}
|
|
|
|
fn renderAsmOutput(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
asm_output: ast.Node.Index,
|
|
space: Space,
|
|
) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const node_tags = tree.nodes.items(.tag);
|
|
const main_tokens = tree.nodes.items(.main_token);
|
|
const datas = tree.nodes.items(.data);
|
|
assert(node_tags[asm_output] == .asm_output);
|
|
const symbolic_name = main_tokens[asm_output];
|
|
|
|
try renderToken(ais, tree, symbolic_name - 1, .none); // lbracket
|
|
try renderToken(ais, tree, symbolic_name, .none); // ident
|
|
try renderToken(ais, tree, symbolic_name + 1, .space); // rbracket
|
|
try renderToken(ais, tree, symbolic_name + 2, .space); // "constraint"
|
|
try renderToken(ais, tree, symbolic_name + 3, .none); // lparen
|
|
|
|
if (token_tags[symbolic_name + 4] == .arrow) {
|
|
try renderToken(ais, tree, symbolic_name + 4, .space); // ->
|
|
try renderExpression(gpa, ais, tree, datas[asm_output].lhs, Space.none);
|
|
return renderToken(ais, tree, datas[asm_output].rhs, space); // rparen
|
|
} else {
|
|
try renderToken(ais, tree, symbolic_name + 4, .none); // ident
|
|
return renderToken(ais, tree, symbolic_name + 5, space); // rparen
|
|
}
|
|
}
|
|
|
|
fn renderAsmInput(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
asm_input: ast.Node.Index,
|
|
space: Space,
|
|
) Error!void {
|
|
const node_tags = tree.nodes.items(.tag);
|
|
const main_tokens = tree.nodes.items(.main_token);
|
|
const datas = tree.nodes.items(.data);
|
|
assert(node_tags[asm_input] == .asm_input);
|
|
const symbolic_name = main_tokens[asm_input];
|
|
|
|
try renderToken(ais, tree, symbolic_name - 1, .none); // lbracket
|
|
try renderToken(ais, tree, symbolic_name, .none); // ident
|
|
try renderToken(ais, tree, symbolic_name + 1, .space); // rbracket
|
|
try renderToken(ais, tree, symbolic_name + 2, .space); // "constraint"
|
|
try renderToken(ais, tree, symbolic_name + 3, .none); // lparen
|
|
try renderExpression(gpa, ais, tree, datas[asm_input].lhs, Space.none);
|
|
return renderToken(ais, tree, datas[asm_input].rhs, space); // rparen
|
|
}
|
|
|
|
fn renderVarDecl(gpa: *Allocator, ais: *Ais, tree: ast.Tree, var_decl: ast.full.VarDecl) Error!void {
|
|
if (var_decl.visib_token) |visib_token| {
|
|
try renderToken(ais, tree, visib_token, Space.space); // pub
|
|
}
|
|
|
|
if (var_decl.extern_export_token) |extern_export_token| {
|
|
try renderToken(ais, tree, extern_export_token, Space.space); // extern
|
|
|
|
if (var_decl.lib_name) |lib_name| {
|
|
try renderToken(ais, tree, lib_name, Space.space); // "lib"
|
|
}
|
|
}
|
|
|
|
if (var_decl.threadlocal_token) |thread_local_token| {
|
|
try renderToken(ais, tree, thread_local_token, Space.space); // threadlocal
|
|
}
|
|
|
|
if (var_decl.comptime_token) |comptime_token| {
|
|
try renderToken(ais, tree, comptime_token, Space.space); // comptime
|
|
}
|
|
|
|
try renderToken(ais, tree, var_decl.ast.mut_token, .space); // var
|
|
|
|
const name_space = if (var_decl.ast.type_node == 0 and
|
|
(var_decl.ast.align_node != 0 or
|
|
var_decl.ast.section_node != 0 or
|
|
var_decl.ast.init_node != 0))
|
|
Space.space
|
|
else
|
|
Space.none;
|
|
try renderToken(ais, tree, var_decl.ast.mut_token + 1, name_space); // name
|
|
|
|
if (var_decl.ast.type_node != 0) {
|
|
try renderToken(ais, tree, var_decl.ast.mut_token + 2, Space.space); // :
|
|
if (var_decl.ast.align_node != 0 or var_decl.ast.section_node != 0 or
|
|
var_decl.ast.init_node != 0)
|
|
{
|
|
try renderExpression(gpa, ais, tree, var_decl.ast.type_node, .space);
|
|
} else {
|
|
try renderExpression(gpa, ais, tree, var_decl.ast.type_node, .none);
|
|
const semicolon = tree.lastToken(var_decl.ast.type_node) + 1;
|
|
return renderToken(ais, tree, semicolon, Space.newline); // ;
|
|
}
|
|
}
|
|
|
|
if (var_decl.ast.align_node != 0) {
|
|
const lparen = tree.firstToken(var_decl.ast.align_node) - 1;
|
|
const align_kw = lparen - 1;
|
|
const rparen = tree.lastToken(var_decl.ast.align_node) + 1;
|
|
try renderToken(ais, tree, align_kw, Space.none); // align
|
|
try renderToken(ais, tree, lparen, Space.none); // (
|
|
try renderExpression(gpa, ais, tree, var_decl.ast.align_node, Space.none);
|
|
if (var_decl.ast.section_node != 0 or var_decl.ast.init_node != 0) {
|
|
try renderToken(ais, tree, rparen, .space); // )
|
|
} else {
|
|
try renderToken(ais, tree, rparen, .none); // )
|
|
return renderToken(ais, tree, rparen + 1, Space.newline); // ;
|
|
}
|
|
}
|
|
|
|
if (var_decl.ast.section_node != 0) {
|
|
const lparen = tree.firstToken(var_decl.ast.section_node) - 1;
|
|
const section_kw = lparen - 1;
|
|
const rparen = tree.lastToken(var_decl.ast.section_node) + 1;
|
|
try renderToken(ais, tree, section_kw, Space.none); // linksection
|
|
try renderToken(ais, tree, lparen, Space.none); // (
|
|
try renderExpression(gpa, ais, tree, var_decl.ast.section_node, Space.none);
|
|
if (var_decl.ast.init_node != 0) {
|
|
try renderToken(ais, tree, rparen, .space); // )
|
|
} else {
|
|
try renderToken(ais, tree, rparen, .none); // )
|
|
return renderToken(ais, tree, rparen + 1, Space.newline); // ;
|
|
}
|
|
}
|
|
|
|
assert(var_decl.ast.init_node != 0);
|
|
const eq_token = tree.firstToken(var_decl.ast.init_node) - 1;
|
|
const eq_space: Space = if (tree.tokensOnSameLine(eq_token, eq_token + 1)) .space else .newline;
|
|
{
|
|
ais.pushIndent();
|
|
try renderToken(ais, tree, eq_token, eq_space); // =
|
|
ais.popIndent();
|
|
}
|
|
ais.pushIndentOneShot();
|
|
try renderExpression(gpa, ais, tree, var_decl.ast.init_node, .semicolon);
|
|
}
|
|
|
|
fn renderIf(gpa: *Allocator, ais: *Ais, tree: ast.Tree, if_node: ast.full.If, space: Space) Error!void {
|
|
return renderWhile(gpa, ais, tree, .{
|
|
.ast = .{
|
|
.while_token = if_node.ast.if_token,
|
|
.cond_expr = if_node.ast.cond_expr,
|
|
.cont_expr = 0,
|
|
.then_expr = if_node.ast.then_expr,
|
|
.else_expr = if_node.ast.else_expr,
|
|
},
|
|
.inline_token = null,
|
|
.label_token = null,
|
|
.payload_token = if_node.payload_token,
|
|
.else_token = if_node.else_token,
|
|
.error_token = if_node.error_token,
|
|
}, space);
|
|
}
|
|
|
|
/// Note that this function is additionally used to render if and for expressions, with
|
|
/// respective values set to null.
|
|
fn renderWhile(gpa: *Allocator, ais: *Ais, tree: ast.Tree, while_node: ast.full.While, space: Space) Error!void {
|
|
const node_tags = tree.nodes.items(.tag);
|
|
const token_tags = tree.tokens.items(.tag);
|
|
|
|
if (while_node.label_token) |label| {
|
|
try renderToken(ais, tree, label, .none); // label
|
|
try renderToken(ais, tree, label + 1, .space); // :
|
|
}
|
|
|
|
if (while_node.inline_token) |inline_token| {
|
|
try renderToken(ais, tree, inline_token, .space); // inline
|
|
}
|
|
|
|
try renderToken(ais, tree, while_node.ast.while_token, .space); // if
|
|
try renderToken(ais, tree, while_node.ast.while_token + 1, .none); // lparen
|
|
try renderExpression(gpa, ais, tree, while_node.ast.cond_expr, .none); // condition
|
|
|
|
const then_tag = node_tags[while_node.ast.then_expr];
|
|
if (nodeIsBlock(then_tag) and !nodeIsIf(then_tag)) {
|
|
if (while_node.payload_token) |payload_token| {
|
|
try renderToken(ais, tree, payload_token - 2, .space); // rparen
|
|
try renderToken(ais, tree, payload_token - 1, .none); // |
|
|
const ident = blk: {
|
|
if (token_tags[payload_token] == .asterisk) {
|
|
try renderToken(ais, tree, payload_token, .none); // *
|
|
break :blk payload_token + 1;
|
|
} else {
|
|
break :blk payload_token;
|
|
}
|
|
};
|
|
try renderToken(ais, tree, ident, .none); // identifier
|
|
const pipe = blk: {
|
|
if (token_tags[ident + 1] == .comma) {
|
|
try renderToken(ais, tree, ident + 1, .space); // ,
|
|
try renderToken(ais, tree, ident + 2, .none); // index
|
|
break :blk ident + 3;
|
|
} else {
|
|
break :blk ident + 1;
|
|
}
|
|
};
|
|
const brace_space = if (while_node.ast.cont_expr == 0 and ais.isLineOverIndented())
|
|
Space.newline
|
|
else
|
|
Space.space;
|
|
try renderToken(ais, tree, pipe, brace_space); // |
|
|
} else {
|
|
const rparen = tree.lastToken(while_node.ast.cond_expr) + 1;
|
|
const brace_space = if (while_node.ast.cont_expr == 0 and ais.isLineOverIndented())
|
|
Space.newline
|
|
else
|
|
Space.space;
|
|
try renderToken(ais, tree, rparen, brace_space); // rparen
|
|
}
|
|
if (while_node.ast.cont_expr != 0) {
|
|
const rparen = tree.lastToken(while_node.ast.cont_expr) + 1;
|
|
const lparen = tree.firstToken(while_node.ast.cont_expr) - 1;
|
|
try renderToken(ais, tree, lparen - 1, .space); // :
|
|
try renderToken(ais, tree, lparen, .none); // lparen
|
|
try renderExpression(gpa, ais, tree, while_node.ast.cont_expr, .none);
|
|
const brace_space: Space = if (ais.isLineOverIndented()) .newline else .space;
|
|
try renderToken(ais, tree, rparen, brace_space); // rparen
|
|
}
|
|
if (while_node.ast.else_expr != 0) {
|
|
try renderExpression(gpa, ais, tree, while_node.ast.then_expr, Space.space);
|
|
try renderToken(ais, tree, while_node.else_token, .space); // else
|
|
if (while_node.error_token) |error_token| {
|
|
try renderToken(ais, tree, error_token - 1, .none); // |
|
|
try renderToken(ais, tree, error_token, .none); // identifier
|
|
try renderToken(ais, tree, error_token + 1, .space); // |
|
|
}
|
|
return renderExpression(gpa, ais, tree, while_node.ast.else_expr, space);
|
|
} else {
|
|
return renderExpression(gpa, ais, tree, while_node.ast.then_expr, space);
|
|
}
|
|
}
|
|
|
|
const rparen = tree.lastToken(while_node.ast.cond_expr) + 1;
|
|
const last_then_token = tree.lastToken(while_node.ast.then_expr);
|
|
const src_has_newline = !tree.tokensOnSameLine(rparen, last_then_token);
|
|
|
|
if (src_has_newline) {
|
|
if (while_node.payload_token) |payload_token| {
|
|
try renderToken(ais, tree, payload_token - 2, .space); // rparen
|
|
try renderToken(ais, tree, payload_token - 1, .none); // |
|
|
const ident = blk: {
|
|
if (token_tags[payload_token] == .asterisk) {
|
|
try renderToken(ais, tree, payload_token, .none); // *
|
|
break :blk payload_token + 1;
|
|
} else {
|
|
break :blk payload_token;
|
|
}
|
|
};
|
|
try renderToken(ais, tree, ident, .none); // identifier
|
|
const pipe = blk: {
|
|
if (token_tags[ident + 1] == .comma) {
|
|
try renderToken(ais, tree, ident + 1, .space); // ,
|
|
try renderToken(ais, tree, ident + 2, .none); // index
|
|
break :blk ident + 3;
|
|
} else {
|
|
break :blk ident + 1;
|
|
}
|
|
};
|
|
const after_space: Space = if (while_node.ast.cont_expr != 0) .space else .newline;
|
|
try renderToken(ais, tree, pipe, after_space); // |
|
|
} else {
|
|
ais.pushIndent();
|
|
const after_space: Space = if (while_node.ast.cont_expr != 0) .space else .newline;
|
|
try renderToken(ais, tree, rparen, after_space); // rparen
|
|
ais.popIndent();
|
|
}
|
|
if (while_node.ast.cont_expr != 0) {
|
|
const cont_rparen = tree.lastToken(while_node.ast.cont_expr) + 1;
|
|
const cont_lparen = tree.firstToken(while_node.ast.cont_expr) - 1;
|
|
try renderToken(ais, tree, cont_lparen - 1, .space); // :
|
|
try renderToken(ais, tree, cont_lparen, .none); // lparen
|
|
try renderExpression(gpa, ais, tree, while_node.ast.cont_expr, .none);
|
|
try renderToken(ais, tree, cont_rparen, .newline); // rparen
|
|
}
|
|
if (while_node.ast.else_expr != 0) {
|
|
ais.pushIndent();
|
|
try renderExpression(gpa, ais, tree, while_node.ast.then_expr, Space.newline);
|
|
ais.popIndent();
|
|
const else_is_block = nodeIsBlock(node_tags[while_node.ast.else_expr]);
|
|
if (else_is_block) {
|
|
try renderToken(ais, tree, while_node.else_token, .space); // else
|
|
if (while_node.error_token) |error_token| {
|
|
try renderToken(ais, tree, error_token - 1, .none); // |
|
|
try renderToken(ais, tree, error_token, .none); // identifier
|
|
try renderToken(ais, tree, error_token + 1, .space); // |
|
|
}
|
|
return renderExpression(gpa, ais, tree, while_node.ast.else_expr, space);
|
|
} else {
|
|
if (while_node.error_token) |error_token| {
|
|
try renderToken(ais, tree, while_node.else_token, .space); // else
|
|
try renderToken(ais, tree, error_token - 1, .none); // |
|
|
try renderToken(ais, tree, error_token, .none); // identifier
|
|
try renderToken(ais, tree, error_token + 1, .space); // |
|
|
} else {
|
|
try renderToken(ais, tree, while_node.else_token, .newline); // else
|
|
}
|
|
try renderExpressionIndented(gpa, ais, tree, while_node.ast.else_expr, space);
|
|
return;
|
|
}
|
|
} else {
|
|
try renderExpressionIndented(gpa, ais, tree, while_node.ast.then_expr, space);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Render everything on a single line.
|
|
|
|
if (while_node.payload_token) |payload_token| {
|
|
assert(payload_token - 2 == rparen);
|
|
try renderToken(ais, tree, payload_token - 2, .space); // )
|
|
try renderToken(ais, tree, payload_token - 1, .none); // |
|
|
const ident = blk: {
|
|
if (token_tags[payload_token] == .asterisk) {
|
|
try renderToken(ais, tree, payload_token, .none); // *
|
|
break :blk payload_token + 1;
|
|
} else {
|
|
break :blk payload_token;
|
|
}
|
|
};
|
|
try renderToken(ais, tree, ident, .none); // identifier
|
|
const pipe = blk: {
|
|
if (token_tags[ident + 1] == .comma) {
|
|
try renderToken(ais, tree, ident + 1, .space); // ,
|
|
try renderToken(ais, tree, ident + 2, .none); // index
|
|
break :blk ident + 3;
|
|
} else {
|
|
break :blk ident + 1;
|
|
}
|
|
};
|
|
try renderToken(ais, tree, pipe, .space); // |
|
|
} else {
|
|
try renderToken(ais, tree, rparen, .space); // )
|
|
}
|
|
|
|
if (while_node.ast.cont_expr != 0) {
|
|
const cont_rparen = tree.lastToken(while_node.ast.cont_expr) + 1;
|
|
const cont_lparen = tree.firstToken(while_node.ast.cont_expr) - 1;
|
|
try renderToken(ais, tree, cont_lparen - 1, .space); // :
|
|
try renderToken(ais, tree, cont_lparen, .none); // lparen
|
|
try renderExpression(gpa, ais, tree, while_node.ast.cont_expr, .none);
|
|
try renderToken(ais, tree, cont_rparen, .space); // rparen
|
|
}
|
|
|
|
if (while_node.ast.else_expr != 0) {
|
|
try renderExpression(gpa, ais, tree, while_node.ast.then_expr, .space);
|
|
try renderToken(ais, tree, while_node.else_token, .space); // else
|
|
|
|
if (while_node.error_token) |error_token| {
|
|
try renderToken(ais, tree, error_token - 1, .none); // |
|
|
try renderToken(ais, tree, error_token, .none); // identifier
|
|
try renderToken(ais, tree, error_token + 1, .space); // |
|
|
}
|
|
|
|
return renderExpression(gpa, ais, tree, while_node.ast.else_expr, space);
|
|
} else {
|
|
return renderExpression(gpa, ais, tree, while_node.ast.then_expr, space);
|
|
}
|
|
}
|
|
|
|
fn renderContainerField(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
field: ast.full.ContainerField,
|
|
space: Space,
|
|
) Error!void {
|
|
const main_tokens = tree.nodes.items(.main_token);
|
|
if (field.comptime_token) |t| {
|
|
try renderToken(ais, tree, t, .space); // comptime
|
|
}
|
|
if (field.ast.type_expr == 0 and field.ast.value_expr == 0) {
|
|
return renderTokenComma(ais, tree, field.ast.name_token, space); // name
|
|
}
|
|
if (field.ast.type_expr != 0 and field.ast.value_expr == 0) {
|
|
try renderToken(ais, tree, field.ast.name_token, .none); // name
|
|
try renderToken(ais, tree, field.ast.name_token + 1, .space); // :
|
|
|
|
if (field.ast.align_expr != 0) {
|
|
try renderExpression(gpa, ais, tree, field.ast.type_expr, .space); // type
|
|
const align_token = tree.firstToken(field.ast.align_expr) - 2;
|
|
try renderToken(ais, tree, align_token, .none); // align
|
|
try renderToken(ais, tree, align_token + 1, .none); // (
|
|
try renderExpression(gpa, ais, tree, field.ast.align_expr, .none); // alignment
|
|
const rparen = tree.lastToken(field.ast.align_expr) + 1;
|
|
return renderTokenComma(ais, tree, rparen, space); // )
|
|
} else {
|
|
return renderExpressionComma(gpa, ais, tree, field.ast.type_expr, space); // type
|
|
}
|
|
}
|
|
if (field.ast.type_expr == 0 and field.ast.value_expr != 0) {
|
|
try renderToken(ais, tree, field.ast.name_token, .space); // name
|
|
try renderToken(ais, tree, field.ast.name_token + 1, .space); // =
|
|
return renderExpressionComma(gpa, ais, tree, field.ast.value_expr, space); // value
|
|
}
|
|
|
|
try renderToken(ais, tree, field.ast.name_token, .none); // name
|
|
try renderToken(ais, tree, field.ast.name_token + 1, .space); // :
|
|
try renderExpression(gpa, ais, tree, field.ast.type_expr, .space); // type
|
|
|
|
if (field.ast.align_expr != 0) {
|
|
const lparen_token = tree.firstToken(field.ast.align_expr) - 1;
|
|
const align_kw = lparen_token - 1;
|
|
const rparen_token = tree.lastToken(field.ast.align_expr) + 1;
|
|
try renderToken(ais, tree, align_kw, .none); // align
|
|
try renderToken(ais, tree, lparen_token, .none); // (
|
|
try renderExpression(gpa, ais, tree, field.ast.align_expr, .none); // alignment
|
|
try renderToken(ais, tree, rparen_token, .space); // )
|
|
}
|
|
const eq_token = tree.firstToken(field.ast.value_expr) - 1;
|
|
try renderToken(ais, tree, eq_token, .space); // =
|
|
return renderExpressionComma(gpa, ais, tree, field.ast.value_expr, space); // value
|
|
}
|
|
|
|
fn renderBuiltinCall(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
builtin_token: ast.TokenIndex,
|
|
params: []const ast.Node.Index,
|
|
space: Space,
|
|
) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
|
|
try renderToken(ais, tree, builtin_token, .none); // @name
|
|
|
|
if (params.len == 0) {
|
|
try renderToken(ais, tree, builtin_token + 1, .none); // (
|
|
return renderToken(ais, tree, builtin_token + 2, space); // )
|
|
}
|
|
|
|
const last_param = params[params.len - 1];
|
|
const after_last_param_token = tree.lastToken(last_param) + 1;
|
|
|
|
if (token_tags[after_last_param_token] != .comma) {
|
|
// Render all on one line, no trailing comma.
|
|
try renderToken(ais, tree, builtin_token + 1, .none); // (
|
|
|
|
for (params) |param_node, i| {
|
|
const first_param_token = tree.firstToken(param_node);
|
|
if (token_tags[first_param_token] == .multiline_string_literal_line or
|
|
hasSameLineComment(tree, first_param_token - 1))
|
|
{
|
|
ais.pushIndentOneShot();
|
|
}
|
|
try renderExpression(gpa, ais, tree, param_node, .none);
|
|
|
|
if (i + 1 < params.len) {
|
|
const comma_token = tree.lastToken(param_node) + 1;
|
|
try renderToken(ais, tree, comma_token, .space); // ,
|
|
}
|
|
}
|
|
return renderToken(ais, tree, after_last_param_token, space); // )
|
|
} else {
|
|
// Render one param per line.
|
|
ais.pushIndent();
|
|
try renderToken(ais, tree, builtin_token + 1, Space.newline); // (
|
|
|
|
for (params) |param_node| {
|
|
try renderExpression(gpa, ais, tree, param_node, .comma);
|
|
}
|
|
ais.popIndent();
|
|
|
|
return renderToken(ais, tree, after_last_param_token + 1, space); // )
|
|
}
|
|
}
|
|
|
|
fn renderFnProto(gpa: *Allocator, ais: *Ais, tree: ast.Tree, fn_proto: ast.full.FnProto, space: Space) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const token_starts = tree.tokens.items(.start);
|
|
|
|
const is_inline = fn_proto.ast.fn_token > 0 and
|
|
token_tags[fn_proto.ast.fn_token - 1] == .keyword_inline;
|
|
|
|
const after_fn_token = fn_proto.ast.fn_token + 1;
|
|
const lparen = if (token_tags[after_fn_token] == .identifier) blk: {
|
|
try renderToken(ais, tree, fn_proto.ast.fn_token, .space); // fn
|
|
try renderToken(ais, tree, after_fn_token, .none); // name
|
|
break :blk after_fn_token + 1;
|
|
} else blk: {
|
|
try renderToken(ais, tree, fn_proto.ast.fn_token, .space); // fn
|
|
break :blk fn_proto.ast.fn_token + 1;
|
|
};
|
|
assert(token_tags[lparen] == .l_paren);
|
|
|
|
const maybe_bang = tree.firstToken(fn_proto.ast.return_type) - 1;
|
|
const rparen = blk: {
|
|
// These may appear in any order, so we have to check the token_starts array
|
|
// to find out which is first.
|
|
var rparen = if (token_tags[maybe_bang] == .bang) maybe_bang - 1 else maybe_bang;
|
|
var smallest_start = token_starts[maybe_bang];
|
|
if (fn_proto.ast.align_expr != 0) {
|
|
const tok = tree.firstToken(fn_proto.ast.align_expr) - 3;
|
|
const start = token_starts[tok];
|
|
if (start < smallest_start) {
|
|
rparen = tok;
|
|
smallest_start = start;
|
|
}
|
|
}
|
|
if (fn_proto.ast.section_expr != 0) {
|
|
const tok = tree.firstToken(fn_proto.ast.section_expr) - 3;
|
|
const start = token_starts[tok];
|
|
if (start < smallest_start) {
|
|
rparen = tok;
|
|
smallest_start = start;
|
|
}
|
|
}
|
|
if (fn_proto.ast.callconv_expr != 0) {
|
|
const tok = tree.firstToken(fn_proto.ast.callconv_expr) - 3;
|
|
const start = token_starts[tok];
|
|
if (start < smallest_start) {
|
|
rparen = tok;
|
|
smallest_start = start;
|
|
}
|
|
}
|
|
break :blk rparen;
|
|
};
|
|
assert(token_tags[rparen] == .r_paren);
|
|
|
|
// The params list is a sparse set that does *not* include anytype or ... parameters.
|
|
|
|
const trailing_comma = token_tags[rparen - 1] == .comma;
|
|
if (!trailing_comma and !hasComment(tree, lparen, rparen)) {
|
|
// Render all on one line, no trailing comma.
|
|
try renderToken(ais, tree, lparen, .none); // (
|
|
|
|
var param_i: usize = 0;
|
|
var last_param_token = lparen;
|
|
while (true) {
|
|
last_param_token += 1;
|
|
switch (token_tags[last_param_token]) {
|
|
.doc_comment => {
|
|
try renderToken(ais, tree, last_param_token, .newline);
|
|
continue;
|
|
},
|
|
.ellipsis3 => {
|
|
try renderToken(ais, tree, last_param_token, .none); // ...
|
|
break;
|
|
},
|
|
.keyword_noalias, .keyword_comptime => {
|
|
try renderToken(ais, tree, last_param_token, .space);
|
|
last_param_token += 1;
|
|
},
|
|
.identifier => {},
|
|
.keyword_anytype => {
|
|
try renderToken(ais, tree, last_param_token, .none); // anytype
|
|
continue;
|
|
},
|
|
.r_paren => break,
|
|
.comma => {
|
|
try renderToken(ais, tree, last_param_token, .space); // ,
|
|
continue;
|
|
},
|
|
else => {}, // Parameter type without a name.
|
|
}
|
|
if (token_tags[last_param_token] == .identifier and
|
|
token_tags[last_param_token + 1] == .colon)
|
|
{
|
|
try renderToken(ais, tree, last_param_token, .none); // name
|
|
last_param_token += 1;
|
|
try renderToken(ais, tree, last_param_token, .space); // :
|
|
last_param_token += 1;
|
|
}
|
|
if (token_tags[last_param_token] == .keyword_anytype) {
|
|
try renderToken(ais, tree, last_param_token, .none); // anytype
|
|
continue;
|
|
}
|
|
const param = fn_proto.ast.params[param_i];
|
|
param_i += 1;
|
|
try renderExpression(gpa, ais, tree, param, .none);
|
|
last_param_token = tree.lastToken(param);
|
|
}
|
|
} else {
|
|
// One param per line.
|
|
ais.pushIndent();
|
|
try renderToken(ais, tree, lparen, .newline); // (
|
|
|
|
var param_i: usize = 0;
|
|
var last_param_token = lparen;
|
|
while (true) {
|
|
last_param_token += 1;
|
|
switch (token_tags[last_param_token]) {
|
|
.doc_comment => {
|
|
try renderToken(ais, tree, last_param_token, .newline);
|
|
continue;
|
|
},
|
|
.ellipsis3 => {
|
|
try renderToken(ais, tree, last_param_token, .comma); // ...
|
|
break;
|
|
},
|
|
.keyword_noalias, .keyword_comptime => {
|
|
try renderToken(ais, tree, last_param_token, .space);
|
|
last_param_token += 1;
|
|
},
|
|
.identifier => {},
|
|
.keyword_anytype => {
|
|
try renderToken(ais, tree, last_param_token, .comma); // anytype
|
|
if (token_tags[last_param_token + 1] == .comma)
|
|
last_param_token += 1;
|
|
continue;
|
|
},
|
|
.r_paren => break,
|
|
else => {}, // Parameter type without a name.
|
|
}
|
|
if (token_tags[last_param_token] == .identifier and
|
|
token_tags[last_param_token + 1] == .colon)
|
|
{
|
|
try renderToken(ais, tree, last_param_token, .none); // name
|
|
last_param_token += 1;
|
|
try renderToken(ais, tree, last_param_token, .space); // :
|
|
last_param_token += 1;
|
|
}
|
|
if (token_tags[last_param_token] == .keyword_anytype) {
|
|
try renderToken(ais, tree, last_param_token, .comma); // anytype
|
|
if (token_tags[last_param_token + 1] == .comma)
|
|
last_param_token += 1;
|
|
continue;
|
|
}
|
|
const param = fn_proto.ast.params[param_i];
|
|
param_i += 1;
|
|
try renderExpression(gpa, ais, tree, param, .comma);
|
|
last_param_token = tree.lastToken(param);
|
|
if (token_tags[last_param_token + 1] == .comma) last_param_token += 1;
|
|
}
|
|
ais.popIndent();
|
|
}
|
|
|
|
try renderToken(ais, tree, rparen, .space); // )
|
|
|
|
if (fn_proto.ast.align_expr != 0) {
|
|
const align_lparen = tree.firstToken(fn_proto.ast.align_expr) - 1;
|
|
const align_rparen = tree.lastToken(fn_proto.ast.align_expr) + 1;
|
|
|
|
try renderToken(ais, tree, align_lparen - 1, .none); // align
|
|
try renderToken(ais, tree, align_lparen, .none); // (
|
|
try renderExpression(gpa, ais, tree, fn_proto.ast.align_expr, .none);
|
|
try renderToken(ais, tree, align_rparen, .space); // )
|
|
}
|
|
|
|
if (fn_proto.ast.section_expr != 0) {
|
|
const section_lparen = tree.firstToken(fn_proto.ast.section_expr) - 1;
|
|
const section_rparen = tree.lastToken(fn_proto.ast.section_expr) + 1;
|
|
|
|
try renderToken(ais, tree, section_lparen - 1, .none); // section
|
|
try renderToken(ais, tree, section_lparen, .none); // (
|
|
try renderExpression(gpa, ais, tree, fn_proto.ast.section_expr, .none);
|
|
try renderToken(ais, tree, section_rparen, .space); // )
|
|
}
|
|
|
|
if (fn_proto.ast.callconv_expr != 0) {
|
|
const callconv_lparen = tree.firstToken(fn_proto.ast.callconv_expr) - 1;
|
|
const callconv_rparen = tree.lastToken(fn_proto.ast.callconv_expr) + 1;
|
|
|
|
try renderToken(ais, tree, callconv_lparen - 1, .none); // callconv
|
|
try renderToken(ais, tree, callconv_lparen, .none); // (
|
|
try renderExpression(gpa, ais, tree, fn_proto.ast.callconv_expr, .none);
|
|
try renderToken(ais, tree, callconv_rparen, .space); // )
|
|
} else if (is_inline) {
|
|
try ais.writer().writeAll("callconv(.Inline) ");
|
|
}
|
|
|
|
if (token_tags[maybe_bang] == .bang) {
|
|
try renderToken(ais, tree, maybe_bang, .none); // !
|
|
}
|
|
return renderExpression(gpa, ais, tree, fn_proto.ast.return_type, space);
|
|
}
|
|
|
|
fn renderSwitchCase(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
switch_case: ast.full.SwitchCase,
|
|
space: Space,
|
|
) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const trailing_comma = token_tags[switch_case.ast.arrow_token - 1] == .comma;
|
|
|
|
// Render everything before the arrow
|
|
if (switch_case.ast.values.len == 0) {
|
|
try renderToken(ais, tree, switch_case.ast.arrow_token - 1, .space); // else keyword
|
|
} else if (switch_case.ast.values.len == 1) {
|
|
// render on one line and drop the trailing comma if any
|
|
try renderExpression(gpa, ais, tree, switch_case.ast.values[0], .space);
|
|
} else if (trailing_comma or
|
|
hasComment(tree, tree.firstToken(switch_case.ast.values[0]), switch_case.ast.arrow_token))
|
|
{
|
|
// Render each value on a new line
|
|
try renderExpressions(gpa, ais, tree, switch_case.ast.values, .comma);
|
|
} else {
|
|
// Render on one line
|
|
for (switch_case.ast.values) |value_expr| {
|
|
try renderExpression(gpa, ais, tree, value_expr, .comma_space);
|
|
}
|
|
}
|
|
|
|
// Render the arrow and everything after it
|
|
try renderToken(ais, tree, switch_case.ast.arrow_token, .space);
|
|
|
|
if (switch_case.payload_token) |payload_token| {
|
|
try renderToken(ais, tree, payload_token - 1, .none); // pipe
|
|
if (token_tags[payload_token] == .asterisk) {
|
|
try renderToken(ais, tree, payload_token, .none); // asterisk
|
|
try renderToken(ais, tree, payload_token + 1, .none); // identifier
|
|
try renderToken(ais, tree, payload_token + 2, .space); // pipe
|
|
} else {
|
|
try renderToken(ais, tree, payload_token, .none); // identifier
|
|
try renderToken(ais, tree, payload_token + 1, .space); // pipe
|
|
}
|
|
}
|
|
|
|
try renderExpression(gpa, ais, tree, switch_case.ast.target_expr, space);
|
|
}
|
|
|
|
fn renderBlock(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
block_node: ast.Node.Index,
|
|
statements: []const ast.Node.Index,
|
|
space: Space,
|
|
) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const node_tags = tree.nodes.items(.tag);
|
|
const nodes_data = tree.nodes.items(.data);
|
|
const lbrace = tree.nodes.items(.main_token)[block_node];
|
|
|
|
if (token_tags[lbrace - 1] == .colon and
|
|
token_tags[lbrace - 2] == .identifier)
|
|
{
|
|
try renderToken(ais, tree, lbrace - 2, .none);
|
|
try renderToken(ais, tree, lbrace - 1, .space);
|
|
}
|
|
|
|
ais.pushIndentNextLine();
|
|
if (statements.len == 0) {
|
|
try renderToken(ais, tree, lbrace, .none);
|
|
} else {
|
|
try renderToken(ais, tree, lbrace, .newline);
|
|
for (statements) |stmt, i| {
|
|
if (i != 0) try renderExtraNewline(ais, tree, stmt);
|
|
switch (node_tags[stmt]) {
|
|
.global_var_decl => try renderVarDecl(gpa, ais, tree, tree.globalVarDecl(stmt)),
|
|
.local_var_decl => try renderVarDecl(gpa, ais, tree, tree.localVarDecl(stmt)),
|
|
.simple_var_decl => try renderVarDecl(gpa, ais, tree, tree.simpleVarDecl(stmt)),
|
|
.aligned_var_decl => try renderVarDecl(gpa, ais, tree, tree.alignedVarDecl(stmt)),
|
|
else => try renderExpression(gpa, ais, tree, stmt, .semicolon),
|
|
}
|
|
}
|
|
}
|
|
ais.popIndent();
|
|
|
|
try renderToken(ais, tree, tree.lastToken(block_node), space); // rbrace
|
|
}
|
|
|
|
fn renderStructInit(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
struct_node: ast.Node.Index,
|
|
struct_init: ast.full.StructInit,
|
|
space: Space,
|
|
) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
if (struct_init.ast.type_expr == 0) {
|
|
try renderToken(ais, tree, struct_init.ast.lbrace - 1, .none); // .
|
|
} else {
|
|
try renderExpression(gpa, ais, tree, struct_init.ast.type_expr, .none); // T
|
|
}
|
|
if (struct_init.ast.fields.len == 0) {
|
|
ais.pushIndentNextLine();
|
|
try renderToken(ais, tree, struct_init.ast.lbrace, .none); // lbrace
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, struct_init.ast.lbrace + 1, space); // rbrace
|
|
}
|
|
|
|
const rbrace = tree.lastToken(struct_node);
|
|
const trailing_comma = token_tags[rbrace - 1] == .comma;
|
|
if (trailing_comma or hasComment(tree, struct_init.ast.lbrace, rbrace)) {
|
|
// Render one field init per line.
|
|
ais.pushIndentNextLine();
|
|
try renderToken(ais, tree, struct_init.ast.lbrace, .newline);
|
|
|
|
try renderToken(ais, tree, struct_init.ast.lbrace + 1, .none); // .
|
|
try renderToken(ais, tree, struct_init.ast.lbrace + 2, .space); // name
|
|
try renderToken(ais, tree, struct_init.ast.lbrace + 3, .space); // =
|
|
try renderExpression(gpa, ais, tree, struct_init.ast.fields[0], .comma);
|
|
|
|
for (struct_init.ast.fields[1..]) |field_init| {
|
|
const init_token = tree.firstToken(field_init);
|
|
try renderExtraNewlineToken(ais, tree, init_token - 3);
|
|
try renderToken(ais, tree, init_token - 3, .none); // .
|
|
try renderToken(ais, tree, init_token - 2, .space); // name
|
|
try renderToken(ais, tree, init_token - 1, .space); // =
|
|
try renderExpression(gpa, ais, tree, field_init, .comma);
|
|
}
|
|
|
|
ais.popIndent();
|
|
} else {
|
|
// Render all on one line, no trailing comma.
|
|
try renderToken(ais, tree, struct_init.ast.lbrace, .space);
|
|
|
|
for (struct_init.ast.fields) |field_init| {
|
|
const init_token = tree.firstToken(field_init);
|
|
try renderToken(ais, tree, init_token - 3, .none); // .
|
|
try renderToken(ais, tree, init_token - 2, .space); // name
|
|
try renderToken(ais, tree, init_token - 1, .space); // =
|
|
try renderExpression(gpa, ais, tree, field_init, .comma_space);
|
|
}
|
|
}
|
|
|
|
return renderToken(ais, tree, rbrace, space);
|
|
}
|
|
|
|
// TODO: handle comments between elements
|
|
fn renderArrayInit(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
array_init: ast.full.ArrayInit,
|
|
space: Space,
|
|
) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const token_starts = tree.tokens.items(.start);
|
|
|
|
if (array_init.ast.type_expr == 0) {
|
|
try renderToken(ais, tree, array_init.ast.lbrace - 1, .none); // .
|
|
} else {
|
|
try renderExpression(gpa, ais, tree, array_init.ast.type_expr, .none); // T
|
|
}
|
|
|
|
if (array_init.ast.elements.len == 0) {
|
|
ais.pushIndentNextLine();
|
|
try renderToken(ais, tree, array_init.ast.lbrace, .none); // lbrace
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, array_init.ast.lbrace + 1, space); // rbrace
|
|
}
|
|
|
|
const last_elem = array_init.ast.elements[array_init.ast.elements.len - 1];
|
|
const last_elem_token = tree.lastToken(last_elem);
|
|
const trailing_comma = token_tags[last_elem_token + 1] == .comma;
|
|
const rbrace = if (trailing_comma) last_elem_token + 2 else last_elem_token + 1;
|
|
assert(token_tags[rbrace] == .r_brace);
|
|
|
|
if (array_init.ast.elements.len == 1) {
|
|
const only_elem = array_init.ast.elements[0];
|
|
const first_token = tree.firstToken(only_elem);
|
|
if (token_tags[first_token] != .multiline_string_literal_line and
|
|
!anythingBetween(tree, last_elem_token, rbrace))
|
|
{
|
|
try renderToken(ais, tree, array_init.ast.lbrace, .none);
|
|
try renderExpression(gpa, ais, tree, only_elem, .none);
|
|
return renderToken(ais, tree, rbrace, space);
|
|
}
|
|
}
|
|
|
|
const contains_newlines = !tree.tokensOnSameLine(array_init.ast.lbrace, rbrace);
|
|
|
|
if (!trailing_comma and !contains_newlines) {
|
|
// Render all on one line, no trailing comma.
|
|
if (array_init.ast.elements.len == 1) {
|
|
// If there is only one element, we don't use spaces
|
|
try renderToken(ais, tree, array_init.ast.lbrace, .none);
|
|
try renderExpression(gpa, ais, tree, array_init.ast.elements[0], .none);
|
|
} else {
|
|
try renderToken(ais, tree, array_init.ast.lbrace, .space);
|
|
for (array_init.ast.elements) |elem| {
|
|
try renderExpression(gpa, ais, tree, elem, .comma_space);
|
|
}
|
|
}
|
|
return renderToken(ais, tree, last_elem_token + 1, space); // rbrace
|
|
}
|
|
|
|
ais.pushIndentNextLine();
|
|
try renderToken(ais, tree, array_init.ast.lbrace, .newline);
|
|
|
|
var expr_index: usize = 0;
|
|
while (rowSize(tree, array_init.ast.elements[expr_index..], rbrace)) |row_size| {
|
|
const row_exprs = array_init.ast.elements[expr_index..];
|
|
// A place to store the width of each expression and its column's maximum
|
|
const widths = try gpa.alloc(usize, row_exprs.len + row_size);
|
|
defer gpa.free(widths);
|
|
mem.set(usize, widths, 0);
|
|
|
|
const expr_newlines = try gpa.alloc(bool, row_exprs.len);
|
|
defer gpa.free(expr_newlines);
|
|
mem.set(bool, expr_newlines, false);
|
|
|
|
const expr_widths = widths[0..row_exprs.len];
|
|
const column_widths = widths[row_exprs.len..];
|
|
|
|
// Find next row with trailing comment (if any) to end the current section.
|
|
const section_end = sec_end: {
|
|
var this_line_first_expr: usize = 0;
|
|
var this_line_size = rowSize(tree, row_exprs, rbrace);
|
|
for (row_exprs) |expr, i| {
|
|
// Ignore comment on first line of this section.
|
|
if (i == 0) continue;
|
|
const expr_last_token = tree.lastToken(expr);
|
|
if (tree.tokensOnSameLine(tree.firstToken(row_exprs[0]), expr_last_token))
|
|
continue;
|
|
// Track start of line containing comment.
|
|
if (!tree.tokensOnSameLine(tree.firstToken(row_exprs[this_line_first_expr]), expr_last_token)) {
|
|
this_line_first_expr = i;
|
|
this_line_size = rowSize(tree, row_exprs[this_line_first_expr..], rbrace);
|
|
}
|
|
|
|
const maybe_comma = expr_last_token + 1;
|
|
if (token_tags[maybe_comma] == .comma) {
|
|
if (hasSameLineComment(tree, maybe_comma))
|
|
break :sec_end i - this_line_size.? + 1;
|
|
}
|
|
}
|
|
break :sec_end row_exprs.len;
|
|
};
|
|
expr_index += section_end;
|
|
|
|
const section_exprs = row_exprs[0..section_end];
|
|
|
|
var sub_expr_buffer = std.ArrayList(u8).init(gpa);
|
|
defer sub_expr_buffer.deinit();
|
|
|
|
var auto_indenting_stream = Ais{
|
|
.indent_delta = indent_delta,
|
|
.underlying_writer = sub_expr_buffer.writer(),
|
|
};
|
|
|
|
// Calculate size of columns in current section
|
|
var column_counter: usize = 0;
|
|
var single_line = true;
|
|
var contains_newline = false;
|
|
for (section_exprs) |expr, i| {
|
|
sub_expr_buffer.shrinkRetainingCapacity(0);
|
|
if (i + 1 < section_exprs.len) {
|
|
try renderExpression(gpa, &auto_indenting_stream, tree, expr, .none);
|
|
const width = sub_expr_buffer.items.len;
|
|
const this_contains_newline = mem.indexOfScalar(u8, sub_expr_buffer.items, '\n') != null;
|
|
contains_newline = contains_newline or this_contains_newline;
|
|
expr_widths[i] = width;
|
|
expr_newlines[i] = this_contains_newline;
|
|
|
|
if (!this_contains_newline) {
|
|
const column = column_counter % row_size;
|
|
column_widths[column] = std.math.max(column_widths[column], width);
|
|
|
|
const expr_last_token = tree.lastToken(expr) + 1;
|
|
const next_expr = section_exprs[i + 1];
|
|
column_counter += 1;
|
|
if (!tree.tokensOnSameLine(expr_last_token, tree.firstToken(next_expr))) single_line = false;
|
|
} else {
|
|
single_line = false;
|
|
column_counter = 0;
|
|
}
|
|
} else {
|
|
try renderExpression(gpa, &auto_indenting_stream, tree, expr, .none);
|
|
const width = sub_expr_buffer.items.len;
|
|
contains_newline = contains_newline or mem.indexOfScalar(u8, sub_expr_buffer.items, '\n') != null;
|
|
expr_widths[i] = width;
|
|
expr_newlines[i] = contains_newline;
|
|
|
|
if (!contains_newline) {
|
|
const column = column_counter % row_size;
|
|
column_widths[column] = std.math.max(column_widths[column], width);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Render exprs in current section.
|
|
column_counter = 0;
|
|
var last_col_index: usize = row_size - 1;
|
|
for (section_exprs) |expr, i| {
|
|
if (i + 1 < section_exprs.len) {
|
|
const next_expr = section_exprs[i + 1];
|
|
try renderExpression(gpa, ais, tree, expr, .none);
|
|
|
|
const comma = tree.lastToken(expr) + 1;
|
|
|
|
if (column_counter != last_col_index) {
|
|
if (!expr_newlines[i] and !expr_newlines[i + 1]) {
|
|
// Neither the current or next expression is multiline
|
|
try renderToken(ais, tree, comma, .space); // ,
|
|
assert(column_widths[column_counter % row_size] >= expr_widths[i]);
|
|
const padding = column_widths[column_counter % row_size] - expr_widths[i];
|
|
try ais.writer().writeByteNTimes(' ', padding);
|
|
|
|
column_counter += 1;
|
|
continue;
|
|
}
|
|
}
|
|
if (single_line and row_size != 1) {
|
|
try renderToken(ais, tree, comma, .space); // ,
|
|
continue;
|
|
}
|
|
|
|
column_counter = 0;
|
|
try renderToken(ais, tree, comma, .newline); // ,
|
|
try renderExtraNewline(ais, tree, next_expr);
|
|
} else {
|
|
try renderExpression(gpa, ais, tree, expr, .comma); // ,
|
|
}
|
|
}
|
|
|
|
if (expr_index == array_init.ast.elements.len)
|
|
break;
|
|
}
|
|
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, rbrace, space); // rbrace
|
|
}
|
|
|
|
fn renderContainerDecl(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
container_decl_node: ast.Node.Index,
|
|
container_decl: ast.full.ContainerDecl,
|
|
space: Space,
|
|
) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const node_tags = tree.nodes.items(.tag);
|
|
|
|
if (container_decl.layout_token) |layout_token| {
|
|
try renderToken(ais, tree, layout_token, .space);
|
|
}
|
|
|
|
var lbrace: ast.TokenIndex = undefined;
|
|
if (container_decl.ast.enum_token) |enum_token| {
|
|
try renderToken(ais, tree, container_decl.ast.main_token, .none); // union
|
|
try renderToken(ais, tree, enum_token - 1, .none); // lparen
|
|
try renderToken(ais, tree, enum_token, .none); // enum
|
|
if (container_decl.ast.arg != 0) {
|
|
try renderToken(ais, tree, enum_token + 1, .none); // lparen
|
|
try renderExpression(gpa, ais, tree, container_decl.ast.arg, .none);
|
|
const rparen = tree.lastToken(container_decl.ast.arg) + 1;
|
|
try renderToken(ais, tree, rparen, .none); // rparen
|
|
try renderToken(ais, tree, rparen + 1, .space); // rparen
|
|
lbrace = rparen + 2;
|
|
} else {
|
|
try renderToken(ais, tree, enum_token + 1, .space); // rparen
|
|
lbrace = enum_token + 2;
|
|
}
|
|
} else if (container_decl.ast.arg != 0) {
|
|
try renderToken(ais, tree, container_decl.ast.main_token, .none); // union
|
|
try renderToken(ais, tree, container_decl.ast.main_token + 1, .none); // lparen
|
|
try renderExpression(gpa, ais, tree, container_decl.ast.arg, .none);
|
|
const rparen = tree.lastToken(container_decl.ast.arg) + 1;
|
|
try renderToken(ais, tree, rparen, .space); // rparen
|
|
lbrace = rparen + 1;
|
|
} else {
|
|
try renderToken(ais, tree, container_decl.ast.main_token, .space); // union
|
|
lbrace = container_decl.ast.main_token + 1;
|
|
}
|
|
|
|
const rbrace = tree.lastToken(container_decl_node);
|
|
if (container_decl.ast.members.len == 0) {
|
|
ais.pushIndentNextLine();
|
|
if (token_tags[lbrace + 1] == .container_doc_comment) {
|
|
try renderToken(ais, tree, lbrace, .newline); // lbrace
|
|
try renderContainerDocComments(ais, tree, lbrace + 1);
|
|
} else {
|
|
try renderToken(ais, tree, lbrace, .none); // lbrace
|
|
}
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, rbrace, space); // rbrace
|
|
}
|
|
|
|
const src_has_trailing_comma = token_tags[rbrace - 1] == .comma;
|
|
if (!src_has_trailing_comma) one_line: {
|
|
// We can only print all the members in-line if all the members are fields.
|
|
for (container_decl.ast.members) |member| {
|
|
if (!node_tags[member].isContainerField()) break :one_line;
|
|
}
|
|
// All the declarations on the same line.
|
|
try renderToken(ais, tree, lbrace, .space); // lbrace
|
|
for (container_decl.ast.members) |member| {
|
|
try renderMember(gpa, ais, tree, member, .space);
|
|
}
|
|
return renderToken(ais, tree, rbrace, space); // rbrace
|
|
}
|
|
|
|
// One member per line.
|
|
ais.pushIndentNextLine();
|
|
try renderToken(ais, tree, lbrace, .newline); // lbrace
|
|
if (token_tags[lbrace + 1] == .container_doc_comment) {
|
|
try renderContainerDocComments(ais, tree, lbrace + 1);
|
|
}
|
|
try renderMembers(gpa, ais, tree, container_decl.ast.members);
|
|
ais.popIndent();
|
|
|
|
return renderToken(ais, tree, rbrace, space); // rbrace
|
|
}
|
|
|
|
fn renderAsm(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
asm_node: ast.full.Asm,
|
|
space: Space,
|
|
) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
|
|
try renderToken(ais, tree, asm_node.ast.asm_token, .space); // asm
|
|
|
|
if (asm_node.volatile_token) |volatile_token| {
|
|
try renderToken(ais, tree, volatile_token, .space); // volatile
|
|
try renderToken(ais, tree, volatile_token + 1, .none); // lparen
|
|
} else {
|
|
try renderToken(ais, tree, asm_node.ast.asm_token + 1, .none); // lparen
|
|
}
|
|
|
|
if (asm_node.ast.items.len == 0) {
|
|
ais.pushIndent();
|
|
if (asm_node.first_clobber) |first_clobber| {
|
|
// asm ("foo" ::: "a", "b")
|
|
// asm ("foo" ::: "a", "b",)
|
|
try renderExpression(gpa, ais, tree, asm_node.ast.template, .space);
|
|
// Render the three colons.
|
|
try renderToken(ais, tree, first_clobber - 3, .none);
|
|
try renderToken(ais, tree, first_clobber - 2, .none);
|
|
try renderToken(ais, tree, first_clobber - 1, .space);
|
|
|
|
var tok_i = first_clobber;
|
|
while (true) : (tok_i += 1) {
|
|
try renderToken(ais, tree, tok_i, .none);
|
|
tok_i += 1;
|
|
switch (token_tags[tok_i]) {
|
|
.r_paren => {
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, tok_i, space);
|
|
},
|
|
.comma => {
|
|
if (token_tags[tok_i + 1] == .r_paren) {
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, tok_i + 1, space);
|
|
} else {
|
|
try renderToken(ais, tree, tok_i, .space);
|
|
}
|
|
},
|
|
else => unreachable,
|
|
}
|
|
}
|
|
} else {
|
|
// asm ("foo")
|
|
try renderExpression(gpa, ais, tree, asm_node.ast.template, .none);
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
|
|
}
|
|
}
|
|
|
|
ais.pushIndent();
|
|
try renderExpression(gpa, ais, tree, asm_node.ast.template, .newline);
|
|
ais.setIndentDelta(asm_indent_delta);
|
|
const colon1 = tree.lastToken(asm_node.ast.template) + 1;
|
|
|
|
const colon2 = if (asm_node.outputs.len == 0) colon2: {
|
|
try renderToken(ais, tree, colon1, .newline); // :
|
|
break :colon2 colon1 + 1;
|
|
} else colon2: {
|
|
try renderToken(ais, tree, colon1, .space); // :
|
|
|
|
ais.pushIndent();
|
|
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(gpa, ais, tree, asm_output, .none);
|
|
|
|
const comma = tree.firstToken(next_asm_output) - 1;
|
|
try renderToken(ais, tree, comma, .newline); // ,
|
|
try renderExtraNewlineToken(ais, tree, tree.firstToken(next_asm_output));
|
|
} else if (asm_node.inputs.len == 0 and asm_node.first_clobber == null) {
|
|
try renderAsmOutput(gpa, ais, tree, asm_output, .newline);
|
|
ais.popIndent();
|
|
ais.setIndentDelta(indent_delta);
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
|
|
} else {
|
|
try renderAsmOutput(gpa, ais, tree, asm_output, .newline);
|
|
const comma_or_colon = tree.lastToken(asm_output) + 1;
|
|
ais.popIndent();
|
|
break :colon2 switch (token_tags[comma_or_colon]) {
|
|
.comma => comma_or_colon + 1,
|
|
else => comma_or_colon,
|
|
};
|
|
}
|
|
} else unreachable;
|
|
};
|
|
|
|
const colon3 = if (asm_node.inputs.len == 0) colon3: {
|
|
try renderToken(ais, tree, colon2, .newline); // :
|
|
break :colon3 colon2 + 1;
|
|
} else colon3: {
|
|
try renderToken(ais, tree, colon2, .space); // :
|
|
ais.pushIndent();
|
|
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(gpa, ais, tree, asm_input, .none);
|
|
|
|
const first_token = tree.firstToken(next_asm_input);
|
|
try renderToken(ais, tree, first_token - 1, .newline); // ,
|
|
try renderExtraNewlineToken(ais, tree, first_token);
|
|
} else if (asm_node.first_clobber == null) {
|
|
try renderAsmInput(gpa, ais, tree, asm_input, .newline);
|
|
ais.popIndent();
|
|
ais.setIndentDelta(indent_delta);
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
|
|
} else {
|
|
try renderAsmInput(gpa, ais, tree, asm_input, .newline);
|
|
const comma_or_colon = tree.lastToken(asm_input) + 1;
|
|
ais.popIndent();
|
|
break :colon3 switch (token_tags[comma_or_colon]) {
|
|
.comma => comma_or_colon + 1,
|
|
else => comma_or_colon,
|
|
};
|
|
}
|
|
}
|
|
unreachable;
|
|
};
|
|
|
|
try renderToken(ais, tree, colon3, .space); // :
|
|
const first_clobber = asm_node.first_clobber.?;
|
|
var tok_i = first_clobber;
|
|
while (true) {
|
|
switch (token_tags[tok_i + 1]) {
|
|
.r_paren => {
|
|
ais.setIndentDelta(indent_delta);
|
|
ais.popIndent();
|
|
try renderToken(ais, tree, tok_i, .newline);
|
|
return renderToken(ais, tree, tok_i + 1, space);
|
|
},
|
|
.comma => {
|
|
try renderToken(ais, tree, tok_i, .none);
|
|
try renderToken(ais, tree, tok_i + 1, .space);
|
|
tok_i += 2;
|
|
},
|
|
else => unreachable,
|
|
}
|
|
} else unreachable; // TODO shouldn't need this on while(true)
|
|
}
|
|
|
|
fn renderCall(
|
|
gpa: *Allocator,
|
|
ais: *Ais,
|
|
tree: ast.Tree,
|
|
call: ast.full.Call,
|
|
space: Space,
|
|
) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const main_tokens = tree.nodes.items(.main_token);
|
|
|
|
if (call.async_token) |async_token| {
|
|
try renderToken(ais, tree, async_token, .space);
|
|
}
|
|
try renderExpression(gpa, ais, tree, call.ast.fn_expr, .none);
|
|
|
|
const lparen = call.ast.lparen;
|
|
const params = call.ast.params;
|
|
if (params.len == 0) {
|
|
ais.pushIndentNextLine();
|
|
try renderToken(ais, tree, lparen, .none);
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, lparen + 1, space); // )
|
|
}
|
|
|
|
const last_param = params[params.len - 1];
|
|
const after_last_param_tok = tree.lastToken(last_param) + 1;
|
|
if (token_tags[after_last_param_tok] == .comma) {
|
|
ais.pushIndentNextLine();
|
|
try renderToken(ais, tree, lparen, .newline); // (
|
|
for (params) |param_node, i| {
|
|
if (i + 1 < params.len) {
|
|
try renderExpression(gpa, ais, tree, param_node, .none);
|
|
|
|
// Unindent the comma for multiline string literals.
|
|
const is_multiline_string =
|
|
token_tags[tree.firstToken(param_node)] == .multiline_string_literal_line;
|
|
if (is_multiline_string) ais.popIndent();
|
|
|
|
const comma = tree.lastToken(param_node) + 1;
|
|
try renderToken(ais, tree, comma, .newline); // ,
|
|
|
|
if (is_multiline_string) ais.pushIndent();
|
|
|
|
try renderExtraNewline(ais, tree, params[i + 1]);
|
|
} else {
|
|
try renderExpression(gpa, ais, tree, param_node, .comma);
|
|
}
|
|
}
|
|
ais.popIndent();
|
|
return renderToken(ais, tree, after_last_param_tok + 1, space); // )
|
|
}
|
|
|
|
try renderToken(ais, tree, lparen, .none); // (
|
|
|
|
for (params) |param_node, i| {
|
|
const first_param_token = tree.firstToken(param_node);
|
|
if (token_tags[first_param_token] == .multiline_string_literal_line or
|
|
hasSameLineComment(tree, first_param_token - 1))
|
|
{
|
|
ais.pushIndentOneShot();
|
|
}
|
|
try renderExpression(gpa, ais, tree, param_node, .none);
|
|
|
|
if (i + 1 < params.len) {
|
|
const comma = tree.lastToken(param_node) + 1;
|
|
const next_multiline_string =
|
|
token_tags[tree.firstToken(params[i + 1])] == .multiline_string_literal_line;
|
|
const comma_space: Space = if (next_multiline_string) .none else .space;
|
|
try renderToken(ais, tree, comma, comma_space);
|
|
}
|
|
}
|
|
|
|
return renderToken(ais, tree, after_last_param_tok, space); // )
|
|
}
|
|
|
|
/// Renders the given expression indented, popping the indent before rendering
|
|
/// any following line comments
|
|
fn renderExpressionIndented(gpa: *Allocator, ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Space) Error!void {
|
|
const token_starts = tree.tokens.items(.start);
|
|
const token_tags = tree.tokens.items(.tag);
|
|
|
|
ais.pushIndent();
|
|
|
|
var last_token = tree.lastToken(node);
|
|
const punctuation = switch (space) {
|
|
.none, .space, .newline, .skip => false,
|
|
.comma => true,
|
|
.comma_space => token_tags[last_token + 1] == .comma,
|
|
.semicolon => token_tags[last_token + 1] == .semicolon,
|
|
};
|
|
|
|
try renderExpression(gpa, ais, tree, node, if (punctuation) .none else .skip);
|
|
|
|
switch (space) {
|
|
.none, .space, .newline, .skip => {},
|
|
.comma => {
|
|
if (token_tags[last_token + 1] == .comma) {
|
|
try renderToken(ais, tree, last_token + 1, .skip);
|
|
last_token += 1;
|
|
} else {
|
|
try ais.writer().writeByte(',');
|
|
}
|
|
},
|
|
.comma_space => if (token_tags[last_token + 1] == .comma) {
|
|
try renderToken(ais, tree, last_token + 1, .skip);
|
|
last_token += 1;
|
|
},
|
|
.semicolon => if (token_tags[last_token + 1] == .semicolon) {
|
|
try renderToken(ais, tree, last_token + 1, .skip);
|
|
last_token += 1;
|
|
},
|
|
}
|
|
|
|
ais.popIndent();
|
|
|
|
if (space == .skip) return;
|
|
|
|
const comment_start = token_starts[last_token] + tokenSliceForRender(tree, last_token).len;
|
|
const comment = try renderComments(ais, tree, comment_start, token_starts[last_token + 1]);
|
|
|
|
if (!comment) switch (space) {
|
|
.none => {},
|
|
.space,
|
|
.comma_space,
|
|
=> try ais.writer().writeByte(' '),
|
|
.newline,
|
|
.comma,
|
|
.semicolon,
|
|
=> try ais.insertNewline(),
|
|
.skip => unreachable,
|
|
};
|
|
}
|
|
|
|
/// Render an expression, and the comma that follows it, if it is present in the source.
|
|
fn renderExpressionComma(gpa: *Allocator, ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Space) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const maybe_comma = tree.lastToken(node) + 1;
|
|
if (token_tags[maybe_comma] == .comma) {
|
|
try renderExpression(gpa, ais, tree, node, .none);
|
|
return renderToken(ais, tree, maybe_comma, space);
|
|
} else {
|
|
return renderExpression(gpa, ais, tree, node, space);
|
|
}
|
|
}
|
|
|
|
fn renderTokenComma(ais: *Ais, tree: ast.Tree, token: ast.TokenIndex, space: Space) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const maybe_comma = token + 1;
|
|
if (token_tags[maybe_comma] == .comma) {
|
|
try renderToken(ais, tree, token, .none);
|
|
return renderToken(ais, tree, maybe_comma, space);
|
|
} else {
|
|
return renderToken(ais, tree, token, space);
|
|
}
|
|
}
|
|
|
|
const Space = enum {
|
|
/// Output the token lexeme only.
|
|
none,
|
|
/// Output the token lexeme followed by a single space.
|
|
space,
|
|
/// Output the token lexeme followed by a newline.
|
|
newline,
|
|
/// If the next token is a comma, render it as well. If not, insert one.
|
|
/// In either case, a newline will be inserted afterwards.
|
|
comma,
|
|
/// Additionally consume the next token if it is a comma.
|
|
/// In either case, a space will be inserted afterwards.
|
|
comma_space,
|
|
/// Additionally consume the next token if it is a semicolon.
|
|
/// In either case, a newline will be inserted afterwards.
|
|
semicolon,
|
|
/// Skip rendering whitespace and comments. If this is used, the caller
|
|
/// *must* handle handle whitespace and comments manually.
|
|
skip,
|
|
};
|
|
|
|
fn renderToken(ais: *Ais, tree: ast.Tree, token_index: ast.TokenIndex, space: Space) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
const token_starts = tree.tokens.items(.start);
|
|
|
|
const token_start = token_starts[token_index];
|
|
const lexeme = tokenSliceForRender(tree, token_index);
|
|
|
|
try ais.writer().writeAll(lexeme);
|
|
|
|
if (space == .skip) return;
|
|
|
|
if (space == .comma and token_tags[token_index + 1] != .comma) {
|
|
try ais.writer().writeByte(',');
|
|
}
|
|
|
|
const comment = try renderComments(ais, tree, token_start + lexeme.len, token_starts[token_index + 1]);
|
|
switch (space) {
|
|
.none => {},
|
|
.space => if (!comment) try ais.writer().writeByte(' '),
|
|
.newline => if (!comment) try ais.insertNewline(),
|
|
|
|
.comma => if (token_tags[token_index + 1] == .comma) {
|
|
try renderToken(ais, tree, token_index + 1, .newline);
|
|
} else if (!comment) {
|
|
try ais.insertNewline();
|
|
},
|
|
|
|
.comma_space => if (token_tags[token_index + 1] == .comma) {
|
|
try renderToken(ais, tree, token_index + 1, .space);
|
|
} else if (!comment) {
|
|
try ais.writer().writeByte(' ');
|
|
},
|
|
|
|
.semicolon => if (token_tags[token_index + 1] == .semicolon) {
|
|
try renderToken(ais, tree, token_index + 1, .newline);
|
|
} else if (!comment) {
|
|
try ais.insertNewline();
|
|
},
|
|
|
|
.skip => unreachable,
|
|
}
|
|
}
|
|
|
|
/// Returns true if there exists a comment between the start of token
|
|
/// `start_token` and the start of token `end_token`. This is used to determine
|
|
/// if e.g. a fn_proto should be wrapped and have a trailing comma inserted
|
|
/// even if there is none in the source.
|
|
fn hasComment(tree: ast.Tree, start_token: ast.TokenIndex, end_token: ast.TokenIndex) bool {
|
|
const token_starts = tree.tokens.items(.start);
|
|
|
|
const start = token_starts[start_token];
|
|
const end = token_starts[end_token];
|
|
|
|
return mem.indexOf(u8, tree.source[start..end], "//") != null;
|
|
}
|
|
|
|
/// Assumes that start is the first byte past the previous token and
|
|
/// that end is the last byte before the next token.
|
|
fn renderComments(ais: *Ais, tree: ast.Tree, start: usize, end: usize) Error!bool {
|
|
var index: usize = start;
|
|
while (mem.indexOf(u8, tree.source[index..end], "//")) |offset| {
|
|
const comment_start = index + offset;
|
|
|
|
// If there is no newline, the comment ends with EOF
|
|
const newline_index = mem.indexOfScalar(u8, tree.source[comment_start..end], '\n');
|
|
const newline = if (newline_index) |i| comment_start + i else null;
|
|
|
|
const untrimmed_comment = tree.source[comment_start .. newline orelse tree.source.len];
|
|
const trimmed_comment = mem.trimRight(u8, untrimmed_comment, &std.ascii.spaces);
|
|
|
|
// Don't leave any whitespace at the start of the file
|
|
if (index != 0) {
|
|
if (index == start and mem.containsAtLeast(u8, tree.source[index..comment_start], 2, "\n")) {
|
|
// Leave up to one empty line before the first comment
|
|
try ais.insertNewline();
|
|
try ais.insertNewline();
|
|
} else if (mem.indexOfScalar(u8, tree.source[index..comment_start], '\n') != null) {
|
|
// Respect the newline directly before the comment.
|
|
// Note: This allows an empty line between comments
|
|
try ais.insertNewline();
|
|
} else if (index == start) {
|
|
// Otherwise if the first comment is on the same line as
|
|
// the token before it, prefix it with a single space.
|
|
try ais.writer().writeByte(' ');
|
|
}
|
|
}
|
|
|
|
index = 1 + (newline orelse end - 1);
|
|
|
|
const comment_content = mem.trimLeft(u8, trimmed_comment["//".len..], &std.ascii.spaces);
|
|
if (ais.disabled_offset != null and mem.eql(u8, comment_content, "zig fmt: on")) {
|
|
// Write the source for which formatting was disabled directly
|
|
// to the underlying writer, fixing up invaild whitespace.
|
|
const disabled_source = tree.source[ais.disabled_offset.?..comment_start];
|
|
try writeFixingWhitespace(ais.underlying_writer, disabled_source);
|
|
ais.disabled_offset = null;
|
|
// Write with the canonical single space.
|
|
try ais.writer().writeAll("// zig fmt: on\n");
|
|
} else if (ais.disabled_offset == null and mem.eql(u8, comment_content, "zig fmt: off")) {
|
|
// Write with the canonical single space.
|
|
try ais.writer().writeAll("// zig fmt: off\n");
|
|
ais.disabled_offset = index;
|
|
} else {
|
|
// Write the comment minus trailing whitespace.
|
|
try ais.writer().print("{s}\n", .{trimmed_comment});
|
|
}
|
|
}
|
|
|
|
if (index != start and mem.containsAtLeast(u8, tree.source[index - 1 .. end], 2, "\n")) {
|
|
try ais.insertNewline();
|
|
}
|
|
|
|
return index != start;
|
|
}
|
|
|
|
fn renderExtraNewline(ais: *Ais, tree: ast.Tree, node: ast.Node.Index) Error!void {
|
|
return renderExtraNewlineToken(ais, tree, tree.firstToken(node));
|
|
}
|
|
|
|
/// Check if there is an empty line immediately before the given token. If so, render it.
|
|
fn renderExtraNewlineToken(ais: *Ais, tree: ast.Tree, token_index: ast.TokenIndex) Error!void {
|
|
const token_starts = tree.tokens.items(.start);
|
|
const token_start = token_starts[token_index];
|
|
if (token_start == 0) return;
|
|
const prev_token_end = if (token_index == 0)
|
|
0
|
|
else
|
|
token_starts[token_index - 1] + tokenSliceForRender(tree, token_index - 1).len;
|
|
|
|
// If there is a comment present, it will handle the empty line
|
|
if (mem.indexOf(u8, tree.source[prev_token_end..token_start], "//") != null) return;
|
|
|
|
// Iterate backwards to the end of the previous token, stopping if a
|
|
// non-whitespace character is encountered or two newlines have been found.
|
|
var i = token_start - 1;
|
|
var newlines: u2 = 0;
|
|
while (std.ascii.isSpace(tree.source[i])) : (i -= 1) {
|
|
if (tree.source[i] == '\n') newlines += 1;
|
|
if (newlines == 2) return ais.insertNewline();
|
|
if (i == prev_token_end) break;
|
|
}
|
|
}
|
|
|
|
/// end_token is the token one past the last doc comment token. This function
|
|
/// searches backwards from there.
|
|
fn renderDocComments(ais: *Ais, tree: ast.Tree, end_token: ast.TokenIndex) Error!void {
|
|
// Search backwards for the first doc comment.
|
|
const token_tags = tree.tokens.items(.tag);
|
|
if (end_token == 0) return;
|
|
var tok = end_token - 1;
|
|
while (token_tags[tok] == .doc_comment) {
|
|
if (tok == 0) break;
|
|
tok -= 1;
|
|
} else {
|
|
tok += 1;
|
|
}
|
|
const first_tok = tok;
|
|
if (first_tok == end_token) return;
|
|
try renderExtraNewlineToken(ais, tree, first_tok);
|
|
|
|
while (token_tags[tok] == .doc_comment) : (tok += 1) {
|
|
try renderToken(ais, tree, tok, .newline);
|
|
}
|
|
}
|
|
|
|
/// start_token is first container doc comment token.
|
|
fn renderContainerDocComments(ais: *Ais, tree: ast.Tree, start_token: ast.TokenIndex) Error!void {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
var tok = start_token;
|
|
while (token_tags[tok] == .container_doc_comment) : (tok += 1) {
|
|
try renderToken(ais, tree, tok, .newline);
|
|
}
|
|
// Render extra newline if there is one between final container doc comment and
|
|
// the next token. If the next token is a doc comment, that code path
|
|
// will have its own logic to insert a newline.
|
|
if (token_tags[tok] != .doc_comment) {
|
|
try renderExtraNewlineToken(ais, tree, tok);
|
|
}
|
|
}
|
|
|
|
fn tokenSliceForRender(tree: ast.Tree, token_index: ast.TokenIndex) []const u8 {
|
|
var ret = tree.tokenSlice(token_index);
|
|
if (tree.tokens.items(.tag)[token_index] == .multiline_string_literal_line) {
|
|
assert(ret[ret.len - 1] == '\n');
|
|
ret.len -= 1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
fn hasSameLineComment(tree: ast.Tree, token_index: ast.TokenIndex) bool {
|
|
const token_starts = tree.tokens.items(.start);
|
|
const between_source = tree.source[token_starts[token_index]..token_starts[token_index + 1]];
|
|
for (between_source) |byte| switch (byte) {
|
|
'\n' => return false,
|
|
'/' => return true,
|
|
else => continue,
|
|
};
|
|
return false;
|
|
}
|
|
|
|
/// Returns `true` if and only if there are any tokens or line comments between
|
|
/// start_token and end_token.
|
|
fn anythingBetween(tree: ast.Tree, start_token: ast.TokenIndex, end_token: ast.TokenIndex) bool {
|
|
if (start_token + 1 != end_token) return true;
|
|
const token_starts = tree.tokens.items(.start);
|
|
const between_source = tree.source[token_starts[start_token]..token_starts[start_token + 1]];
|
|
for (between_source) |byte| switch (byte) {
|
|
'/' => return true,
|
|
else => continue,
|
|
};
|
|
return false;
|
|
}
|
|
|
|
fn writeFixingWhitespace(writer: std.ArrayList(u8).Writer, slice: []const u8) Error!void {
|
|
for (slice) |byte| switch (byte) {
|
|
'\t' => try writer.writeAll(" " ** 4),
|
|
'\r' => {},
|
|
else => try writer.writeByte(byte),
|
|
};
|
|
}
|
|
|
|
fn nodeIsBlock(tag: ast.Node.Tag) bool {
|
|
return switch (tag) {
|
|
.block,
|
|
.block_semicolon,
|
|
.block_two,
|
|
.block_two_semicolon,
|
|
.@"if",
|
|
.if_simple,
|
|
.@"for",
|
|
.for_simple,
|
|
.@"while",
|
|
.while_simple,
|
|
.while_cont,
|
|
.@"switch",
|
|
.switch_comma,
|
|
=> true,
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
fn nodeIsIf(tag: ast.Node.Tag) bool {
|
|
return switch (tag) {
|
|
.@"if", .if_simple => true,
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
fn nodeCausesSliceOpSpace(tag: ast.Node.Tag) bool {
|
|
return switch (tag) {
|
|
.@"catch",
|
|
.add,
|
|
.add_wrap,
|
|
.array_cat,
|
|
.array_mult,
|
|
.assign,
|
|
.assign_bit_and,
|
|
.assign_bit_or,
|
|
.assign_bit_shift_left,
|
|
.assign_bit_shift_right,
|
|
.assign_bit_xor,
|
|
.assign_div,
|
|
.assign_sub,
|
|
.assign_sub_wrap,
|
|
.assign_mod,
|
|
.assign_add,
|
|
.assign_add_wrap,
|
|
.assign_mul,
|
|
.assign_mul_wrap,
|
|
.bang_equal,
|
|
.bit_and,
|
|
.bit_or,
|
|
.bit_shift_left,
|
|
.bit_shift_right,
|
|
.bit_xor,
|
|
.bool_and,
|
|
.bool_or,
|
|
.div,
|
|
.equal_equal,
|
|
.error_union,
|
|
.greater_or_equal,
|
|
.greater_than,
|
|
.less_or_equal,
|
|
.less_than,
|
|
.merge_error_sets,
|
|
.mod,
|
|
.mul,
|
|
.mul_wrap,
|
|
.sub,
|
|
.sub_wrap,
|
|
.@"orelse",
|
|
=> true,
|
|
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
// Returns the number of nodes in `expr` that are on the same line as `rtoken`,
|
|
// or null if they all are on the same line.
|
|
fn rowSize(tree: ast.Tree, exprs: []const ast.Node.Index, rtoken: ast.TokenIndex) ?usize {
|
|
const token_tags = tree.tokens.items(.tag);
|
|
|
|
const first_token = tree.firstToken(exprs[0]);
|
|
if (tree.tokensOnSameLine(first_token, rtoken)) {
|
|
const maybe_comma = rtoken - 1;
|
|
if (token_tags[maybe_comma] == .comma)
|
|
return 1;
|
|
return null; // no newlines
|
|
}
|
|
|
|
var count: usize = 1;
|
|
for (exprs) |expr, i| {
|
|
if (i + 1 < exprs.len) {
|
|
const expr_last_token = tree.lastToken(expr) + 1;
|
|
if (!tree.tokensOnSameLine(expr_last_token, tree.firstToken(exprs[i + 1]))) return count;
|
|
count += 1;
|
|
} else {
|
|
return count;
|
|
}
|
|
}
|
|
unreachable;
|
|
}
|
|
|
|
/// Automatically inserts indentation of written data by keeping
|
|
/// track of the current indentation level
|
|
fn AutoIndentingStream(comptime UnderlyingWriter: type) type {
|
|
return struct {
|
|
const Self = @This();
|
|
pub const Error = UnderlyingWriter.Error;
|
|
pub const Writer = std.io.Writer(*Self, Error, write);
|
|
|
|
underlying_writer: UnderlyingWriter,
|
|
|
|
/// Offset into the source at which formatting has been disabled with
|
|
/// a `zig fmt: off` comment.
|
|
///
|
|
/// If non-null, the AutoIndentingStream will not write any bytes
|
|
/// to the underlying writer. It will however continue to track the
|
|
/// indentation level.
|
|
disabled_offset: ?usize = null,
|
|
|
|
indent_count: usize = 0,
|
|
indent_delta: usize,
|
|
current_line_empty: bool = true,
|
|
/// automatically popped when applied
|
|
indent_one_shot_count: usize = 0,
|
|
/// the most recently applied indent
|
|
applied_indent: usize = 0,
|
|
/// not used until the next line
|
|
indent_next_line: usize = 0,
|
|
|
|
pub fn writer(self: *Self) Writer {
|
|
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);
|
|
}
|
|
|
|
// Change the indent delta without changing the final indentation level
|
|
pub fn setIndentDelta(self: *Self, new_indent_delta: usize) void {
|
|
if (self.indent_delta == new_indent_delta) {
|
|
return;
|
|
} else if (self.indent_delta > new_indent_delta) {
|
|
assert(self.indent_delta % new_indent_delta == 0);
|
|
self.indent_count = self.indent_count * (self.indent_delta / new_indent_delta);
|
|
} else {
|
|
// assert that the current indentation (in spaces) in a multiple of the new delta
|
|
assert((self.indent_count * self.indent_delta) % new_indent_delta == 0);
|
|
self.indent_count = self.indent_count / (new_indent_delta / self.indent_delta);
|
|
}
|
|
self.indent_delta = new_indent_delta;
|
|
}
|
|
|
|
fn writeNoIndent(self: *Self, bytes: []const u8) Error!usize {
|
|
if (bytes.len == 0)
|
|
return @as(usize, 0);
|
|
|
|
if (self.disabled_offset == null) try self.underlying_writer.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
|
|
/// Doesn't actually write any indentation.
|
|
/// Just primes the stream to be able to write the correct indentation if it needs to.
|
|
pub fn pushIndent(self: *Self) void {
|
|
self.indent_count += 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) usize {
|
|
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_count != 0);
|
|
self.indent_count -= 1;
|
|
|
|
if (self.indent_next_line > 0)
|
|
self.indent_next_line -= 1;
|
|
}
|
|
|
|
/// 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) {
|
|
if (self.disabled_offset == null) {
|
|
try self.underlying_writer.writeByteNTimes(' ', current_indent);
|
|
}
|
|
self.applied_indent = current_indent;
|
|
}
|
|
|
|
self.indent_count -= 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) usize {
|
|
var indent_current: usize = 0;
|
|
if (self.indent_count > 0) {
|
|
const indent_count = self.indent_count - self.indent_next_line;
|
|
indent_current = indent_count * self.indent_delta;
|
|
}
|
|
return indent_current;
|
|
}
|
|
};
|
|
}
|