ran zig fmt on stdlib

Author: emekoi

std/debug.zig

@@ -1490,14 +1490,16 @@ fn parseFormValueTargetAddrSize(in_stream: var) !u64 {
 }
 
 fn parseFormValueRef(allocator: *mem.Allocator, in_stream: var, size: i32) !FormValue {
-    return FormValue{ .Ref = switch (size) {
-        1 => try in_stream.readIntLittle(u8),
-        2 => try in_stream.readIntLittle(u16),
-        4 => try in_stream.readIntLittle(u32),
-        8 => try in_stream.readIntLittle(u64),
-        -1 => try leb.readULEB128(u64, in_stream),
-        else => unreachable,
-    } };
+    return FormValue{
+        .Ref = switch (size) {
+            1 => try in_stream.readIntLittle(u8),
+            2 => try in_stream.readIntLittle(u16),
+            4 => try in_stream.readIntLittle(u32),
+            8 => try in_stream.readIntLittle(u64),
+            -1 => try leb.readULEB128(u64, in_stream),
+            else => unreachable,
+        },
+    };
 }
 
 fn parseFormValue(allocator: *mem.Allocator, in_stream: var, form_id: u64, is_64: bool) anyerror!FormValue {

std/io.zig

@@ -1116,10 +1116,12 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
         pub const Stream = InStream(Error);
 
         pub fn init(in_stream: *Stream) Self {
-            return Self{ .in_stream = switch (packing) {
-                .Bit => BitInStream(endian, Stream.Error).init(in_stream),
-                .Byte => in_stream,
-            } };
+            return Self{
+                .in_stream = switch (packing) {
+                    .Bit => BitInStream(endian, Stream.Error).init(in_stream),
+                    .Byte => in_stream,
+                },
+            };
         }
 
         pub fn alignToByte(self: *Self) void {
@@ -1325,10 +1327,12 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
         pub const Stream = OutStream(Error);
 
         pub fn init(out_stream: *Stream) Self {
-            return Self{ .out_stream = switch (packing) {
-                .Bit => BitOutStream(endian, Stream.Error).init(out_stream),
-                .Byte => out_stream,
-            } };
+            return Self{
+                .out_stream = switch (packing) {
+                    .Bit => BitOutStream(endian, Stream.Error).init(out_stream),
+                    .Byte => out_stream,
+                },
+            };
         }
 
         /// Flushes any unwritten bits to the stream

std/os/linux/tls.zig

@@ -114,7 +114,7 @@ pub fn setThreadPointer(addr: usize) void {
         .aarch64 => {
             asm volatile (
                 \\ msr tpidr_el0, %[addr]
-                            :
+                :
                 : [addr] "r" (addr)
             );
         },

std/special/bootstrap.zig

@@ -8,7 +8,10 @@ const assert = std.debug.assert;
 
 var argc_ptr: [*]usize = undefined;
 
-const is_wasm = switch (builtin.arch) { .wasm32, .wasm64 => true, else => false};
+const is_wasm = switch (builtin.arch) {
+    .wasm32, .wasm64 => true,
+    else => false,
+};
 
 comptime {
     if (builtin.link_libc) {

std/special/c.zig

@@ -8,8 +8,14 @@ const std = @import("std");
 const builtin = @import("builtin");
 const maxInt = std.math.maxInt;
 
-const is_wasm = switch (builtin.arch) { .wasm32, .wasm64 => true, else => false};
-const is_freestanding = switch (builtin.os) { .freestanding => true, else => false };
+const is_wasm = switch (builtin.arch) {
+    .wasm32, .wasm64 => true,
+    else => false,
+};
+const is_freestanding = switch (builtin.os) {
+    .freestanding => true,
+    else => false,
+};
 comptime {
     if (is_freestanding and is_wasm and builtin.link_libc) {
         @export("_start", wasm_start, .Strong);

std/special/compiler_rt/extendXfYf2.zig

@@ -76,7 +76,7 @@ fn extendXfYf2(comptime dst_t: type, comptime src_t: type, a: @IntType(false, @t
         // renormalize the significand and clear the leading bit, then insert
         // the correct adjusted exponent in the destination type.
         const scale: u32 = @clz(src_rep_t, aAbs) -
-                           @clz(src_rep_t, src_rep_t(srcMinNormal));
+            @clz(src_rep_t, src_rep_t(srcMinNormal));
         absResult = dst_rep_t(aAbs) << @intCast(DstShift, dstSigBits - srcSigBits + scale);
         absResult ^= dstMinNormal;
         const resultExponent: u32 = dstExpBias - srcExpBias - scale + 1;

std/valgrind/callgrind.zig

@@ -10,70 +10,48 @@ pub const CallgrindClientRequest = extern enum {
     StopInstrumentation,
 };
 
-fn doCallgrindClientRequestExpr(default: usize, request: CallgrindClientRequest,
-        a1: usize, a2: usize, a3: usize, a4: usize, a5: usize
-    ) usize
-{
-    return valgrind.doClientRequest(
-        default,
-        @intCast(usize, @enumToInt(request)),
-        a1, a2, a3, a4, a5);
+fn doCallgrindClientRequestExpr(default: usize, request: CallgrindClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize {
+    return valgrind.doClientRequest(default, @intCast(usize, @enumToInt(request)), a1, a2, a3, a4, a5);
 }
 
-fn doCallgrindClientRequestStmt(request: CallgrindClientRequest,
-        a1: usize, a2: usize, a3: usize, a4: usize, a5: usize
-    ) void
-{
+fn doCallgrindClientRequestStmt(request: CallgrindClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) void {
     _ = doCallgrindClientRequestExpr(0, request, a1, a2, a3, a4, a5);
 }
 
-
-
 /// Dump current state of cost centers, and zero them afterwards
 pub fn dumpStats() void {
-    doCallgrindClientRequestStmt(CallgrindClientRequest.DumpStats,
-        0, 0, 0, 0, 0);
+    doCallgrindClientRequestStmt(CallgrindClientRequest.DumpStats, 0, 0, 0, 0, 0);
 }
 
-
 /// Dump current state of cost centers, and zero them afterwards.
 /// The argument is appended to a string stating the reason which triggered
 /// the dump. This string is written as a description field into the
 /// profile data dump.
 pub fn dumpStatsAt(pos_str: [*]u8) void {
-    doCallgrindClientRequestStmt(CallgrindClientRequest.DumpStatsAt,
-        @ptrToInt(pos_str),
-        0, 0, 0, 0);
+    doCallgrindClientRequestStmt(CallgrindClientRequest.DumpStatsAt, @ptrToInt(pos_str), 0, 0, 0, 0);
 }
 
-
 /// Zero cost centers
 pub fn zeroStats() void {
-    doCallgrindClientRequestStmt(CallgrindClientRequest.ZeroStats,
-        0, 0, 0, 0, 0);
+    doCallgrindClientRequestStmt(CallgrindClientRequest.ZeroStats, 0, 0, 0, 0, 0);
 }
 
-
 /// Toggles collection state.
 /// The collection state specifies whether the happening of events
 /// should be noted or if they are to be ignored. Events are noted
 /// by increment of counters in a cost center
 pub fn toggleCollect() void {
-    doCallgrindClientRequestStmt(CallgrindClientRequest.ToggleCollect,
-        0, 0, 0, 0, 0);
+    doCallgrindClientRequestStmt(CallgrindClientRequest.ToggleCollect, 0, 0, 0, 0, 0);
 }
 
-
 /// Start full callgrind instrumentation if not already switched on.
 /// When cache simulation is done, it will flush the simulated cache;
 /// this will lead to an artificial cache warmup phase afterwards with
 /// cache misses which would not have happened in reality.
 pub fn startInstrumentation() void {
-    doCallgrindClientRequestStmt(CallgrindClientRequest.StartInstrumentation,
-        0, 0, 0, 0, 0);
+    doCallgrindClientRequestStmt(CallgrindClientRequest.StartInstrumentation, 0, 0, 0, 0, 0);
 }
 
-
 /// Stop full callgrind instrumentation if not already switched off.
 /// This flushes Valgrinds translation cache, and does no additional
 /// instrumentation afterwards, which effectivly will run at the same
@@ -82,6 +60,5 @@ pub fn startInstrumentation() void {
 /// To start Callgrind in this mode to ignore the setup phase, use
 /// the option "--instr-atstart=no".
 pub fn stopInstrumentation() void {
-    doCallgrindClientRequestStmt(CallgrindClientRequest.StopInstrumentation,
-        0, 0, 0, 0, 0);
+    doCallgrindClientRequestStmt(CallgrindClientRequest.StopInstrumentation, 0, 0, 0, 0, 0);
 }