@zigc/lib 0.16.0-dev.3066 → 0.16.0-dev.3091

package/std/zig/Ast/Render.zig

@@ -338,9 +338,16 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
             try ais.maybeInsertNewline();
 
             const first_tok, const last_tok = tree.nodeData(node).token_and_token;
-            for (first_tok..last_tok + 1) |i| {
+            for (first_tok..last_tok) |i| {
                 try renderToken(r, @intCast(i), .newline);
             }
+            if (space != .skip) {
+                try renderToken(r, last_tok, .newline);
+            } else {
+                try renderToken(r, last_tok, .skip);
+                try ais.insertNewline(); // A newline is part of the token, so it still needs
+                // rendered here.
+            }
 
             const next_token = last_tok + 1;
             const next_token_tag = tree.tokenTag(next_token);
@@ -645,10 +652,12 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
             const lhs, const rhs = tree.nodeData(node).node_and_node;
             const lbracket = tree.firstToken(rhs) - 1;
             const rbracket = tree.lastToken(rhs) + 1;
+            try renderExpression(r, lhs, .none);
+            // One lien check must come after rendering lhs since it can influence
+            // isLineOverIndented
             const one_line = tree.tokensOnSameLine(lbracket, rbracket) and
-                !becomesMultilineExpr(tree, rhs);
+                !try rendersMultiline(r, rhs);
             const inner_space = if (one_line) Space.none else Space.newline;
-            try renderExpression(r, lhs, .none);
             try ais.pushIndent(.normal);
             try renderToken(r, lbracket, inner_space); // [
             try renderExpression(r, rhs, inner_space);
@@ -793,34 +802,47 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
             canonicalize: {
                 if (params.len != 1) break :canonicalize;
 
-                const CastKind = enum {
+                const CastKind = enum(u8) {
                     ptrCast,
                     alignCast,
                     addrSpaceCast,
                     constCast,
                     volatileCast,
                 };
-                const kind = meta.stringToEnum(CastKind, tree.tokenSlice(builtin_token)[1..]) orelse break :canonicalize;
+                const kind = meta.stringToEnum(
+                    CastKind,
+                    tree.tokenSlice(builtin_token)[1..],
+                ) orelse break :canonicalize;
 
                 var cast_map = std.EnumMap(CastKind, Ast.TokenIndex).init(.{});
                 cast_map.put(kind, builtin_token);
 
                 var casts_before: usize = 0;
-                if (builtin_token >= 2) {
-                    var prev_builtin_token = builtin_token - 2;
-                    while (tree.tokenTag(prev_builtin_token) == .builtin) : (prev_builtin_token -= 2) {
-                        const prev_kind = meta.stringToEnum(CastKind, tree.tokenSlice(prev_builtin_token)[1..]) orelse break;
-                        if (cast_map.contains(prev_kind)) break :canonicalize;
-                        cast_map.put(prev_kind, prev_builtin_token);
-                        casts_before += 1;
-                    }
+                var prev_builtin_token = builtin_token;
+                while (prev_builtin_token >= 2) {
+                    prev_builtin_token -= 2;
+                    if (tree.tokenTag(prev_builtin_token) != .builtin) break;
+                    const builtin_name = tree.tokenSlice(prev_builtin_token)[1..];
+                    const prev_kind = meta.stringToEnum(CastKind, builtin_name) orelse break;
+                    if (cast_map.contains(prev_kind)) break :canonicalize;
+                    // This must be checked after so that cast builtins as arguments to other
+                    // builtins containing comments are reordered.
+                    if (hasComment(tree, prev_builtin_token, prev_builtin_token + 2))
+                        break :canonicalize;
+                    cast_map.put(prev_kind, prev_builtin_token);
+                    casts_before += 1;
                 }
 
                 var next_builtin_token = builtin_token + 2;
-                while (tree.tokenTag(next_builtin_token) == .builtin) : (next_builtin_token += 2) {
-                    const next_kind = meta.stringToEnum(CastKind, tree.tokenSlice(next_builtin_token)[1..]) orelse break;
+                while (true) {
+                    if (hasComment(tree, next_builtin_token - 2, next_builtin_token))
+                        break :canonicalize;
+                    if (tree.tokenTag(next_builtin_token) != .builtin) break;
+                    const builtin_name = tree.tokenSlice(next_builtin_token)[1..];
+                    const next_kind = meta.stringToEnum(CastKind, builtin_name) orelse break;
                     if (cast_map.contains(next_kind)) break :canonicalize;
                     cast_map.put(next_kind, next_builtin_token);
+                    next_builtin_token += 2;
                 }
 
                 var it = cast_map.iterator();
@@ -931,380 +953,61 @@ fn renderExpressionFixup(r: *Render, node: Ast.Node.Index, space: Space) Error!v
     }
 }
 
-/// Same as becomesMultilineExpr, but returns false when `node == .none`
-fn optBecomesMultilineExpr(tree: Ast, node: Ast.Node.OptionalIndex) bool {
-    return if (node.unwrap()) |payload| becomesMultilineExpr(tree, payload) else false;
-}
+fn drainNoNewline(w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize {
+    if (std.mem.indexOfScalar(u8, w.buffered(), '\n') != null) {
+        return error.WriteFailed;
+    }
 
-/// May return false if `node` is already multiline
-fn becomesMultilineExpr(tree: Ast, node: Ast.Node.Index) bool {
-    // Conditions related to comments, doc comments, and multiline string literals are ignored
-    // since they always go to the end of the line, which already make them a multi-line
-    // expression (since they contain a newline).
-    switch (tree.nodeTag(node)) {
-        .identifier,
-        .number_literal,
-        .char_literal,
-        .unreachable_literal,
-        .anyframe_literal,
-        .string_literal,
-        .multiline_string_literal,
-        .error_value,
-        .enum_literal,
-        => return false,
-        .container_decl_trailing,
-        .container_decl_arg_trailing,
-        .container_decl_two_trailing,
-        .tagged_union_trailing,
-        .tagged_union_enum_tag_trailing,
-        .tagged_union_two_trailing,
-        .switch_comma,
-        .builtin_call_two_comma,
-        .builtin_call_comma,
-        .call_one_comma,
-        .call_comma,
-        .struct_init_one_comma,
-        .struct_init_dot_two_comma,
-        .struct_init_dot_comma,
-        .struct_init_comma,
-        .array_init_one_comma,
-        .array_init_dot_two_comma,
-        .array_init_dot_comma,
-        .array_init_comma,
-        // The following always have a non-zero amount of members
-        // which is also the condition for them to be multi-line.
-        .block,
-        .block_semicolon,
-        => return true,
-        .block_two,
-        .block_two_semicolon,
-        => return tree.nodeData(node).opt_node_and_opt_node[0] != .none,
-        .container_decl,
-        .container_decl_arg,
-        .container_decl_two,
-        .tagged_union,
-        .tagged_union_enum_tag,
-        .tagged_union_two,
-        => {
-            var buf: [2]Ast.Node.Index = undefined;
-            const full = tree.fullContainerDecl(&buf, node).?;
-            if (full.ast.arg.unwrap()) |arg| {
-                if (becomesMultilineExpr(tree, arg))
-                    return true;
-            }
-            // This does the same checks as `isOneLineContainerDecl`, however it avoids unnecessary
-            // checks related to comments and multiline strings, which would mean the container is
-            // already multiple lines.
-            for (full.ast.members) |member| {
-                if (tree.fullContainerField(member)) |field_full| {
-                    for ([_]Ast.Node.OptionalIndex{
-                        field_full.ast.type_expr,
-                        field_full.ast.align_expr,
-                        field_full.ast.value_expr,
-                    }) |opt_expr| {
-                        if (opt_expr.unwrap()) |expr| {
-                            if (becomesMultilineExpr(tree, expr))
-                                return true;
-                        }
-                    }
-                } else return true;
-            }
-            return false;
-        },
-        .error_set_decl => {
-            const lbrace, const rbrace = tree.nodeData(node).token_and_token;
-            return !isOneLineErrorSetDecl(tree, lbrace, rbrace);
-        },
-        .@"switch" => {
-            const op, const extra_index = tree.nodeData(node).node_and_extra;
-            const case_range = tree.extraData(extra_index, Ast.Node.SubRange);
-            return @intFromEnum(case_range.end) - @intFromEnum(case_range.start) != 0 or
-                becomesMultilineExpr(tree, op);
-        },
-        .for_simple, .@"for" => {
-            const full = tree.fullFor(node).?;
-            if (becomesMultilineExpr(tree, full.ast.then_expr) or
-                optBecomesMultilineExpr(tree, full.ast.else_expr))
-                return true;
-
-            for (full.ast.inputs) |expr| {
-                if (if (tree.nodeTag(expr) == .for_range) blk: {
-                    const lhs, const rhs = tree.nodeData(expr).node_and_opt_node;
-                    break :blk becomesMultilineExpr(tree, lhs) or optBecomesMultilineExpr(tree, rhs);
-                } else becomesMultilineExpr(tree, expr))
-                    return true;
-            }
-            const final_input_expr = full.ast.inputs[full.ast.inputs.len - 1];
-            if (tree.tokenTag(tree.lastToken(final_input_expr) + 1) == .comma)
-                return true;
-
-            const token_tags = tree.tokens.items(.tag);
-            const payload = full.payload_token;
-            const pipe = std.mem.indexOfScalarPos(Token.Tag, token_tags, payload, .pipe).?;
-            return token_tags[@intCast(pipe - 1)] == .comma;
-        },
-        .while_simple,
-        .while_cont,
-        .@"while",
-        => {
-            const full = tree.fullWhile(node).?;
-            return becomesMultilineExpr(tree, full.ast.cond_expr) or
-                becomesMultilineExpr(tree, full.ast.then_expr) or
-                optBecomesMultilineExpr(tree, full.ast.cont_expr) or
-                optBecomesMultilineExpr(tree, full.ast.else_expr);
-        },
-        .if_simple,
-        .@"if",
-        => {
-            const full = tree.fullIf(node).?;
-            return becomesMultilineExpr(tree, full.ast.cond_expr) or
-                becomesMultilineExpr(tree, full.ast.then_expr) or
-                optBecomesMultilineExpr(tree, full.ast.else_expr);
-        },
-        .fn_proto_simple,
-        .fn_proto_multi,
-        .fn_proto_one,
-        .fn_proto,
-        => {
-            var buf: [1]Ast.Node.Index = undefined;
-            const fn_proto = tree.fullFnProto(&buf, node).?;
-
-            for ([_]Ast.Node.OptionalIndex{
-                fn_proto.ast.return_type,
-                fn_proto.ast.align_expr,
-                fn_proto.ast.addrspace_expr,
-                fn_proto.ast.section_expr,
-                fn_proto.ast.callconv_expr,
-            }) |opt_expr| {
-                if (opt_expr.unwrap()) |expr| {
-                    if (becomesMultilineExpr(tree, expr))
-                        return true;
-                }
-            }
-            for (fn_proto.ast.params) |expr| {
-                if (becomesMultilineExpr(tree, expr))
-                    return true;
-            }
+    var n: usize = 0;
+    for (data[0 .. data.len - 1]) |v| {
+        if (std.mem.indexOfScalar(u8, v, '\n') != null) {
+            return error.WriteFailed;
+        }
+        n += v.len;
+    }
 
-            const lparen = fn_proto.ast.fn_token + 1;
-            const return_type = fn_proto.ast.return_type.unwrap().?;
-            const maybe_bang = tree.firstToken(return_type) - 1;
-            const rparen = fnProtoRparen(tree, fn_proto, maybe_bang);
-            return !isOneLineFnProto(tree, fn_proto, lparen, rparen);
-        },
-        .asm_simple,
-        => {
-            const lhs = tree.nodeData(node).node_and_token[0];
-            return becomesMultilineExpr(tree, lhs);
-        },
-        .@"asm",
-        => {
-            const lhs, const extra_index = tree.nodeData(node).node_and_extra;
-            const asm_extra = tree.extraData(extra_index, Ast.Node.Asm);
-            return @intFromEnum(asm_extra.items_end) - @intFromEnum(asm_extra.items_start) != 0 or
-                becomesMultilineExpr(tree, lhs) or optBecomesMultilineExpr(tree, asm_extra.clobbers);
-        },
-        .array_type, .array_type_sentinel => {
-            const array_type = tree.fullArrayType(node).?;
-            const rbracket = tree.firstToken(array_type.ast.elem_type) - 1;
-            return !isOneLineArrayType(tree, array_type, rbracket) or
-                becomesMultilineExpr(tree, array_type.ast.elem_type);
-        },
-        .array_access => {
-            const lhs, const rhs = tree.nodeData(node).node_and_node;
-            const lbracket = tree.firstToken(rhs) - 1;
-            const rbracket = tree.lastToken(rhs) + 1;
-            return !tree.tokensOnSameLine(lbracket, rbracket) or
-                becomesMultilineExpr(tree, lhs) or
-                becomesMultilineExpr(tree, rhs);
-        },
-        .call_one,
-        .call,
-        .builtin_call_two,
-        .builtin_call,
-        .array_init_one,
-        .array_init_dot_two,
-        .array_init_dot,
-        .array_init,
-        .struct_init_one,
-        .struct_init_dot_two,
-        .struct_init_dot,
-        .struct_init,
-        => |tag| {
-            var buf: [2]Ast.Node.Index = undefined;
-            const opt_lhs: Ast.Node.OptionalIndex, const items = switch (tag) {
-                .call_one, .call => blk: {
-                    const full = tree.fullCall(buf[0..1], node).?;
-                    break :blk .{ full.ast.fn_expr.toOptional(), full.ast.params };
-                },
-                .builtin_call_two, .builtin_call => .{ .none, tree.builtinCallParams(&buf, node).? },
-                .array_init_one,
-                .array_init_dot_two,
-                .array_init_dot,
-                .array_init,
-                => blk: {
-                    const full = tree.fullArrayInit(&buf, node).?;
-                    break :blk .{ full.ast.type_expr, full.ast.elements };
-                },
-                .struct_init_one,
-                .struct_init_dot_two,
-                .struct_init_dot,
-                .struct_init,
-                => blk: {
-                    const full = tree.fullStructInit(&buf, node).?;
-                    break :blk .{ full.ast.type_expr, full.ast.fields };
-                },
-                else => unreachable,
-            };
-            if (opt_lhs.unwrap()) |lhs| {
-                if (becomesMultilineExpr(tree, lhs))
-                    return true;
-            }
-            for (items) |expr| {
-                if (becomesMultilineExpr(tree, expr))
-                    return true;
-            }
-            return false;
-        },
-        .assign_destructure => {
-            const full = tree.assignDestructure(node);
-            for (full.ast.variables) |expr| {
-                if (becomesMultilineExpr(tree, expr))
-                    return true;
-            }
-            return becomesMultilineExpr(tree, full.ast.value_expr);
-        },
-        .ptr_type_aligned,
-        .ptr_type_sentinel,
-        .ptr_type,
-        .ptr_type_bit_range,
-        => {
-            const full = tree.fullPtrType(node).?;
-            return becomesMultilineExpr(tree, full.ast.child_type) or
-                optBecomesMultilineExpr(tree, full.ast.sentinel) or
-                optBecomesMultilineExpr(tree, full.ast.align_node) or
-                optBecomesMultilineExpr(tree, full.ast.addrspace_node) or
-                optBecomesMultilineExpr(tree, full.ast.bit_range_start) or
-                optBecomesMultilineExpr(tree, full.ast.bit_range_end);
-        },
-        .slice_open,
-        .slice,
-        .slice_sentinel,
-        => {
-            const full = tree.fullSlice(node).?;
-            return becomesMultilineExpr(tree, full.ast.sliced) or
-                becomesMultilineExpr(tree, full.ast.start) or
-                optBecomesMultilineExpr(tree, full.ast.end) or
-                optBecomesMultilineExpr(tree, full.ast.sentinel);
-        },
-        .@"comptime",
-        .@"nosuspend",
-        .@"suspend",
-        .@"resume",
-        .bit_not,
-        .bool_not,
-        .negation,
-        .negation_wrap,
-        .optional_type,
-        .address_of,
-        .deref,
-        .@"try",
-        => return becomesMultilineExpr(tree, tree.nodeData(node).node),
-        .@"return" => return optBecomesMultilineExpr(tree, tree.nodeData(node).opt_node),
-        .field_access,
-        .unwrap_optional,
-        .grouped_expression,
-        => return becomesMultilineExpr(tree, tree.nodeData(node).node_and_token[0]),
-        .add,
-        .add_wrap,
-        .add_sat,
-        .array_cat,
-        .array_mult,
-        .bang_equal,
-        .bit_and,
-        .bit_or,
-        .shl,
-        .shl_sat,
-        .shr,
-        .bit_xor,
-        .bool_and,
-        .bool_or,
-        .div,
-        .equal_equal,
-        .greater_or_equal,
-        .greater_than,
-        .less_or_equal,
-        .less_than,
-        .merge_error_sets,
-        .mod,
-        .mul,
-        .mul_wrap,
-        .mul_sat,
-        .sub,
-        .sub_wrap,
-        .sub_sat,
-        .@"orelse",
-        .@"catch",
-        .error_union,
-        .assign,
-        .assign_bit_and,
-        .assign_bit_or,
-        .assign_shl,
-        .assign_shl_sat,
-        .assign_shr,
-        .assign_bit_xor,
-        .assign_div,
-        .assign_sub,
-        .assign_sub_wrap,
-        .assign_sub_sat,
-        .assign_mod,
-        .assign_add,
-        .assign_add_wrap,
-        .assign_add_sat,
-        .assign_mul,
-        .assign_mul_wrap,
-        .assign_mul_sat,
-        => {
-            const lhs, const rhs = tree.nodeData(node).node_and_node;
-            return becomesMultilineExpr(tree, lhs) or becomesMultilineExpr(tree, rhs);
-        },
-        .@"break", .@"continue" => {
-            const opt_expr = tree.nodeData(node).opt_token_and_opt_node[1];
-            return optBecomesMultilineExpr(tree, opt_expr);
-        },
-        .anyframe_type => return becomesMultilineExpr(tree, tree.nodeData(node).token_and_node[1]),
-        .@"errdefer",
-        .@"defer",
-        .for_range,
-        .switch_range,
-        .switch_case_one,
-        .switch_case_inline_one,
-        .switch_case,
-        .switch_case_inline,
-        .asm_output,
-        .asm_input,
-        .fn_decl,
-        .container_field,
-        .container_field_init,
-        .container_field_align,
-        .root,
-        .global_var_decl,
-        .local_var_decl,
-        .simple_var_decl,
-        .aligned_var_decl,
-        .test_decl,
-        => unreachable,
+    const pattern = data[data.len - 1];
+    if (splat != 0 and std.mem.indexOfScalar(u8, pattern, '\n') != null) {
+        return error.WriteFailed;
     }
+    n += pattern.len * splat;
+
+    w.end = 0;
+    return n;
 }
 
-fn isOneLineArrayType(
-    tree: Ast,
-    array_type: Ast.full.ArrayType,
-    rbracket: Ast.TokenIndex,
-) bool {
-    return tree.tokensOnSameLine(array_type.ast.lbracket, rbracket) and
-        !becomesMultilineExpr(tree, array_type.ast.elem_count) and
-        !optBecomesMultilineExpr(tree, array_type.ast.sentinel);
+fn rendersMultiline(r: *const Render, node: Ast.Node.Index) error{OutOfMemory}!bool {
+    var no_nl_buf: [64]u8 = undefined;
+    var no_nl_w: Writer = .{
+        .vtable = &.{ .drain = drainNoNewline },
+        .buffer = &no_nl_buf,
+    };
+
+    if (r.ais.disabled_offset != null) return true;
+    var sub_ais: AutoIndentingStream = .init(r.gpa, &no_nl_w, r.ais.indent_delta);
+    defer sub_ais.deinit();
+    // The following are needed to make sure isLineOverIndented is correct
+    sub_ais.indent_count = r.ais.indent_count;
+    sub_ais.applied_indent = r.ais.applied_indent;
+    sub_ais.current_line_empty = r.ais.current_line_empty;
+
+    var sub_r: Render = .{
+        .gpa = r.gpa,
+        .ais = &sub_ais,
+        .tree = r.tree,
+        .fixups = r.fixups,
+    };
+
+    renderExpression(&sub_r, node, .none) catch |e| return switch (e) {
+        error.OutOfMemory => return error.OutOfMemory,
+        error.WriteFailed => return true,
+    };
+    if (sub_ais.disabled_offset != null) return true;
+    if (std.mem.indexOfScalar(u8, no_nl_w.buffered(), '\n') != null) {
+        return true;
+    }
+
+    return false;
 }
 
 fn renderArrayType(
@@ -1315,7 +1018,9 @@ fn renderArrayType(
     const tree = r.tree;
     const ais = r.ais;
     const rbracket = tree.firstToken(array_type.ast.elem_type) - 1;
-    const one_line = isOneLineArrayType(tree, array_type, rbracket);
+    const one_line = tree.tokensOnSameLine(array_type.ast.lbracket, rbracket) and
+        !try rendersMultiline(r, array_type.ast.elem_count) and
+        (if (array_type.ast.sentinel.unwrap()) |s| !try rendersMultiline(r, s) else true);
     const inner_space = if (one_line) Space.none else Space.newline;
     try ais.pushIndent(.normal);
     try renderToken(r, array_type.ast.lbracket, inner_space); // lbracket
@@ -2094,7 +1799,7 @@ fn renderFnProto(r: *Render, fn_proto: Ast.full.FnProto, space: Space) Error!voi
                     break;
                 },
                 .keyword_noalias, .keyword_comptime => {
-                    try renderToken(r, last_param_token, .space);
+                    try renderToken(r, last_param_token, .maybe_space);
                     last_param_token += 1;
                 },
                 .identifier => {},
@@ -2145,7 +1850,7 @@ fn renderFnProto(r: *Render, fn_proto: Ast.full.FnProto, space: Space) Error!voi
                     break;
                 },
                 .keyword_noalias, .keyword_comptime => {
-                    try renderToken(r, last_param_token, .space);
+                    try renderToken(r, last_param_token, .maybe_space);
                     last_param_token += 1;
                 },
                 .identifier => {},
@@ -2163,7 +1868,7 @@ fn renderFnProto(r: *Render, fn_proto: Ast.full.FnProto, space: Space) Error!voi
             {
                 try renderIdentifier(r, last_param_token, .none, .preserve_when_shadowing); // name
                 last_param_token += 1;
-                try renderToken(r, last_param_token, .space); // :
+                try renderToken(r, last_param_token, .maybe_space); // :
                 last_param_token += 1;
             }
             if (tree.tokenTag(last_param_token) == .keyword_anytype) {
@@ -2504,6 +2209,10 @@ fn renderArrayInit(
             try renderSpace(&sub_r, after_expr, tokenSliceForRender(tree, after_expr).len, .none);
 
             buf.clearRetainingCapacity();
+            // The following are needed to make sure isLineOverIndented is not influenced by
+            // the previous element.
+            sub_ais.indent_count = 0;
+            sub_ais.applied_indent = 0;
         }
     }
 
@@ -2749,8 +2458,47 @@ fn renderAsm(
         try renderToken(r, asm_node.ast.asm_token + 1, .none); // lparen
     }
 
+    const render_colons: [3]?Ast.TokenIndex = colons: {
+        var colons: [3]Ast.TokenIndex = undefined;
+        var render: u2 = 0;
+
+        const rparen = asm_node.ast.rparen;
+        filled: {
+            colons[0] = tree.lastToken(asm_node.ast.template) + 1;
+            if (colons[0] == rparen) break :filled;
+
+            if (asm_node.outputs.len != 0) {
+                colons[1] = tree.lastToken(asm_node.outputs[asm_node.outputs.len - 1]) + 1;
+                colons[1] += @intFromBool(tree.tokenTag(colons[1]) == .comma);
+                render = 1;
+            } else {
+                colons[1] = colons[0] + 1;
+                if (hasComment(tree, colons[0], colons[1])) render = 1;
+            }
+            if (colons[1] == rparen) break :filled;
+
+            // Next colon is not checked for here since it cannot present without clobbers
+            if (asm_node.inputs.len != 0) {
+                render = 2;
+            } else {
+                const colon_or_rparen = colons[1] + 1;
+                if (hasComment(tree, colons[1], colon_or_rparen)) render = 2;
+            }
+
+            if (asm_node.ast.clobbers.unwrap()) |clobbers| {
+                colons[2] = tree.firstToken(clobbers) - 1;
+                render = 3;
+            }
+        }
+
+        var opt_colons: [3]?Ast.TokenIndex = @splat(null);
+        for (0..render) |i| opt_colons[i] = colons[i];
+        break :colons opt_colons;
+    };
+
+    try ais.forcePushIndent(.normal);
+
     if (asm_node.ast.items.len == 0) {
-        try ais.forcePushIndent(.normal);
         if (asm_node.ast.clobbers.unwrap()) |clobbers| {
             // asm ("foo" ::: clobbers)
             try renderExpression(r, asm_node.ast.template, .space);
@@ -2764,99 +2512,78 @@ fn renderAsm(
             return renderToken(r, asm_node.ast.rparen, space); // rparen
         }
 
-        // asm ("foo")
-        try renderExpression(r, asm_node.ast.template, .none);
-        ais.popIndent();
-        return renderToken(r, asm_node.ast.rparen, space); // rparen
+        if (render_colons[0] == null) {
+            // asm ("foo")
+            try renderExpression(r, asm_node.ast.template, .none);
+            ais.popIndent();
+            return renderToken(r, asm_node.ast.rparen, space); // rparen
+        }
     }
 
-    try ais.forcePushIndent(.normal);
     try renderExpression(r, asm_node.ast.template, .newline);
     ais.forceLastIndent(); // Might have been dedented by a multiline string literal
     assert(ais.current_line_empty);
 
+    const prev_indent_delta = ais.indent_delta; // May be part of another asm expression
+    // so indent_delta can't be unconditionally used
     ais.setIndentDelta(asm_indent_delta);
-    const colon1 = tree.lastToken(asm_node.ast.template) + 1;
 
-    const colon2 = if (asm_node.outputs.len == 0) colon2: {
-        try renderToken(r, colon1, .newline); // :
-        break :colon2 colon1 + 1;
-    } else colon2: {
-        try renderToken(r, colon1, .space); // :
+    rendered: {
+        if (render_colons[0]) |colon1| {
+            if (asm_node.outputs.len != 0) {
+                try renderToken(r, colon1, .space);
+                try ais.forcePushIndent(.normal);
 
-        try ais.forcePushIndent(.normal);
-        for (asm_node.outputs, 0..) |asm_output, i| {
-            if (i + 1 < asm_node.outputs.len) {
-                const next_asm_output = asm_node.outputs[i + 1];
-                try renderAsmOutput(r, asm_output, .none);
+                const final = asm_node.outputs.len - 1;
+                for (asm_node.outputs[0..final], 0..) |asm_output, i| {
+                    try renderAsmOutput(r, asm_output, .none);
+
+                    const next_start = tree.firstToken(asm_node.outputs[i + 1]);
+                    try renderToken(r, next_start - 1, .newline); // ,
+                    try renderExtraNewlineToken(r, next_start);
+                }
 
-                const comma = tree.firstToken(next_asm_output) - 1;
-                try renderToken(r, comma, .newline); // ,
-                try renderExtraNewlineToken(r, tree.firstToken(next_asm_output));
-            } else if (asm_node.inputs.len == 0 and asm_node.ast.clobbers == .none) {
                 try ais.pushSpace(.comma);
-                try renderAsmOutput(r, asm_output, .comma);
+                try renderAsmOutput(r, asm_node.outputs[final], .comma);
                 ais.popSpace();
                 ais.popIndent();
-                ais.setIndentDelta(indent_delta);
-                ais.popIndent();
-                return renderToken(r, asm_node.ast.rparen, space); // rparen
             } else {
-                try ais.pushSpace(.comma);
-                try renderAsmOutput(r, asm_output, .comma);
-                ais.popSpace();
-                const comma_or_colon = tree.lastToken(asm_output) + 1;
-                ais.popIndent();
-                break :colon2 switch (tree.tokenTag(comma_or_colon)) {
-                    .comma => comma_or_colon + 1,
-                    else => comma_or_colon,
-                };
+                try renderToken(r, colon1, .newline);
             }
         } else unreachable;
-    };
 
-    const colon3 = if (asm_node.inputs.len == 0) colon3: {
-        try renderToken(r, colon2, .newline); // :
-        break :colon3 colon2 + 1;
-    } else colon3: {
-        try renderToken(r, colon2, .space); // :
-        try ais.forcePushIndent(.normal);
-        for (asm_node.inputs, 0..) |asm_input, i| {
-            if (i + 1 < asm_node.inputs.len) {
-                const next_asm_input = asm_node.inputs[i + 1];
-                try renderAsmInput(r, asm_input, .none);
-
-                const first_token = tree.firstToken(next_asm_input);
-                try renderToken(r, first_token - 1, .newline); // ,
-                try renderExtraNewlineToken(r, first_token);
-            } else if (asm_node.ast.clobbers == .none) {
+        if (render_colons[1]) |colon2| {
+            if (asm_node.inputs.len != 0) {
+                try renderToken(r, colon2, .space);
+                try ais.forcePushIndent(.normal);
+
+                const final = asm_node.inputs.len - 1;
+                for (asm_node.inputs[0..final], 0..) |asm_input, i| {
+                    try renderAsmInput(r, asm_input, .none);
+
+                    const next_start = tree.firstToken(asm_node.inputs[i + 1]);
+                    try renderToken(r, next_start - 1, .newline); // ,
+                    try renderExtraNewlineToken(r, next_start);
+                }
+
                 try ais.pushSpace(.comma);
-                try renderAsmInput(r, asm_input, .comma);
+                try renderAsmInput(r, asm_node.inputs[final], .comma);
                 ais.popSpace();
                 ais.popIndent();
-                ais.setIndentDelta(indent_delta);
-                ais.popIndent();
-                return renderToken(r, asm_node.ast.rparen, space); // rparen
             } else {
-                try ais.pushSpace(.comma);
-                try renderAsmInput(r, asm_input, .comma);
-                ais.popSpace();
-                const comma_or_colon = tree.lastToken(asm_input) + 1;
-                ais.popIndent();
-                break :colon3 switch (tree.tokenTag(comma_or_colon)) {
-                    .comma => comma_or_colon + 1,
-                    else => comma_or_colon,
-                };
+                try renderToken(r, colon2, .newline);
             }
+        } else break :rendered;
+
+        if (render_colons[2]) |colon3| {
+            const clobbers = asm_node.ast.clobbers.unwrap().?;
+            try renderToken(r, colon3, .maybe_space);
+            try renderExpression(r, clobbers, .none);
+            ais.forceLastIndent(); // Might have been dedented by a multiline string literal
         }
-        unreachable;
-    };
+    }
 
-    try renderToken(r, colon3, .maybe_space); // :
-    const clobbers = asm_node.ast.clobbers.unwrap().?;
-    try renderExpression(r, clobbers, .none);
-    ais.forceLastIndent(); // Might have been dedented by a multiline string literal
-    ais.setIndentDelta(indent_delta);
+    ais.setIndentDelta(prev_indent_delta);
     ais.popIndent();
     return renderToken(r, asm_node.ast.rparen, space); // rparen
 }
@@ -3324,6 +3051,7 @@ fn renderComments(r: *Render, start: usize, end: usize) Error!bool {
             // Write with the canonical single space.
             try ais.underlying_writer.writeAll("// zig fmt: on\n");
             ais.disabled_offset = null;
+            ais.resetLine();
         } else if (ais.disabled_offset == null and mem.eql(u8, comment_content, "zig fmt: off")) {
             // Write with the canonical single space.
             try ais.writeAll("// zig fmt: off\n");