From 85ca611af1d7401dd336f4655a0ab15640cc8424 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 26 May 2018 15:37:47 -0400 Subject: [PATCH 01/21] zig fmt: put nested struct inits on newlines See #1003 --- std/zig/parser_test.zig | 9 +++++++++ std/zig/render.zig | 12 +++++++++--- 2 files changed, 18 insertions(+), 3 deletions(-) diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig index 9d5e64a66f50aab38b88c3ad4e79a293c7001ff6..d321f78668267a9397acc3ecbecd0784a48059fe 100644 --- a/std/zig/parser_test.zig +++ b/std/zig/parser_test.zig @@ -1,3 +1,12 @@ +test "zig fmt: nested struct literal with one item" { + try testCanonical( + \\const a = foo{ + \\ .item = bar{ .a = b }, + \\}; + \\ + ); +} + test "zig fmt: switch cases trailing comma" { try testTransform( \\fn switch_cases(x: i32) void { diff --git a/std/zig/render.zig b/std/zig/render.zig index 4691d836c3c8743d7126c356f35057a3c0ef463d..04939324a80a8bf9e7f9a4dbfcfda37096b27d86 100644 --- a/std/zig/render.zig +++ b/std/zig/render.zig @@ -431,12 +431,18 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind return; } - if (field_inits.len == 1) { - const field_init = field_inits.at(0).*; + if (field_inits.len == 1) blk: { + const field_init = ??field_inits.at(0).*.cast(ast.Node.FieldInitializer); + + if (field_init.expr.cast(ast.Node.SuffixOp)) |nested_suffix_op| { + if (nested_suffix_op.op == ast.Node.SuffixOp.Op.StructInitializer) { + break :blk; + } + } try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None); try renderToken(tree, stream, lbrace, indent, Space.Space); - try renderExpression(allocator, stream, tree, indent, field_init, Space.Space); + try renderExpression(allocator, stream, tree, indent, &field_init.base, Space.Space); try renderToken(tree, stream, suffix_op.rtoken, indent, space); return; } -- 2.54.0 From 0ab888c639dffcc48bc08a6ff186aa3da0ecbf74 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 26 May 2018 16:37:55 -0400 Subject: [PATCH 02/21] zig fmt: parse extra comma in asm expressions --- std/zig/ast.zig | 2 +- std/zig/parse.zig | 8 ++-- std/zig/parser_test.zig | 44 ++++++++++++++++++- std/zig/render.zig | 95 ++++++++++++++++++++++++++++++----------- 4 files changed, 120 insertions(+), 29 deletions(-) diff --git a/std/zig/ast.zig b/std/zig/ast.zig index 6c848b4a549fe94bf9a13f9d4fb374455661e615..addd3a37e845200b797800b68a79c75fb9f23841 100644 --- a/std/zig/ast.zig +++ b/std/zig/ast.zig @@ -2071,7 +2071,7 @@ pub const Node = struct { const OutputList = SegmentedList(&AsmOutput, 2); const InputList = SegmentedList(&AsmInput, 2); - const ClobberList = SegmentedList(&Node, 2); + const ClobberList = SegmentedList(TokenIndex, 2); pub fn iterate(self: &Asm, index: usize) ?&Node { var i = index; diff --git a/std/zig/parse.zig b/std/zig/parse.zig index a6eb22a2d0daae7e1ec81e81e35cac089d1b16b1..1bc64c3ddb66e9559c543a6f7df135196d655653 100644 --- a/std/zig/parse.zig +++ b/std/zig/parse.zig @@ -1153,9 +1153,11 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree { continue; }, State.AsmClobberItems => |items| { - stack.append(State{ .AsmClobberItems = items }) catch unreachable; - try stack.append(State{ .IfToken = Token.Id.Comma }); - try stack.append(State{ .StringLiteral = OptionalCtx{ .Required = try items.addOne() } }); + while (eatToken(&tok_it, &tree, Token.Id.StringLiteral)) |strlit| { + try items.push(strlit); + if (eatToken(&tok_it, &tree, Token.Id.Comma) == null) + break; + } continue; }, diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig index d321f78668267a9397acc3ecbecd0784a48059fe..ab15ca3a586d981f1bd9e96e55ed325c3deef1fa 100644 --- a/std/zig/parser_test.zig +++ b/std/zig/parser_test.zig @@ -1,3 +1,44 @@ +test "zig fmt: simple asm" { + try testTransform( + \\comptime { + \\ asm volatile ( + \\ \\.globl aoeu; + \\ \\.type aoeu, @function; + \\ \\.set aoeu, derp; + \\ ); + \\ + \\ asm ("not real assembly" + \\ :[a] "x" (x),); + \\ asm ("not real assembly" + \\ :[a] "x" (->i32),:[a] "x" (1),); + \\ asm ("still not real assembly" + \\ :::"a","b",); + \\} + , + \\comptime { + \\ asm volatile ( + \\ \\.globl aoeu; + \\ \\.type aoeu, @function; + \\ \\.set aoeu, derp; + \\ ); + \\ + \\ asm ("not real assembly" + \\ : [a] "x" (x) + \\ ); + \\ asm ("not real assembly" + \\ : [a] "x" (-> i32) + \\ : [a] "x" (1) + \\ ); + \\ asm ("still not real assembly" + \\ : + \\ : + \\ : "a", "b" + \\ ); + \\} + \\ + ); +} + test "zig fmt: nested struct literal with one item" { try testCanonical( \\const a = foo{ @@ -1295,7 +1336,8 @@ test "zig fmt: inline asm" { \\ : [ret] "={rax}" (-> usize) \\ : [number] "{rax}" (number), \\ [arg1] "{rdi}" (arg1) - \\ : "rcx", "r11"); + \\ : "rcx", "r11" + \\ ); \\} \\ ); diff --git a/std/zig/render.zig b/std/zig/render.zig index 04939324a80a8bf9e7f9a4dbfcfda37096b27d86..c37f6e37c7b35baa78c71cd4a3c9dcba3379b4c2 100644 --- a/std/zig/render.zig +++ b/std/zig/render.zig @@ -1203,19 +1203,35 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind try renderToken(tree, stream, tree.nextToken(asm_node.asm_token), indent, Space.None); // ( } + if (asm_node.outputs.len == 0 and asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) { + try renderExpression(allocator, stream, tree, indent, asm_node.template, Space.None); + try renderToken(tree, stream, asm_node.rparen, indent, space); + return; + } + try renderExpression(allocator, stream, tree, indent, asm_node.template, Space.Newline); + const indent_once = indent + indent_delta; try stream.writeByteNTimes(' ', indent_once); - try stream.print(": "); + + const colon1 = tree.nextToken(asm_node.template.lastToken()); const indent_extra = indent_once + 2; - { + const colon2 = if (asm_node.outputs.len == 0) blk: { + try renderToken(tree, stream, colon1, indent, Space.Newline); // : + try stream.writeByteNTimes(' ', indent_once); + + break :blk tree.nextToken(colon1); + } else blk: { + try renderToken(tree, stream, colon1, indent, Space.Space); // : + var it = asm_node.outputs.iterator(0); - while (it.next()) |asm_output| { + while (true) { + const asm_output = ??it.next(); const node = &(asm_output.*).base; - try renderExpression(allocator, stream, tree, indent_extra, node, Space.None); if (it.peek()) |next_asm_output| { + try renderExpression(allocator, stream, tree, indent_extra, node, Space.None); const next_node = &(next_asm_output.*).base; const comma = tree.prevToken(next_asm_output.*.firstToken()); @@ -1223,21 +1239,38 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind try renderExtraNewline(tree, stream, next_node); try stream.writeByteNTimes(' ', indent_extra); + } else if (asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) { + try renderExpression(allocator, stream, tree, indent_extra, node, Space.Newline); + try stream.writeByteNTimes(' ', indent); + try renderToken(tree, stream, asm_node.rparen, indent, space); + return; + } else { + try renderExpression(allocator, stream, tree, indent_extra, node, Space.Newline); + try stream.writeByteNTimes(' ', indent_once); + const comma_or_colon = tree.nextToken(node.lastToken()); + break :blk switch (tree.tokens.at(comma_or_colon).id) { + Token.Id.Comma => tree.nextToken(comma_or_colon), + else => comma_or_colon, + }; } } - } + }; - try stream.write("\n"); - try stream.writeByteNTimes(' ', indent_once); - try stream.write(": "); + const colon3 = if (asm_node.inputs.len == 0) blk: { + try renderToken(tree, stream, colon2, indent, Space.Newline); // : + try stream.writeByteNTimes(' ', indent_once); + + break :blk tree.nextToken(colon2); + } else blk: { + try renderToken(tree, stream, colon2, indent, Space.Space); // : - { var it = asm_node.inputs.iterator(0); - while (it.next()) |asm_input| { + while (true) { + const asm_input = ??it.next(); const node = &(asm_input.*).base; - try renderExpression(allocator, stream, tree, indent_extra, node, Space.None); if (it.peek()) |next_asm_input| { + try renderExpression(allocator, stream, tree, indent_extra, node, Space.None); const next_node = &(next_asm_input.*).base; const comma = tree.prevToken(next_asm_input.*.firstToken()); @@ -1245,26 +1278,40 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind try renderExtraNewline(tree, stream, next_node); try stream.writeByteNTimes(' ', indent_extra); + } else if (asm_node.clobbers.len == 0) { + try renderExpression(allocator, stream, tree, indent_extra, node, Space.Newline); + try stream.writeByteNTimes(' ', indent); + try renderToken(tree, stream, asm_node.rparen, indent, space); // ) + return; + } else { + try renderExpression(allocator, stream, tree, indent_extra, node, Space.Newline); + try stream.writeByteNTimes(' ', indent_once); + const comma_or_colon = tree.nextToken(node.lastToken()); + break :blk switch (tree.tokens.at(comma_or_colon).id) { + Token.Id.Comma => tree.nextToken(comma_or_colon), + else => comma_or_colon, + }; } } - } + }; - try stream.write("\n"); - try stream.writeByteNTimes(' ', indent_once); - try stream.write(": "); + try renderToken(tree, stream, colon3, indent, Space.Space); // : - { - var it = asm_node.clobbers.iterator(0); - while (it.next()) |node| { - try renderExpression(allocator, stream, tree, indent_once, node.*, Space.None); + var it = asm_node.clobbers.iterator(0); + while (true) { + const clobber_token = ??it.next(); - if (it.peek() != null) { - try stream.write(", "); - } + if (it.peek() == null) { + try renderToken(tree, stream, clobber_token.*, indent_once, Space.Newline); + try stream.writeByteNTimes(' ', indent); + try renderToken(tree, stream, asm_node.rparen, indent, space); + return; + } else { + try renderToken(tree, stream, clobber_token.*, indent_once, Space.None); + const comma = tree.nextToken(clobber_token.*); + try renderToken(tree, stream, comma, indent_once, Space.Space); // , } } - - try renderToken(tree, stream, asm_node.rparen, indent, space); }, ast.Node.Id.AsmInput => { -- 2.54.0 From 0bef1f98247160cbd5101c763404c76ae287b2bd Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 26 May 2018 16:43:33 -0400 Subject: [PATCH 03/21] zig fmt: fix rendering of struct with no trailing comma on last field --- std/zig/parser_test.zig | 15 +++++++++++++++ std/zig/render.zig | 3 +-- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig index ab15ca3a586d981f1bd9e96e55ed325c3deef1fa..e76d588088bce5a99df6aa223b38a1776f55b8b8 100644 --- a/std/zig/parser_test.zig +++ b/std/zig/parser_test.zig @@ -1,3 +1,18 @@ +test "zig fmt: no trailing comma on struct decl" { + try testTransform( + \\const RoundParam = struct { + \\ k: usize, s: u32, t: u32 + \\}; + , + \\const RoundParam = struct { + \\ k: usize, + \\ s: u32, + \\ t: u32, + \\}; + \\ + ); +} + test "zig fmt: simple asm" { try testTransform( \\comptime { diff --git a/std/zig/render.zig b/std/zig/render.zig index c37f6e37c7b35baa78c71cd4a3c9dcba3379b4c2..dea06e3a7d7f049e48fefbd3942bf8f2a7ca4db3 100644 --- a/std/zig/render.zig +++ b/std/zig/render.zig @@ -102,8 +102,7 @@ fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, i } try renderToken(tree, stream, field.name_token, indent, Space.None); // name try renderToken(tree, stream, tree.nextToken(field.name_token), indent, Space.Space); // : - try renderExpression(allocator, stream, tree, indent, field.type_expr, Space.None); // type - try renderToken(tree, stream, tree.nextToken(field.lastToken()), indent, Space.Newline); // , + try renderTrailingComma(allocator, stream, tree, indent, field.type_expr, Space.Newline); // type, }, ast.Node.Id.UnionTag => { -- 2.54.0 From 7e900d28be00e03eee2ec3703c0c45247b4748b1 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 26 May 2018 18:10:06 -0400 Subject: [PATCH 04/21] zig fmt: no space on switch range operator --- std/zig/parser_test.zig | 6 +++--- std/zig/render.zig | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig index e76d588088bce5a99df6aa223b38a1776f55b8b8..dfef594df7f3a84675b67f63b90598f9ef5628ac 100644 --- a/std/zig/parser_test.zig +++ b/std/zig/parser_test.zig @@ -69,7 +69,7 @@ test "zig fmt: switch cases trailing comma" { \\ switch (x) { \\ 1,2,3 => {}, \\ 4,5, => {}, - \\ 6...8, => {}, + \\ 6... 8, => {}, \\ else => {}, \\ } \\} @@ -79,7 +79,7 @@ test "zig fmt: switch cases trailing comma" { \\ 1, 2, 3 => {}, \\ 4, \\ 5, => {}, - \\ 6 ... 8 => {}, + \\ 6...8 => {}, \\ else => {}, \\ } \\} @@ -1091,7 +1091,7 @@ test "zig fmt: switch" { \\ 0 => {}, \\ 1 => unreachable, \\ 2, 3 => {}, - \\ 4 ... 7 => {}, + \\ 4...7 => {}, \\ 1 + 4 * 3 + 22 => {}, \\ else => { \\ const a = 1; diff --git a/std/zig/render.zig b/std/zig/render.zig index dea06e3a7d7f049e48fefbd3942bf8f2a7ca4db3..67ec8f76325bcf970b6f73c7f156074e41a023c4 100644 --- a/std/zig/render.zig +++ b/std/zig/render.zig @@ -244,7 +244,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind const op_token = tree.tokens.at(infix_op_node.op_token); const op_space = switch (infix_op_node.op) { - ast.Node.InfixOp.Op.Period, ast.Node.InfixOp.Op.ErrorUnion => Space.None, + ast.Node.InfixOp.Op.Period, ast.Node.InfixOp.Op.ErrorUnion, ast.Node.InfixOp.Op.Range => Space.None, else => Space.Space, }; try renderExpression(allocator, stream, tree, indent, infix_op_node.lhs, op_space); -- 2.54.0 From b8d4e05361d6a01ae1c0bf931e27e2bfdb25551d Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 26 May 2018 18:29:14 -0400 Subject: [PATCH 05/21] zig fmt: handle empty block with comment inside --- std/zig/parser_test.zig | 11 +++++++++++ std/zig/render.zig | 2 +- 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig index dfef594df7f3a84675b67f63b90598f9ef5628ac..c115c5848fd0a629da729972be6477510ad71eac 100644 --- a/std/zig/parser_test.zig +++ b/std/zig/parser_test.zig @@ -1,3 +1,14 @@ +test "zig fmt: empty block with only comment" { + try testCanonical( + \\comptime { + \\ { + \\ // comment + \\ } + \\} + \\ + ); +} + test "zig fmt: no trailing comma on struct decl" { try testTransform( \\const RoundParam = struct { diff --git a/std/zig/render.zig b/std/zig/render.zig index 67ec8f76325bcf970b6f73c7f156074e41a023c4..90acb0e4122acf430021714bf6dda47cdf366cb4 100644 --- a/std/zig/render.zig +++ b/std/zig/render.zig @@ -1519,7 +1519,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent const after_comment_token = tree.tokens.at(token_index + offset); const next_line_indent = switch (after_comment_token.id) { - Token.Id.RParen, Token.Id.RBrace, Token.Id.RBracket => indent, + Token.Id.RParen, Token.Id.RBrace, Token.Id.RBracket => indent - indent_delta, else => indent, }; try stream.writeByteNTimes(' ', next_line_indent); -- 2.54.0 From cabf7fa93b7250a69a3cfad417537c2a46414779 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 26 May 2018 18:44:10 -0400 Subject: [PATCH 06/21] zig fmt: fn calls with trailing comma with params on new lines --- std/zig/parser_test.zig | 13 +++++++++++++ std/zig/render.zig | 38 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 49 insertions(+), 2 deletions(-) diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig index c115c5848fd0a629da729972be6477510ad71eac..4ce355dc870a2486d7cc8e88c5d12e6745f5f691 100644 --- a/std/zig/parser_test.zig +++ b/std/zig/parser_test.zig @@ -1,3 +1,16 @@ +test "zig fmt: trailing comma on fn call" { + try testCanonical( + \\comptime { + \\ var module = try Module.create( + \\ allocator, + \\ zig_lib_dir, + \\ full_cache_dir, + \\ ); + \\} + \\ + ); +} + test "zig fmt: empty block with only comment" { try testCanonical( \\comptime { diff --git a/std/zig/render.zig b/std/zig/render.zig index 90acb0e4122acf430021714bf6dda47cdf366cb4..f068e652bb51c4b0ff1b7be5705a72885d3d3e68 100644 --- a/std/zig/render.zig +++ b/std/zig/render.zig @@ -374,7 +374,42 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None); const lparen = tree.nextToken(suffix_op.lhs.lastToken()); - try renderToken(tree, stream, lparen, indent, Space.None); + + if (call_info.params.len == 0) { + try renderToken(tree, stream, lparen, indent, Space.None); + try renderToken(tree, stream, suffix_op.rtoken, indent, space); + return; + } + + const src_has_trailing_comma = blk: { + const maybe_comma = tree.prevToken(suffix_op.rtoken); + break :blk tree.tokens.at(maybe_comma).id == Token.Id.Comma; + }; + + if (src_has_trailing_comma) { + const new_indent = indent + indent_delta; + try renderToken(tree, stream, lparen, new_indent, Space.Newline); + + var it = call_info.params.iterator(0); + while (true) { + const param_node = ??it.next(); + try stream.writeByteNTimes(' ', new_indent); + + if (it.peek()) |next_node| { + try renderExpression(allocator, stream, tree, new_indent, param_node.*, Space.None); + const comma = tree.nextToken(param_node.*.lastToken()); + try renderToken(tree, stream, comma, new_indent, Space.Newline); // , + try renderExtraNewline(tree, stream, next_node.*); + } else { + try renderTrailingComma(allocator, stream, tree, new_indent, param_node.*, Space.Newline); + try stream.writeByteNTimes(' ', indent); + try renderToken(tree, stream, suffix_op.rtoken, indent, space); + return; + } + } + } + + try renderToken(tree, stream, lparen, indent, Space.None); // ( var it = call_info.params.iterator(0); while (it.next()) |param_node| { @@ -385,7 +420,6 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind try renderToken(tree, stream, comma, indent, Space.Space); } } - try renderToken(tree, stream, suffix_op.rtoken, indent, space); }, -- 2.54.0 From 349365d9a483bc6be8c1677149ec1a31a789e4b2 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 26 May 2018 19:32:28 -0400 Subject: [PATCH 07/21] zig fmt: better multiline string formatting --- std/zig/parser_test.zig | 29 +++++++++++++++++++++++++++++ std/zig/render.zig | 36 ++++++++++++++++++++++++++++++------ std/zig/tokenizer.zig | 12 ------------ 3 files changed, 59 insertions(+), 18 deletions(-) diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig index 4ce355dc870a2486d7cc8e88c5d12e6745f5f691..152056c6b4592ee2f8c418e2c920a151bdc2f73e 100644 --- a/std/zig/parser_test.zig +++ b/std/zig/parser_test.zig @@ -1,3 +1,32 @@ +test "zig fmt: multiline string with backslash at end of line" { + try testCanonical( + \\comptime { + \\ err( + \\ \\\ + \\ ); + \\} + \\ + ); +} + +test "zig fmt: multiline string parameter in fn call with trailing comma" { + try testCanonical( + \\fn foo() void { + \\ try stdout.print( + \\ \\ZIG_CMAKE_BINARY_DIR {} + \\ \\ZIG_C_HEADER_FILES {} + \\ \\ZIG_DIA_GUIDS_LIB {} + \\ \\ + \\ , + \\ std.cstr.toSliceConst(c.ZIG_CMAKE_BINARY_DIR), + \\ std.cstr.toSliceConst(c.ZIG_CXX_COMPILER), + \\ std.cstr.toSliceConst(c.ZIG_DIA_GUIDS_LIB), + \\ ); + \\} + \\ + ); +} + test "zig fmt: trailing comma on fn call" { try testCanonical( \\comptime { diff --git a/std/zig/render.zig b/std/zig/render.zig index f068e652bb51c4b0ff1b7be5705a72885d3d3e68..409828e0702abe92fd784191c11a155ab8f6deec 100644 --- a/std/zig/render.zig +++ b/std/zig/render.zig @@ -393,15 +393,21 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind var it = call_info.params.iterator(0); while (true) { const param_node = ??it.next(); - try stream.writeByteNTimes(' ', new_indent); + + const param_node_new_indent = if (param_node.*.id == ast.Node.Id.MultilineStringLiteral) blk: { + break :blk indent; + } else blk: { + try stream.writeByteNTimes(' ', new_indent); + break :blk new_indent; + }; if (it.peek()) |next_node| { - try renderExpression(allocator, stream, tree, new_indent, param_node.*, Space.None); + try renderExpression(allocator, stream, tree, param_node_new_indent, param_node.*, Space.None); const comma = tree.nextToken(param_node.*.lastToken()); try renderToken(tree, stream, comma, new_indent, Space.Newline); // , try renderExtraNewline(tree, stream, next_node.*); } else { - try renderTrailingComma(allocator, stream, tree, new_indent, param_node.*, Space.Newline); + try renderTrailingComma(allocator, stream, tree, param_node_new_indent, param_node.*, Space.Newline); try stream.writeByteNTimes(' ', indent); try renderToken(tree, stream, suffix_op.rtoken, indent, space); return; @@ -1502,7 +1508,13 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent if (next_token.id != Token.Id.LineComment) { switch (space) { Space.None, Space.NoNewline, Space.NoIndent => return, - Space.Newline => return stream.write("\n"), + Space.Newline => { + if (next_token.id == Token.Id.MultilineStringLiteralLine) { + return; + } else { + return stream.write("\n"); + } + }, Space.Space => return stream.writeByte(' '), Space.NoComment => unreachable, } @@ -1526,7 +1538,13 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent }; try stream.writeByteNTimes(' ', next_line_indent); }, - Space.Newline, Space.NoIndent => try stream.write("\n"), + Space.Newline, Space.NoIndent => { + if (next_token.id == Token.Id.MultilineStringLiteralLine) { + return; + } else { + return stream.write("\n"); + } + }, Space.NoNewline => {}, Space.NoComment => unreachable, } @@ -1547,7 +1565,13 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent next_token = tree.tokens.at(token_index + offset); if (next_token.id != Token.Id.LineComment) { switch (space) { - Space.Newline, Space.NoIndent => try stream.writeByte('\n'), + Space.Newline, Space.NoIndent => { + if (next_token.id == Token.Id.MultilineStringLiteralLine) { + return; + } else { + return stream.write("\n"); + } + }, Space.None, Space.Space => { try stream.writeByte('\n'); diff --git a/std/zig/tokenizer.zig b/std/zig/tokenizer.zig index f4cd847dff65be10beceedb5b91139208f138705..b90a40108f39177f19381ecad6070c185b046ce4 100644 --- a/std/zig/tokenizer.zig +++ b/std/zig/tokenizer.zig @@ -217,7 +217,6 @@ pub const Tokenizer = struct { StringLiteral, StringLiteralBackslash, MultilineStringLiteralLine, - MultilineStringLiteralLineBackslash, CharLiteral, CharLiteralBackslash, CharLiteralEscape1, @@ -655,9 +654,6 @@ pub const Tokenizer = struct { }, State.MultilineStringLiteralLine => switch (c) { - '\\' => { - state = State.MultilineStringLiteralLineBackslash; - }, '\n' => { self.index += 1; break; @@ -665,13 +661,6 @@ pub const Tokenizer = struct { else => self.checkLiteralCharacter(), }, - State.MultilineStringLiteralLineBackslash => switch (c) { - '\n' => break, // Look for this error later. - else => { - state = State.MultilineStringLiteralLine; - }, - }, - State.Bang => switch (c) { '=' => { result.id = Token.Id.BangEqual; @@ -1010,7 +999,6 @@ pub const Tokenizer = struct { State.FloatExponentUnsignedHex, State.SawAtSign, State.Backslash, - State.MultilineStringLiteralLineBackslash, State.CharLiteral, State.CharLiteralBackslash, State.CharLiteralEscape1, -- 2.54.0 From 118d41ef8325b4c1ca8be1fea66c2e8368b67e32 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 26 May 2018 22:59:46 -0400 Subject: [PATCH 08/21] zig fmt: support array literal row size hint See #1003 --- std/mem.zig | 8 +++ std/zig/parser_test.zig | 59 ++++++++++++++++++++++ std/zig/render.zig | 108 +++++++++++++++++++++++++++++++++++++--- 3 files changed, 167 insertions(+), 8 deletions(-) diff --git a/std/mem.zig b/std/mem.zig index 617c1de2f5da5fad23b988ea077edbe2bfa66f4b..70f2fe22ac1956bcde71d6d4df4e7ce016e5b54c 100644 --- a/std/mem.zig +++ b/std/mem.zig @@ -177,6 +177,14 @@ pub fn eql(comptime T: type, a: []const T, b: []const T) bool { return true; } +/// Returns true if all elements in a slice are equal to the scalar value provided +pub fn allEqual(comptime T: type, slice: []const T, scalar: T) bool { + for (slice) |item| { + if (item != scalar) return false; + } + return true; +} + /// Copies ::m to newly allocated memory. Caller is responsible to free it. pub fn dupe(allocator: &Allocator, comptime T: type, m: []const T) ![]T { const new_buf = try allocator.alloc(T, m.len); diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig index 152056c6b4592ee2f8c418e2c920a151bdc2f73e..909220a6f684c156ca2dd6cd5c6c05ab5fe086b0 100644 --- a/std/zig/parser_test.zig +++ b/std/zig/parser_test.zig @@ -1,3 +1,62 @@ +test "zig fmt: array literal with hint" { + try testTransform( + \\const a = []u8{ + \\ 1, 2, // + \\ 3, + \\ 4, + \\ 5, + \\ 6, + \\ 7 }; + \\const a = []u8{ + \\ 1, 2, // + \\ 3, + \\ 4, + \\ 5, + \\ 6, + \\ 7, 8 }; + \\const a = []u8{ + \\ 1, 2, // + \\ 3, + \\ 4, + \\ 5, + \\ 6, // blah + \\ 7, 8 }; + \\const a = []u8{ + \\ 1, 2, // + \\ 3, // + \\ 4, + \\ 5, + \\ 6, + \\ 7 }; + , + \\const a = []u8{ + \\ 1, 2, // + \\ 3, 4, // + \\ 5, 6, // + \\ 7, + \\}; + \\const a = []u8{ + \\ 1, 2, // + \\ 3, 4, // + \\ 5, 6, // + \\ 7, 8, // + \\}; + \\const a = []u8{ + \\ 1, 2, // + \\ 3, 4, // + \\ 5, 6, // blah + \\ 7, 8, // + \\}; + \\const a = []u8{ + \\ 1, 2, // + \\ 3, 4, // + \\ 5, 6, // + \\ 7, + \\}; + \\ + ); +} + test "zig fmt: multiline string with backslash at end of line" { try testCanonical( \\comptime { diff --git a/std/zig/render.zig b/std/zig/render.zig index 409828e0702abe92fd784191c11a155ab8f6deec..fa3755b719b2e44a89111c833dbc86f3f25da4a6 100644 --- a/std/zig/render.zig +++ b/std/zig/render.zig @@ -19,7 +19,7 @@ pub fn render(allocator: &mem.Allocator, stream: var, tree: &ast.Tree) (@typeOf( var tok_it = tree.tokens.iterator(0); while (tok_it.next()) |token| { if (token.id != Token.Id.LineComment) break; - try stream.print("{}\n", tree.tokenSlicePtr(token)); + try stream.print("{}\n", mem.trimRight(u8, tree.tokenSlicePtr(token), " ")); if (tok_it.peek()) |next_token| { const loc = tree.tokenLocationPtr(token.end, next_token); if (loc.line >= 2) { @@ -532,12 +532,73 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None); + // scan to find row size + const maybe_row_size: ?usize = blk: { + var count: usize = 0; + var it = exprs.iterator(0); + var prev_token = (??it.peek()).*.lastToken() + 1; + while (it.next()) |expr| { + const expr_last_token = expr.*.lastToken() + 1; + const next_token = tree.tokens.at(expr_last_token + 1); + const loc = tree.tokenLocationPtr(tree.tokens.at(prev_token).end, next_token); + if (loc.line != 0) break :blk null; + if (next_token.id == Token.Id.LineComment) { + const trimmed = mem.trimRight(u8, tree.tokenSlicePtr(next_token), " "); + if (trimmed.len == 2) { + break :blk count; + } else { + break :blk null; + } + } + prev_token = expr_last_token; + count += 1; + } + break :blk null; + }; + + const new_indent = indent + indent_delta; try renderToken(tree, stream, lbrace, new_indent, Space.Newline); + try stream.writeByteNTimes(' ', new_indent); + + if (maybe_row_size) |row_size| { + var it = exprs.iterator(0); + var i: usize = 0; + while (it.next()) |expr| { + if (it.peek()) |next_expr| { + try renderExpression(allocator, stream, tree, new_indent, expr.*, Space.None); + + const comma = tree.nextToken(expr.*.lastToken()); + + if (i != row_size) { + try renderToken(tree, stream, comma, new_indent, Space.IgnoreEmptyComment); // , + i += 1; + continue; + } + i = 0; + + try renderToken(tree, stream, comma, new_indent, Space.NoIndent); // , + + const next_token = tree.tokens.at(comma + 1); + if (next_token.id != Token.Id.LineComment) { + try stream.print(" //\n"); + } + + try renderExtraNewline(tree, stream, next_expr.*); + try stream.writeByteNTimes(' ', new_indent); + } else if (i == row_size) { + try renderTrailingCommaAndEmptyComment(allocator, stream, tree, new_indent, expr.*); // , // + } else { + try renderTrailingComma(allocator, stream, tree, new_indent, expr.*, Space.Newline); // , + } + } + try stream.writeByteNTimes(' ', indent); + try renderToken(tree, stream, suffix_op.rtoken, indent, space); + return; + } var it = exprs.iterator(0); while (it.next()) |expr| { - try stream.writeByteNTimes(' ', new_indent); if (it.peek()) |next_expr| { try renderExpression(allocator, stream, tree, new_indent, expr.*, Space.None); @@ -546,6 +607,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind try renderToken(tree, stream, comma, new_indent, Space.Newline); // , try renderExtraNewline(tree, stream, next_expr.*); + try stream.writeByteNTimes(' ', new_indent); } else { try renderTrailingComma(allocator, stream, tree, new_indent, expr.*, Space.Newline); } @@ -1496,11 +1558,12 @@ const Space = enum { NoNewline, NoIndent, NoComment, + IgnoreEmptyComment, }; fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent: usize, space: Space) (@typeOf(stream).Child.Error || Error)!void { var token = tree.tokens.at(token_index); - try stream.write(tree.tokenSlicePtr(token)); + try stream.write(mem.trimRight(u8, tree.tokenSlicePtr(token), " ")); if (space == Space.NoComment) return; @@ -1515,15 +1578,19 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent return stream.write("\n"); } }, - Space.Space => return stream.writeByte(' '), + Space.Space, Space.IgnoreEmptyComment => return stream.writeByte(' '), Space.NoComment => unreachable, } } + if (space == Space.IgnoreEmptyComment and mem.trimRight(u8, tree.tokenSlicePtr(next_token), " ").len == 2) { + return stream.writeByte(' '); + } + var loc = tree.tokenLocationPtr(token.end, next_token); var offset: usize = 1; if (loc.line == 0) { - try stream.print(" {}", tree.tokenSlicePtr(next_token)); + try stream.print(" {}", mem.trimRight(u8, tree.tokenSlicePtr(next_token), " ")); offset = 2; token = next_token; next_token = tree.tokens.at(token_index + offset); @@ -1546,7 +1613,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent } }, Space.NoNewline => {}, - Space.NoComment => unreachable, + Space.NoComment, Space.IgnoreEmptyComment => unreachable, } return; } @@ -1558,7 +1625,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent const newline_count = if (loc.line == 1) u8(1) else u8(2); try stream.writeByteNTimes('\n', newline_count); try stream.writeByteNTimes(' ', indent); - try stream.write(tree.tokenSlicePtr(next_token)); + try stream.write(mem.trimRight(u8, tree.tokenSlicePtr(next_token), " ")); offset += 1; token = next_token; @@ -1583,7 +1650,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent try stream.writeByteNTimes(' ', next_line_indent); }, Space.NoNewline => {}, - Space.NoComment => unreachable, + Space.NoComment, Space.IgnoreEmptyComment => unreachable, } return; } @@ -1621,3 +1688,28 @@ fn renderTrailingComma(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, }, } } + +fn renderTrailingCommaAndEmptyComment(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, base: &ast.Node) (@typeOf(stream).Child.Error || Error)!void +{ + const end_token = base.lastToken() + 1; + switch (tree.tokens.at(end_token).id) { + Token.Id.Comma => { + try renderExpression(allocator, stream, tree, indent, base, Space.None); + try renderToken(tree, stream, end_token, indent, Space.Space); // , + + const next_token = tree.tokens.at(end_token + 1); + if (next_token.id != Token.Id.LineComment) { + try stream.print("//\n"); + } + }, + Token.Id.LineComment => { + try renderExpression(allocator, stream, tree, indent, base, Space.NoComment); + try stream.write(", "); + try renderToken(tree, stream, end_token, indent, Space.Newline); + }, + else => { + try renderExpression(allocator, stream, tree, indent, base, Space.None); + try stream.write(", //\n"); + }, + } +} -- 2.54.0 From b184ae5ca5d3d3c0a4b9de564a6e30555e596e65 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 26 May 2018 18:16:39 -0400 Subject: [PATCH 09/21] run zig fmt on some of the codebase See #1003 --- doc/docgen.zig | 182 ++++--- example/guess_number/main.zig | 2 +- example/hello_world/hello_libc.zig | 3 +- example/mix_o_files/build.zig | 4 +- example/shared_library/build.zig | 4 +- src-self-hosted/introspect.zig | 4 +- src-self-hosted/ir.zig | 1 - src-self-hosted/main.zig | 169 +++--- src-self-hosted/target.zig | 3 +- std/array_list.zig | 9 +- std/base64.zig | 117 ++-- std/buf_map.zig | 4 +- std/buf_set.zig | 4 +- std/build.zig | 59 +- std/c/darwin.zig | 2 +- std/c/index.zig | 12 +- std/crypto/md5.zig | 138 ++--- std/crypto/sha1.zig | 86 +-- std/crypto/sha2.zig | 843 +++++++++++++++-------------- std/crypto/test.zig | 2 +- std/crypto/throughput_test.zig | 2 +- std/cstr.zig | 4 +- std/debug/failing_allocator.zig | 4 +- std/debug/index.zig | 18 +- std/dwarf.zig | 2 - std/elf.zig | 42 +- std/event.zig | 13 +- std/fmt/errol/enum3.zig | 7 +- 28 files changed, 904 insertions(+), 836 deletions(-) diff --git a/doc/docgen.zig b/doc/docgen.zig index bd9dc6c14741727af37816556fbf5c893c016bd6..7dc444f127df49b7fbf948deb3af78344b9713e7 100644 --- a/doc/docgen.zig +++ b/doc/docgen.zig @@ -95,7 +95,7 @@ const Tokenizer = struct { }; fn init(source_file_name: []const u8, buffer: []const u8) Tokenizer { - return Tokenizer { + return Tokenizer{ .buffer = buffer, .index = 0, .state = State.Start, @@ -105,7 +105,7 @@ const Tokenizer = struct { } fn next(self: &Tokenizer) Token { - var result = Token { + var result = Token{ .id = Token.Id.Eof, .start = self.index, .end = undefined, @@ -197,7 +197,7 @@ const Tokenizer = struct { }; fn getTokenLocation(self: &Tokenizer, token: &const Token) Location { - var loc = Location { + var loc = Location{ .line = 0, .column = 0, .line_start = 0, @@ -346,7 +346,7 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc { break; }, Token.Id.Content => { - try nodes.append(Node {.Content = tokenizer.buffer[token.start..token.end] }); + try nodes.append(Node{ .Content = tokenizer.buffer[token.start..token.end] }); }, Token.Id.BracketOpen => { const tag_token = try eatToken(tokenizer, Token.Id.TagContent); @@ -365,11 +365,13 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc { header_stack_size += 1; const urlized = try urlize(allocator, content); - try nodes.append(Node{.HeaderOpen = HeaderOpen { - .name = content, - .url = urlized, - .n = header_stack_size, - }}); + try nodes.append(Node{ + .HeaderOpen = HeaderOpen{ + .name = content, + .url = urlized, + .n = header_stack_size, + }, + }); if (try urls.put(urlized, tag_token)) |other_tag_token| { parseError(tokenizer, tag_token, "duplicate header url: #{}", urlized) catch {}; parseError(tokenizer, other_tag_token, "other tag here") catch {}; @@ -407,14 +409,14 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc { switch (see_also_tok.id) { Token.Id.TagContent => { const content = tokenizer.buffer[see_also_tok.start..see_also_tok.end]; - try list.append(SeeAlsoItem { + try list.append(SeeAlsoItem{ .name = content, .token = see_also_tok, }); }, Token.Id.Separator => {}, Token.Id.BracketClose => { - try nodes.append(Node {.SeeAlso = list.toOwnedSlice() } ); + try nodes.append(Node{ .SeeAlso = list.toOwnedSlice() }); break; }, else => return parseError(tokenizer, see_also_tok, "invalid see_also token"), @@ -438,8 +440,8 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc { } }; - try nodes.append(Node { - .Link = Link { + try nodes.append(Node{ + .Link = Link{ .url = try urlize(allocator, url_name), .name = name, .token = name_tok, @@ -463,24 +465,24 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc { var code_kind_id: Code.Id = undefined; var is_inline = false; if (mem.eql(u8, code_kind_str, "exe")) { - code_kind_id = Code.Id { .Exe = ExpectedOutcome.Succeed }; + code_kind_id = Code.Id{ .Exe = ExpectedOutcome.Succeed }; } else if (mem.eql(u8, code_kind_str, "exe_err")) { - code_kind_id = Code.Id { .Exe = ExpectedOutcome.Fail }; + code_kind_id = Code.Id{ .Exe = ExpectedOutcome.Fail }; } else if (mem.eql(u8, code_kind_str, "test")) { code_kind_id = Code.Id.Test; } else if (mem.eql(u8, code_kind_str, "test_err")) { - code_kind_id = Code.Id { .TestError = name}; + code_kind_id = Code.Id{ .TestError = name }; name = "test"; } else if (mem.eql(u8, code_kind_str, "test_safety")) { - code_kind_id = Code.Id { .TestSafety = name}; + code_kind_id = Code.Id{ .TestSafety = name }; name = "test"; } else if (mem.eql(u8, code_kind_str, "obj")) { - code_kind_id = Code.Id { .Obj = null }; + code_kind_id = Code.Id{ .Obj = null }; } else if (mem.eql(u8, code_kind_str, "obj_err")) { - code_kind_id = Code.Id { .Obj = name }; + code_kind_id = Code.Id{ .Obj = name }; name = "test"; } else if (mem.eql(u8, code_kind_str, "syntax")) { - code_kind_id = Code.Id { .Obj = null }; + code_kind_id = Code.Id{ .Obj = null }; is_inline = true; } else { return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {}", code_kind_str); @@ -514,17 +516,20 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc { return parseError(tokenizer, end_code_tag, "invalid token inside code_begin: {}", end_tag_name); } _ = try eatToken(tokenizer, Token.Id.BracketClose); - } else unreachable; // TODO issue #707 - try nodes.append(Node {.Code = Code { - .id = code_kind_id, - .name = name, - .source_token = source_token, - .is_inline = is_inline, - .mode = mode, - .link_objects = link_objects.toOwnedSlice(), - .target_windows = target_windows, - .link_libc = link_libc, - }}); + } else + unreachable; // TODO issue #707 + try nodes.append(Node{ + .Code = Code{ + .id = code_kind_id, + .name = name, + .source_token = source_token, + .is_inline = is_inline, + .mode = mode, + .link_objects = link_objects.toOwnedSlice(), + .target_windows = target_windows, + .link_libc = link_libc, + }, + }); tokenizer.code_node_count += 1; } else { return parseError(tokenizer, tag_token, "unrecognized tag name: {}", tag_name); @@ -534,7 +539,7 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc { } } - return Toc { + return Toc{ .nodes = nodes.toOwnedSlice(), .toc = toc_buf.toOwnedSlice(), .urls = urls, @@ -727,16 +732,19 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", code.name); const tmp_source_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_ext); try io.writeFile(allocator, tmp_source_file_name, trimmed_raw_source); - + switch (code.id) { Code.Id.Exe => |expected_outcome| { const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, exe_ext); const tmp_bin_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_bin_ext); var build_args = std.ArrayList([]const u8).init(allocator); defer build_args.deinit(); - try build_args.appendSlice([][]const u8 {zig_exe, - "build-exe", tmp_source_file_name, - "--output", tmp_bin_file_name, + try build_args.appendSlice([][]const u8{ + zig_exe, + "build-exe", + tmp_source_file_name, + "--output", + tmp_bin_file_name, }); try out.print("
$ zig build-exe {}.zig", code.name);
                         switch (code.mode) {
@@ -766,10 +774,9 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                             try build_args.append("c");
                             try out.print(" --library c");
                         }
-                        _ = exec(allocator, build_args.toSliceConst()) catch return parseError(
-                            tokenizer, code.source_token, "example failed to compile");
+                        _ = exec(allocator, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile");
 
-                        const run_args = [][]const u8 {tmp_bin_file_name};
+                        const run_args = [][]const u8{tmp_bin_file_name};
 
                         const result = if (expected_outcome == ExpectedOutcome.Fail) blk: {
                             const result = try os.ChildProcess.exec(allocator, run_args, null, null, max_doc_file_size);
@@ -777,7 +784,10 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                                 os.ChildProcess.Term.Exited => |exit_code| {
                                     if (exit_code == 0) {
                                         warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
-                                        for (run_args) |arg| warn("{} ", arg) else warn("\n");
+                                        for (run_args) |arg|
+                                            warn("{} ", arg)
+                                        else
+                                            warn("\n");
                                         return parseError(tokenizer, code.source_token, "example incorrectly compiled");
                                     }
                                 },
@@ -785,11 +795,9 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                             }
                             break :blk result;
                         } else blk: {
-                            break :blk exec(allocator, run_args) catch return parseError(
-                                tokenizer, code.source_token, "example crashed");
+                            break :blk exec(allocator, run_args) catch return parseError(tokenizer, code.source_token, "example crashed");
                         };
 
-                        
                         const escaped_stderr = try escapeHtml(allocator, result.stderr);
                         const escaped_stdout = try escapeHtml(allocator, result.stdout);
 
@@ -802,7 +810,11 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                         var test_args = std.ArrayList([]const u8).init(allocator);
                         defer test_args.deinit();
 
-                        try test_args.appendSlice([][]const u8 {zig_exe, "test", tmp_source_file_name});
+                        try test_args.appendSlice([][]const u8{
+                            zig_exe,
+                            "test",
+                            tmp_source_file_name,
+                        });
                         try out.print("
$ zig test {}.zig", code.name);
                         switch (code.mode) {
                             builtin.Mode.Debug => {},
@@ -821,13 +833,15 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                         }
                         if (code.target_windows) {
                             try test_args.appendSlice([][]const u8{
-                                "--target-os", "windows",
-                                "--target-arch", "x86_64",
-                                "--target-environ", "msvc",
+                                "--target-os",
+                                "windows",
+                                "--target-arch",
+                                "x86_64",
+                                "--target-environ",
+                                "msvc",
                             });
                         }
-                        const result = exec(allocator, test_args.toSliceConst()) catch return parseError(
-                            tokenizer, code.source_token, "test failed");
+                        const result = exec(allocator, test_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "test failed");
                         const escaped_stderr = try escapeHtml(allocator, result.stderr);
                         const escaped_stdout = try escapeHtml(allocator, result.stdout);
                         try out.print("\n{}{}
\n", escaped_stderr, escaped_stdout);
@@ -836,7 +850,13 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                         var test_args = std.ArrayList([]const u8).init(allocator);
                         defer test_args.deinit();
 
-                        try test_args.appendSlice([][]const u8 {zig_exe, "test", "--color", "on", tmp_source_file_name});
+                        try test_args.appendSlice([][]const u8{
+                            zig_exe,
+                            "test",
+                            "--color",
+                            "on",
+                            tmp_source_file_name,
+                        });
                         try out.print("
$ zig test {}.zig", code.name);
                         switch (code.mode) {
                             builtin.Mode.Debug => {},
@@ -858,13 +878,19 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                             os.ChildProcess.Term.Exited => |exit_code| {
                                 if (exit_code == 0) {
                                     warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
-                                    for (test_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n");
+                                    for (test_args.toSliceConst()) |arg|
+                                        warn("{} ", arg)
+                                    else
+                                        warn("\n");
                                     return parseError(tokenizer, code.source_token, "example incorrectly compiled");
                                 }
                             },
                             else => {
                                 warn("{}\nThe following command crashed:\n", result.stderr);
-                                for (test_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n");
+                                for (test_args.toSliceConst()) |arg|
+                                    warn("{} ", arg)
+                                else
+                                    warn("\n");
                                 return parseError(tokenizer, code.source_token, "example compile crashed");
                             },
                         }
@@ -881,7 +907,11 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                         var test_args = std.ArrayList([]const u8).init(allocator);
                         defer test_args.deinit();
 
-                        try test_args.appendSlice([][]const u8 {zig_exe, "test", tmp_source_file_name});
+                        try test_args.appendSlice([][]const u8{
+                            zig_exe,
+                            "test",
+                            tmp_source_file_name,
+                        });
                         switch (code.mode) {
                             builtin.Mode.Debug => {},
                             builtin.Mode.ReleaseSafe => try test_args.append("--release-safe"),
@@ -894,13 +924,19 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                             os.ChildProcess.Term.Exited => |exit_code| {
                                 if (exit_code == 0) {
                                     warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
-                                    for (test_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n");
+                                    for (test_args.toSliceConst()) |arg|
+                                        warn("{} ", arg)
+                                    else
+                                        warn("\n");
                                     return parseError(tokenizer, code.source_token, "example test incorrectly succeeded");
                                 }
                             },
                             else => {
                                 warn("{}\nThe following command crashed:\n", result.stderr);
-                                for (test_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n");
+                                for (test_args.toSliceConst()) |arg|
+                                    warn("{} ", arg)
+                                else
+                                    warn("\n");
                                 return parseError(tokenizer, code.source_token, "example compile crashed");
                             },
                         }
@@ -918,9 +954,15 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                         var build_args = std.ArrayList([]const u8).init(allocator);
                         defer build_args.deinit();
 
-                        try build_args.appendSlice([][]const u8 {zig_exe, "build-obj", tmp_source_file_name,
-                            "--color", "on",
-                            "--output", tmp_obj_file_name});
+                        try build_args.appendSlice([][]const u8{
+                            zig_exe,
+                            "build-obj",
+                            tmp_source_file_name,
+                            "--color",
+                            "on",
+                            "--output",
+                            tmp_obj_file_name,
+                        });
 
                         if (!code.is_inline) {
                             try out.print("
$ zig build-obj {}.zig", code.name);
@@ -954,13 +996,19 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                                 os.ChildProcess.Term.Exited => |exit_code| {
                                     if (exit_code == 0) {
                                         warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
-                                        for (build_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n");
+                                        for (build_args.toSliceConst()) |arg|
+                                            warn("{} ", arg)
+                                        else
+                                            warn("\n");
                                         return parseError(tokenizer, code.source_token, "example build incorrectly succeeded");
                                     }
                                 },
                                 else => {
                                     warn("{}\nThe following command crashed:\n", result.stderr);
-                                    for (build_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n");
+                                    for (build_args.toSliceConst()) |arg|
+                                        warn("{} ", arg)
+                                    else
+                                        warn("\n");
                                     return parseError(tokenizer, code.source_token, "example compile crashed");
                                 },
                             }
@@ -975,8 +1023,7 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
                                 try out.print("
\n");
                             }
                         } else {
-                            _ = exec(allocator, build_args.toSliceConst()) catch return parseError(
-                                tokenizer, code.source_token, "example failed to compile");
+                            _ = exec(allocator, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile");
                         }
                         if (!code.is_inline) {
                             try out.print("
\n");
@@ -987,7 +1034,6 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
             },
         }
     }
-
 }
 
 fn exec(allocator: &mem.Allocator, args: []const []const u8) !os.ChildProcess.ExecResult {
@@ -996,13 +1042,19 @@ fn exec(allocator: &mem.Allocator, args: []const []const u8) !os.ChildProcess.Ex
         os.ChildProcess.Term.Exited => |exit_code| {
             if (exit_code != 0) {
                 warn("{}\nThe following command exited with code {}:\n", result.stderr, exit_code);
-                for (args) |arg| warn("{} ", arg) else warn("\n");
+                for (args) |arg|
+                    warn("{} ", arg)
+                else
+                    warn("\n");
                 return error.ChildExitError;
             }
         },
         else => {
             warn("{}\nThe following command crashed:\n", result.stderr);
-            for (args) |arg| warn("{} ", arg) else warn("\n");
+            for (args) |arg|
+                warn("{} ", arg)
+            else
+                warn("\n");
             return error.ChildCrashed;
         },
     }
diff --git a/example/guess_number/main.zig b/example/guess_number/main.zig
index 7178c5274ad666025f7f5921d311291dc31eb0dc..bed132b25c6701d15354866bb196585a0fbe46ea 100644
--- a/example/guess_number/main.zig
+++ b/example/guess_number/main.zig
@@ -23,7 +23,7 @@ pub fn main() !void {
 
     while (true) {
         try stdout.print("\nGuess a number between 1 and 100: ");
-        var line_buf : [20]u8 = undefined;
+        var line_buf: [20]u8 = undefined;
 
         const line_len = io.readLine(line_buf[0..]) catch |err| switch (err) {
             error.InputTooLong => {
diff --git a/example/hello_world/hello_libc.zig b/example/hello_world/hello_libc.zig
index 4a35e47b157b9cd0487f9759ed2cbab6f9754051..1df8f04ce493dd40f97448b5bf163eda7014e933 100644
--- a/example/hello_world/hello_libc.zig
+++ b/example/hello_world/hello_libc.zig
@@ -8,8 +8,7 @@ const c = @cImport({
 const msg = c"Hello, world!\n";
 
 export fn main(argc: c_int, argv: &&u8) c_int {
-    if (c.printf(msg) != c_int(c.strlen(msg)))
-        return -1;
+    if (c.printf(msg) != c_int(c.strlen(msg))) return -1;
 
     return 0;
 }
diff --git a/example/mix_o_files/build.zig b/example/mix_o_files/build.zig
index 43804868678109327afa46e73befa505dbf546cc..e5d2e6a4466103275013cd1f365371d5f2d40d95 100644
--- a/example/mix_o_files/build.zig
+++ b/example/mix_o_files/build.zig
@@ -4,9 +4,7 @@ pub fn build(b: &Builder) void {
     const obj = b.addObject("base64", "base64.zig");
 
     const exe = b.addCExecutable("test");
-    exe.addCompileFlags([][]const u8 {
-        "-std=c99",
-    });
+    exe.addCompileFlags([][]const u8{"-std=c99"});
     exe.addSourceFile("test.c");
     exe.addObject(obj);
 
diff --git a/example/shared_library/build.zig b/example/shared_library/build.zig
index 2b5a178b356b05dfe043c21045ada401165badf7..30c714c6c6c7ddee70e9e7b94a673dfee5c950b8 100644
--- a/example/shared_library/build.zig
+++ b/example/shared_library/build.zig
@@ -4,9 +4,7 @@ pub fn build(b: &Builder) void {
     const lib = b.addSharedLibrary("mathtest", "mathtest.zig", b.version(1, 0, 0));
 
     const exe = b.addCExecutable("test");
-    exe.addCompileFlags([][]const u8 {
-        "-std=c99",
-    });
+    exe.addCompileFlags([][]const u8{"-std=c99"});
     exe.addSourceFile("test.c");
     exe.linkLibrary(lib);
 
diff --git a/src-self-hosted/introspect.zig b/src-self-hosted/introspect.zig
index 3f1fefdd5a3f5c9b43fa935e974916e95dc69b61..adab00286bdb2ec14f418824530092b132642444 100644
--- a/src-self-hosted/introspect.zig
+++ b/src-self-hosted/introspect.zig
@@ -48,9 +48,7 @@ pub fn resolveZigLibDir(allocator: &mem.Allocator) ![]u8 {
             \\Unable to find zig lib directory: {}.
             \\Reinstall Zig or use --zig-install-prefix.
             \\
-            ,
-            @errorName(err)
-        );
+        , @errorName(err));
 
         return error.ZigLibDirNotFound;
     };
diff --git a/src-self-hosted/ir.zig b/src-self-hosted/ir.zig
index b66a0abdeefb690f9c33e936bcf418bd0743de96..c4550b5179ac8946cebdfe668c73da0beb0bad0b 100644
--- a/src-self-hosted/ir.zig
+++ b/src-self-hosted/ir.zig
@@ -108,5 +108,4 @@ pub const Instruction = struct {
         ArgType,
         Export,
     };
-
 };
diff --git a/src-self-hosted/main.zig b/src-self-hosted/main.zig
index 22f49e80d95da07cca88ae1ddbf9aed5de594165..f54bdbdaf0f8ccc58aef18f3b16ac8a83cc4e32f 100644
--- a/src-self-hosted/main.zig
+++ b/src-self-hosted/main.zig
@@ -37,7 +37,7 @@ const usage =
     \\  zen                          Print zen of zig and exit
     \\
     \\
-    ;
+;
 
 const Command = struct {
     name: []const u8,
@@ -63,22 +63,61 @@ pub fn main() !void {
         os.exit(1);
     }
 
-    const commands = []Command {
-        Command { .name = "build",       .exec = cmdBuild      },
-        Command { .name = "build-exe",   .exec = cmdBuildExe   },
-        Command { .name = "build-lib",   .exec = cmdBuildLib   },
-        Command { .name = "build-obj",   .exec = cmdBuildObj   },
-        Command { .name = "fmt",         .exec = cmdFmt        },
-        Command { .name = "run",         .exec = cmdRun        },
-        Command { .name = "targets",     .exec = cmdTargets    },
-        Command { .name = "test",        .exec = cmdTest       },
-        Command { .name = "translate-c", .exec = cmdTranslateC },
-        Command { .name = "version",     .exec = cmdVersion    },
-        Command { .name = "zen",         .exec = cmdZen        },
+    const commands = []Command{
+        Command{
+            .name = "build",
+            .exec = cmdBuild,
+        },
+        Command{
+            .name = "build-exe",
+            .exec = cmdBuildExe,
+        },
+        Command{
+            .name = "build-lib",
+            .exec = cmdBuildLib,
+        },
+        Command{
+            .name = "build-obj",
+            .exec = cmdBuildObj,
+        },
+        Command{
+            .name = "fmt",
+            .exec = cmdFmt,
+        },
+        Command{
+            .name = "run",
+            .exec = cmdRun,
+        },
+        Command{
+            .name = "targets",
+            .exec = cmdTargets,
+        },
+        Command{
+            .name = "test",
+            .exec = cmdTest,
+        },
+        Command{
+            .name = "translate-c",
+            .exec = cmdTranslateC,
+        },
+        Command{
+            .name = "version",
+            .exec = cmdVersion,
+        },
+        Command{
+            .name = "zen",
+            .exec = cmdZen,
+        },
 
         // undocumented commands
-        Command { .name = "help",        .exec = cmdHelp       },
-        Command { .name = "internal",    .exec = cmdInternal   },
+        Command{
+            .name = "help",
+            .exec = cmdHelp,
+        },
+        Command{
+            .name = "internal",
+            .exec = cmdInternal,
+        },
     };
 
     for (commands) |command| {
@@ -120,9 +159,9 @@ const usage_build =
     \\   --verbose-cimport            Enable compiler debug output for C imports
     \\
     \\
-    ;
+;
 
-const args_build_spec = []Flag {
+const args_build_spec = []Flag{
     Flag.Bool("--help"),
     Flag.Bool("--init"),
     Flag.Arg1("--build-file"),
@@ -148,7 +187,7 @@ const missing_build_file =
     \\
     \\See: `zig build --help` or `zig help` for more options.
     \\
-    ;
+;
 
 fn cmdBuild(allocator: &Allocator, args: []const []const u8) !void {
     var flags = try Args.parse(allocator, args_build_spec, args);
@@ -317,15 +356,23 @@ const usage_build_generic =
     \\  --ver-patch [ver]            Dynamic library semver patch version
     \\
     \\
-    ;
+;
 
-const args_build_generic = []Flag {
+const args_build_generic = []Flag{
     Flag.Bool("--help"),
-    Flag.Option("--color", []const []const u8 { "auto", "off", "on" }),
+    Flag.Option("--color", []const []const u8{
+        "auto",
+        "off",
+        "on",
+    }),
 
     Flag.ArgMergeN("--assembly", 1),
     Flag.Arg1("--cache-dir"),
-    Flag.Option("--emit", []const []const u8 { "asm", "bin", "llvm-ir" }),
+    Flag.Option("--emit", []const []const u8{
+        "asm",
+        "bin",
+        "llvm-ir",
+    }),
     Flag.Bool("--enable-timing-info"),
     Flag.Arg1("--libc-include-dir"),
     Flag.Arg1("--name"),
@@ -471,7 +518,7 @@ fn buildOutputType(allocator: &Allocator, args: []const []const u8, out_type: Mo
         os.exit(1);
     };
 
-    const asm_a= flags.many("assembly");
+    const asm_a = flags.many("assembly");
     const obj_a = flags.many("object");
     if (in_file == null and (obj_a == null or (??obj_a).len == 0) and (asm_a == null or (??asm_a).len == 0)) {
         try stderr.write("Expected source file argument or at least one --object or --assembly argument\n");
@@ -493,17 +540,16 @@ fn buildOutputType(allocator: &Allocator, args: []const []const u8, out_type: Mo
     const zig_lib_dir = introspect.resolveZigLibDir(allocator) catch os.exit(1);
     defer allocator.free(zig_lib_dir);
 
-    var module =
-        try Module.create(
-            allocator,
-            root_name,
-            zig_root_source_file,
-            Target.Native,
-            out_type,
-            build_mode,
-            zig_lib_dir,
-            full_cache_dir
-        );
+    var module = try Module.create(
+        allocator,
+        root_name,
+        zig_root_source_file,
+        Target.Native,
+        out_type,
+        build_mode,
+        zig_lib_dir,
+        full_cache_dir,
+    );
     defer module.destroy();
 
     module.version_major = try std.fmt.parseUnsigned(u32, flags.single("ver-major") ?? "0", 10);
@@ -588,10 +634,10 @@ fn buildOutputType(allocator: &Allocator, args: []const []const u8, out_type: Mo
     }
 
     if (flags.single("mmacosx-version-min")) |ver| {
-        module.darwin_version_min = Module.DarwinVersionMin { .MacOS = ver };
+        module.darwin_version_min = Module.DarwinVersionMin{ .MacOS = ver };
     }
     if (flags.single("mios-version-min")) |ver| {
-        module.darwin_version_min = Module.DarwinVersionMin { .Ios = ver };
+        module.darwin_version_min = Module.DarwinVersionMin{ .Ios = ver };
     }
 
     module.emit_file_type = emit_type;
@@ -639,11 +685,9 @@ const usage_fmt =
     \\   --help                 Print this help and exit
     \\
     \\
-    ;
+;
 
-const args_fmt_spec = []Flag {
-    Flag.Bool("--help"),
-};
+const args_fmt_spec = []Flag{Flag.Bool("--help")};
 
 fn cmdFmt(allocator: &Allocator, args: []const []const u8) !void {
     var flags = try Args.parse(allocator, args_fmt_spec, args);
@@ -675,7 +719,6 @@ fn cmdFmt(allocator: &Allocator, args: []const []const u8) !void {
         };
         defer tree.deinit();
 
-
         var error_it = tree.errors.iterator(0);
         while (error_it.next()) |parse_error| {
             const token = tree.tokens.at(parse_error.loc());
@@ -721,8 +764,7 @@ fn cmdTargets(allocator: &Allocator, args: []const []const u8) !void {
         inline while (i < @memberCount(builtin.Arch)) : (i += 1) {
             comptime const arch_tag = @memberName(builtin.Arch, i);
             // NOTE: Cannot use empty string, see #918.
-            comptime const native_str =
-                if (comptime mem.eql(u8, arch_tag, @tagName(builtin.arch))) " (native)\n" else "\n";
+            comptime const native_str = if (comptime mem.eql(u8, arch_tag, @tagName(builtin.arch))) " (native)\n" else "\n";
 
             try stdout.print("  {}{}", arch_tag, native_str);
         }
@@ -735,8 +777,7 @@ fn cmdTargets(allocator: &Allocator, args: []const []const u8) !void {
         inline while (i < @memberCount(builtin.Os)) : (i += 1) {
             comptime const os_tag = @memberName(builtin.Os, i);
             // NOTE: Cannot use empty string, see #918.
-            comptime const native_str =
-                if (comptime mem.eql(u8, os_tag, @tagName(builtin.os))) " (native)\n" else "\n";
+            comptime const native_str = if (comptime mem.eql(u8, os_tag, @tagName(builtin.os))) " (native)\n" else "\n";
 
             try stdout.print("  {}{}", os_tag, native_str);
         }
@@ -749,8 +790,7 @@ fn cmdTargets(allocator: &Allocator, args: []const []const u8) !void {
         inline while (i < @memberCount(builtin.Environ)) : (i += 1) {
             comptime const environ_tag = @memberName(builtin.Environ, i);
             // NOTE: Cannot use empty string, see #918.
-            comptime const native_str =
-                if (comptime mem.eql(u8, environ_tag, @tagName(builtin.environ))) " (native)\n" else "\n";
+            comptime const native_str = if (comptime mem.eql(u8, environ_tag, @tagName(builtin.environ))) " (native)\n" else "\n";
 
             try stdout.print("  {}{}", environ_tag, native_str);
         }
@@ -772,12 +812,9 @@ const usage_test =
     \\   --help                 Print this help and exit
     \\
     \\
-    ;
-
-const args_test_spec = []Flag {
-    Flag.Bool("--help"),
-};
+;
 
+const args_test_spec = []Flag{Flag.Bool("--help")};
 
 fn cmdTest(allocator: &Allocator, args: []const []const u8) !void {
     var flags = try Args.parse(allocator, args_build_spec, args);
@@ -810,21 +847,18 @@ const usage_run =
     \\   --help                 Print this help and exit
     \\
     \\
-    ;
-
-const args_run_spec = []Flag {
-    Flag.Bool("--help"),
-};
+;
 
+const args_run_spec = []Flag{Flag.Bool("--help")};
 
 fn cmdRun(allocator: &Allocator, args: []const []const u8) !void {
     var compile_args = args;
-    var runtime_args: []const []const u8 = []const []const u8 {};
+    var runtime_args: []const []const u8 = []const []const u8{};
 
     for (args) |argv, i| {
         if (mem.eql(u8, argv, "--")) {
             compile_args = args[0..i];
-            runtime_args = args[i+1..];
+            runtime_args = args[i + 1..];
             break;
         }
     }
@@ -858,9 +892,9 @@ const usage_translate_c =
     \\  --output [path]              Output file to write generated zig file (default: stdout)
     \\
     \\
-    ;
+;
 
-const args_translate_c_spec = []Flag {
+const args_translate_c_spec = []Flag{
     Flag.Bool("--help"),
     Flag.Bool("--enable-timing-info"),
     Flag.Arg1("--libc-include-dir"),
@@ -934,7 +968,7 @@ const info_zen =
     \\ * Together we serve end users.
     \\
     \\
-    ;
+;
 
 fn cmdZen(allocator: &Allocator, args: []const []const u8) !void {
     try stdout.write(info_zen);
@@ -949,7 +983,7 @@ const usage_internal =
     \\  build-info                   Print static compiler build-info
     \\
     \\
-    ;
+;
 
 fn cmdInternal(allocator: &Allocator, args: []const []const u8) !void {
     if (args.len == 0) {
@@ -957,9 +991,10 @@ fn cmdInternal(allocator: &Allocator, args: []const []const u8) !void {
         os.exit(1);
     }
 
-    const sub_commands = []Command {
-        Command { .name = "build-info", .exec = cmdInternalBuildInfo },
-    };
+    const sub_commands = []Command{Command{
+        .name = "build-info",
+        .exec = cmdInternalBuildInfo,
+    }};
 
     for (sub_commands) |sub_command| {
         if (mem.eql(u8, sub_command.name, args[0])) {
@@ -983,7 +1018,7 @@ fn cmdInternalBuildInfo(allocator: &Allocator, args: []const []const u8) !void {
         \\ZIG_C_HEADER_FILES   {}
         \\ZIG_DIA_GUIDS_LIB    {}
         \\
-        ,
+    ,
         std.cstr.toSliceConst(c.ZIG_CMAKE_BINARY_DIR),
         std.cstr.toSliceConst(c.ZIG_CXX_COMPILER),
         std.cstr.toSliceConst(c.ZIG_LLVM_CONFIG_EXE),
diff --git a/src-self-hosted/target.zig b/src-self-hosted/target.zig
index 27a90bd0968efd5ee771d357653071b050a7bbc5..7983a3ddec7b6a80787920209d260d5a43c60737 100644
--- a/src-self-hosted/target.zig
+++ b/src-self-hosted/target.zig
@@ -38,8 +38,7 @@ pub const Target = union(enum) {
 
     pub fn isDarwin(self: &const Target) bool {
         return switch (self.getOs()) {
-            builtin.Os.ios,
-            builtin.Os.macosx => true,
+            builtin.Os.ios, builtin.Os.macosx => true,
             else => false,
         };
     }
diff --git a/std/array_list.zig b/std/array_list.zig
index d1165c626da0c7d5c4fd7955e47d8260f220a1b8..679f7d73b8c654cef6e5fc2017598144f23b6819 100644
--- a/std/array_list.zig
+++ b/std/array_list.zig
@@ -150,7 +150,10 @@ pub fn AlignedArrayList(comptime T: type, comptime A: u29) type {
         };
 
         pub fn iterator(self: &const Self) Iterator {
-            return Iterator { .list = self, .count = 0 };
+            return Iterator{
+                .list = self,
+                .count = 0,
+            };
         }
     };
 }
@@ -207,7 +210,7 @@ test "iterator ArrayList test" {
     try list.append(2);
     try list.append(3);
 
-    var count : i32 = 0;
+    var count: i32 = 0;
     var it = list.iterator();
     while (it.next()) |next| {
         assert(next == count + 1);
@@ -225,7 +228,7 @@ test "iterator ArrayList test" {
     }
 
     it.reset();
-    assert(?? it.next() == 1);
+    assert(??it.next() == 1);
 }
 
 test "insert ArrayList test" {
diff --git a/std/base64.zig b/std/base64.zig
index 13f3ea5714e22dd55025a1120169f0b6330e5cc6..515738a99e3f6f6ceb0af6ef3162cd626f35b837 100644
--- a/std/base64.zig
+++ b/std/base64.zig
@@ -41,12 +41,10 @@ pub const Base64Encoder = struct {
             dest[out_index] = encoder.alphabet_chars[(source[i] >> 2) & 0x3f];
             out_index += 1;
 
-            dest[out_index] = encoder.alphabet_chars[((source[i] & 0x3) << 4) |
-                              ((source[i + 1] & 0xf0) >> 4)];
+            dest[out_index] = encoder.alphabet_chars[((source[i] & 0x3) << 4) | ((source[i + 1] & 0xf0) >> 4)];
             out_index += 1;
 
-            dest[out_index] = encoder.alphabet_chars[((source[i + 1] & 0xf) << 2) |
-                              ((source[i + 2] & 0xc0) >> 6)];
+            dest[out_index] = encoder.alphabet_chars[((source[i + 1] & 0xf) << 2) | ((source[i + 2] & 0xc0) >> 6)];
             out_index += 1;
 
             dest[out_index] = encoder.alphabet_chars[source[i + 2] & 0x3f];
@@ -64,8 +62,7 @@ pub const Base64Encoder = struct {
                 dest[out_index] = encoder.pad_char;
                 out_index += 1;
             } else {
-                dest[out_index] = encoder.alphabet_chars[((source[i] & 0x3) << 4) |
-                                  ((source[i + 1] & 0xf0) >> 4)];
+                dest[out_index] = encoder.alphabet_chars[((source[i] & 0x3) << 4) | ((source[i + 1] & 0xf0) >> 4)];
                 out_index += 1;
 
                 dest[out_index] = encoder.alphabet_chars[(source[i + 1] & 0xf) << 2];
@@ -131,26 +128,20 @@ pub const Base64Decoder = struct {
                 // common case
                 if (!decoder.char_in_alphabet[source[src_cursor + 2]]) return error.InvalidCharacter;
                 if (!decoder.char_in_alphabet[source[src_cursor + 3]]) return error.InvalidCharacter;
-                dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 |
-                                        decoder.char_to_index[source[src_cursor + 1]] >> 4;
-                dest[dest_cursor + 1] = decoder.char_to_index[source[src_cursor + 1]] << 4 |
-                                        decoder.char_to_index[source[src_cursor + 2]] >> 2;
-                dest[dest_cursor + 2] = decoder.char_to_index[source[src_cursor + 2]] << 6 |
-                                        decoder.char_to_index[source[src_cursor + 3]];
+                dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | decoder.char_to_index[source[src_cursor + 1]] >> 4;
+                dest[dest_cursor + 1] = decoder.char_to_index[source[src_cursor + 1]] << 4 | decoder.char_to_index[source[src_cursor + 2]] >> 2;
+                dest[dest_cursor + 2] = decoder.char_to_index[source[src_cursor + 2]] << 6 | decoder.char_to_index[source[src_cursor + 3]];
                 dest_cursor += 3;
             } else if (source[src_cursor + 2] != decoder.pad_char) {
                 // one pad char
                 if (!decoder.char_in_alphabet[source[src_cursor + 2]]) return error.InvalidCharacter;
-                dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 |
-                                        decoder.char_to_index[source[src_cursor + 1]] >> 4;
-                dest[dest_cursor + 1] = decoder.char_to_index[source[src_cursor + 1]] << 4 |
-                                        decoder.char_to_index[source[src_cursor + 2]] >> 2;
+                dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | decoder.char_to_index[source[src_cursor + 1]] >> 4;
+                dest[dest_cursor + 1] = decoder.char_to_index[source[src_cursor + 1]] << 4 | decoder.char_to_index[source[src_cursor + 2]] >> 2;
                 if (decoder.char_to_index[source[src_cursor + 2]] << 6 != 0) return error.InvalidPadding;
                 dest_cursor += 2;
             } else {
                 // two pad chars
-                dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 |
-                                        decoder.char_to_index[source[src_cursor + 1]] >> 4;
+                dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | decoder.char_to_index[source[src_cursor + 1]] >> 4;
                 if (decoder.char_to_index[source[src_cursor + 1]] << 4 != 0) return error.InvalidPadding;
                 dest_cursor += 1;
             }
@@ -165,7 +156,7 @@ pub const Base64DecoderWithIgnore = struct {
     decoder: Base64Decoder,
     char_is_ignored: [256]bool,
     pub fn init(alphabet_chars: []const u8, pad_char: u8, ignore_chars: []const u8) Base64DecoderWithIgnore {
-        var result = Base64DecoderWithIgnore {
+        var result = Base64DecoderWithIgnore{
             .decoder = Base64Decoder.init(alphabet_chars, pad_char),
             .char_is_ignored = []bool{false} ** 256,
         };
@@ -223,10 +214,12 @@ pub const Base64DecoderWithIgnore = struct {
                         } else if (decoder_with_ignore.char_is_ignored[c]) {
                             // we can even ignore chars during the padding
                             continue;
-                        } else return error.InvalidCharacter;
+                        } else
+                            return error.InvalidCharacter;
                     }
                     break;
-                } else return error.InvalidCharacter;
+                } else
+                    return error.InvalidCharacter;
             }
 
             switch (available_chars) {
@@ -234,22 +227,17 @@ pub const Base64DecoderWithIgnore = struct {
                     // common case
                     if (dest_cursor + 3 > dest.len) return error.OutputTooSmall;
                     assert(pad_char_count == 0);
-                    dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 |
-                                            decoder.char_to_index[next_4_chars[1]] >> 4;
-                    dest[dest_cursor + 1] = decoder.char_to_index[next_4_chars[1]] << 4 |
-                                            decoder.char_to_index[next_4_chars[2]] >> 2;
-                    dest[dest_cursor + 2] = decoder.char_to_index[next_4_chars[2]] << 6 |
-                                            decoder.char_to_index[next_4_chars[3]];
+                    dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | decoder.char_to_index[next_4_chars[1]] >> 4;
+                    dest[dest_cursor + 1] = decoder.char_to_index[next_4_chars[1]] << 4 | decoder.char_to_index[next_4_chars[2]] >> 2;
+                    dest[dest_cursor + 2] = decoder.char_to_index[next_4_chars[2]] << 6 | decoder.char_to_index[next_4_chars[3]];
                     dest_cursor += 3;
                     continue;
                 },
                 3 => {
                     if (dest_cursor + 2 > dest.len) return error.OutputTooSmall;
                     if (pad_char_count != 1) return error.InvalidPadding;
-                    dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 |
-                                            decoder.char_to_index[next_4_chars[1]] >> 4;
-                    dest[dest_cursor + 1] = decoder.char_to_index[next_4_chars[1]] << 4 |
-                                            decoder.char_to_index[next_4_chars[2]] >> 2;
+                    dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | decoder.char_to_index[next_4_chars[1]] >> 4;
+                    dest[dest_cursor + 1] = decoder.char_to_index[next_4_chars[1]] << 4 | decoder.char_to_index[next_4_chars[2]] >> 2;
                     if (decoder.char_to_index[next_4_chars[2]] << 6 != 0) return error.InvalidPadding;
                     dest_cursor += 2;
                     break;
@@ -257,8 +245,7 @@ pub const Base64DecoderWithIgnore = struct {
                 2 => {
                     if (dest_cursor + 1 > dest.len) return error.OutputTooSmall;
                     if (pad_char_count != 2) return error.InvalidPadding;
-                    dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 |
-                                            decoder.char_to_index[next_4_chars[1]] >> 4;
+                    dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | decoder.char_to_index[next_4_chars[1]] >> 4;
                     if (decoder.char_to_index[next_4_chars[1]] << 4 != 0) return error.InvalidPadding;
                     dest_cursor += 1;
                     break;
@@ -280,7 +267,6 @@ pub const Base64DecoderWithIgnore = struct {
     }
 };
 
-
 pub const standard_decoder_unsafe = Base64DecoderUnsafe.init(standard_alphabet_chars, standard_pad_char);
 
 pub const Base64DecoderUnsafe = struct {
@@ -291,7 +277,7 @@ pub const Base64DecoderUnsafe = struct {
 
     pub fn init(alphabet_chars: []const u8, pad_char: u8) Base64DecoderUnsafe {
         assert(alphabet_chars.len == 64);
-        var result = Base64DecoderUnsafe {
+        var result = Base64DecoderUnsafe{
             .char_to_index = undefined,
             .pad_char = pad_char,
         };
@@ -321,16 +307,13 @@ pub const Base64DecoderUnsafe = struct {
         }
 
         while (in_buf_len > 4) {
-            dest[dest_index] = decoder.char_to_index[source[src_index + 0]] << 2 |
-                               decoder.char_to_index[source[src_index + 1]] >> 4;
+            dest[dest_index] = decoder.char_to_index[source[src_index + 0]] << 2 | decoder.char_to_index[source[src_index + 1]] >> 4;
             dest_index += 1;
 
-            dest[dest_index] = decoder.char_to_index[source[src_index + 1]] << 4 |
-                               decoder.char_to_index[source[src_index + 2]] >> 2;
+            dest[dest_index] = decoder.char_to_index[source[src_index + 1]] << 4 | decoder.char_to_index[source[src_index + 2]] >> 2;
             dest_index += 1;
 
-            dest[dest_index] = decoder.char_to_index[source[src_index + 2]] << 6 |
-                               decoder.char_to_index[source[src_index + 3]];
+            dest[dest_index] = decoder.char_to_index[source[src_index + 2]] << 6 | decoder.char_to_index[source[src_index + 3]];
             dest_index += 1;
 
             src_index += 4;
@@ -338,18 +321,15 @@ pub const Base64DecoderUnsafe = struct {
         }
 
         if (in_buf_len > 1) {
-            dest[dest_index] = decoder.char_to_index[source[src_index + 0]] << 2 |
-                               decoder.char_to_index[source[src_index + 1]] >> 4;
+            dest[dest_index] = decoder.char_to_index[source[src_index + 0]] << 2 | decoder.char_to_index[source[src_index + 1]] >> 4;
             dest_index += 1;
         }
         if (in_buf_len > 2) {
-            dest[dest_index] = decoder.char_to_index[source[src_index + 1]] << 4 |
-                               decoder.char_to_index[source[src_index + 2]] >> 2;
+            dest[dest_index] = decoder.char_to_index[source[src_index + 1]] << 4 | decoder.char_to_index[source[src_index + 2]] >> 2;
             dest_index += 1;
         }
         if (in_buf_len > 3) {
-            dest[dest_index] = decoder.char_to_index[source[src_index + 2]] << 6 |
-                               decoder.char_to_index[source[src_index + 3]];
+            dest[dest_index] = decoder.char_to_index[source[src_index + 2]] << 6 | decoder.char_to_index[source[src_index + 3]];
             dest_index += 1;
         }
     }
@@ -367,7 +347,6 @@ fn calcDecodedSizeExactUnsafe(source: []const u8, pad_char: u8) usize {
     return result;
 }
 
-
 test "base64" {
     @setEvalBranchQuota(8000);
     testBase64() catch unreachable;
@@ -375,26 +354,26 @@ test "base64" {
 }
 
 fn testBase64() !void {
-    try testAllApis("",       "");
-    try testAllApis("f",      "Zg==");
-    try testAllApis("fo",     "Zm8=");
-    try testAllApis("foo",    "Zm9v");
-    try testAllApis("foob",   "Zm9vYg==");
-    try testAllApis("fooba",  "Zm9vYmE=");
+    try testAllApis("", "");
+    try testAllApis("f", "Zg==");
+    try testAllApis("fo", "Zm8=");
+    try testAllApis("foo", "Zm9v");
+    try testAllApis("foob", "Zm9vYg==");
+    try testAllApis("fooba", "Zm9vYmE=");
     try testAllApis("foobar", "Zm9vYmFy");
 
-    try testDecodeIgnoreSpace("",       " ");
-    try testDecodeIgnoreSpace("f",      "Z g= =");
-    try testDecodeIgnoreSpace("fo",     "    Zm8=");
-    try testDecodeIgnoreSpace("foo",    "Zm9v    ");
-    try testDecodeIgnoreSpace("foob",   "Zm9vYg = = ");
-    try testDecodeIgnoreSpace("fooba",  "Zm9v YmE=");
+    try testDecodeIgnoreSpace("", " ");
+    try testDecodeIgnoreSpace("f", "Z g= =");
+    try testDecodeIgnoreSpace("fo", "    Zm8=");
+    try testDecodeIgnoreSpace("foo", "Zm9v    ");
+    try testDecodeIgnoreSpace("foob", "Zm9vYg = = ");
+    try testDecodeIgnoreSpace("fooba", "Zm9v YmE=");
     try testDecodeIgnoreSpace("foobar", " Z m 9 v Y m F y ");
 
     // test getting some api errors
-    try testError("A",    error.InvalidPadding);
-    try testError("AA",   error.InvalidPadding);
-    try testError("AAA",  error.InvalidPadding);
+    try testError("A", error.InvalidPadding);
+    try testError("AA", error.InvalidPadding);
+    try testError("AAA", error.InvalidPadding);
     try testError("A..A", error.InvalidCharacter);
     try testError("AA=A", error.InvalidCharacter);
     try testError("AA/=", error.InvalidPadding);
@@ -427,8 +406,7 @@ fn testAllApis(expected_decoded: []const u8, expected_encoded: []const u8) !void
 
     // Base64DecoderWithIgnore
     {
-        const standard_decoder_ignore_nothing = Base64DecoderWithIgnore.init(
-            standard_alphabet_chars, standard_pad_char, "");
+        const standard_decoder_ignore_nothing = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, "");
         var buffer: [0x100]u8 = undefined;
         var decoded = buffer[0..Base64DecoderWithIgnore.calcSizeUpperBound(expected_encoded.len)];
         var written = try standard_decoder_ignore_nothing.decode(decoded, expected_encoded);
@@ -446,8 +424,7 @@ fn testAllApis(expected_decoded: []const u8, expected_encoded: []const u8) !void
 }
 
 fn testDecodeIgnoreSpace(expected_decoded: []const u8, encoded: []const u8) !void {
-    const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(
-        standard_alphabet_chars, standard_pad_char, " ");
+    const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, " ");
     var buffer: [0x100]u8 = undefined;
     var decoded = buffer[0..Base64DecoderWithIgnore.calcSizeUpperBound(encoded.len)];
     var written = try standard_decoder_ignore_space.decode(decoded, encoded);
@@ -455,8 +432,7 @@ fn testDecodeIgnoreSpace(expected_decoded: []const u8, encoded: []const u8) !voi
 }
 
 fn testError(encoded: []const u8, expected_err: error) !void {
-    const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(
-        standard_alphabet_chars, standard_pad_char, " ");
+    const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, " ");
     var buffer: [0x100]u8 = undefined;
     if (standard_decoder.calcSize(encoded)) |decoded_size| {
         var decoded = buffer[0..decoded_size];
@@ -471,8 +447,7 @@ fn testError(encoded: []const u8, expected_err: error) !void {
 }
 
 fn testOutputTooSmallError(encoded: []const u8) !void {
-    const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(
-        standard_alphabet_chars, standard_pad_char, " ");
+    const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, " ");
     var buffer: [0x100]u8 = undefined;
     var decoded = buffer[0..calcDecodedSizeExactUnsafe(encoded, standard_pad_char) - 1];
     if (standard_decoder_ignore_space.decode(decoded, encoded)) |_| {
diff --git a/std/buf_map.zig b/std/buf_map.zig
index 57c5830bbe8239b509b7df73f59ef96845e08d96..930fc36a7815014c7eacb8fef9697909303ab5c4 100644
--- a/std/buf_map.zig
+++ b/std/buf_map.zig
@@ -12,9 +12,7 @@ pub const BufMap = struct {
     const BufMapHashMap = HashMap([]const u8, []const u8, mem.hash_slice_u8, mem.eql_slice_u8);
 
     pub fn init(allocator: &Allocator) BufMap {
-        var self = BufMap {
-            .hash_map = BufMapHashMap.init(allocator),
-        };
+        var self = BufMap{ .hash_map = BufMapHashMap.init(allocator) };
         return self;
     }
 
diff --git a/std/buf_set.zig b/std/buf_set.zig
index 1badb5bf18b03328c312f089e8efbd7b6c1f403d..c5a80e16fb5bcfb072012d3c52af52680d4632fd 100644
--- a/std/buf_set.zig
+++ b/std/buf_set.zig
@@ -10,9 +10,7 @@ pub const BufSet = struct {
     const BufSetHashMap = HashMap([]const u8, void, mem.hash_slice_u8, mem.eql_slice_u8);
 
     pub fn init(a: &Allocator) BufSet {
-        var self = BufSet {
-            .hash_map = BufSetHashMap.init(a),
-        };
+        var self = BufSet{ .hash_map = BufSetHashMap.init(a) };
         return self;
     }
 
diff --git a/std/build.zig b/std/build.zig
index 276176c63c5ae8b05135ddd9842e6be3951e4ab6..f86c3d394f26dd1a2aced79cc32f6f42ee5f3105 100644
--- a/std/build.zig
+++ b/std/build.zig
@@ -420,15 +420,7 @@ pub const Builder = struct {
         const release_fast = self.option(bool, "release-fast", "optimizations on and safety off") ?? false;
         const release_small = self.option(bool, "release-small", "size optimizations on and safety off") ?? false;
 
-        const mode = if (release_safe and !release_fast and !release_small)
-            builtin.Mode.ReleaseSafe
-        else if (release_fast and !release_safe and !release_small)
-            builtin.Mode.ReleaseFast
-        else if (release_small and !release_fast and !release_safe)
-            builtin.Mode.ReleaseSmall
-        else if (!release_fast and !release_safe and !release_small)
-            builtin.Mode.Debug
-        else x: {
+        const mode = if (release_safe and !release_fast and !release_small) builtin.Mode.ReleaseSafe else if (release_fast and !release_safe and !release_small) builtin.Mode.ReleaseFast else if (release_small and !release_fast and !release_safe) builtin.Mode.ReleaseSmall else if (!release_fast and !release_safe and !release_small) builtin.Mode.Debug else x: {
             warn("Multiple release modes (of -Drelease-safe, -Drelease-fast and -Drelease-small)");
             self.markInvalidUserInput();
             break :x builtin.Mode.Debug;
@@ -649,11 +641,7 @@ pub const Builder = struct {
         if (builtin.environ == builtin.Environ.msvc) {
             return "cl.exe";
         } else {
-            return os.getEnvVarOwned(self.allocator, "CC") catch |err|
-                if (err == error.EnvironmentVariableNotFound)
-                    ([]const u8)("cc")
-                else
-                    debug.panic("Unable to get environment variable: {}", err);
+            return os.getEnvVarOwned(self.allocator, "CC") catch |err| if (err == error.EnvironmentVariableNotFound) ([]const u8)("cc") else debug.panic("Unable to get environment variable: {}", err);
         }
     }
 
@@ -782,8 +770,7 @@ pub const Target = union(enum) {
 
     pub fn isDarwin(self: &const Target) bool {
         return switch (self.getOs()) {
-            builtin.Os.ios,
-            builtin.Os.macosx => true,
+            builtin.Os.ios, builtin.Os.macosx => true,
             else => false,
         };
     }
@@ -990,8 +977,7 @@ pub const LibExeObjStep = struct {
                     self.out_filename = self.builder.fmt("lib{}.a", self.name);
                 } else {
                     switch (self.target.getOs()) {
-                        builtin.Os.ios,
-                        builtin.Os.macosx => {
+                        builtin.Os.ios, builtin.Os.macosx => {
                             self.out_filename = self.builder.fmt("lib{}.{d}.{d}.{d}.dylib", self.name, self.version.major, self.version.minor, self.version.patch);
                             self.major_only_filename = self.builder.fmt("lib{}.{d}.dylib", self.name, self.version.major);
                             self.name_only_filename = self.builder.fmt("lib{}.dylib", self.name);
@@ -1011,11 +997,13 @@ pub const LibExeObjStep = struct {
     }
 
     pub fn setTarget(self: &LibExeObjStep, target_arch: builtin.Arch, target_os: builtin.Os, target_environ: builtin.Environ) void {
-        self.target = Target{ .Cross = CrossTarget{
-            .arch = target_arch,
-            .os = target_os,
-            .environ = target_environ,
-        } };
+        self.target = Target{
+            .Cross = CrossTarget{
+                .arch = target_arch,
+                .os = target_os,
+                .environ = target_environ,
+            },
+        };
         self.computeOutFileNames();
     }
 
@@ -1079,10 +1067,7 @@ pub const LibExeObjStep = struct {
     }
 
     pub fn getOutputPath(self: &LibExeObjStep) []const u8 {
-        return if (self.output_path) |output_path|
-            output_path
-        else
-            os.path.join(self.builder.allocator, self.builder.cache_root, self.out_filename) catch unreachable;
+        return if (self.output_path) |output_path| output_path else os.path.join(self.builder.allocator, self.builder.cache_root, self.out_filename) catch unreachable;
     }
 
     pub fn setOutputHPath(self: &LibExeObjStep, file_path: []const u8) void {
@@ -1095,10 +1080,7 @@ pub const LibExeObjStep = struct {
     }
 
     pub fn getOutputHPath(self: &LibExeObjStep) []const u8 {
-        return if (self.output_h_path) |output_h_path|
-            output_h_path
-        else
-            os.path.join(self.builder.allocator, self.builder.cache_root, self.out_h_filename) catch unreachable;
+        return if (self.output_h_path) |output_h_path| output_h_path else os.path.join(self.builder.allocator, self.builder.cache_root, self.out_h_filename) catch unreachable;
     }
 
     pub fn addAssemblyFile(self: &LibExeObjStep, path: []const u8) void {
@@ -1352,8 +1334,7 @@ pub const LibExeObjStep = struct {
                     args.append("ssp-buffer-size=4") catch unreachable;
                 }
             },
-            builtin.Mode.ReleaseFast,
-            builtin.Mode.ReleaseSmall => {
+            builtin.Mode.ReleaseFast, builtin.Mode.ReleaseSmall => {
                 args.append("-O2") catch unreachable;
                 args.append("-fno-stack-protector") catch unreachable;
             },
@@ -1652,11 +1633,13 @@ pub const TestStep = struct {
     }
 
     pub fn setTarget(self: &TestStep, target_arch: builtin.Arch, target_os: builtin.Os, target_environ: builtin.Environ) void {
-        self.target = Target{ .Cross = CrossTarget{
-            .arch = target_arch,
-            .os = target_os,
-            .environ = target_environ,
-        } };
+        self.target = Target{
+            .Cross = CrossTarget{
+                .arch = target_arch,
+                .os = target_os,
+                .environ = target_environ,
+            },
+        };
     }
 
     pub fn setExecCmd(self: &TestStep, args: []const ?[]const u8) void {
diff --git a/std/c/darwin.zig b/std/c/darwin.zig
index 7ac57514c9a4e7482c4ae832fb1e84c4668d0db5..24be832d01e007182834d1a7ae6ae6971aafa6d8 100644
--- a/std/c/darwin.zig
+++ b/std/c/darwin.zig
@@ -60,7 +60,7 @@ pub const sigset_t = u32;
 
 /// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
 pub const Sigaction = extern struct {
-    handler: extern fn(c_int)void,
+    handler: extern fn(c_int) void,
     sa_mask: sigset_t,
     sa_flags: c_int,
 };
diff --git a/std/c/index.zig b/std/c/index.zig
index 34269d2aa2250ee2f10ba0a9b2e6f16225b267c8..b5e6b48751007da24bca1c5fbec6183874ef89e9 100644
--- a/std/c/index.zig
+++ b/std/c/index.zig
@@ -1,7 +1,7 @@
 const builtin = @import("builtin");
 const Os = builtin.Os;
 
-pub use switch(builtin.os) {
+pub use switch (builtin.os) {
     Os.linux => @import("linux.zig"),
     Os.windows => @import("windows.zig"),
     Os.macosx, Os.ios => @import("darwin.zig"),
@@ -21,8 +21,7 @@ pub extern "c" fn raise(sig: c_int) c_int;
 pub extern "c" fn read(fd: c_int, buf: &c_void, nbyte: usize) isize;
 pub extern "c" fn stat(noalias path: &const u8, noalias buf: &Stat) c_int;
 pub extern "c" fn write(fd: c_int, buf: &const c_void, nbyte: usize) isize;
-pub extern "c" fn mmap(addr: ?&c_void, len: usize, prot: c_int, flags: c_int,
-    fd: c_int, offset: isize) ?&c_void;
+pub extern "c" fn mmap(addr: ?&c_void, len: usize, prot: c_int, flags: c_int, fd: c_int, offset: isize) ?&c_void;
 pub extern "c" fn munmap(addr: &c_void, len: usize) c_int;
 pub extern "c" fn unlink(path: &const u8) c_int;
 pub extern "c" fn getcwd(buf: &u8, size: usize) ?&u8;
@@ -34,8 +33,7 @@ pub extern "c" fn mkdir(path: &const u8, mode: c_uint) c_int;
 pub extern "c" fn symlink(existing: &const u8, new: &const u8) c_int;
 pub extern "c" fn rename(old: &const u8, new: &const u8) c_int;
 pub extern "c" fn chdir(path: &const u8) c_int;
-pub extern "c" fn execve(path: &const u8, argv: &const ?&const u8,
-    envp: &const ?&const u8) c_int;
+pub extern "c" fn execve(path: &const u8, argv: &const ?&const u8, envp: &const ?&const u8) c_int;
 pub extern "c" fn dup(fd: c_int) c_int;
 pub extern "c" fn dup2(old_fd: c_int, new_fd: c_int) c_int;
 pub extern "c" fn readlink(noalias path: &const u8, noalias buf: &u8, bufsize: usize) isize;
@@ -54,9 +52,7 @@ pub extern "c" fn realloc(&c_void, usize) ?&c_void;
 pub extern "c" fn free(&c_void) void;
 pub extern "c" fn posix_memalign(memptr: &&c_void, alignment: usize, size: usize) c_int;
 
-pub extern "pthread" fn pthread_create(noalias newthread: &pthread_t,
-    noalias attr: ?&const pthread_attr_t, start_routine: extern fn(?&c_void) ?&c_void,
-    noalias arg: ?&c_void) c_int;
+pub extern "pthread" fn pthread_create(noalias newthread: &pthread_t, noalias attr: ?&const pthread_attr_t, start_routine: extern fn(?&c_void) ?&c_void, noalias arg: ?&c_void) c_int;
 pub extern "pthread" fn pthread_attr_init(attr: &pthread_attr_t) c_int;
 pub extern "pthread" fn pthread_attr_setstack(attr: &pthread_attr_t, stackaddr: &c_void, stacksize: usize) c_int;
 pub extern "pthread" fn pthread_attr_destroy(attr: &pthread_attr_t) c_int;
diff --git a/std/crypto/md5.zig b/std/crypto/md5.zig
index 705b2428a7860d6c1dfd9d29bd57ecd06a7ec17a..e0473884cd18eda338ab7b02d08be6392c1c238a 100644
--- a/std/crypto/md5.zig
+++ b/std/crypto/md5.zig
@@ -6,12 +6,25 @@ const debug = @import("../debug/index.zig");
 const fmt = @import("../fmt/index.zig");
 
 const RoundParam = struct {
-    a: usize, b: usize, c: usize, d: usize,
-    k: usize, s: u32, t: u32
+    a: usize,
+    b: usize,
+    c: usize,
+    d: usize,
+    k: usize,
+    s: u32,
+    t: u32,
 };
 
 fn Rp(a: usize, b: usize, c: usize, d: usize, k: usize, s: u32, t: u32) RoundParam {
-    return RoundParam { .a = a, .b = b, .c = c, .d = d, .k = k, .s = s, .t = t };
+    return RoundParam{
+        .a = a,
+        .b = b,
+        .c = c,
+        .d = d,
+        .k = k,
+        .s = s,
+        .t = t,
+    };
 }
 
 pub const Md5 = struct {
@@ -99,7 +112,7 @@ pub const Md5 = struct {
         d.round(d.buf[0..]);
 
         for (d.s) |s, j| {
-            mem.writeInt(out[4*j .. 4*j + 4], s, builtin.Endian.Little);
+            mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Little);
         }
     }
 
@@ -112,30 +125,33 @@ pub const Md5 = struct {
         while (i < 16) : (i += 1) {
             // NOTE: Performing or's separately improves perf by ~10%
             s[i] = 0;
-            s[i] |= u32(b[i*4+0]);
-            s[i] |= u32(b[i*4+1]) << 8;
-            s[i] |= u32(b[i*4+2]) << 16;
-            s[i] |= u32(b[i*4+3]) << 24;
+            s[i] |= u32(b[i * 4 + 0]);
+            s[i] |= u32(b[i * 4 + 1]) << 8;
+            s[i] |= u32(b[i * 4 + 2]) << 16;
+            s[i] |= u32(b[i * 4 + 3]) << 24;
         }
 
-        var v: [4]u32 = []u32 {
-            d.s[0], d.s[1], d.s[2], d.s[3],
+        var v: [4]u32 = []u32{
+            d.s[0],
+            d.s[1],
+            d.s[2],
+            d.s[3],
         };
 
-        const round0 = comptime []RoundParam {
-            Rp(0, 1, 2, 3,  0,  7, 0xD76AA478),
-            Rp(3, 0, 1, 2,  1, 12, 0xE8C7B756),
-            Rp(2, 3, 0, 1,  2, 17, 0x242070DB),
-            Rp(1, 2, 3, 0,  3, 22, 0xC1BDCEEE),
-            Rp(0, 1, 2, 3,  4,  7, 0xF57C0FAF),
-            Rp(3, 0, 1, 2,  5, 12, 0x4787C62A),
-            Rp(2, 3, 0, 1,  6, 17, 0xA8304613),
-            Rp(1, 2, 3, 0,  7, 22, 0xFD469501),
-            Rp(0, 1, 2, 3,  8,  7, 0x698098D8),
-            Rp(3, 0, 1, 2,  9, 12, 0x8B44F7AF),
+        const round0 = comptime []RoundParam{
+            Rp(0, 1, 2, 3, 0, 7, 0xD76AA478),
+            Rp(3, 0, 1, 2, 1, 12, 0xE8C7B756),
+            Rp(2, 3, 0, 1, 2, 17, 0x242070DB),
+            Rp(1, 2, 3, 0, 3, 22, 0xC1BDCEEE),
+            Rp(0, 1, 2, 3, 4, 7, 0xF57C0FAF),
+            Rp(3, 0, 1, 2, 5, 12, 0x4787C62A),
+            Rp(2, 3, 0, 1, 6, 17, 0xA8304613),
+            Rp(1, 2, 3, 0, 7, 22, 0xFD469501),
+            Rp(0, 1, 2, 3, 8, 7, 0x698098D8),
+            Rp(3, 0, 1, 2, 9, 12, 0x8B44F7AF),
             Rp(2, 3, 0, 1, 10, 17, 0xFFFF5BB1),
             Rp(1, 2, 3, 0, 11, 22, 0x895CD7BE),
-            Rp(0, 1, 2, 3, 12,  7, 0x6B901122),
+            Rp(0, 1, 2, 3, 12, 7, 0x6B901122),
             Rp(3, 0, 1, 2, 13, 12, 0xFD987193),
             Rp(2, 3, 0, 1, 14, 17, 0xA679438E),
             Rp(1, 2, 3, 0, 15, 22, 0x49B40821),
@@ -145,22 +161,22 @@ pub const Md5 = struct {
             v[r.a] = v[r.b] +% math.rotl(u32, v[r.a], r.s);
         }
 
-        const round1 = comptime []RoundParam {
-            Rp(0, 1, 2, 3,  1,  5, 0xF61E2562),
-            Rp(3, 0, 1, 2,  6,  9, 0xC040B340),
+        const round1 = comptime []RoundParam{
+            Rp(0, 1, 2, 3, 1, 5, 0xF61E2562),
+            Rp(3, 0, 1, 2, 6, 9, 0xC040B340),
             Rp(2, 3, 0, 1, 11, 14, 0x265E5A51),
-            Rp(1, 2, 3, 0,  0, 20, 0xE9B6C7AA),
-            Rp(0, 1, 2, 3,  5,  5, 0xD62F105D),
-            Rp(3, 0, 1, 2, 10,  9, 0x02441453),
+            Rp(1, 2, 3, 0, 0, 20, 0xE9B6C7AA),
+            Rp(0, 1, 2, 3, 5, 5, 0xD62F105D),
+            Rp(3, 0, 1, 2, 10, 9, 0x02441453),
             Rp(2, 3, 0, 1, 15, 14, 0xD8A1E681),
-            Rp(1, 2, 3, 0,  4, 20, 0xE7D3FBC8),
-            Rp(0, 1, 2, 3,  9,  5, 0x21E1CDE6),
-            Rp(3, 0, 1, 2, 14,  9, 0xC33707D6),
-            Rp(2, 3, 0, 1,  3, 14, 0xF4D50D87),
-            Rp(1, 2, 3, 0,  8, 20, 0x455A14ED),
-            Rp(0, 1, 2, 3, 13,  5, 0xA9E3E905),
-            Rp(3, 0, 1, 2,  2,  9, 0xFCEFA3F8),
-            Rp(2, 3, 0, 1,  7, 14, 0x676F02D9),
+            Rp(1, 2, 3, 0, 4, 20, 0xE7D3FBC8),
+            Rp(0, 1, 2, 3, 9, 5, 0x21E1CDE6),
+            Rp(3, 0, 1, 2, 14, 9, 0xC33707D6),
+            Rp(2, 3, 0, 1, 3, 14, 0xF4D50D87),
+            Rp(1, 2, 3, 0, 8, 20, 0x455A14ED),
+            Rp(0, 1, 2, 3, 13, 5, 0xA9E3E905),
+            Rp(3, 0, 1, 2, 2, 9, 0xFCEFA3F8),
+            Rp(2, 3, 0, 1, 7, 14, 0x676F02D9),
             Rp(1, 2, 3, 0, 12, 20, 0x8D2A4C8A),
         };
         inline for (round1) |r| {
@@ -168,46 +184,46 @@ pub const Md5 = struct {
             v[r.a] = v[r.b] +% math.rotl(u32, v[r.a], r.s);
         }
 
-        const round2 = comptime []RoundParam {
-            Rp(0, 1, 2, 3,  5,  4, 0xFFFA3942),
-            Rp(3, 0, 1, 2,  8, 11, 0x8771F681),
+        const round2 = comptime []RoundParam{
+            Rp(0, 1, 2, 3, 5, 4, 0xFFFA3942),
+            Rp(3, 0, 1, 2, 8, 11, 0x8771F681),
             Rp(2, 3, 0, 1, 11, 16, 0x6D9D6122),
             Rp(1, 2, 3, 0, 14, 23, 0xFDE5380C),
-            Rp(0, 1, 2, 3,  1,  4, 0xA4BEEA44),
-            Rp(3, 0, 1, 2,  4, 11, 0x4BDECFA9),
-            Rp(2, 3, 0, 1,  7, 16, 0xF6BB4B60),
+            Rp(0, 1, 2, 3, 1, 4, 0xA4BEEA44),
+            Rp(3, 0, 1, 2, 4, 11, 0x4BDECFA9),
+            Rp(2, 3, 0, 1, 7, 16, 0xF6BB4B60),
             Rp(1, 2, 3, 0, 10, 23, 0xBEBFBC70),
-            Rp(0, 1, 2, 3, 13,  4, 0x289B7EC6),
-            Rp(3, 0, 1, 2,  0, 11, 0xEAA127FA),
-            Rp(2, 3, 0, 1,  3, 16, 0xD4EF3085),
-            Rp(1, 2, 3, 0,  6, 23, 0x04881D05),
-            Rp(0, 1, 2, 3,  9,  4, 0xD9D4D039),
+            Rp(0, 1, 2, 3, 13, 4, 0x289B7EC6),
+            Rp(3, 0, 1, 2, 0, 11, 0xEAA127FA),
+            Rp(2, 3, 0, 1, 3, 16, 0xD4EF3085),
+            Rp(1, 2, 3, 0, 6, 23, 0x04881D05),
+            Rp(0, 1, 2, 3, 9, 4, 0xD9D4D039),
             Rp(3, 0, 1, 2, 12, 11, 0xE6DB99E5),
             Rp(2, 3, 0, 1, 15, 16, 0x1FA27CF8),
-            Rp(1, 2, 3, 0,  2, 23, 0xC4AC5665),
+            Rp(1, 2, 3, 0, 2, 23, 0xC4AC5665),
         };
         inline for (round2) |r| {
             v[r.a] = v[r.a] +% (v[r.b] ^ v[r.c] ^ v[r.d]) +% r.t +% s[r.k];
             v[r.a] = v[r.b] +% math.rotl(u32, v[r.a], r.s);
         }
 
-        const round3 = comptime []RoundParam {
-            Rp(0, 1, 2, 3,  0,  6, 0xF4292244),
-            Rp(3, 0, 1, 2,  7, 10, 0x432AFF97),
+        const round3 = comptime []RoundParam{
+            Rp(0, 1, 2, 3, 0, 6, 0xF4292244),
+            Rp(3, 0, 1, 2, 7, 10, 0x432AFF97),
             Rp(2, 3, 0, 1, 14, 15, 0xAB9423A7),
-            Rp(1, 2, 3, 0,  5, 21, 0xFC93A039),
-            Rp(0, 1, 2, 3, 12,  6, 0x655B59C3),
-            Rp(3, 0, 1, 2,  3, 10, 0x8F0CCC92),
+            Rp(1, 2, 3, 0, 5, 21, 0xFC93A039),
+            Rp(0, 1, 2, 3, 12, 6, 0x655B59C3),
+            Rp(3, 0, 1, 2, 3, 10, 0x8F0CCC92),
             Rp(2, 3, 0, 1, 10, 15, 0xFFEFF47D),
-            Rp(1, 2, 3, 0,  1, 21, 0x85845DD1),
-            Rp(0, 1, 2, 3,  8,  6, 0x6FA87E4F),
+            Rp(1, 2, 3, 0, 1, 21, 0x85845DD1),
+            Rp(0, 1, 2, 3, 8, 6, 0x6FA87E4F),
             Rp(3, 0, 1, 2, 15, 10, 0xFE2CE6E0),
-            Rp(2, 3, 0, 1,  6, 15, 0xA3014314),
+            Rp(2, 3, 0, 1, 6, 15, 0xA3014314),
             Rp(1, 2, 3, 0, 13, 21, 0x4E0811A1),
-            Rp(0, 1, 2, 3,  4,  6, 0xF7537E82),
+            Rp(0, 1, 2, 3, 4, 6, 0xF7537E82),
             Rp(3, 0, 1, 2, 11, 10, 0xBD3AF235),
-            Rp(2, 3, 0, 1,  2, 15, 0x2AD7D2BB),
-            Rp(1, 2, 3, 0,  9, 21, 0xEB86D391),
+            Rp(2, 3, 0, 1, 2, 15, 0x2AD7D2BB),
+            Rp(1, 2, 3, 0, 9, 21, 0xEB86D391),
         };
         inline for (round3) |r| {
             v[r.a] = v[r.a] +% (v[r.c] ^ (v[r.b] | ~v[r.d])) +% r.t +% s[r.k];
@@ -255,7 +271,7 @@ test "md5 streaming" {
 }
 
 test "md5 aligned final" {
-    var block = []u8 {0} ** Md5.block_size;
+    var block = []u8{0} ** Md5.block_size;
     var out: [Md5.digest_size]u8 = undefined;
 
     var h = Md5.init();
diff --git a/std/crypto/sha1.zig b/std/crypto/sha1.zig
index 333597b12d1f2ada176583813d2b38e9bbb22a39..77324b482f74b5a1ef24091d2cb31f6e97948ef6 100644
--- a/std/crypto/sha1.zig
+++ b/std/crypto/sha1.zig
@@ -7,11 +7,23 @@ const builtin = @import("builtin");
 pub const u160 = @IntType(false, 160);
 
 const RoundParam = struct {
-    a: usize, b: usize, c: usize, d: usize, e: usize, i: u32,
+    a: usize,
+    b: usize,
+    c: usize,
+    d: usize,
+    e: usize,
+    i: u32,
 };
 
 fn Rp(a: usize, b: usize, c: usize, d: usize, e: usize, i: u32) RoundParam {
-    return RoundParam { .a = a, .b = b, .c = c, .d = d, .e = e, .i = i };
+    return RoundParam{
+        .a = a,
+        .b = b,
+        .c = c,
+        .d = d,
+        .e = e,
+        .i = i,
+    };
 }
 
 pub const Sha1 = struct {
@@ -99,7 +111,7 @@ pub const Sha1 = struct {
         d.round(d.buf[0..]);
 
         for (d.s) |s, j| {
-            mem.writeInt(out[4*j .. 4*j + 4], s, builtin.Endian.Big);
+            mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Big);
         }
     }
 
@@ -108,21 +120,25 @@ pub const Sha1 = struct {
 
         var s: [16]u32 = undefined;
 
-        var v: [5]u32 = []u32 {
-            d.s[0], d.s[1], d.s[2], d.s[3], d.s[4],
+        var v: [5]u32 = []u32{
+            d.s[0],
+            d.s[1],
+            d.s[2],
+            d.s[3],
+            d.s[4],
         };
 
-        const round0a = comptime []RoundParam {
-            Rp(0, 1, 2, 3, 4,  0),
-            Rp(4, 0, 1, 2, 3,  1),
-            Rp(3, 4, 0, 1, 2,  2),
-            Rp(2, 3, 4, 0, 1,  3),
-            Rp(1, 2, 3, 4, 0,  4),
-            Rp(0, 1, 2, 3, 4,  5),
-            Rp(4, 0, 1, 2, 3,  6),
-            Rp(3, 4, 0, 1, 2,  7),
-            Rp(2, 3, 4, 0, 1,  8),
-            Rp(1, 2, 3, 4, 0,  9),
+        const round0a = comptime []RoundParam{
+            Rp(0, 1, 2, 3, 4, 0),
+            Rp(4, 0, 1, 2, 3, 1),
+            Rp(3, 4, 0, 1, 2, 2),
+            Rp(2, 3, 4, 0, 1, 3),
+            Rp(1, 2, 3, 4, 0, 4),
+            Rp(0, 1, 2, 3, 4, 5),
+            Rp(4, 0, 1, 2, 3, 6),
+            Rp(3, 4, 0, 1, 2, 7),
+            Rp(2, 3, 4, 0, 1, 8),
+            Rp(1, 2, 3, 4, 0, 9),
             Rp(0, 1, 2, 3, 4, 10),
             Rp(4, 0, 1, 2, 3, 11),
             Rp(3, 4, 0, 1, 2, 12),
@@ -131,32 +147,27 @@ pub const Sha1 = struct {
             Rp(0, 1, 2, 3, 4, 15),
         };
         inline for (round0a) |r| {
-            s[r.i] = (u32(b[r.i * 4 + 0]) << 24) |
-                     (u32(b[r.i * 4 + 1]) << 16) |
-                     (u32(b[r.i * 4 + 2]) <<  8) |
-                     (u32(b[r.i * 4 + 3]) <<  0);
+            s[r.i] = (u32(b[r.i * 4 + 0]) << 24) | (u32(b[r.i * 4 + 1]) << 16) | (u32(b[r.i * 4 + 2]) << 8) | (u32(b[r.i * 4 + 3]) << 0);
 
-            v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x5A827999 +% s[r.i & 0xf]
-                        +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
+            v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x5A827999 +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
             v[r.b] = math.rotl(u32, v[r.b], u32(30));
         }
 
-        const round0b = comptime []RoundParam {
+        const round0b = comptime []RoundParam{
             Rp(4, 0, 1, 2, 3, 16),
             Rp(3, 4, 0, 1, 2, 17),
             Rp(2, 3, 4, 0, 1, 18),
             Rp(1, 2, 3, 4, 0, 19),
         };
         inline for (round0b) |r| {
-            const t = s[(r.i-3) & 0xf] ^ s[(r.i-8) & 0xf] ^ s[(r.i-14) & 0xf] ^ s[(r.i-16) & 0xf];
+            const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
             s[r.i & 0xf] = math.rotl(u32, t, u32(1));
 
-            v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x5A827999 +% s[r.i & 0xf]
-                        +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
+            v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x5A827999 +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
             v[r.b] = math.rotl(u32, v[r.b], u32(30));
         }
 
-        const round1 = comptime []RoundParam {
+        const round1 = comptime []RoundParam{
             Rp(0, 1, 2, 3, 4, 20),
             Rp(4, 0, 1, 2, 3, 21),
             Rp(3, 4, 0, 1, 2, 22),
@@ -179,15 +190,14 @@ pub const Sha1 = struct {
             Rp(1, 2, 3, 4, 0, 39),
         };
         inline for (round1) |r| {
-            const t = s[(r.i-3) & 0xf] ^ s[(r.i-8) & 0xf] ^ s[(r.i-14) & 0xf] ^ s[(r.i-16) & 0xf];
+            const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
             s[r.i & 0xf] = math.rotl(u32, t, u32(1));
 
-            v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x6ED9EBA1 +% s[r.i & 0xf]
-                        +% (v[r.b] ^ v[r.c] ^ v[r.d]);
+            v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x6ED9EBA1 +% s[r.i & 0xf] +% (v[r.b] ^ v[r.c] ^ v[r.d]);
             v[r.b] = math.rotl(u32, v[r.b], u32(30));
         }
 
-        const round2 = comptime []RoundParam {
+        const round2 = comptime []RoundParam{
             Rp(0, 1, 2, 3, 4, 40),
             Rp(4, 0, 1, 2, 3, 41),
             Rp(3, 4, 0, 1, 2, 42),
@@ -210,15 +220,14 @@ pub const Sha1 = struct {
             Rp(1, 2, 3, 4, 0, 59),
         };
         inline for (round2) |r| {
-            const t = s[(r.i-3) & 0xf] ^ s[(r.i-8) & 0xf] ^ s[(r.i-14) & 0xf] ^ s[(r.i-16) & 0xf];
+            const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
             s[r.i & 0xf] = math.rotl(u32, t, u32(1));
 
-            v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x8F1BBCDC  +% s[r.i & 0xf]
-                        +% ((v[r.b] & v[r.c]) ^ (v[r.b] & v[r.d]) ^ (v[r.c] & v[r.d]));
+            v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x8F1BBCDC +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) ^ (v[r.b] & v[r.d]) ^ (v[r.c] & v[r.d]));
             v[r.b] = math.rotl(u32, v[r.b], u32(30));
         }
 
-        const round3 = comptime []RoundParam {
+        const round3 = comptime []RoundParam{
             Rp(0, 1, 2, 3, 4, 60),
             Rp(4, 0, 1, 2, 3, 61),
             Rp(3, 4, 0, 1, 2, 62),
@@ -241,11 +250,10 @@ pub const Sha1 = struct {
             Rp(1, 2, 3, 4, 0, 79),
         };
         inline for (round3) |r| {
-            const t = s[(r.i-3) & 0xf] ^ s[(r.i-8) & 0xf] ^ s[(r.i-14) & 0xf] ^ s[(r.i-16) & 0xf];
+            const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
             s[r.i & 0xf] = math.rotl(u32, t, u32(1));
 
-            v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0xCA62C1D6 +% s[r.i & 0xf]
-                        +% (v[r.b] ^ v[r.c] ^ v[r.d]);
+            v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0xCA62C1D6 +% s[r.i & 0xf] +% (v[r.b] ^ v[r.c] ^ v[r.d]);
             v[r.b] = math.rotl(u32, v[r.b], u32(30));
         }
 
@@ -286,7 +294,7 @@ test "sha1 streaming" {
 }
 
 test "sha1 aligned final" {
-    var block = []u8 {0} ** Sha1.block_size;
+    var block = []u8{0} ** Sha1.block_size;
     var out: [Sha1.digest_size]u8 = undefined;
 
     var h = Sha1.init();
diff --git a/std/crypto/sha2.zig b/std/crypto/sha2.zig
index b70450c0add297e388cc8202d7e584284495050c..a55182aacd0beee866fe9045ac70f45a52a94328 100644
--- a/std/crypto/sha2.zig
+++ b/std/crypto/sha2.zig
@@ -9,12 +9,31 @@ const htest = @import("test.zig");
 // Sha224 + Sha256
 
 const RoundParam256 = struct {
-    a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize,
-    i: usize, k: u32,
+    a: usize,
+    b: usize,
+    c: usize,
+    d: usize,
+    e: usize,
+    f: usize,
+    g: usize,
+    h: usize,
+    i: usize,
+    k: u32,
 };
 
 fn Rp256(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize, i: usize, k: u32) RoundParam256 {
-    return RoundParam256 { .a = a, .b = b, .c = c, .d = d, .e = e, .f = f, .g = g, .h = h, .i = i, .k = k };
+    return RoundParam256{
+        .a = a,
+        .b = b,
+        .c = c,
+        .d = d,
+        .e = e,
+        .f = f,
+        .g = g,
+        .h = h,
+        .i = i,
+        .k = k,
+    };
 }
 
 const Sha2Params32 = struct {
@@ -29,7 +48,7 @@ const Sha2Params32 = struct {
     out_len: usize,
 };
 
-const Sha224Params = Sha2Params32 {
+const Sha224Params = Sha2Params32{
     .iv0 = 0xC1059ED8,
     .iv1 = 0x367CD507,
     .iv2 = 0x3070DD17,
@@ -41,7 +60,7 @@ const Sha224Params = Sha2Params32 {
     .out_len = 224,
 };
 
-const Sha256Params = Sha2Params32 {
+const Sha256Params = Sha2Params32{
     .iv0 = 0x6A09E667,
     .iv1 = 0xBB67AE85,
     .iv2 = 0x3C6EF372,
@@ -56,216 +75,215 @@ const Sha256Params = Sha2Params32 {
 pub const Sha224 = Sha2_32(Sha224Params);
 pub const Sha256 = Sha2_32(Sha256Params);
 
-fn Sha2_32(comptime params: Sha2Params32) type { return struct {
-    const Self = this;
-    const block_size = 64;
-    const digest_size = params.out_len / 8;
+fn Sha2_32(comptime params: Sha2Params32) type {
+    return struct {
+        const Self = this;
+        const block_size = 64;
+        const digest_size = params.out_len / 8;
 
-    s: [8]u32,
-    // Streaming Cache
-    buf: [64]u8,
-    buf_len: u8,
-    total_len: u64,
+        s: [8]u32,
+        // Streaming Cache
+        buf: [64]u8,
+        buf_len: u8,
+        total_len: u64,
 
-    pub fn init() Self {
-        var d: Self = undefined;
-        d.reset();
-        return d;
-    }
+        pub fn init() Self {
+            var d: Self = undefined;
+            d.reset();
+            return d;
+        }
 
-    pub fn reset(d: &Self) void {
-        d.s[0] = params.iv0;
-        d.s[1] = params.iv1;
-        d.s[2] = params.iv2;
-        d.s[3] = params.iv3;
-        d.s[4] = params.iv4;
-        d.s[5] = params.iv5;
-        d.s[6] = params.iv6;
-        d.s[7] = params.iv7;
-        d.buf_len = 0;
-        d.total_len = 0;
-    }
-
-    pub fn hash(b: []const u8, out: []u8) void {
-        var d = Self.init();
-        d.update(b);
-        d.final(out);
-    }
-
-    pub fn update(d: &Self, b: []const u8) void {
-        var off: usize = 0;
-
-        // Partial buffer exists from previous update. Copy into buffer then hash.
-        if (d.buf_len != 0 and d.buf_len + b.len > 64) {
-            off += 64 - d.buf_len;
-            mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
-
-            d.round(d.buf[0..]);
+        pub fn reset(d: &Self) void {
+            d.s[0] = params.iv0;
+            d.s[1] = params.iv1;
+            d.s[2] = params.iv2;
+            d.s[3] = params.iv3;
+            d.s[4] = params.iv4;
+            d.s[5] = params.iv5;
+            d.s[6] = params.iv6;
+            d.s[7] = params.iv7;
             d.buf_len = 0;
+            d.total_len = 0;
         }
 
-        // Full middle blocks.
-        while (off + 64 <= b.len) : (off += 64) {
-            d.round(b[off..off + 64]);
+        pub fn hash(b: []const u8, out: []u8) void {
+            var d = Self.init();
+            d.update(b);
+            d.final(out);
         }
 
-        // Copy any remainder for next pass.
-        mem.copy(u8, d.buf[d.buf_len..], b[off..]);
-        d.buf_len += u8(b[off..].len);
+        pub fn update(d: &Self, b: []const u8) void {
+            var off: usize = 0;
 
-        d.total_len += b.len;
-    }
+            // Partial buffer exists from previous update. Copy into buffer then hash.
+            if (d.buf_len != 0 and d.buf_len + b.len > 64) {
+                off += 64 - d.buf_len;
+                mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
 
-    pub fn final(d: &Self, out: []u8) void {
-        debug.assert(out.len >= params.out_len / 8);
+                d.round(d.buf[0..]);
+                d.buf_len = 0;
+            }
 
-        // The buffer here will never be completely full.
-        mem.set(u8, d.buf[d.buf_len..], 0);
+            // Full middle blocks.
+            while (off + 64 <= b.len) : (off += 64) {
+                d.round(b[off..off + 64]);
+            }
 
-        // Append padding bits.
-        d.buf[d.buf_len] = 0x80;
-        d.buf_len += 1;
+            // Copy any remainder for next pass.
+            mem.copy(u8, d.buf[d.buf_len..], b[off..]);
+            d.buf_len += u8(b[off..].len);
+
+            d.total_len += b.len;
+        }
+
+        pub fn final(d: &Self, out: []u8) void {
+            debug.assert(out.len >= params.out_len / 8);
+
+            // The buffer here will never be completely full.
+            mem.set(u8, d.buf[d.buf_len..], 0);
+
+            // Append padding bits.
+            d.buf[d.buf_len] = 0x80;
+            d.buf_len += 1;
+
+            // > 448 mod 512 so need to add an extra round to wrap around.
+            if (64 - d.buf_len < 8) {
+                d.round(d.buf[0..]);
+                mem.set(u8, d.buf[0..], 0);
+            }
+
+            // Append message length.
+            var i: usize = 1;
+            var len = d.total_len >> 5;
+            d.buf[63] = u8(d.total_len & 0x1f) << 3;
+            while (i < 8) : (i += 1) {
+                d.buf[63 - i] = u8(len & 0xff);
+                len >>= 8;
+            }
 
-        // > 448 mod 512 so need to add an extra round to wrap around.
-        if (64 - d.buf_len < 8) {
             d.round(d.buf[0..]);
-            mem.set(u8, d.buf[0..], 0);
-        }
-
-        // Append message length.
-        var i: usize = 1;
-        var len = d.total_len >> 5;
-        d.buf[63] = u8(d.total_len & 0x1f) << 3;
-        while (i < 8) : (i += 1) {
-            d.buf[63 - i] = u8(len & 0xff);
-            len >>= 8;
-        }
-
-        d.round(d.buf[0..]);
 
-        // May truncate for possible 224 output
-        const rr = d.s[0 .. params.out_len / 32];
+            // May truncate for possible 224 output
+            const rr = d.s[0..params.out_len / 32];
 
-        for (rr) |s, j| {
-            mem.writeInt(out[4*j .. 4*j + 4], s, builtin.Endian.Big);
+            for (rr) |s, j| {
+                mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Big);
+            }
         }
-    }
 
-    fn round(d: &Self, b: []const u8) void {
-        debug.assert(b.len == 64);
+        fn round(d: &Self, b: []const u8) void {
+            debug.assert(b.len == 64);
 
-        var s: [64]u32 = undefined;
+            var s: [64]u32 = undefined;
 
-        var i: usize = 0;
-        while (i < 16) : (i += 1) {
-            s[i] = 0;
-            s[i] |= u32(b[i*4+0]) << 24;
-            s[i] |= u32(b[i*4+1]) << 16;
-            s[i] |= u32(b[i*4+2]) <<  8;
-            s[i] |= u32(b[i*4+3]) <<  0;
-        }
-        while (i < 64) : (i += 1) {
-            s[i] =
-                s[i-16] +% s[i-7] +%
-                (math.rotr(u32, s[i-15], u32(7)) ^ math.rotr(u32, s[i-15], u32(18)) ^ (s[i-15] >> 3)) +%
-                (math.rotr(u32, s[i-2], u32(17)) ^ math.rotr(u32, s[i-2], u32(19)) ^ (s[i-2] >> 10));
-        }
+            var i: usize = 0;
+            while (i < 16) : (i += 1) {
+                s[i] = 0;
+                s[i] |= u32(b[i * 4 + 0]) << 24;
+                s[i] |= u32(b[i * 4 + 1]) << 16;
+                s[i] |= u32(b[i * 4 + 2]) << 8;
+                s[i] |= u32(b[i * 4 + 3]) << 0;
+            }
+            while (i < 64) : (i += 1) {
+                s[i] = s[i - 16] +% s[i - 7] +% (math.rotr(u32, s[i - 15], u32(7)) ^ math.rotr(u32, s[i - 15], u32(18)) ^ (s[i - 15] >> 3)) +% (math.rotr(u32, s[i - 2], u32(17)) ^ math.rotr(u32, s[i - 2], u32(19)) ^ (s[i - 2] >> 10));
+            }
 
-        var v: [8]u32 = []u32 {
-            d.s[0], d.s[1], d.s[2], d.s[3], d.s[4], d.s[5], d.s[6], d.s[7],
-        };
+            var v: [8]u32 = []u32{
+                d.s[0],
+                d.s[1],
+                d.s[2],
+                d.s[3],
+                d.s[4],
+                d.s[5],
+                d.s[6],
+                d.s[7],
+            };
 
-        const round0 = comptime []RoundParam256 {
-            Rp256(0, 1, 2, 3, 4, 5, 6, 7,  0, 0x428A2F98),
-            Rp256(7, 0, 1, 2, 3, 4, 5, 6,  1, 0x71374491),
-            Rp256(6, 7, 0, 1, 2, 3, 4, 5,  2, 0xB5C0FBCF),
-            Rp256(5, 6, 7, 0, 1, 2, 3, 4,  3, 0xE9B5DBA5),
-            Rp256(4, 5, 6, 7, 0, 1, 2, 3,  4, 0x3956C25B),
-            Rp256(3, 4, 5, 6, 7, 0, 1, 2,  5, 0x59F111F1),
-            Rp256(2, 3, 4, 5, 6, 7, 0, 1,  6, 0x923F82A4),
-            Rp256(1, 2, 3, 4, 5, 6, 7, 0,  7, 0xAB1C5ED5),
-            Rp256(0, 1, 2, 3, 4, 5, 6, 7,  8, 0xD807AA98),
-            Rp256(7, 0, 1, 2, 3, 4, 5, 6,  9, 0x12835B01),
-            Rp256(6, 7, 0, 1, 2, 3, 4, 5, 10, 0x243185BE),
-            Rp256(5, 6, 7, 0, 1, 2, 3, 4, 11, 0x550C7DC3),
-            Rp256(4, 5, 6, 7, 0, 1, 2, 3, 12, 0x72BE5D74),
-            Rp256(3, 4, 5, 6, 7, 0, 1, 2, 13, 0x80DEB1FE),
-            Rp256(2, 3, 4, 5, 6, 7, 0, 1, 14, 0x9BDC06A7),
-            Rp256(1, 2, 3, 4, 5, 6, 7, 0, 15, 0xC19BF174),
-            Rp256(0, 1, 2, 3, 4, 5, 6, 7, 16, 0xE49B69C1),
-            Rp256(7, 0, 1, 2, 3, 4, 5, 6, 17, 0xEFBE4786),
-            Rp256(6, 7, 0, 1, 2, 3, 4, 5, 18, 0x0FC19DC6),
-            Rp256(5, 6, 7, 0, 1, 2, 3, 4, 19, 0x240CA1CC),
-            Rp256(4, 5, 6, 7, 0, 1, 2, 3, 20, 0x2DE92C6F),
-            Rp256(3, 4, 5, 6, 7, 0, 1, 2, 21, 0x4A7484AA),
-            Rp256(2, 3, 4, 5, 6, 7, 0, 1, 22, 0x5CB0A9DC),
-            Rp256(1, 2, 3, 4, 5, 6, 7, 0, 23, 0x76F988DA),
-            Rp256(0, 1, 2, 3, 4, 5, 6, 7, 24, 0x983E5152),
-            Rp256(7, 0, 1, 2, 3, 4, 5, 6, 25, 0xA831C66D),
-            Rp256(6, 7, 0, 1, 2, 3, 4, 5, 26, 0xB00327C8),
-            Rp256(5, 6, 7, 0, 1, 2, 3, 4, 27, 0xBF597FC7),
-            Rp256(4, 5, 6, 7, 0, 1, 2, 3, 28, 0xC6E00BF3),
-            Rp256(3, 4, 5, 6, 7, 0, 1, 2, 29, 0xD5A79147),
-            Rp256(2, 3, 4, 5, 6, 7, 0, 1, 30, 0x06CA6351),
-            Rp256(1, 2, 3, 4, 5, 6, 7, 0, 31, 0x14292967),
-            Rp256(0, 1, 2, 3, 4, 5, 6, 7, 32, 0x27B70A85),
-            Rp256(7, 0, 1, 2, 3, 4, 5, 6, 33, 0x2E1B2138),
-            Rp256(6, 7, 0, 1, 2, 3, 4, 5, 34, 0x4D2C6DFC),
-            Rp256(5, 6, 7, 0, 1, 2, 3, 4, 35, 0x53380D13),
-            Rp256(4, 5, 6, 7, 0, 1, 2, 3, 36, 0x650A7354),
-            Rp256(3, 4, 5, 6, 7, 0, 1, 2, 37, 0x766A0ABB),
-            Rp256(2, 3, 4, 5, 6, 7, 0, 1, 38, 0x81C2C92E),
-            Rp256(1, 2, 3, 4, 5, 6, 7, 0, 39, 0x92722C85),
-            Rp256(0, 1, 2, 3, 4, 5, 6, 7, 40, 0xA2BFE8A1),
-            Rp256(7, 0, 1, 2, 3, 4, 5, 6, 41, 0xA81A664B),
-            Rp256(6, 7, 0, 1, 2, 3, 4, 5, 42, 0xC24B8B70),
-            Rp256(5, 6, 7, 0, 1, 2, 3, 4, 43, 0xC76C51A3),
-            Rp256(4, 5, 6, 7, 0, 1, 2, 3, 44, 0xD192E819),
-            Rp256(3, 4, 5, 6, 7, 0, 1, 2, 45, 0xD6990624),
-            Rp256(2, 3, 4, 5, 6, 7, 0, 1, 46, 0xF40E3585),
-            Rp256(1, 2, 3, 4, 5, 6, 7, 0, 47, 0x106AA070),
-            Rp256(0, 1, 2, 3, 4, 5, 6, 7, 48, 0x19A4C116),
-            Rp256(7, 0, 1, 2, 3, 4, 5, 6, 49, 0x1E376C08),
-            Rp256(6, 7, 0, 1, 2, 3, 4, 5, 50, 0x2748774C),
-            Rp256(5, 6, 7, 0, 1, 2, 3, 4, 51, 0x34B0BCB5),
-            Rp256(4, 5, 6, 7, 0, 1, 2, 3, 52, 0x391C0CB3),
-            Rp256(3, 4, 5, 6, 7, 0, 1, 2, 53, 0x4ED8AA4A),
-            Rp256(2, 3, 4, 5, 6, 7, 0, 1, 54, 0x5B9CCA4F),
-            Rp256(1, 2, 3, 4, 5, 6, 7, 0, 55, 0x682E6FF3),
-            Rp256(0, 1, 2, 3, 4, 5, 6, 7, 56, 0x748F82EE),
-            Rp256(7, 0, 1, 2, 3, 4, 5, 6, 57, 0x78A5636F),
-            Rp256(6, 7, 0, 1, 2, 3, 4, 5, 58, 0x84C87814),
-            Rp256(5, 6, 7, 0, 1, 2, 3, 4, 59, 0x8CC70208),
-            Rp256(4, 5, 6, 7, 0, 1, 2, 3, 60, 0x90BEFFFA),
-            Rp256(3, 4, 5, 6, 7, 0, 1, 2, 61, 0xA4506CEB),
-            Rp256(2, 3, 4, 5, 6, 7, 0, 1, 62, 0xBEF9A3F7),
-            Rp256(1, 2, 3, 4, 5, 6, 7, 0, 63, 0xC67178F2),
-        };
-        inline for (round0) |r| {
-            v[r.h] =
-                v[r.h] +%
-                (math.rotr(u32, v[r.e], u32(6)) ^ math.rotr(u32, v[r.e], u32(11)) ^ math.rotr(u32, v[r.e], u32(25))) +%
-                (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +%
-                r.k +% s[r.i];
+            const round0 = comptime []RoundParam256{
+                Rp256(0, 1, 2, 3, 4, 5, 6, 7, 0, 0x428A2F98),
+                Rp256(7, 0, 1, 2, 3, 4, 5, 6, 1, 0x71374491),
+                Rp256(6, 7, 0, 1, 2, 3, 4, 5, 2, 0xB5C0FBCF),
+                Rp256(5, 6, 7, 0, 1, 2, 3, 4, 3, 0xE9B5DBA5),
+                Rp256(4, 5, 6, 7, 0, 1, 2, 3, 4, 0x3956C25B),
+                Rp256(3, 4, 5, 6, 7, 0, 1, 2, 5, 0x59F111F1),
+                Rp256(2, 3, 4, 5, 6, 7, 0, 1, 6, 0x923F82A4),
+                Rp256(1, 2, 3, 4, 5, 6, 7, 0, 7, 0xAB1C5ED5),
+                Rp256(0, 1, 2, 3, 4, 5, 6, 7, 8, 0xD807AA98),
+                Rp256(7, 0, 1, 2, 3, 4, 5, 6, 9, 0x12835B01),
+                Rp256(6, 7, 0, 1, 2, 3, 4, 5, 10, 0x243185BE),
+                Rp256(5, 6, 7, 0, 1, 2, 3, 4, 11, 0x550C7DC3),
+                Rp256(4, 5, 6, 7, 0, 1, 2, 3, 12, 0x72BE5D74),
+                Rp256(3, 4, 5, 6, 7, 0, 1, 2, 13, 0x80DEB1FE),
+                Rp256(2, 3, 4, 5, 6, 7, 0, 1, 14, 0x9BDC06A7),
+                Rp256(1, 2, 3, 4, 5, 6, 7, 0, 15, 0xC19BF174),
+                Rp256(0, 1, 2, 3, 4, 5, 6, 7, 16, 0xE49B69C1),
+                Rp256(7, 0, 1, 2, 3, 4, 5, 6, 17, 0xEFBE4786),
+                Rp256(6, 7, 0, 1, 2, 3, 4, 5, 18, 0x0FC19DC6),
+                Rp256(5, 6, 7, 0, 1, 2, 3, 4, 19, 0x240CA1CC),
+                Rp256(4, 5, 6, 7, 0, 1, 2, 3, 20, 0x2DE92C6F),
+                Rp256(3, 4, 5, 6, 7, 0, 1, 2, 21, 0x4A7484AA),
+                Rp256(2, 3, 4, 5, 6, 7, 0, 1, 22, 0x5CB0A9DC),
+                Rp256(1, 2, 3, 4, 5, 6, 7, 0, 23, 0x76F988DA),
+                Rp256(0, 1, 2, 3, 4, 5, 6, 7, 24, 0x983E5152),
+                Rp256(7, 0, 1, 2, 3, 4, 5, 6, 25, 0xA831C66D),
+                Rp256(6, 7, 0, 1, 2, 3, 4, 5, 26, 0xB00327C8),
+                Rp256(5, 6, 7, 0, 1, 2, 3, 4, 27, 0xBF597FC7),
+                Rp256(4, 5, 6, 7, 0, 1, 2, 3, 28, 0xC6E00BF3),
+                Rp256(3, 4, 5, 6, 7, 0, 1, 2, 29, 0xD5A79147),
+                Rp256(2, 3, 4, 5, 6, 7, 0, 1, 30, 0x06CA6351),
+                Rp256(1, 2, 3, 4, 5, 6, 7, 0, 31, 0x14292967),
+                Rp256(0, 1, 2, 3, 4, 5, 6, 7, 32, 0x27B70A85),
+                Rp256(7, 0, 1, 2, 3, 4, 5, 6, 33, 0x2E1B2138),
+                Rp256(6, 7, 0, 1, 2, 3, 4, 5, 34, 0x4D2C6DFC),
+                Rp256(5, 6, 7, 0, 1, 2, 3, 4, 35, 0x53380D13),
+                Rp256(4, 5, 6, 7, 0, 1, 2, 3, 36, 0x650A7354),
+                Rp256(3, 4, 5, 6, 7, 0, 1, 2, 37, 0x766A0ABB),
+                Rp256(2, 3, 4, 5, 6, 7, 0, 1, 38, 0x81C2C92E),
+                Rp256(1, 2, 3, 4, 5, 6, 7, 0, 39, 0x92722C85),
+                Rp256(0, 1, 2, 3, 4, 5, 6, 7, 40, 0xA2BFE8A1),
+                Rp256(7, 0, 1, 2, 3, 4, 5, 6, 41, 0xA81A664B),
+                Rp256(6, 7, 0, 1, 2, 3, 4, 5, 42, 0xC24B8B70),
+                Rp256(5, 6, 7, 0, 1, 2, 3, 4, 43, 0xC76C51A3),
+                Rp256(4, 5, 6, 7, 0, 1, 2, 3, 44, 0xD192E819),
+                Rp256(3, 4, 5, 6, 7, 0, 1, 2, 45, 0xD6990624),
+                Rp256(2, 3, 4, 5, 6, 7, 0, 1, 46, 0xF40E3585),
+                Rp256(1, 2, 3, 4, 5, 6, 7, 0, 47, 0x106AA070),
+                Rp256(0, 1, 2, 3, 4, 5, 6, 7, 48, 0x19A4C116),
+                Rp256(7, 0, 1, 2, 3, 4, 5, 6, 49, 0x1E376C08),
+                Rp256(6, 7, 0, 1, 2, 3, 4, 5, 50, 0x2748774C),
+                Rp256(5, 6, 7, 0, 1, 2, 3, 4, 51, 0x34B0BCB5),
+                Rp256(4, 5, 6, 7, 0, 1, 2, 3, 52, 0x391C0CB3),
+                Rp256(3, 4, 5, 6, 7, 0, 1, 2, 53, 0x4ED8AA4A),
+                Rp256(2, 3, 4, 5, 6, 7, 0, 1, 54, 0x5B9CCA4F),
+                Rp256(1, 2, 3, 4, 5, 6, 7, 0, 55, 0x682E6FF3),
+                Rp256(0, 1, 2, 3, 4, 5, 6, 7, 56, 0x748F82EE),
+                Rp256(7, 0, 1, 2, 3, 4, 5, 6, 57, 0x78A5636F),
+                Rp256(6, 7, 0, 1, 2, 3, 4, 5, 58, 0x84C87814),
+                Rp256(5, 6, 7, 0, 1, 2, 3, 4, 59, 0x8CC70208),
+                Rp256(4, 5, 6, 7, 0, 1, 2, 3, 60, 0x90BEFFFA),
+                Rp256(3, 4, 5, 6, 7, 0, 1, 2, 61, 0xA4506CEB),
+                Rp256(2, 3, 4, 5, 6, 7, 0, 1, 62, 0xBEF9A3F7),
+                Rp256(1, 2, 3, 4, 5, 6, 7, 0, 63, 0xC67178F2),
+            };
+            inline for (round0) |r| {
+                v[r.h] = v[r.h] +% (math.rotr(u32, v[r.e], u32(6)) ^ math.rotr(u32, v[r.e], u32(11)) ^ math.rotr(u32, v[r.e], u32(25))) +% (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +% r.k +% s[r.i];
 
-            v[r.d] = v[r.d] +% v[r.h];
+                v[r.d] = v[r.d] +% v[r.h];
 
-            v[r.h] =
-                v[r.h] +%
-                (math.rotr(u32, v[r.a], u32(2)) ^ math.rotr(u32, v[r.a], u32(13)) ^ math.rotr(u32, v[r.a], u32(22))) +%
-                ((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
-        }
+                v[r.h] = v[r.h] +% (math.rotr(u32, v[r.a], u32(2)) ^ math.rotr(u32, v[r.a], u32(13)) ^ math.rotr(u32, v[r.a], u32(22))) +% ((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
+            }
 
-        d.s[0] +%= v[0];
-        d.s[1] +%= v[1];
-        d.s[2] +%= v[2];
-        d.s[3] +%= v[3];
-        d.s[4] +%= v[4];
-        d.s[5] +%= v[5];
-        d.s[6] +%= v[6];
-        d.s[7] +%= v[7];
-    }
-};}
+            d.s[0] +%= v[0];
+            d.s[1] +%= v[1];
+            d.s[2] +%= v[2];
+            d.s[3] +%= v[3];
+            d.s[4] +%= v[4];
+            d.s[5] +%= v[5];
+            d.s[6] +%= v[6];
+            d.s[7] +%= v[7];
+        }
+    };
+}
 
 test "sha224 single" {
     htest.assertEqualHash(Sha224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", "");
@@ -320,7 +338,7 @@ test "sha256 streaming" {
 }
 
 test "sha256 aligned final" {
-    var block = []u8 {0} ** Sha256.block_size;
+    var block = []u8{0} ** Sha256.block_size;
     var out: [Sha256.digest_size]u8 = undefined;
 
     var h = Sha256.init();
@@ -328,17 +346,35 @@ test "sha256 aligned final" {
     h.final(out[0..]);
 }
 
-
 /////////////////////
 // Sha384 + Sha512
 
 const RoundParam512 = struct {
-    a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize,
-    i: usize, k: u64,
+    a: usize,
+    b: usize,
+    c: usize,
+    d: usize,
+    e: usize,
+    f: usize,
+    g: usize,
+    h: usize,
+    i: usize,
+    k: u64,
 };
 
 fn Rp512(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize, i: usize, k: u64) RoundParam512 {
-    return RoundParam512 { .a = a, .b = b, .c = c, .d = d, .e = e, .f = f, .g = g, .h = h, .i = i, .k = k };
+    return RoundParam512{
+        .a = a,
+        .b = b,
+        .c = c,
+        .d = d,
+        .e = e,
+        .f = f,
+        .g = g,
+        .h = h,
+        .i = i,
+        .k = k,
+    };
 }
 
 const Sha2Params64 = struct {
@@ -353,7 +389,7 @@ const Sha2Params64 = struct {
     out_len: usize,
 };
 
-const Sha384Params = Sha2Params64 {
+const Sha384Params = Sha2Params64{
     .iv0 = 0xCBBB9D5DC1059ED8,
     .iv1 = 0x629A292A367CD507,
     .iv2 = 0x9159015A3070DD17,
@@ -365,7 +401,7 @@ const Sha384Params = Sha2Params64 {
     .out_len = 384,
 };
 
-const Sha512Params = Sha2Params64 {
+const Sha512Params = Sha2Params64{
     .iv0 = 0x6A09E667F3BCC908,
     .iv1 = 0xBB67AE8584CAA73B,
     .iv2 = 0x3C6EF372FE94F82B,
@@ -374,242 +410,241 @@ const Sha512Params = Sha2Params64 {
     .iv5 = 0x9B05688C2B3E6C1F,
     .iv6 = 0x1F83D9ABFB41BD6B,
     .iv7 = 0x5BE0CD19137E2179,
-    .out_len = 512
+    .out_len = 512,
 };
 
 pub const Sha384 = Sha2_64(Sha384Params);
 pub const Sha512 = Sha2_64(Sha512Params);
 
-fn Sha2_64(comptime params: Sha2Params64) type { return struct {
-    const Self = this;
-    const block_size = 128;
-    const digest_size = params.out_len / 8;
+fn Sha2_64(comptime params: Sha2Params64) type {
+    return struct {
+        const Self = this;
+        const block_size = 128;
+        const digest_size = params.out_len / 8;
 
-    s: [8]u64,
-    // Streaming Cache
-    buf: [128]u8,
-    buf_len: u8,
-    total_len: u128,
+        s: [8]u64,
+        // Streaming Cache
+        buf: [128]u8,
+        buf_len: u8,
+        total_len: u128,
 
-    pub fn init() Self {
-        var d: Self = undefined;
-        d.reset();
-        return d;
-    }
+        pub fn init() Self {
+            var d: Self = undefined;
+            d.reset();
+            return d;
+        }
 
-    pub fn reset(d: &Self) void {
-        d.s[0] = params.iv0;
-        d.s[1] = params.iv1;
-        d.s[2] = params.iv2;
-        d.s[3] = params.iv3;
-        d.s[4] = params.iv4;
-        d.s[5] = params.iv5;
-        d.s[6] = params.iv6;
-        d.s[7] = params.iv7;
-        d.buf_len = 0;
-        d.total_len = 0;
-    }
-
-    pub fn hash(b: []const u8, out: []u8) void {
-        var d = Self.init();
-        d.update(b);
-        d.final(out);
-    }
-
-    pub fn update(d: &Self, b: []const u8) void {
-        var off: usize = 0;
-
-        // Partial buffer exists from previous update. Copy into buffer then hash.
-        if (d.buf_len != 0 and d.buf_len + b.len > 128) {
-            off += 128 - d.buf_len;
-            mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
-
-            d.round(d.buf[0..]);
+        pub fn reset(d: &Self) void {
+            d.s[0] = params.iv0;
+            d.s[1] = params.iv1;
+            d.s[2] = params.iv2;
+            d.s[3] = params.iv3;
+            d.s[4] = params.iv4;
+            d.s[5] = params.iv5;
+            d.s[6] = params.iv6;
+            d.s[7] = params.iv7;
             d.buf_len = 0;
+            d.total_len = 0;
         }
 
-        // Full middle blocks.
-        while (off + 128 <= b.len) : (off += 128) {
-            d.round(b[off..off + 128]);
+        pub fn hash(b: []const u8, out: []u8) void {
+            var d = Self.init();
+            d.update(b);
+            d.final(out);
         }
 
-        // Copy any remainder for next pass.
-        mem.copy(u8, d.buf[d.buf_len..], b[off..]);
-        d.buf_len += u8(b[off..].len);
+        pub fn update(d: &Self, b: []const u8) void {
+            var off: usize = 0;
 
-        d.total_len += b.len;
-    }
+            // Partial buffer exists from previous update. Copy into buffer then hash.
+            if (d.buf_len != 0 and d.buf_len + b.len > 128) {
+                off += 128 - d.buf_len;
+                mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
 
-    pub fn final(d: &Self, out: []u8) void {
-        debug.assert(out.len >= params.out_len / 8);
+                d.round(d.buf[0..]);
+                d.buf_len = 0;
+            }
 
-        // The buffer here will never be completely full.
-        mem.set(u8, d.buf[d.buf_len..], 0);
+            // Full middle blocks.
+            while (off + 128 <= b.len) : (off += 128) {
+                d.round(b[off..off + 128]);
+            }
 
-        // Append padding bits.
-        d.buf[d.buf_len] = 0x80;
-        d.buf_len += 1;
+            // Copy any remainder for next pass.
+            mem.copy(u8, d.buf[d.buf_len..], b[off..]);
+            d.buf_len += u8(b[off..].len);
+
+            d.total_len += b.len;
+        }
+
+        pub fn final(d: &Self, out: []u8) void {
+            debug.assert(out.len >= params.out_len / 8);
+
+            // The buffer here will never be completely full.
+            mem.set(u8, d.buf[d.buf_len..], 0);
+
+            // Append padding bits.
+            d.buf[d.buf_len] = 0x80;
+            d.buf_len += 1;
+
+            // > 896 mod 1024 so need to add an extra round to wrap around.
+            if (128 - d.buf_len < 16) {
+                d.round(d.buf[0..]);
+                mem.set(u8, d.buf[0..], 0);
+            }
+
+            // Append message length.
+            var i: usize = 1;
+            var len = d.total_len >> 5;
+            d.buf[127] = u8(d.total_len & 0x1f) << 3;
+            while (i < 16) : (i += 1) {
+                d.buf[127 - i] = u8(len & 0xff);
+                len >>= 8;
+            }
 
-        // > 896 mod 1024 so need to add an extra round to wrap around.
-        if (128 - d.buf_len < 16) {
             d.round(d.buf[0..]);
-            mem.set(u8, d.buf[0..], 0);
-        }
-
-        // Append message length.
-        var i: usize = 1;
-        var len = d.total_len >> 5;
-        d.buf[127] = u8(d.total_len & 0x1f) << 3;
-        while (i < 16) : (i += 1) {
-            d.buf[127 - i] = u8(len & 0xff);
-            len >>= 8;
-        }
-
-        d.round(d.buf[0..]);
 
-        // May truncate for possible 384 output
-        const rr = d.s[0 .. params.out_len / 64];
+            // May truncate for possible 384 output
+            const rr = d.s[0..params.out_len / 64];
 
-        for (rr) |s, j| {
-            mem.writeInt(out[8*j .. 8*j + 8], s, builtin.Endian.Big);
+            for (rr) |s, j| {
+                mem.writeInt(out[8 * j..8 * j + 8], s, builtin.Endian.Big);
+            }
         }
-    }
 
-    fn round(d: &Self, b: []const u8) void {
-        debug.assert(b.len == 128);
+        fn round(d: &Self, b: []const u8) void {
+            debug.assert(b.len == 128);
 
-        var s: [80]u64 = undefined;
+            var s: [80]u64 = undefined;
 
-        var i: usize = 0;
-        while (i < 16) : (i += 1) {
-            s[i] = 0;
-            s[i] |= u64(b[i*8+0]) << 56;
-            s[i] |= u64(b[i*8+1]) << 48;
-            s[i] |= u64(b[i*8+2]) << 40;
-            s[i] |= u64(b[i*8+3]) << 32;
-            s[i] |= u64(b[i*8+4]) << 24;
-            s[i] |= u64(b[i*8+5]) << 16;
-            s[i] |= u64(b[i*8+6]) <<  8;
-            s[i] |= u64(b[i*8+7]) <<  0;
-        }
-        while (i < 80) : (i += 1) {
-            s[i] =
-                s[i-16] +% s[i-7] +%
-                (math.rotr(u64, s[i-15], u64(1)) ^ math.rotr(u64, s[i-15], u64(8)) ^ (s[i-15] >> 7)) +%
-                (math.rotr(u64, s[i-2], u64(19)) ^ math.rotr(u64, s[i-2], u64(61)) ^ (s[i-2] >> 6));
-        }
+            var i: usize = 0;
+            while (i < 16) : (i += 1) {
+                s[i] = 0;
+                s[i] |= u64(b[i * 8 + 0]) << 56;
+                s[i] |= u64(b[i * 8 + 1]) << 48;
+                s[i] |= u64(b[i * 8 + 2]) << 40;
+                s[i] |= u64(b[i * 8 + 3]) << 32;
+                s[i] |= u64(b[i * 8 + 4]) << 24;
+                s[i] |= u64(b[i * 8 + 5]) << 16;
+                s[i] |= u64(b[i * 8 + 6]) << 8;
+                s[i] |= u64(b[i * 8 + 7]) << 0;
+            }
+            while (i < 80) : (i += 1) {
+                s[i] = s[i - 16] +% s[i - 7] +% (math.rotr(u64, s[i - 15], u64(1)) ^ math.rotr(u64, s[i - 15], u64(8)) ^ (s[i - 15] >> 7)) +% (math.rotr(u64, s[i - 2], u64(19)) ^ math.rotr(u64, s[i - 2], u64(61)) ^ (s[i - 2] >> 6));
+            }
 
-        var v: [8]u64 = []u64 {
-            d.s[0], d.s[1], d.s[2], d.s[3], d.s[4], d.s[5], d.s[6], d.s[7],
-        };
+            var v: [8]u64 = []u64{
+                d.s[0],
+                d.s[1],
+                d.s[2],
+                d.s[3],
+                d.s[4],
+                d.s[5],
+                d.s[6],
+                d.s[7],
+            };
 
-        const round0 = comptime []RoundParam512 {
-            Rp512(0, 1, 2, 3, 4, 5, 6, 7,  0, 0x428A2F98D728AE22),
-            Rp512(7, 0, 1, 2, 3, 4, 5, 6,  1, 0x7137449123EF65CD),
-            Rp512(6, 7, 0, 1, 2, 3, 4, 5,  2, 0xB5C0FBCFEC4D3B2F),
-            Rp512(5, 6, 7, 0, 1, 2, 3, 4,  3, 0xE9B5DBA58189DBBC),
-            Rp512(4, 5, 6, 7, 0, 1, 2, 3,  4, 0x3956C25BF348B538),
-            Rp512(3, 4, 5, 6, 7, 0, 1, 2,  5, 0x59F111F1B605D019),
-            Rp512(2, 3, 4, 5, 6, 7, 0, 1,  6, 0x923F82A4AF194F9B),
-            Rp512(1, 2, 3, 4, 5, 6, 7, 0,  7, 0xAB1C5ED5DA6D8118),
-            Rp512(0, 1, 2, 3, 4, 5, 6, 7,  8, 0xD807AA98A3030242),
-            Rp512(7, 0, 1, 2, 3, 4, 5, 6,  9, 0x12835B0145706FBE),
-            Rp512(6, 7, 0, 1, 2, 3, 4, 5, 10, 0x243185BE4EE4B28C),
-            Rp512(5, 6, 7, 0, 1, 2, 3, 4, 11, 0x550C7DC3D5FFB4E2),
-            Rp512(4, 5, 6, 7, 0, 1, 2, 3, 12, 0x72BE5D74F27B896F),
-            Rp512(3, 4, 5, 6, 7, 0, 1, 2, 13, 0x80DEB1FE3B1696B1),
-            Rp512(2, 3, 4, 5, 6, 7, 0, 1, 14, 0x9BDC06A725C71235),
-            Rp512(1, 2, 3, 4, 5, 6, 7, 0, 15, 0xC19BF174CF692694),
-            Rp512(0, 1, 2, 3, 4, 5, 6, 7, 16, 0xE49B69C19EF14AD2),
-            Rp512(7, 0, 1, 2, 3, 4, 5, 6, 17, 0xEFBE4786384F25E3),
-            Rp512(6, 7, 0, 1, 2, 3, 4, 5, 18, 0x0FC19DC68B8CD5B5),
-            Rp512(5, 6, 7, 0, 1, 2, 3, 4, 19, 0x240CA1CC77AC9C65),
-            Rp512(4, 5, 6, 7, 0, 1, 2, 3, 20, 0x2DE92C6F592B0275),
-            Rp512(3, 4, 5, 6, 7, 0, 1, 2, 21, 0x4A7484AA6EA6E483),
-            Rp512(2, 3, 4, 5, 6, 7, 0, 1, 22, 0x5CB0A9DCBD41FBD4),
-            Rp512(1, 2, 3, 4, 5, 6, 7, 0, 23, 0x76F988DA831153B5),
-            Rp512(0, 1, 2, 3, 4, 5, 6, 7, 24, 0x983E5152EE66DFAB),
-            Rp512(7, 0, 1, 2, 3, 4, 5, 6, 25, 0xA831C66D2DB43210),
-            Rp512(6, 7, 0, 1, 2, 3, 4, 5, 26, 0xB00327C898FB213F),
-            Rp512(5, 6, 7, 0, 1, 2, 3, 4, 27, 0xBF597FC7BEEF0EE4),
-            Rp512(4, 5, 6, 7, 0, 1, 2, 3, 28, 0xC6E00BF33DA88FC2),
-            Rp512(3, 4, 5, 6, 7, 0, 1, 2, 29, 0xD5A79147930AA725),
-            Rp512(2, 3, 4, 5, 6, 7, 0, 1, 30, 0x06CA6351E003826F),
-            Rp512(1, 2, 3, 4, 5, 6, 7, 0, 31, 0x142929670A0E6E70),
-            Rp512(0, 1, 2, 3, 4, 5, 6, 7, 32, 0x27B70A8546D22FFC),
-            Rp512(7, 0, 1, 2, 3, 4, 5, 6, 33, 0x2E1B21385C26C926),
-            Rp512(6, 7, 0, 1, 2, 3, 4, 5, 34, 0x4D2C6DFC5AC42AED),
-            Rp512(5, 6, 7, 0, 1, 2, 3, 4, 35, 0x53380D139D95B3DF),
-            Rp512(4, 5, 6, 7, 0, 1, 2, 3, 36, 0x650A73548BAF63DE),
-            Rp512(3, 4, 5, 6, 7, 0, 1, 2, 37, 0x766A0ABB3C77B2A8),
-            Rp512(2, 3, 4, 5, 6, 7, 0, 1, 38, 0x81C2C92E47EDAEE6),
-            Rp512(1, 2, 3, 4, 5, 6, 7, 0, 39, 0x92722C851482353B),
-            Rp512(0, 1, 2, 3, 4, 5, 6, 7, 40, 0xA2BFE8A14CF10364),
-            Rp512(7, 0, 1, 2, 3, 4, 5, 6, 41, 0xA81A664BBC423001),
-            Rp512(6, 7, 0, 1, 2, 3, 4, 5, 42, 0xC24B8B70D0F89791),
-            Rp512(5, 6, 7, 0, 1, 2, 3, 4, 43, 0xC76C51A30654BE30),
-            Rp512(4, 5, 6, 7, 0, 1, 2, 3, 44, 0xD192E819D6EF5218),
-            Rp512(3, 4, 5, 6, 7, 0, 1, 2, 45, 0xD69906245565A910),
-            Rp512(2, 3, 4, 5, 6, 7, 0, 1, 46, 0xF40E35855771202A),
-            Rp512(1, 2, 3, 4, 5, 6, 7, 0, 47, 0x106AA07032BBD1B8),
-            Rp512(0, 1, 2, 3, 4, 5, 6, 7, 48, 0x19A4C116B8D2D0C8),
-            Rp512(7, 0, 1, 2, 3, 4, 5, 6, 49, 0x1E376C085141AB53),
-            Rp512(6, 7, 0, 1, 2, 3, 4, 5, 50, 0x2748774CDF8EEB99),
-            Rp512(5, 6, 7, 0, 1, 2, 3, 4, 51, 0x34B0BCB5E19B48A8),
-            Rp512(4, 5, 6, 7, 0, 1, 2, 3, 52, 0x391C0CB3C5C95A63),
-            Rp512(3, 4, 5, 6, 7, 0, 1, 2, 53, 0x4ED8AA4AE3418ACB),
-            Rp512(2, 3, 4, 5, 6, 7, 0, 1, 54, 0x5B9CCA4F7763E373),
-            Rp512(1, 2, 3, 4, 5, 6, 7, 0, 55, 0x682E6FF3D6B2B8A3),
-            Rp512(0, 1, 2, 3, 4, 5, 6, 7, 56, 0x748F82EE5DEFB2FC),
-            Rp512(7, 0, 1, 2, 3, 4, 5, 6, 57, 0x78A5636F43172F60),
-            Rp512(6, 7, 0, 1, 2, 3, 4, 5, 58, 0x84C87814A1F0AB72),
-            Rp512(5, 6, 7, 0, 1, 2, 3, 4, 59, 0x8CC702081A6439EC),
-            Rp512(4, 5, 6, 7, 0, 1, 2, 3, 60, 0x90BEFFFA23631E28),
-            Rp512(3, 4, 5, 6, 7, 0, 1, 2, 61, 0xA4506CEBDE82BDE9),
-            Rp512(2, 3, 4, 5, 6, 7, 0, 1, 62, 0xBEF9A3F7B2C67915),
-            Rp512(1, 2, 3, 4, 5, 6, 7, 0, 63, 0xC67178F2E372532B),
-            Rp512(0, 1, 2, 3, 4, 5, 6, 7, 64, 0xCA273ECEEA26619C),
-            Rp512(7, 0, 1, 2, 3, 4, 5, 6, 65, 0xD186B8C721C0C207),
-            Rp512(6, 7, 0, 1, 2, 3, 4, 5, 66, 0xEADA7DD6CDE0EB1E),
-            Rp512(5, 6, 7, 0, 1, 2, 3, 4, 67, 0xF57D4F7FEE6ED178),
-            Rp512(4, 5, 6, 7, 0, 1, 2, 3, 68, 0x06F067AA72176FBA),
-            Rp512(3, 4, 5, 6, 7, 0, 1, 2, 69, 0x0A637DC5A2C898A6),
-            Rp512(2, 3, 4, 5, 6, 7, 0, 1, 70, 0x113F9804BEF90DAE),
-            Rp512(1, 2, 3, 4, 5, 6, 7, 0, 71, 0x1B710B35131C471B),
-            Rp512(0, 1, 2, 3, 4, 5, 6, 7, 72, 0x28DB77F523047D84),
-            Rp512(7, 0, 1, 2, 3, 4, 5, 6, 73, 0x32CAAB7B40C72493),
-            Rp512(6, 7, 0, 1, 2, 3, 4, 5, 74, 0x3C9EBE0A15C9BEBC),
-            Rp512(5, 6, 7, 0, 1, 2, 3, 4, 75, 0x431D67C49C100D4C),
-            Rp512(4, 5, 6, 7, 0, 1, 2, 3, 76, 0x4CC5D4BECB3E42B6),
-            Rp512(3, 4, 5, 6, 7, 0, 1, 2, 77, 0x597F299CFC657E2A),
-            Rp512(2, 3, 4, 5, 6, 7, 0, 1, 78, 0x5FCB6FAB3AD6FAEC),
-            Rp512(1, 2, 3, 4, 5, 6, 7, 0, 79, 0x6C44198C4A475817),
-        };
-        inline for (round0) |r| {
-            v[r.h] =
-                v[r.h] +%
-                (math.rotr(u64, v[r.e], u64(14)) ^ math.rotr(u64, v[r.e], u64(18)) ^ math.rotr(u64, v[r.e], u64(41))) +%
-                (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +%
-                r.k +% s[r.i];
+            const round0 = comptime []RoundParam512{
+                Rp512(0, 1, 2, 3, 4, 5, 6, 7, 0, 0x428A2F98D728AE22),
+                Rp512(7, 0, 1, 2, 3, 4, 5, 6, 1, 0x7137449123EF65CD),
+                Rp512(6, 7, 0, 1, 2, 3, 4, 5, 2, 0xB5C0FBCFEC4D3B2F),
+                Rp512(5, 6, 7, 0, 1, 2, 3, 4, 3, 0xE9B5DBA58189DBBC),
+                Rp512(4, 5, 6, 7, 0, 1, 2, 3, 4, 0x3956C25BF348B538),
+                Rp512(3, 4, 5, 6, 7, 0, 1, 2, 5, 0x59F111F1B605D019),
+                Rp512(2, 3, 4, 5, 6, 7, 0, 1, 6, 0x923F82A4AF194F9B),
+                Rp512(1, 2, 3, 4, 5, 6, 7, 0, 7, 0xAB1C5ED5DA6D8118),
+                Rp512(0, 1, 2, 3, 4, 5, 6, 7, 8, 0xD807AA98A3030242),
+                Rp512(7, 0, 1, 2, 3, 4, 5, 6, 9, 0x12835B0145706FBE),
+                Rp512(6, 7, 0, 1, 2, 3, 4, 5, 10, 0x243185BE4EE4B28C),
+                Rp512(5, 6, 7, 0, 1, 2, 3, 4, 11, 0x550C7DC3D5FFB4E2),
+                Rp512(4, 5, 6, 7, 0, 1, 2, 3, 12, 0x72BE5D74F27B896F),
+                Rp512(3, 4, 5, 6, 7, 0, 1, 2, 13, 0x80DEB1FE3B1696B1),
+                Rp512(2, 3, 4, 5, 6, 7, 0, 1, 14, 0x9BDC06A725C71235),
+                Rp512(1, 2, 3, 4, 5, 6, 7, 0, 15, 0xC19BF174CF692694),
+                Rp512(0, 1, 2, 3, 4, 5, 6, 7, 16, 0xE49B69C19EF14AD2),
+                Rp512(7, 0, 1, 2, 3, 4, 5, 6, 17, 0xEFBE4786384F25E3),
+                Rp512(6, 7, 0, 1, 2, 3, 4, 5, 18, 0x0FC19DC68B8CD5B5),
+                Rp512(5, 6, 7, 0, 1, 2, 3, 4, 19, 0x240CA1CC77AC9C65),
+                Rp512(4, 5, 6, 7, 0, 1, 2, 3, 20, 0x2DE92C6F592B0275),
+                Rp512(3, 4, 5, 6, 7, 0, 1, 2, 21, 0x4A7484AA6EA6E483),
+                Rp512(2, 3, 4, 5, 6, 7, 0, 1, 22, 0x5CB0A9DCBD41FBD4),
+                Rp512(1, 2, 3, 4, 5, 6, 7, 0, 23, 0x76F988DA831153B5),
+                Rp512(0, 1, 2, 3, 4, 5, 6, 7, 24, 0x983E5152EE66DFAB),
+                Rp512(7, 0, 1, 2, 3, 4, 5, 6, 25, 0xA831C66D2DB43210),
+                Rp512(6, 7, 0, 1, 2, 3, 4, 5, 26, 0xB00327C898FB213F),
+                Rp512(5, 6, 7, 0, 1, 2, 3, 4, 27, 0xBF597FC7BEEF0EE4),
+                Rp512(4, 5, 6, 7, 0, 1, 2, 3, 28, 0xC6E00BF33DA88FC2),
+                Rp512(3, 4, 5, 6, 7, 0, 1, 2, 29, 0xD5A79147930AA725),
+                Rp512(2, 3, 4, 5, 6, 7, 0, 1, 30, 0x06CA6351E003826F),
+                Rp512(1, 2, 3, 4, 5, 6, 7, 0, 31, 0x142929670A0E6E70),
+                Rp512(0, 1, 2, 3, 4, 5, 6, 7, 32, 0x27B70A8546D22FFC),
+                Rp512(7, 0, 1, 2, 3, 4, 5, 6, 33, 0x2E1B21385C26C926),
+                Rp512(6, 7, 0, 1, 2, 3, 4, 5, 34, 0x4D2C6DFC5AC42AED),
+                Rp512(5, 6, 7, 0, 1, 2, 3, 4, 35, 0x53380D139D95B3DF),
+                Rp512(4, 5, 6, 7, 0, 1, 2, 3, 36, 0x650A73548BAF63DE),
+                Rp512(3, 4, 5, 6, 7, 0, 1, 2, 37, 0x766A0ABB3C77B2A8),
+                Rp512(2, 3, 4, 5, 6, 7, 0, 1, 38, 0x81C2C92E47EDAEE6),
+                Rp512(1, 2, 3, 4, 5, 6, 7, 0, 39, 0x92722C851482353B),
+                Rp512(0, 1, 2, 3, 4, 5, 6, 7, 40, 0xA2BFE8A14CF10364),
+                Rp512(7, 0, 1, 2, 3, 4, 5, 6, 41, 0xA81A664BBC423001),
+                Rp512(6, 7, 0, 1, 2, 3, 4, 5, 42, 0xC24B8B70D0F89791),
+                Rp512(5, 6, 7, 0, 1, 2, 3, 4, 43, 0xC76C51A30654BE30),
+                Rp512(4, 5, 6, 7, 0, 1, 2, 3, 44, 0xD192E819D6EF5218),
+                Rp512(3, 4, 5, 6, 7, 0, 1, 2, 45, 0xD69906245565A910),
+                Rp512(2, 3, 4, 5, 6, 7, 0, 1, 46, 0xF40E35855771202A),
+                Rp512(1, 2, 3, 4, 5, 6, 7, 0, 47, 0x106AA07032BBD1B8),
+                Rp512(0, 1, 2, 3, 4, 5, 6, 7, 48, 0x19A4C116B8D2D0C8),
+                Rp512(7, 0, 1, 2, 3, 4, 5, 6, 49, 0x1E376C085141AB53),
+                Rp512(6, 7, 0, 1, 2, 3, 4, 5, 50, 0x2748774CDF8EEB99),
+                Rp512(5, 6, 7, 0, 1, 2, 3, 4, 51, 0x34B0BCB5E19B48A8),
+                Rp512(4, 5, 6, 7, 0, 1, 2, 3, 52, 0x391C0CB3C5C95A63),
+                Rp512(3, 4, 5, 6, 7, 0, 1, 2, 53, 0x4ED8AA4AE3418ACB),
+                Rp512(2, 3, 4, 5, 6, 7, 0, 1, 54, 0x5B9CCA4F7763E373),
+                Rp512(1, 2, 3, 4, 5, 6, 7, 0, 55, 0x682E6FF3D6B2B8A3),
+                Rp512(0, 1, 2, 3, 4, 5, 6, 7, 56, 0x748F82EE5DEFB2FC),
+                Rp512(7, 0, 1, 2, 3, 4, 5, 6, 57, 0x78A5636F43172F60),
+                Rp512(6, 7, 0, 1, 2, 3, 4, 5, 58, 0x84C87814A1F0AB72),
+                Rp512(5, 6, 7, 0, 1, 2, 3, 4, 59, 0x8CC702081A6439EC),
+                Rp512(4, 5, 6, 7, 0, 1, 2, 3, 60, 0x90BEFFFA23631E28),
+                Rp512(3, 4, 5, 6, 7, 0, 1, 2, 61, 0xA4506CEBDE82BDE9),
+                Rp512(2, 3, 4, 5, 6, 7, 0, 1, 62, 0xBEF9A3F7B2C67915),
+                Rp512(1, 2, 3, 4, 5, 6, 7, 0, 63, 0xC67178F2E372532B),
+                Rp512(0, 1, 2, 3, 4, 5, 6, 7, 64, 0xCA273ECEEA26619C),
+                Rp512(7, 0, 1, 2, 3, 4, 5, 6, 65, 0xD186B8C721C0C207),
+                Rp512(6, 7, 0, 1, 2, 3, 4, 5, 66, 0xEADA7DD6CDE0EB1E),
+                Rp512(5, 6, 7, 0, 1, 2, 3, 4, 67, 0xF57D4F7FEE6ED178),
+                Rp512(4, 5, 6, 7, 0, 1, 2, 3, 68, 0x06F067AA72176FBA),
+                Rp512(3, 4, 5, 6, 7, 0, 1, 2, 69, 0x0A637DC5A2C898A6),
+                Rp512(2, 3, 4, 5, 6, 7, 0, 1, 70, 0x113F9804BEF90DAE),
+                Rp512(1, 2, 3, 4, 5, 6, 7, 0, 71, 0x1B710B35131C471B),
+                Rp512(0, 1, 2, 3, 4, 5, 6, 7, 72, 0x28DB77F523047D84),
+                Rp512(7, 0, 1, 2, 3, 4, 5, 6, 73, 0x32CAAB7B40C72493),
+                Rp512(6, 7, 0, 1, 2, 3, 4, 5, 74, 0x3C9EBE0A15C9BEBC),
+                Rp512(5, 6, 7, 0, 1, 2, 3, 4, 75, 0x431D67C49C100D4C),
+                Rp512(4, 5, 6, 7, 0, 1, 2, 3, 76, 0x4CC5D4BECB3E42B6),
+                Rp512(3, 4, 5, 6, 7, 0, 1, 2, 77, 0x597F299CFC657E2A),
+                Rp512(2, 3, 4, 5, 6, 7, 0, 1, 78, 0x5FCB6FAB3AD6FAEC),
+                Rp512(1, 2, 3, 4, 5, 6, 7, 0, 79, 0x6C44198C4A475817),
+            };
+            inline for (round0) |r| {
+                v[r.h] = v[r.h] +% (math.rotr(u64, v[r.e], u64(14)) ^ math.rotr(u64, v[r.e], u64(18)) ^ math.rotr(u64, v[r.e], u64(41))) +% (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +% r.k +% s[r.i];
 
-            v[r.d] = v[r.d] +% v[r.h];
+                v[r.d] = v[r.d] +% v[r.h];
 
-            v[r.h] =
-                v[r.h] +%
-                (math.rotr(u64, v[r.a], u64(28)) ^ math.rotr(u64, v[r.a], u64(34)) ^ math.rotr(u64, v[r.a], u64(39))) +%
-                ((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
-        }
+                v[r.h] = v[r.h] +% (math.rotr(u64, v[r.a], u64(28)) ^ math.rotr(u64, v[r.a], u64(34)) ^ math.rotr(u64, v[r.a], u64(39))) +% ((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
+            }
 
-        d.s[0] +%= v[0];
-        d.s[1] +%= v[1];
-        d.s[2] +%= v[2];
-        d.s[3] +%= v[3];
-        d.s[4] +%= v[4];
-        d.s[5] +%= v[5];
-        d.s[6] +%= v[6];
-        d.s[7] +%= v[7];
-    }
-};}
+            d.s[0] +%= v[0];
+            d.s[1] +%= v[1];
+            d.s[2] +%= v[2];
+            d.s[3] +%= v[3];
+            d.s[4] +%= v[4];
+            d.s[5] +%= v[5];
+            d.s[6] +%= v[6];
+            d.s[7] +%= v[7];
+        }
+    };
+}
 
 test "sha384 single" {
     const h1 = "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b";
@@ -680,7 +715,7 @@ test "sha512 streaming" {
 }
 
 test "sha512 aligned final" {
-    var block = []u8 {0} ** Sha512.block_size;
+    var block = []u8{0} ** Sha512.block_size;
     var out: [Sha512.digest_size]u8 = undefined;
 
     var h = Sha512.init();
diff --git a/std/crypto/test.zig b/std/crypto/test.zig
index 3fa24272e5ecdc49b9b346e911f46f94b9b78395..c0a96a98dee1c9cf8e393ff6e5a81e605fe3c6a4 100644
--- a/std/crypto/test.zig
+++ b/std/crypto/test.zig
@@ -14,7 +14,7 @@ pub fn assertEqualHash(comptime Hasher: var, comptime expected: []const u8, inpu
 pub fn assertEqual(comptime expected: []const u8, input: []const u8) void {
     var expected_bytes: [expected.len / 2]u8 = undefined;
     for (expected_bytes) |*r, i| {
-        r.* = fmt.parseInt(u8, expected[2 * i .. 2 * i + 2], 16) catch unreachable;
+        r.* = fmt.parseInt(u8, expected[2 * i..2 * i + 2], 16) catch unreachable;
     }
 
     debug.assert(mem.eql(u8, expected_bytes, input));
diff --git a/std/crypto/throughput_test.zig b/std/crypto/throughput_test.zig
index 0756f9a4eb1526d19798031ef617e55717bcf60e..c5c4f9fe102c7815b6ea96045fa0ed5704e05518 100644
--- a/std/crypto/throughput_test.zig
+++ b/std/crypto/throughput_test.zig
@@ -11,7 +11,7 @@ const Timer = time.Timer;
 const HashFunction = @import("md5.zig").Md5;
 
 const MiB = 1024 * 1024;
-const BytesToHash  = 1024 * MiB;
+const BytesToHash = 1024 * MiB;
 
 pub fn main() !void {
     var stdout_file = try std.io.getStdOut();
diff --git a/std/cstr.zig b/std/cstr.zig
index d396dcbce3ce497f540700f933478ac914e60559..c9f302606451057eb5bbdddfe82277a69f16367f 100644
--- a/std/cstr.zig
+++ b/std/cstr.zig
@@ -9,7 +9,6 @@ pub const line_sep = switch (builtin.os) {
     else => "\n",
 };
 
-
 pub fn len(ptr: &const u8) usize {
     var count: usize = 0;
     while (ptr[count] != 0) : (count += 1) {}
@@ -95,7 +94,7 @@ pub const NullTerminated2DArray = struct {
         }
         index_buf[i] = null;
 
-        return NullTerminated2DArray {
+        return NullTerminated2DArray{
             .allocator = allocator,
             .byte_count = byte_count,
             .ptr = @ptrCast(?&?&u8, buf.ptr),
@@ -107,4 +106,3 @@ pub const NullTerminated2DArray = struct {
         self.allocator.free(buf[0..self.byte_count]);
     }
 };
-
diff --git a/std/debug/failing_allocator.zig b/std/debug/failing_allocator.zig
index f876b7902d3d600292e28c6311a0ec2864d0ae8d..6b5edff5bf7be64f914be7a29776f69ca0c127c6 100644
--- a/std/debug/failing_allocator.zig
+++ b/std/debug/failing_allocator.zig
@@ -13,14 +13,14 @@ pub const FailingAllocator = struct {
     deallocations: usize,
 
     pub fn init(allocator: &mem.Allocator, fail_index: usize) FailingAllocator {
-        return FailingAllocator {
+        return FailingAllocator{
             .internal_allocator = allocator,
             .fail_index = fail_index,
             .index = 0,
             .allocated_bytes = 0,
             .freed_bytes = 0,
             .deallocations = 0,
-            .allocator = mem.Allocator {
+            .allocator = mem.Allocator{
                 .allocFn = alloc,
                 .reallocFn = realloc,
                 .freeFn = free,
diff --git a/std/debug/index.zig b/std/debug/index.zig
index 36ac2e8a3fa007bab0142d02ac74d11bbb75b9bf..92e565b39184acf98cab8ae77b000b8ce98f2e73 100644
--- a/std/debug/index.zig
+++ b/std/debug/index.zig
@@ -227,8 +227,7 @@ fn printSourceAtAddress(debug_info: &ElfStackTrace, out_stream: var, address: us
                     else => return err,
                 }
             } else |err| switch (err) {
-                error.MissingDebugInfo,
-                error.InvalidDebugInfo => {
+                error.MissingDebugInfo, error.InvalidDebugInfo => {
                     try out_stream.print(ptr_hex ++ " in ??? ({})\n", address, compile_unit_name);
                 },
                 else => return err,
@@ -597,10 +596,12 @@ fn parseFormValueBlock(allocator: &mem.Allocator, in_stream: var, size: usize) !
 }
 
 fn parseFormValueConstant(allocator: &mem.Allocator, in_stream: var, signed: bool, size: usize) !FormValue {
-    return FormValue{ .Const = Constant{
-        .signed = signed,
-        .payload = try readAllocBytes(allocator, in_stream, size),
-    } };
+    return FormValue{
+        .Const = Constant{
+            .signed = signed,
+            .payload = try readAllocBytes(allocator, in_stream, size),
+        },
+    };
 }
 
 fn parseFormValueDwarfOffsetSize(in_stream: var, is_64: bool) !u64 {
@@ -621,7 +622,7 @@ fn parseFormValueRef(allocator: &mem.Allocator, in_stream: var, comptime T: type
     return parseFormValueRefLen(allocator, in_stream, block_len);
 }
 
-const ParseFormValueError = error {
+const ParseFormValueError = error{
     EndOfStream,
     Io,
     BadFd,
@@ -645,8 +646,7 @@ fn parseFormValue(allocator: &mem.Allocator, in_stream: var, form_id: u64, is_64
         DW.FORM_data2 => parseFormValueConstant(allocator, in_stream, false, 2),
         DW.FORM_data4 => parseFormValueConstant(allocator, in_stream, false, 4),
         DW.FORM_data8 => parseFormValueConstant(allocator, in_stream, false, 8),
-        DW.FORM_udata,
-        DW.FORM_sdata => {
+        DW.FORM_udata, DW.FORM_sdata => {
             const block_len = try readULeb128(in_stream);
             const signed = form_id == DW.FORM_sdata;
             return parseFormValueConstant(allocator, in_stream, signed, block_len);
diff --git a/std/dwarf.zig b/std/dwarf.zig
index 04456d9e5cd260268d1607e00aaccffa9199e0d3..76ed1224478b96064a5936086bb37d75068abebb 100644
--- a/std/dwarf.zig
+++ b/std/dwarf.zig
@@ -337,7 +337,6 @@ pub const AT_PGI_lbase = 0x3a00;
 pub const AT_PGI_soffset = 0x3a01;
 pub const AT_PGI_lstride = 0x3a02;
 
-
 pub const OP_addr = 0x03;
 pub const OP_deref = 0x06;
 pub const OP_const1u = 0x08;
@@ -577,7 +576,6 @@ pub const ATE_HP_unsigned_fixed = 0x8e; // Cobol.
 pub const ATE_HP_VAX_complex_float = 0x8f; // F or G floating complex.
 pub const ATE_HP_VAX_complex_float_d = 0x90; // D floating complex.
 
-
 pub const CFA_advance_loc = 0x40;
 pub const CFA_offset = 0x80;
 pub const CFA_restore = 0xc0;
diff --git a/std/elf.zig b/std/elf.zig
index 1764829bc85b565b32035e00bdd0b69a4af0fb28..29b9473f98f5046d48e39af0730b3d53395151ee 100644
--- a/std/elf.zig
+++ b/std/elf.zig
@@ -123,13 +123,11 @@ pub const DT_SYMINFO = 0x6ffffeff;
 pub const DT_ADDRRNGHI = 0x6ffffeff;
 pub const DT_ADDRNUM = 11;
 
-
 pub const DT_VERSYM = 0x6ffffff0;
 
 pub const DT_RELACOUNT = 0x6ffffff9;
 pub const DT_RELCOUNT = 0x6ffffffa;
 
-
 pub const DT_FLAGS_1 = 0x6ffffffb;
 pub const DT_VERDEF = 0x6ffffffc;
 
@@ -139,13 +137,10 @@ pub const DT_VERNEED = 0x6ffffffe;
 pub const DT_VERNEEDNUM = 0x6fffffff;
 pub const DT_VERSIONTAGNUM = 16;
 
-
-
 pub const DT_AUXILIARY = 0x7ffffffd;
 pub const DT_FILTER = 0x7fffffff;
 pub const DT_EXTRANUM = 3;
 
-
 pub const DT_SPARC_REGISTER = 0x70000001;
 pub const DT_SPARC_NUM = 2;
 
@@ -434,9 +429,7 @@ pub const Elf = struct {
         try elf.in_file.seekForward(4);
 
         const header_size = try in.readInt(elf.endian, u16);
-        if ((elf.is_64 and header_size != 64) or
-            (!elf.is_64 and header_size != 52))
-        {
+        if ((elf.is_64 and header_size != 64) or (!elf.is_64 and header_size != 52)) {
             return error.InvalidFormat;
         }
 
@@ -467,16 +460,16 @@ pub const Elf = struct {
             if (sh_entry_size != 64) return error.InvalidFormat;
 
             for (elf.section_headers) |*elf_section| {
-                elf_section.name         = try in.readInt(elf.endian, u32);
-                elf_section.sh_type      = try in.readInt(elf.endian, u32);
-                elf_section.flags        = try in.readInt(elf.endian, u64);
-                elf_section.addr         = try in.readInt(elf.endian, u64);
-                elf_section.offset       = try in.readInt(elf.endian, u64);
-                elf_section.size         = try in.readInt(elf.endian, u64);
-                elf_section.link         = try in.readInt(elf.endian, u32);
-                elf_section.info         = try in.readInt(elf.endian, u32);
-                elf_section.addr_align   = try in.readInt(elf.endian, u64);
-                elf_section.ent_size     = try in.readInt(elf.endian, u64);
+                elf_section.name = try in.readInt(elf.endian, u32);
+                elf_section.sh_type = try in.readInt(elf.endian, u32);
+                elf_section.flags = try in.readInt(elf.endian, u64);
+                elf_section.addr = try in.readInt(elf.endian, u64);
+                elf_section.offset = try in.readInt(elf.endian, u64);
+                elf_section.size = try in.readInt(elf.endian, u64);
+                elf_section.link = try in.readInt(elf.endian, u32);
+                elf_section.info = try in.readInt(elf.endian, u32);
+                elf_section.addr_align = try in.readInt(elf.endian, u64);
+                elf_section.ent_size = try in.readInt(elf.endian, u64);
             }
         } else {
             if (sh_entry_size != 40) return error.InvalidFormat;
@@ -513,8 +506,7 @@ pub const Elf = struct {
     pub fn close(elf: &Elf) void {
         elf.allocator.free(elf.section_headers);
 
-        if (elf.auto_close_stream)
-            elf.in_file.close();
+        if (elf.auto_close_stream) elf.in_file.close();
     }
 
     pub fn findSection(elf: &Elf, name: []const u8) !?&SectionHeader {
@@ -852,27 +844,27 @@ pub const Elf_MIPS_ABIFlags_v0 = extern struct {
     flags2: Elf32_Word,
 };
 
-pub const Ehdr = switch(@sizeOf(usize)) {
+pub const Ehdr = switch (@sizeOf(usize)) {
     4 => Elf32_Ehdr,
     8 => Elf64_Ehdr,
     else => @compileError("expected pointer size of 32 or 64"),
 };
-pub const Phdr = switch(@sizeOf(usize)) {
+pub const Phdr = switch (@sizeOf(usize)) {
     4 => Elf32_Phdr,
     8 => Elf64_Phdr,
     else => @compileError("expected pointer size of 32 or 64"),
 };
-pub const Sym = switch(@sizeOf(usize)) {
+pub const Sym = switch (@sizeOf(usize)) {
     4 => Elf32_Sym,
     8 => Elf64_Sym,
     else => @compileError("expected pointer size of 32 or 64"),
 };
-pub const Verdef = switch(@sizeOf(usize)) {
+pub const Verdef = switch (@sizeOf(usize)) {
     4 => Elf32_Verdef,
     8 => Elf64_Verdef,
     else => @compileError("expected pointer size of 32 or 64"),
 };
-pub const Verdaux = switch(@sizeOf(usize)) {
+pub const Verdaux = switch (@sizeOf(usize)) {
     4 => Elf32_Verdaux,
     8 => Elf64_Verdaux,
     else => @compileError("expected pointer size of 32 or 64"),
diff --git a/std/event.zig b/std/event.zig
index 558bd2a18888b98ea076ec69e210de44796ef74f..6ee8ab35f1f2781f9f1fa76d2dc7666c54a35250 100644
--- a/std/event.zig
+++ b/std/event.zig
@@ -76,19 +76,14 @@ pub const TcpServer = struct {
                     }
                     continue;
                 },
-                error.ConnectionAborted,
-                error.FileDescriptorClosed => continue,
+                error.ConnectionAborted, error.FileDescriptorClosed => continue,
 
                 error.PageFault => unreachable,
                 error.InvalidSyscall => unreachable,
                 error.FileDescriptorNotASocket => unreachable,
                 error.OperationNotSupported => unreachable,
 
-                error.SystemFdQuotaExceeded,
-                error.SystemResources,
-                error.ProtocolFailure,
-                error.BlockedByFirewall,
-                error.Unexpected => {
+                error.SystemFdQuotaExceeded, error.SystemResources, error.ProtocolFailure, error.BlockedByFirewall, error.Unexpected => {
                     @panic("TODO handle this error");
                 },
             }
@@ -121,7 +116,6 @@ pub const Loop = struct {
     pub fn removeFd(self: &Loop, fd: i32) void {
         std.os.linuxEpollCtl(self.epollfd, std.os.linux.EPOLL_CTL_DEL, fd, undefined) catch {};
     }
-
     async fn waitFd(self: &Loop, fd: i32) !void {
         defer self.removeFd(fd);
         suspend |p| {
@@ -169,7 +163,6 @@ test "listen on a port, send bytes, receive bytes" {
         tcp_server: TcpServer,
 
         const Self = this;
-
         async<&mem.Allocator> fn handler(tcp_server: &TcpServer, _addr: &const std.net.Address, _socket: &const std.os.File) void {
             const self = @fieldParentPtr(Self, "tcp_server", tcp_server);
             var socket = _socket.*; // TODO https://github.com/ziglang/zig/issues/733
@@ -184,7 +177,6 @@ test "listen on a port, send bytes, receive bytes" {
                 cancel p;
             }
         }
-
         async fn errorableHandler(self: &Self, _addr: &const std.net.Address, _socket: &const std.os.File) !void {
             const addr = _addr.*; // TODO https://github.com/ziglang/zig/issues/733
             var socket = _socket.*; // TODO https://github.com/ziglang/zig/issues/733
@@ -207,7 +199,6 @@ test "listen on a port, send bytes, receive bytes" {
     defer cancel p;
     loop.run();
 }
-
 async fn doAsyncTest(loop: &Loop, address: &const std.net.Address) void {
     errdefer @panic("test failure");
 
diff --git a/std/fmt/errol/enum3.zig b/std/fmt/errol/enum3.zig
index f8299d3c6fed32a0e875c022a65de0dd40aec715..7663f9b5d985f6cba115b9b7535c2f314155970c 100644
--- a/std/fmt/errol/enum3.zig
+++ b/std/fmt/errol/enum3.zig
@@ -1,4 +1,4 @@
-pub const enum3 = []u64 {
+pub const enum3 = []u64{
     0x4e2e2785c3a2a20b,
     0x240a28877a09a4e1,
     0x728fca36c06cf106,
@@ -439,13 +439,13 @@ const Slab = struct {
 };
 
 fn slab(str: []const u8, exp: i32) Slab {
-    return Slab {
+    return Slab{
         .str = str,
         .exp = exp,
     };
 }
 
-pub const enum3_data = []Slab {
+pub const enum3_data = []Slab{
     slab("40648030339495312", 69),
     slab("4498645355592131", -134),
     slab("678321594594593", 244),
@@ -879,4 +879,3 @@ pub const enum3_data = []Slab {
     slab("32216657306260762", 218),
     slab("30423431424080128", 219),
 };
-
-- 
2.54.0


From afdfbc0367b261ea43d5618027e23022c01e2c93 Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Sat, 26 May 2018 23:17:24 -0400
Subject: [PATCH 10/21] zig fmt: delete empty comments that do nothing

---
 std/zig/parser_test.zig | 16 ++++++++++++++++
 std/zig/render.zig      |  9 +++++++--
 2 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index 909220a6f684c156ca2dd6cd5c6c05ab5fe086b0..a2ee77796bf45065dfc14bee1ec234a3d99f7499 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -28,6 +28,12 @@ test "zig fmt: array literal with hint" {
         \\    5,
         \\    6,
         \\    7 };
+        \\const a = []u8{
+        \\    1, 2,
+        \\    3, 4, //
+        \\    5, 6, //
+        \\    7, 8, //
+        \\};
     ,
         \\const a = []u8{
         \\    1, 2, //
@@ -53,6 +59,16 @@ test "zig fmt: array literal with hint" {
         \\    5, 6, //
         \\    7,
         \\};
+        \\const a = []u8{
+        \\    1,
+        \\    2,
+        \\    3,
+        \\    4,
+        \\    5,
+        \\    6,
+        \\    7,
+        \\    8,
+        \\};
         \\
     );
 }
diff --git a/std/zig/render.zig b/std/zig/render.zig
index fa3755b719b2e44a89111c833dbc86f3f25da4a6..49138e0e786e496e1ca22c8b6e2f3610984d8747 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -1583,8 +1583,13 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
         }
     }
 
-    if (space == Space.IgnoreEmptyComment and mem.trimRight(u8, tree.tokenSlicePtr(next_token), " ").len == 2) {
-        return stream.writeByte(' ');
+    const comment_is_empty = mem.trimRight(u8, tree.tokenSlicePtr(next_token), " ").len == 2;
+    if (comment_is_empty) {
+        switch (space) {
+            Space.IgnoreEmptyComment => return stream.writeByte(' '),
+            Space.Newline => return stream.writeByte('\n'),
+            else => {},
+        }
     }
 
     var loc = tree.tokenLocationPtr(token.end, next_token);
-- 
2.54.0


From 3fed10883bd6916147cce8060949040770532daf Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Sat, 26 May 2018 23:24:43 -0400
Subject: [PATCH 11/21] zig fmt: array literals with no trailing comma all on
 one line

---
 std/zig/parser_test.zig | 10 ++++------
 std/zig/render.zig      | 32 ++++++++++++++++++++++++++++----
 2 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index a2ee77796bf45065dfc14bee1ec234a3d99f7499..e83f99c972c3eb2dbf75858ac9a589334cdda7e7 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -229,16 +229,14 @@ test "zig fmt: add trailing comma to array literal" {
         \\comptime {
         \\    return []u16{'m', 's', 'y', 's', '-' // hi
         \\   };
+        \\    return []u16{'m', 's', 'y', 's',
+        \\      '-'};
         \\}
     ,
         \\comptime {
-        \\    return []u16{
-        \\        'm',
-        \\        's',
-        \\        'y',
-        \\        's',
-        \\        '-', // hi
+        \\    return []u16{ 'm', 's', 'y', 's', '-' // hi
         \\    };
+        \\    return []u16{ 'm', 's', 'y', 's', '-'};
         \\}
         \\
     );
diff --git a/std/zig/render.zig b/std/zig/render.zig
index 49138e0e786e496e1ca22c8b6e2f3610984d8747..9805b7cf754305be083f354031940f48c75b0ef5 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -557,11 +557,11 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                     };
 
 
-                    const new_indent = indent + indent_delta;
-                    try renderToken(tree, stream, lbrace, new_indent, Space.Newline);
-                    try stream.writeByteNTimes(' ', new_indent);
-
                     if (maybe_row_size) |row_size| {
+                        const new_indent = indent + indent_delta;
+                        try renderToken(tree, stream, lbrace, new_indent, Space.Newline);
+                        try stream.writeByteNTimes(' ', new_indent);
+
                         var it = exprs.iterator(0);
                         var i: usize = 0;
                         while (it.next()) |expr| {
@@ -597,6 +597,30 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                         return;
                     }
 
+                    const src_has_trailing_comma = blk: {
+                        const maybe_comma = tree.prevToken(suffix_op.rtoken);
+                        break :blk tree.tokens.at(maybe_comma).id == Token.Id.Comma;
+                    };
+                    if (!src_has_trailing_comma) {
+                        try renderToken(tree, stream, lbrace, indent, Space.Space);
+                        var it = exprs.iterator(0);
+                        while (it.next()) |expr| {
+                            try renderExpression(allocator, stream, tree, indent, expr.*, Space.None);
+
+                            if (it.peek()) |next_expr| {
+                                const comma = tree.nextToken(expr.*.lastToken());
+                                try renderToken(tree, stream, comma, indent, Space.Space); // ,
+                            }
+                        }
+
+                        try renderToken(tree, stream, suffix_op.rtoken, indent, space);
+                        return;
+                    }
+
+                    const new_indent = indent + indent_delta;
+                    try renderToken(tree, stream, lbrace, new_indent, Space.Newline);
+                    try stream.writeByteNTimes(' ', new_indent);
+
                     var it = exprs.iterator(0);
                     while (it.next()) |expr| {
 
-- 
2.54.0


From 122a74724cb527ae6e1997c2c77118047fb50a2c Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Mon, 28 May 2018 16:23:33 -0400
Subject: [PATCH 12/21] zig fmt: use simple newlines rather than empty comments
 to hint

now the first row of an array literal is the hint to zig fmt
for how long each row should be.

See #1003
---
 std/zig/parser_test.zig | 40 ++++++++++--------
 std/zig/render.zig      | 91 ++++++++++++++---------------------------
 2 files changed, 55 insertions(+), 76 deletions(-)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index e83f99c972c3eb2dbf75858ac9a589334cdda7e7..550d8fa1113fc5b590ace9a8959db28402311d75 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -29,34 +29,36 @@ test "zig fmt: array literal with hint" {
         \\    6,
         \\    7 };
         \\const a = []u8{
-        \\    1, 2,
+        \\    1,
+        \\    2,
         \\    3, 4, //
         \\    5, 6, //
         \\    7, 8, //
         \\};
     ,
         \\const a = []u8{
-        \\    1, 2, //
-        \\    3, 4, //
-        \\    5, 6, //
+        \\    1, 2,
+        \\    3, 4,
+        \\    5, 6,
         \\    7,
         \\};
         \\const a = []u8{
-        \\    1, 2, //
-        \\    3, 4, //
-        \\    5, 6, //
-        \\    7, 8, //
+        \\    1, 2,
+        \\    3, 4,
+        \\    5, 6,
+        \\    7, 8,
         \\};
         \\const a = []u8{
-        \\    1, 2, //
-        \\    3, 4, //
+        \\    1, 2,
+        \\    3, 4,
         \\    5, 6, // blah
-        \\    7, 8, //
+        \\    7, 8,
         \\};
         \\const a = []u8{
-        \\    1, 2, //
-        \\    3, 4, //
-        \\    5, 6, //
+        \\    1, 2,
+        \\    3, //
+        \\        4,
+        \\    5, 6,
         \\    7,
         \\};
         \\const a = []u8{
@@ -231,12 +233,18 @@ test "zig fmt: add trailing comma to array literal" {
         \\   };
         \\    return []u16{'m', 's', 'y', 's',
         \\      '-'};
+        \\    return []u16{'m', 's', 'y', 's', '-'};
         \\}
     ,
         \\comptime {
-        \\    return []u16{ 'm', 's', 'y', 's', '-' // hi
+        \\    return []u16{
+        \\        'm', 's', 'y', 's', '-', // hi
         \\    };
-        \\    return []u16{ 'm', 's', 'y', 's', '-'};
+        \\    return []u16{
+        \\        'm', 's', 'y', 's',
+        \\        '-',
+        \\    };
+        \\    return []u16{ 'm', 's', 'y', 's', '-' };
         \\}
         \\
     );
diff --git a/std/zig/render.zig b/std/zig/render.zig
index 9805b7cf754305be083f354031940f48c75b0ef5..1528ae31aa9aecace47c99db827abcfcf8b1c776 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -534,36 +534,42 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
 
                     // scan to find row size
                     const maybe_row_size: ?usize = blk: {
-                        var count: usize = 0;
+                        var count: usize = 1;
                         var it = exprs.iterator(0);
-                        var prev_token = (??it.peek()).*.lastToken() + 1;
-                        while (it.next()) |expr| {
-                            const expr_last_token = expr.*.lastToken() + 1;
-                            const next_token = tree.tokens.at(expr_last_token + 1);
-                            const loc = tree.tokenLocationPtr(tree.tokens.at(prev_token).end, next_token);
-                            if (loc.line != 0) break :blk null;
-                            if (next_token.id == Token.Id.LineComment) {
-                                const trimmed = mem.trimRight(u8, tree.tokenSlicePtr(next_token), " ");
-                                if (trimmed.len == 2) {
-                                    break :blk count;
-                                } else {
-                                    break :blk null;
+                        while (true) {
+                            const expr = (??it.next()).*;
+                            if (it.peek()) |next_expr| {
+                                const expr_last_token = expr.*.lastToken() + 1;
+                                const loc = tree.tokenLocation(tree.tokens.at(expr_last_token).end, next_expr.*.firstToken());
+                                if (loc.line != 0) break :blk count;
+                                count += 1;
+                            } else {
+                                const expr_last_token = expr.*.lastToken();
+                                const loc = tree.tokenLocation(tree.tokens.at(expr_last_token).end, suffix_op.rtoken);
+                                if (loc.line == 0) {
+                                    // all on one line
+                                    const src_has_trailing_comma = trailblk: {
+                                        const maybe_comma = tree.prevToken(suffix_op.rtoken);
+                                        break :trailblk tree.tokens.at(maybe_comma).id == Token.Id.Comma;
+                                    };
+                                    if (src_has_trailing_comma) {
+                                        break :blk 1; // force row size 1
+                                    } else {
+                                        break :blk null; // no newlines
+                                    }
                                 }
+                                break :blk count;
                             }
-                            prev_token = expr_last_token;
-                            count += 1;
                         }
-                        break :blk null;
                     };
 
-
                     if (maybe_row_size) |row_size| {
                         const new_indent = indent + indent_delta;
                         try renderToken(tree, stream, lbrace, new_indent, Space.Newline);
                         try stream.writeByteNTimes(' ', new_indent);
 
                         var it = exprs.iterator(0);
-                        var i: usize = 0;
+                        var i: usize = 1;
                         while (it.next()) |expr| {
                             if (it.peek()) |next_expr| {
                                 try renderExpression(allocator, stream, tree, new_indent, expr.*, Space.None);
@@ -571,23 +577,16 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                                 const comma = tree.nextToken(expr.*.lastToken());
 
                                 if (i != row_size) {
-                                    try renderToken(tree, stream, comma, new_indent, Space.IgnoreEmptyComment); // ,
+                                    try renderToken(tree, stream, comma, new_indent, Space.Space); // ,
                                     i += 1;
                                     continue;
                                 }
-                                i = 0;
+                                i = 1;
 
-                                try renderToken(tree, stream, comma, new_indent, Space.NoIndent); // ,
-
-                                const next_token = tree.tokens.at(comma + 1);
-                                if (next_token.id != Token.Id.LineComment) {
-                                    try stream.print(" //\n");
-                                }
+                                try renderToken(tree, stream, comma, new_indent, Space.Newline); // ,
 
                                 try renderExtraNewline(tree, stream, next_expr.*);
                                 try stream.writeByteNTimes(' ', new_indent);
-                            } else if (i == row_size) {
-                                try renderTrailingCommaAndEmptyComment(allocator, stream, tree, new_indent, expr.*); // , //
                             } else {
                                 try renderTrailingComma(allocator, stream, tree, new_indent, expr.*, Space.Newline); // ,
                             }
@@ -595,50 +594,22 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                         try stream.writeByteNTimes(' ', indent);
                         try renderToken(tree, stream, suffix_op.rtoken, indent, space);
                         return;
-                    }
-
-                    const src_has_trailing_comma = blk: {
-                        const maybe_comma = tree.prevToken(suffix_op.rtoken);
-                        break :blk tree.tokens.at(maybe_comma).id == Token.Id.Comma;
-                    };
-                    if (!src_has_trailing_comma) {
+                    } else {
                         try renderToken(tree, stream, lbrace, indent, Space.Space);
                         var it = exprs.iterator(0);
                         while (it.next()) |expr| {
-                            try renderExpression(allocator, stream, tree, indent, expr.*, Space.None);
-
                             if (it.peek()) |next_expr| {
+                                try renderExpression(allocator, stream, tree, indent, expr.*, Space.None);
                                 const comma = tree.nextToken(expr.*.lastToken());
                                 try renderToken(tree, stream, comma, indent, Space.Space); // ,
+                            } else {
+                                try renderExpression(allocator, stream, tree, indent, expr.*, Space.Space);
                             }
                         }
 
                         try renderToken(tree, stream, suffix_op.rtoken, indent, space);
                         return;
                     }
-
-                    const new_indent = indent + indent_delta;
-                    try renderToken(tree, stream, lbrace, new_indent, Space.Newline);
-                    try stream.writeByteNTimes(' ', new_indent);
-
-                    var it = exprs.iterator(0);
-                    while (it.next()) |expr| {
-
-                        if (it.peek()) |next_expr| {
-                            try renderExpression(allocator, stream, tree, new_indent, expr.*, Space.None);
-
-                            const comma = tree.nextToken(expr.*.lastToken());
-                            try renderToken(tree, stream, comma, new_indent, Space.Newline); // ,
-
-                            try renderExtraNewline(tree, stream, next_expr.*);
-                            try stream.writeByteNTimes(' ', new_indent);
-                        } else {
-                            try renderTrailingComma(allocator, stream, tree, new_indent, expr.*, Space.Newline);
-                        }
-                    }
-
-                    try stream.writeByteNTimes(' ', indent);
-                    try renderToken(tree, stream, suffix_op.rtoken, indent, space);
                 },
             }
         },
-- 
2.54.0


From fd13a757855e185b4250c65fe89bbd72c9479a52 Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Mon, 28 May 2018 16:59:42 -0400
Subject: [PATCH 13/21] zig fmt: allow same line struct literal with no
 trailing comma

See #1003
---
 std/zig/parser_test.zig | 15 +++++++++++++++
 std/zig/render.zig      | 31 +++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index 550d8fa1113fc5b590ace9a8959db28402311d75..72818bc074b2dc616d3727d03dacdffaef2be8dc 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -1,3 +1,18 @@
+test "zig fmt: struct literal no trailing comma" {
+    try testTransform(
+        \\const a = foo{ .x = 1, .y = 2 };
+        \\const a = foo{ .x = 1,
+        \\    .y = 2 };
+    ,
+        \\const a = foo{ .x = 1, .y = 2 };
+        \\const a = foo{
+        \\    .x = 1,
+        \\    .y = 2,
+        \\};
+        \\
+    );
+}
+
 test "zig fmt: array literal with hint" {
     try testTransform(
         \\const a = []u8{
diff --git a/std/zig/render.zig b/std/zig/render.zig
index 1528ae31aa9aecace47c99db827abcfcf8b1c776..86e972c173111463a1885decdf932389ea17a90e 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -486,6 +486,37 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                         return;
                     }
 
+                    const src_has_trailing_comma = blk: {
+                        const maybe_comma = tree.prevToken(suffix_op.rtoken);
+                        break :blk tree.tokens.at(maybe_comma).id == Token.Id.Comma;
+                    };
+
+                    const src_same_line = blk: {
+                        const loc = tree.tokenLocation(tree.tokens.at(lbrace).end, suffix_op.rtoken);
+                        break :blk loc.line == 0;
+                    };
+
+                    if (!src_has_trailing_comma and src_same_line) {
+                        // render all on one line, no trailing comma
+                        try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
+                        try renderToken(tree, stream, lbrace, indent, Space.Space);
+
+                        var it = field_inits.iterator(0);
+                        while (it.next()) |field_init| {
+                            if (it.peek() != null) {
+                                try renderExpression(allocator, stream, tree, indent, field_init.*, Space.None);
+
+                                const comma = tree.nextToken(field_init.*.lastToken());
+                                try renderToken(tree, stream, comma, indent, Space.Space);
+                            } else {
+                                try renderExpression(allocator, stream, tree, indent, field_init.*, Space.Space);
+                            }
+                        }
+
+                        try renderToken(tree, stream, suffix_op.rtoken, indent, space);
+                        return;
+                    }
+
                     try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
                     try renderToken(tree, stream, lbrace, indent, Space.Newline);
 
-- 
2.54.0


From 6c1fda3f99ebef60f4cb45b6bd66e76c85483c36 Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Mon, 28 May 2018 17:09:55 -0400
Subject: [PATCH 14/21] zig fmt: fix switch body indent

---
 std/zig/parser_test.zig | 12 ++++++++++++
 std/zig/render.zig      |  6 +++---
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index 72818bc074b2dc616d3727d03dacdffaef2be8dc..dc522b3ef422d9d2a3391d49a95e1ef65d54d957 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -1,3 +1,15 @@
+test "zig fmt: switch comment before prong" {
+    try testCanonical(
+        \\comptime {
+        \\    switch (a) {
+        \\        // hi
+        \\        0 => {},
+        \\    }
+        \\}
+        \\
+    );
+}
+
 test "zig fmt: struct literal no trailing comma" {
     try testTransform(
         \\const a = foo{ .x = 1, .y = 2 };
diff --git a/std/zig/render.zig b/std/zig/render.zig
index 86e972c173111463a1885decdf932389ea17a90e..2f94d1cf8aebaef5dd4aa5a7ada3bf3eb3cd2e3f 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -1050,11 +1050,11 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
 
             try renderExpression(allocator, stream, tree, indent, switch_node.expr, Space.None);
 
-            try renderToken(tree, stream, rparen, indent, Space.Space); // )
-            try renderToken(tree, stream, lbrace, indent, Space.Newline); // {
-
             const new_indent = indent + indent_delta;
 
+            try renderToken(tree, stream, rparen, indent, Space.Space); // )
+            try renderToken(tree, stream, lbrace, new_indent, Space.Newline); // {
+
             var it = switch_node.cases.iterator(0);
             while (it.next()) |node| {
                 try stream.writeByteNTimes(' ', new_indent);
-- 
2.54.0


From 530da363521ca7c3b22e6451874cef24d49683cc Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Mon, 28 May 2018 17:43:17 -0400
Subject: [PATCH 15/21] zig fmt: fix enum decl with no trailing comma

See #1003
---
 std/zig/parser_test.zig | 12 +++++++
 std/zig/render.zig      | 69 ++++++++++++++++++++---------------------
 2 files changed, 46 insertions(+), 35 deletions(-)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index dc522b3ef422d9d2a3391d49a95e1ef65d54d957..dc586e53b4631385c7f73ef77bd966162ab6c7b3 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -1,3 +1,15 @@
+test "zig fmt: enum decl with no trailing comma" {
+    try testTransform(
+        \\const StrLitKind = enum {Normal, C};
+    ,
+        \\const StrLitKind = enum {
+        \\    Normal,
+        \\    C,
+        \\};
+        \\
+    );
+}
+
 test "zig fmt: switch comment before prong" {
     try testCanonical(
         \\comptime {
diff --git a/std/zig/render.zig b/std/zig/render.zig
index 2f94d1cf8aebaef5dd4aa5a7ada3bf3eb3cd2e3f..ed760a4b22dcd031262972b56cde1c53a44d4507 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -110,22 +110,29 @@ fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, i
 
             try renderDocComments(tree, stream, tag, indent);
 
-            const name_space = if (tag.type_expr == null and tag.value_expr != null) Space.Space else Space.None;
-            try renderToken(tree, stream, tag.name_token, indent, name_space); // name
+            if (tag.type_expr == null and tag.value_expr == null) {
+                return renderTokenAndTrailingComma(tree, stream, tag.name_token, indent, Space.Newline); // name,
+            }
+
+            if (tag.type_expr == null) {
+                try renderToken(tree, stream, tag.name_token, indent, Space.Space); // name
+            } else {
+                try renderToken(tree, stream, tag.name_token, indent, Space.None); // name
+            }
 
             if (tag.type_expr) |type_expr| {
                 try renderToken(tree, stream, tree.nextToken(tag.name_token), indent, Space.Space); // :
 
-                const after_type_space = if (tag.value_expr == null) Space.None else Space.Space;
-                try renderExpression(allocator, stream, tree, indent, type_expr, after_type_space);
+                if (tag.value_expr == null) {
+                    return renderTrailingComma(allocator, stream, tree, indent, type_expr, Space.Newline); // type,
+                } else {
+                    try renderExpression(allocator, stream, tree, indent, type_expr, Space.Space); // type
+                }
             }
 
-            if (tag.value_expr) |value_expr| {
-                try renderToken(tree, stream, tree.prevToken(value_expr.firstToken()), indent, Space.Space); // =
-                try renderExpression(allocator, stream, tree, indent, value_expr, Space.None);
-            }
-
-            try renderToken(tree, stream, tree.nextToken(decl.lastToken()), indent, Space.Newline); // ,
+            const value_expr = ??tag.value_expr;
+            try renderToken(tree, stream, tree.prevToken(value_expr.firstToken()), indent, Space.Space); // =
+            try renderTrailingComma(allocator, stream, tree, indent, value_expr, Space.Newline); // value,
         },
 
         ast.Node.Id.EnumTag => {
@@ -133,15 +140,14 @@ fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, i
 
             try renderDocComments(tree, stream, tag, indent);
 
-            const after_name_space = if (tag.value == null) Space.None else Space.Space;
-            try renderToken(tree, stream, tag.name_token, indent, after_name_space); // name
-
             if (tag.value) |value| {
+                try renderToken(tree, stream, tag.name_token, indent, Space.Space); // name
+
                 try renderToken(tree, stream, tree.nextToken(tag.name_token), indent, Space.Space); // =
-                try renderExpression(allocator, stream, tree, indent, value, Space.None);
+                try renderTrailingComma(allocator, stream, tree, indent, value, Space.Newline);
+            } else {
+                try renderTokenAndTrailingComma(tree, stream, tag.name_token, indent, Space.Newline); // name
             }
-
-            try renderToken(tree, stream, tree.nextToken(decl.lastToken()), indent, Space.Newline); // ,
         },
 
         ast.Node.Id.Comptime => {
@@ -1584,7 +1590,6 @@ const Space = enum {
     NoNewline,
     NoIndent,
     NoComment,
-    IgnoreEmptyComment,
 };
 
 fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent: usize, space: Space) (@typeOf(stream).Child.Error || Error)!void {
@@ -1604,7 +1609,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                     return stream.write("\n");
                 }
             },
-            Space.Space, Space.IgnoreEmptyComment => return stream.writeByte(' '),
+            Space.Space => return stream.writeByte(' '),
             Space.NoComment => unreachable,
         }
     }
@@ -1612,7 +1617,6 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
     const comment_is_empty = mem.trimRight(u8, tree.tokenSlicePtr(next_token), " ").len == 2;
     if (comment_is_empty) {
         switch (space) {
-            Space.IgnoreEmptyComment => return stream.writeByte(' '),
             Space.Newline => return stream.writeByte('\n'),
             else => {},
         }
@@ -1644,7 +1648,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                     }
                 },
                 Space.NoNewline => {},
-                Space.NoComment, Space.IgnoreEmptyComment => unreachable,
+                Space.NoComment => unreachable,
             }
             return;
         }
@@ -1681,7 +1685,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                     try stream.writeByteNTimes(' ', next_line_indent);
                 },
                 Space.NoNewline => {},
-                Space.NoComment, Space.IgnoreEmptyComment => unreachable,
+                Space.NoComment => unreachable,
             }
             return;
         }
@@ -1720,27 +1724,22 @@ fn renderTrailingComma(allocator: &mem.Allocator, stream: var, tree: &ast.Tree,
     }
 }
 
-fn renderTrailingCommaAndEmptyComment(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, base: &ast.Node) (@typeOf(stream).Child.Error || Error)!void
-{
-    const end_token = base.lastToken() + 1;
+fn renderTokenAndTrailingComma(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent: usize, space: Space) (@typeOf(stream).Child.Error || Error)!void {
+    const end_token = token_index + 1;
     switch (tree.tokens.at(end_token).id) {
         Token.Id.Comma => {
-            try renderExpression(allocator, stream, tree, indent, base, Space.None);
-            try renderToken(tree, stream, end_token, indent, Space.Space); // ,
-
-            const next_token = tree.tokens.at(end_token + 1);
-            if (next_token.id != Token.Id.LineComment) {
-                try stream.print("//\n");
-            }
+            try renderToken(tree, stream, token_index, indent, Space.None);
+            try renderToken(tree, stream, end_token, indent, space); // ,
         },
         Token.Id.LineComment => {
-            try renderExpression(allocator, stream, tree, indent, base, Space.NoComment);
+            try renderToken(tree, stream, token_index, indent, Space.NoComment);
             try stream.write(", ");
-            try renderToken(tree, stream, end_token, indent, Space.Newline);
+            try renderToken(tree, stream, end_token, indent, space);
         },
         else => {
-            try renderExpression(allocator, stream, tree, indent, base, Space.None);
-            try stream.write(", //\n");
+            try renderToken(tree, stream, token_index, indent, Space.None);
+            try stream.write(",\n");
+            assert(space == Space.Newline);
         },
     }
 }
-- 
2.54.0


From 354ab1c5c8ec62c485fbc297817a0e70ab625a71 Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Mon, 28 May 2018 21:18:41 -0400
Subject: [PATCH 16/21] zig fmt: render fn decl with trailing comma 1 line per
 param

---
 std/zig/parser_test.zig |  15 +++-
 std/zig/render.zig      | 158 ++++++++++++++++++++--------------------
 2 files changed, 95 insertions(+), 78 deletions(-)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index dc586e53b4631385c7f73ef77bd966162ab6c7b3..edf1b002b0af96cb569735a1e8b0333f886e8146 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -1,3 +1,15 @@
+test "zig fmt: fn decl with trailing comma" {
+    try testTransform(
+        \\fn foo(a: i32, b: i32,) void {}
+    ,
+        \\fn foo(
+        \\    a: i32,
+        \\    b: i32,
+        \\) void {}
+        \\
+    );
+}
+
 test "zig fmt: enum decl with no trailing comma" {
     try testTransform(
         \\const StrLitKind = enum {Normal, C};
@@ -247,7 +259,8 @@ test "zig fmt: switch cases trailing comma" {
         \\    switch (x) {
         \\        1, 2, 3 => {},
         \\        4,
-        \\        5, => {},
+        \\        5,
+        \\        => {},
         \\        6...8 => {},
         \\        else => {},
         \\    }
diff --git a/std/zig/render.zig b/std/zig/render.zig
index ed760a4b22dcd031262972b56cde1c53a44d4507..b8481b1348d7942c658ef67cd7aec47cc6f0b4ce 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -102,7 +102,7 @@ fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, i
             }
             try renderToken(tree, stream, field.name_token, indent, Space.None); // name
             try renderToken(tree, stream, tree.nextToken(field.name_token), indent, Space.Space); // :
-            try renderTrailingComma(allocator, stream, tree, indent, field.type_expr, Space.Newline); // type,
+            try renderExpression(allocator, stream, tree, indent, field.type_expr, Space.Comma); // type,
         },
 
         ast.Node.Id.UnionTag => {
@@ -111,7 +111,7 @@ fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, i
             try renderDocComments(tree, stream, tag, indent);
 
             if (tag.type_expr == null and tag.value_expr == null) {
-                return renderTokenAndTrailingComma(tree, stream, tag.name_token, indent, Space.Newline); // name,
+                return renderToken(tree, stream, tag.name_token, indent, Space.Comma); // name,
             }
 
             if (tag.type_expr == null) {
@@ -124,7 +124,7 @@ fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, i
                 try renderToken(tree, stream, tree.nextToken(tag.name_token), indent, Space.Space); // :
 
                 if (tag.value_expr == null) {
-                    return renderTrailingComma(allocator, stream, tree, indent, type_expr, Space.Newline); // type,
+                    return renderExpression(allocator, stream, tree, indent, type_expr, Space.Comma); // type,
                 } else {
                     try renderExpression(allocator, stream, tree, indent, type_expr, Space.Space); // type
                 }
@@ -132,7 +132,7 @@ fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, i
 
             const value_expr = ??tag.value_expr;
             try renderToken(tree, stream, tree.prevToken(value_expr.firstToken()), indent, Space.Space); // =
-            try renderTrailingComma(allocator, stream, tree, indent, value_expr, Space.Newline); // value,
+            try renderExpression(allocator, stream, tree, indent, value_expr, Space.Comma); // value,
         },
 
         ast.Node.Id.EnumTag => {
@@ -144,9 +144,9 @@ fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, i
                 try renderToken(tree, stream, tag.name_token, indent, Space.Space); // name
 
                 try renderToken(tree, stream, tree.nextToken(tag.name_token), indent, Space.Space); // =
-                try renderTrailingComma(allocator, stream, tree, indent, value, Space.Newline);
+                try renderExpression(allocator, stream, tree, indent, value, Space.Comma);
             } else {
-                try renderTokenAndTrailingComma(tree, stream, tag.name_token, indent, Space.Newline); // name
+                try renderToken(tree, stream, tag.name_token, indent, Space.Comma); // name
             }
         },
 
@@ -413,7 +413,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                                 try renderToken(tree, stream, comma, new_indent, Space.Newline); // ,
                                 try renderExtraNewline(tree, stream, next_node.*);
                             } else {
-                                try renderTrailingComma(allocator, stream, tree, param_node_new_indent, param_node.*, Space.Newline);
+                                try renderExpression(allocator, stream, tree, param_node_new_indent, param_node.*, Space.Comma);
                                 try stream.writeByteNTimes(' ', indent);
                                 try renderToken(tree, stream, suffix_op.rtoken, indent, space);
                                 return;
@@ -540,7 +540,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
 
                             try renderExtraNewline(tree, stream, next_field_init.*);
                         } else {
-                            try renderTrailingComma(allocator, stream, tree, new_indent, field_init.*, Space.Newline);
+                            try renderExpression(allocator, stream, tree, new_indent, field_init.*, Space.Comma);
                         }
                     }
 
@@ -625,7 +625,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                                 try renderExtraNewline(tree, stream, next_expr.*);
                                 try stream.writeByteNTimes(' ', new_indent);
                             } else {
-                                try renderTrailingComma(allocator, stream, tree, new_indent, expr.*, Space.Newline); // ,
+                                try renderExpression(allocator, stream, tree, new_indent, expr.*, Space.Comma); // ,
                             }
                         }
                         try stream.writeByteNTimes(' ', indent);
@@ -892,7 +892,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
 
                     try renderExtraNewline(tree, stream, next_node.*);
                 } else {
-                    try renderTrailingComma(allocator, stream, tree, new_indent, node.*, Space.Newline);
+                    try renderExpression(allocator, stream, tree, new_indent, node.*, Space.Comma);
                 }
             }
 
@@ -976,29 +976,55 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 try renderExpression(allocator, stream, tree, indent, &async_attr.base, Space.Space);
             }
 
-            if (fn_proto.name_token) |name_token| blk: {
+            const lparen = if (fn_proto.name_token) |name_token| blk: {
                 try renderToken(tree, stream, fn_proto.fn_token, indent, Space.Space); // fn
                 try renderToken(tree, stream, name_token, indent, Space.None); // name
-                try renderToken(tree, stream, tree.nextToken(name_token), indent, Space.None); // (
+                break :blk tree.nextToken(name_token);
             } else blk: {
                 try renderToken(tree, stream, fn_proto.fn_token, indent, Space.None); // fn
-                try renderToken(tree, stream, tree.nextToken(fn_proto.fn_token), indent, Space.None); // (
-            }
-
-            var it = fn_proto.params.iterator(0);
-            while (it.next()) |param_decl_node| {
-                try renderParamDecl(allocator, stream, tree, indent, param_decl_node.*);
-
-                if (it.peek() != null) {
-                    const comma = tree.nextToken(param_decl_node.*.lastToken());
-                    try renderToken(tree, stream, comma, indent, Space.Space); // ,
-                }
-            }
+                break :blk tree.nextToken(fn_proto.fn_token);
+            };
 
             const rparen = tree.prevToken(switch (fn_proto.return_type) {
                 ast.Node.FnProto.ReturnType.Explicit => |node| node.firstToken(),
                 ast.Node.FnProto.ReturnType.InferErrorSet => |node| tree.prevToken(node.firstToken()),
             });
+
+            const src_params_trailing_comma = blk: {
+                const maybe_comma = tree.prevToken(rparen);
+                break :blk tree.tokens.at(maybe_comma).id == Token.Id.Comma;
+            };
+            const src_params_same_line = blk: {
+                const loc = tree.tokenLocation(tree.tokens.at(lparen).end, rparen);
+                break :blk loc.line == 0;
+            };
+
+            if (!src_params_trailing_comma and src_params_same_line) {
+                try renderToken(tree, stream, lparen, indent, Space.None); // (
+
+                // render all on one line, no trailing comma
+                var it = fn_proto.params.iterator(0);
+                while (it.next()) |param_decl_node| {
+                    try renderParamDecl(allocator, stream, tree, indent, param_decl_node.*, Space.None);
+
+                    if (it.peek() != null) {
+                        const comma = tree.nextToken(param_decl_node.*.lastToken());
+                        try renderToken(tree, stream, comma, indent, Space.Space); // ,
+                    }
+                }
+            } else {
+                // one param per line
+                const new_indent = indent + indent_delta;
+                try renderToken(tree, stream, lparen, new_indent, Space.Newline); // (
+
+                var it = fn_proto.params.iterator(0);
+                while (it.next()) |param_decl_node| {
+                    try stream.writeByteNTimes(' ', new_indent);
+                    try renderParamDecl(allocator, stream, tree, indent, param_decl_node.*, Space.Comma);
+                }
+                try stream.writeByteNTimes(' ', indent);
+            }
+
             try renderToken(tree, stream, rparen, indent, Space.Space); // )
 
             if (fn_proto.align_expr) |align_expr| {
@@ -1064,7 +1090,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             var it = switch_node.cases.iterator(0);
             while (it.next()) |node| {
                 try stream.writeByteNTimes(' ', new_indent);
-                try renderExpression(allocator, stream, tree, new_indent, node.*, Space.Newline);
+                try renderExpression(allocator, stream, tree, new_indent, node.*, Space.Comma);
 
                 if (it.peek()) |next_node| {
                     try renderExtraNewline(tree, stream, next_node.*);
@@ -1110,7 +1136,8 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                         try renderExtraNewline(tree, stream, next_node.*);
                         try stream.writeByteNTimes(' ', indent);
                     } else {
-                        try renderTrailingComma(allocator, stream, tree, indent, node.*, Space.Space);
+                        try renderExpression(allocator, stream, tree, indent, node.*, Space.Comma);
+                        try stream.writeByteNTimes(' ', indent);
                         break;
                     }
                 }
@@ -1122,7 +1149,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
             }
 
-            try renderTrailingComma(allocator, stream, tree, indent, switch_case.expr, space);
+            try renderExpression(allocator, stream, tree, indent, switch_case.expr, space);
         },
         ast.Node.Id.SwitchElse => {
             const switch_else = @fieldParentPtr(ast.Node.SwitchElse, "base", base);
@@ -1543,7 +1570,7 @@ fn renderVarDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent
     try renderToken(tree, stream, var_decl.semicolon_token, indent, Space.Newline);
 }
 
-fn renderParamDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, base: &ast.Node) (@typeOf(stream).Child.Error || Error)!void {
+fn renderParamDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, base: &ast.Node, space: Space) (@typeOf(stream).Child.Error || Error)!void {
     const param_decl = @fieldParentPtr(ast.Node.ParamDecl, "base", base);
 
     if (param_decl.comptime_token) |comptime_token| {
@@ -1557,9 +1584,9 @@ fn renderParamDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, inde
         try renderToken(tree, stream, tree.nextToken(name_token), indent, Space.Space); // :
     }
     if (param_decl.var_args_token) |var_args_token| {
-        try renderToken(tree, stream, var_args_token, indent, Space.None);
+        try renderToken(tree, stream, var_args_token, indent, space);
     } else {
-        try renderExpression(allocator, stream, tree, indent, param_decl.type_node, Space.None);
+        try renderExpression(allocator, stream, tree, indent, param_decl.type_node, space);
     }
 }
 
@@ -1586,6 +1613,7 @@ fn renderStatement(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, inde
 const Space = enum {
     None,
     Newline,
+    Comma,
     Space,
     NoNewline,
     NoIndent,
@@ -1596,9 +1624,27 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
     var token = tree.tokens.at(token_index);
     try stream.write(mem.trimRight(u8, tree.tokenSlicePtr(token), " "));
 
-    if (space == Space.NoComment) return;
-
     var next_token = tree.tokens.at(token_index + 1);
+
+    switch (space) {
+        Space.NoComment => return,
+        Space.Comma => switch (next_token.id) {
+            Token.Id.Comma => return renderToken(tree, stream, token_index + 1, indent, Space.Newline),
+            Token.Id.LineComment => {
+                try stream.write(", ");
+                return renderToken(tree, stream, token_index + 1, indent, Space.Newline);
+            },
+            else => {
+                if (tree.tokens.at(token_index + 2).id == Token.Id.MultilineStringLiteralLine) {
+                    return stream.write(",");
+                } else {
+                    return stream.write(",\n");
+                }
+            },
+        },
+        else => {},
+    }
+
     if (next_token.id != Token.Id.LineComment) {
         switch (space) {
             Space.None, Space.NoNewline, Space.NoIndent => return,
@@ -1610,7 +1656,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                 }
             },
             Space.Space => return stream.writeByte(' '),
-            Space.NoComment => unreachable,
+            Space.NoComment, Space.Comma => unreachable,
         }
     }
 
@@ -1648,7 +1694,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                     }
                 },
                 Space.NoNewline => {},
-                Space.NoComment => unreachable,
+                Space.NoComment, Space.Comma => unreachable,
             }
             return;
         }
@@ -1685,7 +1731,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                     try stream.writeByteNTimes(' ', next_line_indent);
                 },
                 Space.NoNewline => {},
-                Space.NoComment => unreachable,
+                Space.NoComment, Space.Comma => unreachable,
             }
             return;
         }
@@ -1701,45 +1747,3 @@ fn renderDocComments(tree: &ast.Tree, stream: var, node: var, indent: usize) (@t
         try stream.writeByteNTimes(' ', indent);
     }
 }
-
-fn renderTrailingComma(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, base: &ast.Node,
-    space: Space) (@typeOf(stream).Child.Error || Error)!void
-{
-    const end_token = base.lastToken() + 1;
-    switch (tree.tokens.at(end_token).id) {
-        Token.Id.Comma => {
-            try renderExpression(allocator, stream, tree, indent, base, Space.None);
-            try renderToken(tree, stream, end_token, indent, space); // ,
-        },
-        Token.Id.LineComment => {
-            try renderExpression(allocator, stream, tree, indent, base, Space.NoComment);
-            try stream.write(", ");
-            try renderToken(tree, stream, end_token, indent, space);
-        },
-        else => {
-            try renderExpression(allocator, stream, tree, indent, base, Space.None);
-            try stream.write(",\n");
-            assert(space == Space.Newline);
-        },
-    }
-}
-
-fn renderTokenAndTrailingComma(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent: usize, space: Space) (@typeOf(stream).Child.Error || Error)!void {
-    const end_token = token_index + 1;
-    switch (tree.tokens.at(end_token).id) {
-        Token.Id.Comma => {
-            try renderToken(tree, stream, token_index, indent, Space.None);
-            try renderToken(tree, stream, end_token, indent, space); // ,
-        },
-        Token.Id.LineComment => {
-            try renderToken(tree, stream, token_index, indent, Space.NoComment);
-            try stream.write(", ");
-            try renderToken(tree, stream, end_token, indent, space);
-        },
-        else => {
-            try renderToken(tree, stream, token_index, indent, Space.None);
-            try stream.write(",\n");
-            assert(space == Space.Newline);
-        },
-    }
-}
-- 
2.54.0


From 71badebd08a1e5da9326fc7126c4de0fba4ae3d0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Mon, 28 May 2018 21:28:32 -0400
Subject: [PATCH 17/21] zig fmt: respect line breaks after infix operators

---
 std/zig/parser_test.zig | 17 +++++++++++++++++
 std/zig/render.zig      | 12 +++++++++++-
 2 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index edf1b002b0af96cb569735a1e8b0333f886e8146..f722c7f08f1ed9479b71e372c4d0d73937305888 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -1,3 +1,20 @@
+test "zig fmt: respect line breaks after infix operators" {
+    try testCanonical(
+        \\comptime {
+        \\    self.crc =
+        \\        lookup_tables[0][p[7]] ^
+        \\        lookup_tables[1][p[6]] ^
+        \\        lookup_tables[2][p[5]] ^
+        \\        lookup_tables[3][p[4]] ^
+        \\        lookup_tables[4][@truncate(u8, self.crc >> 24)] ^
+        \\        lookup_tables[5][@truncate(u8, self.crc >> 16)] ^
+        \\        lookup_tables[6][@truncate(u8, self.crc >> 8)] ^
+        \\        lookup_tables[7][@truncate(u8, self.crc >> 0)];
+        \\}
+        \\
+    );
+}
+
 test "zig fmt: fn decl with trailing comma" {
     try testTransform(
         \\fn foo(a: i32, b: i32,) void {}
diff --git a/std/zig/render.zig b/std/zig/render.zig
index b8481b1348d7942c658ef67cd7aec47cc6f0b4ce..56f3d24b8eacdd904592ed5183e4d117758fcaf4 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -254,7 +254,17 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 else => Space.Space,
             };
             try renderExpression(allocator, stream, tree, indent, infix_op_node.lhs, op_space);
-            try renderToken(tree, stream, infix_op_node.op_token, indent, op_space);
+
+            const after_op_space = blk: {
+                const loc = tree.tokenLocation(tree.tokens.at(infix_op_node.op_token).end,
+                    tree.nextToken(infix_op_node.op_token));
+                break :blk if (loc.line == 0) op_space else Space.Newline;
+            };
+
+            try renderToken(tree, stream, infix_op_node.op_token, indent, after_op_space);
+            if (after_op_space == Space.Newline) {
+                try stream.writeByteNTimes(' ', indent + indent_delta);
+            }
 
             switch (infix_op_node.op) {
                 ast.Node.InfixOp.Op.Catch => |maybe_payload| if (maybe_payload) |payload| {
-- 
2.54.0


From 77ec81b0353eac45a66b4ed79821c8c954032345 Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Mon, 28 May 2018 22:22:01 -0400
Subject: [PATCH 18/21] zig fmt: respect line breaks in if-else

---
 std/zig/parser_test.zig |  19 +++++++
 std/zig/render.zig      | 118 ++++++++++++++++++++++++++++++----------
 2 files changed, 108 insertions(+), 29 deletions(-)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index f722c7f08f1ed9479b71e372c4d0d73937305888..30e7eb3e7cdf80a9fba6c30eda21a34becdc57f6 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -1,3 +1,22 @@
+test "zig fmt: respect line breaks in if-else" {
+    try testCanonical(
+        \\comptime {
+        \\    return if (cond) a else b;
+        \\    return if (cond)
+        \\        a
+        \\    else
+        \\        b;
+        \\    return if (cond)
+        \\        a
+        \\    else if (cond)
+        \\        b
+        \\    else
+        \\        c;
+        \\}
+        \\
+    );
+}
+
 test "zig fmt: respect line breaks after infix operators" {
     try testCanonical(
         \\comptime {
diff --git a/std/zig/render.zig b/std/zig/render.zig
index 56f3d24b8eacdd904592ed5183e4d117758fcaf4..90bc74fd635880ce24e3b0fd8285bb1f60c4d98d 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -1315,49 +1315,109 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
         ast.Node.Id.If => {
             const if_node = @fieldParentPtr(ast.Node.If, "base", base);
 
-            try renderToken(tree, stream, if_node.if_token, indent, Space.Space);
-            try renderToken(tree, stream, tree.prevToken(if_node.condition.firstToken()), indent, Space.None);
+            const lparen = tree.prevToken(if_node.condition.firstToken());
+            const rparen = tree.nextToken(if_node.condition.lastToken());
 
-            try renderExpression(allocator, stream, tree, indent, if_node.condition, Space.None);
-            try renderToken(tree, stream, tree.nextToken(if_node.condition.lastToken()), indent, Space.Space);
+            try renderToken(tree, stream, if_node.if_token, indent, Space.Space); // if
+            try renderToken(tree, stream, lparen, indent, Space.None); // (
 
-            if (if_node.payload) |payload| {
-                try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
-            }
+            try renderExpression(allocator, stream, tree, indent, if_node.condition, Space.None); // condition
 
-            switch (if_node.body.id) {
+            const body_is_block = switch (if_node.body.id) {
                 ast.Node.Id.Block,
                 ast.Node.Id.If,
                 ast.Node.Id.For,
                 ast.Node.Id.While,
-                ast.Node.Id.Switch => {
-                    if (if_node.@"else") |@"else"| {
-                        if (if_node.body.id == ast.Node.Id.Block) {
-                            try renderExpression(allocator, stream, tree, indent, if_node.body, Space.Space);
-                        } else {
-                            try renderExpression(allocator, stream, tree, indent, if_node.body, Space.Newline);
-                            try stream.writeByteNTimes(' ', indent);
-                        }
-
-                        try renderExpression(allocator, stream, tree, indent, &@"else".base, space);
-                    } else {
-                        try renderExpression(allocator, stream, tree, indent, if_node.body, space);
-                    }
-                },
-                else => {
-                    if (if_node.@"else") |@"else"| {
-                        try renderExpression(allocator, stream, tree, indent, if_node.body, Space.Space);
-                        try renderToken(tree, stream, @"else".else_token, indent, Space.Space);
+                ast.Node.Id.Switch,
+                => true,
+                else => false,
+            };
+
+            if (body_is_block) {
+                try renderToken(tree, stream, rparen, indent, Space.Space); // )
+
+                if (if_node.payload) |payload| {
+                    try renderExpression(allocator, stream, tree, indent, payload, Space.Space); // |x|
+                }
+
+                if (if_node.@"else") |@"else"| {
+                    try renderExpression(allocator, stream, tree, indent, if_node.body, Space.Space);
+                    return renderExpression(allocator, stream, tree, indent, &@"else".base, space);
+                } else {
+                    return renderExpression(allocator, stream, tree, indent, if_node.body, space);
+                }
+            }
+
+            const src_has_newline = blk: {
+                const loc = tree.tokenLocation(tree.tokens.at(rparen).end, if_node.body.lastToken());
+                break :blk loc.line != 0;
+            };
+
+            if (src_has_newline) {
+                const after_rparen_space = if (if_node.payload == null) Space.Newline else Space.Space;
+                try renderToken(tree, stream, rparen, indent, after_rparen_space); // )
+
+                if (if_node.payload) |payload| {
+                    try renderExpression(allocator, stream, tree, indent, payload, Space.Newline);
+                }
+
+                const new_indent = indent + indent_delta;
+                try stream.writeByteNTimes(' ', new_indent);
+
+                if (if_node.@"else") |@"else"| {
+                    const else_is_block = switch (@"else".body.id) {
+                        ast.Node.Id.Block,
+                        ast.Node.Id.If,
+                        ast.Node.Id.For,
+                        ast.Node.Id.While,
+                        ast.Node.Id.Switch,
+                        => true,
+                        else => false,
+                    };
+                    try renderExpression(allocator, stream, tree, new_indent, if_node.body, Space.Newline);
+                    try stream.writeByteNTimes(' ', indent);
+
+                    if (else_is_block) {
+                        try renderToken(tree, stream, @"else".else_token, indent, Space.Space); // else
 
                         if (@"else".payload) |payload| {
                             try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
                         }
 
-                        try renderExpression(allocator, stream, tree, indent, @"else".body, space);
+                        return renderExpression(allocator, stream, tree, indent, @"else".body, space);
                     } else {
-                        try renderExpression(allocator, stream, tree, indent, if_node.body, space);
+                        const after_else_space = if (@"else".payload == null) Space.Newline else Space.Space;
+                        try renderToken(tree, stream, @"else".else_token, indent, after_else_space); // else
+
+                        if (@"else".payload) |payload| {
+                            try renderExpression(allocator, stream, tree, indent, payload, Space.Newline);
+                        }
+                        try stream.writeByteNTimes(' ', new_indent);
+
+                        return renderExpression(allocator, stream, tree, new_indent, @"else".body, space);
                     }
-                },
+                } else {
+                    return renderExpression(allocator, stream, tree, new_indent, if_node.body, space);
+                }
+            }
+
+            try renderToken(tree, stream, rparen, indent, Space.Space); // )
+
+            if (if_node.payload) |payload| {
+                try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
+            }
+
+            if (if_node.@"else") |@"else"| {
+                try renderExpression(allocator, stream, tree, indent, if_node.body, Space.Space);
+                try renderToken(tree, stream, @"else".else_token, indent, Space.Space);
+
+                if (@"else".payload) |payload| {
+                    try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
+                }
+
+                return renderExpression(allocator, stream, tree, indent, @"else".body, space);
+            } else {
+                return renderExpression(allocator, stream, tree, indent, if_node.body, space);
             }
         },
 
-- 
2.54.0


From 0d1b47362c7623ba923a6831dab0989133caf9ab Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Mon, 28 May 2018 22:41:05 -0400
Subject: [PATCH 19/21] zig fmt: if-else with comment before else

---
 std/zig/parser_test.zig | 18 ++++++++++++++++++
 std/zig/render.zig      | 20 ++++++++++++++------
 2 files changed, 32 insertions(+), 6 deletions(-)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index 30e7eb3e7cdf80a9fba6c30eda21a34becdc57f6..0f8b2d798affb08d6857d17c653f24e8316798d8 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -1,3 +1,21 @@
+test "zig fmt: if-else with comment before else" {
+    try testCanonical(
+        \\comptime {
+        \\    // cexp(finite|nan +- i inf|nan) = nan + i nan
+        \\    if ((hx & 0x7fffffff) != 0x7f800000) {
+        \\        return Complex(f32).new(y - y, y - y);
+        \\    } // cexp(-inf +- i inf|nan) = 0 + i0
+        \\    else if (hx & 0x80000000 != 0) {
+        \\        return Complex(f32).new(0, 0);
+        \\    } // cexp(+inf +- i inf|nan) = inf + i nan
+        \\    else {
+        \\        return Complex(f32).new(x, y - y);
+        \\    }
+        \\}
+        \\
+    );
+}
+
 test "zig fmt: respect line breaks in if-else" {
     try testCanonical(
         \\comptime {
diff --git a/std/zig/render.zig b/std/zig/render.zig
index 90bc74fd635880ce24e3b0fd8285bb1f60c4d98d..af8f3f385cda538192d5397c16f4673cb6f2328f 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -1341,7 +1341,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 }
 
                 if (if_node.@"else") |@"else"| {
-                    try renderExpression(allocator, stream, tree, indent, if_node.body, Space.Space);
+                    try renderExpression(allocator, stream, tree, indent, if_node.body, Space.SpaceOrOutdent);
                     return renderExpression(allocator, stream, tree, indent, &@"else".base, space);
                 } else {
                     return renderExpression(allocator, stream, tree, indent, if_node.body, space);
@@ -1685,8 +1685,8 @@ const Space = enum {
     Newline,
     Comma,
     Space,
+    SpaceOrOutdent,
     NoNewline,
-    NoIndent,
     NoComment,
 };
 
@@ -1717,7 +1717,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
 
     if (next_token.id != Token.Id.LineComment) {
         switch (space) {
-            Space.None, Space.NoNewline, Space.NoIndent => return,
+            Space.None, Space.NoNewline => return,
             Space.Newline => {
                 if (next_token.id == Token.Id.MultilineStringLiteralLine) {
                     return;
@@ -1725,7 +1725,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                     return stream.write("\n");
                 }
             },
-            Space.Space => return stream.writeByte(' '),
+            Space.Space, Space.SpaceOrOutdent => return stream.writeByte(' '),
             Space.NoComment, Space.Comma => unreachable,
         }
     }
@@ -1756,7 +1756,11 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                     };
                     try stream.writeByteNTimes(' ', next_line_indent);
                 },
-                Space.Newline, Space.NoIndent => {
+                Space.SpaceOrOutdent => {
+                    try stream.writeByte('\n');
+                    try stream.writeByteNTimes(' ', indent);
+                },
+                Space.Newline => {
                     if (next_token.id == Token.Id.MultilineStringLiteralLine) {
                         return;
                     } else {
@@ -1783,7 +1787,7 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
         next_token = tree.tokens.at(token_index + offset);
         if (next_token.id != Token.Id.LineComment) {
             switch (space) {
-                Space.Newline, Space.NoIndent => {
+                Space.Newline => {
                     if (next_token.id == Token.Id.MultilineStringLiteralLine) {
                         return;
                     } else {
@@ -1800,6 +1804,10 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                     };
                     try stream.writeByteNTimes(' ', next_line_indent);
                 },
+                Space.SpaceOrOutdent => {
+                    try stream.writeByte('\n');
+                    try stream.writeByteNTimes(' ', indent);
+                },
                 Space.NoNewline => {},
                 Space.NoComment, Space.Comma => unreachable,
             }
-- 
2.54.0


From 530d17542207151f768a14a0cc8311181599b9b9 Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Mon, 28 May 2018 23:41:09 -0400
Subject: [PATCH 20/21] zig fmt: fix spacing when moving doc comment on var
 decls

---
 std/zig/parser_test.zig | 39 +++++++++++++++++++++++++--------------
 std/zig/render.zig      | 33 +++++++++++++++++++++++++--------
 2 files changed, 50 insertions(+), 22 deletions(-)

diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index 0f8b2d798affb08d6857d17c653f24e8316798d8..0106b990bcb2df6480784e905c5cd1f40d2de6f0 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -1,3 +1,28 @@
+test "zig fmt: same-line doc comment on variable declaration" {
+    try testTransform(
+        \\pub const MAP_ANONYMOUS = 0x1000; /// allocated from memory, swap space
+        \\pub const MAP_FILE = 0x0000; /// map from file (default)
+        \\
+        \\pub const EMEDIUMTYPE = 124; /// Wrong medium type
+        \\
+        \\// nameserver query return codes
+        \\pub const ENSROK = 0; /// DNS server returned answer with no data
+    ,
+        \\/// allocated from memory, swap space
+        \\pub const MAP_ANONYMOUS = 0x1000;
+        \\/// map from file (default)
+        \\pub const MAP_FILE = 0x0000;
+        \\
+        \\/// Wrong medium type
+        \\pub const EMEDIUMTYPE = 124;
+        \\
+        \\// nameserver query return codes
+        \\/// DNS server returned answer with no data
+        \\pub const ENSROK = 0;
+        \\
+    );
+}
+
 test "zig fmt: if-else with comment before else" {
     try testCanonical(
         \\comptime {
@@ -557,20 +582,6 @@ test "zig fmt: add comma on last switch prong" {
     );
 }
 
-test "zig fmt: same-line doc comment on variable declaration" {
-    try testTransform(
-        \\pub const MAP_ANONYMOUS = 0x1000; /// allocated from memory, swap space
-        \\pub const MAP_FILE = 0x0000; /// map from file (default)
-        \\
-    ,
-        \\/// allocated from memory, swap space
-        \\pub const MAP_ANONYMOUS = 0x1000;
-        \\/// map from file (default)
-        \\pub const MAP_FILE = 0x0000;
-        \\
-    );
-}
-
 test "zig fmt: same-line comment after a statement" {
     try testCanonical(
         \\test "" {
diff --git a/std/zig/render.zig b/std/zig/render.zig
index af8f3f385cda538192d5397c16f4673cb6f2328f..3248b33aa7a128686b5698f137e8002d38605718 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -39,11 +39,12 @@ pub fn render(allocator: &mem.Allocator, stream: var, tree: &ast.Tree) (@typeOf(
 }
 
 fn renderExtraNewline(tree: &ast.Tree, stream: var, node: &ast.Node) !void {
-    var first_token = node.firstToken();
-    while (tree.tokens.at(first_token - 1).id == Token.Id.DocComment) {
-        first_token -= 1;
+    const first_token = node.firstToken();
+    var prev_token = first_token;
+    while (tree.tokens.at(prev_token - 1).id == Token.Id.DocComment) {
+        prev_token -= 1;
     }
-    const prev_token_end = tree.tokens.at(first_token - 1).end;
+    const prev_token_end = tree.tokens.at(prev_token - 1).end;
     const loc = tree.tokenLocation(prev_token_end, first_token);
     if (loc.line >= 2) {
         try stream.writeByte('\n');
@@ -1715,7 +1716,17 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
         else => {},
     }
 
-    if (next_token.id != Token.Id.LineComment) {
+    // Skip over same line doc comments
+    var offset: usize = 1;
+    if (next_token.id == Token.Id.DocComment) {
+        const loc = tree.tokenLocationPtr(token.end, next_token);
+        if (loc.line == 0) {
+            offset += 1;
+            next_token = tree.tokens.at(token_index + offset);
+        }
+    }
+
+    if (next_token.id != Token.Id.LineComment) blk: {
         switch (space) {
             Space.None, Space.NoNewline => return,
             Space.Newline => {
@@ -1739,7 +1750,6 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
     }
 
     var loc = tree.tokenLocationPtr(token.end, next_token);
-    var offset: usize = 1;
     if (loc.line == 0) {
         try stream.print(" {}", mem.trimRight(u8, tree.tokenSlicePtr(next_token), " "));
         offset = 2;
@@ -1820,8 +1830,15 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
 fn renderDocComments(tree: &ast.Tree, stream: var, node: var, indent: usize) (@typeOf(stream).Child.Error || Error)!void {
     const comment = node.doc_comments ?? return;
     var it = comment.lines.iterator(0);
+    const first_token = node.firstToken();
     while (it.next()) |line_token_index| {
-        try renderToken(tree, stream, line_token_index.*, indent, Space.Newline);
-        try stream.writeByteNTimes(' ', indent);
+        if (line_token_index.* < first_token) {
+            try renderToken(tree, stream, line_token_index.*, indent, Space.Newline);
+            try stream.writeByteNTimes(' ', indent);
+        } else {
+            try renderToken(tree, stream, line_token_index.*, indent, Space.NoComment);
+            try stream.write("\n");
+            try stream.writeByteNTimes(' ', indent);
+        }
     }
 }
-- 
2.54.0


From eda6898c5b253367174172db909ee23013f32733 Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Tue, 29 May 2018 03:15:12 -0400
Subject: [PATCH 21/21] zig fmt: handle if and while indentation better

---
 std/zig/ast.zig         |   24 +-
 std/zig/parser_test.zig |   92 ++++
 std/zig/render.zig      | 1077 ++++++++++++++++++++-------------------
 3 files changed, 658 insertions(+), 535 deletions(-)

diff --git a/std/zig/ast.zig b/std/zig/ast.zig
index addd3a37e845200b797800b68a79c75fb9f23841..3b705e2ee62afa7a54a5dfb6c510dd2fb5404741 100644
--- a/std/zig/ast.zig
+++ b/std/zig/ast.zig
@@ -68,6 +68,14 @@ pub const Tree = struct {
         return self.tokenLocationPtr(start_index, self.tokens.at(token_index));
     }
 
+    pub fn tokensOnSameLine(self: &Tree, token1_index: TokenIndex, token2_index: TokenIndex) bool {
+        return self.tokensOnSameLinePtr(self.tokens.at(token1_index), self.tokens.at(token2_index));
+    }
+
+    pub fn tokensOnSameLinePtr(self: &Tree, token1: &const Token, token2: &const Token) bool {
+        return mem.indexOfScalar(u8, self.source[token1.end..token2.start], '\n') == null;
+    }
+
     pub fn dump(self: &Tree) void {
         self.root_node.base.dump(0);
     }
@@ -1529,14 +1537,14 @@ pub const Node = struct {
 
             switch (self.op) {
                 Op.SliceType => |addr_of_info| {
-                    if (addr_of_info.align_expr) |align_expr| {
-                        if (i < 1) return align_expr;
+                    if (addr_of_info.align_info) |align_info| {
+                        if (i < 1) return align_info.node;
                         i -= 1;
                     }
                 },
                 Op.AddrOf => |addr_of_info| {
-                    if (addr_of_info.align_expr) |align_expr| {
-                        if (i < 1) return align_expr;
+                    if (addr_of_info.align_info) |align_info| {
+                        if (i < 1) return align_info.node;
                         i -= 1;
                     }
                 },
@@ -1553,7 +1561,9 @@ pub const Node = struct {
                 Op.NegationWrap,
                 Op.Try,
                 Op.Resume,
-                Op.UnwrapMaybe => {},
+                Op.UnwrapMaybe,
+                Op.PointerType,
+                => {},
             }
 
             if (i < 1) return self.rhs;
@@ -1656,6 +1666,7 @@ pub const Node = struct {
                     if (i < fields.len) return fields.at(i).*;
                     i -= fields.len;
                 },
+                Op.Deref => {},
             }
 
             return null;
@@ -2082,9 +2093,6 @@ pub const Node = struct {
             if (i < self.inputs.len) return &(self.inputs.at(index).*).base;
             i -= self.inputs.len;
 
-            if (i < self.clobbers.len) return self.clobbers.at(index).*;
-            i -= self.clobbers.len;
-
             return null;
         }
 
diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index 0106b990bcb2df6480784e905c5cd1f40d2de6f0..8ed748ed30c6f4dd626431445a266bae9b898269 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -1,3 +1,95 @@
+test "zig fmt: if condition wraps" {
+    try testTransform(
+        \\comptime {
+        \\    if (cond and
+        \\        cond) {
+        \\        return x;
+        \\    }
+        \\    while (cond and
+        \\        cond) {
+        \\        return x;
+        \\    }
+        \\    if (a == b and
+        \\        c) {
+        \\        a = b;
+        \\    }
+        \\    while (a == b and
+        \\        c) {
+        \\        a = b;
+        \\    }
+        \\    if ((cond and
+        \\        cond)) {
+        \\        return x;
+        \\    }
+        \\    while ((cond and
+        \\        cond)) {
+        \\        return x;
+        \\    }
+        \\    var a = if (a) |*f| x: {
+        \\        break :x &a.b;
+        \\    } else |err| err;
+        \\}
+    ,
+        \\comptime {
+        \\    if (cond and
+        \\        cond)
+        \\    {
+        \\        return x;
+        \\    }
+        \\    while (cond and
+        \\        cond)
+        \\    {
+        \\        return x;
+        \\    }
+        \\    if (a == b and
+        \\        c)
+        \\    {
+        \\        a = b;
+        \\    }
+        \\    while (a == b and
+        \\        c)
+        \\    {
+        \\        a = b;
+        \\    }
+        \\    if ((cond and
+        \\        cond))
+        \\    {
+        \\        return x;
+        \\    }
+        \\    while ((cond and
+        \\        cond))
+        \\    {
+        \\        return x;
+        \\    }
+        \\    var a = if (a) |*f| x: {
+        \\        break :x &a.b;
+        \\    } else |err| err;
+        \\}
+        \\
+    );
+}
+
+test "zig fmt: if condition has line break but must not wrap" {
+    try testCanonical(
+        \\comptime {
+        \\    if (self.user_input_options.put(name, UserInputOption{
+        \\        .name = name,
+        \\        .used = false,
+        \\    }) catch unreachable) |*prev_value| {
+        \\        foo();
+        \\        bar();
+        \\    }
+        \\    if (put(
+        \\        a,
+        \\        b,
+        \\    )) {
+        \\        foo();
+        \\    }
+        \\}
+        \\
+    );
+}
+
 test "zig fmt: same-line doc comment on variable declaration" {
     try testTransform(
         \\pub const MAP_ANONYMOUS = 0x1000; /// allocated from memory, swap space
diff --git a/std/zig/render.zig b/std/zig/render.zig
index 3248b33aa7a128686b5698f137e8002d38605718..16aed808fc6ee08bcfcaa42b6b97efff1533ce96 100644
--- a/std/zig/render.zig
+++ b/std/zig/render.zig
@@ -28,17 +28,17 @@ pub fn render(allocator: &mem.Allocator, stream: var, tree: &ast.Tree) (@typeOf(
         }
     }
 
-
+    var start_col: usize = 0;
     var it = tree.root_node.decls.iterator(0);
     while (it.next()) |decl| {
-        try renderTopLevelDecl(allocator, stream, tree, 0, decl.*);
+        try renderTopLevelDecl(allocator, stream, tree, 0, &start_col, decl.*);
         if (it.peek()) |next_decl| {
-            try renderExtraNewline(tree, stream, next_decl.*);
+            try renderExtraNewline(tree, stream, &start_col, next_decl.*);
         }
     }
 }
 
-fn renderExtraNewline(tree: &ast.Tree, stream: var, node: &ast.Node) !void {
+fn renderExtraNewline(tree: &ast.Tree, stream: var, start_col: &usize, node: &ast.Node) !void {
     const first_token = node.firstToken();
     var prev_token = first_token;
     while (tree.tokens.at(prev_token - 1).id == Token.Id.DocComment) {
@@ -48,22 +48,23 @@ fn renderExtraNewline(tree: &ast.Tree, stream: var, node: &ast.Node) !void {
     const loc = tree.tokenLocation(prev_token_end, first_token);
     if (loc.line >= 2) {
         try stream.writeByte('\n');
+        start_col.* = 0;
     }
 }
 
-fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, decl: &ast.Node) (@typeOf(stream).Child.Error || Error)!void {
+fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, start_col: &usize, decl: &ast.Node) (@typeOf(stream).Child.Error || Error)!void {
     switch (decl.id) {
         ast.Node.Id.FnProto => {
             const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
 
-            try renderDocComments(tree, stream, fn_proto, indent);
+            try renderDocComments(tree, stream, fn_proto, indent, start_col);
 
             if (fn_proto.body_node) |body_node| {
-                try renderExpression(allocator, stream, tree, indent, decl, Space.Space);
-                try renderExpression(allocator, stream, tree, indent, body_node, Space.Newline);
+                try renderExpression(allocator, stream, tree, indent, start_col, decl, Space.Space);
+                try renderExpression(allocator, stream, tree, indent, start_col, body_node, Space.Newline);
             } else {
-                try renderExpression(allocator, stream, tree, indent, decl, Space.None);
-                try renderToken(tree, stream, tree.nextToken(decl.lastToken()), indent, Space.Newline);
+                try renderExpression(allocator, stream, tree, indent, start_col, decl, Space.None);
+                try renderToken(tree, stream, tree.nextToken(decl.lastToken()), indent, start_col, Space.Newline);
             }
         },
 
@@ -71,153 +72,154 @@ fn renderTopLevelDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, i
             const use_decl = @fieldParentPtr(ast.Node.Use, "base", decl);
 
             if (use_decl.visib_token) |visib_token| {
-                try renderToken(tree, stream, visib_token, indent, Space.Space); // pub
+                try renderToken(tree, stream, visib_token, indent, start_col, Space.Space); // pub
             }
-            try renderToken(tree, stream, use_decl.use_token, indent, Space.Space); // use
-            try renderExpression(allocator, stream, tree, indent, use_decl.expr, Space.None);
-            try renderToken(tree, stream, use_decl.semicolon_token, indent, Space.Newline); // ;
+            try renderToken(tree, stream, use_decl.use_token, indent, start_col, Space.Space); // use
+            try renderExpression(allocator, stream, tree, indent, start_col, use_decl.expr, Space.None);
+            try renderToken(tree, stream, use_decl.semicolon_token, indent, start_col, Space.Newline); // ;
         },
 
         ast.Node.Id.VarDecl => {
             const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", decl);
 
-            try renderDocComments(tree, stream, var_decl, indent);
-            try renderVarDecl(allocator, stream, tree, indent, var_decl);
+            try renderDocComments(tree, stream, var_decl, indent, start_col);
+            try renderVarDecl(allocator, stream, tree, indent, start_col, var_decl);
         },
 
         ast.Node.Id.TestDecl => {
             const test_decl = @fieldParentPtr(ast.Node.TestDecl, "base", decl);
 
-            try renderDocComments(tree, stream, test_decl, indent);
-            try renderToken(tree, stream, test_decl.test_token, indent, Space.Space);
-            try renderExpression(allocator, stream, tree, indent, test_decl.name, Space.Space);
-            try renderExpression(allocator, stream, tree, indent, test_decl.body_node, Space.Newline);
+            try renderDocComments(tree, stream, test_decl, indent, start_col);
+            try renderToken(tree, stream, test_decl.test_token, indent, start_col, Space.Space);
+            try renderExpression(allocator, stream, tree, indent, start_col, test_decl.name, Space.Space);
+            try renderExpression(allocator, stream, tree, indent, start_col, test_decl.body_node, Space.Newline);
         },
 
         ast.Node.Id.StructField => {
             const field = @fieldParentPtr(ast.Node.StructField, "base", decl);
 
-            try renderDocComments(tree, stream, field, indent);
+            try renderDocComments(tree, stream, field, indent, start_col);
             if (field.visib_token) |visib_token| {
-                try renderToken(tree, stream, visib_token, indent, Space.Space); // pub
+                try renderToken(tree, stream, visib_token, indent, start_col, Space.Space); // pub
             }
-            try renderToken(tree, stream, field.name_token, indent, Space.None); // name
-            try renderToken(tree, stream, tree.nextToken(field.name_token), indent, Space.Space); // :
-            try renderExpression(allocator, stream, tree, indent, field.type_expr, Space.Comma); // type,
+            try renderToken(tree, stream, field.name_token, indent, start_col, Space.None); // name
+            try renderToken(tree, stream, tree.nextToken(field.name_token), indent, start_col, Space.Space); // :
+            try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr, Space.Comma); // type,
         },
 
         ast.Node.Id.UnionTag => {
             const tag = @fieldParentPtr(ast.Node.UnionTag, "base", decl);
 
-            try renderDocComments(tree, stream, tag, indent);
+            try renderDocComments(tree, stream, tag, indent, start_col);
 
             if (tag.type_expr == null and tag.value_expr == null) {
-                return renderToken(tree, stream, tag.name_token, indent, Space.Comma); // name,
+                return renderToken(tree, stream, tag.name_token, indent, start_col, Space.Comma); // name,
             }
 
             if (tag.type_expr == null) {
-                try renderToken(tree, stream, tag.name_token, indent, Space.Space); // name
+                try renderToken(tree, stream, tag.name_token, indent, start_col, Space.Space); // name
             } else {
-                try renderToken(tree, stream, tag.name_token, indent, Space.None); // name
+                try renderToken(tree, stream, tag.name_token, indent, start_col, Space.None); // name
             }
 
             if (tag.type_expr) |type_expr| {
-                try renderToken(tree, stream, tree.nextToken(tag.name_token), indent, Space.Space); // :
+                try renderToken(tree, stream, tree.nextToken(tag.name_token), indent, start_col, Space.Space); // :
 
                 if (tag.value_expr == null) {
-                    return renderExpression(allocator, stream, tree, indent, type_expr, Space.Comma); // type,
+                    try renderExpression(allocator, stream, tree, indent, start_col, type_expr, Space.Comma); // type,
+                    return;
                 } else {
-                    try renderExpression(allocator, stream, tree, indent, type_expr, Space.Space); // type
+                    try renderExpression(allocator, stream, tree, indent, start_col, type_expr, Space.Space); // type
                 }
             }
 
             const value_expr = ??tag.value_expr;
-            try renderToken(tree, stream, tree.prevToken(value_expr.firstToken()), indent, Space.Space); // =
-            try renderExpression(allocator, stream, tree, indent, value_expr, Space.Comma); // value,
+            try renderToken(tree, stream, tree.prevToken(value_expr.firstToken()), indent, start_col, Space.Space); // =
+            try renderExpression(allocator, stream, tree, indent, start_col, value_expr, Space.Comma); // value,
         },
 
         ast.Node.Id.EnumTag => {
             const tag = @fieldParentPtr(ast.Node.EnumTag, "base", decl);
 
-            try renderDocComments(tree, stream, tag, indent);
+            try renderDocComments(tree, stream, tag, indent, start_col);
 
             if (tag.value) |value| {
-                try renderToken(tree, stream, tag.name_token, indent, Space.Space); // name
+                try renderToken(tree, stream, tag.name_token, indent, start_col, Space.Space); // name
 
-                try renderToken(tree, stream, tree.nextToken(tag.name_token), indent, Space.Space); // =
-                try renderExpression(allocator, stream, tree, indent, value, Space.Comma);
+                try renderToken(tree, stream, tree.nextToken(tag.name_token), indent, start_col, Space.Space); // =
+                try renderExpression(allocator, stream, tree, indent, start_col, value, Space.Comma);
             } else {
-                try renderToken(tree, stream, tag.name_token, indent, Space.Comma); // name
+                try renderToken(tree, stream, tag.name_token, indent, start_col, Space.Comma); // name
             }
         },
 
         ast.Node.Id.Comptime => {
             assert(!decl.requireSemiColon());
-            try renderExpression(allocator, stream, tree, indent, decl, Space.Newline);
+            try renderExpression(allocator, stream, tree, indent, start_col, decl, Space.Newline);
         },
         else => unreachable,
     }
 }
 
-fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, base: &ast.Node, space: Space) (@typeOf(stream).Child.Error || Error)!void {
+fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, start_col: &usize, base: &ast.Node, space: Space,) (@typeOf(stream).Child.Error || Error)!void {
     switch (base.id) {
         ast.Node.Id.Identifier => {
             const identifier = @fieldParentPtr(ast.Node.Identifier, "base", base);
-            try renderToken(tree, stream, identifier.token, indent, space);
+            return renderToken(tree, stream, identifier.token, indent, start_col, space);
         },
         ast.Node.Id.Block => {
             const block = @fieldParentPtr(ast.Node.Block, "base", base);
 
             if (block.label) |label| {
-                try renderToken(tree, stream, label, indent, Space.None);
-                try renderToken(tree, stream, tree.nextToken(label), indent, Space.Space);
+                try renderToken(tree, stream, label, indent, start_col, Space.None);
+                try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space);
             }
 
             if (block.statements.len == 0) {
-                try renderToken(tree, stream, block.lbrace, indent + indent_delta, Space.None);
-                try renderToken(tree, stream, block.rbrace, indent, space);
+                try renderToken(tree, stream, block.lbrace, indent + indent_delta, start_col, Space.None);
+                return renderToken(tree, stream, block.rbrace, indent, start_col, space);
             } else {
                 const block_indent = indent + indent_delta;
-                try renderToken(tree, stream, block.lbrace, block_indent, Space.Newline);
+                try renderToken(tree, stream, block.lbrace, block_indent, start_col, Space.Newline);
 
                 var it = block.statements.iterator(0);
                 while (it.next()) |statement| {
                     try stream.writeByteNTimes(' ', block_indent);
-                    try renderStatement(allocator, stream, tree, block_indent, statement.*);
+                    try renderStatement(allocator, stream, tree, block_indent, start_col, statement.*);
 
                     if (it.peek()) |next_statement| {
-                        try renderExtraNewline(tree, stream, next_statement.*);
+                        try renderExtraNewline(tree, stream, start_col, next_statement.*);
                     }
                 }
 
                 try stream.writeByteNTimes(' ', indent);
-                try renderToken(tree, stream, block.rbrace, indent, space);
+                return renderToken(tree, stream, block.rbrace, indent, start_col, space);
             }
         },
         ast.Node.Id.Defer => {
             const defer_node = @fieldParentPtr(ast.Node.Defer, "base", base);
 
-            try renderToken(tree, stream, defer_node.defer_token, indent, Space.Space);
-            try renderExpression(allocator, stream, tree, indent, defer_node.expr, space);
+            try renderToken(tree, stream, defer_node.defer_token, indent, start_col, Space.Space);
+            return renderExpression(allocator, stream, tree, indent, start_col, defer_node.expr, space);
         },
         ast.Node.Id.Comptime => {
             const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", base);
 
-            try renderToken(tree, stream, comptime_node.comptime_token, indent, Space.Space);
-            try renderExpression(allocator, stream, tree, indent, comptime_node.expr, space);
+            try renderToken(tree, stream, comptime_node.comptime_token, indent, start_col, Space.Space);
+            return renderExpression(allocator, stream, tree, indent, start_col, comptime_node.expr, space);
         },
 
         ast.Node.Id.AsyncAttribute => {
             const async_attr = @fieldParentPtr(ast.Node.AsyncAttribute, "base", base);
 
             if (async_attr.allocator_type) |allocator_type| {
-                try renderToken(tree, stream, async_attr.async_token, indent, Space.None);
+                try renderToken(tree, stream, async_attr.async_token, indent, start_col, Space.None);
 
-                try renderToken(tree, stream, tree.nextToken(async_attr.async_token), indent, Space.None);
-                try renderExpression(allocator, stream, tree, indent, allocator_type, Space.None);
-                try renderToken(tree, stream, tree.nextToken(allocator_type.lastToken()), indent, space);
+                try renderToken(tree, stream, tree.nextToken(async_attr.async_token), indent, start_col, Space.None);
+                try renderExpression(allocator, stream, tree, indent, start_col, allocator_type, Space.None);
+                return renderToken(tree, stream, tree.nextToken(allocator_type.lastToken()), indent, start_col, space);
             } else {
-                try renderToken(tree, stream, async_attr.async_token, indent, space);
+                return renderToken(tree, stream, async_attr.async_token, indent, start_col, space);
             }
         },
 
@@ -225,24 +227,24 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", base);
 
             if (suspend_node.label) |label| {
-                try renderToken(tree, stream, label, indent, Space.None);
-                try renderToken(tree, stream, tree.nextToken(label), indent, Space.Space);
+                try renderToken(tree, stream, label, indent, start_col, Space.None);
+                try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space);
             }
 
             if (suspend_node.payload) |payload| {
                 if (suspend_node.body) |body| {
-                    try renderToken(tree, stream, suspend_node.suspend_token, indent, Space.Space);
-                    try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
-                    try renderExpression(allocator, stream, tree, indent, body, space);
+                    try renderToken(tree, stream, suspend_node.suspend_token, indent, start_col, Space.Space);
+                    try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
+                    return renderExpression(allocator, stream, tree, indent, start_col, body, space);
                 } else {
-                    try renderToken(tree, stream, suspend_node.suspend_token, indent, Space.Space);
-                    try renderExpression(allocator, stream, tree, indent, payload, space);
+                    try renderToken(tree, stream, suspend_node.suspend_token, indent, start_col, Space.Space);
+                    return renderExpression(allocator, stream, tree, indent, start_col, payload, space);
                 }
             } else if (suspend_node.body) |body| {
-                try renderToken(tree, stream, suspend_node.suspend_token, indent, Space.Space);
-                try renderExpression(allocator, stream, tree, indent, body, space);
+                try renderToken(tree, stream, suspend_node.suspend_token, indent, start_col, Space.Space);
+                return renderExpression(allocator, stream, tree, indent, start_col, body, space);
             } else {
-                try renderToken(tree, stream, suspend_node.suspend_token, indent, space);
+                return renderToken(tree, stream, suspend_node.suspend_token, indent, start_col, space);
             }
         },
 
@@ -254,7 +256,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 ast.Node.InfixOp.Op.Period, ast.Node.InfixOp.Op.ErrorUnion, ast.Node.InfixOp.Op.Range => Space.None,
                 else => Space.Space,
             };
-            try renderExpression(allocator, stream, tree, indent, infix_op_node.lhs, op_space);
+            try renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.lhs, op_space);
 
             const after_op_space = blk: {
                 const loc = tree.tokenLocation(tree.tokens.at(infix_op_node.op_token).end,
@@ -262,19 +264,20 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 break :blk if (loc.line == 0) op_space else Space.Newline;
             };
 
-            try renderToken(tree, stream, infix_op_node.op_token, indent, after_op_space);
+            try renderToken(tree, stream, infix_op_node.op_token, indent, start_col, after_op_space);
             if (after_op_space == Space.Newline) {
                 try stream.writeByteNTimes(' ', indent + indent_delta);
+                start_col.* = indent + indent_delta;
             }
 
             switch (infix_op_node.op) {
                 ast.Node.InfixOp.Op.Catch => |maybe_payload| if (maybe_payload) |payload| {
-                    try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
+                    try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
                 },
                 else => {},
             }
 
-            try renderExpression(allocator, stream, tree, indent, infix_op_node.rhs, space);
+            return renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.rhs, space);
         },
 
         ast.Node.Id.PrefixOp => {
@@ -282,81 +285,81 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
 
             switch (prefix_op_node.op) {
                 ast.Node.PrefixOp.Op.AddrOf => |addr_of_info| {
-                    try renderToken(tree, stream, prefix_op_node.op_token, indent, Space.None); // &
+                    try renderToken(tree, stream, prefix_op_node.op_token, indent, start_col, Space.None); // &
                     if (addr_of_info.align_info) |align_info| {
                         const lparen_token = tree.prevToken(align_info.node.firstToken());
                         const align_token = tree.prevToken(lparen_token);
 
-                        try renderToken(tree, stream, align_token, indent, Space.None); // align
-                        try renderToken(tree, stream, lparen_token, indent, Space.None); // (
+                        try renderToken(tree, stream, align_token, indent, start_col, Space.None); // align
+                        try renderToken(tree, stream, lparen_token, indent, start_col, Space.None); // (
 
-                        try renderExpression(allocator, stream, tree, indent, align_info.node, Space.None);
+                        try renderExpression(allocator, stream, tree, indent, start_col, align_info.node, Space.None);
 
                         if (align_info.bit_range) |bit_range| {
                             const colon1 = tree.prevToken(bit_range.start.firstToken());
                             const colon2 = tree.prevToken(bit_range.end.firstToken());
 
-                            try renderToken(tree, stream, colon1, indent, Space.None); // :
-                            try renderExpression(allocator, stream, tree, indent, bit_range.start, Space.None);
-                            try renderToken(tree, stream, colon2, indent, Space.None); // :
-                            try renderExpression(allocator, stream, tree, indent, bit_range.end, Space.None);
+                            try renderToken(tree, stream, colon1, indent, start_col, Space.None); // :
+                            try renderExpression(allocator, stream, tree, indent, start_col, bit_range.start, Space.None);
+                            try renderToken(tree, stream, colon2, indent, start_col, Space.None); // :
+                            try renderExpression(allocator, stream, tree, indent, start_col, bit_range.end, Space.None);
 
                             const rparen_token = tree.nextToken(bit_range.end.lastToken());
-                            try renderToken(tree, stream, rparen_token, indent, Space.Space); // )
+                            try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
                         } else {
                             const rparen_token = tree.nextToken(align_info.node.lastToken());
-                            try renderToken(tree, stream, rparen_token, indent, Space.Space); // )
+                            try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
                         }
                     }
                     if (addr_of_info.const_token) |const_token| {
-                        try renderToken(tree, stream, const_token, indent, Space.Space); // const
+                        try renderToken(tree, stream, const_token, indent, start_col, Space.Space); // const
                     }
                     if (addr_of_info.volatile_token) |volatile_token| {
-                        try renderToken(tree, stream, volatile_token, indent, Space.Space); // volatile
+                        try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space); // volatile
                     }
                 },
 
                 ast.Node.PrefixOp.Op.SliceType => |addr_of_info| {
-                    try renderToken(tree, stream, prefix_op_node.op_token, indent, Space.None); // [
-                    try renderToken(tree, stream, tree.nextToken(prefix_op_node.op_token), indent, Space.None); // ]
+                    try renderToken(tree, stream, prefix_op_node.op_token, indent, start_col, Space.None); // [
+                    try renderToken(tree, stream, tree.nextToken(prefix_op_node.op_token), indent, start_col, Space.None); // ]
 
                     if (addr_of_info.align_info) |align_info| {
                         const lparen_token = tree.prevToken(align_info.node.firstToken());
                         const align_token = tree.prevToken(lparen_token);
 
-                        try renderToken(tree, stream, align_token, indent, Space.None); // align
-                        try renderToken(tree, stream, lparen_token, indent, Space.None); // (
+                        try renderToken(tree, stream, align_token, indent, start_col, Space.None); // align
+                        try renderToken(tree, stream, lparen_token, indent, start_col, Space.None); // (
 
-                        try renderExpression(allocator, stream, tree, indent, align_info.node, Space.None);
+                        try renderExpression(allocator, stream, tree, indent, start_col, align_info.node, Space.None);
 
                         if (align_info.bit_range) |bit_range| {
                             const colon1 = tree.prevToken(bit_range.start.firstToken());
                             const colon2 = tree.prevToken(bit_range.end.firstToken());
 
-                            try renderToken(tree, stream, colon1, indent, Space.None); // :
-                            try renderExpression(allocator, stream, tree, indent, bit_range.start, Space.None);
-                            try renderToken(tree, stream, colon2, indent, Space.None); // :
-                            try renderExpression(allocator, stream, tree, indent, bit_range.end, Space.None);
+                            try renderToken(tree, stream, colon1, indent, start_col, Space.None); // :
+                            try renderExpression(allocator, stream, tree, indent, start_col, bit_range.start, Space.None);
+                            try renderToken(tree, stream, colon2, indent, start_col, Space.None); // :
+                            try renderExpression(allocator, stream, tree, indent, start_col, bit_range.end, Space.None);
 
                             const rparen_token = tree.nextToken(bit_range.end.lastToken());
-                            try renderToken(tree, stream, rparen_token, indent, Space.Space); // )
+                            try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
                         } else {
                             const rparen_token = tree.nextToken(align_info.node.lastToken());
-                            try renderToken(tree, stream, rparen_token, indent, Space.Space); // )
+                            try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
                         }
                     }
                     if (addr_of_info.const_token) |const_token| {
-                        try renderToken(tree, stream, const_token, indent, Space.Space);
+                        try renderToken(tree, stream, const_token, indent, start_col, Space.Space);
                     }
                     if (addr_of_info.volatile_token) |volatile_token| {
-                        try renderToken(tree, stream, volatile_token, indent, Space.Space);
+                        try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space);
                     }
                 },
 
                 ast.Node.PrefixOp.Op.ArrayType => |array_index| {
-                    try renderToken(tree, stream, prefix_op_node.op_token, indent, Space.None); // [
-                    try renderExpression(allocator, stream, tree, indent, array_index, Space.None);
-                    try renderToken(tree, stream, tree.nextToken(array_index.lastToken()), indent, Space.None); // ]
+                    try renderToken(tree, stream, prefix_op_node.op_token, indent, start_col, Space.None); // [
+                    try renderExpression(allocator, stream, tree, indent, start_col, array_index, Space.None);
+                    try renderToken(tree, stream, tree.nextToken(array_index.lastToken()), indent, start_col, Space.None); // ]
                 },
                 ast.Node.PrefixOp.Op.BitNot,
                 ast.Node.PrefixOp.Op.BoolNot,
@@ -365,18 +368,18 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 ast.Node.PrefixOp.Op.UnwrapMaybe,
                 ast.Node.PrefixOp.Op.MaybeType,
                 ast.Node.PrefixOp.Op.PointerType => {
-                    try renderToken(tree, stream, prefix_op_node.op_token, indent, Space.None);
+                    try renderToken(tree, stream, prefix_op_node.op_token, indent, start_col, Space.None);
                 },
 
                 ast.Node.PrefixOp.Op.Try,
                 ast.Node.PrefixOp.Op.Await,
                 ast.Node.PrefixOp.Op.Cancel,
                 ast.Node.PrefixOp.Op.Resume => {
-                    try renderToken(tree, stream, prefix_op_node.op_token, indent, Space.Space);
+                    try renderToken(tree, stream, prefix_op_node.op_token, indent, start_col, Space.Space);
                 },
             }
 
-            try renderExpression(allocator, stream, tree, indent, prefix_op_node.rhs, space);
+            return renderExpression(allocator, stream, tree, indent, start_col, prefix_op_node.rhs, space);
         },
 
         ast.Node.Id.SuffixOp => {
@@ -385,17 +388,16 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             switch (suffix_op.op) {
                 @TagType(ast.Node.SuffixOp.Op).Call => |*call_info| {
                     if (call_info.async_attr) |async_attr| {
-                        try renderExpression(allocator, stream, tree, indent, &async_attr.base, Space.Space);
+                        try renderExpression(allocator, stream, tree, indent, start_col, &async_attr.base, Space.Space);
                     }
 
-                    try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
+                    try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
 
                     const lparen = tree.nextToken(suffix_op.lhs.lastToken());
 
                     if (call_info.params.len == 0) {
-                        try renderToken(tree, stream, lparen, indent, Space.None);
-                        try renderToken(tree, stream, suffix_op.rtoken, indent, space);
-                        return;
+                        try renderToken(tree, stream, lparen, indent, start_col, Space.None);
+                        return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                     }
 
                     const src_has_trailing_comma = blk: {
@@ -405,7 +407,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
 
                     if (src_has_trailing_comma) {
                         const new_indent = indent + indent_delta;
-                        try renderToken(tree, stream, lparen, new_indent, Space.Newline);
+                        try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline);
 
                         var it = call_info.params.iterator(0);
                         while (true) {
@@ -419,72 +421,70 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                             };
 
                             if (it.peek()) |next_node| {
-                                try renderExpression(allocator, stream, tree, param_node_new_indent, param_node.*, Space.None);
+                                try renderExpression(allocator, stream, tree, param_node_new_indent, start_col, param_node.*, Space.None);
                                 const comma = tree.nextToken(param_node.*.lastToken());
-                                try renderToken(tree, stream, comma, new_indent, Space.Newline); // ,
-                                try renderExtraNewline(tree, stream, next_node.*);
+                                try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline); // ,
+                                try renderExtraNewline(tree, stream, start_col, next_node.*);
                             } else {
-                                try renderExpression(allocator, stream, tree, param_node_new_indent, param_node.*, Space.Comma);
+                                try renderExpression(allocator, stream, tree, param_node_new_indent, start_col, param_node.*, Space.Comma);
                                 try stream.writeByteNTimes(' ', indent);
-                                try renderToken(tree, stream, suffix_op.rtoken, indent, space);
-                                return;
+                                return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                             }
                         }
                     }
 
-                    try renderToken(tree, stream, lparen, indent, Space.None); // (
+                    try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
 
                     var it = call_info.params.iterator(0);
                     while (it.next()) |param_node| {
-                        try renderExpression(allocator, stream, tree, indent, param_node.*, Space.None);
+                        try renderExpression(allocator, stream, tree, indent, start_col, param_node.*, Space.None);
 
                         if (it.peek() != null) {
                             const comma = tree.nextToken(param_node.*.lastToken());
-                            try renderToken(tree, stream, comma, indent, Space.Space);
+                            try renderToken(tree, stream, comma, indent, start_col, Space.Space);
                         }
                     }
-                    try renderToken(tree, stream, suffix_op.rtoken, indent, space);
+                    return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                 },
 
                 ast.Node.SuffixOp.Op.ArrayAccess => |index_expr| {
                     const lbracket = tree.prevToken(index_expr.firstToken());
                     const rbracket = tree.nextToken(index_expr.lastToken());
 
-                    try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
-                    try renderToken(tree, stream, lbracket, indent, Space.None); // [
-                    try renderExpression(allocator, stream, tree, indent, index_expr, Space.None);
-                    try renderToken(tree, stream, rbracket, indent, space); // ]
+                    try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
+                    try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
+                    try renderExpression(allocator, stream, tree, indent, start_col, index_expr, Space.None);
+                    return renderToken(tree, stream, rbracket, indent, start_col, space); // ]
                 },
 
                 ast.Node.SuffixOp.Op.Deref => {
-                    try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
-                    try renderToken(tree, stream, tree.prevToken(suffix_op.rtoken), indent, Space.None); // .
-                    try renderToken(tree, stream, suffix_op.rtoken, indent, space); // *
+                    try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
+                    try renderToken(tree, stream, tree.prevToken(suffix_op.rtoken), indent, start_col, Space.None); // .
+                    return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // *
                 },
 
                 @TagType(ast.Node.SuffixOp.Op).Slice => |range| {
-                    try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
+                    try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
 
                     const lbracket = tree.prevToken(range.start.firstToken());
                     const dotdot = tree.nextToken(range.start.lastToken());
 
-                    try renderToken(tree, stream, lbracket, indent, Space.None); // [
-                    try renderExpression(allocator, stream, tree, indent, range.start, Space.None);
-                    try renderToken(tree, stream, dotdot, indent, Space.None); // ..
+                    try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
+                    try renderExpression(allocator, stream, tree, indent, start_col, range.start, Space.None);
+                    try renderToken(tree, stream, dotdot, indent, start_col, Space.None); // ..
                     if (range.end) |end| {
-                        try renderExpression(allocator, stream, tree, indent, end, Space.None);
+                        try renderExpression(allocator, stream, tree, indent, start_col, end, Space.None);
                     }
-                    try renderToken(tree, stream, suffix_op.rtoken, indent, space); // ]
+                    return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // ]
                 },
 
                 ast.Node.SuffixOp.Op.StructInitializer => |*field_inits| {
                     const lbrace = tree.nextToken(suffix_op.lhs.lastToken());
 
                     if (field_inits.len == 0) {
-                        try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
-                        try renderToken(tree, stream, lbrace, indent, Space.None);
-                        try renderToken(tree, stream, suffix_op.rtoken, indent, space);
-                        return;
+                        try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
+                        try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
+                        return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                     }
 
                     if (field_inits.len == 1) blk: {
@@ -496,11 +496,10 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                             }
                         }
 
-                        try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
-                        try renderToken(tree, stream, lbrace, indent, Space.Space);
-                        try renderExpression(allocator, stream, tree, indent, &field_init.base, Space.Space);
-                        try renderToken(tree, stream, suffix_op.rtoken, indent, space);
-                        return;
+                        try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
+                        try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
+                        try renderExpression(allocator, stream, tree, indent, start_col, &field_init.base, Space.Space);
+                        return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                     }
 
                     const src_has_trailing_comma = blk: {
@@ -515,27 +514,26 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
 
                     if (!src_has_trailing_comma and src_same_line) {
                         // render all on one line, no trailing comma
-                        try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
-                        try renderToken(tree, stream, lbrace, indent, Space.Space);
+                        try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
+                        try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
 
                         var it = field_inits.iterator(0);
                         while (it.next()) |field_init| {
                             if (it.peek() != null) {
-                                try renderExpression(allocator, stream, tree, indent, field_init.*, Space.None);
+                                try renderExpression(allocator, stream, tree, indent, start_col, field_init.*, Space.None);
 
                                 const comma = tree.nextToken(field_init.*.lastToken());
-                                try renderToken(tree, stream, comma, indent, Space.Space);
+                                try renderToken(tree, stream, comma, indent, start_col, Space.Space);
                             } else {
-                                try renderExpression(allocator, stream, tree, indent, field_init.*, Space.Space);
+                                try renderExpression(allocator, stream, tree, indent, start_col, field_init.*, Space.Space);
                             }
                         }
 
-                        try renderToken(tree, stream, suffix_op.rtoken, indent, space);
-                        return;
+                        return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                     }
 
-                    try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
-                    try renderToken(tree, stream, lbrace, indent, Space.Newline);
+                    try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
+                    try renderToken(tree, stream, lbrace, indent, start_col, Space.Newline);
 
                     const new_indent = indent + indent_delta;
 
@@ -544,41 +542,39 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                         try stream.writeByteNTimes(' ', new_indent);
 
                         if (it.peek()) |next_field_init| {
-                            try renderExpression(allocator, stream, tree, new_indent, field_init.*, Space.None);
+                            try renderExpression(allocator, stream, tree, new_indent, start_col, field_init.*, Space.None);
 
                             const comma = tree.nextToken(field_init.*.lastToken());
-                            try renderToken(tree, stream, comma, new_indent, Space.Newline);
+                            try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline);
 
-                            try renderExtraNewline(tree, stream, next_field_init.*);
+                            try renderExtraNewline(tree, stream, start_col, next_field_init.*);
                         } else {
-                            try renderExpression(allocator, stream, tree, new_indent, field_init.*, Space.Comma);
+                            try renderExpression(allocator, stream, tree, new_indent, start_col, field_init.*, Space.Comma);
                         }
                     }
 
                     try stream.writeByteNTimes(' ', indent);
-                    try renderToken(tree, stream, suffix_op.rtoken, indent, space);
+                    return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                 },
 
                 ast.Node.SuffixOp.Op.ArrayInitializer => |*exprs| {
                     const lbrace = tree.nextToken(suffix_op.lhs.lastToken());
 
                     if (exprs.len == 0) {
-                        try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
-                        try renderToken(tree, stream, lbrace, indent, Space.None);
-                        try renderToken(tree, stream, suffix_op.rtoken, indent, space);
-                        return;
+                        try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
+                        try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
+                        return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                     }
                     if (exprs.len == 1) {
                         const expr = exprs.at(0).*;
 
-                        try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
-                        try renderToken(tree, stream, lbrace, indent, Space.None);
-                        try renderExpression(allocator, stream, tree, indent, expr, Space.None);
-                        try renderToken(tree, stream, suffix_op.rtoken, indent, space);
-                        return;
+                        try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
+                        try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
+                        try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
+                        return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                     }
 
-                    try renderExpression(allocator, stream, tree, indent, suffix_op.lhs, Space.None);
+                    try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
 
                     // scan to find row size
                     const maybe_row_size: ?usize = blk: {
@@ -613,50 +609,48 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
 
                     if (maybe_row_size) |row_size| {
                         const new_indent = indent + indent_delta;
-                        try renderToken(tree, stream, lbrace, new_indent, Space.Newline);
+                        try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline);
                         try stream.writeByteNTimes(' ', new_indent);
 
                         var it = exprs.iterator(0);
                         var i: usize = 1;
                         while (it.next()) |expr| {
                             if (it.peek()) |next_expr| {
-                                try renderExpression(allocator, stream, tree, new_indent, expr.*, Space.None);
+                                try renderExpression(allocator, stream, tree, new_indent, start_col, expr.*, Space.None);
 
                                 const comma = tree.nextToken(expr.*.lastToken());
 
                                 if (i != row_size) {
-                                    try renderToken(tree, stream, comma, new_indent, Space.Space); // ,
+                                    try renderToken(tree, stream, comma, new_indent, start_col, Space.Space); // ,
                                     i += 1;
                                     continue;
                                 }
                                 i = 1;
 
-                                try renderToken(tree, stream, comma, new_indent, Space.Newline); // ,
+                                try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline); // ,
 
-                                try renderExtraNewline(tree, stream, next_expr.*);
+                                try renderExtraNewline(tree, stream, start_col, next_expr.*);
                                 try stream.writeByteNTimes(' ', new_indent);
                             } else {
-                                try renderExpression(allocator, stream, tree, new_indent, expr.*, Space.Comma); // ,
+                                try renderExpression(allocator, stream, tree, new_indent, start_col, expr.*, Space.Comma); // ,
                             }
                         }
                         try stream.writeByteNTimes(' ', indent);
-                        try renderToken(tree, stream, suffix_op.rtoken, indent, space);
-                        return;
+                        return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                     } else {
-                        try renderToken(tree, stream, lbrace, indent, Space.Space);
+                        try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
                         var it = exprs.iterator(0);
                         while (it.next()) |expr| {
                             if (it.peek()) |next_expr| {
-                                try renderExpression(allocator, stream, tree, indent, expr.*, Space.None);
+                                try renderExpression(allocator, stream, tree, indent, start_col, expr.*, Space.None);
                                 const comma = tree.nextToken(expr.*.lastToken());
-                                try renderToken(tree, stream, comma, indent, Space.Space); // ,
+                                try renderToken(tree, stream, comma, indent, start_col, Space.Space); // ,
                             } else {
-                                try renderExpression(allocator, stream, tree, indent, expr.*, Space.Space);
+                                try renderExpression(allocator, stream, tree, indent, start_col, expr.*, Space.Space);
                             }
                         }
 
-                        try renderToken(tree, stream, suffix_op.rtoken, indent, space);
-                        return;
+                        return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space);
                     }
                 },
             }
@@ -667,195 +661,204 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
 
             switch (flow_expr.kind) {
                 ast.Node.ControlFlowExpression.Kind.Break => |maybe_label| {
-                    const kw_space = if (maybe_label != null or flow_expr.rhs != null) Space.Space else space;
-                    try renderToken(tree, stream, flow_expr.ltoken, indent, kw_space);
+                    if (maybe_label == null and flow_expr.rhs == null) {
+                        return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space); // break
+                    }
+
+                    try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space); // break
                     if (maybe_label) |label| {
                         const colon = tree.nextToken(flow_expr.ltoken);
-                        try renderToken(tree, stream, colon, indent, Space.None);
+                        try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
 
-                        const expr_space = if (flow_expr.rhs != null) Space.Space else space;
-                        try renderExpression(allocator, stream, tree, indent, label, expr_space);
+                        if (flow_expr.rhs == null) {
+                            return renderExpression(allocator, stream, tree, indent, start_col, label, space); // label
+                        }
+                        try renderExpression(allocator, stream, tree, indent, start_col, label, Space.Space); // label
                     }
                 },
                 ast.Node.ControlFlowExpression.Kind.Continue => |maybe_label| {
-                    const kw_space = if (maybe_label != null or flow_expr.rhs != null) Space.Space else space;
-                    try renderToken(tree, stream, flow_expr.ltoken, indent, kw_space);
+                    assert(flow_expr.rhs == null);
+
+                    if (maybe_label == null and flow_expr.rhs == null) {
+                        return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space); // continue
+                    }
+
+                    try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space); // continue
                     if (maybe_label) |label| {
                         const colon = tree.nextToken(flow_expr.ltoken);
-                        try renderToken(tree, stream, colon, indent, Space.None);
+                        try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
 
-                        const expr_space = if (flow_expr.rhs != null) Space.Space else space;
-                        try renderExpression(allocator, stream, tree, indent, label, space);
+                        return renderExpression(allocator, stream, tree, indent, start_col, label, space);
                     }
                 },
                 ast.Node.ControlFlowExpression.Kind.Return => {
-                    const kw_space = if (flow_expr.rhs != null) Space.Space else space;
-                    try renderToken(tree, stream, flow_expr.ltoken, indent, kw_space);
+                    if (flow_expr.rhs == null) {
+                        return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space);
+                    }
+                    try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space);
                 },
             }
 
-            if (flow_expr.rhs) |rhs| {
-                try renderExpression(allocator, stream, tree, indent, rhs, space);
-            }
+            return renderExpression(allocator, stream, tree, indent, start_col, ??flow_expr.rhs, space);
         },
 
         ast.Node.Id.Payload => {
             const payload = @fieldParentPtr(ast.Node.Payload, "base", base);
 
-            try renderToken(tree, stream, payload.lpipe, indent, Space.None);
-            try renderExpression(allocator, stream, tree, indent, payload.error_symbol, Space.None);
-            try renderToken(tree, stream, payload.rpipe, indent, space);
+            try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
+            try renderExpression(allocator, stream, tree, indent, start_col, payload.error_symbol, Space.None);
+            return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
         },
 
         ast.Node.Id.PointerPayload => {
             const payload = @fieldParentPtr(ast.Node.PointerPayload, "base", base);
 
-            try renderToken(tree, stream, payload.lpipe, indent, Space.None);
+            try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
             if (payload.ptr_token) |ptr_token| {
-                try renderToken(tree, stream, ptr_token, indent, Space.None);
+                try renderToken(tree, stream, ptr_token, indent, start_col, Space.None);
             }
-            try renderExpression(allocator, stream, tree, indent, payload.value_symbol, Space.None);
-            try renderToken(tree, stream, payload.rpipe, indent, space);
+            try renderExpression(allocator, stream, tree, indent, start_col, payload.value_symbol, Space.None);
+            return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
         },
 
         ast.Node.Id.PointerIndexPayload => {
             const payload = @fieldParentPtr(ast.Node.PointerIndexPayload, "base", base);
 
-            try renderToken(tree, stream, payload.lpipe, indent, Space.None);
+            try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
             if (payload.ptr_token) |ptr_token| {
-                try renderToken(tree, stream, ptr_token, indent, Space.None);
+                try renderToken(tree, stream, ptr_token, indent, start_col, Space.None);
             }
-            try renderExpression(allocator, stream, tree, indent, payload.value_symbol, Space.None);
+            try renderExpression(allocator, stream, tree, indent, start_col, payload.value_symbol, Space.None);
 
             if (payload.index_symbol) |index_symbol| {
                 const comma = tree.nextToken(payload.value_symbol.lastToken());
 
-                try renderToken(tree, stream, comma, indent, Space.Space);
-                try renderExpression(allocator, stream, tree, indent, index_symbol, Space.None);
+                try renderToken(tree, stream, comma, indent, start_col, Space.Space);
+                try renderExpression(allocator, stream, tree, indent, start_col, index_symbol, Space.None);
             }
 
-            try renderToken(tree, stream, payload.rpipe, indent, space);
+            return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
         },
 
         ast.Node.Id.GroupedExpression => {
             const grouped_expr = @fieldParentPtr(ast.Node.GroupedExpression, "base", base);
 
-            try renderToken(tree, stream, grouped_expr.lparen, indent, Space.None);
-            try renderExpression(allocator, stream, tree, indent, grouped_expr.expr, Space.None);
-            try renderToken(tree, stream, grouped_expr.rparen, indent, space);
+            try renderToken(tree, stream, grouped_expr.lparen, indent, start_col, Space.None);
+            try renderExpression(allocator, stream, tree, indent, start_col, grouped_expr.expr, Space.None);
+            return renderToken(tree, stream, grouped_expr.rparen, indent, start_col, space);
         },
 
         ast.Node.Id.FieldInitializer => {
             const field_init = @fieldParentPtr(ast.Node.FieldInitializer, "base", base);
 
-            try renderToken(tree, stream, field_init.period_token, indent, Space.None); // .
-            try renderToken(tree, stream, field_init.name_token, indent, Space.Space); // name
-            try renderToken(tree, stream, tree.nextToken(field_init.name_token), indent, Space.Space); // =
-            try renderExpression(allocator, stream, tree, indent, field_init.expr, space);
+            try renderToken(tree, stream, field_init.period_token, indent, start_col, Space.None); // .
+            try renderToken(tree, stream, field_init.name_token, indent, start_col, Space.Space); // name
+            try renderToken(tree, stream, tree.nextToken(field_init.name_token), indent, start_col, Space.Space); // =
+            return renderExpression(allocator, stream, tree, indent, start_col, field_init.expr, space);
         },
 
         ast.Node.Id.IntegerLiteral => {
             const integer_literal = @fieldParentPtr(ast.Node.IntegerLiteral, "base", base);
-            try renderToken(tree, stream, integer_literal.token, indent, space);
+            return renderToken(tree, stream, integer_literal.token, indent, start_col, space);
         },
         ast.Node.Id.FloatLiteral => {
             const float_literal = @fieldParentPtr(ast.Node.FloatLiteral, "base", base);
-            try renderToken(tree, stream, float_literal.token, indent, space);
+            return renderToken(tree, stream, float_literal.token, indent, start_col, space);
         },
         ast.Node.Id.StringLiteral => {
             const string_literal = @fieldParentPtr(ast.Node.StringLiteral, "base", base);
-            try renderToken(tree, stream, string_literal.token, indent, space);
+            return renderToken(tree, stream, string_literal.token, indent, start_col, space);
         },
         ast.Node.Id.CharLiteral => {
             const char_literal = @fieldParentPtr(ast.Node.CharLiteral, "base", base);
-            try renderToken(tree, stream, char_literal.token, indent, space);
+            return renderToken(tree, stream, char_literal.token, indent, start_col, space);
         },
         ast.Node.Id.BoolLiteral => {
             const bool_literal = @fieldParentPtr(ast.Node.CharLiteral, "base", base);
-            try renderToken(tree, stream, bool_literal.token, indent, space);
+            return renderToken(tree, stream, bool_literal.token, indent, start_col, space);
         },
         ast.Node.Id.NullLiteral => {
             const null_literal = @fieldParentPtr(ast.Node.NullLiteral, "base", base);
-            try renderToken(tree, stream, null_literal.token, indent, space);
+            return renderToken(tree, stream, null_literal.token, indent, start_col, space);
         },
         ast.Node.Id.ThisLiteral => {
             const this_literal = @fieldParentPtr(ast.Node.ThisLiteral, "base", base);
-            try renderToken(tree, stream, this_literal.token, indent, space);
+            return renderToken(tree, stream, this_literal.token, indent, start_col, space);
         },
         ast.Node.Id.Unreachable => {
             const unreachable_node = @fieldParentPtr(ast.Node.Unreachable, "base", base);
-            try renderToken(tree, stream, unreachable_node.token, indent, space);
+            return renderToken(tree, stream, unreachable_node.token, indent, start_col, space);
         },
         ast.Node.Id.ErrorType => {
             const error_type = @fieldParentPtr(ast.Node.ErrorType, "base", base);
-            try renderToken(tree, stream, error_type.token, indent, space);
+            return renderToken(tree, stream, error_type.token, indent, start_col, space);
         },
         ast.Node.Id.VarType => {
             const var_type = @fieldParentPtr(ast.Node.VarType, "base", base);
-            try renderToken(tree, stream, var_type.token, indent, space);
+            return renderToken(tree, stream, var_type.token, indent, start_col, space);
         },
         ast.Node.Id.ContainerDecl => {
             const container_decl = @fieldParentPtr(ast.Node.ContainerDecl, "base", base);
 
             if (container_decl.layout_token) |layout_token| {
-                try renderToken(tree, stream, layout_token, indent, Space.Space);
+                try renderToken(tree, stream, layout_token, indent, start_col, Space.Space);
             }
 
             switch (container_decl.init_arg_expr) {
                 ast.Node.ContainerDecl.InitArg.None => {
-                    try renderToken(tree, stream, container_decl.kind_token, indent, Space.Space); // union
+                    try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.Space); // union
                 },
                 ast.Node.ContainerDecl.InitArg.Enum => |enum_tag_type| {
-                    try renderToken(tree, stream, container_decl.kind_token, indent, Space.None); // union
+                    try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.None); // union
 
                     const lparen = tree.nextToken(container_decl.kind_token);
                     const enum_token = tree.nextToken(lparen);
 
-                    try renderToken(tree, stream, lparen, indent, Space.None); // (
-                    try renderToken(tree, stream, enum_token, indent, Space.None); // enum
+                    try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
+                    try renderToken(tree, stream, enum_token, indent, start_col, Space.None); // enum
 
                     if (enum_tag_type) |expr| {
-                        try renderToken(tree, stream, tree.nextToken(enum_token), indent, Space.None); // (
-                        try renderExpression(allocator, stream, tree, indent, expr, Space.None);
+                        try renderToken(tree, stream, tree.nextToken(enum_token), indent, start_col, Space.None); // (
+                        try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
 
                         const rparen = tree.nextToken(expr.lastToken());
-                        try renderToken(tree, stream, rparen, indent, Space.None); // )
-                        try renderToken(tree, stream, tree.nextToken(rparen), indent, Space.Space); // )
+                        try renderToken(tree, stream, rparen, indent, start_col, Space.None); // )
+                        try renderToken(tree, stream, tree.nextToken(rparen), indent, start_col, Space.Space); // )
                     } else {
-                        try renderToken(tree, stream, tree.nextToken(enum_token), indent, Space.Space); // )
+                        try renderToken(tree, stream, tree.nextToken(enum_token), indent, start_col, Space.Space); // )
                     }
                 },
                 ast.Node.ContainerDecl.InitArg.Type => |type_expr| {
-                    try renderToken(tree, stream, container_decl.kind_token, indent, Space.None); // union
+                    try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.None); // union
 
                     const lparen = tree.nextToken(container_decl.kind_token);
                     const rparen = tree.nextToken(type_expr.lastToken());
 
-                    try renderToken(tree, stream, lparen, indent, Space.None); // (
-                    try renderExpression(allocator, stream, tree, indent, type_expr, Space.None);
-                    try renderToken(tree, stream, rparen, indent, Space.Space); // )
+                    try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
+                    try renderExpression(allocator, stream, tree, indent, start_col, type_expr, Space.None);
+                    try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
                 },
             }
 
             if (container_decl.fields_and_decls.len == 0) {
-                try renderToken(tree, stream, container_decl.lbrace_token, indent + indent_delta, Space.None); // {
-                try renderToken(tree, stream, container_decl.rbrace_token, indent, space); // }
+                try renderToken(tree, stream, container_decl.lbrace_token, indent + indent_delta, start_col, Space.None); // {
+                return renderToken(tree, stream, container_decl.rbrace_token, indent, start_col, space); // }
             } else {
                 const new_indent = indent + indent_delta;
-                try renderToken(tree, stream, container_decl.lbrace_token, new_indent, Space.Newline); // {
+                try renderToken(tree, stream, container_decl.lbrace_token, new_indent, start_col, Space.Newline); // {
 
                 var it = container_decl.fields_and_decls.iterator(0);
                 while (it.next()) |decl| {
                     try stream.writeByteNTimes(' ', new_indent);
-                    try renderTopLevelDecl(allocator, stream, tree, new_indent, decl.*);
+                    try renderTopLevelDecl(allocator, stream, tree, new_indent, start_col, decl.*);
 
                     if (it.peek()) |next_decl| {
-                        try renderExtraNewline(tree, stream, next_decl.*);
+                        try renderExtraNewline(tree, stream, start_col, next_decl.*);
                     }
                 }
 
                 try stream.writeByteNTimes(' ', indent);
-                try renderToken(tree, stream, container_decl.rbrace_token, indent, space); // }
+                return renderToken(tree, stream, container_decl.rbrace_token, indent, start_col, space); // }
             }
         },
 
@@ -865,10 +868,9 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             const lbrace = tree.nextToken(err_set_decl.error_token);
 
             if (err_set_decl.decls.len == 0) {
-                try renderToken(tree, stream, err_set_decl.error_token, indent, Space.None);
-                try renderToken(tree, stream, lbrace, indent, Space.None);
-                try renderToken(tree, stream, err_set_decl.rbrace_token, indent, space);
-                return;
+                try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None);
+                try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
+                return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space);
             }
 
             if (err_set_decl.decls.len == 1) blk: {
@@ -882,15 +884,14 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                     break :blk;
                 }
 
-                try renderToken(tree, stream, err_set_decl.error_token, indent, Space.None); // error
-                try renderToken(tree, stream, lbrace, indent, Space.None); // {
-                try renderExpression(allocator, stream, tree, indent, node, Space.None);
-                try renderToken(tree, stream, err_set_decl.rbrace_token, indent, space); // }
-                return;
+                try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None); // error
+                try renderToken(tree, stream, lbrace, indent, start_col, Space.None); // {
+                try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
+                return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space); // }
             }
 
-            try renderToken(tree, stream, err_set_decl.error_token, indent, Space.None); // error
-            try renderToken(tree, stream, lbrace, indent, Space.Newline); // {
+            try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None); // error
+            try renderToken(tree, stream, lbrace, indent, start_col, Space.Newline); // {
             const new_indent = indent + indent_delta;
 
             var it = err_set_decl.decls.iterator(0);
@@ -898,24 +899,24 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 try stream.writeByteNTimes(' ', new_indent);
 
                 if (it.peek()) |next_node| {
-                    try renderExpression(allocator, stream, tree, new_indent, node.*, Space.None);
-                    try renderToken(tree, stream, tree.nextToken(node.*.lastToken()), new_indent, Space.Newline); // ,
+                    try renderExpression(allocator, stream, tree, new_indent, start_col, node.*, Space.None);
+                    try renderToken(tree, stream, tree.nextToken(node.*.lastToken()), new_indent, start_col, Space.Newline); // ,
 
-                    try renderExtraNewline(tree, stream, next_node.*);
+                    try renderExtraNewline(tree, stream, start_col, next_node.*);
                 } else {
-                    try renderExpression(allocator, stream, tree, new_indent, node.*, Space.Comma);
+                    try renderExpression(allocator, stream, tree, new_indent, start_col, node.*, Space.Comma);
                 }
             }
 
             try stream.writeByteNTimes(' ', indent);
-            try renderToken(tree, stream, err_set_decl.rbrace_token, indent, space); // }
+            return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space); // }
         },
 
         ast.Node.Id.ErrorTag => {
             const tag = @fieldParentPtr(ast.Node.ErrorTag, "base", base);
 
-            try renderDocComments(tree, stream, tag, indent);
-            try renderToken(tree, stream, tag.name_token, indent, space); // name
+            try renderDocComments(tree, stream, tag, indent, start_col);
+            return renderToken(tree, stream, tag.name_token, indent, start_col, space); // name
         },
 
         ast.Node.Id.MultilineStringLiteral => {
@@ -933,32 +934,32 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 if (!skip_first_indent) {
                     try stream.writeByteNTimes(' ', indent + indent_delta);
                 }
-                try renderToken(tree, stream, t, indent, Space.None);
+                try renderToken(tree, stream, t, indent, start_col, Space.None);
                 skip_first_indent = false;
             }
             try stream.writeByteNTimes(' ', indent);
         },
         ast.Node.Id.UndefinedLiteral => {
             const undefined_literal = @fieldParentPtr(ast.Node.UndefinedLiteral, "base", base);
-            try renderToken(tree, stream, undefined_literal.token, indent, space);
+            return renderToken(tree, stream, undefined_literal.token, indent, start_col, space);
         },
 
         ast.Node.Id.BuiltinCall => {
             const builtin_call = @fieldParentPtr(ast.Node.BuiltinCall, "base", base);
 
-            try renderToken(tree, stream, builtin_call.builtin_token, indent, Space.None); // @name
-            try renderToken(tree, stream, tree.nextToken(builtin_call.builtin_token), indent, Space.None); // (
+            try renderToken(tree, stream, builtin_call.builtin_token, indent, start_col, Space.None); // @name
+            try renderToken(tree, stream, tree.nextToken(builtin_call.builtin_token), indent, start_col, Space.None); // (
 
             var it = builtin_call.params.iterator(0);
             while (it.next()) |param_node| {
-                try renderExpression(allocator, stream, tree, indent, param_node.*, Space.None);
+                try renderExpression(allocator, stream, tree, indent, start_col, param_node.*, Space.None);
 
                 if (it.peek() != null) {
                     const comma_token = tree.nextToken(param_node.*.lastToken());
-                    try renderToken(tree, stream, comma_token, indent, Space.Space); // ,
+                    try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
                 }
             }
-            try renderToken(tree, stream, builtin_call.rparen_token, indent, space); // )
+            return renderToken(tree, stream, builtin_call.rparen_token, indent, start_col, space); // )
         },
 
         ast.Node.Id.FnProto => {
@@ -968,31 +969,31 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 const visib_token = tree.tokens.at(visib_token_index);
                 assert(visib_token.id == Token.Id.Keyword_pub or visib_token.id == Token.Id.Keyword_export);
 
-                try renderToken(tree, stream, visib_token_index, indent, Space.Space); // pub
+                try renderToken(tree, stream, visib_token_index, indent, start_col, Space.Space); // pub
             }
 
             if (fn_proto.extern_export_inline_token) |extern_export_inline_token| {
-                try renderToken(tree, stream, extern_export_inline_token, indent, Space.Space); // extern/export
+                try renderToken(tree, stream, extern_export_inline_token, indent, start_col, Space.Space); // extern/export
             }
 
             if (fn_proto.lib_name) |lib_name| {
-                try renderExpression(allocator, stream, tree, indent, lib_name, Space.Space);
+                try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space);
             }
 
             if (fn_proto.cc_token) |cc_token| {
-                try renderToken(tree, stream, cc_token, indent, Space.Space); // stdcallcc
+                try renderToken(tree, stream, cc_token, indent, start_col, Space.Space); // stdcallcc
             }
 
             if (fn_proto.async_attr) |async_attr| {
-                try renderExpression(allocator, stream, tree, indent, &async_attr.base, Space.Space);
+                try renderExpression(allocator, stream, tree, indent, start_col, &async_attr.base, Space.Space);
             }
 
             const lparen = if (fn_proto.name_token) |name_token| blk: {
-                try renderToken(tree, stream, fn_proto.fn_token, indent, Space.Space); // fn
-                try renderToken(tree, stream, name_token, indent, Space.None); // name
+                try renderToken(tree, stream, fn_proto.fn_token, indent, start_col, Space.Space); // fn
+                try renderToken(tree, stream, name_token, indent, start_col, Space.None); // name
                 break :blk tree.nextToken(name_token);
             } else blk: {
-                try renderToken(tree, stream, fn_proto.fn_token, indent, Space.None); // fn
+                try renderToken(tree, stream, fn_proto.fn_token, indent, start_col, Space.None); // fn
                 break :blk tree.nextToken(fn_proto.fn_token);
             };
 
@@ -1011,51 +1012,51 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             };
 
             if (!src_params_trailing_comma and src_params_same_line) {
-                try renderToken(tree, stream, lparen, indent, Space.None); // (
+                try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
 
                 // render all on one line, no trailing comma
                 var it = fn_proto.params.iterator(0);
                 while (it.next()) |param_decl_node| {
-                    try renderParamDecl(allocator, stream, tree, indent, param_decl_node.*, Space.None);
+                    try renderParamDecl(allocator, stream, tree, indent, start_col, param_decl_node.*, Space.None);
 
                     if (it.peek() != null) {
                         const comma = tree.nextToken(param_decl_node.*.lastToken());
-                        try renderToken(tree, stream, comma, indent, Space.Space); // ,
+                        try renderToken(tree, stream, comma, indent, start_col, Space.Space); // ,
                     }
                 }
             } else {
                 // one param per line
                 const new_indent = indent + indent_delta;
-                try renderToken(tree, stream, lparen, new_indent, Space.Newline); // (
+                try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline); // (
 
                 var it = fn_proto.params.iterator(0);
                 while (it.next()) |param_decl_node| {
                     try stream.writeByteNTimes(' ', new_indent);
-                    try renderParamDecl(allocator, stream, tree, indent, param_decl_node.*, Space.Comma);
+                    try renderParamDecl(allocator, stream, tree, indent, start_col, param_decl_node.*, Space.Comma);
                 }
                 try stream.writeByteNTimes(' ', indent);
             }
 
-            try renderToken(tree, stream, rparen, indent, Space.Space); // )
+            try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
 
             if (fn_proto.align_expr) |align_expr| {
                 const align_rparen = tree.nextToken(align_expr.lastToken());
                 const align_lparen = tree.prevToken(align_expr.firstToken());
                 const align_kw = tree.prevToken(align_lparen);
 
-                try renderToken(tree, stream, align_kw, indent, Space.None); // align
-                try renderToken(tree, stream, align_lparen, indent, Space.None); // (
-                try renderExpression(allocator, stream, tree, indent, align_expr, Space.None);
-                try renderToken(tree, stream, align_rparen, indent, Space.Space); // )
+                try renderToken(tree, stream, align_kw, indent, start_col, Space.None); // align
+                try renderToken(tree, stream, align_lparen, indent, start_col, Space.None); // (
+                try renderExpression(allocator, stream, tree, indent, start_col, align_expr, Space.None);
+                try renderToken(tree, stream, align_rparen, indent, start_col, Space.Space); // )
             }
 
             switch (fn_proto.return_type) {
                 ast.Node.FnProto.ReturnType.Explicit => |node| {
-                    try renderExpression(allocator, stream, tree, indent, node, space);
+                    return renderExpression(allocator, stream, tree, indent, start_col, node, space);
                 },
                 ast.Node.FnProto.ReturnType.InferErrorSet => |node| {
-                    try renderToken(tree, stream, tree.prevToken(node.firstToken()), indent, Space.None); // !
-                    try renderExpression(allocator, stream, tree, indent, node, space);
+                    try renderToken(tree, stream, tree.prevToken(node.firstToken()), indent, start_col, Space.None); // !
+                    return renderExpression(allocator, stream, tree, indent, start_col, node, space);
                 },
             }
         },
@@ -1064,11 +1065,11 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             const promise_type = @fieldParentPtr(ast.Node.PromiseType, "base", base);
 
             if (promise_type.result) |result| {
-                try renderToken(tree, stream, promise_type.promise_token, indent, Space.None); // promise
-                try renderToken(tree, stream, result.arrow_token, indent, Space.None); // ->
-                try renderExpression(allocator, stream, tree, indent, result.return_type, space);
+                try renderToken(tree, stream, promise_type.promise_token, indent, start_col, Space.None); // promise
+                try renderToken(tree, stream, result.arrow_token, indent, start_col, Space.None); // ->
+                return renderExpression(allocator, stream, tree, indent, start_col, result.return_type, space);
             } else {
-                try renderToken(tree, stream, promise_type.promise_token, indent, space); // promise
+                return renderToken(tree, stream, promise_type.promise_token, indent, start_col, space); // promise
             }
         },
 
@@ -1077,39 +1078,38 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
         ast.Node.Id.Switch => {
             const switch_node = @fieldParentPtr(ast.Node.Switch, "base", base);
 
-            try renderToken(tree, stream, switch_node.switch_token, indent, Space.Space); // switch
-            try renderToken(tree, stream, tree.nextToken(switch_node.switch_token), indent, Space.None); // (
+            try renderToken(tree, stream, switch_node.switch_token, indent, start_col, Space.Space); // switch
+            try renderToken(tree, stream, tree.nextToken(switch_node.switch_token), indent, start_col, Space.None); // (
 
             const rparen = tree.nextToken(switch_node.expr.lastToken());
             const lbrace = tree.nextToken(rparen);
 
             if (switch_node.cases.len == 0) {
-                try renderExpression(allocator, stream, tree, indent, switch_node.expr, Space.None);
-                try renderToken(tree, stream, rparen, indent, Space.Space); // )
-                try renderToken(tree, stream, lbrace, indent, Space.None); // {
-                try renderToken(tree, stream, switch_node.rbrace, indent, space); // }
-                return;
+                try renderExpression(allocator, stream, tree, indent, start_col, switch_node.expr, Space.None);
+                try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
+                try renderToken(tree, stream, lbrace, indent, start_col, Space.None); // {
+                return renderToken(tree, stream, switch_node.rbrace, indent, start_col, space); // }
             }
 
-            try renderExpression(allocator, stream, tree, indent, switch_node.expr, Space.None);
+            try renderExpression(allocator, stream, tree, indent, start_col, switch_node.expr, Space.None);
 
             const new_indent = indent + indent_delta;
 
-            try renderToken(tree, stream, rparen, indent, Space.Space); // )
-            try renderToken(tree, stream, lbrace, new_indent, Space.Newline); // {
+            try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
+            try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline); // {
 
             var it = switch_node.cases.iterator(0);
             while (it.next()) |node| {
                 try stream.writeByteNTimes(' ', new_indent);
-                try renderExpression(allocator, stream, tree, new_indent, node.*, Space.Comma);
+                try renderExpression(allocator, stream, tree, new_indent, start_col, node.*, Space.Comma);
 
                 if (it.peek()) |next_node| {
-                    try renderExtraNewline(tree, stream, next_node.*);
+                    try renderExtraNewline(tree, stream, start_col, next_node.*);
                 }
             }
 
             try stream.writeByteNTimes(' ', indent);
-            try renderToken(tree, stream, switch_node.rbrace, indent, space); // }
+            return renderToken(tree, stream, switch_node.rbrace, indent, start_col, space); // }
         },
 
         ast.Node.Id.SwitchCase => {
@@ -1126,13 +1126,13 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 var it = switch_case.items.iterator(0);
                 while (it.next()) |node| {
                     if (it.peek()) |next_node| {
-                        try renderExpression(allocator, stream, tree, indent, node.*, Space.None);
+                        try renderExpression(allocator, stream, tree, indent, start_col, node.*, Space.None);
 
                         const comma_token = tree.nextToken(node.*.lastToken());
-                        try renderToken(tree, stream, comma_token, indent, Space.Space); // ,
-                        try renderExtraNewline(tree, stream, next_node.*);
+                        try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
+                        try renderExtraNewline(tree, stream, start_col, next_node.*);
                     } else {
-                        try renderExpression(allocator, stream, tree, indent, node.*, Space.Space);
+                        try renderExpression(allocator, stream, tree, indent, start_col, node.*, Space.Space);
                     }
                 }
             } else {
@@ -1140,85 +1140,97 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 while (true) {
                     const node = ??it.next();
                     if (it.peek()) |next_node| {
-                        try renderExpression(allocator, stream, tree, indent, node.*, Space.None);
+                        try renderExpression(allocator, stream, tree, indent, start_col, node.*, Space.None);
 
                         const comma_token = tree.nextToken(node.*.lastToken());
-                        try renderToken(tree, stream, comma_token, indent, Space.Newline); // ,
-                        try renderExtraNewline(tree, stream, next_node.*);
+                        try renderToken(tree, stream, comma_token, indent, start_col, Space.Newline); // ,
+                        try renderExtraNewline(tree, stream, start_col, next_node.*);
                         try stream.writeByteNTimes(' ', indent);
                     } else {
-                        try renderExpression(allocator, stream, tree, indent, node.*, Space.Comma);
+                        try renderExpression(allocator, stream, tree, indent, start_col, node.*, Space.Comma);
                         try stream.writeByteNTimes(' ', indent);
                         break;
                     }
                 }
             }
 
-            try renderToken(tree, stream, switch_case.arrow_token, indent, Space.Space); // =>
+            try renderToken(tree, stream, switch_case.arrow_token, indent, start_col, Space.Space); // =>
 
             if (switch_case.payload) |payload| {
-                try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
+                try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
             }
 
-            try renderExpression(allocator, stream, tree, indent, switch_case.expr, space);
+            return renderExpression(allocator, stream, tree, indent, start_col, switch_case.expr, space);
         },
         ast.Node.Id.SwitchElse => {
             const switch_else = @fieldParentPtr(ast.Node.SwitchElse, "base", base);
-            try renderToken(tree, stream, switch_else.token, indent, space);
+            return renderToken(tree, stream, switch_else.token, indent, start_col, space);
         },
         ast.Node.Id.Else => {
             const else_node = @fieldParentPtr(ast.Node.Else, "base", base);
 
-            const block_body = switch (else_node.body.id) {
-                ast.Node.Id.Block,
-                ast.Node.Id.If,
-                ast.Node.Id.For,
-                ast.Node.Id.While,
-                ast.Node.Id.Switch => true,
-                else => false,
-            };
+            const body_is_block = nodeIsBlock(else_node.body);
+            const same_line = body_is_block or tree.tokensOnSameLine(else_node.else_token, else_node.body.lastToken());
 
-            const after_else_space = if (block_body or else_node.payload != null) Space.Space else Space.Newline;
-            try renderToken(tree, stream, else_node.else_token, indent, after_else_space);
+            const after_else_space = if (same_line or else_node.payload != null) Space.Space else Space.Newline;
+            try renderToken(tree, stream, else_node.else_token, indent, start_col, after_else_space);
 
             if (else_node.payload) |payload| {
-                const payload_space = if (block_body) Space.Space else Space.Newline;
-                try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
+                const payload_space = if (same_line) Space.Space else Space.Newline;
+                try renderExpression(allocator, stream, tree, indent, start_col, payload, payload_space);
             }
 
-            if (block_body) {
-                try renderExpression(allocator, stream, tree, indent, else_node.body, space);
-            } else {
-                try stream.writeByteNTimes(' ', indent + indent_delta);
-                try renderExpression(allocator, stream, tree, indent, else_node.body, space);
+            if (same_line) {
+                return renderExpression(allocator, stream, tree, indent, start_col, else_node.body, space);
             }
+
+            try stream.writeByteNTimes(' ', indent + indent_delta);
+            start_col.* = indent + indent_delta;
+            return renderExpression(allocator, stream, tree, indent, start_col, else_node.body, space);
         },
 
         ast.Node.Id.While => {
             const while_node = @fieldParentPtr(ast.Node.While, "base", base);
 
             if (while_node.label) |label| {
-                try renderToken(tree, stream, label, indent, Space.None); // label
-                try renderToken(tree, stream, tree.nextToken(label), indent, Space.Space); // :
+                try renderToken(tree, stream, label, indent, start_col, Space.None); // label
+                try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space); // :
             }
 
             if (while_node.inline_token) |inline_token| {
-                try renderToken(tree, stream, inline_token, indent, Space.Space); // inline
+                try renderToken(tree, stream, inline_token, indent, start_col, Space.Space); // inline
             }
 
-            try renderToken(tree, stream, while_node.while_token, indent, Space.Space); // while
-            try renderToken(tree, stream, tree.nextToken(while_node.while_token), indent, Space.None); // (
-            try renderExpression(allocator, stream, tree, indent, while_node.condition, Space.None);
+            try renderToken(tree, stream, while_node.while_token, indent, start_col, Space.Space); // while
+            try renderToken(tree, stream, tree.nextToken(while_node.while_token), indent, start_col, Space.None); // (
+            try renderExpression(allocator, stream, tree, indent, start_col, while_node.condition, Space.None);
+
+            const cond_rparen = tree.nextToken(while_node.condition.lastToken());
+
+            const body_is_block = nodeIsBlock(while_node.body);
+
+            var block_start_space: Space = undefined;
+            var after_body_space: Space = undefined;
+
+            if (body_is_block) {
+                block_start_space = Space.BlockStart;
+                after_body_space = if (while_node.@"else" == null) space else Space.SpaceOrOutdent;
+            } else if (tree.tokensOnSameLine(cond_rparen, while_node.body.lastToken())) {
+                block_start_space = Space.Space;
+                after_body_space = if (while_node.@"else" == null) space else Space.Space;
+            } else {
+                block_start_space = Space.Newline;
+                after_body_space = if (while_node.@"else" == null) space else Space.Newline;
+            }
 
             {
-                const rparen = tree.nextToken(while_node.condition.lastToken());
-                const rparen_space = if (while_node.payload != null or while_node.continue_expr != null or
-                    while_node.body.id == ast.Node.Id.Block) Space.Space else Space.Newline;
-                try renderToken(tree, stream, rparen, indent, rparen_space); // )
+                const rparen_space = if (while_node.payload != null or while_node.continue_expr != null) Space.Space else block_start_space;
+                try renderToken(tree, stream, cond_rparen, indent, start_col, rparen_space); // )
             }
 
             if (while_node.payload) |payload| {
-                try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
+                const payload_space = if (while_node.continue_expr != null) Space.Space else block_start_space;
+                try renderExpression(allocator, stream, tree, indent, start_col, payload, payload_space);
             }
 
             if (while_node.continue_expr) |continue_expr| {
@@ -1226,37 +1238,29 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 const lparen = tree.prevToken(continue_expr.firstToken());
                 const colon = tree.prevToken(lparen);
 
-                try renderToken(tree, stream, colon, indent, Space.Space); // :
-                try renderToken(tree, stream, lparen, indent, Space.None); // (
+                try renderToken(tree, stream, colon, indent, start_col, Space.Space); // :
+                try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
 
-                try renderExpression(allocator, stream, tree, indent, continue_expr, Space.None);
+                try renderExpression(allocator, stream, tree, indent, start_col, continue_expr, Space.None);
 
-                const rparen_space = if (while_node.body.id == ast.Node.Id.Block) Space.Space else Space.Newline;
-                try renderToken(tree, stream, rparen, indent, rparen_space); // )
+                try renderToken(tree, stream, rparen, indent, start_col, block_start_space); // )
             }
 
-            const body_space = blk: {
-                if (while_node.@"else" != null) {
-                    break :blk if (while_node.body.id == ast.Node.Id.Block) Space.Space else Space.Newline;
-                } else {
-                    break :blk space;
-                }
-            };
-
-            if (while_node.body.id == ast.Node.Id.Block) {
-                try renderExpression(allocator, stream, tree, indent, while_node.body, body_space);
-            } else {
-                try stream.writeByteNTimes(' ', indent + indent_delta);
-                try renderExpression(allocator, stream, tree, indent, while_node.body, body_space);
+            var new_indent = indent;
+            if (block_start_space == Space.Newline) {
+                new_indent += indent_delta;
+                try stream.writeByteNTimes(' ', new_indent);
+                start_col.* = new_indent;
             }
 
+            try renderExpression(allocator, stream, tree, indent, start_col, while_node.body, after_body_space);
+
             if (while_node.@"else") |@"else"| {
-                if (while_node.body.id == ast.Node.Id.Block) {
-                } else {
+                if (after_body_space == Space.Newline) {
                     try stream.writeByteNTimes(' ', indent);
+                    start_col.* = indent;
                 }
-
-                try renderExpression(allocator, stream, tree, indent, &@"else".base, space);
+                return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space);
             }
         },
 
@@ -1264,26 +1268,26 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             const for_node = @fieldParentPtr(ast.Node.For, "base", base);
 
             if (for_node.label) |label| {
-                try renderToken(tree, stream, label, indent, Space.None); // label
-                try renderToken(tree, stream, tree.nextToken(label), indent, Space.Space); // :
+                try renderToken(tree, stream, label, indent, start_col, Space.None); // label
+                try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space); // :
             }
 
             if (for_node.inline_token) |inline_token| {
-                try renderToken(tree, stream, inline_token, indent, Space.Space); // inline
+                try renderToken(tree, stream, inline_token, indent, start_col, Space.Space); // inline
             }
 
-            try renderToken(tree, stream, for_node.for_token, indent, Space.Space); // for
-            try renderToken(tree, stream, tree.nextToken(for_node.for_token), indent, Space.None); // (
-            try renderExpression(allocator, stream, tree, indent, for_node.array_expr, Space.None);
+            try renderToken(tree, stream, for_node.for_token, indent, start_col, Space.Space); // for
+            try renderToken(tree, stream, tree.nextToken(for_node.for_token), indent, start_col, Space.None); // (
+            try renderExpression(allocator, stream, tree, indent, start_col, for_node.array_expr, Space.None);
 
             const rparen = tree.nextToken(for_node.array_expr.lastToken());
             const rparen_space = if (for_node.payload != null or
                 for_node.body.id == ast.Node.Id.Block) Space.Space else Space.Newline;
-            try renderToken(tree, stream, rparen, indent, rparen_space); // )
+            try renderToken(tree, stream, rparen, indent, start_col, rparen_space); // )
 
             if (for_node.payload) |payload| {
                 const payload_space = if (for_node.body.id == ast.Node.Id.Block) Space.Space else Space.Newline;
-                try renderExpression(allocator, stream, tree, indent, payload, payload_space);
+                try renderExpression(allocator, stream, tree, indent, start_col, payload, payload_space);
             }
 
             const body_space = blk: {
@@ -1298,10 +1302,10 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 }
             };
             if (for_node.body.id == ast.Node.Id.Block) {
-                try renderExpression(allocator, stream, tree, indent, for_node.body, body_space);
+                try renderExpression(allocator, stream, tree, indent, start_col, for_node.body, body_space);
             } else {
                 try stream.writeByteNTimes(' ', indent + indent_delta);
-                try renderExpression(allocator, stream, tree, indent, for_node.body, body_space);
+                try renderExpression(allocator, stream, tree, indent, start_col, for_node.body, body_space);
             }
 
             if (for_node.@"else") |@"else"| {
@@ -1309,7 +1313,7 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                     try stream.writeByteNTimes(' ', indent);
                 }
 
-                try renderExpression(allocator, stream, tree, indent, &@"else".base, space);
+                return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space);
             }
         },
 
@@ -1319,128 +1323,109 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             const lparen = tree.prevToken(if_node.condition.firstToken());
             const rparen = tree.nextToken(if_node.condition.lastToken());
 
-            try renderToken(tree, stream, if_node.if_token, indent, Space.Space); // if
-            try renderToken(tree, stream, lparen, indent, Space.None); // (
+            try renderToken(tree, stream, if_node.if_token, indent, start_col, Space.Space); // if
+            try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
 
-            try renderExpression(allocator, stream, tree, indent, if_node.condition, Space.None); // condition
+            try renderExpression(allocator, stream, tree, indent, start_col, if_node.condition, Space.None); // condition
 
-            const body_is_block = switch (if_node.body.id) {
-                ast.Node.Id.Block,
-                ast.Node.Id.If,
-                ast.Node.Id.For,
-                ast.Node.Id.While,
-                ast.Node.Id.Switch,
-                => true,
-                else => false,
-            };
+            const body_is_block = nodeIsBlock(if_node.body);
 
             if (body_is_block) {
-                try renderToken(tree, stream, rparen, indent, Space.Space); // )
+                const after_rparen_space = if (if_node.payload == null) Space.BlockStart else Space.Space;
+                try renderToken(tree, stream, rparen, indent, start_col, after_rparen_space); // )
 
                 if (if_node.payload) |payload| {
-                    try renderExpression(allocator, stream, tree, indent, payload, Space.Space); // |x|
+                    try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.BlockStart); // |x|
                 }
 
                 if (if_node.@"else") |@"else"| {
-                    try renderExpression(allocator, stream, tree, indent, if_node.body, Space.SpaceOrOutdent);
-                    return renderExpression(allocator, stream, tree, indent, &@"else".base, space);
+                    try renderExpression(allocator, stream, tree, indent, start_col, if_node.body, Space.SpaceOrOutdent);
+                    return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space);
                 } else {
-                    return renderExpression(allocator, stream, tree, indent, if_node.body, space);
+                    return renderExpression(allocator, stream, tree, indent, start_col, if_node.body, space);
                 }
             }
 
-            const src_has_newline = blk: {
-                const loc = tree.tokenLocation(tree.tokens.at(rparen).end, if_node.body.lastToken());
-                break :blk loc.line != 0;
-            };
+            const src_has_newline = !tree.tokensOnSameLine(rparen, if_node.body.lastToken());
 
             if (src_has_newline) {
                 const after_rparen_space = if (if_node.payload == null) Space.Newline else Space.Space;
-                try renderToken(tree, stream, rparen, indent, after_rparen_space); // )
+                try renderToken(tree, stream, rparen, indent, start_col, after_rparen_space); // )
 
                 if (if_node.payload) |payload| {
-                    try renderExpression(allocator, stream, tree, indent, payload, Space.Newline);
+                    try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Newline);
                 }
 
                 const new_indent = indent + indent_delta;
                 try stream.writeByteNTimes(' ', new_indent);
 
                 if (if_node.@"else") |@"else"| {
-                    const else_is_block = switch (@"else".body.id) {
-                        ast.Node.Id.Block,
-                        ast.Node.Id.If,
-                        ast.Node.Id.For,
-                        ast.Node.Id.While,
-                        ast.Node.Id.Switch,
-                        => true,
-                        else => false,
-                    };
-                    try renderExpression(allocator, stream, tree, new_indent, if_node.body, Space.Newline);
+                    const else_is_block = nodeIsBlock(@"else".body);
+                    try renderExpression(allocator, stream, tree, new_indent, start_col, if_node.body, Space.Newline);
                     try stream.writeByteNTimes(' ', indent);
 
                     if (else_is_block) {
-                        try renderToken(tree, stream, @"else".else_token, indent, Space.Space); // else
+                        try renderToken(tree, stream, @"else".else_token, indent, start_col, Space.Space); // else
 
                         if (@"else".payload) |payload| {
-                            try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
+                            try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
                         }
 
-                        return renderExpression(allocator, stream, tree, indent, @"else".body, space);
+                        return renderExpression(allocator, stream, tree, indent, start_col, @"else".body, space);
                     } else {
                         const after_else_space = if (@"else".payload == null) Space.Newline else Space.Space;
-                        try renderToken(tree, stream, @"else".else_token, indent, after_else_space); // else
+                        try renderToken(tree, stream, @"else".else_token, indent, start_col, after_else_space); // else
 
                         if (@"else".payload) |payload| {
-                            try renderExpression(allocator, stream, tree, indent, payload, Space.Newline);
+                            try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Newline);
                         }
                         try stream.writeByteNTimes(' ', new_indent);
 
-                        return renderExpression(allocator, stream, tree, new_indent, @"else".body, space);
+                        return renderExpression(allocator, stream, tree, new_indent, start_col, @"else".body, space);
                     }
                 } else {
-                    return renderExpression(allocator, stream, tree, new_indent, if_node.body, space);
+                    return renderExpression(allocator, stream, tree, new_indent, start_col, if_node.body, space);
                 }
             }
 
-            try renderToken(tree, stream, rparen, indent, Space.Space); // )
+            try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
 
             if (if_node.payload) |payload| {
-                try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
+                try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
             }
 
             if (if_node.@"else") |@"else"| {
-                try renderExpression(allocator, stream, tree, indent, if_node.body, Space.Space);
-                try renderToken(tree, stream, @"else".else_token, indent, Space.Space);
+                try renderExpression(allocator, stream, tree, indent, start_col, if_node.body, Space.Space);
+                try renderToken(tree, stream, @"else".else_token, indent, start_col, Space.Space);
 
                 if (@"else".payload) |payload| {
-                    try renderExpression(allocator, stream, tree, indent, payload, Space.Space);
+                    try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
                 }
 
-                return renderExpression(allocator, stream, tree, indent, @"else".body, space);
+                return renderExpression(allocator, stream, tree, indent, start_col, @"else".body, space);
             } else {
-                return renderExpression(allocator, stream, tree, indent, if_node.body, space);
+                return renderExpression(allocator, stream, tree, indent, start_col, if_node.body, space);
             }
         },
 
         ast.Node.Id.Asm => {
             const asm_node = @fieldParentPtr(ast.Node.Asm, "base", base);
 
-            try renderToken(tree, stream, asm_node.asm_token, indent, Space.Space); // asm
+            try renderToken(tree, stream, asm_node.asm_token, indent, start_col, Space.Space); // asm
 
             if (asm_node.volatile_token) |volatile_token| {
-                try renderToken(tree, stream, volatile_token, indent, Space.Space); // volatile
-                try renderToken(tree, stream, tree.nextToken(volatile_token), indent, Space.None); // (
+                try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space); // volatile
+                try renderToken(tree, stream, tree.nextToken(volatile_token), indent, start_col, Space.None); // (
             } else {
-                try renderToken(tree, stream, tree.nextToken(asm_node.asm_token), indent, Space.None); // (
+                try renderToken(tree, stream, tree.nextToken(asm_node.asm_token), indent, start_col, Space.None); // (
             }
 
             if (asm_node.outputs.len == 0 and asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
-                try renderExpression(allocator, stream, tree, indent, asm_node.template, Space.None);
-                try renderToken(tree, stream, asm_node.rparen, indent, space);
-                return;
+                try renderExpression(allocator, stream, tree, indent, start_col, asm_node.template, Space.None);
+                return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
             }
 
-            try renderExpression(allocator, stream, tree, indent, asm_node.template, Space.Newline);
+            try renderExpression(allocator, stream, tree, indent, start_col, asm_node.template, Space.Newline);
 
             const indent_once = indent + indent_delta;
             try stream.writeByteNTimes(' ', indent_once);
@@ -1449,12 +1434,12 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             const indent_extra = indent_once + 2;
 
             const colon2 = if (asm_node.outputs.len == 0) blk: {
-                try renderToken(tree, stream, colon1, indent, Space.Newline); // :
+                try renderToken(tree, stream, colon1, indent, start_col, Space.Newline); // :
                 try stream.writeByteNTimes(' ', indent_once);
 
                 break :blk tree.nextToken(colon1);
             } else blk: {
-                try renderToken(tree, stream, colon1, indent, Space.Space); // :
+                try renderToken(tree, stream, colon1, indent, start_col, Space.Space); // :
 
                 var it = asm_node.outputs.iterator(0);
                 while (true) {
@@ -1462,21 +1447,20 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                     const node = &(asm_output.*).base;
 
                     if (it.peek()) |next_asm_output| {
-                        try renderExpression(allocator, stream, tree, indent_extra, node, Space.None);
+                        try renderExpression(allocator, stream, tree, indent_extra, start_col, node, Space.None);
                         const next_node = &(next_asm_output.*).base;
 
                         const comma = tree.prevToken(next_asm_output.*.firstToken());
-                        try renderToken(tree, stream, comma, indent_extra, Space.Newline); // ,
-                        try renderExtraNewline(tree, stream, next_node);
+                        try renderToken(tree, stream, comma, indent_extra, start_col, Space.Newline); // ,
+                        try renderExtraNewline(tree, stream, start_col, next_node);
 
                         try stream.writeByteNTimes(' ', indent_extra);
                     } else if (asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
-                        try renderExpression(allocator, stream, tree, indent_extra, node, Space.Newline);
+                        try renderExpression(allocator, stream, tree, indent_extra, start_col, node, Space.Newline);
                         try stream.writeByteNTimes(' ', indent);
-                        try renderToken(tree, stream, asm_node.rparen, indent, space);
-                        return;
+                        return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
                     } else {
-                        try renderExpression(allocator, stream, tree, indent_extra, node, Space.Newline);
+                        try renderExpression(allocator, stream, tree, indent_extra, start_col, node, Space.Newline);
                         try stream.writeByteNTimes(' ', indent_once);
                         const comma_or_colon = tree.nextToken(node.lastToken());
                         break :blk switch (tree.tokens.at(comma_or_colon).id) {
@@ -1488,12 +1472,12 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             };
 
             const colon3 = if (asm_node.inputs.len == 0) blk: {
-                try renderToken(tree, stream, colon2, indent, Space.Newline); // :
+                try renderToken(tree, stream, colon2, indent, start_col, Space.Newline); // :
                 try stream.writeByteNTimes(' ', indent_once);
 
                 break :blk tree.nextToken(colon2);
             } else blk: {
-                try renderToken(tree, stream, colon2, indent, Space.Space); // :
+                try renderToken(tree, stream, colon2, indent, start_col, Space.Space); // :
 
                 var it = asm_node.inputs.iterator(0);
                 while (true) {
@@ -1501,21 +1485,20 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                     const node = &(asm_input.*).base;
 
                     if (it.peek()) |next_asm_input| {
-                        try renderExpression(allocator, stream, tree, indent_extra, node, Space.None);
+                        try renderExpression(allocator, stream, tree, indent_extra, start_col, node, Space.None);
                         const next_node = &(next_asm_input.*).base;
 
                         const comma = tree.prevToken(next_asm_input.*.firstToken());
-                        try renderToken(tree, stream, comma, indent_extra, Space.Newline); // ,
-                        try renderExtraNewline(tree, stream, next_node);
+                        try renderToken(tree, stream, comma, indent_extra, start_col, Space.Newline); // ,
+                        try renderExtraNewline(tree, stream, start_col, next_node);
 
                         try stream.writeByteNTimes(' ', indent_extra);
                     } else if (asm_node.clobbers.len == 0) {
-                        try renderExpression(allocator, stream, tree, indent_extra, node, Space.Newline);
+                        try renderExpression(allocator, stream, tree, indent_extra, start_col, node, Space.Newline);
                         try stream.writeByteNTimes(' ', indent);
-                        try renderToken(tree, stream, asm_node.rparen, indent, space); // )
-                        return;
+                        return renderToken(tree, stream, asm_node.rparen, indent, start_col, space); // )
                     } else {
-                        try renderExpression(allocator, stream, tree, indent_extra, node, Space.Newline);
+                        try renderExpression(allocator, stream, tree, indent_extra, start_col, node, Space.Newline);
                         try stream.writeByteNTimes(' ', indent_once);
                         const comma_or_colon = tree.nextToken(node.lastToken());
                         break :blk switch (tree.tokens.at(comma_or_colon).id) {
@@ -1526,21 +1509,20 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
                 }
             };
 
-            try renderToken(tree, stream, colon3, indent, Space.Space); // :
+            try renderToken(tree, stream, colon3, indent, start_col, Space.Space); // :
 
             var it = asm_node.clobbers.iterator(0);
             while (true) {
                 const clobber_token = ??it.next();
 
                 if (it.peek() == null) {
-                    try renderToken(tree, stream, clobber_token.*, indent_once, Space.Newline);
+                    try renderToken(tree, stream, clobber_token.*, indent_once, start_col, Space.Newline);
                     try stream.writeByteNTimes(' ', indent);
-                    try renderToken(tree, stream, asm_node.rparen, indent, space);
-                    return;
+                    return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
                 } else {
-                    try renderToken(tree, stream, clobber_token.*, indent_once, Space.None);
+                    try renderToken(tree, stream, clobber_token.*, indent_once, start_col, Space.None);
                     const comma = tree.nextToken(clobber_token.*);
-                    try renderToken(tree, stream, comma, indent_once, Space.Space); // ,
+                    try renderToken(tree, stream, comma, indent_once, start_col, Space.Space); // ,
                 }
             }
         },
@@ -1549,34 +1531,34 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
             const asm_input = @fieldParentPtr(ast.Node.AsmInput, "base", base);
 
             try stream.write("[");
-            try renderExpression(allocator, stream, tree, indent, asm_input.symbolic_name, Space.None);
+            try renderExpression(allocator, stream, tree, indent, start_col, asm_input.symbolic_name, Space.None);
             try stream.write("] ");
-            try renderExpression(allocator, stream, tree, indent, asm_input.constraint, Space.None);
+            try renderExpression(allocator, stream, tree, indent, start_col, asm_input.constraint, Space.None);
             try stream.write(" (");
-            try renderExpression(allocator, stream, tree, indent, asm_input.expr, Space.None);
-            try renderToken(tree, stream, asm_input.lastToken(), indent, space); // )
+            try renderExpression(allocator, stream, tree, indent, start_col, asm_input.expr, Space.None);
+            return renderToken(tree, stream, asm_input.lastToken(), indent, start_col, space); // )
         },
 
         ast.Node.Id.AsmOutput => {
             const asm_output = @fieldParentPtr(ast.Node.AsmOutput, "base", base);
 
             try stream.write("[");
-            try renderExpression(allocator, stream, tree, indent, asm_output.symbolic_name, Space.None);
+            try renderExpression(allocator, stream, tree, indent, start_col, asm_output.symbolic_name, Space.None);
             try stream.write("] ");
-            try renderExpression(allocator, stream, tree, indent, asm_output.constraint, Space.None);
+            try renderExpression(allocator, stream, tree, indent, start_col, asm_output.constraint, Space.None);
             try stream.write(" (");
 
             switch (asm_output.kind) {
                 ast.Node.AsmOutput.Kind.Variable => |variable_name| {
-                    try renderExpression(allocator, stream, tree, indent, &variable_name.base, Space.None);
+                    try renderExpression(allocator, stream, tree, indent, start_col, &variable_name.base, Space.None);
                 },
                 ast.Node.AsmOutput.Kind.Return => |return_type| {
                     try stream.write("-> ");
-                    try renderExpression(allocator, stream, tree, indent, return_type, Space.None);
+                    try renderExpression(allocator, stream, tree, indent, start_col, return_type, Space.None);
                 },
             }
 
-            try renderToken(tree, stream, asm_output.lastToken(), indent, space); // )
+            return renderToken(tree, stream, asm_output.lastToken(), indent, start_col, space); // )
         },
 
         ast.Node.Id.StructField,
@@ -1590,92 +1572,92 @@ fn renderExpression(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, ind
     }
 }
 
-fn renderVarDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize,
-    var_decl: &ast.Node.VarDecl) (@typeOf(stream).Child.Error || Error)!void
+fn renderVarDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, start_col: &usize,
+    var_decl: &ast.Node.VarDecl,) (@typeOf(stream).Child.Error || Error)!void
 {
     if (var_decl.visib_token) |visib_token| {
-        try renderToken(tree, stream, visib_token, indent, Space.Space); // pub
+        try renderToken(tree, stream, visib_token, indent, start_col, Space.Space); // pub
     }
 
     if (var_decl.extern_export_token) |extern_export_token| {
-        try renderToken(tree, stream, extern_export_token, indent, Space.Space); // extern
+        try renderToken(tree, stream, extern_export_token, indent, start_col, Space.Space); // extern
 
         if (var_decl.lib_name) |lib_name| {
-            try renderExpression(allocator, stream, tree, indent, lib_name, Space.Space); // "lib"
+            try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space); // "lib"
         }
     }
 
     if (var_decl.comptime_token) |comptime_token| {
-        try renderToken(tree, stream, comptime_token, indent, Space.Space); // comptime
+        try renderToken(tree, stream, comptime_token, indent, start_col, Space.Space); // comptime
     }
 
-    try renderToken(tree, stream, var_decl.mut_token, indent, Space.Space); // var
+    try renderToken(tree, stream, var_decl.mut_token, indent, start_col, Space.Space); // var
 
     const name_space = if (var_decl.type_node == null and (var_decl.align_node != null or
         var_decl.init_node != null)) Space.Space else Space.None;
-    try renderToken(tree, stream, var_decl.name_token, indent, name_space);
+    try renderToken(tree, stream, var_decl.name_token, indent, start_col, name_space);
 
     if (var_decl.type_node) |type_node| {
-        try renderToken(tree, stream, tree.nextToken(var_decl.name_token), indent, Space.Space);
+        try renderToken(tree, stream, tree.nextToken(var_decl.name_token), indent, start_col, Space.Space);
         const s = if (var_decl.align_node != null or var_decl.init_node != null) Space.Space else Space.None;
-        try renderExpression(allocator, stream, tree, indent, type_node, s);
+        try renderExpression(allocator, stream, tree, indent, start_col, type_node, s);
     }
 
     if (var_decl.align_node) |align_node| {
         const lparen = tree.prevToken(align_node.firstToken());
         const align_kw = tree.prevToken(lparen);
         const rparen = tree.nextToken(align_node.lastToken());
-        try renderToken(tree, stream, align_kw, indent, Space.None); // align
-        try renderToken(tree, stream, lparen, indent, Space.None); // (
-        try renderExpression(allocator, stream, tree, indent, align_node, Space.None);
+        try renderToken(tree, stream, align_kw, indent, start_col, Space.None); // align
+        try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
+        try renderExpression(allocator, stream, tree, indent, start_col, align_node, Space.None);
         const s = if (var_decl.init_node != null) Space.Space else Space.None;
-        try renderToken(tree, stream, rparen, indent, s); // )
+        try renderToken(tree, stream, rparen, indent, start_col, s); // )
     }
 
     if (var_decl.init_node) |init_node| {
         const s = if (init_node.id == ast.Node.Id.MultilineStringLiteral) Space.None else Space.Space;
-        try renderToken(tree, stream, var_decl.eq_token, indent, s); // =
-        try renderExpression(allocator, stream, tree, indent, init_node, Space.None);
+        try renderToken(tree, stream, var_decl.eq_token, indent, start_col, s); // =
+        try renderExpression(allocator, stream, tree, indent, start_col, init_node, Space.None);
     }
 
-    try renderToken(tree, stream, var_decl.semicolon_token, indent, Space.Newline);
+    try renderToken(tree, stream, var_decl.semicolon_token, indent, start_col, Space.Newline);
 }
 
-fn renderParamDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, base: &ast.Node, space: Space) (@typeOf(stream).Child.Error || Error)!void {
+fn renderParamDecl(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, start_col: &usize, base: &ast.Node, space: Space,) (@typeOf(stream).Child.Error || Error)!void {
     const param_decl = @fieldParentPtr(ast.Node.ParamDecl, "base", base);
 
     if (param_decl.comptime_token) |comptime_token| {
-        try renderToken(tree, stream, comptime_token, indent, Space.Space);
+        try renderToken(tree, stream, comptime_token, indent, start_col, Space.Space);
     }
     if (param_decl.noalias_token) |noalias_token| {
-        try renderToken(tree, stream, noalias_token, indent, Space.Space);
+        try renderToken(tree, stream, noalias_token, indent, start_col, Space.Space);
     }
     if (param_decl.name_token) |name_token| {
-        try renderToken(tree, stream, name_token, indent, Space.None);
-        try renderToken(tree, stream, tree.nextToken(name_token), indent, Space.Space); // :
+        try renderToken(tree, stream, name_token, indent, start_col, Space.None);
+        try renderToken(tree, stream, tree.nextToken(name_token), indent, start_col, Space.Space); // :
     }
     if (param_decl.var_args_token) |var_args_token| {
-        try renderToken(tree, stream, var_args_token, indent, space);
+        try renderToken(tree, stream, var_args_token, indent, start_col, space);
     } else {
-        try renderExpression(allocator, stream, tree, indent, param_decl.type_node, space);
+        try renderExpression(allocator, stream, tree, indent, start_col, param_decl.type_node, space);
     }
 }
 
-fn renderStatement(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, base: &ast.Node) (@typeOf(stream).Child.Error || Error)!void {
+fn renderStatement(allocator: &mem.Allocator, stream: var, tree: &ast.Tree, indent: usize, start_col: &usize, base: &ast.Node,) (@typeOf(stream).Child.Error || Error)!void {
     switch (base.id) {
         ast.Node.Id.VarDecl => {
             const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", base);
-            try renderVarDecl(allocator, stream, tree, indent, var_decl);
+            try renderVarDecl(allocator, stream, tree, indent, start_col, var_decl);
         },
         else => {
             if (base.requireSemiColon()) {
-                try renderExpression(allocator, stream, tree, indent, base, Space.None);
+                try renderExpression(allocator, stream, tree, indent, start_col, base, Space.None);
 
                 const semicolon_index = tree.nextToken(base.lastToken());
                 assert(tree.tokens.at(semicolon_index).id == Token.Id.Semicolon);
-                try renderToken(tree, stream, semicolon_index, indent, Space.Newline);
+                try renderToken(tree, stream, semicolon_index, indent, start_col, Space.Newline);
             } else {
-                try renderExpression(allocator, stream, tree, indent, base, Space.Newline);
+                try renderExpression(allocator, stream, tree, indent, start_col, base, Space.Newline);
             }
         },
     }
@@ -1689,32 +1671,44 @@ const Space = enum {
     SpaceOrOutdent,
     NoNewline,
     NoComment,
+    BlockStart,
 };
 
-fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent: usize, space: Space) (@typeOf(stream).Child.Error || Error)!void {
+fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent: usize, start_col: &usize, space: Space) (@typeOf(stream).Child.Error || Error)!void {
+    if (space == Space.BlockStart) {
+        if (start_col.* < indent + indent_delta)
+            return renderToken(tree, stream, token_index, indent, start_col, Space.Space);
+        try renderToken(tree, stream, token_index, indent, start_col, Space.Newline);
+        try stream.writeByteNTimes(' ', indent);
+        start_col.* = indent;
+        return;
+    }
+
     var token = tree.tokens.at(token_index);
     try stream.write(mem.trimRight(u8, tree.tokenSlicePtr(token), " "));
 
+    if (space == Space.NoComment)
+        return;
+
     var next_token = tree.tokens.at(token_index + 1);
 
-    switch (space) {
-        Space.NoComment => return,
-        Space.Comma => switch (next_token.id) {
-            Token.Id.Comma => return renderToken(tree, stream, token_index + 1, indent, Space.Newline),
-            Token.Id.LineComment => {
-                try stream.write(", ");
-                return renderToken(tree, stream, token_index + 1, indent, Space.Newline);
-            },
-            else => {
-                if (tree.tokens.at(token_index + 2).id == Token.Id.MultilineStringLiteralLine) {
-                    return stream.write(",");
-                } else {
-                    return stream.write(",\n");
-                }
-            },
+    if (space == Space.Comma) switch (next_token.id) {
+        Token.Id.Comma => return renderToken(tree, stream, token_index + 1, indent, start_col, Space.Newline),
+        Token.Id.LineComment => {
+            try stream.write(", ");
+            return renderToken(tree, stream, token_index + 1, indent, start_col, Space.Newline);
         },
-        else => {},
-    }
+        else => {
+            if (tree.tokens.at(token_index + 2).id == Token.Id.MultilineStringLiteralLine) {
+                try stream.write(",");
+                return;
+            } else {
+                try stream.write(",\n");
+                start_col.* = 0;
+                return;
+            }
+        },
+    };
 
     // Skip over same line doc comments
     var offset: usize = 1;
@@ -1733,18 +1727,27 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                 if (next_token.id == Token.Id.MultilineStringLiteralLine) {
                     return;
                 } else {
-                    return stream.write("\n");
+                    try stream.write("\n");
+                    start_col.* = 0;
+                    return;
                 }
             },
-            Space.Space, Space.SpaceOrOutdent => return stream.writeByte(' '),
-            Space.NoComment, Space.Comma => unreachable,
+            Space.Space, Space.SpaceOrOutdent => {
+                try stream.writeByte(' ');
+                return;
+            },
+            Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
         }
     }
 
     const comment_is_empty = mem.trimRight(u8, tree.tokenSlicePtr(next_token), " ").len == 2;
     if (comment_is_empty) {
         switch (space) {
-            Space.Newline => return stream.writeByte('\n'),
+            Space.Newline => {
+                try stream.writeByte('\n');
+                start_col.* = 0;
+                return;
+            },
             else => {},
         }
     }
@@ -1765,20 +1768,24 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                         else => indent + indent_delta,
                     };
                     try stream.writeByteNTimes(' ', next_line_indent);
+                    start_col.* = next_line_indent;
                 },
                 Space.SpaceOrOutdent => {
                     try stream.writeByte('\n');
                     try stream.writeByteNTimes(' ', indent);
+                    start_col.* = indent;
                 },
                 Space.Newline => {
                     if (next_token.id == Token.Id.MultilineStringLiteralLine) {
                         return;
                     } else {
-                        return stream.write("\n");
+                        try stream.write("\n");
+                        start_col.* = 0;
+                        return;
                     }
                 },
                 Space.NoNewline => {},
-                Space.NoComment, Space.Comma => unreachable,
+                Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
             }
             return;
         }
@@ -1801,7 +1808,9 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                     if (next_token.id == Token.Id.MultilineStringLiteralLine) {
                         return;
                     } else {
-                        return stream.write("\n");
+                        try stream.write("\n");
+                        start_col.* = 0;
+                        return;
                     }
                 },
                 Space.None, Space.Space => {
@@ -1813,13 +1822,15 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
                         else => indent,
                     };
                     try stream.writeByteNTimes(' ', next_line_indent);
+                    start_col.* = next_line_indent;
                 },
                 Space.SpaceOrOutdent => {
                     try stream.writeByte('\n');
                     try stream.writeByteNTimes(' ', indent);
+                    start_col.* = indent;
                 },
                 Space.NoNewline => {},
-                Space.NoComment, Space.Comma => unreachable,
+                Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
             }
             return;
         }
@@ -1827,18 +1838,30 @@ fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent
     }
 }
 
-fn renderDocComments(tree: &ast.Tree, stream: var, node: var, indent: usize) (@typeOf(stream).Child.Error || Error)!void {
+fn renderDocComments(tree: &ast.Tree, stream: var, node: var, indent: usize, start_col: &usize,) (@typeOf(stream).Child.Error || Error)!void {
     const comment = node.doc_comments ?? return;
     var it = comment.lines.iterator(0);
     const first_token = node.firstToken();
     while (it.next()) |line_token_index| {
         if (line_token_index.* < first_token) {
-            try renderToken(tree, stream, line_token_index.*, indent, Space.Newline);
+            try renderToken(tree, stream, line_token_index.*, indent, start_col, Space.Newline);
             try stream.writeByteNTimes(' ', indent);
         } else {
-            try renderToken(tree, stream, line_token_index.*, indent, Space.NoComment);
+            try renderToken(tree, stream, line_token_index.*, indent, start_col, Space.NoComment);
             try stream.write("\n");
             try stream.writeByteNTimes(' ', indent);
         }
     }
 }
+
+fn nodeIsBlock(base: &const ast.Node) bool {
+    return switch (base.id) {
+        ast.Node.Id.Block,
+        ast.Node.Id.If,
+        ast.Node.Id.For,
+        ast.Node.Id.While,
+        ast.Node.Id.Switch,
+        => true,
+        else => false,
+    };
+}
-- 
2.54.0