Merge pull request ziglang#21727 from 87flowers/fmt-render2

std/zig/render: Rewrite indentation

Author: andrewrk

lib/compiler/aro/aro/Parser.zig

@@ -979,7 +979,7 @@ fn decl(p: *Parser) Error!bool {
         _ = try p.expectToken(.semicolon);
         if (decl_spec.ty.is(.@"enum") or
             (decl_spec.ty.isRecord() and !decl_spec.ty.isAnonymousRecord(p.comp) and
-            !decl_spec.ty.isTypeof())) // we follow GCC and clang's behavior here
+                !decl_spec.ty.isTypeof())) // we follow GCC and clang's behavior here
         {
             const specifier = decl_spec.ty.canonicalize(.standard).specifier;
             const attrs = p.attr_buf.items(.attr)[attr_buf_top..];

lib/compiler/aro/aro/pragmas/gcc.zig

@@ -114,9 +114,9 @@ fn preprocessorHandler(pragma: *Pragma, pp: *Preprocessor, start_idx: TokenIndex
 
     const gcc_pragma = std.meta.stringToEnum(Directive, pp.expandedSlice(directive_tok)) orelse
         return pp.comp.addDiagnostic(.{
-        .tag = .unknown_gcc_pragma,
-        .loc = directive_tok.loc,
-    }, pp.expansionSlice(start_idx + 1));
+            .tag = .unknown_gcc_pragma,
+            .loc = directive_tok.loc,
+        }, pp.expansionSlice(start_idx + 1));
 
     switch (gcc_pragma) {
         .warning, .@"error" => {

lib/compiler/resinator/lang.zig

@@ -255,7 +255,7 @@ pub fn parse(lang_tag: []const u8) error{InvalidLanguageTag}!Parsed {
         // Special case for qps-ploca and qps-plocm
         else if (std.ascii.eqlIgnoreCase(lang_code, "qps") and
             (std.ascii.eqlIgnoreCase(part_str, "ploca") or
-            std.ascii.eqlIgnoreCase(part_str, "plocm")))
+                std.ascii.eqlIgnoreCase(part_str, "plocm")))
         {
             parsed.suffix = part_str;
         } else {

lib/compiler_rt/count0bits.zig

@@ -143,7 +143,7 @@ pub const __clzsi2 = switch (builtin.cpu.arch) {
     .arm, .armeb, .thumb, .thumbeb => impl: {
         const use_thumb1 =
             (builtin.cpu.arch.isThumb() or
-            std.Target.arm.featureSetHas(builtin.cpu.features, .noarm)) and
+                std.Target.arm.featureSetHas(builtin.cpu.features, .noarm)) and
             !std.Target.arm.featureSetHas(builtin.cpu.features, .thumb2);
 
         if (use_thumb1) {

lib/compiler_rt/int.zig

@@ -81,19 +81,19 @@ fn test_one_divmoddi4(a: i64, b: i64, expected_q: i64, expected_r: i64) !void {
 
 const cases__divmoddi4 =
     [_][4]i64{
-    [_]i64{ 0, 1, 0, 0 },
-    [_]i64{ 0, -1, 0, 0 },
-    [_]i64{ 2, 1, 2, 0 },
-    [_]i64{ 2, -1, -2, 0 },
-    [_]i64{ -2, 1, -2, 0 },
-    [_]i64{ -2, -1, 2, 0 },
-    [_]i64{ 7, 5, 1, 2 },
-    [_]i64{ -7, 5, -1, -2 },
-    [_]i64{ 19, 5, 3, 4 },
-    [_]i64{ 19, -5, -3, 4 },
-    [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000000))), 8, @as(i64, @bitCast(@as(u64, 0xf000000000000000))), 0 },
-    [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000007))), 8, @as(i64, @bitCast(@as(u64, 0xf000000000000001))), -1 },
-};
+        [_]i64{ 0, 1, 0, 0 },
+        [_]i64{ 0, -1, 0, 0 },
+        [_]i64{ 2, 1, 2, 0 },
+        [_]i64{ 2, -1, -2, 0 },
+        [_]i64{ -2, 1, -2, 0 },
+        [_]i64{ -2, -1, 2, 0 },
+        [_]i64{ 7, 5, 1, 2 },
+        [_]i64{ -7, 5, -1, -2 },
+        [_]i64{ 19, 5, 3, 4 },
+        [_]i64{ 19, -5, -3, 4 },
+        [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000000))), 8, @as(i64, @bitCast(@as(u64, 0xf000000000000000))), 0 },
+        [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000007))), 8, @as(i64, @bitCast(@as(u64, 0xf000000000000001))), -1 },
+    };
 
 test "test_divmoddi4" {
     for (cases__divmoddi4) |case| {
@@ -215,19 +215,19 @@ pub fn __divmodsi4(a: i32, b: i32, rem: *i32) callconv(.C) i32 {
 
 const cases__divmodsi4 =
     [_][4]i32{
-    [_]i32{ 0, 1, 0, 0 },
-    [_]i32{ 0, -1, 0, 0 },
-    [_]i32{ 2, 1, 2, 0 },
-    [_]i32{ 2, -1, -2, 0 },
-    [_]i32{ -2, 1, -2, 0 },
-    [_]i32{ -2, -1, 2, 0 },
-    [_]i32{ 7, 5, 1, 2 },
-    [_]i32{ -7, 5, -1, -2 },
-    [_]i32{ 19, 5, 3, 4 },
-    [_]i32{ 19, -5, -3, 4 },
-    [_]i32{ @bitCast(@as(u32, 0x80000000)), 8, @bitCast(@as(u32, 0xf0000000)), 0 },
-    [_]i32{ @bitCast(@as(u32, 0x80000007)), 8, @bitCast(@as(u32, 0xf0000001)), -1 },
-};
+        [_]i32{ 0, 1, 0, 0 },
+        [_]i32{ 0, -1, 0, 0 },
+        [_]i32{ 2, 1, 2, 0 },
+        [_]i32{ 2, -1, -2, 0 },
+        [_]i32{ -2, 1, -2, 0 },
+        [_]i32{ -2, -1, 2, 0 },
+        [_]i32{ 7, 5, 1, 2 },
+        [_]i32{ -7, 5, -1, -2 },
+        [_]i32{ 19, 5, 3, 4 },
+        [_]i32{ 19, -5, -3, 4 },
+        [_]i32{ @bitCast(@as(u32, 0x80000000)), 8, @bitCast(@as(u32, 0xf0000000)), 0 },
+        [_]i32{ @bitCast(@as(u32, 0x80000007)), 8, @bitCast(@as(u32, 0xf0000001)), -1 },
+    };
 
 fn test_one_divmodsi4(a: i32, b: i32, expected_q: i32, expected_r: i32) !void {
     var r: i32 = undefined;

lib/compiler_rt/popcount.zig

@@ -40,7 +40,7 @@ inline fn popcountXi2(comptime ST: type, a: ST) i32 {
     var x: UT = @bitCast(a);
     x -= (x >> 1) & (~@as(UT, 0) / 3); // 0x55...55, aggregate duos
     x = ((x >> 2) & (~@as(UT, 0) / 5)) // 0x33...33, aggregate nibbles
-    + (x & (~@as(UT, 0) / 5));
+        + (x & (~@as(UT, 0) / 5));
     x += x >> 4;
     x &= ~@as(UT, 0) / 17; // 0x0F...0F, aggregate bytes
     // 8 most significant bits of x + (x<<8) + (x<<16) + ..

lib/docs/wasm/markdown/Parser.zig

@@ -374,7 +374,7 @@ fn appendBlockStart(p: *Parser, block_start: BlockStart) !void {
         // or not of the same marker type.
         const should_close_list = last_pending_block.tag == .list and
             (block_start.tag != .list_item or
-            block_start.data.list_item.marker != last_pending_block.data.list.marker);
+                block_start.data.list_item.marker != last_pending_block.data.list.marker);
         // The last block should also be closed if the new block is not a table
         // row, which is the only allowed child of a table.
         const should_close_table = last_pending_block.tag == .table and

lib/std/Target.zig

@@ -299,7 +299,7 @@ pub const Os = struct {
         pub fn parse(str: []const u8) !WindowsVersion {
             return std.meta.stringToEnum(WindowsVersion, str) orelse
                 @enumFromInt(std.fmt.parseInt(u32, str, 0) catch
-                return error.InvalidOperatingSystemVersion);
+                    return error.InvalidOperatingSystemVersion);
         }
 
         /// This function is defined to serialize a Zig source code representation of this

lib/std/c.zig

@@ -9879,10 +9879,10 @@ pub extern "c" fn setlocale(category: LC, locale: ?[*:0]const u8) ?[*:0]const u8
 
 pub const getcontext = if (builtin.target.abi.isAndroid() or builtin.target.os.tag == .openbsd)
 {} // android bionic and openbsd libc does not implement getcontext
-else if (native_os == .linux and builtin.target.abi.isMusl())
-    linux.getcontext
-else
-    private.getcontext;
+    else if (native_os == .linux and builtin.target.abi.isMusl())
+        linux.getcontext
+    else
+        private.getcontext;
 
 pub const max_align_t = if (native_abi == .msvc or native_abi == .itanium)
     f64

lib/std/crypto/tls/Client.zig

@@ -692,7 +692,7 @@ pub fn init(stream: anytype, options: Options) InitError(@TypeOf(stream))!Client
                         const client_key_exchange_msg = .{@intFromEnum(tls.ContentType.handshake)} ++
                             int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
                             array(u16, u8, .{@intFromEnum(tls.HandshakeType.client_key_exchange)} ++
-                            array(u24, u8, array(u8, u8, key_share.secp256r1_kp.public_key.toUncompressedSec1())));
+                                array(u24, u8, array(u8, u8, key_share.secp256r1_kp.public_key.toUncompressedSec1())));
                         const client_change_cipher_spec_msg = .{@intFromEnum(tls.ContentType.change_cipher_spec)} ++
                             int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
                             array(u16, tls.ChangeCipherSpecType, .{.change_cipher_spec});
@@ -720,11 +720,11 @@ pub fn init(stream: anytype, options: Options) InitError(@TypeOf(stream))!Client
                                 );
                                 const client_verify_cleartext = .{@intFromEnum(tls.HandshakeType.finished)} ++
                                     array(u24, u8, hmacExpandLabel(
-                                    P.Hmac,
-                                    &master_secret,
-                                    &.{ "client finished", &p.transcript_hash.peek() },
-                                    P.verify_data_length,
-                                ));
+                                        P.Hmac,
+                                        &master_secret,
+                                        &.{ "client finished", &p.transcript_hash.peek() },
+                                        P.verify_data_length,
+                                    ));
                                 p.transcript_hash.update(&client_verify_cleartext);
                                 p.version = .{ .tls_1_2 = .{
                                     .expected_server_verify_data = hmacExpandLabel(
@@ -745,7 +745,7 @@ pub fn init(stream: anytype, options: Options) InitError(@TypeOf(stream))!Client
                                 var client_verify_msg = .{@intFromEnum(tls.ContentType.handshake)} ++
                                     int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
                                     array(u16, u8, nonce[P.fixed_iv_length..].* ++
-                                    @as([client_verify_cleartext.len + P.mac_length]u8, undefined));
+                                        @as([client_verify_cleartext.len + P.mac_length]u8, undefined));
                                 P.AEAD.encrypt(
                                     client_verify_msg[client_verify_msg.len - P.mac_length -
                                         client_verify_cleartext.len ..][0..client_verify_cleartext.len],