Fix remaining variadic formatted prints

Used a series of regex searches to try to find as many instances of the old pattern as I could and update them.

13 files changed, 23 insertions, 23 deletions

diff --git a/lib/std/special/c.zig b/lib/std/special/c.zig
index 604bfd277a..581a004e86 100644
--- a/lib/std/special/c.zig
+++ b/lib/std/special/c.zig
@@ -81,7 +81,7 @@ test "strncmp" {
 pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
     if (builtin.is_test) {
         @setCold(true);
-        std.debug.panic("{}", msg);
+        std.debug.panic("{}", .{msg});
     }
     if (builtin.os != .freestanding and builtin.os != .other) {
         std.os.abort();
diff --git a/lib/std/special/compiler_rt.zig b/lib/std/special/compiler_rt.zig
index efa21d6cd7..6a2f11e1aa 100644
--- a/lib/std/special/compiler_rt.zig
+++ b/lib/std/special/compiler_rt.zig
@@ -308,7 +308,7 @@ const __udivmoddi4 = @import("compiler_rt/udivmoddi4.zig").__udivmoddi4;
 pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
     @setCold(true);
     if (is_test) {
-        std.debug.panic("{}", msg);
+        std.debug.panic("{}", .{msg});
     } else {
         unreachable;
     }
diff --git a/lib/std/special/compiler_rt/ashrti3_test.zig b/lib/std/special/compiler_rt/ashrti3_test.zig
index ad3164be8d..6a7565e557 100644
--- a/lib/std/special/compiler_rt/ashrti3_test.zig
+++ b/lib/std/special/compiler_rt/ashrti3_test.zig
@@ -3,8 +3,8 @@ const testing = @import("std").testing;
 
 fn test__ashrti3(a: i128, b: i32, expected: i128) void {
     const x = __ashrti3(a, b);
-    // @import("std").debug.warn("got 0x{x}\nexp 0x{x}\n", @truncate(u64,
-    // @bitCast(u128, x) >> 64), @truncate(u64, @bitCast(u128, expected)) >> 64);
+    // @import("std").debug.warn("got 0x{x}\nexp 0x{x}\n", .{@truncate(u64,
+    // @bitCast(u128, x) >> 64), @truncate(u64, @bitCast(u128, expected)) >> 64});
     testing.expect(x == expected);
 }
 
diff --git a/lib/std/special/compiler_rt/fixdfdi_test.zig b/lib/std/special/compiler_rt/fixdfdi_test.zig
index e06d641824..92dbdc2a5e 100644
--- a/lib/std/special/compiler_rt/fixdfdi_test.zig
+++ b/lib/std/special/compiler_rt/fixdfdi_test.zig
@@ -6,12 +6,12 @@ const warn = std.debug.warn;
 
 fn test__fixdfdi(a: f64, expected: i64) void {
     const x = __fixdfdi(a);
-    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u64, expected));
+    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u64, expected)});
     testing.expect(x == expected);
 }
 
 test "fixdfdi" {
-    //warn("\n");
+    //warn("\n", .{});
     test__fixdfdi(-math.f64_max, math.minInt(i64));
 
     test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
diff --git a/lib/std/special/compiler_rt/fixdfsi_test.zig b/lib/std/special/compiler_rt/fixdfsi_test.zig
index da53468c7d..fb90518892 100644
--- a/lib/std/special/compiler_rt/fixdfsi_test.zig
+++ b/lib/std/special/compiler_rt/fixdfsi_test.zig
@@ -6,12 +6,12 @@ const warn = std.debug.warn;
 
 fn test__fixdfsi(a: f64, expected: i32) void {
     const x = __fixdfsi(a);
-    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u32, expected));
+    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u32, expected)});
     testing.expect(x == expected);
 }
 
 test "fixdfsi" {
-    //warn("\n");
+    //warn("\n", .{});
     test__fixdfsi(-math.f64_max, math.minInt(i32));
 
     test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
diff --git a/lib/std/special/compiler_rt/fixdfti_test.zig b/lib/std/special/compiler_rt/fixdfti_test.zig
index b0c9049ba8..f66e4a3d88 100644
--- a/lib/std/special/compiler_rt/fixdfti_test.zig
+++ b/lib/std/special/compiler_rt/fixdfti_test.zig
@@ -6,12 +6,12 @@ const warn = std.debug.warn;
 
 fn test__fixdfti(a: f64, expected: i128) void {
     const x = __fixdfti(a);
-    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u128, expected));
+    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u128, expected)});
     testing.expect(x == expected);
 }
 
 test "fixdfti" {
-    //warn("\n");
+    //warn("\n", .{});
     test__fixdfti(-math.f64_max, math.minInt(i128));
 
     test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
diff --git a/lib/std/special/compiler_rt/fixint_test.zig b/lib/std/special/compiler_rt/fixint_test.zig
index d5f7b3898d..4efb1e6ab3 100644
--- a/lib/std/special/compiler_rt/fixint_test.zig
+++ b/lib/std/special/compiler_rt/fixint_test.zig
@@ -8,7 +8,7 @@ const fixint = @import("fixint.zig").fixint;
 
 fn test__fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t, expected: fixint_t) void {
     const x = fixint(fp_t, fixint_t, a);
-    //warn("a={} x={}:{x} expected={}:{x})\n", a, x, x, expected, expected);
+    //warn("a={} x={}:{x} expected={}:{x})\n", .{a, x, x, expected, expected});
     testing.expect(x == expected);
 }
 
diff --git a/lib/std/special/compiler_rt/fixsfdi_test.zig b/lib/std/special/compiler_rt/fixsfdi_test.zig
index 02844946a7..5888c9804d 100644
--- a/lib/std/special/compiler_rt/fixsfdi_test.zig
+++ b/lib/std/special/compiler_rt/fixsfdi_test.zig
@@ -6,12 +6,12 @@ const warn = std.debug.warn;
 
 fn test__fixsfdi(a: f32, expected: i64) void {
     const x = __fixsfdi(a);
-    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u64, expected));
+    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u64, expected)});
     testing.expect(x == expected);
 }
 
 test "fixsfdi" {
-    //warn("\n");
+    //warn("\n", .{});
     test__fixsfdi(-math.f32_max, math.minInt(i64));
 
     test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
diff --git a/lib/std/special/compiler_rt/fixsfsi_test.zig b/lib/std/special/compiler_rt/fixsfsi_test.zig
index 69d8309de0..844235bc9d 100644
--- a/lib/std/special/compiler_rt/fixsfsi_test.zig
+++ b/lib/std/special/compiler_rt/fixsfsi_test.zig
@@ -6,12 +6,12 @@ const warn = std.debug.warn;
 
 fn test__fixsfsi(a: f32, expected: i32) void {
     const x = __fixsfsi(a);
-    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u32, expected));
+    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u32, expected)});
     testing.expect(x == expected);
 }
 
 test "fixsfsi" {
-    //warn("\n");
+    //warn("\n", .{});
     test__fixsfsi(-math.f32_max, math.minInt(i32));
 
     test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
diff --git a/lib/std/special/compiler_rt/fixsfti_test.zig b/lib/std/special/compiler_rt/fixsfti_test.zig
index cecfeda557..9eb2883f38 100644
--- a/lib/std/special/compiler_rt/fixsfti_test.zig
+++ b/lib/std/special/compiler_rt/fixsfti_test.zig
@@ -6,12 +6,12 @@ const warn = std.debug.warn;
 
 fn test__fixsfti(a: f32, expected: i128) void {
     const x = __fixsfti(a);
-    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u128, expected));
+    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u128, expected)});
     testing.expect(x == expected);
 }
 
 test "fixsfti" {
-    //warn("\n");
+    //warn("\n", .{});
     test__fixsfti(-math.f32_max, math.minInt(i128));
 
     test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
diff --git a/lib/std/special/compiler_rt/fixtfdi_test.zig b/lib/std/special/compiler_rt/fixtfdi_test.zig
index b45001e18e..6baa9011c3 100644
--- a/lib/std/special/compiler_rt/fixtfdi_test.zig
+++ b/lib/std/special/compiler_rt/fixtfdi_test.zig
@@ -6,12 +6,12 @@ const warn = std.debug.warn;
 
 fn test__fixtfdi(a: f128, expected: i64) void {
     const x = __fixtfdi(a);
-    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u64, expected));
+    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u64, expected)});
     testing.expect(x == expected);
 }
 
 test "fixtfdi" {
-    //warn("\n");
+    //warn("\n", .{});
     test__fixtfdi(-math.f128_max, math.minInt(i64));
 
     test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
diff --git a/lib/std/special/compiler_rt/fixtfsi_test.zig b/lib/std/special/compiler_rt/fixtfsi_test.zig
index c6f6623995..c7294fe250 100644
--- a/lib/std/special/compiler_rt/fixtfsi_test.zig
+++ b/lib/std/special/compiler_rt/fixtfsi_test.zig
@@ -6,12 +6,12 @@ const warn = std.debug.warn;
 
 fn test__fixtfsi(a: f128, expected: i32) void {
     const x = __fixtfsi(a);
-    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u32, expected));
+    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u32, expected)});
     testing.expect(x == expected);
 }
 
 test "fixtfsi" {
-    //warn("\n");
+    //warn("\n", .{});
     test__fixtfsi(-math.f128_max, math.minInt(i32));
 
     test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
diff --git a/lib/std/special/compiler_rt/fixtfti_test.zig b/lib/std/special/compiler_rt/fixtfti_test.zig
index b36c5beb4e..6b8218e2f6 100644
--- a/lib/std/special/compiler_rt/fixtfti_test.zig
+++ b/lib/std/special/compiler_rt/fixtfti_test.zig
@@ -6,12 +6,12 @@ const warn = std.debug.warn;
 
 fn test__fixtfti(a: f128, expected: i128) void {
     const x = __fixtfti(a);
-    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u128, expected));
+    //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u128, expected)});
     testing.expect(x == expected);
 }
 
 test "fixtfti" {
-    //warn("\n");
+    //warn("\n", .{});
     test__fixtfti(-math.f128_max, math.minInt(i128));
 
     test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));