Commit 640e09183d3100c477a26c6cdc26f1eae31472a1 | zig

build.zig+5-5

...	@@ -154,7 +154,7 @@ fn dependOnLib(b: *Builder, lib_exe_obj: var, dep: LibraryDep) void {	...	@@ -154,7 +154,7 @@ fn dependOnLib(b: *Builder, lib_exe_obj: var, dep: LibraryDep) void {
154	const static_bare_name = if (mem.eql(u8, lib, "curses"))	154	const static_bare_name = if (mem.eql(u8, lib, "curses"))
155	@as([]const u8, "libncurses.a")	155	@as([]const u8, "libncurses.a")
156	else	156	else
157	b.fmt("lib{}.a", lib);	157	b.fmt("lib{}.a", .{lib});
158	const static_lib_name = fs.path.join(	158	const static_lib_name = fs.path.join(
159	b.allocator,	159	b.allocator,
160	&[_][]const u8{ lib_dir, static_bare_name },	160	&[_][]const u8{ lib_dir, static_bare_name },
...	@@ -186,7 +186,7 @@ fn addCppLib(b: *Builder, lib_exe_obj: var, cmake_binary_dir: []const u8, lib_na	...	@@ -186,7 +186,7 @@ fn addCppLib(b: *Builder, lib_exe_obj: var, cmake_binary_dir: []const u8, lib_na
186	lib_exe_obj.addObjectFile(fs.path.join(b.allocator, &[_][]const u8{	186	lib_exe_obj.addObjectFile(fs.path.join(b.allocator, &[_][]const u8{
187	cmake_binary_dir,	187	cmake_binary_dir,
188	"zig_cpp",	188	"zig_cpp",
189	b.fmt("{}{}{}", lib_exe_obj.target.libPrefix(), lib_name, lib_exe_obj.target.staticLibSuffix()),	189	b.fmt("{}{}{}", .{ lib_exe_obj.target.libPrefix(), lib_name, lib_exe_obj.target.staticLibSuffix() }),
190	}) catch unreachable);	190	}) catch unreachable);
191	}	191	}
192		192
...	@@ -343,14 +343,14 @@ fn addCxxKnownPath(	...	@@ -343,14 +343,14 @@ fn addCxxKnownPath(
343	) !void {	343	) !void {
344	const path_padded = try b.exec(&[_][]const u8{	344	const path_padded = try b.exec(&[_][]const u8{
345	ctx.cxx_compiler,	345	ctx.cxx_compiler,
346	b.fmt("-print-file-name={}", objname),	346	b.fmt("-print-file-name={}", .{objname}),
347	});	347	});
348	const path_unpadded = mem.tokenize(path_padded, "\r\n").next().?;	348	const path_unpadded = mem.tokenize(path_padded, "\r\n").next().?;
349	if (mem.eql(u8, path_unpadded, objname)) {	349	if (mem.eql(u8, path_unpadded, objname)) {
350	if (errtxt) \|msg\| {	350	if (errtxt) \|msg\| {
351	warn("{}", msg);	351	warn("{}", .{msg});
352	} else {	352	} else {
353	warn("Unable to determine path to {}\n", objname);	353	warn("Unable to determine path to {}\n", .{objname});
354	}	354	}
355	return error.RequiredLibraryNotFound;	355	return error.RequiredLibraryNotFound;
356	}	356	}

doc/docgen.zig+146-135

 @@ -215,32 +215,33 @@ const Tokenizer = struct {
     }
 };
-fn parseError(tokenizer: *Tokenizer, token: Token, comptime fmt: []const u8, args: ...) anyerror {
+fn parseError(tokenizer: *Tokenizer, token: Token, comptime fmt: []const u8, args: var) anyerror {
     const loc = tokenizer.getTokenLocation(token);
-    warn("{}:{}:{}: error: " ++ fmt ++ "\n", tokenizer.source_file_name, loc.line + 1, loc.column + 1, args);
+    const args_prefix = .{ tokenizer.source_file_name, loc.line + 1, loc.column + 1 };
+    warn("{}:{}:{}: error: " ++ fmt ++ "\n", args_prefix ++ args);
     if (loc.line_start <= loc.line_end) {
-        warn("{}\n", tokenizer.buffer[loc.line_start..loc.line_end]);
+        warn("{}\n", .{tokenizer.buffer[loc.line_start..loc.line_end]});
         {
             var i: usize = 0;
             while (i < loc.column) : (i += 1) {
-                warn(" ");
+                warn(" ", .{});
             }
         }
         {
             const caret_count = token.end - token.start;
             var i: usize = 0;
             while (i < caret_count) : (i += 1) {
-                warn("~");
+                warn("~", .{});
             }
         }
-        warn("\n");
+        warn("\n", .{});
     }
     return error.ParseError;
 }
 fn assertToken(tokenizer: *Tokenizer, token: Token, id: Token.Id) !void {
     if (token.id != id) {
-        return parseError(tokenizer, token, "expected {}, found {}", @tagName(id), @tagName(token.id));
+        return parseError(tokenizer, token, "expected {}, found {}", .{ @tagName(id), @tagName(token.id) });
     }
 }
 @@ -339,7 +340,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
         switch (token.id) {
             Token.Id.Eof => {
                 if (header_stack_size != 0) {
-                    return parseError(tokenizer, token, "unbalanced headers");
+                    return parseError(tokenizer, token, "unbalanced headers", .{});
                 }
                 try toc.write("    </ul>\n");
                 break;
 @@ -373,10 +374,15 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
                                 if (mem.eql(u8, param, "3col")) {
                                     columns = 3;
                                 } else {
-                                    return parseError(tokenizer, bracket_tok, "unrecognized header_open param: {}", param);
+                                    return parseError(
+                                        tokenizer,
+                                        bracket_tok,
+                                        "unrecognized header_open param: {}",
+                                        .{param},
+                                    );
                                 }
                             },
-                            else => return parseError(tokenizer, bracket_tok, "invalid header_open token"),
+                            else => return parseError(tokenizer, bracket_tok, "invalid header_open token", .{}),
                         }
                     }
 @@ -391,15 +397,15 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
                         },
                     });
                     if (try urls.put(urlized, tag_token)) |entry| {
-                        parseError(tokenizer, tag_token, "duplicate header url: #{}", urlized) catch {};
+                        parseError(tokenizer, tag_token, "duplicate header url: #{}", .{urlized}) catch {};
-                        parseError(tokenizer, entry.value, "other tag here") catch {};
+                        parseError(tokenizer, entry.value, "other tag here", .{}) catch {};
                         return error.ParseError;
                     }
                     if (last_action == Action.Open) {
                         try toc.writeByte('\n');
                         try toc.writeByteNTimes(' ', header_stack_size * 4);
                         if (last_columns) |n| {
-                            try toc.print("<ul style=\"columns: {}\">\n", n);
+                            try toc.print("<ul style=\"columns: {}\">\n", .{n});
                         } else {
                             try toc.write("<ul>\n");
                         }
 @@ -408,10 +414,10 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
                     }
                     last_columns = columns;
                     try toc.writeByteNTimes(' ', 4 + header_stack_size * 4);
-                    try toc.print("<li><a id=\"toc-{}\" href=\"#{}\">{}</a>", urlized, urlized, content);
+                    try toc.print("<li><a id=\"toc-{}\" href=\"#{}\">{}</a>", .{ urlized, urlized, content });
                 } else if (mem.eql(u8, tag_name, "header_close")) {
                     if (header_stack_size == 0) {
-                        return parseError(tokenizer, tag_token, "unbalanced close header");
+                        return parseError(tokenizer, tag_token, "unbalanced close header", .{});
                     }
                     header_stack_size -= 1;
                     _ = try eatToken(tokenizer, Token.Id.BracketClose);
 @@ -442,7 +448,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
                                 try nodes.append(Node{ .SeeAlso = list.toOwnedSlice() });
                                 break;
                             },
-                            else => return parseError(tokenizer, see_also_tok, "invalid see_also token"),
+                            else => return parseError(tokenizer, see_also_tok, "invalid see_also token", .{}),
                         }
                     }
                 } else if (mem.eql(u8, tag_name, "link")) {
 @@ -459,7 +465,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
                                 _ = try eatToken(tokenizer, Token.Id.BracketClose);
                                 break :blk tokenizer.buffer[explicit_text.start..explicit_text.end];
                             },
-                            else => return parseError(tokenizer, tok, "invalid link token"),
+                            else => return parseError(tokenizer, tok, "invalid link token", .{}),
                         }
                     };
 @@ -482,7 +488,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
                             _ = try eatToken(tokenizer, Token.Id.BracketClose);
                         },
                         Token.Id.BracketClose => {},
-                        else => return parseError(tokenizer, token, "invalid token"),
+                        else => return parseError(tokenizer, token, "invalid token", .{}),
                     }
                     const code_kind_str = tokenizer.buffer[code_kind_tok.start..code_kind_tok.end];
                     var code_kind_id: Code.Id = undefined;
 @@ -512,7 +518,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
                         code_kind_id = Code.Id{ .Obj = null };
                         is_inline = true;
                     } else {
-                        return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {}", code_kind_str);
+                        return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {}", .{code_kind_str});
                     }
                     var mode = builtin.Mode.Debug;
 @@ -550,7 +556,12 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
                             _ = try eatToken(tokenizer, Token.Id.BracketClose);
                             break content_tok;
                         } else {
-                            return parseError(tokenizer, end_code_tag, "invalid token inside code_begin: {}", end_tag_name);
+                            return parseError(
+                                tokenizer,
+                                end_code_tag,
+                                "invalid token inside code_begin: {}",
+                                .{end_tag_name},
+                            );
                         }
                         _ = try eatToken(tokenizer, Token.Id.BracketClose);
                     } else
 @@ -575,15 +586,20 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
                     const end_syntax_tag = try eatToken(tokenizer, Token.Id.TagContent);
                     const end_tag_name = tokenizer.buffer[end_syntax_tag.start..end_syntax_tag.end];
                     if (!mem.eql(u8, end_tag_name, "endsyntax")) {
-                        return parseError(tokenizer, end_syntax_tag, "invalid token inside syntax: {}", end_tag_name);
+                        return parseError(
+                            tokenizer,
+                            end_syntax_tag,
+                            "invalid token inside syntax: {}",
+                            .{end_tag_name},
+                        );
                     }
                     _ = try eatToken(tokenizer, Token.Id.BracketClose);
                     try nodes.append(Node{ .Syntax = content_tok });
                 } else {
-                    return parseError(tokenizer, tag_token, "unrecognized tag name: {}", tag_name);
+                    return parseError(tokenizer, tag_token, "unrecognized tag name: {}", .{tag_name});
                 }
             },
-            else => return parseError(tokenizer, token, "invalid token"),
+            else => return parseError(tokenizer, token, "invalid token", .{}),
         }
     }
 @@ -729,7 +745,7 @@ fn termColor(allocator: *mem.Allocator, input: []const u8) ![]u8 {
                         try out.write("</span>");
                     }
                     if (first_number != 0 or second_number != 0) {
-                        try out.print("<span class=\"t{}_{}\">", first_number, second_number);
+                        try out.print("<span class=\"t{}_{}\">", .{ first_number, second_number });
                         open_span_count += 1;
                     }
                 },
 @@ -960,6 +976,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok
                 docgen_tokenizer,
                 source_token,
                 "syntax error",
+                .{},
             ),
         }
         index = token.end;
 @@ -987,9 +1004,9 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
             },
             Node.Link => |info| {
                 if (!toc.urls.contains(info.url)) {
-                    return parseError(tokenizer, info.token, "url not found: {}", info.url);
+                    return parseError(tokenizer, info.token, "url not found: {}", .{info.url});
                 }
-                try out.print("<a href=\"#{}\">{}</a>", info.url, info.name);
+                try out.print("<a href=\"#{}\">{}</a>", .{ info.url, info.name });
             },
             Node.Nav => {
                 try out.write(toc.toc);
 @@ -1002,12 +1019,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
             Node.HeaderOpen => |info| {
                 try out.print(
                     "<h{} id=\"{}\"><a href=\"#toc-{}\">{}</a> <a class=\"hdr\" href=\"#{}\">§</a></h{}>\n",
-                    info.n,
+                    .{ info.n, info.url, info.url, info.name, info.url, info.n },
-                    info.url,
-                    info.url,
-                    info.name,
-                    info.url,
-                    info.n,
                 );
             },
             Node.SeeAlso => |items| {
 @@ -1015,9 +1027,9 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                 for (items) |item| {
                     const url = try urlize(allocator, item.name);
                     if (!toc.urls.contains(url)) {
-                        return parseError(tokenizer, item.token, "url not found: {}", url);
+                        return parseError(tokenizer, item.token, "url not found: {}", .{url});
                     }
-                    try out.print("<li><a href=\"#{}\">{}</a></li>\n", url, item.name);
+                    try out.print("<li><a href=\"#{}\">{}</a></li>\n", .{ url, item.name });
                 }
                 try out.write("</ul>\n");
             },
 @@ -1026,17 +1038,17 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
             },
             Node.Code => |code| {
                 code_progress_index += 1;
-                warn("docgen example code {}/{}...", code_progress_index, tokenizer.code_node_count);
+                warn("docgen example code {}/{}...", .{ code_progress_index, tokenizer.code_node_count });
                 const raw_source = tokenizer.buffer[code.source_token.start..code.source_token.end];
                 const trimmed_raw_source = mem.trim(u8, raw_source, " \n");
                 if (!code.is_inline) {
-                    try out.print("<p class=\"file\">{}.zig</p>", code.name);
+                    try out.print("<p class=\"file\">{}.zig</p>", .{code.name});
                 }
                 try out.write("<pre>");
                 try tokenizeAndPrint(tokenizer, out, code.source_token);
                 try out.write("</pre>");
-                const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", code.name);
+                const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", .{code.name});
                 const tmp_source_file_name = try fs.path.join(
                     allocator,
                     &[_][]const u8{ tmp_dir_name, name_plus_ext },
 @@ -1045,7 +1057,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                 switch (code.id) {
                     Code.Id.Exe => |expected_outcome| code_block: {
-                        const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, exe_ext);
+                        const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ code.name, exe_ext });
                         var build_args = std.ArrayList([]const u8).init(allocator);
                         defer build_args.deinit();
                         try build_args.appendSlice(&[_][]const u8{
 @@ -1059,40 +1071,40 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                             "--cache",
                             "on",
                         });
-                        try out.print("<pre><code class=\"shell\">$ zig build-exe {}.zig", code.name);
+                        try out.print("<pre><code class=\"shell\">$ zig build-exe {}.zig", .{code.name});
                         switch (code.mode) {
                             builtin.Mode.Debug => {},
                             builtin.Mode.ReleaseSafe => {
                                 try build_args.append("--release-safe");
-                                try out.print(" --release-safe");
+                                try out.print(" --release-safe", .{});
                             },
                             builtin.Mode.ReleaseFast => {
                                 try build_args.append("--release-fast");
-                                try out.print(" --release-fast");
+                                try out.print(" --release-fast", .{});
                             },
                             builtin.Mode.ReleaseSmall => {
                                 try build_args.append("--release-small");
-                                try out.print(" --release-small");
+                                try out.print(" --release-small", .{});
                             },
                         }
                         for (code.link_objects) |link_object| {
-                            const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", link_object, obj_ext);
+                            const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ link_object, obj_ext });
                             const full_path_object = try fs.path.join(
                                 allocator,
                                 &[_][]const u8{ tmp_dir_name, name_with_ext },
                             );
                             try build_args.append("--object");
                             try build_args.append(full_path_object);
-                            try out.print(" --object {}", name_with_ext);
+                            try out.print(" --object {}", .{name_with_ext});
                         }
                         if (code.link_libc) {
                             try build_args.append("-lc");
-                            try out.print(" -lc");
+                            try out.print(" -lc", .{});
                         }
                         if (code.target_str) |triple| {
                             try build_args.appendSlice(&[_][]const u8{ "-target", triple });
                             if (!code.is_inline) {
-                                try out.print(" -target {}", triple);
+                                try out.print(" -target {}", .{triple});
                             }
                         }
                         if (expected_outcome == .BuildFail) {
 @@ -1106,29 +1118,29 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                             switch (result.term) {
                                 .Exited => |exit_code| {
                                     if (exit_code == 0) {
-                                        warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
+                                        warn("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
                                         for (build_args.toSliceConst()) |arg|
-                                            warn("{} ", arg)
+                                            warn("{} ", .{arg})
                                         else
-                                            warn("\n");
+                                            warn("\n", .{});
-                                        return parseError(tokenizer, code.source_token, "example incorrectly compiled");
+                                        return parseError(tokenizer, code.source_token, "example incorrectly compiled", .{});
                                     }
                                 },
                                 else => {
-                                    warn("{}\nThe following command crashed:\n", result.stderr);
+                                    warn("{}\nThe following command crashed:\n", .{result.stderr});
                                     for (build_args.toSliceConst()) |arg|
-                                        warn("{} ", arg)
+                                        warn("{} ", .{arg})
                                     else
-                                        warn("\n");
+                                        warn("\n", .{});
-                                    return parseError(tokenizer, code.source_token, "example compile crashed");
+                                    return parseError(tokenizer, code.source_token, "example compile crashed", .{});
                                 },
                             }
                             const escaped_stderr = try escapeHtml(allocator, result.stderr);
                             const colored_stderr = try termColor(allocator, escaped_stderr);
-                            try out.print("\n{}</code></pre>\n", colored_stderr);
+                            try out.print("\n{}</code></pre>\n", .{colored_stderr});
                             break :code_block;
                         }
-                        const exec_result = exec(allocator, &env_map, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile");
+                        const exec_result = exec(allocator, &env_map, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile", .{});
                         if (code.target_str) |triple| {
                             if (mem.startsWith(u8, triple, "wasm32") or
 @@ -1137,7 +1149,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                                 (builtin.os != .linux or builtin.arch != .x86_64))
                             {
                                 // skip execution
-                                try out.print("</code></pre>\n");
+                                try out.print("</code></pre>\n", .{});
                                 break :code_block;
                             }
                         }
 @@ -1152,12 +1164,12 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                             switch (result.term) {
                                 .Exited => |exit_code| {
                                     if (exit_code == 0) {
-                                        warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
+                                        warn("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
                                         for (run_args) |arg|
-                                            warn("{} ", arg)
+                                            warn("{} ", .{arg})
                                         else
-                                            warn("\n");
+                                            warn("\n", .{});
-                                        return parseError(tokenizer, code.source_token, "example incorrectly compiled");
+                                        return parseError(tokenizer, code.source_token, "example incorrectly compiled", .{});
                                     }
                                 },
                                 .Signal => exited_with_signal = true,
 @@ -1165,7 +1177,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                             }
                             break :blk result;
                         } else blk: {
-                            break :blk exec(allocator, &env_map, run_args) catch return parseError(tokenizer, code.source_token, "example crashed");
+                            break :blk exec(allocator, &env_map, run_args) catch return parseError(tokenizer, code.source_token, "example crashed", .{});
                         };
                         const escaped_stderr = try escapeHtml(allocator, result.stderr);
 @@ -1174,11 +1186,11 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                         const colored_stderr = try termColor(allocator, escaped_stderr);
                         const colored_stdout = try termColor(allocator, escaped_stdout);
-                        try out.print("\n$ ./{}\n{}{}", code.name, colored_stdout, colored_stderr);
+                        try out.print("\n$ ./{}\n{}{}", .{ code.name, colored_stdout, colored_stderr });
                         if (exited_with_signal) {
-                            try out.print("(process terminated by signal)");
+                            try out.print("(process terminated by signal)", .{});
                         }
-                        try out.print("</code></pre>\n");
+                        try out.print("</code></pre>\n", .{});
                     },
                     Code.Id.Test => {
                         var test_args = std.ArrayList([]const u8).init(allocator);
 @@ -1191,34 +1203,34 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                             "--cache",
                             "on",
                         });
-                        try out.print("<pre><code class=\"shell\">$ zig test {}.zig", code.name);
+                        try out.print("<pre><code class=\"shell\">$ zig test {}.zig", .{code.name});
                         switch (code.mode) {
                             builtin.Mode.Debug => {},
                             builtin.Mode.ReleaseSafe => {
                                 try test_args.append("--release-safe");
-                                try out.print(" --release-safe");
+                                try out.print(" --release-safe", .{});
                             },
                             builtin.Mode.ReleaseFast => {
                                 try test_args.append("--release-fast");
-                                try out.print(" --release-fast");
+                                try out.print(" --release-fast", .{});
                             },
                             builtin.Mode.ReleaseSmall => {
                                 try test_args.append("--release-small");
-                                try out.print(" --release-small");
+                                try out.print(" --release-small", .{});
                             },
                         }
                         if (code.link_libc) {
                             try test_args.append("-lc");
-                            try out.print(" -lc");
+                            try out.print(" -lc", .{});
                         }
                         if (code.target_str) |triple| {
                             try test_args.appendSlice(&[_][]const u8{ "-target", triple });
-                            try out.print(" -target {}", triple);
+                            try out.print(" -target {}", .{triple});
                         }
-                        const result = exec(allocator, &env_map, test_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "test failed");
+                        const result = exec(allocator, &env_map, 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{}{}</code></pre>\n", escaped_stderr, escaped_stdout);
+                        try out.print("\n{}{}</code></pre>\n", .{ escaped_stderr, escaped_stdout });
                     },
                     Code.Id.TestError => |error_match| {
                         var test_args = std.ArrayList([]const u8).init(allocator);
 @@ -1233,50 +1245,50 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                             "--output-dir",
                             tmp_dir_name,
                         });
-                        try out.print("<pre><code class=\"shell\">$ zig test {}.zig", code.name);
+                        try out.print("<pre><code class=\"shell\">$ zig test {}.zig", .{code.name});
                         switch (code.mode) {
                             builtin.Mode.Debug => {},
                             builtin.Mode.ReleaseSafe => {
                                 try test_args.append("--release-safe");
-                                try out.print(" --release-safe");
+                                try out.print(" --release-safe", .{});
                             },
                             builtin.Mode.ReleaseFast => {
                                 try test_args.append("--release-fast");
-                                try out.print(" --release-fast");
+                                try out.print(" --release-fast", .{});
                             },
                             builtin.Mode.ReleaseSmall => {
                                 try test_args.append("--release-small");
-                                try out.print(" --release-small");
+                                try out.print(" --release-small", .{});
                             },
                         }
                         const result = try ChildProcess.exec(allocator, test_args.toSliceConst(), null, &env_map, max_doc_file_size);
                         switch (result.term) {
                             .Exited => |exit_code| {
                                 if (exit_code == 0) {
-                                    warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
+                                    warn("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
                                     for (test_args.toSliceConst()) |arg|
-                                        warn("{} ", arg)
+                                        warn("{} ", .{arg})
                                     else
-                                        warn("\n");
+                                        warn("\n", .{});
-                                    return parseError(tokenizer, code.source_token, "example incorrectly compiled");
+                                    return parseError(tokenizer, code.source_token, "example incorrectly compiled", .{});
                                 }
                             },
                             else => {
-                                warn("{}\nThe following command crashed:\n", result.stderr);
+                                warn("{}\nThe following command crashed:\n", .{result.stderr});
                                 for (test_args.toSliceConst()) |arg|
-                                    warn("{} ", arg)
+                                    warn("{} ", .{arg})
                                 else
-                                    warn("\n");
+                                    warn("\n", .{});
-                                return parseError(tokenizer, code.source_token, "example compile crashed");
+                                return parseError(tokenizer, code.source_token, "example compile crashed", .{});
                             },
                         }
                         if (mem.indexOf(u8, result.stderr, error_match) == null) {
-                            warn("{}\nExpected to find '{}' in stderr", result.stderr, error_match);
+                            warn("{}\nExpected to find '{}' in stderr", .{ result.stderr, error_match });
-                            return parseError(tokenizer, code.source_token, "example did not have expected compile error");
+                            return parseError(tokenizer, code.source_token, "example did not have expected compile error", .{});
                         }
                         const escaped_stderr = try escapeHtml(allocator, result.stderr);
                         const colored_stderr = try termColor(allocator, escaped_stderr);
-                        try out.print("\n{}</code></pre>\n", colored_stderr);
+                        try out.print("\n{}</code></pre>\n", .{colored_stderr});
                     },
                     Code.Id.TestSafety => |error_match| {
 @@ -1311,38 +1323,37 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                         switch (result.term) {
                             .Exited => |exit_code| {
                                 if (exit_code == 0) {
-                                    warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
+                                    warn("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
                                     for (test_args.toSliceConst()) |arg|
-                                        warn("{} ", arg)
+                                        warn("{} ", .{arg})
                                     else
-                                        warn("\n");
+                                        warn("\n", .{});
-                                    return parseError(tokenizer, code.source_token, "example test incorrectly succeeded");
+                                    return parseError(tokenizer, code.source_token, "example test incorrectly succeeded", .{});
                                 }
                             },
                             else => {
-                                warn("{}\nThe following command crashed:\n", result.stderr);
+                                warn("{}\nThe following command crashed:\n", .{result.stderr});
                                 for (test_args.toSliceConst()) |arg|
-                                    warn("{} ", arg)
+                                    warn("{} ", .{arg})
                                 else
-                                    warn("\n");
+                                    warn("\n", .{});
-                                return parseError(tokenizer, code.source_token, "example compile crashed");
+                                return parseError(tokenizer, code.source_token, "example compile crashed", .{});
                             },
                         }
                         if (mem.indexOf(u8, result.stderr, error_match) == null) {
-                            warn("{}\nExpected to find '{}' in stderr", result.stderr, error_match);
+                            warn("{}\nExpected to find '{}' in stderr", .{ result.stderr, error_match });
-                            return parseError(tokenizer, code.source_token, "example did not have expected runtime safety error message");
+                            return parseError(tokenizer, code.source_token, "example did not have expected runtime safety error message", .{});
                         }
                         const escaped_stderr = try escapeHtml(allocator, result.stderr);
                         const colored_stderr = try termColor(allocator, escaped_stderr);
-                        try out.print(
+                        try out.print("<pre><code class=\"shell\">$ zig test {}.zig{}\n{}</code></pre>\n", .{
-                            "<pre><code class=\"shell\">$ zig test {}.zig{}\n{}</code></pre>\n",
                             code.name,
                             mode_arg,
                             colored_stderr,
-                        );
+                        });
                     },
                     Code.Id.Obj => |maybe_error_match| {
-                        const name_plus_obj_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, obj_ext);
+                        const name_plus_obj_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ code.name, obj_ext });
                         const tmp_obj_file_name = try fs.path.join(
                             allocator,
                             &[_][]const u8{ tmp_dir_name, name_plus_obj_ext },
 @@ -1350,7 +1361,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                         var build_args = std.ArrayList([]const u8).init(allocator);
                         defer build_args.deinit();
-                        const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{}.h", code.name);
+                        const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{}.h", .{code.name});
                         const output_h_file_name = try fs.path.join(
                             allocator,
                             &[_][]const u8{ tmp_dir_name, name_plus_h_ext },
 @@ -1369,7 +1380,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                         });
                         if (!code.is_inline) {
-                            try out.print("<pre><code class=\"shell\">$ zig build-obj {}.zig", code.name);
+                            try out.print("<pre><code class=\"shell\">$ zig build-obj {}.zig", .{code.name});
                         }
                         switch (code.mode) {
 @@ -1377,26 +1388,26 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                             builtin.Mode.ReleaseSafe => {
                                 try build_args.append("--release-safe");
                                 if (!code.is_inline) {
-                                    try out.print(" --release-safe");
+                                    try out.print(" --release-safe", .{});
                                 }
                             },
                             builtin.Mode.ReleaseFast => {
                                 try build_args.append("--release-fast");
                                 if (!code.is_inline) {
-                                    try out.print(" --release-fast");
+                                    try out.print(" --release-fast", .{});
                                 }
                             },
                             builtin.Mode.ReleaseSmall => {
                                 try build_args.append("--release-small");
                                 if (!code.is_inline) {
-                                    try out.print(" --release-small");
+                                    try out.print(" --release-small", .{});
                                 }
                             },
                         }
                         if (code.target_str) |triple| {
                             try build_args.appendSlice(&[_][]const u8{ "-target", triple });
-                            try out.print(" -target {}", triple);
+                            try out.print(" -target {}", .{triple});
                         }
                         if (maybe_error_match) |error_match| {
 @@ -1404,35 +1415,35 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                             switch (result.term) {
                                 .Exited => |exit_code| {
                                     if (exit_code == 0) {
-                                        warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
+                                        warn("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
                                         for (build_args.toSliceConst()) |arg|
-                                            warn("{} ", arg)
+                                            warn("{} ", .{arg})
                                         else
-                                            warn("\n");
+                                            warn("\n", .{});
-                                        return parseError(tokenizer, code.source_token, "example build incorrectly succeeded");
+                                        return parseError(tokenizer, code.source_token, "example build incorrectly succeeded", .{});
                                     }
                                 },
                                 else => {
-                                    warn("{}\nThe following command crashed:\n", result.stderr);
+                                    warn("{}\nThe following command crashed:\n", .{result.stderr});
                                     for (build_args.toSliceConst()) |arg|
-                                        warn("{} ", arg)
+                                        warn("{} ", .{arg})
                                     else
-                                        warn("\n");
+                                        warn("\n", .{});
-                                    return parseError(tokenizer, code.source_token, "example compile crashed");
+                                    return parseError(tokenizer, code.source_token, "example compile crashed", .{});
                                 },
                             }
                             if (mem.indexOf(u8, result.stderr, error_match) == null) {
-                                warn("{}\nExpected to find '{}' in stderr", result.stderr, error_match);
+                                warn("{}\nExpected to find '{}' in stderr", .{ result.stderr, error_match });
-                                return parseError(tokenizer, code.source_token, "example did not have expected compile error message");
+                                return parseError(tokenizer, code.source_token, "example did not have expected compile error message", .{});
                             }
                             const escaped_stderr = try escapeHtml(allocator, result.stderr);
                             const colored_stderr = try termColor(allocator, escaped_stderr);
-                            try out.print("\n{}", colored_stderr);
+                            try out.print("\n{}", .{colored_stderr});
                         } else {
-                            _ = exec(allocator, &env_map, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile");
+                            _ = exec(allocator, &env_map, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile", .{});
                         }
                         if (!code.is_inline) {
-                            try out.print("</code></pre>\n");
+                            try out.print("</code></pre>\n", .{});
                         }
                     },
                     Code.Id.Lib => {
 @@ -1446,33 +1457,33 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                             "--output-dir",
                             tmp_dir_name,
                         });
-                        try out.print("<pre><code class=\"shell\">$ zig build-lib {}.zig", code.name);
+                        try out.print("<pre><code class=\"shell\">$ zig build-lib {}.zig", .{code.name});
                         switch (code.mode) {
                             builtin.Mode.Debug => {},
                             builtin.Mode.ReleaseSafe => {
                                 try test_args.append("--release-safe");
-                                try out.print(" --release-safe");
+                                try out.print(" --release-safe", .{});
                             },
                             builtin.Mode.ReleaseFast => {
                                 try test_args.append("--release-fast");
-                                try out.print(" --release-fast");
+                                try out.print(" --release-fast", .{});
                             },
                             builtin.Mode.ReleaseSmall => {
                                 try test_args.append("--release-small");
-                                try out.print(" --release-small");
+                                try out.print(" --release-small", .{});
                             },
                         }
                         if (code.target_str) |triple| {
                             try test_args.appendSlice(&[_][]const u8{ "-target", triple });
-                            try out.print(" -target {}", triple);
+                            try out.print(" -target {}", .{triple});
                         }
-                        const result = exec(allocator, &env_map, test_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "test failed");
+                        const result = exec(allocator, &env_map, 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{}{}</code></pre>\n", escaped_stderr, escaped_stdout);
+                        try out.print("\n{}{}</code></pre>\n", .{ escaped_stderr, escaped_stdout });
                     },
                 }
-                warn("OK\n");
+                warn("OK\n", .{});
             },
         }
     }
 @@ -1483,20 +1494,20 @@ fn exec(allocator: *mem.Allocator, env_map: *std.BufMap, args: []const []const u
     switch (result.term) {
         .Exited => |exit_code| {
             if (exit_code != 0) {
-                warn("{}\nThe following command exited with code {}:\n", result.stderr, exit_code);
+                warn("{}\nThe following command exited with code {}:\n", .{ result.stderr, exit_code });
                 for (args) |arg|
-                    warn("{} ", arg)
+                    warn("{} ", .{arg})
                 else
-                    warn("\n");
+                    warn("\n", .{});
                 return error.ChildExitError;
             }
         },
         else => {
-            warn("{}\nThe following command crashed:\n", result.stderr);
+            warn("{}\nThe following command crashed:\n", .{result.stderr});
             for (args) |arg|
-                warn("{} ", arg)
+                warn("{} ", .{arg})
             else
-                warn("\n");
+                warn("\n", .{});
             return error.ChildCrashed;
         },
     }

doc/langref.html.in+82-70

 @@ -205,7 +205,7 @@ const std = @import("std");
 pub fn main() !void {
     const stdout = &std.io.getStdOut().outStream().stream;
-    try stdout.print("Hello, {}!\n", "world");
+    try stdout.print("Hello, {}!\n", .{"world"});
 }
       {#code_end#}
       <p>
 @@ -217,7 +217,7 @@ pub fn main() !void {
 const warn = @import("std").debug.warn;
 pub fn main() void {
-    warn("Hello, world!\n");
+    warn("Hello, world!\n", .{});
 }
       {#code_end#}
       <p>
 @@ -289,41 +289,50 @@ const assert = std.debug.assert;
 pub fn main() void {
     // integers
     const one_plus_one: i32 = 1 + 1;
-    warn("1 + 1 = {}\n", one_plus_one);
+    warn("1 + 1 = {}\n", .{one_plus_one});
     // floats
     const seven_div_three: f32 = 7.0 / 3.0;
-    warn("7.0 / 3.0 = {}\n", seven_div_three);
+    warn("7.0 / 3.0 = {}\n", .{seven_div_three});
     // boolean
-    warn("{}\n{}\n{}\n",
+    warn("{}\n{}\n{}\n", .{
         true and false,
         true or false,
-        !true);
+        !true,
+    });
     // optional
     var optional_value: ?[]const u8 = null;
     assert(optional_value == null);
-    warn("\noptional 1\ntype: {}\nvalue: {}\n",
+    warn("\noptional 1\ntype: {}\nvalue: {}\n", .{
-        @typeName(@typeOf(optional_value)), optional_value);
+        @typeName(@typeOf(optional_value)),
+        optional_value,
+    });
     optional_value = "hi";
     assert(optional_value != null);
-    warn("\noptional 2\ntype: {}\nvalue: {}\n",
+    warn("\noptional 2\ntype: {}\nvalue: {}\n", .{
-        @typeName(@typeOf(optional_value)), optional_value);
+        @typeName(@typeOf(optional_value)),
+        optional_value,
+    });
     // error union
     var number_or_error: anyerror!i32 = error.ArgNotFound;
-    warn("\nerror union 1\ntype: {}\nvalue: {}\n",
+    warn("\nerror union 1\ntype: {}\nvalue: {}\n", .{
-        @typeName(@typeOf(number_or_error)), number_or_error);
+        @typeName(@typeOf(number_or_error)),
+        number_or_error,
+    });
     number_or_error = 1234;
-    warn("\nerror union 2\ntype: {}\nvalue: {}\n",
+    warn("\nerror union 2\ntype: {}\nvalue: {}\n", .{
-        @typeName(@typeOf(number_or_error)), number_or_error);
+        @typeName(@typeOf(number_or_error)),
+        number_or_error,
+    });
 }
       {#code_end#}
       {#header_open|Primitive Types#}
 @@ -954,8 +963,8 @@ extern fn foo_optimized(x: f64) f64;
 pub fn main() void {
     const x = 0.001;
-    warn("optimized = {}\n", foo_optimized(x));
+    warn("optimized = {}\n", .{foo_optimized(x)});
-    warn("strict = {}\n", foo_strict(x));
+    warn("strict = {}\n", .{foo_strict(x)});
 }
       {#code_end#}
       {#see_also|@setFloatMode|Division by Zero#}
 @@ -2182,7 +2191,7 @@ test "using slices for strings" {
     // You can use slice syntax on an array to convert an array into a slice.
     const all_together_slice = all_together[0..];
     // String concatenation example.
-    const hello_world = try fmt.bufPrint(all_together_slice, "{} {}", hello, world);
+    const hello_world = try fmt.bufPrint(all_together_slice, "{} {}", .{hello, world});
     // Generally, you can use UTF-8 and not worry about whether something is a
     // string. If you don't need to deal with individual characters, no need
 @@ -2623,9 +2632,9 @@ const std = @import("std");
 pub fn main() void {
     const Foo = struct {};
-    std.debug.warn("variable: {}\n", @typeName(Foo));
+    std.debug.warn("variable: {}\n", .{@typeName(Foo)});
-    std.debug.warn("anonymous: {}\n", @typeName(struct {}));
+    std.debug.warn("anonymous: {}\n", .{@typeName(struct {})});
-    std.debug.warn("function: {}\n", @typeName(List(i32)));
+    std.debug.warn("function: {}\n", .{@typeName(List(i32))});
 }
 fn List(comptime T: type) type {
 @@ -3806,18 +3815,18 @@ test "defer basics" {
 // If multiple defer statements are specified, they will be executed in
 // the reverse order they were run.
 fn deferUnwindExample() void {
-    warn("\n");
+    warn("\n", .{});
     defer {
-        warn("1 ");
+        warn("1 ", .{});
     }
     defer {
-        warn("2 ");
+        warn("2 ", .{});
     }
     if (false) {
         // defers are not run if they are never executed.
         defer {
-            warn("3 ");
+            warn("3 ", .{});
         }
     }
 }
 @@ -3832,15 +3841,15 @@ test "defer unwinding" {
 // This is especially useful in allowing a function to clean up properly
 // on error, and replaces goto error handling tactics as seen in c.
 fn deferErrorExample(is_error: bool) !void {
-    warn("\nstart of function\n");
+    warn("\nstart of function\n", .{});
     // This will always be executed on exit
     defer {
-        warn("end of function\n");
+        warn("end of function\n", .{});
     }
     errdefer {
-        warn("encountered an error!\n");
+        warn("encountered an error!\n", .{});
     }
     if (is_error) {
 @@ -5843,7 +5852,7 @@ const a_number: i32 = 1234;
 const a_string = "foobar";
 pub fn main() void {
-    warn("here is a string: '{}' here is a number: {}\n", a_string, a_number);
+    warn("here is a string: '{}' here is a number: {}\n", .{a_string, a_number});
 }
       {#code_end#}
 @@ -5960,8 +5969,11 @@ const a_number: i32 = 1234;
 const a_string = "foobar";
 test "printf too many arguments" {
-    warn("here is a string: '{}' here is a number: {}\n",
+    warn("here is a string: '{}' here is a number: {}\n", .{
-        a_string, a_number, a_number);
+        a_string,
+        a_number,
+        a_number,
+    });
 }
       {#code_end#}
       <p>
 @@ -5979,7 +5991,7 @@ const a_string = "foobar";
 const fmt = "here is a string: '{}' here is a number: {}\n";
 pub fn main() void {
-    warn(fmt, a_string, a_number);
+    warn(fmt, .{a_string, a_number});
 }
       {#code_end#}
       <p>
 @@ -6417,7 +6429,7 @@ pub fn main() void {
 fn amainWrap() void {
     amain() catch |e| {
-        std.debug.warn("{}\n", e);
+        std.debug.warn("{}\n", .{e});
         if (@errorReturnTrace()) |trace| {
             std.debug.dumpStackTrace(trace.*);
         }
 @@ -6447,8 +6459,8 @@ fn amain() !void {
     const download_text = try await download_frame;
     defer allocator.free(download_text);
-    std.debug.warn("download_text: {}\n", download_text);
+    std.debug.warn("download_text: {}\n", .{download_text});
-    std.debug.warn("file_text: {}\n", file_text);
+    std.debug.warn("file_text: {}\n", .{file_text});
 }
 var global_download_frame: anyframe = undefined;
 @@ -6458,7 +6470,7 @@ fn fetchUrl(allocator: *Allocator, url: []const u8) ![]u8 {
     suspend {
         global_download_frame = @frame();
     }
-    std.debug.warn("fetchUrl returning\n");
+    std.debug.warn("fetchUrl returning\n", .{});
     return result;
 }
 @@ -6469,7 +6481,7 @@ fn readFile(allocator: *Allocator, filename: []const u8) ![]u8 {
     suspend {
         global_file_frame = @frame();
     }
-    std.debug.warn("readFile returning\n");
+    std.debug.warn("readFile returning\n", .{});
     return result;
 }
       {#code_end#}
 @@ -6487,7 +6499,7 @@ pub fn main() void {
 fn amainWrap() void {
     amain() catch |e| {
-        std.debug.warn("{}\n", e);
+        std.debug.warn("{}\n", .{e});
         if (@errorReturnTrace()) |trace| {
             std.debug.dumpStackTrace(trace.*);
         }
 @@ -6517,21 +6529,21 @@ fn amain() !void {
     const download_text = try await download_frame;
     defer allocator.free(download_text);
-    std.debug.warn("download_text: {}\n", download_text);
+    std.debug.warn("download_text: {}\n", .{download_text});
-    std.debug.warn("file_text: {}\n", file_text);
+    std.debug.warn("file_text: {}\n", .{file_text});
 }
 fn fetchUrl(allocator: *Allocator, url: []const u8) ![]u8 {
     const result = try std.mem.dupe(allocator, u8, "this is the downloaded url contents");
     errdefer allocator.free(result);
-    std.debug.warn("fetchUrl returning\n");
+    std.debug.warn("fetchUrl returning\n", .{});
     return result;
 }
 fn readFile(allocator: *Allocator, filename: []const u8) ![]u8 {
     const result = try std.mem.dupe(allocator, u8, "this is the file contents");
     errdefer allocator.free(result);
-    std.debug.warn("readFile returning\n");
+    std.debug.warn("readFile returning\n", .{});
     return result;
 }
       {#code_end#}
 @@ -7103,7 +7115,7 @@ const num1 = blk: {
 test "main" {
     @compileLog("comptime in main");
-    warn("Runtime in main, num1 = {}.\n", num1);
+    warn("Runtime in main, num1 = {}.\n", .{num1});
 }
       {#code_end#}
       <p>
 @@ -7124,7 +7136,7 @@ const num1 = blk: {
 };
 test "main" {
-    warn("Runtime in main, num1 = {}.\n", num1);
+    warn("Runtime in main, num1 = {}.\n", .{num1});
 }
       {#code_end#}
       {#header_close#}
 @@ -8706,7 +8718,7 @@ const std = @import("std");
 pub fn main() void {
     var value: i32 = -1;
     var unsigned = @intCast(u32, value);
-    std.debug.warn("value: {}\n", unsigned);
+    std.debug.warn("value: {}\n", .{unsigned});
 }
       {#code_end#}
       <p>
 @@ -8728,7 +8740,7 @@ const std = @import("std");
 pub fn main() void {
     var spartan_count: u16 = 300;
     const byte = @intCast(u8, spartan_count);
-    std.debug.warn("value: {}\n", byte);
+    std.debug.warn("value: {}\n", .{byte});
 }
       {#code_end#}
       <p>
 @@ -8762,7 +8774,7 @@ const std = @import("std");
 pub fn main() void {
     var byte: u8 = 255;
     byte += 1;
-    std.debug.warn("value: {}\n", byte);
+    std.debug.warn("value: {}\n", .{byte});
 }
       {#code_end#}
       {#header_close#}
 @@ -8785,11 +8797,11 @@ pub fn main() !void {
     var byte: u8 = 255;
     byte = if (math.add(u8, byte, 1)) |result| result else |err| {
-        warn("unable to add one: {}\n", @errorName(err));
+        warn("unable to add one: {}\n", .{@errorName(err)});
         return err;
     };
-    warn("result: {}\n", byte);
+    warn("result: {}\n", .{byte});
 }
       {#code_end#}
       {#header_close#}
 @@ -8814,9 +8826,9 @@ pub fn main() void {
     var result: u8 = undefined;
     if (@addWithOverflow(u8, byte, 10, &result)) {
-        warn("overflowed result: {}\n", result);
+        warn("overflowed result: {}\n", .{result});
     } else {
-        warn("result: {}\n", result);
+        warn("result: {}\n", .{result});
     }
 }
       {#code_end#}
 @@ -8861,7 +8873,7 @@ const std = @import("std");
 pub fn main() void {
     var x: u8 = 0b01010101;
     var y = @shlExact(x, 2);
-    std.debug.warn("value: {}\n", y);
+    std.debug.warn("value: {}\n", .{y});
 }
       {#code_end#}
       {#header_close#}
 @@ -8879,7 +8891,7 @@ const std = @import("std");
 pub fn main() void {
     var x: u8 = 0b10101010;
     var y = @shrExact(x, 2);
-    std.debug.warn("value: {}\n", y);
+    std.debug.warn("value: {}\n", .{y});
 }
       {#code_end#}
       {#header_close#}
 @@ -8900,7 +8912,7 @@ pub fn main() void {
     var a: u32 = 1;
     var b: u32 = 0;
     var c = a / b;
-    std.debug.warn("value: {}\n", c);
+    std.debug.warn("value: {}\n", .{c});
 }
       {#code_end#}
       {#header_close#}
 @@ -8921,7 +8933,7 @@ pub fn main() void {
     var a: u32 = 10;
     var b: u32 = 0;
     var c = a % b;
-    std.debug.warn("value: {}\n", c);
+    std.debug.warn("value: {}\n", .{c});
 }
       {#code_end#}
       {#header_close#}
 @@ -8942,7 +8954,7 @@ pub fn main() void {
     var a: u32 = 10;
     var b: u32 = 3;
     var c = @divExact(a, b);
-    std.debug.warn("value: {}\n", c);
+    std.debug.warn("value: {}\n", .{c});
 }
       {#code_end#}
       {#header_close#}
 @@ -8961,7 +8973,7 @@ const std = @import("std");
 pub fn main() void {
     var bytes = [5]u8{ 1, 2, 3, 4, 5 };
     var slice = @bytesToSlice(u32, bytes[0..]);
-    std.debug.warn("value: {}\n", slice[0]);
+    std.debug.warn("value: {}\n", .{slice[0]});
 }
       {#code_end#}
       {#header_close#}
 @@ -8980,7 +8992,7 @@ const std = @import("std");
 pub fn main() void {
     var optional_number: ?i32 = null;
     var number = optional_number.?;
-    std.debug.warn("value: {}\n", number);
+    std.debug.warn("value: {}\n", .{number});
 }
       {#code_end#}
       <p>One way to avoid this crash is to test for null instead of assuming non-null, with
 @@ -8991,9 +9003,9 @@ pub fn main() void {
     const optional_number: ?i32 = null;
     if (optional_number) |number| {
-        warn("got number: {}\n", number);
+        warn("got number: {}\n", .{number});
     } else {
-        warn("it's null\n");
+        warn("it's null\n", .{});
     }
 }
       {#code_end#}
 @@ -9016,7 +9028,7 @@ const std = @import("std");
 pub fn main() void {
     const number = getNumberOrFail() catch unreachable;
-    std.debug.warn("value: {}\n", number);
+    std.debug.warn("value: {}\n", .{number});
 }
 fn getNumberOrFail() !i32 {
 @@ -9032,9 +9044,9 @@ pub fn main() void {
     const result = getNumberOrFail();
     if (result) |number| {
-        warn("got number: {}\n", number);
+        warn("got number: {}\n", .{number});
     } else |err| {
-        warn("got error: {}\n", @errorName(err));
+        warn("got error: {}\n", .{@errorName(err)});
     }
 }
 @@ -9061,7 +9073,7 @@ pub fn main() void {
     var err = error.AnError;
     var number = @errorToInt(err) + 500;
     var invalid_err = @intToError(number);
-    std.debug.warn("value: {}\n", number);
+    std.debug.warn("value: {}\n", .{number});
 }
       {#code_end#}
       {#header_close#}
 @@ -9091,7 +9103,7 @@ const Foo = enum {
 pub fn main() void {
     var a: u2 = 3;
     var b = @intToEnum(Foo, a);
-    std.debug.warn("value: {}\n", @tagName(b));
+    std.debug.warn("value: {}\n", .{@tagName(b)});
 }
       {#code_end#}
       {#header_close#}
 @@ -9128,7 +9140,7 @@ pub fn main() void {
 }
 fn foo(set1: Set1) void {
     const x = @errSetCast(Set2, set1);
-    std.debug.warn("value: {}\n", x);
+    std.debug.warn("value: {}\n", .{x});
 }
       {#code_end#}
       {#header_close#}
 @@ -9184,7 +9196,7 @@ pub fn main() void {
 fn bar(f: *Foo) void {
     f.float = 12.34;
-    std.debug.warn("value: {}\n", f.float);
+    std.debug.warn("value: {}\n", .{f.float});
 }
       {#code_end#}
       <p>
 @@ -9208,7 +9220,7 @@ pub fn main() void {
 fn bar(f: *Foo) void {
     f.* = Foo{ .float = 12.34 };
-    std.debug.warn("value: {}\n", f.float);
+    std.debug.warn("value: {}\n", .{f.float});
 }
       {#code_end#}
       <p>
 @@ -9227,7 +9239,7 @@ pub fn main() void {
     var f = Foo{ .int = 42 };
     f = Foo{ .float = undefined };
     bar(&f);
-    std.debug.warn("value: {}\n", f.float);
+    std.debug.warn("value: {}\n", .{f.float});
 }
 fn bar(f: *Foo) void {
 @@ -9348,7 +9360,7 @@ pub fn main() !void {
     const allocator = &arena.allocator;
     const ptr = try allocator.create(i32);
-    std.debug.warn("ptr={*}\n", ptr);
+    std.debug.warn("ptr={*}\n", .{ptr});
 }
               {#code_end#}
               When using this kind of allocator, there is no need to free anything manually. Everything
 @@ -9881,7 +9893,7 @@ pub fn main() !void {
     defer std.process.argsFree(std.heap.page_allocator, args);
     for (args) |arg, i| {
-        std.debug.warn("{}: {}\n", i, arg);
+        std.debug.warn("{}: {}\n", .{i, arg});
     }
 }
       {#code_end#}

lib/std/atomic/queue.zig+9-10

 @@ -116,19 +116,19 @@ pub fn Queue(comptime T: type) type {
                 fn dumpRecursive(s: *std.io.OutStream(Error), optional_node: ?*Node, indent: usize) Error!void {
                     try s.writeByteNTimes(' ', indent);
                     if (optional_node) |node| {
-                        try s.print("0x{x}={}\n", @ptrToInt(node), node.data);
+                        try s.print("0x{x}={}\n", .{ @ptrToInt(node), node.data });
                         try dumpRecursive(s, node.next, indent + 1);
                     } else {
-                        try s.print("(null)\n");
+                        try s.print("(null)\n", .{});
                     }
                 }
             };
             const held = self.mutex.acquire();
             defer held.release();
-            try stream.print("head: ");
+            try stream.print("head: ", .{});
             try S.dumpRecursive(stream, self.head, 0);
-            try stream.print("tail: ");
+            try stream.print("tail: ", .{});
             try S.dumpRecursive(stream, self.tail, 0);
         }
     };
 @@ -207,16 +207,15 @@ test "std.atomic.Queue" {
     }
     if (context.put_sum != context.get_sum) {
-        std.debug.panic("failure\nput_sum:{} != get_sum:{}", context.put_sum, context.get_sum);
+        std.debug.panic("failure\nput_sum:{} != get_sum:{}", .{ context.put_sum, context.get_sum });
     }
     if (context.get_count != puts_per_thread * put_thread_count) {
-        std.debug.panic(
+        std.debug.panic("failure\nget_count:{} != puts_per_thread:{} * put_thread_count:{}", .{
-            "failure\nget_count:{} != puts_per_thread:{} * put_thread_count:{}",
             context.get_count,
             @as(u32, puts_per_thread),
             @as(u32, put_thread_count),
-        );
+        });
     }
 }
 @@ -351,7 +350,7 @@ test "std.atomic.Queue dump" {
         \\tail: 0x{x}=1
         \\ (null)
         \\
-    , @ptrToInt(queue.head), @ptrToInt(queue.tail));
+    , .{ @ptrToInt(queue.head), @ptrToInt(queue.tail) });
     expect(mem.eql(u8, buffer[0..sos.pos], expected));
     // Test a stream with two elements
 @@ -372,6 +371,6 @@ test "std.atomic.Queue dump" {
         \\tail: 0x{x}=2
         \\ (null)
         \\
-    , @ptrToInt(queue.head), @ptrToInt(queue.head.?.next), @ptrToInt(queue.tail));
+    , .{ @ptrToInt(queue.head), @ptrToInt(queue.head.?.next), @ptrToInt(queue.tail) });
     expect(mem.eql(u8, buffer[0..sos.pos], expected));
 }

lib/std/atomic/stack.zig+3-4

 @@ -134,16 +134,15 @@ test "std.atomic.stack" {
     }
     if (context.put_sum != context.get_sum) {
-        std.debug.panic("failure\nput_sum:{} != get_sum:{}", context.put_sum, context.get_sum);
+        std.debug.panic("failure\nput_sum:{} != get_sum:{}", .{ context.put_sum, context.get_sum });
     }
     if (context.get_count != puts_per_thread * put_thread_count) {
-        std.debug.panic(
+        std.debug.panic("failure\nget_count:{} != puts_per_thread:{} * put_thread_count:{}", .{
-            "failure\nget_count:{} != puts_per_thread:{} * put_thread_count:{}",
             context.get_count,
             @as(u32, puts_per_thread),
             @as(u32, put_thread_count),
-        );
+        });
     }
 }

lib/std/buffer.zig+4-4

lib/std/build.zig+104-82

 @@ -232,7 +232,7 @@ pub const Builder = struct {
     /// To run an executable built with zig build, see `LibExeObjStep.run`.
     pub fn addSystemCommand(self: *Builder, argv: []const []const u8) *RunStep {
         assert(argv.len >= 1);
-        const run_step = RunStep.create(self, self.fmt("run {}", argv[0]));
+        const run_step = RunStep.create(self, self.fmt("run {}", .{argv[0]}));
         run_step.addArgs(argv);
         return run_step;
     }
 @@ -258,7 +258,7 @@ pub const Builder = struct {
         return write_file_step;
     }
-    pub fn addLog(self: *Builder, comptime format: []const u8, args: ...) *LogStep {
+    pub fn addLog(self: *Builder, comptime format: []const u8, args: var) *LogStep {
         const data = self.fmt(format, args);
         const log_step = self.allocator.create(LogStep) catch unreachable;
         log_step.* = LogStep.init(self, data);
 @@ -330,7 +330,7 @@ pub const Builder = struct {
         for (self.installed_files.toSliceConst()) |installed_file| {
             const full_path = self.getInstallPath(installed_file.dir, installed_file.path);
             if (self.verbose) {
-                warn("rm {}\n", full_path);
+                warn("rm {}\n", .{full_path});
             }
             fs.deleteTree(full_path) catch {};
         }
 @@ -340,7 +340,7 @@ pub const Builder = struct {
     fn makeOneStep(self: *Builder, s: *Step) anyerror!void {
         if (s.loop_flag) {
-            warn("Dependency loop detected:\n  {}\n", s.name);
+            warn("Dependency loop detected:\n  {}\n", .{s.name});
             return error.DependencyLoopDetected;
         }
         s.loop_flag = true;
 @@ -348,7 +348,7 @@ pub const Builder = struct {
         for (s.dependencies.toSlice()) |dep| {
             self.makeOneStep(dep) catch |err| {
                 if (err == error.DependencyLoopDetected) {
-                    warn("  {}\n", s.name);
+                    warn("  {}\n", .{s.name});
                 }
                 return err;
             };
 @@ -365,7 +365,7 @@ pub const Builder = struct {
                 return &top_level_step.step;
             }
         }
-        warn("Cannot run step '{}' because it does not exist\n", name);
+        warn("Cannot run step '{}' because it does not exist\n", .{name});
         return error.InvalidStepName;
     }
 @@ -378,12 +378,12 @@ pub const Builder = struct {
                 const word = it.next() orelse break;
                 if (mem.eql(u8, word, "-isystem")) {
                     const include_path = it.next() orelse {
-                        warn("Expected argument after -isystem in NIX_CFLAGS_COMPILE\n");
+                        warn("Expected argument after -isystem in NIX_CFLAGS_COMPILE\n", .{});
                         break;
                     };
                     self.addNativeSystemIncludeDir(include_path);
                 } else {
-                    warn("Unrecognized C flag from NIX_CFLAGS_COMPILE: {}\n", word);
+                    warn("Unrecognized C flag from NIX_CFLAGS_COMPILE: {}\n", .{word});
                     break;
                 }
             }
 @@ -397,7 +397,7 @@ pub const Builder = struct {
                 const word = it.next() orelse break;
                 if (mem.eql(u8, word, "-rpath")) {
                     const rpath = it.next() orelse {
-                        warn("Expected argument after -rpath in NIX_LDFLAGS\n");
+                        warn("Expected argument after -rpath in NIX_LDFLAGS\n", .{});
                         break;
                     };
                     self.addNativeSystemRPath(rpath);
 @@ -405,7 +405,7 @@ pub const Builder = struct {
                     const lib_path = word[2..];
                     self.addNativeSystemLibPath(lib_path);
                 } else {
-                    warn("Unrecognized C flag from NIX_LDFLAGS: {}\n", word);
+                    warn("Unrecognized C flag from NIX_LDFLAGS: {}\n", .{word});
                     break;
                 }
             }
 @@ -431,8 +431,8 @@ pub const Builder = struct {
                 self.addNativeSystemIncludeDir("/usr/local/include");
                 self.addNativeSystemLibPath("/usr/local/lib");
-                self.addNativeSystemIncludeDir(self.fmt("/usr/include/{}", triple));
+                self.addNativeSystemIncludeDir(self.fmt("/usr/include/{}", .{triple}));
-                self.addNativeSystemLibPath(self.fmt("/usr/lib/{}", triple));
+                self.addNativeSystemLibPath(self.fmt("/usr/lib/{}", .{triple}));
                 self.addNativeSystemIncludeDir("/usr/include");
                 self.addNativeSystemLibPath("/usr/lib");
 @@ -440,7 +440,7 @@ pub const Builder = struct {
                 // example: on a 64-bit debian-based linux distro, with zlib installed from apt:
                 // zlib.h is in /usr/include (added above)
                 // libz.so.1 is in /lib/x86_64-linux-gnu (added here)
-                self.addNativeSystemLibPath(self.fmt("/lib/{}", triple));
+                self.addNativeSystemLibPath(self.fmt("/lib/{}", .{triple}));
             },
         }
     }
 @@ -453,7 +453,7 @@ pub const Builder = struct {
             .description = description,
         };
         if ((self.available_options_map.put(name, available_option) catch unreachable) != null) {
-            panic("Option '{}' declared twice", name);
+            panic("Option '{}' declared twice", .{name});
         }
         self.available_options_list.append(available_option) catch unreachable;
 @@ -468,33 +468,33 @@ pub const Builder = struct {
                     } else if (mem.eql(u8, s, "false")) {
                         return false;
                     } else {
-                        warn("Expected -D{} to be a boolean, but received '{}'\n", name, s);
+                        warn("Expected -D{} to be a boolean, but received '{}'\n", .{ name, s });
                         self.markInvalidUserInput();
                         return null;
                     }
                 },
                 UserValue.List => {
-                    warn("Expected -D{} to be a boolean, but received a list.\n", name);
+                    warn("Expected -D{} to be a boolean, but received a list.\n", .{name});
                     self.markInvalidUserInput();
                     return null;
                 },
             },
-            TypeId.Int => panic("TODO integer options to build script"),
+            TypeId.Int => panic("TODO integer options to build script", .{}),
-            TypeId.Float => panic("TODO float options to build script"),
+            TypeId.Float => panic("TODO float options to build script", .{}),
             TypeId.String => switch (entry.value.value) {
                 UserValue.Flag => {
-                    warn("Expected -D{} to be a string, but received a boolean.\n", name);
+                    warn("Expected -D{} to be a string, but received a boolean.\n", .{name});
                     self.markInvalidUserInput();
                     return null;
                 },
                 UserValue.List => {
-                    warn("Expected -D{} to be a string, but received a list.\n", name);
+                    warn("Expected -D{} to be a string, but received a list.\n", .{name});
                     self.markInvalidUserInput();
                     return null;
                 },
                 UserValue.Scalar => |s| return s,
             },
-            TypeId.List => panic("TODO list options to build script"),
+            TypeId.List => panic("TODO list options to build script", .{}),
         }
     }
 @@ -513,7 +513,7 @@ pub const Builder = struct {
         if (self.release_mode != null) {
             @panic("setPreferredReleaseMode must be called before standardReleaseOptions and may not be called twice");
         }
-        const description = self.fmt("create a release build ({})", @tagName(mode));
+        const description = self.fmt("create a release build ({})", .{@tagName(mode)});
         self.is_release = self.option(bool, "release", description) orelse false;
         self.release_mode = if (self.is_release) mode else builtin.Mode.Debug;
     }
 @@ -536,7 +536,7 @@ pub const Builder = struct {
         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)");
+            warn("Multiple release modes (of -Drelease-safe, -Drelease-fast and -Drelease-small)", .{});
             self.markInvalidUserInput();
             break :x builtin.Mode.Debug;
         };
 @@ -599,7 +599,7 @@ pub const Builder = struct {
                 }) catch unreachable;
             },
             UserValue.Flag => {
-                warn("Option '-D{}={}' conflicts with flag '-D{}'.\n", name, value, name);
+                warn("Option '-D{}={}' conflicts with flag '-D{}'.\n", .{ name, value, name });
                 return true;
             },
         }
 @@ -620,11 +620,11 @@ pub const Builder = struct {
         // option already exists
         switch (gop.kv.value.value) {
             UserValue.Scalar => |s| {
-                warn("Flag '-D{}' conflicts with option '-D{}={}'.\n", name, name, s);
+                warn("Flag '-D{}' conflicts with option '-D{}={}'.\n", .{ name, name, s });
                 return true;
             },
             UserValue.List => {
-                warn("Flag '-D{}' conflicts with multiple options of the same name.\n", name);
+                warn("Flag '-D{}' conflicts with multiple options of the same name.\n", .{name});
                 return true;
             },
             UserValue.Flag => {},
 @@ -665,7 +665,7 @@ pub const Builder = struct {
         while (true) {
             const entry = it.next() orelse break;
             if (!entry.value.used) {
-                warn("Invalid option: -D{}\n\n", entry.key);
+                warn("Invalid option: -D{}\n\n", .{entry.key});
                 self.markInvalidUserInput();
             }
         }
 @@ -678,11 +678,11 @@ pub const Builder = struct {
     }
     fn printCmd(cwd: ?[]const u8, argv: []const []const u8) void {
-        if (cwd) |yes_cwd| warn("cd {} && ", yes_cwd);
+        if (cwd) |yes_cwd| warn("cd {} && ", .{yes_cwd});
         for (argv) |arg| {
-            warn("{} ", arg);
+            warn("{} ", .{arg});
         }
-        warn("\n");
+        warn("\n", .{});
     }
     fn spawnChildEnvMap(self: *Builder, cwd: ?[]const u8, env_map: *const BufMap, argv: []const []const u8) !void {
 @@ -697,20 +697,20 @@ pub const Builder = struct {
         child.env_map = env_map;
         const term = child.spawnAndWait() catch |err| {
-            warn("Unable to spawn {}: {}\n", argv[0], @errorName(err));
+            warn("Unable to spawn {}: {}\n", .{ argv[0], @errorName(err) });
             return err;
         };
         switch (term) {
             .Exited => |code| {
                 if (code != 0) {
-                    warn("The following command exited with error code {}:\n", code);
+                    warn("The following command exited with error code {}:\n", .{code});
                     printCmd(cwd, argv);
                     return error.UncleanExit;
                 }
             },
             else => {
-                warn("The following command terminated unexpectedly:\n");
+                warn("The following command terminated unexpectedly:\n", .{});
                 printCmd(cwd, argv);
                 return error.UncleanExit;
 @@ -720,7 +720,7 @@ pub const Builder = struct {
     pub fn makePath(self: *Builder, path: []const u8) !void {
         fs.makePath(self.allocator, self.pathFromRoot(path)) catch |err| {
-            warn("Unable to create path {}: {}\n", path, @errorName(err));
+            warn("Unable to create path {}: {}\n", .{ path, @errorName(err) });
             return err;
         };
     }
 @@ -793,12 +793,12 @@ pub const Builder = struct {
     fn updateFile(self: *Builder, source_path: []const u8, dest_path: []const u8) !void {
         if (self.verbose) {
-            warn("cp {} {} ", source_path, dest_path);
+            warn("cp {} {} ", .{ source_path, dest_path });
         }
         const prev_status = try fs.updateFile(source_path, dest_path);
         if (self.verbose) switch (prev_status) {
-            .stale => warn("# installed\n"),
+            .stale => warn("# installed\n", .{}),
-            .fresh => warn("# up-to-date\n"),
+            .fresh => warn("# up-to-date\n", .{}),
         };
     }
 @@ -806,7 +806,7 @@ pub const Builder = struct {
         return fs.path.resolve(self.allocator, &[_][]const u8{ self.build_root, rel_path }) catch unreachable;
     }
-    pub fn fmt(self: *Builder, comptime format: []const u8, args: ...) []u8 {
+    pub fn fmt(self: *Builder, comptime format: []const u8, args: var) []u8 {
         return fmt_lib.allocPrint(self.allocator, format, args) catch unreachable;
     }
 @@ -818,7 +818,11 @@ pub const Builder = struct {
                 if (fs.path.isAbsolute(name)) {
                     return name;
                 }
-                const full_path = try fs.path.join(self.allocator, &[_][]const u8{ search_prefix, "bin", self.fmt("{}{}", name, exe_extension) });
+                const full_path = try fs.path.join(self.allocator, &[_][]const u8{
+                    search_prefix,
+                    "bin",
+                    self.fmt("{}{}", .{ name, exe_extension }),
+                });
                 return fs.realpathAlloc(self.allocator, full_path) catch continue;
             }
         }
 @@ -829,7 +833,10 @@ pub const Builder = struct {
                 }
                 var it = mem.tokenize(PATH, &[_]u8{fs.path.delimiter});
                 while (it.next()) |path| {
-                    const full_path = try fs.path.join(self.allocator, &[_][]const u8{ path, self.fmt("{}{}", name, exe_extension) });
+                    const full_path = try fs.path.join(self.allocator, &[_][]const u8{
+                        path,
+                        self.fmt("{}{}", .{ name, exe_extension }),
+                    });
                     return fs.realpathAlloc(self.allocator, full_path) catch continue;
                 }
             }
 @@ -839,7 +846,10 @@ pub const Builder = struct {
                 return name;
             }
             for (paths) |path| {
-                const full_path = try fs.path.join(self.allocator, &[_][]const u8{ path, self.fmt("{}{}", name, exe_extension) });
+                const full_path = try fs.path.join(self.allocator, &[_][]const u8{
+                    path,
+                    self.fmt("{}{}", .{ name, exe_extension }),
+                });
                 return fs.realpathAlloc(self.allocator, full_path) catch continue;
             }
         }
 @@ -896,17 +906,17 @@ pub const Builder = struct {
         var code: u8 = undefined;
         return self.execAllowFail(argv, &code, .Inherit) catch |err| switch (err) {
             error.FileNotFound => {
-                warn("Unable to spawn the following command: file not found\n");
+                warn("Unable to spawn the following command: file not found\n", .{});
                 printCmd(null, argv);
                 std.os.exit(@truncate(u8, code));
             },
             error.ExitCodeFailure => {
-                warn("The following command exited with error code {}:\n", code);
+                warn("The following command exited with error code {}:\n", .{code});
                 printCmd(null, argv);
                 std.os.exit(@truncate(u8, code));
             },
             error.ProcessTerminated => {
-                warn("The following command terminated unexpectedly:\n");
+                warn("The following command terminated unexpectedly:\n", .{});
                 printCmd(null, argv);
                 std.os.exit(@truncate(u8, code));
             },
 @@ -1133,7 +1143,7 @@ pub const LibExeObjStep = struct {
     fn initExtraArgs(builder: *Builder, name: []const u8, root_src: ?[]const u8, kind: Kind, is_dynamic: bool, ver: Version) LibExeObjStep {
         if (mem.indexOf(u8, name, "/") != null or mem.indexOf(u8, name, "\\") != null) {
-            panic("invalid name: '{}'. It looks like a file path, but it is supposed to be the library or application name.", name);
+            panic("invalid name: '{}'. It looks like a file path, but it is supposed to be the library or application name.", .{name});
         }
         var self = LibExeObjStep{
             .strip = false,
 @@ -1150,9 +1160,9 @@ pub const LibExeObjStep = struct {
             .step = Step.init(name, builder.allocator, make),
             .version = ver,
             .out_filename = undefined,
-            .out_h_filename = builder.fmt("{}.h", name),
+            .out_h_filename = builder.fmt("{}.h", .{name}),
             .out_lib_filename = undefined,
-            .out_pdb_filename = builder.fmt("{}.pdb", name),
+            .out_pdb_filename = builder.fmt("{}.pdb", .{name}),
             .major_only_filename = undefined,
             .name_only_filename = undefined,
             .packages = ArrayList(Pkg).init(builder.allocator),
 @@ -1186,36 +1196,48 @@ pub const LibExeObjStep = struct {
     fn computeOutFileNames(self: *LibExeObjStep) void {
         switch (self.kind) {
             .Obj => {
-                self.out_filename = self.builder.fmt("{}{}", self.name, self.target.oFileExt());
+                self.out_filename = self.builder.fmt("{}{}", .{ self.name, self.target.oFileExt() });
             },
             .Exe => {
-                self.out_filename = self.builder.fmt("{}{}", self.name, self.target.exeFileExt());
+                self.out_filename = self.builder.fmt("{}{}", .{ self.name, self.target.exeFileExt() });
             },
             .Test => {
-                self.out_filename = self.builder.fmt("test{}", self.target.exeFileExt());
+                self.out_filename = self.builder.fmt("test{}", .{self.target.exeFileExt()});
             },
             .Lib => {
                 if (!self.is_dynamic) {
-                    self.out_filename = self.builder.fmt(
+                    self.out_filename = self.builder.fmt("{}{}{}", .{
-                        "{}{}{}",
                         self.target.libPrefix(),
                         self.name,
                         self.target.staticLibSuffix(),
-                    );
+                    });
                     self.out_lib_filename = self.out_filename;
                 } else {
                     if (self.target.isDarwin()) {
-                        self.out_filename = self.builder.fmt("lib{}.{d}.{d}.{d}.dylib", self.name, self.version.major, self.version.minor, self.version.patch);
+                        self.out_filename = self.builder.fmt("lib{}.{d}.{d}.{d}.dylib", .{
-                        self.major_only_filename = self.builder.fmt("lib{}.{d}.dylib", self.name, self.version.major);
+                            self.name,
-                        self.name_only_filename = self.builder.fmt("lib{}.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});
                         self.out_lib_filename = self.out_filename;
                     } else if (self.target.isWindows()) {
-                        self.out_filename = self.builder.fmt("{}.dll", self.name);
+                        self.out_filename = self.builder.fmt("{}.dll", .{self.name});
-                        self.out_lib_filename = self.builder.fmt("{}.lib", self.name);
+                        self.out_lib_filename = self.builder.fmt("{}.lib", .{self.name});
                     } else {
-                        self.out_filename = self.builder.fmt("lib{}.so.{d}.{d}.{d}", self.name, self.version.major, self.version.minor, self.version.patch);
+                        self.out_filename = self.builder.fmt("lib{}.so.{d}.{d}.{d}", .{
-                        self.major_only_filename = self.builder.fmt("lib{}.so.{d}", self.name, self.version.major);
+                            self.name,
-                        self.name_only_filename = self.builder.fmt("lib{}.so", self.name);
+                            self.version.major,
+                            self.version.minor,
+                            self.version.patch,
+                        });
+                        self.major_only_filename = self.builder.fmt("lib{}.so.{d}", .{ self.name, self.version.major });
+                        self.name_only_filename = self.builder.fmt("lib{}.so", .{self.name});
                         self.out_lib_filename = self.out_filename;
                     }
                 }
 @@ -1268,7 +1290,7 @@ pub const LibExeObjStep = struct {
         // It doesn't have to be native. We catch that if you actually try to run it.
         // Consider that this is declarative; the run step may not be run unless a user
         // option is supplied.
-        const run_step = RunStep.create(exe.builder, exe.builder.fmt("run {}", exe.step.name));
+        const run_step = RunStep.create(exe.builder, exe.builder.fmt("run {}", .{exe.step.name}));
         run_step.addArtifactArg(exe);
         if (exe.vcpkg_bin_path) |path| {
 @@ -1420,7 +1442,7 @@ pub const LibExeObjStep = struct {
             } else if (mem.eql(u8, tok, "-pthread")) {
                 self.linkLibC();
             } else if (self.builder.verbose) {
-                warn("Ignoring pkg-config flag '{}'\n", tok);
+                warn("Ignoring pkg-config flag '{}'\n", .{tok});
             }
         }
     }
 @@ -1653,7 +1675,7 @@ pub const LibExeObjStep = struct {
         const builder = self.builder;
         if (self.root_src == null and self.link_objects.len == 0) {
-            warn("{}: linker needs 1 or more objects to link\n", self.step.name);
+            warn("{}: linker needs 1 or more objects to link\n", .{self.step.name});
             return error.NeedAnObject;
         }
 @@ -1725,7 +1747,7 @@ pub const LibExeObjStep = struct {
         if (self.build_options_contents.len() > 0) {
             const build_options_file = try fs.path.join(
                 builder.allocator,
-                &[_][]const u8{ builder.cache_root, builder.fmt("{}_build_options.zig", self.name) },
+                &[_][]const u8{ builder.cache_root, builder.fmt("{}_build_options.zig", .{self.name}) },
             );
             try std.io.writeFile(build_options_file, self.build_options_contents.toSliceConst());
             try zig_args.append("--pkg-begin");
 @@ -1780,13 +1802,13 @@ pub const LibExeObjStep = struct {
         if (self.kind == Kind.Lib and self.is_dynamic) {
             zig_args.append("--ver-major") catch unreachable;
-            zig_args.append(builder.fmt("{}", self.version.major)) catch unreachable;
+            zig_args.append(builder.fmt("{}", .{self.version.major})) catch unreachable;
             zig_args.append("--ver-minor") catch unreachable;
-            zig_args.append(builder.fmt("{}", self.version.minor)) catch unreachable;
+            zig_args.append(builder.fmt("{}", .{self.version.minor})) catch unreachable;
             zig_args.append("--ver-patch") catch unreachable;
-            zig_args.append(builder.fmt("{}", self.version.patch)) catch unreachable;
+            zig_args.append(builder.fmt("{}", .{self.version.patch})) catch unreachable;
         }
         if (self.is_dynamic) {
             try zig_args.append("-dynamic");
 @@ -1811,7 +1833,7 @@ pub const LibExeObjStep = struct {
         if (self.target_glibc) |ver| {
             try zig_args.append("-target-glibc");
-            try zig_args.append(builder.fmt("{}.{}.{}", ver.major, ver.minor, ver.patch));
+            try zig_args.append(builder.fmt("{}.{}.{}", .{ ver.major, ver.minor, ver.patch }));
         }
         if (self.linker_script) |linker_script| {
 @@ -2079,7 +2101,7 @@ pub const RunStep = struct {
         }
         if (prev_path) |pp| {
-            const new_path = self.builder.fmt("{}" ++ [1]u8{fs.path.delimiter} ++ "{}", pp, search_path);
+            const new_path = self.builder.fmt("{}" ++ [1]u8{fs.path.delimiter} ++ "{}", .{ pp, search_path });
             env_map.set(key, new_path) catch unreachable;
         } else {
             env_map.set(key, search_path) catch unreachable;
 @@ -2153,7 +2175,7 @@ const InstallArtifactStep = struct {
         const self = builder.allocator.create(Self) catch unreachable;
         self.* = Self{
             .builder = builder,
-            .step = Step.init(builder.fmt("install {}", artifact.step.name), builder.allocator, make),
+            .step = Step.init(builder.fmt("install {}", .{artifact.step.name}), builder.allocator, make),
             .artifact = artifact,
             .dest_dir = switch (artifact.kind) {
                 .Obj => unreachable,
 @@ -2219,7 +2241,7 @@ pub const InstallFileStep = struct {
         builder.pushInstalledFile(dir, dest_rel_path);
         return InstallFileStep{
             .builder = builder,
-            .step = Step.init(builder.fmt("install {}", src_path), builder.allocator, make),
+            .step = Step.init(builder.fmt("install {}", .{src_path}), builder.allocator, make),
             .src_path = src_path,
             .dir = dir,
             .dest_rel_path = dest_rel_path,
 @@ -2253,7 +2275,7 @@ pub const InstallDirStep = struct {
         builder.pushInstalledFile(options.install_dir, options.install_subdir);
         return InstallDirStep{
             .builder = builder,
-            .step = Step.init(builder.fmt("install {}/", options.source_dir), builder.allocator, make),
+            .step = Step.init(builder.fmt("install {}/", .{options.source_dir}), builder.allocator, make),
             .options = options,
         };
     }
 @@ -2290,7 +2312,7 @@ pub const WriteFileStep = struct {
     pub fn init(builder: *Builder, file_path: []const u8, data: []const u8) WriteFileStep {
         return WriteFileStep{
             .builder = builder,
-            .step = Step.init(builder.fmt("writefile {}", file_path), builder.allocator, make),
+            .step = Step.init(builder.fmt("writefile {}", .{file_path}), builder.allocator, make),
             .file_path = file_path,
             .data = data,
         };
 @@ -2301,11 +2323,11 @@ pub const WriteFileStep = struct {
         const full_path = self.builder.pathFromRoot(self.file_path);
         const full_path_dir = fs.path.dirname(full_path) orelse ".";
         fs.makePath(self.builder.allocator, full_path_dir) catch |err| {
-            warn("unable to make path {}: {}\n", full_path_dir, @errorName(err));
+            warn("unable to make path {}: {}\n", .{ full_path_dir, @errorName(err) });
             return err;
         };
         io.writeFile(full_path, self.data) catch |err| {
-            warn("unable to write {}: {}\n", full_path, @errorName(err));
+            warn("unable to write {}: {}\n", .{ full_path, @errorName(err) });
             return err;
         };
     }
 @@ -2319,14 +2341,14 @@ pub const LogStep = struct {
     pub fn init(builder: *Builder, data: []const u8) LogStep {
         return LogStep{
             .builder = builder,
-            .step = Step.init(builder.fmt("log {}", data), builder.allocator, make),
+            .step = Step.init(builder.fmt("log {}", .{data}), builder.allocator, make),
             .data = data,
         };
     }
     fn make(step: *Step) anyerror!void {
         const self = @fieldParentPtr(LogStep, "step", step);
-        warn("{}", self.data);
+        warn("{}", .{self.data});
     }
 };
 @@ -2338,7 +2360,7 @@ pub const RemoveDirStep = struct {
     pub fn init(builder: *Builder, dir_path: []const u8) RemoveDirStep {
         return RemoveDirStep{
             .builder = builder,
-            .step = Step.init(builder.fmt("RemoveDir {}", dir_path), builder.allocator, make),
+            .step = Step.init(builder.fmt("RemoveDir {}", .{dir_path}), builder.allocator, make),
             .dir_path = dir_path,
         };
     }
 @@ -2348,7 +2370,7 @@ pub const RemoveDirStep = struct {
         const full_path = self.builder.pathFromRoot(self.dir_path);
         fs.deleteTree(full_path) catch |err| {
-            warn("Unable to remove {}: {}\n", full_path, @errorName(err));
+            warn("Unable to remove {}: {}\n", .{ full_path, @errorName(err) });
             return err;
         };
     }
 @@ -2397,7 +2419,7 @@ fn doAtomicSymLinks(allocator: *Allocator, output_path: []const u8, filename_maj
         &[_][]const u8{ out_dir, filename_major_only },
     ) catch unreachable;
     fs.atomicSymLink(allocator, out_basename, major_only_path) catch |err| {
-        warn("Unable to symlink {} -> {}\n", major_only_path, out_basename);
+        warn("Unable to symlink {} -> {}\n", .{ major_only_path, out_basename });
         return err;
     };
     // sym link for libfoo.so to libfoo.so.1
 @@ -2406,7 +2428,7 @@ fn doAtomicSymLinks(allocator: *Allocator, output_path: []const u8, filename_maj
         &[_][]const u8{ out_dir, filename_name_only },
     ) catch unreachable;
     fs.atomicSymLink(allocator, filename_major_only, name_only_path) catch |err| {
-        warn("Unable to symlink {} -> {}\n", name_only_path, filename_major_only);
+        warn("Unable to symlink {} -> {}\n", .{ name_only_path, filename_major_only });
         return err;
     };
 }

lib/std/builtin.zig+2-2

...	@@ -429,7 +429,7 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace) noreturn	...	@@ -429,7 +429,7 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace) noreturn
429	}	429	}
430	},	430	},
431	.wasi => {	431	.wasi => {
432	std.debug.warn("{}", msg);	432	std.debug.warn("{}", .{msg});
433	_ = std.os.wasi.proc_raise(std.os.wasi.SIGABRT);	433	_ = std.os.wasi.proc_raise(std.os.wasi.SIGABRT);
434	unreachable;	434	unreachable;
435	},	435	},
...	@@ -439,7 +439,7 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace) noreturn	...	@@ -439,7 +439,7 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace) noreturn
439	},	439	},
440	else => {	440	else => {
441	const first_trace_addr = @returnAddress();	441	const first_trace_addr = @returnAddress();
442	std.debug.panicExtra(error_return_trace, first_trace_addr, "{}", msg);	442	std.debug.panicExtra(error_return_trace, first_trace_addr, "{}", .{msg});
443	},	443	},
444	}	444	}
445	}	445	}

lib/std/crypto/benchmark.zig+1-1

...	@@ -114,7 +114,7 @@ fn usage() void {	...	@@ -114,7 +114,7 @@ fn usage() void {
114	\\ --seed [int]	114	\\ --seed [int]
115	\\ --help	115	\\ --help
116	\\	116	\\
117	);	117	, .{});
118	}	118	}
119		119
120	fn mode(comptime x: comptime_int) comptime_int {	120	fn mode(comptime x: comptime_int) comptime_int {

lib/std/debug.zig+56-43

 @@ -46,7 +46,7 @@ var stderr_file_out_stream: File.OutStream = undefined;
 var stderr_stream: ?*io.OutStream(File.WriteError) = null;
 var stderr_mutex = std.Mutex.init();
-pub fn warn(comptime fmt: []const u8, args: ...) void {
+pub fn warn(comptime fmt: []const u8, args: var) void {
     const held = stderr_mutex.acquire();
     defer held.release();
     const stderr = getStderrStream();
 @@ -92,15 +92,15 @@ fn wantTtyColor() bool {
 pub fn dumpCurrentStackTrace(start_addr: ?usize) void {
     const stderr = getStderrStream();
     if (builtin.strip_debug_info) {
-        stderr.print("Unable to dump stack trace: debug info stripped\n") catch return;
+        stderr.print("Unable to dump stack trace: debug info stripped\n", .{}) catch return;
         return;
     }
     const debug_info = getSelfDebugInfo() catch |err| {
-        stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", @errorName(err)) catch return;
+        stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", .{@errorName(err)}) catch return;
         return;
     };
     writeCurrentStackTrace(stderr, debug_info, wantTtyColor(), start_addr) catch |err| {
-        stderr.print("Unable to dump stack trace: {}\n", @errorName(err)) catch return;
+        stderr.print("Unable to dump stack trace: {}\n", .{@errorName(err)}) catch return;
         return;
     };
 }
 @@ -111,11 +111,11 @@ pub fn dumpCurrentStackTrace(start_addr: ?usize) void {
 pub fn dumpStackTraceFromBase(bp: usize, ip: usize) void {
     const stderr = getStderrStream();
     if (builtin.strip_debug_info) {
-        stderr.print("Unable to dump stack trace: debug info stripped\n") catch return;
+        stderr.print("Unable to dump stack trace: debug info stripped\n", .{}) catch return;
         return;
     }
     const debug_info = getSelfDebugInfo() catch |err| {
-        stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", @errorName(err)) catch return;
+        stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", .{@errorName(err)}) catch return;
         return;
     };
     const tty_color = wantTtyColor();
 @@ -184,15 +184,15 @@ pub fn captureStackTrace(first_address: ?usize, stack_trace: *builtin.StackTrace
 pub fn dumpStackTrace(stack_trace: builtin.StackTrace) void {
     const stderr = getStderrStream();
     if (builtin.strip_debug_info) {
-        stderr.print("Unable to dump stack trace: debug info stripped\n") catch return;
+        stderr.print("Unable to dump stack trace: debug info stripped\n", .{}) catch return;
         return;
     }
     const debug_info = getSelfDebugInfo() catch |err| {
-        stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", @errorName(err)) catch return;
+        stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", .{@errorName(err)}) catch return;
         return;
     };
     writeStackTrace(stack_trace, stderr, getDebugInfoAllocator(), debug_info, wantTtyColor()) catch |err| {
-        stderr.print("Unable to dump stack trace: {}\n", @errorName(err)) catch return;
+        stderr.print("Unable to dump stack trace: {}\n", .{@errorName(err)}) catch return;
         return;
     };
 }
 @@ -211,7 +211,7 @@ pub fn assert(ok: bool) void {
     if (!ok) unreachable; // assertion failure
 }
-pub fn panic(comptime format: []const u8, args: ...) noreturn {
+pub fn panic(comptime format: []const u8, args: var) noreturn {
     @setCold(true);
     // TODO: remove conditional once wasi / LLVM defines __builtin_return_address
     const first_trace_addr = if (builtin.os == .wasi) null else @returnAddress();
 @@ -221,7 +221,7 @@ pub fn panic(comptime format: []const u8, args: ...) noreturn {
 /// TODO multithreaded awareness
 var panicking: u8 = 0; // TODO make this a bool
-pub fn panicExtra(trace: ?*const builtin.StackTrace, first_trace_addr: ?usize, comptime format: []const u8, args: ...) noreturn {
+pub fn panicExtra(trace: ?*const builtin.StackTrace, first_trace_addr: ?usize, comptime format: []const u8, args: var) noreturn {
     @setCold(true);
     if (enable_segfault_handler) {
 @@ -376,13 +376,13 @@ fn printSourceAtAddressWindows(di: *DebugInfo, out_stream: var, relocated_addres
     } else {
         // we have no information to add to the address
         if (tty_color) {
-            try out_stream.print("???:?:?: ");
+            try out_stream.print("???:?:?: ", .{});
             setTtyColor(TtyColor.Dim);
-            try out_stream.print("0x{x} in ??? (???)", relocated_address);
+            try out_stream.print("0x{x} in ??? (???)", .{relocated_address});
             setTtyColor(TtyColor.Reset);
-            try out_stream.print("\n\n\n");
+            try out_stream.print("\n\n\n", .{});
         } else {
-            try out_stream.print("???:?:?: 0x{x} in ??? (???)\n\n\n", relocated_address);
+            try out_stream.print("???:?:?: 0x{x} in ??? (???)\n\n\n", .{relocated_address});
         }
         return;
     };
 @@ -509,18 +509,18 @@ fn printSourceAtAddressWindows(di: *DebugInfo, out_stream: var, relocated_addres
     if (tty_color) {
         setTtyColor(TtyColor.White);
         if (opt_line_info) |li| {
-            try out_stream.print("{}:{}:{}", li.file_name, li.line, li.column);
+            try out_stream.print("{}:{}:{}", .{ li.file_name, li.line, li.column });
         } else {
-            try out_stream.print("???:?:?");
+            try out_stream.print("???:?:?", .{});
         }
         setTtyColor(TtyColor.Reset);
-        try out_stream.print(": ");
+        try out_stream.print(": ", .{});
         setTtyColor(TtyColor.Dim);
-        try out_stream.print("0x{x} in {} ({})", relocated_address, symbol_name, obj_basename);
+        try out_stream.print("0x{x} in {} ({})", .{ relocated_address, symbol_name, obj_basename });
         setTtyColor(TtyColor.Reset);
         if (opt_line_info) |line_info| {
-            try out_stream.print("\n");
+            try out_stream.print("\n", .{});
             if (printLineFromFileAnyOs(out_stream, line_info)) {
                 if (line_info.column == 0) {
                     try out_stream.write("\n");
 @@ -546,13 +546,24 @@ fn printSourceAtAddressWindows(di: *DebugInfo, out_stream: var, relocated_addres
                 else => return err,
             }
         } else {
-            try out_stream.print("\n\n\n");
+            try out_stream.print("\n\n\n", .{});
         }
     } else {
         if (opt_line_info) |li| {
-            try out_stream.print("{}:{}:{}: 0x{x} in {} ({})\n\n\n", li.file_name, li.line, li.column, relocated_address, symbol_name, obj_basename);
+            try out_stream.print("{}:{}:{}: 0x{x} in {} ({})\n\n\n", .{
+                li.file_name,
+                li.line,
+                li.column,
+                relocated_address,
+                symbol_name,
+                obj_basename,
+            });
         } else {
-            try out_stream.print("???:?:?: 0x{x} in {} ({})\n\n\n", relocated_address, symbol_name, obj_basename);
+            try out_stream.print("???:?:?: 0x{x} in {} ({})\n\n\n", .{
+                relocated_address,
+                symbol_name,
+                obj_basename,
+            });
         }
     }
 }
 @@ -697,9 +708,9 @@ fn printSourceAtAddressMacOs(di: *DebugInfo, out_stream: var, address: usize, tt
     const symbol = machoSearchSymbols(di.symbols, adjusted_addr) orelse {
         if (tty_color) {
-            try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in ??? (???)" ++ RESET ++ "\n\n\n", address);
+            try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in ??? (???)" ++ RESET ++ "\n\n\n", .{address});
         } else {
-            try out_stream.print("???:?:?: 0x{x} in ??? (???)\n\n\n", address);
+            try out_stream.print("???:?:?: 0x{x} in ??? (???)\n\n\n", .{address});
         }
         return;
     };
 @@ -723,9 +734,11 @@ fn printSourceAtAddressMacOs(di: *DebugInfo, out_stream: var, address: usize, tt
     } else |err| switch (err) {
         error.MissingDebugInfo, error.InvalidDebugInfo => {
             if (tty_color) {
-                try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in {} ({})" ++ RESET ++ "\n\n\n", address, symbol_name, compile_unit_name);
+                try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in {} ({})" ++ RESET ++ "\n\n\n", .{
+                    address, symbol_name, compile_unit_name,
+                });
             } else {
-                try out_stream.print("???:?:?: 0x{x} in {} ({})\n\n\n", address, symbol_name, compile_unit_name);
+                try out_stream.print("???:?:?: 0x{x} in {} ({})\n\n\n", .{ address, symbol_name, compile_unit_name });
             }
         },
         else => return err,
 @@ -746,15 +759,14 @@ fn printLineInfo(
     comptime printLineFromFile: var,
 ) !void {
     if (tty_color) {
-        try out_stream.print(
+        try out_stream.print(WHITE ++ "{}:{}:{}" ++ RESET ++ ": " ++ DIM ++ "0x{x} in {} ({})" ++ RESET ++ "\n", .{
-            WHITE ++ "{}:{}:{}" ++ RESET ++ ": " ++ DIM ++ "0x{x} in {} ({})" ++ RESET ++ "\n",
             line_info.file_name,
             line_info.line,
             line_info.column,
             address,
             symbol_name,
             compile_unit_name,
-        );
+        });
         if (printLineFromFile(out_stream, line_info)) {
             if (line_info.column == 0) {
                 try out_stream.write("\n");
 @@ -772,15 +784,14 @@ fn printLineInfo(
             else => return err,
         }
     } else {
-        try out_stream.print(
+        try out_stream.print("{}:{}:{}: 0x{x} in {} ({})\n", .{
-            "{}:{}:{}: 0x{x} in {} ({})\n",
             line_info.file_name,
             line_info.line,
             line_info.column,
             address,
             symbol_name,
             compile_unit_name,
-        );
+        });
     }
 }
 @@ -1226,9 +1237,9 @@ pub const DwarfInfo = struct {
     ) !void {
         const compile_unit = self.findCompileUnit(address) catch {
             if (tty_color) {
-                try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in ??? (???)" ++ RESET ++ "\n\n\n", address);
+                try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in ??? (???)" ++ RESET ++ "\n\n\n", .{address});
             } else {
-                try out_stream.print("???:?:?: 0x{x} in ??? (???)\n\n\n", address);
+                try out_stream.print("???:?:?: 0x{x} in ??? (???)\n\n\n", .{address});
             }
             return;
         };
 @@ -1248,9 +1259,11 @@ pub const DwarfInfo = struct {
         } else |err| switch (err) {
             error.MissingDebugInfo, error.InvalidDebugInfo => {
                 if (tty_color) {
-                    try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in ??? ({})" ++ RESET ++ "\n\n\n", address, compile_unit_name);
+                    try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in ??? ({})" ++ RESET ++ "\n\n\n", .{
+                        address, compile_unit_name,
+                    });
                 } else {
-                    try out_stream.print("???:?:?: 0x{x} in ??? ({})\n\n\n", address, compile_unit_name);
+                    try out_stream.print("???:?:?: 0x{x} in ??? ({})\n\n\n", .{ address, compile_unit_name });
                 }
             },
             else => return err,
 @@ -2416,7 +2429,7 @@ extern fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: *con
     resetSegfaultHandler();
     const addr = @ptrToInt(info.fields.sigfault.addr);
-    std.debug.warn("Segmentation fault at address 0x{x}\n", addr);
+    std.debug.warn("Segmentation fault at address 0x{x}\n", .{addr});
     switch (builtin.arch) {
         .i386 => {
 @@ -2456,10 +2469,10 @@ extern fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: *con
 stdcallcc fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) c_long {
     const exception_address = @ptrToInt(info.ExceptionRecord.ExceptionAddress);
     switch (info.ExceptionRecord.ExceptionCode) {
-        windows.EXCEPTION_DATATYPE_MISALIGNMENT => panicExtra(null, exception_address, "Unaligned Memory Access"),
+        windows.EXCEPTION_DATATYPE_MISALIGNMENT => panicExtra(null, exception_address, "Unaligned Memory Access", .{}),
-        windows.EXCEPTION_ACCESS_VIOLATION => panicExtra(null, exception_address, "Segmentation fault at address 0x{x}", info.ExceptionRecord.ExceptionInformation[1]),
+        windows.EXCEPTION_ACCESS_VIOLATION => panicExtra(null, exception_address, "Segmentation fault at address 0x{x}", .{info.ExceptionRecord.ExceptionInformation[1]}),
-        windows.EXCEPTION_ILLEGAL_INSTRUCTION => panicExtra(null, exception_address, "Illegal Instruction"),
+        windows.EXCEPTION_ILLEGAL_INSTRUCTION => panicExtra(null, exception_address, "Illegal Instruction", .{}),
-        windows.EXCEPTION_STACK_OVERFLOW => panicExtra(null, exception_address, "Stack Overflow"),
+        windows.EXCEPTION_STACK_OVERFLOW => panicExtra(null, exception_address, "Stack Overflow", .{}),
         else => return windows.EXCEPTION_CONTINUE_SEARCH,
     }
 }
 @@ -2468,7 +2481,7 @@ pub fn dumpStackPointerAddr(prefix: []const u8) void {
     const sp = asm (""
         : [argc] "={rsp}" (-> usize)
     );
-    std.debug.warn("{} sp = 0x{x}\n", prefix, sp);
+    std.debug.warn("{} sp = 0x{x}\n", .{ prefix, sp });
 }
 // Reference everything so it gets tested.

lib/std/event/channel.zig+2-2

...	@@ -294,14 +294,14 @@ test "std.event.Channel wraparound" {	...	@@ -294,14 +294,14 @@ test "std.event.Channel wraparound" {
294		294
295	const channel_size = 2;	295	const channel_size = 2;
296		296
297	var buf : [channel_size]i32 = undefined;	297	var buf: [channel_size]i32 = undefined;
298	var channel: Channel(i32) = undefined;	298	var channel: Channel(i32) = undefined;
299	channel.init(&buf);	299	channel.init(&buf);
300	defer channel.deinit();	300	defer channel.deinit();
301		301
302	// add items to channel and pull them out until	302	// add items to channel and pull them out until
303	// the buffer wraps around, make sure it doesn't crash.	303	// the buffer wraps around, make sure it doesn't crash.
304	var result : i32 = undefined;	304	var result: i32 = undefined;
305	channel.put(5);	305	channel.put(5);
306	testing.expectEqual(@as(i32, 5), channel.get());	306	testing.expectEqual(@as(i32, 5), channel.get());
307	channel.put(6);	307	channel.put(6);

lib/std/fifo.zig+2-2

...	@@ -293,7 +293,7 @@ pub fn LinearFifo(	...	@@ -293,7 +293,7 @@ pub fn LinearFifo(
293		293
294	pub usingnamespace if (T == u8)	294	pub usingnamespace if (T == u8)
295	struct {	295	struct {
296	pub fn print(self: *Self, comptime format: []const u8, args: ...) !void {	296	pub fn print(self: *Self, comptime format: []const u8, args: var) !void {
297	return std.fmt.format(self, error{OutOfMemory}, Self.write, format, args);	297	return std.fmt.format(self, error{OutOfMemory}, Self.write, format, args);
298	}	298	}
299	}	299	}
...	@@ -407,7 +407,7 @@ test "LinearFifo(u8, .Dynamic)" {	...	@@ -407,7 +407,7 @@ test "LinearFifo(u8, .Dynamic)" {
407	fifo.shrink(0);	407	fifo.shrink(0);
408		408
409	{	409	{
410	try fifo.print("{}, {}!", "Hello", "World");	410	try fifo.print("{}, {}!", .{ "Hello", "World" });
411	var result: [30]u8 = undefined;	411	var result: [30]u8 = undefined;
412	testing.expectEqualSlices(u8, "Hello, World!", result[0..fifo.read(&result)]);	412	testing.expectEqualSlices(u8, "Hello, World!", result[0..fifo.read(&result)]);
413	testing.expectEqual(@as(usize, 0), fifo.readableLength());	413	testing.expectEqual(@as(usize, 0), fifo.readableLength());

lib/std/fmt.zig+111-109

 @@ -91,10 +91,12 @@ pub fn format(
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
     comptime fmt: []const u8,
-    args: ...,
+    args: var,
 ) Errors!void {
     const ArgSetType = @IntType(false, 32);
-    if (args.len > ArgSetType.bit_count) {
+    const args_fields = std.meta.fields(@typeOf(args));
+    const args_len = args_fields.len;
+    if (args_len > ArgSetType.bit_count) {
         @compileError("32 arguments max are supported per format call");
     }
 @@ -158,14 +160,14 @@ pub fn format(
                     maybe_pos_arg.? += c - '0';
                     specifier_start = i + 1;
-                    if (maybe_pos_arg.? >= args.len) {
+                    if (maybe_pos_arg.? >= args_len) {
                         @compileError("Positional value refers to non-existent argument");
                     }
                 },
                 '}' => {
                     const arg_to_print = comptime nextArg(&used_pos_args, maybe_pos_arg, &next_arg);
-                    if (arg_to_print >= args.len) {
+                    if (arg_to_print >= args_len) {
                         @compileError("Too few arguments");
                     }
 @@ -302,7 +304,7 @@ pub fn format(
             used_pos_args |= 1 << i;
         }
-        if (@popCount(ArgSetType, used_pos_args) != args.len) {
+        if (@popCount(ArgSetType, used_pos_args) != args_len) {
             @compileError("Unused arguments");
         }
         if (state != State.Start) {
 @@ -389,7 +391,7 @@ pub fn formatType(
                 }
                 try output(context, " }");
             } else {
-                try format(context, Errors, output, "@{x}", @ptrToInt(&value));
+                try format(context, Errors, output, "@{x}", .{@ptrToInt(&value)});
             }
         },
         .Struct => {
 @@ -421,12 +423,12 @@ pub fn formatType(
                     if (info.child == u8) {
                         return formatText(value, fmt, options, context, Errors, output);
                     }
-                    return format(context, Errors, output, "{}@{x}", @typeName(T.Child), @ptrToInt(value));
+                    return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
                 },
                 builtin.TypeId.Enum, builtin.TypeId.Union, builtin.TypeId.Struct => {
                     return formatType(value.*, fmt, options, context, Errors, output, max_depth);
                 },
-                else => return format(context, Errors, output, "{}@{x}", @typeName(T.Child), @ptrToInt(value)),
+                else => return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) }),
             },
             .Many => {
                 if (ptr_info.child == u8) {
 @@ -435,7 +437,7 @@ pub fn formatType(
                         return formatText(value[0..len], fmt, options, context, Errors, output);
                     }
                 }
-                return format(context, Errors, output, "{}@{x}", @typeName(T.Child), @ptrToInt(value));
+                return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
             },
             .Slice => {
                 if (fmt.len > 0 and ((fmt[0] == 'x') or (fmt[0] == 'X'))) {
 @@ -444,10 +446,10 @@ pub fn formatType(
                 if (ptr_info.child == u8) {
                     return formatText(value, fmt, options, context, Errors, output);
                 }
-                return format(context, Errors, output, "{}@{x}", @typeName(ptr_info.child), @ptrToInt(value.ptr));
+                return format(context, Errors, output, "{}@{x}", .{ @typeName(ptr_info.child), @ptrToInt(value.ptr) });
             },
             .C => {
-                return format(context, Errors, output, "{}@{x}", @typeName(T.Child), @ptrToInt(value));
+                return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
             },
         },
         .Array => |info| {
 @@ -465,7 +467,7 @@ pub fn formatType(
             return formatType(@as(Slice, &value), fmt, options, context, Errors, output, max_depth);
         },
         .Fn => {
-            return format(context, Errors, output, "{}@{x}", @typeName(T), @ptrToInt(value));
+            return format(context, Errors, output, "{}@{x}", .{ @typeName(T), @ptrToInt(value) });
         },
         else => @compileError("Unable to format type '" ++ @typeName(T) ++ "'"),
     }
 @@ -1113,7 +1115,7 @@ pub const BufPrintError = error{
     /// As much as possible was written to the buffer, but it was too small to fit all the printed bytes.
     BufferTooSmall,
 };
-pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: ...) BufPrintError![]u8 {
+pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: var) BufPrintError![]u8 {
     var context = BufPrintContext{ .remaining = buf };
     try format(&context, BufPrintError, bufPrintWrite, fmt, args);
     return buf[0 .. buf.len - context.remaining.len];
 @@ -1121,7 +1123,7 @@ pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: ...) BufPrintError![]
 pub const AllocPrintError = error{OutOfMemory};
-pub fn allocPrint(allocator: *mem.Allocator, comptime fmt: []const u8, args: ...) AllocPrintError![]u8 {
+pub fn allocPrint(allocator: *mem.Allocator, comptime fmt: []const u8, args: var) AllocPrintError![]u8 {
     var size: usize = 0;
     format(&size, error{}, countSize, fmt, args) catch |err| switch (err) {};
     const buf = try allocator.alloc(u8, size);
 @@ -1173,46 +1175,46 @@ test "parse unsigned comptime" {
 test "optional" {
     {
         const value: ?i32 = 1234;
-        try testFmt("optional: 1234\n", "optional: {}\n", value);
+        try testFmt("optional: 1234\n", "optional: {}\n", .{value});
     }
     {
         const value: ?i32 = null;
-        try testFmt("optional: null\n", "optional: {}\n", value);
+        try testFmt("optional: null\n", "optional: {}\n", .{value});
     }
 }
 test "error" {
     {
         const value: anyerror!i32 = 1234;
-        try testFmt("error union: 1234\n", "error union: {}\n", value);
+        try testFmt("error union: 1234\n", "error union: {}\n", .{value});
     }
     {
         const value: anyerror!i32 = error.InvalidChar;
-        try testFmt("error union: error.InvalidChar\n", "error union: {}\n", value);
+        try testFmt("error union: error.InvalidChar\n", "error union: {}\n", .{value});
     }
 }
 test "int.small" {
     {
         const value: u3 = 0b101;
-        try testFmt("u3: 5\n", "u3: {}\n", value);
+        try testFmt("u3: 5\n", "u3: {}\n", .{value});
     }
 }
 test "int.specifier" {
     {
         const value: u8 = 'a';
-        try testFmt("u8: a\n", "u8: {c}\n", value);
+        try testFmt("u8: a\n", "u8: {c}\n", .{value});
     }
     {
         const value: u8 = 0b1100;
-        try testFmt("u8: 0b1100\n", "u8: 0b{b}\n", value);
+        try testFmt("u8: 0b1100\n", "u8: 0b{b}\n", .{value});
     }
 }
 test "int.padded" {
-    try testFmt("u8: '   1'", "u8: '{:4}'", @as(u8, 1));
+    try testFmt("u8: '   1'", "u8: '{:4}'", .{@as(u8, 1)});
-    try testFmt("u8: 'xxx1'", "u8: '{:x<4}'", @as(u8, 1));
+    try testFmt("u8: 'xxx1'", "u8: '{:x<4}'", .{@as(u8, 1)});
 }
 test "buffer" {
 @@ -1238,14 +1240,14 @@ test "buffer" {
 test "array" {
     {
         const value: [3]u8 = "abc".*;
-        try testFmt("array: abc\n", "array: {}\n", value);
+        try testFmt("array: abc\n", "array: {}\n", .{value});
-        try testFmt("array: abc\n", "array: {}\n", &value);
+        try testFmt("array: abc\n", "array: {}\n", .{&value});
         var buf: [100]u8 = undefined;
         try testFmt(
-            try bufPrint(buf[0..], "array: [3]u8@{x}\n", @ptrToInt(&value)),
+            try bufPrint(buf[0..], "array: [3]u8@{x}\n", .{@ptrToInt(&value)}),
             "array: {*}\n",
-            &value,
+            .{&value},
         );
     }
 }
 @@ -1253,36 +1255,36 @@ test "array" {
 test "slice" {
     {
         const value: []const u8 = "abc";
-        try testFmt("slice: abc\n", "slice: {}\n", value);
+        try testFmt("slice: abc\n", "slice: {}\n", .{value});
     }
     {
         const value = @intToPtr([*]const []const u8, 0xdeadbeef)[0..0];
-        try testFmt("slice: []const u8@deadbeef\n", "slice: {}\n", value);
+        try testFmt("slice: []const u8@deadbeef\n", "slice: {}\n", .{value});
     }
-    try testFmt("buf: Test \n", "buf: {s:5}\n", "Test");
+    try testFmt("buf: Test \n", "buf: {s:5}\n", .{"Test"});
-    try testFmt("buf: Test\n Other text", "buf: {s}\n Other text", "Test");
+    try testFmt("buf: Test\n Other text", "buf: {s}\n Other text", .{"Test"});
 }
 test "pointer" {
     {
         const value = @intToPtr(*i32, 0xdeadbeef);
-        try testFmt("pointer: i32@deadbeef\n", "pointer: {}\n", value);
+        try testFmt("pointer: i32@deadbeef\n", "pointer: {}\n", .{value});
-        try testFmt("pointer: i32@deadbeef\n", "pointer: {*}\n", value);
+        try testFmt("pointer: i32@deadbeef\n", "pointer: {*}\n", .{value});
     }
     {
         const value = @intToPtr(fn () void, 0xdeadbeef);
-        try testFmt("pointer: fn() void@deadbeef\n", "pointer: {}\n", value);
+        try testFmt("pointer: fn() void@deadbeef\n", "pointer: {}\n", .{value});
     }
     {
         const value = @intToPtr(fn () void, 0xdeadbeef);
-        try testFmt("pointer: fn() void@deadbeef\n", "pointer: {}\n", value);
+        try testFmt("pointer: fn() void@deadbeef\n", "pointer: {}\n", .{value});
     }
 }
 test "cstr" {
-    try testFmt("cstr: Test C\n", "cstr: {s}\n", "Test C");
+    try testFmt("cstr: Test C\n", "cstr: {s}\n", .{"Test C"});
-    try testFmt("cstr: Test C    \n", "cstr: {s:10}\n", "Test C");
+    try testFmt("cstr: Test C    \n", "cstr: {s:10}\n", .{"Test C"});
 }
 test "filesize" {
 @@ -1290,8 +1292,8 @@ test "filesize" {
         // TODO https://github.com/ziglang/zig/issues/3289
         return error.SkipZigTest;
     }
-    try testFmt("file size: 63MiB\n", "file size: {Bi}\n", @as(usize, 63 * 1024 * 1024));
+    try testFmt("file size: 63MiB\n", "file size: {Bi}\n", .{@as(usize, 63 * 1024 * 1024)});
-    try testFmt("file size: 66.06MB\n", "file size: {B:.2}\n", @as(usize, 63 * 1024 * 1024));
+    try testFmt("file size: 66.06MB\n", "file size: {B:.2}\n", .{@as(usize, 63 * 1024 * 1024)});
 }
 test "struct" {
 @@ -1300,8 +1302,8 @@ test "struct" {
             field: u8,
         };
         const value = Struct{ .field = 42 };
-        try testFmt("struct: Struct{ .field = 42 }\n", "struct: {}\n", value);
+        try testFmt("struct: Struct{ .field = 42 }\n", "struct: {}\n", .{value});
-        try testFmt("struct: Struct{ .field = 42 }\n", "struct: {}\n", &value);
+        try testFmt("struct: Struct{ .field = 42 }\n", "struct: {}\n", .{&value});
     }
     {
         const Struct = struct {
 @@ -1309,7 +1311,7 @@ test "struct" {
             b: u1,
         };
         const value = Struct{ .a = 0, .b = 1 };
-        try testFmt("struct: Struct{ .a = 0, .b = 1 }\n", "struct: {}\n", value);
+        try testFmt("struct: Struct{ .a = 0, .b = 1 }\n", "struct: {}\n", .{value});
     }
 }
 @@ -1319,8 +1321,8 @@ test "enum" {
         Two,
     };
     const value = Enum.Two;
-    try testFmt("enum: Enum.Two\n", "enum: {}\n", value);
+    try testFmt("enum: Enum.Two\n", "enum: {}\n", .{value});
-    try testFmt("enum: Enum.Two\n", "enum: {}\n", &value);
+    try testFmt("enum: Enum.Two\n", "enum: {}\n", .{&value});
 }
 test "float.scientific" {
 @@ -1328,10 +1330,10 @@ test "float.scientific" {
         // TODO https://github.com/ziglang/zig/issues/3289
         return error.SkipZigTest;
     }
-    try testFmt("f32: 1.34000003e+00", "f32: {e}", @as(f32, 1.34));
+    try testFmt("f32: 1.34000003e+00", "f32: {e}", .{@as(f32, 1.34)});
-    try testFmt("f32: 1.23400001e+01", "f32: {e}", @as(f32, 12.34));
+    try testFmt("f32: 1.23400001e+01", "f32: {e}", .{@as(f32, 12.34)});
-    try testFmt("f64: -1.234e+11", "f64: {e}", @as(f64, -12.34e10));
+    try testFmt("f64: -1.234e+11", "f64: {e}", .{@as(f64, -12.34e10)});
-    try testFmt("f64: 9.99996e-40", "f64: {e}", @as(f64, 9.999960e-40));
+    try testFmt("f64: 9.99996e-40", "f64: {e}", .{@as(f64, 9.999960e-40)});
 }
 test "float.scientific.precision" {
 @@ -1339,12 +1341,12 @@ test "float.scientific.precision" {
         // TODO https://github.com/ziglang/zig/issues/3289
         return error.SkipZigTest;
     }
-    try testFmt("f64: 1.40971e-42", "f64: {e:.5}", @as(f64, 1.409706e-42));
+    try testFmt("f64: 1.40971e-42", "f64: {e:.5}", .{@as(f64, 1.409706e-42)});
-    try testFmt("f64: 1.00000e-09", "f64: {e:.5}", @as(f64, @bitCast(f32, @as(u32, 814313563))));
+    try testFmt("f64: 1.00000e-09", "f64: {e:.5}", .{@as(f64, @bitCast(f32, @as(u32, 814313563)))});
-    try testFmt("f64: 7.81250e-03", "f64: {e:.5}", @as(f64, @bitCast(f32, @as(u32, 1006632960))));
+    try testFmt("f64: 7.81250e-03", "f64: {e:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1006632960)))});
     // libc rounds 1.000005e+05 to 1.00000e+05 but zig does 1.00001e+05.
     // In fact, libc doesn't round a lot of 5 cases up when one past the precision point.
-    try testFmt("f64: 1.00001e+05", "f64: {e:.5}", @as(f64, @bitCast(f32, @as(u32, 1203982400))));
+    try testFmt("f64: 1.00001e+05", "f64: {e:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1203982400)))});
 }
 test "float.special" {
 @@ -1352,14 +1354,14 @@ test "float.special" {
         // TODO https://github.com/ziglang/zig/issues/3289
         return error.SkipZigTest;
     }
-    try testFmt("f64: nan", "f64: {}", math.nan_f64);
+    try testFmt("f64: nan", "f64: {}", .{math.nan_f64});
     // negative nan is not defined by IEE 754,
     // and ARM thus normalizes it to positive nan
     if (builtin.arch != builtin.Arch.arm) {
-        try testFmt("f64: -nan", "f64: {}", -math.nan_f64);
+        try testFmt("f64: -nan", "f64: {}", .{-math.nan_f64});
     }
-    try testFmt("f64: inf", "f64: {}", math.inf_f64);
+    try testFmt("f64: inf", "f64: {}", .{math.inf_f64});
-    try testFmt("f64: -inf", "f64: {}", -math.inf_f64);
+    try testFmt("f64: -inf", "f64: {}", .{-math.inf_f64});
 }
 test "float.decimal" {
 @@ -1367,21 +1369,21 @@ test "float.decimal" {
         // TODO https://github.com/ziglang/zig/issues/3289
         return error.SkipZigTest;
     }
-    try testFmt("f64: 152314000000000000000000000000", "f64: {d}", @as(f64, 1.52314e+29));
+    try testFmt("f64: 152314000000000000000000000000", "f64: {d}", .{@as(f64, 1.52314e+29)});
-    try testFmt("f32: 1.1", "f32: {d:.1}", @as(f32, 1.1234));
+    try testFmt("f32: 1.1", "f32: {d:.1}", .{@as(f32, 1.1234)});
-    try testFmt("f32: 1234.57", "f32: {d:.2}", @as(f32, 1234.567));
+    try testFmt("f32: 1234.57", "f32: {d:.2}", .{@as(f32, 1234.567)});
     // -11.1234 is converted to f64 -11.12339... internally (errol3() function takes f64).
     // -11.12339... is rounded back up to -11.1234
-    try testFmt("f32: -11.1234", "f32: {d:.4}", @as(f32, -11.1234));
+    try testFmt("f32: -11.1234", "f32: {d:.4}", .{@as(f32, -11.1234)});
-    try testFmt("f32: 91.12345", "f32: {d:.5}", @as(f32, 91.12345));
+    try testFmt("f32: 91.12345", "f32: {d:.5}", .{@as(f32, 91.12345)});
-    try testFmt("f64: 91.1234567890", "f64: {d:.10}", @as(f64, 91.12345678901235));
+    try testFmt("f64: 91.1234567890", "f64: {d:.10}", .{@as(f64, 91.12345678901235)});
-    try testFmt("f64: 0.00000", "f64: {d:.5}", @as(f64, 0.0));
+    try testFmt("f64: 0.00000", "f64: {d:.5}", .{@as(f64, 0.0)});
-    try testFmt("f64: 6", "f64: {d:.0}", @as(f64, 5.700));
+    try testFmt("f64: 6", "f64: {d:.0}", .{@as(f64, 5.700)});
-    try testFmt("f64: 10.0", "f64: {d:.1}", @as(f64, 9.999));
+    try testFmt("f64: 10.0", "f64: {d:.1}", .{@as(f64, 9.999)});
-    try testFmt("f64: 1.000", "f64: {d:.3}", @as(f64, 1.0));
+    try testFmt("f64: 1.000", "f64: {d:.3}", .{@as(f64, 1.0)});
-    try testFmt("f64: 0.00030000", "f64: {d:.8}", @as(f64, 0.0003));
+    try testFmt("f64: 0.00030000", "f64: {d:.8}", .{@as(f64, 0.0003)});
-    try testFmt("f64: 0.00000", "f64: {d:.5}", @as(f64, 1.40130e-45));
+    try testFmt("f64: 0.00000", "f64: {d:.5}", .{@as(f64, 1.40130e-45)});
-    try testFmt("f64: 0.00000", "f64: {d:.5}", @as(f64, 9.999960e-40));
+    try testFmt("f64: 0.00000", "f64: {d:.5}", .{@as(f64, 9.999960e-40)});
 }
 test "float.libc.sanity" {
 @@ -1389,22 +1391,22 @@ test "float.libc.sanity" {
         // TODO https://github.com/ziglang/zig/issues/3289
         return error.SkipZigTest;
     }
-    try testFmt("f64: 0.00001", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 916964781))));
+    try testFmt("f64: 0.00001", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 916964781)))});
-    try testFmt("f64: 0.00001", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 925353389))));
+    try testFmt("f64: 0.00001", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 925353389)))});
-    try testFmt("f64: 0.10000", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 1036831278))));
+    try testFmt("f64: 0.10000", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1036831278)))});
-    try testFmt("f64: 1.00000", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 1065353133))));
+    try testFmt("f64: 1.00000", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1065353133)))});
-    try testFmt("f64: 10.00000", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 1092616192))));
+    try testFmt("f64: 10.00000", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1092616192)))});
     // libc differences
     //
     // This is 0.015625 exactly according to gdb. We thus round down,
     // however glibc rounds up for some reason. This occurs for all
     // floats of the form x.yyyy25 on a precision point.
-    try testFmt("f64: 0.01563", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 1015021568))));
+    try testFmt("f64: 0.01563", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1015021568)))});
     // errol3 rounds to ... 630 but libc rounds to ...632. Grisu3
     // also rounds to 630 so I'm inclined to believe libc is not
     // optimal here.
-    try testFmt("f64: 18014400656965630.00000", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 1518338049))));
+    try testFmt("f64: 18014400656965630.00000", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1518338049)))});
 }
 test "custom" {
 @@ -1422,9 +1424,9 @@ test "custom" {
             output: fn (@typeOf(context), []const u8) Errors!void,
         ) Errors!void {
             if (fmt.len == 0 or comptime std.mem.eql(u8, fmt, "p")) {
-                return std.fmt.format(context, Errors, output, "({d:.3},{d:.3})", self.x, self.y);
+                return std.fmt.format(context, Errors, output, "({d:.3},{d:.3})", .{ self.x, self.y });
             } else if (comptime std.mem.eql(u8, fmt, "d")) {
-                return std.fmt.format(context, Errors, output, "{d:.3}x{d:.3}", self.x, self.y);
+                return std.fmt.format(context, Errors, output, "{d:.3}x{d:.3}", .{ self.x, self.y });
             } else {
                 @compileError("Unknown format character: '" ++ fmt ++ "'");
             }
 @@ -1436,12 +1438,12 @@ test "custom" {
         .x = 10.2,
         .y = 2.22,
     };
-    try testFmt("point: (10.200,2.220)\n", "point: {}\n", &value);
+    try testFmt("point: (10.200,2.220)\n", "point: {}\n", .{&value});
-    try testFmt("dim: 10.200x2.220\n", "dim: {d}\n", &value);
+    try testFmt("dim: 10.200x2.220\n", "dim: {d}\n", .{&value});
     // same thing but not passing a pointer
-    try testFmt("point: (10.200,2.220)\n", "point: {}\n", value);
+    try testFmt("point: (10.200,2.220)\n", "point: {}\n", .{value});
-    try testFmt("dim: 10.200x2.220\n", "dim: {d}\n", value);
+    try testFmt("dim: 10.200x2.220\n", "dim: {d}\n", .{value});
 }
 test "struct" {
 @@ -1455,7 +1457,7 @@ test "struct" {
         .b = error.Unused,
     };
-    try testFmt("S{ .a = 456, .b = error.Unused }", "{}", inst);
+    try testFmt("S{ .a = 456, .b = error.Unused }", "{}", .{inst});
 }
 test "union" {
 @@ -1478,13 +1480,13 @@ test "union" {
     const uu_inst = UU{ .int = 456 };
     const eu_inst = EU{ .float = 321.123 };
-    try testFmt("TU{ .int = 123 }", "{}", tu_inst);
+    try testFmt("TU{ .int = 123 }", "{}", .{tu_inst});
     var buf: [100]u8 = undefined;
-    const uu_result = try bufPrint(buf[0..], "{}", uu_inst);
+    const uu_result = try bufPrint(buf[0..], "{}", .{uu_inst});
     std.testing.expect(mem.eql(u8, uu_result[0..3], "UU@"));
-    const eu_result = try bufPrint(buf[0..], "{}", eu_inst);
+    const eu_result = try bufPrint(buf[0..], "{}", .{eu_inst});
     std.testing.expect(mem.eql(u8, uu_result[0..3], "EU@"));
 }
 @@ -1497,7 +1499,7 @@ test "enum" {
     const inst = E.Two;
-    try testFmt("E.Two", "{}", inst);
+    try testFmt("E.Two", "{}", .{inst});
 }
 test "struct.self-referential" {
 @@ -1511,7 +1513,7 @@ test "struct.self-referential" {
     };
     inst.a = &inst;
-    try testFmt("S{ .a = S{ .a = S{ .a = S{ ... } } } }", "{}", inst);
+    try testFmt("S{ .a = S{ .a = S{ .a = S{ ... } } } }", "{}", .{inst});
 }
 test "struct.zero-size" {
 @@ -1526,30 +1528,30 @@ test "struct.zero-size" {
     const a = A{};
     const b = B{ .a = a, .c = 0 };
-    try testFmt("B{ .a = A{ }, .c = 0 }", "{}", b);
+    try testFmt("B{ .a = A{ }, .c = 0 }", "{}", .{b});
 }
 test "bytes.hex" {
     const some_bytes = "\xCA\xFE\xBA\xBE";
-    try testFmt("lowercase: cafebabe\n", "lowercase: {x}\n", some_bytes);
+    try testFmt("lowercase: cafebabe\n", "lowercase: {x}\n", .{some_bytes});
-    try testFmt("uppercase: CAFEBABE\n", "uppercase: {X}\n", some_bytes);
+    try testFmt("uppercase: CAFEBABE\n", "uppercase: {X}\n", .{some_bytes});
     //Test Slices
-    try testFmt("uppercase: CAFE\n", "uppercase: {X}\n", some_bytes[0..2]);
+    try testFmt("uppercase: CAFE\n", "uppercase: {X}\n", .{some_bytes[0..2]});
-    try testFmt("lowercase: babe\n", "lowercase: {x}\n", some_bytes[2..]);
+    try testFmt("lowercase: babe\n", "lowercase: {x}\n", .{some_bytes[2..]});
     const bytes_with_zeros = "\x00\x0E\xBA\xBE";
-    try testFmt("lowercase: 000ebabe\n", "lowercase: {x}\n", bytes_with_zeros);
+    try testFmt("lowercase: 000ebabe\n", "lowercase: {x}\n", .{bytes_with_zeros});
 }
-fn testFmt(expected: []const u8, comptime template: []const u8, args: ...) !void {
+fn testFmt(expected: []const u8, comptime template: []const u8, args: var) !void {
     var buf: [100]u8 = undefined;
     const result = try bufPrint(buf[0..], template, args);
     if (mem.eql(u8, result, expected)) return;
-    std.debug.warn("\n====== expected this output: =========\n");
+    std.debug.warn("\n====== expected this output: =========\n", .{});
-    std.debug.warn("{}", expected);
+    std.debug.warn("{}", .{expected});
-    std.debug.warn("\n======== instead found this: =========\n");
+    std.debug.warn("\n======== instead found this: =========\n", .{});
-    std.debug.warn("{}", result);
+    std.debug.warn("{}", .{result});
-    std.debug.warn("\n======================================\n");
+    std.debug.warn("\n======================================\n", .{});
     return error.TestFailed;
 }
 @@ -1602,7 +1604,7 @@ test "hexToBytes" {
     const test_hex_str = "909A312BB12ED1F819B3521AC4C1E896F2160507FFC1C8381E3B07BB16BD1706";
     var pb: [32]u8 = undefined;
     try hexToBytes(pb[0..], test_hex_str);
-    try testFmt(test_hex_str, "{X}", pb);
+    try testFmt(test_hex_str, "{X}", .{pb});
 }
 test "formatIntValue with comptime_int" {
 @@ -1628,7 +1630,7 @@ test "formatType max_depth" {
             output: fn (@typeOf(context), []const u8) Errors!void,
         ) Errors!void {
             if (fmt.len == 0) {
-                return std.fmt.format(context, Errors, output, "({d:.3},{d:.3})", self.x, self.y);
+                return std.fmt.format(context, Errors, output, "({d:.3},{d:.3})", .{ self.x, self.y });
             } else {
                 @compileError("Unknown format string: '" ++ fmt ++ "'");
             }
 @@ -1680,17 +1682,17 @@ test "formatType max_depth" {
 }
 test "positional" {
-    try testFmt("2 1 0", "{2} {1} {0}", @as(usize, 0), @as(usize, 1), @as(usize, 2));
+    try testFmt("2 1 0", "{2} {1} {0}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });
-    try testFmt("2 1 0", "{2} {1} {}", @as(usize, 0), @as(usize, 1), @as(usize, 2));
+    try testFmt("2 1 0", "{2} {1} {}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });
-    try testFmt("0 0", "{0} {0}", @as(usize, 0));
+    try testFmt("0 0", "{0} {0}", .{@as(usize, 0)});
-    try testFmt("0 1", "{} {1}", @as(usize, 0), @as(usize, 1));
+    try testFmt("0 1", "{} {1}", .{ @as(usize, 0), @as(usize, 1) });
-    try testFmt("1 0 0 1", "{1} {} {0} {}", @as(usize, 0), @as(usize, 1));
+    try testFmt("1 0 0 1", "{1} {} {0} {}", .{ @as(usize, 0), @as(usize, 1) });
 }
 test "positional with specifier" {
-    try testFmt("10.0", "{0d:.1}", @as(f64, 9.999));
+    try testFmt("10.0", "{0d:.1}", .{@as(f64, 9.999)});
 }
 test "positional/alignment/width/precision" {
-    try testFmt("10.0", "{0d: >3.1}", @as(f64, 9.999));
+    try testFmt("10.0", "{0d: >3.1}", .{@as(f64, 9.999)});
 }

lib/std/hash/benchmark.zig+1-1

...	@@ -164,7 +164,7 @@ fn usage() void {	...	@@ -164,7 +164,7 @@ fn usage() void {
164	\\ --iterative-only	164	\\ --iterative-only
165	\\ --help	165	\\ --help
166	\\	166	\\
167	);	167	, .{});
168	}	168	}
169		169
170	fn mode(comptime x: comptime_int) comptime_int {	170	fn mode(comptime x: comptime_int) comptime_int {

lib/std/http/headers.zig+1-1

...	@@ -610,5 +610,5 @@ test "Headers.format" {	...	@@ -610,5 +610,5 @@ test "Headers.format" {
610	\\foo: bar	610	\\foo: bar
611	\\cookie: somevalue	611	\\cookie: somevalue
612	\\	612	\\
613	, try std.fmt.bufPrint(buf[0..], "{}", h));	613	, try std.fmt.bufPrint(buf[0..], "{}", .{h}));
614	}	614	}

lib/std/io.zig+1-1

...	@@ -492,7 +492,7 @@ test "io.SliceOutStream" {	...	@@ -492,7 +492,7 @@ test "io.SliceOutStream" {
492	var slice_stream = SliceOutStream.init(buf[0..]);	492	var slice_stream = SliceOutStream.init(buf[0..]);
493	const stream = &slice_stream.stream;	493	const stream = &slice_stream.stream;
494		494
495	try stream.print("{}{}!", "Hello", "World");	495	try stream.print("{}{}!", .{ "Hello", "World" });
496	testing.expectEqualSlices(u8, "HelloWorld!", slice_stream.getWritten());	496	testing.expectEqualSlices(u8, "HelloWorld!", slice_stream.getWritten());
497	}	497	}
498		498

lib/std/io/out_stream.zig+1-1

...	@@ -35,7 +35,7 @@ pub fn OutStream(comptime WriteError: type) type {	...	@@ -35,7 +35,7 @@ pub fn OutStream(comptime WriteError: type) type {
35	}	35	}
36	}	36	}
37		37
38	pub fn print(self: *Self, comptime format: []const u8, args: ...) Error!void {	38	pub fn print(self: *Self, comptime format: []const u8, args: var) Error!void {
39	return std.fmt.format(self, Error, self.writeFn, format, args);	39	return std.fmt.format(self, Error, self.writeFn, format, args);
40	}	40	}
41		41

lib/std/io/test.zig+4-4

...	@@ -27,9 +27,9 @@ test "write a file, read it, then delete it" {	...	@@ -27,9 +27,9 @@ test "write a file, read it, then delete it" {
27	var file_out_stream = file.outStream();	27	var file_out_stream = file.outStream();
28	var buf_stream = io.BufferedOutStream(File.WriteError).init(&file_out_stream.stream);	28	var buf_stream = io.BufferedOutStream(File.WriteError).init(&file_out_stream.stream);
29	const st = &buf_stream.stream;	29	const st = &buf_stream.stream;
30	try st.print("begin");	30	try st.print("begin", .{});
31	try st.write(data[0..]);	31	try st.write(data[0..]);
32	try st.print("end");	32	try st.print("end", .{});
33	try buf_stream.flush();	33	try buf_stream.flush();
34	}	34	}
35		35
...	@@ -72,7 +72,7 @@ test "BufferOutStream" {	...	@@ -72,7 +72,7 @@ test "BufferOutStream" {
72		72
73	const x: i32 = 42;	73	const x: i32 = 42;
74	const y: i32 = 1234;	74	const y: i32 = 1234;
75	try buf_stream.print("x: {}\ny: {}\n", x, y);	75	try buf_stream.print("x: {}\ny: {}\n", .{ x, y });
76		76
77	expect(mem.eql(u8, buffer.toSlice(), "x: 42\ny: 1234\n"));	77	expect(mem.eql(u8, buffer.toSlice(), "x: 42\ny: 1234\n"));
78	}	78	}
...	@@ -605,7 +605,7 @@ test "c out stream" {	...	@@ -605,7 +605,7 @@ test "c out stream" {
605	}	605	}
606		606
607	const out_stream = &io.COutStream.init(out_file).stream;	607	const out_stream = &io.COutStream.init(out_file).stream;
608	try out_stream.print("hi: {}\n", @as(i32, 123));	608	try out_stream.print("hi: {}\n", .{@as(i32, 123)});
609	}	609	}
610		610
611	test "File seek ops" {	611	test "File seek ops" {

lib/std/json/write_stream.zig+4-4

...	@@ -158,24 +158,24 @@ pub fn WriteStream(comptime OutStream: type, comptime max_depth: usize) type {	...	@@ -158,24 +158,24 @@ pub fn WriteStream(comptime OutStream: type, comptime max_depth: usize) type {
158	switch (@typeInfo(@typeOf(value))) {	158	switch (@typeInfo(@typeOf(value))) {
159	.Int => \|info\| {	159	.Int => \|info\| {
160	if (info.bits < 53) {	160	if (info.bits < 53) {
161	try self.stream.print("{}", value);	161	try self.stream.print("{}", .{value});
162	self.popState();	162	self.popState();
163	return;	163	return;
164	}	164	}
165	if (value < 4503599627370496 and (!info.is_signed or value > -4503599627370496)) {	165	if (value < 4503599627370496 and (!info.is_signed or value > -4503599627370496)) {
166	try self.stream.print("{}", value);	166	try self.stream.print("{}", .{value});
167	self.popState();	167	self.popState();
168	return;	168	return;
169	}	169	}
170	},	170	},
171	.Float => if (@floatCast(f64, value) == value) {	171	.Float => if (@floatCast(f64, value) == value) {
172	try self.stream.print("{}", value);	172	try self.stream.print("{}", .{value});
173	self.popState();	173	self.popState();
174	return;	174	return;
175	},	175	},
176	else => {},	176	else => {},
177	}	177	}
178	try self.stream.print("\"{}\"", value);	178	try self.stream.print("\"{}\"", .{value});
179	self.popState();	179	self.popState();
180	}	180	}
181		181

lib/std/math/big/int.zig+2-2

...	@@ -180,9 +180,9 @@ pub const Int = struct {	...	@@ -180,9 +180,9 @@ pub const Int = struct {
180		180
181	pub fn dump(self: Int) void {	181	pub fn dump(self: Int) void {
182	for (self.limbs) \|limb\| {	182	for (self.limbs) \|limb\| {
183	debug.warn("{x} ", limb);	183	debug.warn("{x} ", .{limb});
184	}	184	}
185	debug.warn("\n");	185	debug.warn("\n", .{});
186	}	186	}
187		187
188	/// Negate the sign of an Int.	188	/// Negate the sign of an Int.

lib/std/net.zig+8-16

 @@ -277,32 +277,24 @@ pub const Address = extern union {
             os.AF_INET => {
                 const port = mem.bigToNative(u16, self.in.port);
                 const bytes = @ptrCast(*const [4]u8, &self.in.addr);
-                try std.fmt.format(
+                try std.fmt.format(context, Errors, output, "{}.{}.{}.{}:{}", .{
-                    context,
-                    Errors,
-                    output,
-                    "{}.{}.{}.{}:{}",
                     bytes[0],
                     bytes[1],
                     bytes[2],
                     bytes[3],
                     port,
-                );
+                });
             },
             os.AF_INET6 => {
                 const port = mem.bigToNative(u16, self.in6.port);
                 if (mem.eql(u8, self.in6.addr[0..12], &[_]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff })) {
-                    try std.fmt.format(
+                    try std.fmt.format(context, Errors, output, "[::ffff:{}.{}.{}.{}]:{}", .{
-                        context,
-                        Errors,
-                        output,
-                        "[::ffff:{}.{}.{}.{}]:{}",
                         self.in6.addr[12],
                         self.in6.addr[13],
                         self.in6.addr[14],
                         self.in6.addr[15],
                         port,
-                    );
+                    });
                     return;
                 }
                 const big_endian_parts = @ptrCast(*align(1) const [8]u16, &self.in6.addr);
 @@ -327,19 +319,19 @@ pub const Address = extern union {
                         }
                         continue;
                     }
-                    try std.fmt.format(context, Errors, output, "{x}", native_endian_parts[i]);
+                    try std.fmt.format(context, Errors, output, "{x}", .{native_endian_parts[i]});
                     if (i != native_endian_parts.len - 1) {
                         try output(context, ":");
                     }
                 }
-                try std.fmt.format(context, Errors, output, "]:{}", port);
+                try std.fmt.format(context, Errors, output, "]:{}", .{port});
             },
             os.AF_UNIX => {
                 if (!has_unix_sockets) {
                     unreachable;
                 }
-                try std.fmt.format(context, Errors, output, "{}", &self.un.path);
+                try std.fmt.format(context, Errors, output, "{}", .{&self.un.path});
             },
             else => unreachable,
         }
 @@ -445,7 +437,7 @@ pub fn getAddressList(allocator: *mem.Allocator, name: []const u8, port: u16) !*
         const name_c = try std.cstr.addNullByte(allocator, name);
         defer allocator.free(name_c);
-        const port_c = try std.fmt.allocPrint(allocator, "{}\x00", port);
+        const port_c = try std.fmt.allocPrint(allocator, "{}\x00", .{port});
         defer allocator.free(port_c);
         const hints = os.addrinfo{

lib/std/net/test.zig+3-3

lib/std/os.zig+2-2

...	@@ -2603,7 +2603,7 @@ pub fn realpathC(pathname: [:0]const u8, out_buffer: [MAX_PATH_BYTES]u8) RealP	...	@@ -2603,7 +2603,7 @@ pub fn realpathC(pathname: [:0]const u8, out_buffer: [MAX_PATH_BYTES]u8) RealP
2603	defer close(fd);	2603	defer close(fd);
2604		2604
2605	var procfs_buf: ["/proc/self/fd/-2147483648".len:0]u8 = undefined;	2605	var procfs_buf: ["/proc/self/fd/-2147483648".len:0]u8 = undefined;
2606	const proc_path = std.fmt.bufPrint(procfs_buf[0..], "/proc/self/fd/{}\x00", fd) catch unreachable;	2606	const proc_path = std.fmt.bufPrint(procfs_buf[0..], "/proc/self/fd/{}\x00", .{fd}) catch unreachable;
2607		2607
2608	return readlinkC(@ptrCast([*:0]const u8, proc_path.ptr), out_buffer);	2608	return readlinkC(@ptrCast([*:0]const u8, proc_path.ptr), out_buffer);
2609	}	2609	}
...	@@ -2832,7 +2832,7 @@ pub const UnexpectedError = error{	...	@@ -2832,7 +2832,7 @@ pub const UnexpectedError = error{
2832	/// and you get an unexpected error.	2832	/// and you get an unexpected error.
2833	pub fn unexpectedErrno(err: usize) UnexpectedError {	2833	pub fn unexpectedErrno(err: usize) UnexpectedError {
2834	if (unexpected_error_tracing) {	2834	if (unexpected_error_tracing) {
2835	std.debug.warn("unexpected errno: {}\n", err);	2835	std.debug.warn("unexpected errno: {}\n", .{err});
2836	std.debug.dumpCurrentStackTrace(null);	2836	std.debug.dumpCurrentStackTrace(null);
2837	}	2837	}
2838	return error.Unexpected;	2838	return error.Unexpected;

lib/std/os/windows.zig+3-3

lib/std/os/zen.zig deleted-260

...	@@ -1,260 +0,0 @@
1	const std = @import("../std.zig");
2	const assert = std.debug.assert;
3
4	//////////////////////////
5	//// IPC structures ////
6	//////////////////////////
7
8	pub const Message = struct {
9	sender: MailboxId,
10	receiver: MailboxId,
11	code: usize,
12	args: [5]usize,
13	payload: ?[]const u8,
14
15	pub fn from(mailbox_id: MailboxId) Message {
16	return Message{
17	.sender = MailboxId.Undefined,
18	.receiver = mailbox_id,
19	.code = undefined,
20	.args = undefined,
21	.payload = null,
22	};
23	}
24
25	pub fn to(mailbox_id: MailboxId, msg_code: usize, args: ...) Message {
26	var message = Message{
27	.sender = MailboxId.This,
28	.receiver = mailbox_id,
29	.code = msg_code,
30	.args = undefined,
31	.payload = null,
32	};
33
34	assert(args.len <= message.args.len);
35	comptime var i = 0;
36	inline while (i < args.len) : (i += 1) {
37	message.args[i] = args[i];
38	}
39
40	return message;
41	}
42
43	pub fn as(self: Message, sender: MailboxId) Message {
44	var message = self;
45	message.sender = sender;
46	return message;
47	}
48
49	pub fn withPayload(self: Message, payload: []const u8) Message {
50	var message = self;
51	message.payload = payload;
52	return message;
53	}
54	};
55
56	pub const MailboxId = union(enum) {
57	Undefined,
58	This,
59	Kernel,
60	Port: u16,
61	Thread: u16,
62	};
63
64	//////////////////////////////////////
65	//// Ports reserved for servers ////
66	//////////////////////////////////////
67
68	pub const Server = struct {
69	pub const Keyboard = MailboxId{ .Port = 0 };
70	pub const Terminal = MailboxId{ .Port = 1 };
71	};
72
73	////////////////////////
74	//// POSIX things ////
75	////////////////////////
76
77	// Standard streams.
78	pub const STDIN_FILENO = 0;
79	pub const STDOUT_FILENO = 1;
80	pub const STDERR_FILENO = 2;
81
82	// FIXME: let's borrow Linux's error numbers for now.
83	usingnamespace @import("bits/linux/errno-generic.zig");
84	// Get the errno from a syscall return value, or 0 for no error.
85	pub fn getErrno(r: usize) usize {
86	const signed_r = @bitCast(isize, r);
87	return if (signed_r > -4096 and signed_r < 0) @intCast(usize, -signed_r) else 0;
88	}
89
90	// TODO: implement this correctly.
91	pub fn read(fd: i32, buf: [*]u8, count: usize) usize {
92	switch (fd) {
93	STDIN_FILENO => {
94	var i: usize = 0;
95	while (i < count) : (i += 1) {
96	send(&Message.to(Server.Keyboard, 0));
97
98	// FIXME: we should be certain that we are receiving from Keyboard.
99	var message = Message.from(MailboxId.This);
100	receive(&message);
101
102	buf[i] = @intCast(u8, message.args[0]);
103	}
104	},
105	else => unreachable,
106	}
107	return count;
108	}
109
110	// TODO: implement this correctly.
111	pub fn write(fd: i32, buf: [*]const u8, count: usize) usize {
112	switch (fd) {
113	STDOUT_FILENO, STDERR_FILENO => {
114	send(&Message.to(Server.Terminal, 1).withPayload(buf[0..count]));
115	},
116	else => unreachable,
117	}
118	return count;
119	}
120
121	///////////////////////////
122	//// Syscall numbers ////
123	///////////////////////////
124
125	pub const Syscall = enum(usize) {
126	exit = 0,
127	send = 1,
128	receive = 2,
129	subscribeIRQ = 3,
130	inb = 4,
131	outb = 5,
132	map = 6,
133	createThread = 7,
134	};
135
136	////////////////////
137	//// Syscalls ////
138	////////////////////
139
140	pub fn exit(status: i32) noreturn {
141	_ = syscall1(Syscall.exit, @bitCast(usize, @as(isize, status)));
142	unreachable;
143	}
144
145	pub fn send(message: *const Message) void {
146	_ = syscall1(Syscall.send, @ptrToInt(message));
147	}
148
149	pub fn receive(destination: *Message) void {
150	_ = syscall1(Syscall.receive, @ptrToInt(destination));
151	}
152
153	pub fn subscribeIRQ(irq: u8, mailbox_id: *const MailboxId) void {
154	_ = syscall2(Syscall.subscribeIRQ, irq, @ptrToInt(mailbox_id));
155	}
156
157	pub fn inb(port: u16) u8 {
158	return @intCast(u8, syscall1(Syscall.inb, port));
159	}
160
161	pub fn outb(port: u16, value: u8) void {
162	_ = syscall2(Syscall.outb, port, value);
163	}
164
165	pub fn map(v_addr: usize, p_addr: usize, size: usize, writable: bool) bool {
166	return syscall4(Syscall.map, v_addr, p_addr, size, @boolToInt(writable)) != 0;
167	}
168
169	pub fn createThread(function: fn () void) u16 {
170	return @as(u16, syscall1(Syscall.createThread, @ptrToInt(function)));
171	}
172
173	/////////////////////////
174	//// Syscall stubs ////
175	/////////////////////////
176
177	inline fn syscall0(number: Syscall) usize {
178	return asm volatile ("int $0x80"
179	: [ret] "={eax}" (-> usize)
180	: [number] "{eax}" (number)
181	);
182	}
183
184	inline fn syscall1(number: Syscall, arg1: usize) usize {
185	return asm volatile ("int $0x80"
186	: [ret] "={eax}" (-> usize)
187	: [number] "{eax}" (number),
188	[arg1] "{ecx}" (arg1)
189	);
190	}
191
192	inline fn syscall2(number: Syscall, arg1: usize, arg2: usize) usize {
193	return asm volatile ("int $0x80"
194	: [ret] "={eax}" (-> usize)
195	: [number] "{eax}" (number),
196	[arg1] "{ecx}" (arg1),
197	[arg2] "{edx}" (arg2)
198	);
199	}
200
201	inline fn syscall3(number: Syscall, arg1: usize, arg2: usize, arg3: usize) usize {
202	return asm volatile ("int $0x80"
203	: [ret] "={eax}" (-> usize)
204	: [number] "{eax}" (number),
205	[arg1] "{ecx}" (arg1),
206	[arg2] "{edx}" (arg2),
207	[arg3] "{ebx}" (arg3)
208	);
209	}
210
211	inline fn syscall4(number: Syscall, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
212	return asm volatile ("int $0x80"
213	: [ret] "={eax}" (-> usize)
214	: [number] "{eax}" (number),
215	[arg1] "{ecx}" (arg1),
216	[arg2] "{edx}" (arg2),
217	[arg3] "{ebx}" (arg3),
218	[arg4] "{esi}" (arg4)
219	);
220	}
221
222	inline fn syscall5(
223	number: Syscall,
224	arg1: usize,
225	arg2: usize,
226	arg3: usize,
227	arg4: usize,
228	arg5: usize,
229	) usize {
230	return asm volatile ("int $0x80"
231	: [ret] "={eax}" (-> usize)
232	: [number] "{eax}" (number),
233	[arg1] "{ecx}" (arg1),
234	[arg2] "{edx}" (arg2),
235	[arg3] "{ebx}" (arg3),
236	[arg4] "{esi}" (arg4),
237	[arg5] "{edi}" (arg5)
238	);
239	}
240
241	inline fn syscall6(
242	number: Syscall,
243	arg1: usize,
244	arg2: usize,
245	arg3: usize,
246	arg4: usize,
247	arg5: usize,
248	arg6: usize,
249	) usize {
250	return asm volatile ("int $0x80"
251	: [ret] "={eax}" (-> usize)
252	: [number] "{eax}" (number),
253	[arg1] "{ecx}" (arg1),
254	[arg2] "{edx}" (arg2),
255	[arg3] "{ebx}" (arg3),
256	[arg4] "{esi}" (arg4),
257	[arg5] "{edi}" (arg5),
258	[arg6] "{ebp}" (arg6)
259	);
260	}

lib/std/priority_queue.zig+8-8

...	@@ -199,19 +199,19 @@ pub fn PriorityQueue(comptime T: type) type {	...	@@ -199,19 +199,19 @@ pub fn PriorityQueue(comptime T: type) type {
199	}	199	}
200		200
201	fn dump(self: *Self) void {	201	fn dump(self: *Self) void {
202	warn("{{ ");	202	warn("{{ ", .{});
203	warn("items: ");	203	warn("items: ", .{});
204	for (self.items) \|e, i\| {	204	for (self.items) \|e, i\| {
205	if (i >= self.len) break;	205	if (i >= self.len) break;
206	warn("{}, ", e);	206	warn("{}, ", .{e});
207	}	207	}
208	warn("array: ");	208	warn("array: ", .{});
209	for (self.items) \|e, i\| {	209	for (self.items) \|e, i\| {
210	warn("{}, ", e);	210	warn("{}, ", .{e});
211	}	211	}
212	warn("len: {} ", self.len);	212	warn("len: {} ", .{self.len});
213	warn("capacity: {}", self.capacity());	213	warn("capacity: {}", .{self.capacity()});
214	warn(" }}\n");	214	warn(" }}\n", .{});
215	}	215	}
216	};	216	};
217	}	217	}

lib/std/progress.zig+11-11

...	@@ -130,11 +130,11 @@ pub const Progress = struct {	...	@@ -130,11 +130,11 @@ pub const Progress = struct {
130	var end: usize = 0;	130	var end: usize = 0;
131	if (self.columns_written > 0) {	131	if (self.columns_written > 0) {
132	// restore cursor position	132	// restore cursor position
133	end += (std.fmt.bufPrint(self.output_buffer[end..], "\x1b[{}D", self.columns_written) catch unreachable).len;	133	end += (std.fmt.bufPrint(self.output_buffer[end..], "\x1b[{}D", .{self.columns_written}) catch unreachable).len;
134	self.columns_written = 0;	134	self.columns_written = 0;
135		135
136	// clear rest of line	136	// clear rest of line
137	end += (std.fmt.bufPrint(self.output_buffer[end..], "\x1b[0K") catch unreachable).len;	137	end += (std.fmt.bufPrint(self.output_buffer[end..], "\x1b[0K", .{}) catch unreachable).len;
138	}	138	}
139		139
140	if (!self.done) {	140	if (!self.done) {
...	@@ -142,28 +142,28 @@ pub const Progress = struct {	...	@@ -142,28 +142,28 @@ pub const Progress = struct {
142	var maybe_node: ?*Node = &self.root;	142	var maybe_node: ?*Node = &self.root;
143	while (maybe_node) \|node\| {	143	while (maybe_node) \|node\| {
144	if (need_ellipse) {	144	if (need_ellipse) {
145	self.bufWrite(&end, "...");	145	self.bufWrite(&end, "...", .{});
146	}	146	}
147	need_ellipse = false;	147	need_ellipse = false;
148	if (node.name.len != 0 or node.estimated_total_items != null) {	148	if (node.name.len != 0 or node.estimated_total_items != null) {
149	if (node.name.len != 0) {	149	if (node.name.len != 0) {
150	self.bufWrite(&end, "{}", node.name);	150	self.bufWrite(&end, "{}", .{node.name});
151	need_ellipse = true;	151	need_ellipse = true;
152	}	152	}
153	if (node.estimated_total_items) \|total\| {	153	if (node.estimated_total_items) \|total\| {
154	if (need_ellipse) self.bufWrite(&end, " ");	154	if (need_ellipse) self.bufWrite(&end, " ", .{});
155	self.bufWrite(&end, "[{}/{}] ", node.completed_items + 1, total);	155	self.bufWrite(&end, "[{}/{}] ", .{ node.completed_items + 1, total });
156	need_ellipse = false;	156	need_ellipse = false;
157	} else if (node.completed_items != 0) {	157	} else if (node.completed_items != 0) {
158	if (need_ellipse) self.bufWrite(&end, " ");	158	if (need_ellipse) self.bufWrite(&end, " ", .{});
159	self.bufWrite(&end, "[{}] ", node.completed_items + 1);	159	self.bufWrite(&end, "[{}] ", .{node.completed_items + 1});
160	need_ellipse = false;	160	need_ellipse = false;
161	}	161	}
162	}	162	}
163	maybe_node = node.recently_updated_child;	163	maybe_node = node.recently_updated_child;
164	}	164	}
165	if (need_ellipse) {	165	if (need_ellipse) {
166	self.bufWrite(&end, "...");	166	self.bufWrite(&end, "...", .{});
167	}	167	}
168	}	168	}
169		169
...	@@ -174,7 +174,7 @@ pub const Progress = struct {	...	@@ -174,7 +174,7 @@ pub const Progress = struct {
174	self.prev_refresh_timestamp = self.timer.read();	174	self.prev_refresh_timestamp = self.timer.read();
175	}	175	}
176		176
177	pub fn log(self: *Progress, comptime format: []const u8, args: ...) void {	177	pub fn log(self: *Progress, comptime format: []const u8, args: var) void {
178	const file = self.terminal orelse return;	178	const file = self.terminal orelse return;
179	self.refresh();	179	self.refresh();
180	file.outStream().stream.print(format, args) catch {	180	file.outStream().stream.print(format, args) catch {
...	@@ -184,7 +184,7 @@ pub const Progress = struct {	...	@@ -184,7 +184,7 @@ pub const Progress = struct {
184	self.columns_written = 0;	184	self.columns_written = 0;
185	}	185	}
186		186
187	fn bufWrite(self: Progress, end: usize, comptime format: []const u8, args: ...) void {	187	fn bufWrite(self: Progress, end: usize, comptime format: []const u8, args: var) void {
188	if (std.fmt.bufPrint(self.output_buffer[end.*..], format, args)) \|written\| {	188	if (std.fmt.bufPrint(self.output_buffer[end.*..], format, args)) \|written\| {
189	const amt = written.len;	189	const amt = written.len;
190	end.* += amt;	190	end.* += amt;

lib/std/special/build_runner.zig+18-15

 @@ -26,15 +26,15 @@ pub fn main() !void {
     _ = arg_it.skip();
     const zig_exe = try unwrapArg(arg_it.next(allocator) orelse {
-        warn("Expected first argument to be path to zig compiler\n");
+        warn("Expected first argument to be path to zig compiler\n", .{});
         return error.InvalidArgs;
     });
     const build_root = try unwrapArg(arg_it.next(allocator) orelse {
-        warn("Expected second argument to be build root directory path\n");
+        warn("Expected second argument to be build root directory path\n", .{});
         return error.InvalidArgs;
     });
     const cache_root = try unwrapArg(arg_it.next(allocator) orelse {
-        warn("Expected third argument to be cache root directory path\n");
+        warn("Expected third argument to be cache root directory path\n", .{});
         return error.InvalidArgs;
     });
 @@ -51,7 +51,7 @@ pub fn main() !void {
         if (mem.startsWith(u8, arg, "-D")) {
             const option_contents = arg[2..];
             if (option_contents.len == 0) {
-                warn("Expected option name after '-D'\n\n");
+                warn("Expected option name after '-D'\n\n", .{});
                 return usageAndErr(builder, false, stderr_stream);
             }
             if (mem.indexOfScalar(u8, option_contents, '=')) |name_end| {
 @@ -70,18 +70,18 @@ pub fn main() !void {
                 return usage(builder, false, stdout_stream);
             } else if (mem.eql(u8, arg, "--prefix")) {
                 builder.install_prefix = try unwrapArg(arg_it.next(allocator) orelse {
-                    warn("Expected argument after --prefix\n\n");
+                    warn("Expected argument after --prefix\n\n", .{});
                     return usageAndErr(builder, false, stderr_stream);
                 });
             } else if (mem.eql(u8, arg, "--search-prefix")) {
                 const search_prefix = try unwrapArg(arg_it.next(allocator) orelse {
-                    warn("Expected argument after --search-prefix\n\n");
+                    warn("Expected argument after --search-prefix\n\n", .{});
                     return usageAndErr(builder, false, stderr_stream);
                 });
                 builder.addSearchPrefix(search_prefix);
             } else if (mem.eql(u8, arg, "--override-lib-dir")) {
                 builder.override_lib_dir = try unwrapArg(arg_it.next(allocator) orelse {
-                    warn("Expected argument after --override-lib-dir\n\n");
+                    warn("Expected argument after --override-lib-dir\n\n", .{});
                     return usageAndErr(builder, false, stderr_stream);
                 });
             } else if (mem.eql(u8, arg, "--verbose-tokenize")) {
 @@ -99,7 +99,7 @@ pub fn main() !void {
             } else if (mem.eql(u8, arg, "--verbose-cc")) {
                 builder.verbose_cc = true;
             } else {
-                warn("Unrecognized argument: {}\n\n", arg);
+                warn("Unrecognized argument: {}\n\n", .{arg});
                 return usageAndErr(builder, false, stderr_stream);
             }
         } else {
 @@ -145,15 +145,15 @@ fn usage(builder: *Builder, already_ran_build: bool, out_stream: var) !void {
         \\
         \\Steps:
         \\
-    , builder.zig_exe);
+    , .{builder.zig_exe});
     const allocator = builder.allocator;
     for (builder.top_level_steps.toSliceConst()) |top_level_step| {
         const name = if (&top_level_step.step == builder.default_step)
-            try fmt.allocPrint(allocator, "{} (default)", top_level_step.step.name)
+            try fmt.allocPrint(allocator, "{} (default)", .{top_level_step.step.name})
         else
             top_level_step.step.name;
-        try out_stream.print("  {s:22} {}\n", name, top_level_step.description);
+        try out_stream.print("  {s:22} {}\n", .{ name, top_level_step.description });
     }
     try out_stream.write(
 @@ -169,12 +169,15 @@ fn usage(builder: *Builder, already_ran_build: bool, out_stream: var) !void {
     );
     if (builder.available_options_list.len == 0) {
-        try out_stream.print("  (none)\n");
+        try out_stream.print("  (none)\n", .{});
     } else {
         for (builder.available_options_list.toSliceConst()) |option| {
-            const name = try fmt.allocPrint(allocator, "  -D{}=[{}]", option.name, Builder.typeIdName(option.type_id));
+            const name = try fmt.allocPrint(allocator, "  -D{}=[{}]", .{
+                option.name,
+                Builder.typeIdName(option.type_id),
+            });
             defer allocator.free(name);
-            try out_stream.print("{s:24} {}\n", name, option.description);
+            try out_stream.print("{s:24} {}\n", .{ name, option.description });
         }
     }
 @@ -204,7 +207,7 @@ const UnwrapArgError = error{OutOfMemory};
 fn unwrapArg(arg: UnwrapArgError![]u8) UnwrapArgError![]u8 {
     return arg catch |err| {
-        warn("Unable to parse command line: {}\n", err);
+        warn("Unable to parse command line: {}\n", .{err});
         return err;
     };
 }

lib/std/special/compiler_rt/truncXfYf2_test.zig+1-1

...	@@ -217,7 +217,7 @@ fn test__truncdfsf2(a: f64, expected: u32) void {	...	@@ -217,7 +217,7 @@ fn test__truncdfsf2(a: f64, expected: u32) void {
217	}	217	}
218	}	218	}
219		219
220	@import("std").debug.warn("got 0x{x} wanted 0x{x}\n", rep, expected);	220	@import("std").debug.warn("got 0x{x} wanted 0x{x}\n", .{ rep, expected });
221		221
222	@panic("__trunctfsf2 test failure");	222	@panic("__trunctfsf2 test failure");
223	}	223	}

lib/std/special/init-exe/src/main.zig+1-1

...	@@ -1,5 +1,5 @@	...	@@ -1,5 +1,5 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn main() anyerror!void {	3	pub fn main() anyerror!void {
4	std.debug.warn("All your base are belong to us.\n");	4	std.debug.warn("All your base are belong to us.\n", .{});
5	}	5	}

lib/std/special/start.zig+2-2

...	@@ -217,7 +217,7 @@ inline fn initEventLoopAndCallMain() u8 {	...	@@ -217,7 +217,7 @@ inline fn initEventLoopAndCallMain() u8 {
217	if (std.event.Loop.instance) \|loop\| {	217	if (std.event.Loop.instance) \|loop\| {
218	if (!@hasDecl(root, "event_loop")) {	218	if (!@hasDecl(root, "event_loop")) {
219	loop.init() catch \|err\| {	219	loop.init() catch \|err\| {
220	std.debug.warn("error: {}\n", @errorName(err));	220	std.debug.warn("error: {}\n", .{@errorName(err)});
221	if (@errorReturnTrace()) \|trace\| {	221	if (@errorReturnTrace()) \|trace\| {
222	std.debug.dumpStackTrace(trace.*);	222	std.debug.dumpStackTrace(trace.*);
223	}	223	}
...	@@ -264,7 +264,7 @@ fn callMain() u8 {	...	@@ -264,7 +264,7 @@ fn callMain() u8 {
264	},	264	},
265	.ErrorUnion => {	265	.ErrorUnion => {
266	const result = root.main() catch \|err\| {	266	const result = root.main() catch \|err\| {
267	std.debug.warn("error: {}\n", @errorName(err));	267	std.debug.warn("error: {}\n", .{@errorName(err)});
268	if (@errorReturnTrace()) \|trace\| {	268	if (@errorReturnTrace()) \|trace\| {
269	std.debug.dumpStackTrace(trace.*);	269	std.debug.dumpStackTrace(trace.*);
270	}	270	}

lib/std/special/test_runner.zig+7-7

...	@@ -16,28 +16,28 @@ pub fn main() anyerror!void {	...	@@ -16,28 +16,28 @@ pub fn main() anyerror!void {
16	var test_node = root_node.start(test_fn.name, null);	16	var test_node = root_node.start(test_fn.name, null);
17	test_node.activate();	17	test_node.activate();
18	progress.refresh();	18	progress.refresh();
19	if (progress.terminal == null) std.debug.warn("{}/{} {}...", i + 1, test_fn_list.len, test_fn.name);	19	if (progress.terminal == null) std.debug.warn("{}/{} {}...", .{ i + 1, test_fn_list.len, test_fn.name });
20	if (test_fn.func()) \|_\| {	20	if (test_fn.func()) \|_\| {
21	ok_count += 1;	21	ok_count += 1;
22	test_node.end();	22	test_node.end();
23	if (progress.terminal == null) std.debug.warn("OK\n");	23	if (progress.terminal == null) std.debug.warn("OK\n", .{});
24	} else \|err\| switch (err) {	24	} else \|err\| switch (err) {
25	error.SkipZigTest => {	25	error.SkipZigTest => {
26	skip_count += 1;	26	skip_count += 1;
27	test_node.end();	27	test_node.end();
28	progress.log("{}...SKIP\n", test_fn.name);	28	progress.log("{}...SKIP\n", .{test_fn.name});
29	if (progress.terminal == null) std.debug.warn("SKIP\n");	29	if (progress.terminal == null) std.debug.warn("SKIP\n", .{});
30	},	30	},
31	else => {	31	else => {
32	progress.log("");	32	progress.log("", .{});
33	return err;	33	return err;
34	},	34	},
35	}	35	}
36	}	36	}
37	root_node.end();	37	root_node.end();
38	if (ok_count == test_fn_list.len) {	38	if (ok_count == test_fn_list.len) {
39	std.debug.warn("All {} tests passed.\n", ok_count);	39	std.debug.warn("All {} tests passed.\n", .{ok_count});
40	} else {	40	} else {
41	std.debug.warn("{} passed; {} skipped.\n", ok_count, skip_count);	41	std.debug.warn("{} passed; {} skipped.\n", .{ ok_count, skip_count });
42	}	42	}
43	}	43	}

lib/std/target.zig+6-12

 @@ -321,14 +321,12 @@ pub const Target = union(enum) {
     pub const stack_align = 16;
     pub fn zigTriple(self: Target, allocator: *mem.Allocator) ![]u8 {
-        return std.fmt.allocPrint(
+        return std.fmt.allocPrint(allocator, "{}{}-{}-{}", .{
-            allocator,
-            "{}{}-{}-{}",
             @tagName(self.getArch()),
             Target.archSubArchName(self.getArch()),
             @tagName(self.getOs()),
             @tagName(self.getAbi()),
-        );
+        });
     }
     /// Returned slice must be freed by the caller.
 @@ -372,23 +370,19 @@ pub const Target = union(enum) {
     }
     pub fn zigTripleNoSubArch(self: Target, allocator: *mem.Allocator) ![]u8 {
-        return std.fmt.allocPrint(
+        return std.fmt.allocPrint(allocator, "{}-{}-{}", .{
-            allocator,
-            "{}-{}-{}",
             @tagName(self.getArch()),
             @tagName(self.getOs()),
             @tagName(self.getAbi()),
-        );
+        });
     }
     pub fn linuxTriple(self: Target, allocator: *mem.Allocator) ![]u8 {
-        return std.fmt.allocPrint(
+        return std.fmt.allocPrint(allocator, "{}-{}-{}", .{
-            allocator,
-            "{}-{}-{}",
             @tagName(self.getArch()),
             @tagName(self.getOs()),
             @tagName(self.getAbi()),
-        );
+        });
     }
     pub fn parse(text: []const u8) !Target {

lib/std/testing.zig+23-18

 @@ -8,13 +8,19 @@ pub fn expectError(expected_error: anyerror, actual_error_union: var) void {
     if (actual_error_union) |actual_payload| {
         // TODO remove workaround here for https://github.com/ziglang/zig/issues/557
         if (@sizeOf(@typeOf(actual_payload)) == 0) {
-            std.debug.panic("expected error.{}, found {} value", @errorName(expected_error), @typeName(@typeOf(actual_payload)));
+            std.debug.panic("expected error.{}, found {} value", .{
+                @errorName(expected_error),
+                @typeName(@typeOf(actual_payload)),
+            });
         } else {
-            std.debug.panic("expected error.{}, found {}", @errorName(expected_error), actual_payload);
+            std.debug.panic("expected error.{}, found {}", .{ @errorName(expected_error), actual_payload });
         }
     } else |actual_error| {
         if (expected_error != actual_error) {
-            std.debug.panic("expected error.{}, found error.{}", @errorName(expected_error), @errorName(actual_error));
+            std.debug.panic("expected error.{}, found error.{}", .{
+                @errorName(expected_error),
+                @errorName(actual_error),
+            });
         }
     }
 }
 @@ -51,7 +57,7 @@ pub fn expectEqual(expected: var, actual: @typeOf(expected)) void {
         .ErrorSet,
         => {
             if (actual != expected) {
-                std.debug.panic("expected {}, found {}", expected, actual);
+                std.debug.panic("expected {}, found {}", .{ expected, actual });
             }
         },
 @@ -62,16 +68,16 @@ pub fn expectEqual(expected: var, actual: @typeOf(expected)) void {
                 builtin.TypeInfo.Pointer.Size.C,
                 => {
                     if (actual != expected) {
-                        std.debug.panic("expected {*}, found {*}", expected, actual);
+                        std.debug.panic("expected {*}, found {*}", .{ expected, actual });
                     }
                 },
                 builtin.TypeInfo.Pointer.Size.Slice => {
                     if (actual.ptr != expected.ptr) {
-                        std.debug.panic("expected slice ptr {}, found {}", expected.ptr, actual.ptr);
+                        std.debug.panic("expected slice ptr {}, found {}", .{ expected.ptr, actual.ptr });
                     }
                     if (actual.len != expected.len) {
-                        std.debug.panic("expected slice len {}, found {}", expected.len, actual.len);
+                        std.debug.panic("expected slice len {}, found {}", .{ expected.len, actual.len });
                     }
                 },
             }
 @@ -106,7 +112,7 @@ pub fn expectEqual(expected: var, actual: @typeOf(expected)) void {
             }
             // we iterate over *all* union fields
             // => we should never get here as the loop above is
             //    including all possible values.
             unreachable;
         },
 @@ -116,11 +122,11 @@ pub fn expectEqual(expected: var, actual: @typeOf(expected)) void {
                 if (actual) |actual_payload| {
                     expectEqual(expected_payload, actual_payload);
                 } else {
-                    std.debug.panic("expected {}, found null", expected_payload);
+                    std.debug.panic("expected {}, found null", .{expected_payload});
                 }
             } else {
                 if (actual) |actual_payload| {
-                    std.debug.panic("expected null, found {}", actual_payload);
+                    std.debug.panic("expected null, found {}", .{actual_payload});
                 }
             }
         },
 @@ -130,11 +136,11 @@ pub fn expectEqual(expected: var, actual: @typeOf(expected)) void {
                 if (actual) |actual_payload| {
                     expectEqual(expected_payload, actual_payload);
                 } else |actual_err| {
-                    std.debug.panic("expected {}, found {}", expected_payload, actual_err);
+                    std.debug.panic("expected {}, found {}", .{ expected_payload, actual_err });
                 }
             } else |expected_err| {
                 if (actual) |actual_payload| {
-                    std.debug.panic("expected {}, found {}", expected_err, actual_payload);
+                    std.debug.panic("expected {}, found {}", .{ expected_err, actual_payload });
                 } else |actual_err| {
                     expectEqual(expected_err, actual_err);
                 }
 @@ -143,15 +149,14 @@ pub fn expectEqual(expected: var, actual: @typeOf(expected)) void {
     }
 }
-test "expectEqual.union(enum)"
+test "expectEqual.union(enum)" {
-{
     const T = union(enum) {
         a: i32,
         b: f32,
     };
-    const a10 = T { .a = 10 };
+    const a10 = T{ .a = 10 };
-    const a20 = T { .a = 20 };
+    const a20 = T{ .a = 20 };
     expectEqual(a10, a10);
 }
 @@ -165,12 +170,12 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
     // If the child type is u8 and no weird bytes, we could print it as strings
     // Even for the length difference, it would be useful to see the values of the slices probably.
     if (expected.len != actual.len) {
-        std.debug.panic("slice lengths differ. expected {}, found {}", expected.len, actual.len);
+        std.debug.panic("slice lengths differ. expected {}, found {}", .{ expected.len, actual.len });
     }
     var i: usize = 0;
     while (i < expected.len) : (i += 1) {
         if (expected[i] != actual[i]) {
-            std.debug.panic("index {} incorrect. expected {}, found {}", i, expected[i], actual[i]);
+            std.debug.panic("index {} incorrect. expected {}, found {}", .{ i, expected[i], actual[i] });
         }
     }
 }

lib/std/unicode.zig+1-1

...	@@ -170,7 +170,7 @@ pub fn utf8ValidateSlice(s: []const u8) bool {	...	@@ -170,7 +170,7 @@ pub fn utf8ValidateSlice(s: []const u8) bool {
170	/// ```	170	/// ```
171	/// var utf8 = (try std.unicode.Utf8View.init("hi there")).iterator();	171	/// var utf8 = (try std.unicode.Utf8View.init("hi there")).iterator();
172	/// while (utf8.nextCodepointSlice()) \|codepoint\| {	172	/// while (utf8.nextCodepointSlice()) \|codepoint\| {
173	/// std.debug.warn("got codepoint {}\n", codepoint);	173	/// std.debug.warn("got codepoint {}\n", .{codepoint});
174	/// }	174	/// }
175	/// ```	175	/// ```
176	pub const Utf8View = struct {	176	pub const Utf8View = struct {

lib/std/unicode/throughput_test.zig+6-2

 @@ -24,8 +24,12 @@ pub fn main() !void {
     const elapsed_ns_better = timer.lap();
     @fence(.SeqCst);
-    std.debug.warn("original utf8ToUtf16Le: elapsed: {} ns ({} ms)\n", elapsed_ns_orig, elapsed_ns_orig / 1000000);
+    std.debug.warn("original utf8ToUtf16Le: elapsed: {} ns ({} ms)\n", .{
-    std.debug.warn("new utf8ToUtf16Le: elapsed: {} ns ({} ms)\n", elapsed_ns_better, elapsed_ns_better / 1000000);
+        elapsed_ns_orig, elapsed_ns_orig / 1000000,
+    });
+    std.debug.warn("new utf8ToUtf16Le: elapsed: {} ns ({} ms)\n", .{
+        elapsed_ns_better, elapsed_ns_better / 1000000,
+    });
     asm volatile ("nop"
         :
         : [a] "r" (&buffer1),

lib/std/valgrind.zig-14

...	@@ -114,20 +114,6 @@ pub fn innerThreads(qzz: [*]u8) void {	...	@@ -114,20 +114,6 @@ pub fn innerThreads(qzz: [*]u8) void {
114	doClientRequestStmt(.InnerThreads, qzz, 0, 0, 0, 0);	114	doClientRequestStmt(.InnerThreads, qzz, 0, 0, 0, 0);
115	}	115	}
116		116
117	//pub fn printf(format: [*]const u8, args: ...) usize {
118	// return doClientRequestExpr(0,
119	// .PrintfValistByRef,
120	// @ptrToInt(format), @ptrToInt(args),
121	// 0, 0, 0);
122	//}
123
124	//pub fn printfBacktrace(format: [*]const u8, args: ...) usize {
125	// return doClientRequestExpr(0,
126	// .PrintfBacktraceValistByRef,
127	// @ptrToInt(format), @ptrToInt(args),
128	// 0, 0, 0);
129	//}
130
131	pub fn nonSIMDCall0(func: fn (usize) usize) usize {	117	pub fn nonSIMDCall0(func: fn (usize) usize) usize {
132	return doClientRequestExpr(0, .ClientCall0, @ptrToInt(func), 0, 0, 0, 0);	118	return doClientRequestExpr(0, .ClientCall0, @ptrToInt(func), 0, 0, 0, 0);
133	}	119	}

lib/std/zig/ast.zig+15-9

 @@ -301,7 +301,9 @@ pub const Error = union(enum) {
         node: *Node,
         pub fn render(self: *const ExpectedCall, tokens: *Tree.TokenList, stream: var) !void {
-            return stream.print("expected " ++ @tagName(@TagType(Node.SuffixOp.Op).Call) ++ ", found {}", @tagName(self.node.id));
+            return stream.print("expected " ++ @tagName(@TagType(Node.SuffixOp.Op).Call) ++ ", found {}", .{
+                @tagName(self.node.id),
+            });
         }
     };
 @@ -309,7 +311,8 @@ pub const Error = union(enum) {
         node: *Node,
         pub fn render(self: *const ExpectedCallOrFnProto, tokens: *Tree.TokenList, stream: var) !void {
-            return stream.print("expected " ++ @tagName(@TagType(Node.SuffixOp.Op).Call) ++ " or " ++ @tagName(Node.Id.FnProto) ++ ", found {}", @tagName(self.node.id));
+            return stream.print("expected " ++ @tagName(@TagType(Node.SuffixOp.Op).Call) ++ " or " ++
+                @tagName(Node.Id.FnProto) ++ ", found {}", .{@tagName(self.node.id)});
         }
     };
 @@ -321,14 +324,14 @@ pub const Error = union(enum) {
             const found_token = tokens.at(self.token);
             switch (found_token.id) {
                 .Invalid_ampersands => {
-                    return stream.print("`&&` is invalid. Note that `and` is boolean AND.");
+                    return stream.print("`&&` is invalid. Note that `and` is boolean AND.", .{});
                 },
                 .Invalid => {
-                    return stream.print("expected '{}', found invalid bytes", self.expected_id.symbol());
+                    return stream.print("expected '{}', found invalid bytes", .{self.expected_id.symbol()});
                 },
                 else => {
                     const token_name = found_token.id.symbol();
-                    return stream.print("expected '{}', found '{}'", self.expected_id.symbol(), token_name);
+                    return stream.print("expected '{}', found '{}'", .{ self.expected_id.symbol(), token_name });
                 },
             }
         }
 @@ -340,7 +343,10 @@ pub const Error = union(enum) {
         pub fn render(self: *const ExpectedCommaOrEnd, tokens: *Tree.TokenList, stream: var) !void {
             const actual_token = tokens.at(self.token);
-            return stream.print("expected ',' or '{}', found '{}'", self.end_id.symbol(), actual_token.id.symbol());
+            return stream.print("expected ',' or '{}', found '{}'", .{
+                self.end_id.symbol(),
+                actual_token.id.symbol(),
+            });
         }
     };
 @@ -352,7 +358,7 @@ pub const Error = union(enum) {
             pub fn render(self: *const ThisError, tokens: *Tree.TokenList, stream: var) !void {
                 const actual_token = tokens.at(self.token);
-                return stream.print(msg, actual_token.id.symbol());
+                return stream.print(msg, .{actual_token.id.symbol()});
             }
         };
     }
 @@ -563,10 +569,10 @@ pub const Node = struct {
         {
             var i: usize = 0;
             while (i < indent) : (i += 1) {
-                std.debug.warn(" ");
+                std.debug.warn(" ", .{});
             }
         }
-        std.debug.warn("{}\n", @tagName(self.id));
+        std.debug.warn("{}\n", .{@tagName(self.id)});
         var child_i: usize = 0;
         while (self.iterate(child_i)) |child| : (child_i += 1) {

lib/std/zig/parser_test.zig+16-30

 @@ -642,15 +642,6 @@ test "zig fmt: fn decl with trailing comma" {
     );
 }
-test "zig fmt: var_args with trailing comma" {
-    try testCanonical(
-        \\pub fn add(
-        \\    a: ...,
-        \\) void {}
-        \\
-    );
-}
 test "zig fmt: enum decl with no trailing comma" {
     try testTransform(
         \\const StrLitKind = enum {Normal, C};
 @@ -1750,13 +1741,6 @@ test "zig fmt: call expression" {
     );
 }
-test "zig fmt: var args" {
-    try testCanonical(
-        \\fn print(args: ...) void {}
-        \\
-    );
-}
 test "zig fmt: var type" {
     try testCanonical(
         \\fn print(args: var) var {}
 @@ -2705,9 +2689,9 @@ fn testParse(source: []const u8, allocator: *mem.Allocator, anything_changed: *b
     while (error_it.next()) |parse_error| {
         const token = tree.tokens.at(parse_error.loc());
         const loc = tree.tokenLocation(0, parse_error.loc());
-        try stderr.print("(memory buffer):{}:{}: error: ", loc.line + 1, loc.column + 1);
+        try stderr.print("(memory buffer):{}:{}: error: ", .{ loc.line + 1, loc.column + 1 });
         try tree.renderError(parse_error, stderr);
-        try stderr.print("\n{}\n", source[loc.line_start..loc.line_end]);
+        try stderr.print("\n{}\n", .{source[loc.line_start..loc.line_end]});
         {
             var i: usize = 0;
             while (i < loc.column) : (i += 1) {
 @@ -2743,16 +2727,16 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void {
         var anything_changed: bool = undefined;
         const result_source = try testParse(source, &failing_allocator.allocator, &anything_changed);
         if (!mem.eql(u8, result_source, expected_source)) {
-            warn("\n====== expected this output: =========\n");
+            warn("\n====== expected this output: =========\n", .{});
-            warn("{}", expected_source);
+            warn("{}", .{expected_source});
-            warn("\n======== instead found this: =========\n");
+            warn("\n======== instead found this: =========\n", .{});
-            warn("{}", result_source);
+            warn("{}", .{result_source});
-            warn("\n======================================\n");
+            warn("\n======================================\n", .{});
             return error.TestFailed;
         }
         const changes_expected = source.ptr != expected_source.ptr;
         if (anything_changed != changes_expected) {
-            warn("std.zig.render returned {} instead of {}\n", anything_changed, changes_expected);
+            warn("std.zig.render returned {} instead of {}\n", .{ anything_changed, changes_expected });
             return error.TestFailed;
         }
         std.testing.expect(anything_changed == changes_expected);
 @@ -2772,12 +2756,14 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void {
                 if (failing_allocator.allocated_bytes != failing_allocator.freed_bytes) {
                     warn(
                         "\nfail_index: {}/{}\nallocated bytes: {}\nfreed bytes: {}\nallocations: {}\ndeallocations: {}\n",
-                        fail_index,
+                        .{
-                        needed_alloc_count,
+                            fail_index,
-                        failing_allocator.allocated_bytes,
+                            needed_alloc_count,
-                        failing_allocator.freed_bytes,
+                            failing_allocator.allocated_bytes,
-                        failing_allocator.allocations,
+                            failing_allocator.freed_bytes,
-                        failing_allocator.deallocations,
+                            failing_allocator.allocations,
+                            failing_allocator.deallocations,
+                        },
                     );
                     return error.MemoryLeakDetected;
                 }

lib/std/zig/render.zig+3-3

...	@@ -76,7 +76,7 @@ fn renderRoot(	...	@@ -76,7 +76,7 @@ fn renderRoot(
76	// render all the line comments at the beginning of the file	76	// render all the line comments at the beginning of the file
77	while (tok_it.next()) \|token\| {	77	while (tok_it.next()) \|token\| {
78	if (token.id != .LineComment) break;	78	if (token.id != .LineComment) break;
79	try stream.print("{}\n", mem.trimRight(u8, tree.tokenSlicePtr(token), " "));	79	try stream.print("{}\n", .{mem.trimRight(u8, tree.tokenSlicePtr(token), " ")});
80	if (tok_it.peek()) \|next_token\| {	80	if (tok_it.peek()) \|next_token\| {
81	const loc = tree.tokenLocationPtr(token.end, next_token);	81	const loc = tree.tokenLocationPtr(token.end, next_token);
82	if (loc.line >= 2) {	82	if (loc.line >= 2) {
...	@@ -1226,7 +1226,7 @@ fn renderExpression(	...	@@ -1226,7 +1226,7 @@ fn renderExpression(
1226		1226
1227	var skip_first_indent = true;	1227	var skip_first_indent = true;
1228	if (tree.tokens.at(multiline_str_literal.firstToken() - 1).id != .LineComment) {	1228	if (tree.tokens.at(multiline_str_literal.firstToken() - 1).id != .LineComment) {
1229	try stream.print("\n");	1229	try stream.print("\n", .{});
1230	skip_first_indent = false;	1230	skip_first_indent = false;
1231	}	1231	}
1232		1232
...	@@ -2129,7 +2129,7 @@ fn renderTokenOffset(	...	@@ -2129,7 +2129,7 @@ fn renderTokenOffset(
2129		2129
2130	var loc = tree.tokenLocationPtr(token.end, next_token);	2130	var loc = tree.tokenLocationPtr(token.end, next_token);
2131	if (loc.line == 0) {	2131	if (loc.line == 0) {
2132	try stream.print(" {}", mem.trimRight(u8, tree.tokenSlicePtr(next_token), " "));	2132	try stream.print(" {}", .{mem.trimRight(u8, tree.tokenSlicePtr(next_token), " ")});
2133	offset = 2;	2133	offset = 2;
2134	token = next_token;	2134	token = next_token;
2135	next_token = tree.tokens.at(token_index + offset);	2135	next_token = tree.tokens.at(token_index + offset);

lib/std/zig/tokenizer.zig+2-2

...	@@ -330,7 +330,7 @@ pub const Tokenizer = struct {	...	@@ -330,7 +330,7 @@ pub const Tokenizer = struct {
330		330
331	/// For debugging purposes	331	/// For debugging purposes
332	pub fn dump(self: Tokenizer, token: const Token) void {	332	pub fn dump(self: Tokenizer, token: const Token) void {
333	std.debug.warn("{} \"{}\"\n", @tagName(token.id), self.buffer[token.start..token.end]);	333	std.debug.warn("{} \"{}\"\n", .{ @tagName(token.id), self.buffer[token.start..token.end] });
334	}	334	}
335		335
336	pub fn init(buffer: []const u8) Tokenizer {	336	pub fn init(buffer: []const u8) Tokenizer {
...	@@ -1576,7 +1576,7 @@ fn testTokenize(source: []const u8, expected_tokens: []const Token.Id) void {	...	@@ -1576,7 +1576,7 @@ fn testTokenize(source: []const u8, expected_tokens: []const Token.Id) void {
1576	for (expected_tokens) \|expected_token_id\| {	1576	for (expected_tokens) \|expected_token_id\| {
1577	const token = tokenizer.next();	1577	const token = tokenizer.next();
1578	if (token.id != expected_token_id) {	1578	if (token.id != expected_token_id) {
1579	std.debug.panic("expected {}, found {}\n", @tagName(expected_token_id), @tagName(token.id));	1579	std.debug.panic("expected {}, found {}\n", .{ @tagName(expected_token_id), @tagName(token.id) });
1580	}	1580	}
1581	}	1581	}
1582	const last_token = tokenizer.next();	1582	const last_token = tokenizer.next();

src-self-hosted/arg.zig+6-6

src-self-hosted/codegen.zig+6-8

 @@ -45,13 +45,11 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
     // Don't use ZIG_VERSION_STRING here. LLVM misparses it when it includes
     // the git revision.
-    const producer = try std.Buffer.allocPrint(
+    const producer = try std.Buffer.allocPrint(&code.arena.allocator, "zig {}.{}.{}", .{
-        &code.arena.allocator,
-        "zig {}.{}.{}",
         @as(u32, c.ZIG_VERSION_MAJOR),
         @as(u32, c.ZIG_VERSION_MINOR),
         @as(u32, c.ZIG_VERSION_PATCH),
-    );
+    });
     const flags = "";
     const runtime_version = 0;
     const compile_unit_file = llvm.CreateFile(
 @@ -93,7 +91,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
     llvm.DIBuilderFinalize(dibuilder);
     if (comp.verbose_llvm_ir) {
-        std.debug.warn("raw module:\n");
+        std.debug.warn("raw module:\n", .{});
         llvm.DumpModule(ofile.module);
     }
 @@ -120,18 +118,18 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
         is_small,
     )) {
         if (std.debug.runtime_safety) {
-            std.debug.panic("unable to write object file {}: {s}\n", output_path.toSliceConst(), err_msg);
+            std.debug.panic("unable to write object file {}: {s}\n", .{ output_path.toSliceConst(), err_msg });
         }
         return error.WritingObjectFileFailed;
     }
     //validate_inline_fns(g); TODO
     fn_val.containing_object = output_path;
     if (comp.verbose_llvm_ir) {
-        std.debug.warn("optimized module:\n");
+        std.debug.warn("optimized module:\n", .{});
         llvm.DumpModule(ofile.module);
     }
     if (comp.verbose_link) {
-        std.debug.warn("created {}\n", output_path.toSliceConst());
+        std.debug.warn("created {}\n", .{output_path.toSliceConst()});
     }
 }

src-self-hosted/compilation.zig+12-15

src-self-hosted/dep_tokenizer.zig+15-15

src-self-hosted/errmsg.zig+5-7

 @@ -231,7 +231,7 @@ pub const Msg = struct {
     pub fn printToStream(msg: *const Msg, stream: var, color_on: bool) !void {
         switch (msg.data) {
             .Cli => {
-                try stream.print("{}:-:-: error: {}\n", msg.realpath, msg.text);
+                try stream.print("{}:-:-: error: {}\n", .{ msg.realpath, msg.text });
                 return;
             },
             else => {},
 @@ -254,24 +254,22 @@ pub const Msg = struct {
         const start_loc = tree.tokenLocationPtr(0, first_token);
         const end_loc = tree.tokenLocationPtr(first_token.end, last_token);
         if (!color_on) {
-            try stream.print(
+            try stream.print("{}:{}:{}: error: {}\n", .{
-                "{}:{}:{}: error: {}\n",
                 path,
                 start_loc.line + 1,
                 start_loc.column + 1,
                 msg.text,
-            );
+            });
             return;
         }
-        try stream.print(
+        try stream.print("{}:{}:{}: error: {}\n{}\n", .{
-            "{}:{}:{}: error: {}\n{}\n",
             path,
             start_loc.line + 1,
             start_loc.column + 1,
             msg.text,
             tree.source[start_loc.line_start..start_loc.line_end],
-        );
+        });
         try stream.writeByteNTimes(' ', start_loc.column);
         try stream.writeByteNTimes('~', last_token.end - first_token.start);
         try stream.write("\n");

src-self-hosted/introspect.zig+1-1

...	@@ -48,7 +48,7 @@ pub fn resolveZigLibDir(allocator: *mem.Allocator) ![]u8 {	...	@@ -48,7 +48,7 @@ pub fn resolveZigLibDir(allocator: *mem.Allocator) ![]u8 {
48	\\Unable to find zig lib directory: {}.	48	\\Unable to find zig lib directory: {}.
49	\\Reinstall Zig or use --zig-install-prefix.	49	\\Reinstall Zig or use --zig-install-prefix.
50	\\	50	\\
51	, @errorName(err));	51	, .{@errorName(err)});
52		52
53	return error.ZigLibDirNotFound;	53	return error.ZigLibDirNotFound;
54	};	54	};

src-self-hosted/ir.zig+38-40

src-self-hosted/libc_installation.zig+13-15

...	@@ -65,7 +65,7 @@ pub const LibCInstallation = struct {	...	@@ -65,7 +65,7 @@ pub const LibCInstallation = struct {
65	if (line.len == 0 or line[0] == '#') continue;	65	if (line.len == 0 or line[0] == '#') continue;
66	var line_it = std.mem.separate(line, "=");	66	var line_it = std.mem.separate(line, "=");
67	const name = line_it.next() orelse {	67	const name = line_it.next() orelse {
68	try stderr.print("missing equal sign after field name\n");	68	try stderr.print("missing equal sign after field name\n", .{});
69	return error.ParseError;	69	return error.ParseError;
70	};	70	};
71	const value = line_it.rest();	71	const value = line_it.rest();
...	@@ -83,7 +83,7 @@ pub const LibCInstallation = struct {	...	@@ -83,7 +83,7 @@ pub const LibCInstallation = struct {
83	},	83	},
84	else => {	84	else => {
85	if (value.len == 0) {	85	if (value.len == 0) {
86	try stderr.print("field cannot be empty: {}\n", key);	86	try stderr.print("field cannot be empty: {}\n", .{key});
87	return error.ParseError;	87	return error.ParseError;
88	}	88	}
89	const dupe = try std.mem.dupe(allocator, u8, value);	89	const dupe = try std.mem.dupe(allocator, u8, value);
...	@@ -97,7 +97,7 @@ pub const LibCInstallation = struct {	...	@@ -97,7 +97,7 @@ pub const LibCInstallation = struct {
97	}	97	}
98	for (found_keys) \|found_key, i\| {	98	for (found_keys) \|found_key, i\| {
99	if (!found_key.found) {	99	if (!found_key.found) {
100	try stderr.print("missing field: {}\n", keys[i]);	100	try stderr.print("missing field: {}\n", .{keys[i]});
101	return error.ParseError;	101	return error.ParseError;
102	}	102	}
103	}	103	}
...	@@ -105,6 +105,11 @@ pub const LibCInstallation = struct {	...	@@ -105,6 +105,11 @@ pub const LibCInstallation = struct {
105		105
106	pub fn render(self: const LibCInstallation, out: std.io.OutStream(fs.File.WriteError)) !void {	106	pub fn render(self: const LibCInstallation, out: std.io.OutStream(fs.File.WriteError)) !void {
107	@setEvalBranchQuota(4000);	107	@setEvalBranchQuota(4000);
		108	const lib_dir = self.lib_dir orelse "";
		109	const static_lib_dir = self.static_lib_dir orelse "";
		110	const msvc_lib_dir = self.msvc_lib_dir orelse "";
		111	const kernel32_lib_dir = self.kernel32_lib_dir orelse "";
		112	const dynamic_linker_path = self.dynamic_linker_path orelse util.getDynamicLinkerPath(Target{ .Native = {} });
108	try out.print(	113	try out.print(
109	\\# The directory that contains `stdlib.h`.	114	\\# The directory that contains `stdlib.h`.
110	\\# On Linux, can be found with: `cc -E -Wp,-v -xc /dev/null`	115	\\# On Linux, can be found with: `cc -E -Wp,-v -xc /dev/null`
...	@@ -132,14 +137,7 @@ pub const LibCInstallation = struct {	...	@@ -132,14 +137,7 @@ pub const LibCInstallation = struct {
132	\\# Only needed when targeting Linux.	137	\\# Only needed when targeting Linux.
133	\\dynamic_linker_path={}	138	\\dynamic_linker_path={}
134	\\	139	\\
135	,	140	, .{ self.include_dir, lib_dir, static_lib_dir, msvc_lib_dir, kernel32_lib_dir, dynamic_linker_path });
136	self.include_dir,
137	self.lib_dir orelse "",
138	self.static_lib_dir orelse "",
139	self.msvc_lib_dir orelse "",
140	self.kernel32_lib_dir orelse "",
141	self.dynamic_linker_path orelse util.getDynamicLinkerPath(Target{ .Native = {} }),
142	);
143	}	141	}
144		142
145	/// Finds the default, native libc.	143	/// Finds the default, native libc.
...	@@ -255,7 +253,7 @@ pub const LibCInstallation = struct {	...	@@ -255,7 +253,7 @@ pub const LibCInstallation = struct {
255	for (searches) \|search\| {	253	for (searches) \|search\| {
256	result_buf.shrink(0);	254	result_buf.shrink(0);
257	const stream = &std.io.BufferOutStream.init(&result_buf).stream;	255	const stream = &std.io.BufferOutStream.init(&result_buf).stream;
258	try stream.print("{}\\Include\\{}\\ucrt", search.path, search.version);	256	try stream.print("{}\\Include\\{}\\ucrt", .{ search.path, search.version });
259		257
260	const stdlib_path = try fs.path.join(	258	const stdlib_path = try fs.path.join(
261	allocator,	259	allocator,
...	@@ -282,7 +280,7 @@ pub const LibCInstallation = struct {	...	@@ -282,7 +280,7 @@ pub const LibCInstallation = struct {
282	for (searches) \|search\| {	280	for (searches) \|search\| {
283	result_buf.shrink(0);	281	result_buf.shrink(0);
284	const stream = &std.io.BufferOutStream.init(&result_buf).stream;	282	const stream = &std.io.BufferOutStream.init(&result_buf).stream;
285	try stream.print("{}\\Lib\\{}\\ucrt\\", search.path, search.version);	283	try stream.print("{}\\Lib\\{}\\ucrt\\", .{ search.path, search.version });
286	switch (builtin.arch) {	284	switch (builtin.arch) {
287	.i386 => try stream.write("x86"),	285	.i386 => try stream.write("x86"),
288	.x86_64 => try stream.write("x64"),	286	.x86_64 => try stream.write("x64"),
...	@@ -360,7 +358,7 @@ pub const LibCInstallation = struct {	...	@@ -360,7 +358,7 @@ pub const LibCInstallation = struct {
360	for (searches) \|search\| {	358	for (searches) \|search\| {
361	result_buf.shrink(0);	359	result_buf.shrink(0);
362	const stream = &std.io.BufferOutStream.init(&result_buf).stream;	360	const stream = &std.io.BufferOutStream.init(&result_buf).stream;
363	try stream.print("{}\\Lib\\{}\\um\\", search.path, search.version);	361	try stream.print("{}\\Lib\\{}\\um\\", .{ search.path, search.version });
364	switch (builtin.arch) {	362	switch (builtin.arch) {
365	.i386 => try stream.write("x86\\"),	363	.i386 => try stream.write("x86\\"),
366	.x86_64 => try stream.write("x64\\"),	364	.x86_64 => try stream.write("x64\\"),
...	@@ -395,7 +393,7 @@ pub const LibCInstallation = struct {	...	@@ -395,7 +393,7 @@ pub const LibCInstallation = struct {
395	/// caller owns returned memory	393	/// caller owns returned memory
396	fn ccPrintFileName(allocator: *Allocator, o_file: []const u8, want_dirname: bool) ![]u8 {	394	fn ccPrintFileName(allocator: *Allocator, o_file: []const u8, want_dirname: bool) ![]u8 {
397	const cc_exe = std.os.getenv("CC") orelse "cc";	395	const cc_exe = std.os.getenv("CC") orelse "cc";
398	const arg1 = try std.fmt.allocPrint(allocator, "-print-file-name={}", o_file);	396	const arg1 = try std.fmt.allocPrint(allocator, "-print-file-name={}", .{o_file});
399	defer allocator.free(arg1);	397	defer allocator.free(arg1);
400	const argv = [_][]const u8{ cc_exe, arg1 };	398	const argv = [_][]const u8{ cc_exe, arg1 };
401		399

src-self-hosted/link.zig+20-13

 @@ -75,9 +75,9 @@ pub fn link(comp: *Compilation) !void {
     if (comp.verbose_link) {
         for (ctx.args.toSliceConst()) |arg, i| {
             const space = if (i == 0) "" else " ";
-            std.debug.warn("{}{s}", space, arg);
+            std.debug.warn("{}{s}", .{ space, arg });
         }
-        std.debug.warn("\n");
+        std.debug.warn("\n", .{});
     }
     const extern_ofmt = toExternObjectFormatType(util.getObjectFormat(comp.target));
 @@ -94,7 +94,7 @@ pub fn link(comp: *Compilation) !void {
                 // TODO capture these messages and pass them through the system, reporting them through the
                 // event system instead of printing them directly here.
                 // perhaps try to parse and understand them.
-                std.debug.warn("{}\n", ctx.link_msg.toSliceConst());
+                std.debug.warn("{}\n", .{ctx.link_msg.toSliceConst()});
             }
             return error.LinkFailed;
         }
 @@ -334,13 +334,13 @@ fn constructLinkerArgsCoff(ctx: *Context) !void {
     const is_library = ctx.comp.kind == .Lib;
-    const out_arg = try std.fmt.allocPrint(&ctx.arena.allocator, "-OUT:{}\x00", ctx.out_file_path.toSliceConst());
+    const out_arg = try std.fmt.allocPrint(&ctx.arena.allocator, "-OUT:{}\x00", .{ctx.out_file_path.toSliceConst()});
     try ctx.args.append(@ptrCast([*:0]const u8, out_arg.ptr));
     if (ctx.comp.haveLibC()) {
-        try ctx.args.append(@ptrCast([*:0]const u8, (try std.fmt.allocPrint(&ctx.arena.allocator, "-LIBPATH:{}\x00", ctx.libc.msvc_lib_dir.?)).ptr));
+        try ctx.args.append(@ptrCast([*:0]const u8, (try std.fmt.allocPrint(&ctx.arena.allocator, "-LIBPATH:{}\x00", .{ctx.libc.msvc_lib_dir.?})).ptr));
-        try ctx.args.append(@ptrCast([*:0]const u8, (try std.fmt.allocPrint(&ctx.arena.allocator, "-LIBPATH:{}\x00", ctx.libc.kernel32_lib_dir.?)).ptr));
+        try ctx.args.append(@ptrCast([*:0]const u8, (try std.fmt.allocPrint(&ctx.arena.allocator, "-LIBPATH:{}\x00", .{ctx.libc.kernel32_lib_dir.?})).ptr));
-        try ctx.args.append(@ptrCast([*:0]const u8, (try std.fmt.allocPrint(&ctx.arena.allocator, "-LIBPATH:{}\x00", ctx.libc.lib_dir.?)).ptr));
+        try ctx.args.append(@ptrCast([*:0]const u8, (try std.fmt.allocPrint(&ctx.arena.allocator, "-LIBPATH:{}\x00", .{ctx.libc.lib_dir.?})).ptr));
     }
     if (ctx.link_in_crt) {
 @@ -348,17 +348,20 @@ fn constructLinkerArgsCoff(ctx: *Context) !void {
         const d_str = if (ctx.comp.build_mode == .Debug) "d" else "";
         if (ctx.comp.is_static) {
-            const cmt_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "libcmt{}.lib\x00", d_str);
+            const cmt_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "libcmt{}.lib\x00", .{d_str});
             try ctx.args.append(@ptrCast([*:0]const u8, cmt_lib_name.ptr));
         } else {
-            const msvcrt_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "msvcrt{}.lib\x00", d_str);
+            const msvcrt_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "msvcrt{}.lib\x00", .{d_str});
             try ctx.args.append(@ptrCast([*:0]const u8, msvcrt_lib_name.ptr));
         }
-        const vcruntime_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "{}vcruntime{}.lib\x00", lib_str, d_str);
+        const vcruntime_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "{}vcruntime{}.lib\x00", .{
+            lib_str,
+            d_str,
+        });
         try ctx.args.append(@ptrCast([*:0]const u8, vcruntime_lib_name.ptr));
-        const crt_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "{}ucrt{}.lib\x00", lib_str, d_str);
+        const crt_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "{}ucrt{}.lib\x00", .{ lib_str, d_str });
         try ctx.args.append(@ptrCast([*:0]const u8, crt_lib_name.ptr));
         // Visual C++ 2015 Conformance Changes
 @@ -508,7 +511,11 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
         .IPhoneOS => try ctx.args.append("-iphoneos_version_min"),
         .IPhoneOSSimulator => try ctx.args.append("-ios_simulator_version_min"),
     }
-    const ver_str = try std.fmt.allocPrint(&ctx.arena.allocator, "{}.{}.{}\x00", platform.major, platform.minor, platform.micro);
+    const ver_str = try std.fmt.allocPrint(&ctx.arena.allocator, "{}.{}.{}\x00", .{
+        platform.major,
+        platform.minor,
+        platform.micro,
+    });
     try ctx.args.append(@ptrCast([*:0]const u8, ver_str.ptr));
     if (ctx.comp.kind == .Exe) {
 @@ -584,7 +591,7 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
                 try ctx.args.append("-lSystem");
             } else {
                 if (mem.indexOfScalar(u8, lib.name, '/') == null) {
-                    const arg = try std.fmt.allocPrint(&ctx.arena.allocator, "-l{}\x00", lib.name);
+                    const arg = try std.fmt.allocPrint(&ctx.arena.allocator, "-l{}\x00", .{lib.name});
                     try ctx.args.append(@ptrCast([*:0]const u8, arg.ptr));
                 } else {
                     const arg = try std.cstr.addNullByte(&ctx.arena.allocator, lib.name);

src-self-hosted/main.zig+24-25

...	@@ -128,7 +128,7 @@ pub fn main() !void {	...	@@ -128,7 +128,7 @@ pub fn main() !void {
128	}	128	}
129	}	129	}
130		130
131	try stderr.print("unknown command: {}\n\n", args[1]);	131	try stderr.print("unknown command: {}\n\n", .{args[1]});
132	try stderr.write(usage);	132	try stderr.write(usage);
133	process.argsFree(allocator, args);	133	process.argsFree(allocator, args);
134	process.exit(1);	134	process.exit(1);
...	@@ -329,14 +329,14 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co	...	@@ -329,14 +329,14 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
329	if (cur_pkg.parent) \|parent\| {	329	if (cur_pkg.parent) \|parent\| {
330	cur_pkg = parent;	330	cur_pkg = parent;
331	} else {	331	} else {
332	try stderr.print("encountered --pkg-end with no matching --pkg-begin\n");	332	try stderr.print("encountered --pkg-end with no matching --pkg-begin\n", .{});
333	process.exit(1);	333	process.exit(1);
334	}	334	}
335	}	335	}
336	}	336	}
337		337
338	if (cur_pkg.parent != null) {	338	if (cur_pkg.parent != null) {
339	try stderr.print("unmatched --pkg-begin\n");	339	try stderr.print("unmatched --pkg-begin\n", .{});
340	process.exit(1);	340	process.exit(1);
341	}	341	}
342		342
...	@@ -345,7 +345,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co	...	@@ -345,7 +345,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
345	0 => null,	345	0 => null,
346	1 => flags.positionals.at(0),	346	1 => flags.positionals.at(0),
347	else => {	347	else => {
348	try stderr.print("unexpected extra parameter: {}\n", flags.positionals.at(1));	348	try stderr.print("unexpected extra parameter: {}\n", .{flags.positionals.at(1)});
349	process.exit(1);	349	process.exit(1);
350	},	350	},
351	};	351	};
...	@@ -477,13 +477,13 @@ fn processBuildEvents(comp: *Compilation, color: errmsg.Color) void {	...	@@ -477,13 +477,13 @@ fn processBuildEvents(comp: *Compilation, color: errmsg.Color) void {
477		477
478	switch (build_event) {	478	switch (build_event) {
479	.Ok => {	479	.Ok => {
480	stderr.print("Build {} succeeded\n", count) catch process.exit(1);	480	stderr.print("Build {} succeeded\n", .{count}) catch process.exit(1);
481	},	481	},
482	.Error => \|err\| {	482	.Error => \|err\| {
483	stderr.print("Build {} failed: {}\n", count, @errorName(err)) catch process.exit(1);	483	stderr.print("Build {} failed: {}\n", .{ count, @errorName(err) }) catch process.exit(1);
484	},	484	},
485	.Fail => \|msgs\| {	485	.Fail => \|msgs\| {
486	stderr.print("Build {} compile errors:\n", count) catch process.exit(1);	486	stderr.print("Build {} compile errors:\n", .{count}) catch process.exit(1);
487	for (msgs) \|msg\| {	487	for (msgs) \|msg\| {
488	defer msg.destroy();	488	defer msg.destroy();
489	msg.printToFile(stderr_file, color) catch process.exit(1);	489	msg.printToFile(stderr_file, color) catch process.exit(1);
...	@@ -544,12 +544,11 @@ const Fmt = struct {	...	@@ -544,12 +544,11 @@ const Fmt = struct {
544		544
545	fn parseLibcPaths(allocator: Allocator, libc: LibCInstallation, libc_paths_file: []const u8) void {	545	fn parseLibcPaths(allocator: Allocator, libc: LibCInstallation, libc_paths_file: []const u8) void {
546	libc.parse(allocator, libc_paths_file, stderr) catch \|err\| {	546	libc.parse(allocator, libc_paths_file, stderr) catch \|err\| {
547	stderr.print(	547	stderr.print("Unable to parse libc path file '{}': {}.\n" ++
548	"Unable to parse libc path file '{}': {}.\n" ++	548	"Try running `zig libc` to see an example for the native target.\n", .{
549	"Try running `zig libc` to see an example for the native target.\n",
550	libc_paths_file,	549	libc_paths_file,
551	@errorName(err),	550	@errorName(err),
552	) catch {};	551	}) catch {};
553	process.exit(1);	552	process.exit(1);
554	};	553	};
555	}	554	}
...	@@ -563,7 +562,7 @@ fn cmdLibC(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -563,7 +562,7 @@ fn cmdLibC(allocator: *Allocator, args: []const []const u8) !void {
563	return;	562	return;
564	},	563	},
565	else => {	564	else => {
566	try stderr.print("unexpected extra parameter: {}\n", args[1]);	565	try stderr.print("unexpected extra parameter: {}\n", .{args[1]});
567	process.exit(1);	566	process.exit(1);
568	},	567	},
569	}	568	}
...	@@ -572,7 +571,7 @@ fn cmdLibC(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -572,7 +571,7 @@ fn cmdLibC(allocator: *Allocator, args: []const []const u8) !void {
572	defer zig_compiler.deinit();	571	defer zig_compiler.deinit();
573		572
574	const libc = zig_compiler.getNativeLibC() catch \|err\| {	573	const libc = zig_compiler.getNativeLibC() catch \|err\| {
575	stderr.print("unable to find libc: {}\n", @errorName(err)) catch {};	574	stderr.print("unable to find libc: {}\n", .{@errorName(err)}) catch {};
576	process.exit(1);	575	process.exit(1);
577	};	576	};
578	libc.render(stdout) catch process.exit(1);	577	libc.render(stdout) catch process.exit(1);
...	@@ -614,7 +613,7 @@ fn cmdFmt(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -614,7 +613,7 @@ fn cmdFmt(allocator: *Allocator, args: []const []const u8) !void {
614	defer allocator.free(source_code);	613	defer allocator.free(source_code);
615		614
616	const tree = std.zig.parse(allocator, source_code) catch \|err\| {	615	const tree = std.zig.parse(allocator, source_code) catch \|err\| {
617	try stderr.print("error parsing stdin: {}\n", err);	616	try stderr.print("error parsing stdin: {}\n", .{err});
618	process.exit(1);	617	process.exit(1);
619	};	618	};
620	defer tree.deinit();	619	defer tree.deinit();
...	@@ -718,7 +717,7 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro	...	@@ -718,7 +717,7 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro
718	},	717	},
719	else => {	718	else => {
720	// TODO lock stderr printing	719	// TODO lock stderr printing
721	try stderr.print("unable to open '{}': {}\n", file_path, err);	720	try stderr.print("unable to open '{}': {}\n", .{ file_path, err });
722	fmt.any_error = true;	721	fmt.any_error = true;
723	return;	722	return;
724	},	723	},
...	@@ -726,7 +725,7 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro	...	@@ -726,7 +725,7 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro
726	defer fmt.allocator.free(source_code);	725	defer fmt.allocator.free(source_code);
727		726
728	const tree = std.zig.parse(fmt.allocator, source_code) catch \|err\| {	727	const tree = std.zig.parse(fmt.allocator, source_code) catch \|err\| {
729	try stderr.print("error parsing file '{}': {}\n", file_path, err);	728	try stderr.print("error parsing file '{}': {}\n", .{ file_path, err });
730	fmt.any_error = true;	729	fmt.any_error = true;
731	return;	730	return;
732	};	731	};
...	@@ -747,7 +746,7 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro	...	@@ -747,7 +746,7 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro
747	if (check_mode) {	746	if (check_mode) {
748	const anything_changed = try std.zig.render(fmt.allocator, io.null_out_stream, tree);	747	const anything_changed = try std.zig.render(fmt.allocator, io.null_out_stream, tree);
749	if (anything_changed) {	748	if (anything_changed) {
750	try stderr.print("{}\n", file_path);	749	try stderr.print("{}\n", .{file_path});
751	fmt.any_error = true;	750	fmt.any_error = true;
752	}	751	}
753	} else {	752	} else {
...	@@ -757,7 +756,7 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro	...	@@ -757,7 +756,7 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro
757		756
758	const anything_changed = try std.zig.render(fmt.allocator, baf.stream(), tree);	757	const anything_changed = try std.zig.render(fmt.allocator, baf.stream(), tree);
759	if (anything_changed) {	758	if (anything_changed) {
760	try stderr.print("{}\n", file_path);	759	try stderr.print("{}\n", .{file_path});
761	try baf.finish();	760	try baf.finish();
762	}	761	}
763	}	762	}
...	@@ -774,7 +773,7 @@ fn cmdTargets(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -774,7 +773,7 @@ fn cmdTargets(allocator: *Allocator, args: []const []const u8) !void {
774	// NOTE: Cannot use empty string, see #918.	773	// NOTE: Cannot use empty string, see #918.
775	comptime const native_str = if (comptime mem.eql(u8, arch_tag, @tagName(builtin.arch))) " (native)\n" else "\n";	774	comptime const native_str = if (comptime mem.eql(u8, arch_tag, @tagName(builtin.arch))) " (native)\n" else "\n";
776		775
777	try stdout.print(" {}{}", arch_tag, native_str);	776	try stdout.print(" {}{}", .{ arch_tag, native_str });
778	}	777	}
779	}	778	}
780	try stdout.write("\n");	779	try stdout.write("\n");
...	@@ -787,7 +786,7 @@ fn cmdTargets(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -787,7 +786,7 @@ fn cmdTargets(allocator: *Allocator, args: []const []const u8) !void {
787	// NOTE: Cannot use empty string, see #918.	786	// NOTE: Cannot use empty string, see #918.
788	comptime const native_str = if (comptime mem.eql(u8, os_tag, @tagName(builtin.os))) " (native)\n" else "\n";	787	comptime const native_str = if (comptime mem.eql(u8, os_tag, @tagName(builtin.os))) " (native)\n" else "\n";
789		788
790	try stdout.print(" {}{}", os_tag, native_str);	789	try stdout.print(" {}{}", .{ os_tag, native_str });
791	}	790	}
792	}	791	}
793	try stdout.write("\n");	792	try stdout.write("\n");
...	@@ -800,13 +799,13 @@ fn cmdTargets(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -800,13 +799,13 @@ fn cmdTargets(allocator: *Allocator, args: []const []const u8) !void {
800	// NOTE: Cannot use empty string, see #918.	799	// NOTE: Cannot use empty string, see #918.
801	comptime const native_str = if (comptime mem.eql(u8, abi_tag, @tagName(builtin.abi))) " (native)\n" else "\n";	800	comptime const native_str = if (comptime mem.eql(u8, abi_tag, @tagName(builtin.abi))) " (native)\n" else "\n";
802		801
803	try stdout.print(" {}{}", abi_tag, native_str);	802	try stdout.print(" {}{}", .{ abi_tag, native_str });
804	}	803	}
805	}	804	}
806	}	805	}
807		806
808	fn cmdVersion(allocator: *Allocator, args: []const []const u8) !void {	807	fn cmdVersion(allocator: *Allocator, args: []const []const u8) !void {
809	try stdout.print("{}\n", std.mem.toSliceConst(u8, c.ZIG_VERSION_STRING));	808	try stdout.print("{}\n", .{std.mem.toSliceConst(u8, c.ZIG_VERSION_STRING)});
810	}	809	}
811		810
812	const args_test_spec = [_]Flag{Flag.Bool("--help")};	811	const args_test_spec = [_]Flag{Flag.Bool("--help")};
...	@@ -865,7 +864,7 @@ fn cmdInternal(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -865,7 +864,7 @@ fn cmdInternal(allocator: *Allocator, args: []const []const u8) !void {
865	}	864	}
866	}	865	}
867		866
868	try stderr.print("unknown sub command: {}\n\n", args[0]);	867	try stderr.print("unknown sub command: {}\n\n", .{args[0]});
869	try stderr.write(usage_internal);	868	try stderr.write(usage_internal);
870	}	869	}
871		870
...	@@ -878,14 +877,14 @@ fn cmdInternalBuildInfo(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -878,14 +877,14 @@ fn cmdInternalBuildInfo(allocator: *Allocator, args: []const []const u8) !void {
878	\\ZIG_LLVM_CONFIG_EXE {}	877	\\ZIG_LLVM_CONFIG_EXE {}
879	\\ZIG_DIA_GUIDS_LIB {}	878	\\ZIG_DIA_GUIDS_LIB {}
880	\\	879	\\
881	,	880	, .{
882	std.mem.toSliceConst(u8, c.ZIG_CMAKE_BINARY_DIR),	881	std.mem.toSliceConst(u8, c.ZIG_CMAKE_BINARY_DIR),
883	std.mem.toSliceConst(u8, c.ZIG_CXX_COMPILER),	882	std.mem.toSliceConst(u8, c.ZIG_CXX_COMPILER),
884	std.mem.toSliceConst(u8, c.ZIG_LLD_INCLUDE_PATH),	883	std.mem.toSliceConst(u8, c.ZIG_LLD_INCLUDE_PATH),
885	std.mem.toSliceConst(u8, c.ZIG_LLD_LIBRARIES),	884	std.mem.toSliceConst(u8, c.ZIG_LLD_LIBRARIES),
886	std.mem.toSliceConst(u8, c.ZIG_LLVM_CONFIG_EXE),	885	std.mem.toSliceConst(u8, c.ZIG_LLVM_CONFIG_EXE),
887	std.mem.toSliceConst(u8, c.ZIG_DIA_GUIDS_LIB),	886	std.mem.toSliceConst(u8, c.ZIG_DIA_GUIDS_LIB),
888	);	887	});
889	}	888	}
890		889
891	const CliPkg = struct {	890	const CliPkg = struct {

src-self-hosted/stage1.zig+7-7

...	@@ -149,7 +149,7 @@ export fn stage2_fmt(argc: c_int, argv: []const [:0]const u8) c_int {	...	@@ -149,7 +149,7 @@ export fn stage2_fmt(argc: c_int, argv: []const [:0]const u8) c_int {
149	fmtMain(argc, argv) catch unreachable;	149	fmtMain(argc, argv) catch unreachable;
150	} else {	150	} else {
151	fmtMain(argc, argv) catch \|e\| {	151	fmtMain(argc, argv) catch \|e\| {
152	std.debug.warn("{}\n", @errorName(e));	152	std.debug.warn("{}\n", .{@errorName(e)});
153	return -1;	153	return -1;
154	};	154	};
155	}	155	}
...	@@ -205,7 +205,7 @@ fn fmtMain(argc: c_int, argv: []const [:0]const u8) !void {	...	@@ -205,7 +205,7 @@ fn fmtMain(argc: c_int, argv: []const [:0]const u8) !void {
205	defer allocator.free(source_code);	205	defer allocator.free(source_code);
206		206
207	const tree = std.zig.parse(allocator, source_code) catch \|err\| {	207	const tree = std.zig.parse(allocator, source_code) catch \|err\| {
208	try stderr.print("error parsing stdin: {}\n", err);	208	try stderr.print("error parsing stdin: {}\n", .{err});
209	process.exit(1);	209	process.exit(1);
210	};	210	};
211	defer tree.deinit();	211	defer tree.deinit();
...	@@ -294,7 +294,7 @@ fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtError!void	...	@@ -294,7 +294,7 @@ fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtError!void
294	},	294	},
295	else => {	295	else => {
296	// TODO lock stderr printing	296	// TODO lock stderr printing
297	try stderr.print("unable to open '{}': {}\n", file_path, err);	297	try stderr.print("unable to open '{}': {}\n", .{ file_path, err });
298	fmt.any_error = true;	298	fmt.any_error = true;
299	return;	299	return;
300	},	300	},
...	@@ -302,7 +302,7 @@ fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtError!void	...	@@ -302,7 +302,7 @@ fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtError!void
302	defer fmt.allocator.free(source_code);	302	defer fmt.allocator.free(source_code);
303		303
304	const tree = std.zig.parse(fmt.allocator, source_code) catch \|err\| {	304	const tree = std.zig.parse(fmt.allocator, source_code) catch \|err\| {
305	try stderr.print("error parsing file '{}': {}\n", file_path, err);	305	try stderr.print("error parsing file '{}': {}\n", .{ file_path, err });
306	fmt.any_error = true;	306	fmt.any_error = true;
307	return;	307	return;
308	};	308	};
...	@@ -320,7 +320,7 @@ fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtError!void	...	@@ -320,7 +320,7 @@ fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtError!void
320	if (check_mode) {	320	if (check_mode) {
321	const anything_changed = try std.zig.render(fmt.allocator, io.null_out_stream, tree);	321	const anything_changed = try std.zig.render(fmt.allocator, io.null_out_stream, tree);
322	if (anything_changed) {	322	if (anything_changed) {
323	try stderr.print("{}\n", file_path);	323	try stderr.print("{}\n", .{file_path});
324	fmt.any_error = true;	324	fmt.any_error = true;
325	}	325	}
326	} else {	326	} else {
...	@@ -329,7 +329,7 @@ fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtError!void	...	@@ -329,7 +329,7 @@ fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtError!void
329		329
330	const anything_changed = try std.zig.render(fmt.allocator, baf.stream(), tree);	330	const anything_changed = try std.zig.render(fmt.allocator, baf.stream(), tree);
331	if (anything_changed) {	331	if (anything_changed) {
332	try stderr.print("{}\n", file_path);	332	try stderr.print("{}\n", .{file_path});
333	try baf.finish();	333	try baf.finish();
334	}	334	}
335	}	335	}
...	@@ -374,7 +374,7 @@ fn printErrMsgToFile(	...	@@ -374,7 +374,7 @@ fn printErrMsgToFile(
374	const text = text_buf.toOwnedSlice();	374	const text = text_buf.toOwnedSlice();
375		375
376	const stream = &file.outStream().stream;	376	const stream = &file.outStream().stream;
377	try stream.print("{}:{}:{}: error: {}\n", path, start_loc.line + 1, start_loc.column + 1, text);	377	try stream.print("{}:{}:{}: error: {}\n", .{ path, start_loc.line + 1, start_loc.column + 1, text });
378		378
379	if (!color_on) return;	379	if (!color_on) return;
380		380

src-self-hosted/translate_c.zig+49-30

 @@ -125,7 +125,7 @@ const Context = struct {
         const line = ZigClangSourceManager_getSpellingLineNumber(c.source_manager, spelling_loc);
         const column = ZigClangSourceManager_getSpellingColumnNumber(c.source_manager, spelling_loc);
-        return std.fmt.allocPrint(c.a(), "{}:{}:{}", filename, line, column);
+        return std.fmt.allocPrint(c.a(), "{}:{}:{}", .{ filename, line, column });
     }
 };
 @@ -228,20 +228,20 @@ fn declVisitor(c: *Context, decl: *const ZigClangDecl) Error!void {
             return visitFnDecl(c, @ptrCast(*const ZigClangFunctionDecl, decl));
         },
         .Typedef => {
-            try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for typedefs");
+            try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for typedefs", .{});
         },
         .Enum => {
-            try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for enums");
+            try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for enums", .{});
         },
         .Record => {
-            try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for structs");
+            try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for structs", .{});
         },
         .Var => {
-            try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for variables");
+            try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for variables", .{});
         },
         else => {
             const decl_name = try c.str(ZigClangDecl_getDeclKindName(decl));
-            try emitWarning(c, ZigClangDecl_getLocation(decl), "ignoring {} declaration", decl_name);
+            try emitWarning(c, ZigClangDecl_getLocation(decl), "ignoring {} declaration", .{decl_name});
         },
     }
 }
 @@ -264,7 +264,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
         .is_export = switch (storage_class) {
             .None => has_body and c.mode != .import,
             .Extern, .Static => false,
-            .PrivateExtern => return failDecl(c, fn_decl_loc, fn_name, "unsupported storage class: private extern"),
+            .PrivateExtern => return failDecl(c, fn_decl_loc, fn_name, "unsupported storage class: private extern", .{}),
             .Auto => unreachable, // Not legal on functions
             .Register => unreachable, // Not legal on functions
         },
 @@ -274,7 +274,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
             const fn_proto_type = @ptrCast(*const ZigClangFunctionProtoType, fn_type);
             break :blk transFnProto(rp, fn_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) {
                 error.UnsupportedType => {
-                    return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function");
+                    return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{});
                 },
                 error.OutOfMemory => |e| return e,
             };
 @@ -283,7 +283,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
             const fn_no_proto_type = @ptrCast(*const ZigClangFunctionType, fn_type);
             break :blk transFnNoProto(rp, fn_no_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) {
                 error.UnsupportedType => {
-                    return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function");
+                    return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{});
                 },
                 error.OutOfMemory => |e| return e,
             };
 @@ -302,7 +302,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
         error.OutOfMemory => |e| return e,
         error.UnsupportedTranslation,
         error.UnsupportedType,
-        => return failDecl(c, fn_decl_loc, fn_name, "unable to translate function"),
+        => return failDecl(c, fn_decl_loc, fn_name, "unable to translate function", .{}),
     };
     assert(result.node.id == ast.Node.Id.Block);
     proto_node.body_node = result.node;
 @@ -344,7 +344,7 @@ fn transStmt(
                 error.UnsupportedTranslation,
                 ZigClangStmt_getBeginLoc(stmt),
                 "TODO implement translation of stmt class {}",
-                @tagName(sc),
+                .{@tagName(sc)},
             );
         },
     }
 @@ -364,7 +364,7 @@ fn transBinaryOperator(
             error.UnsupportedTranslation,
             ZigClangBinaryOperator_getBeginLoc(stmt),
             "TODO: handle more C binary operators: {}",
-            op,
+            .{op},
         ),
         .Assign => return TransResult{
             .node = &(try transCreateNodeAssign(rp, scope, result_used, ZigClangBinaryOperator_getLHS(stmt), ZigClangBinaryOperator_getRHS(stmt))).base,
 @@ -415,7 +415,7 @@ fn transBinaryOperator(
             error.UnsupportedTranslation,
             ZigClangBinaryOperator_getBeginLoc(stmt),
             "TODO: handle more C binary operators: {}",
-            op,
+            .{op},
         ),
         .MulAssign,
         .DivAssign,
 @@ -567,7 +567,7 @@ fn transDeclStmt(rp: RestorePoint, parent_scope: *Scope, stmt: *const ZigClangDe
                 error.UnsupportedTranslation,
                 ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)),
                 "TODO implement translation of DeclStmt kind {}",
-                @tagName(kind),
+                .{@tagName(kind)},
             ),
         }
     }
 @@ -636,7 +636,7 @@ fn transImplicitCastExpr(
             error.UnsupportedTranslation,
             ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, expr)),
             "TODO implement translation of CastKind {}",
-            @tagName(kind),
+            .{@tagName(kind)},
         ),
     }
 }
 @@ -650,7 +650,7 @@ fn transIntegerLiteral(
     var eval_result: ZigClangExprEvalResult = undefined;
     if (!ZigClangIntegerLiteral_EvaluateAsInt(expr, &eval_result, rp.c.clang_context)) {
         const loc = ZigClangIntegerLiteral_getBeginLoc(expr);
-        return revertAndWarn(rp, error.UnsupportedTranslation, loc, "invalid integer literal");
+        return revertAndWarn(rp, error.UnsupportedTranslation, loc, "invalid integer literal", .{});
     }
     const node = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&eval_result.Val));
     const res = TransResult{
 @@ -719,7 +719,7 @@ fn transStringLiteral(
             error.UnsupportedTranslation,
             ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)),
             "TODO: support string literal kind {}",
-            kind,
+            .{kind},
         ),
     }
 }
 @@ -751,7 +751,7 @@ fn escapeChar(c: u8, char_buf: *[4]u8) []const u8 {
         '\n' => return "\\n"[0..],
         '\r' => return "\\r"[0..],
         '\t' => return "\\t"[0..],
-        else => return std.fmt.bufPrint(char_buf[0..], "\\x{x:2}", c) catch unreachable,
+        else => return std.fmt.bufPrint(char_buf[0..], "\\x{x:2}", .{c}) catch unreachable,
     };
     std.mem.copy(u8, char_buf, escaped);
     return char_buf[0..escaped.len];
 @@ -1016,7 +1016,13 @@ fn transCreateNodeAssign(
     // zig:     lhs = _tmp;
     // zig:     break :x _tmp
     // zig: })
-    return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(lhs), "TODO: worst case assign op expr");
+    return revertAndWarn(
+        rp,
+        error.UnsupportedTranslation,
+        ZigClangExpr_getBeginLoc(lhs),
+        "TODO: worst case assign op expr",
+        .{},
+    );
 }
 fn transCreateNodeBuiltinFnCall(c: *Context, name: []const u8) !*ast.Node.BuiltinCall {
 @@ -1211,7 +1217,7 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
                 .Float128 => return appendIdentifier(rp.c, "f128"),
                 .Float16 => return appendIdentifier(rp.c, "f16"),
                 .LongDouble => return appendIdentifier(rp.c, "c_longdouble"),
-                else => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported builtin type"),
+                else => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported builtin type", .{}),
             }
         },
         .FunctionProto => {
 @@ -1253,7 +1259,7 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
         },
         else => {
             const type_name = rp.c.str(ZigClangType_getTypeClassName(ty));
-            return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported type: '{}'", type_name);
+            return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported type: '{}'", .{type_name});
         },
     }
 }
 @@ -1275,7 +1281,13 @@ fn transCC(
     switch (clang_cc) {
         .C => return CallingConvention.C,
         .X86StdCall => return CallingConvention.Stdcall,
-        else => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: {}", @tagName(clang_cc)),
+        else => return revertAndWarn(
+            rp,
+            error.UnsupportedType,
+            source_loc,
+            "unsupported calling convention: {}",
+            .{@tagName(clang_cc)},
+        ),
     }
 }
 @@ -1292,7 +1304,13 @@ fn transFnProto(
     const param_count: usize = ZigClangFunctionProtoType_getNumParams(fn_proto_ty);
     var i: usize = 0;
     while (i < param_count) : (i += 1) {
-        return revertAndWarn(rp, error.UnsupportedType, source_loc, "TODO: implement parameters for FunctionProto in transType");
+        return revertAndWarn(
+            rp,
+            error.UnsupportedType,
+            source_loc,
+            "TODO: implement parameters for FunctionProto in transType",
+            .{},
+        );
     }
     return finishTransFnProto(rp, fn_ty, source_loc, fn_decl_context, is_var_args, cc, is_pub);
 @@ -1350,7 +1368,7 @@ fn finishTransFnProto(
             } else {
                 break :blk transQualType(rp, return_qt, source_loc) catch |err| switch (err) {
                     error.UnsupportedType => {
-                        try emitWarning(rp.c, source_loc, "unsupported function proto return type");
+                        try emitWarning(rp.c, source_loc, "unsupported function proto return type", .{});
                         return err;
                     },
                     error.OutOfMemory => |e| return e,
 @@ -1397,18 +1415,19 @@ fn revertAndWarn(
     err: var,
     source_loc: ZigClangSourceLocation,
     comptime format: []const u8,
-    args: ...,
+    args: var,
 ) (@typeOf(err) || error{OutOfMemory}) {
     rp.activate();
     try emitWarning(rp.c, source_loc, format, args);
     return err;
 }
-fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: ...) !void {
+fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: var) !void {
-    _ = try appendTokenFmt(c, .LineComment, "// {}: warning: " ++ format, c.locStr(loc), args);
+    const args_prefix = .{c.locStr(loc)};
+    _ = try appendTokenFmt(c, .LineComment, "// {}: warning: " ++ format, args_prefix ++ args);
 }
-fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime format: []const u8, args: ...) !void {
+fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime format: []const u8, args: var) !void {
     // const name = @compileError(msg);
     const const_tok = try appendToken(c, .Keyword_const, "const");
     const name_tok = try appendToken(c, .Identifier, name);
 @@ -1456,10 +1475,10 @@ fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime
 }
 fn appendToken(c: *Context, token_id: Token.Id, bytes: []const u8) !ast.TokenIndex {
-    return appendTokenFmt(c, token_id, "{}", bytes);
+    return appendTokenFmt(c, token_id, "{}", .{bytes});
 }
-fn appendTokenFmt(c: *Context, token_id: Token.Id, comptime format: []const u8, args: ...) !ast.TokenIndex {
+fn appendTokenFmt(c: *Context, token_id: Token.Id, comptime format: []const u8, args: var) !ast.TokenIndex {
     const S = struct {
         fn callback(context: *Context, bytes: []const u8) error{OutOfMemory}!void {
             return context.source_buffer.append(bytes);

src-self-hosted/type.zig+11-15

 @@ -399,7 +399,7 @@ pub const Type = struct {
                 .Generic => |generic| {
                     self.non_key = NonKey{ .Generic = {} };
                     const cc_str = ccFnTypeStr(generic.cc);
-                    try name_stream.print("{}fn(", cc_str);
+                    try name_stream.print("{}fn(", .{cc_str});
                     var param_i: usize = 0;
                     while (param_i < generic.param_count) : (param_i += 1) {
                         const arg = if (param_i == 0) "var" else ", var";
 @@ -407,7 +407,7 @@ pub const Type = struct {
                     }
                     try name_stream.write(")");
                     if (key.alignment) |alignment| {
-                        try name_stream.print(" align({})", alignment);
+                        try name_stream.print(" align({})", .{alignment});
                     }
                     try name_stream.write(" var");
                 },
 @@ -416,7 +416,7 @@ pub const Type = struct {
                         .Normal = NonKey.Normal{ .variable_list = std.ArrayList(*Scope.Var).init(comp.gpa()) },
                     };
                     const cc_str = ccFnTypeStr(normal.cc);
-                    try name_stream.print("{}fn(", cc_str);
+                    try name_stream.print("{}fn(", .{cc_str});
                     for (normal.params) |param, i| {
                         if (i != 0) try name_stream.write(", ");
                         if (param.is_noalias) try name_stream.write("noalias ");
 @@ -428,9 +428,9 @@ pub const Type = struct {
                     }
                     try name_stream.write(")");
                     if (key.alignment) |alignment| {
-                        try name_stream.print(" align({})", alignment);
+                        try name_stream.print(" align({})", .{alignment});
                     }
-                    try name_stream.print(" {}", normal.return_type.name);
+                    try name_stream.print(" {}", .{normal.return_type.name});
                 },
             }
 @@ -584,7 +584,7 @@ pub const Type = struct {
             errdefer comp.gpa().destroy(self);
             const u_or_i = "ui"[@boolToInt(key.is_signed)];
-            const name = try std.fmt.allocPrint(comp.gpa(), "{c}{}", u_or_i, key.bit_count);
+            const name = try std.fmt.allocPrint(comp.gpa(), "{c}{}", .{ u_or_i, key.bit_count });
             errdefer comp.gpa().free(name);
             self.base.init(comp, .Int, name);
 @@ -767,23 +767,19 @@ pub const Type = struct {
                 .Non => "",
             };
             const name = switch (self.key.alignment) {
-                .Abi => try std.fmt.allocPrint(
+                .Abi => try std.fmt.allocPrint(comp.gpa(), "{}{}{}{}", .{
-                    comp.gpa(),
-                    "{}{}{}{}",
                     size_str,
                     mut_str,
                     vol_str,
                     self.key.child_type.name,
-                ),
+                }),
-                .Override => |alignment| try std.fmt.allocPrint(
+                .Override => |alignment| try std.fmt.allocPrint(comp.gpa(), "{}align<{}> {}{}{}", .{
-                    comp.gpa(),
-                    "{}align<{}> {}{}{}",
                     size_str,
                     alignment,
                     mut_str,
                     vol_str,
                     self.key.child_type.name,
-                ),
+                }),
             };
             errdefer comp.gpa().free(name);
 @@ -852,7 +848,7 @@ pub const Type = struct {
             };
             errdefer comp.gpa().destroy(self);
-            const name = try std.fmt.allocPrint(comp.gpa(), "[{}]{}", key.len, key.elem_type.name);
+            const name = try std.fmt.allocPrint(comp.gpa(), "[{}]{}", .{ key.len, key.elem_type.name });
             errdefer comp.gpa().free(name);
             self.base.init(comp, .Array, name);

src-self-hosted/util.zig+2-2

...	@@ -175,7 +175,7 @@ pub fn llvmTargetFromTriple(triple: std.Buffer) !*llvm.Target {	...	@@ -175,7 +175,7 @@ pub fn llvmTargetFromTriple(triple: std.Buffer) !*llvm.Target {
175	var result: *llvm.Target = undefined;	175	var result: *llvm.Target = undefined;
176	var err_msg: [*:0]u8 = undefined;	176	var err_msg: [*:0]u8 = undefined;
177	if (llvm.GetTargetFromTriple(triple.toSlice(), &result, &err_msg) != 0) {	177	if (llvm.GetTargetFromTriple(triple.toSlice(), &result, &err_msg) != 0) {
178	std.debug.warn("triple: {s} error: {s}\n", triple.toSlice(), err_msg);	178	std.debug.warn("triple: {s} error: {s}\n", .{ triple.toSlice(), err_msg });
179	return error.UnsupportedTarget;	179	return error.UnsupportedTarget;
180	}	180	}
181	return result;	181	return result;
...	@@ -206,7 +206,7 @@ pub fn getTriple(allocator: *std.mem.Allocator, self: std.Target) !std.Buffer {	...	@@ -206,7 +206,7 @@ pub fn getTriple(allocator: *std.mem.Allocator, self: std.Target) !std.Buffer {
206	const env_name = if (self.isWasm()) "wasm" else @tagName(self.getAbi());	206	const env_name = if (self.isWasm()) "wasm" else @tagName(self.getAbi());
207		207
208	var out = &std.io.BufferOutStream.init(&result).stream;	208	var out = &std.io.BufferOutStream.init(&result).stream;
209	try out.print("{}-unknown-{}-{}", @tagName(self.getArch()), @tagName(self.getOs()), env_name);	209	try out.print("{}-unknown-{}-{}", .{ @tagName(self.getArch()), @tagName(self.getOs()), env_name });
210		210
211	return result;	211	return result;
212	}	212	}

src-self-hosted/value.zig+1-1

...	@@ -53,7 +53,7 @@ pub const Value = struct {	...	@@ -53,7 +53,7 @@ pub const Value = struct {
53	}	53	}
54		54
55	pub fn dump(base: *const Value) void {	55	pub fn dump(base: *const Value) void {
56	std.debug.warn("{}", @tagName(base.id));	56	std.debug.warn("{}", .{@tagName(base.id)});
57	}	57	}
58		58
59	pub fn getLlvmConst(base: Value, ofile: ObjectFile) (error{OutOfMemory}!?*llvm.Value) {	59	pub fn getLlvmConst(base: Value, ofile: ObjectFile) (error{OutOfMemory}!?*llvm.Value) {

src/ir.cpp+12-4

 @@ -17025,7 +17025,7 @@ static IrInstruction *ir_resolve_result(IrAnalyze *ira, IrInstruction *suspend_s
     {
         result_loc_pass1 = no_result_loc();
     }
-    bool was_written = result_loc_pass1->written;
+    bool was_already_resolved = result_loc_pass1->resolved_loc != nullptr;
     IrInstruction *result_loc = ir_resolve_result_raw(ira, suspend_source_instr, result_loc_pass1, value_type,
             value, force_runtime, non_null_comptime, allow_discard);
     if (result_loc == nullptr || (instr_is_unreachable(result_loc) || type_is_invalid(result_loc->value->type)))
 @@ -17038,7 +17038,7 @@ static IrInstruction *ir_resolve_result(IrAnalyze *ira, IrInstruction *suspend_s
     }
     InferredStructField *isf = result_loc->value->type->data.pointer.inferred_struct_field;
-    if (!was_written && isf != nullptr) {
+    if (!was_already_resolved && isf != nullptr) {
         // Now it's time to add the field to the struct type.
         uint32_t old_field_count = isf->inferred_struct_type->data.structure.src_field_count;
         uint32_t new_field_count = old_field_count + 1;
 @@ -18077,7 +18077,11 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstruction *source_i
                 if (type_is_invalid(result_loc->value->type) || instr_is_unreachable(result_loc)) {
                     return result_loc;
                 }
-                if (!handle_is_ptr(result_loc->value->type->data.pointer.child_type)) {
+                ZigType *res_child_type = result_loc->value->type->data.pointer.child_type;
+                if (res_child_type == ira->codegen->builtin_types.entry_var) {
+                    res_child_type = impl_fn_type_id->return_type;
+                }
+                if (!handle_is_ptr(res_child_type)) {
                     ir_reset_result(call_result_loc);
                     result_loc = nullptr;
                 }
 @@ -18240,7 +18244,11 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstruction *source_i
             if (type_is_invalid(result_loc->value->type) || instr_is_unreachable(result_loc)) {
                 return result_loc;
             }
-            if (!handle_is_ptr(result_loc->value->type->data.pointer.child_type)) {
+            ZigType *res_child_type = result_loc->value->type->data.pointer.child_type;
+            if (res_child_type == ira->codegen->builtin_types.entry_var) {
+                res_child_type = return_type;
+            }
+            if (!handle_is_ptr(res_child_type)) {
                 ir_reset_result(call_result_loc);
                 result_loc = nullptr;
             }

test/cli.zig+11-11

...	@@ -19,11 +19,11 @@ pub fn main() !void {	...	@@ -19,11 +19,11 @@ pub fn main() !void {
19	a = &arena.allocator;	19	a = &arena.allocator;
20		20
21	const zig_exe_rel = try (arg_it.next(a) orelse {	21	const zig_exe_rel = try (arg_it.next(a) orelse {
22	std.debug.warn("Expected first argument to be path to zig compiler\n");	22	std.debug.warn("Expected first argument to be path to zig compiler\n", .{});
23	return error.InvalidArgs;	23	return error.InvalidArgs;
24	});	24	});
25	const cache_root = try (arg_it.next(a) orelse {	25	const cache_root = try (arg_it.next(a) orelse {
26	std.debug.warn("Expected second argument to be cache root directory path\n");	26	std.debug.warn("Expected second argument to be cache root directory path\n", .{});
27	return error.InvalidArgs;	27	return error.InvalidArgs;
28	});	28	});
29	const zig_exe = try fs.path.resolve(a, &[_][]const u8{zig_exe_rel});	29	const zig_exe = try fs.path.resolve(a, &[_][]const u8{zig_exe_rel});
...	@@ -45,39 +45,39 @@ pub fn main() !void {	...	@@ -45,39 +45,39 @@ pub fn main() !void {
45		45
46	fn unwrapArg(arg: UnwrapArgError![]u8) UnwrapArgError![]u8 {	46	fn unwrapArg(arg: UnwrapArgError![]u8) UnwrapArgError![]u8 {
47	return arg catch \|err\| {	47	return arg catch \|err\| {
48	warn("Unable to parse command line: {}\n", err);	48	warn("Unable to parse command line: {}\n", .{err});
49	return err;	49	return err;
50	};	50	};
51	}	51	}
52		52
53	fn printCmd(cwd: []const u8, argv: []const []const u8) void {	53	fn printCmd(cwd: []const u8, argv: []const []const u8) void {
54	std.debug.warn("cd {} && ", cwd);	54	std.debug.warn("cd {} && ", .{cwd});
55	for (argv) \|arg\| {	55	for (argv) \|arg\| {
56	std.debug.warn("{} ", arg);	56	std.debug.warn("{} ", .{arg});
57	}	57	}
58	std.debug.warn("\n");	58	std.debug.warn("\n", .{});
59	}	59	}
60		60
61	fn exec(cwd: []const u8, argv: []const []const u8) !ChildProcess.ExecResult {	61	fn exec(cwd: []const u8, argv: []const []const u8) !ChildProcess.ExecResult {
62	const max_output_size = 100 * 1024;	62	const max_output_size = 100 * 1024;
63	const result = ChildProcess.exec(a, argv, cwd, null, max_output_size) catch \|err\| {	63	const result = ChildProcess.exec(a, argv, cwd, null, max_output_size) catch \|err\| {
64	std.debug.warn("The following command failed:\n");	64	std.debug.warn("The following command failed:\n", .{});
65	printCmd(cwd, argv);	65	printCmd(cwd, argv);
66	return err;	66	return err;
67	};	67	};
68	switch (result.term) {	68	switch (result.term) {
69	.Exited => \|code\| {	69	.Exited => \|code\| {
70	if (code != 0) {	70	if (code != 0) {
71	std.debug.warn("The following command exited with error code {}:\n", code);	71	std.debug.warn("The following command exited with error code {}:\n", .{code});
72	printCmd(cwd, argv);	72	printCmd(cwd, argv);
73	std.debug.warn("stderr:\n{}\n", result.stderr);	73	std.debug.warn("stderr:\n{}\n", .{result.stderr});
74	return error.CommandFailed;	74	return error.CommandFailed;
75	}	75	}
76	},	76	},
77	else => {	77	else => {
78	std.debug.warn("The following command terminated unexpectedly:\n");	78	std.debug.warn("The following command terminated unexpectedly:\n", .{});
79	printCmd(cwd, argv);	79	printCmd(cwd, argv);
80	std.debug.warn("stderr:\n{}\n", result.stderr);	80	std.debug.warn("stderr:\n{}\n", .{result.stderr});
81	return error.CommandFailed;	81	return error.CommandFailed;
82	},	82	},
83	}	83	}

test/compare_output.zig+33-33

...	@@ -20,7 +20,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -20,7 +20,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
20	\\pub fn main() void {	20	\\pub fn main() void {
21	\\ privateFunction();	21	\\ privateFunction();
22	\\ const stdout = &getStdOut().outStream().stream;	22	\\ const stdout = &getStdOut().outStream().stream;
23	\\ stdout.print("OK 2\n") catch unreachable;	23	\\ stdout.print("OK 2\n", .{}) catch unreachable;
24	\\}	24	\\}
25	\\	25	\\
26	\\fn privateFunction() void {	26	\\fn privateFunction() void {
...	@@ -35,7 +35,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -35,7 +35,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
35	\\// but it's private so it should be OK	35	\\// but it's private so it should be OK
36	\\fn privateFunction() void {	36	\\fn privateFunction() void {
37	\\ const stdout = &getStdOut().outStream().stream;	37	\\ const stdout = &getStdOut().outStream().stream;
38	\\ stdout.print("OK 1\n") catch unreachable;	38	\\ stdout.print("OK 1\n", .{}) catch unreachable;
39	\\}	39	\\}
40	\\	40	\\
41	\\pub fn printText() void {	41	\\pub fn printText() void {
...	@@ -61,7 +61,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -61,7 +61,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
61	\\usingnamespace @import("std").io;	61	\\usingnamespace @import("std").io;
62	\\pub fn foo_function() void {	62	\\pub fn foo_function() void {
63	\\ const stdout = &getStdOut().outStream().stream;	63	\\ const stdout = &getStdOut().outStream().stream;
64	\\ stdout.print("OK\n") catch unreachable;	64	\\ stdout.print("OK\n", .{}) catch unreachable;
65	\\}	65	\\}
66	);	66	);
67		67
...	@@ -72,7 +72,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -72,7 +72,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
72	\\pub fn bar_function() void {	72	\\pub fn bar_function() void {
73	\\ if (foo_function()) {	73	\\ if (foo_function()) {
74	\\ const stdout = &getStdOut().outStream().stream;	74	\\ const stdout = &getStdOut().outStream().stream;
75	\\ stdout.print("OK\n") catch unreachable;	75	\\ stdout.print("OK\n", .{}) catch unreachable;
76	\\ }	76	\\ }
77	\\}	77	\\}
78	);	78	);
...	@@ -104,7 +104,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -104,7 +104,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
104	\\	104	\\
105	\\pub fn ok() void {	105	\\pub fn ok() void {
106	\\ const stdout = &io.getStdOut().outStream().stream;	106	\\ const stdout = &io.getStdOut().outStream().stream;
107	\\ stdout.print(b_text) catch unreachable;	107	\\ stdout.print(b_text, .{}) catch unreachable;
108	\\}	108	\\}
109	);	109	);
110		110
...	@@ -122,7 +122,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -122,7 +122,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
122	\\	122	\\
123	\\pub fn main() void {	123	\\pub fn main() void {
124	\\ const stdout = &io.getStdOut().outStream().stream;	124	\\ const stdout = &io.getStdOut().outStream().stream;
125	\\ stdout.print("Hello, world!\n{d:4} {x:3} {c}\n", @as(u32, 12), @as(u16, 0x12), @as(u8, 'a')) catch unreachable;	125	\\ stdout.print("Hello, world!\n{d:4} {x:3} {c}\n", .{@as(u32, 12), @as(u16, 0x12), @as(u8, 'a')}) catch unreachable;
126	\\}	126	\\}
127	, "Hello, world!\n 12 12 a\n");	127	, "Hello, world!\n 12 12 a\n");
128		128
...	@@ -265,7 +265,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -265,7 +265,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
265	\\}	265	\\}
266	\\fn print_ok(val: @typeOf(x)) @typeOf(foo) {	266	\\fn print_ok(val: @typeOf(x)) @typeOf(foo) {
267	\\ const stdout = &io.getStdOut().outStream().stream;	267	\\ const stdout = &io.getStdOut().outStream().stream;
268	\\ stdout.print("OK\n") catch unreachable;	268	\\ stdout.print("OK\n", .{}) catch unreachable;
269	\\ return 0;	269	\\ return 0;
270	\\}	270	\\}
271	\\const foo : i32 = 0;	271	\\const foo : i32 = 0;
...	@@ -348,12 +348,12 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -348,12 +348,12 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
348	\\ const foo = Foo {.field1 = bar,};	348	\\ const foo = Foo {.field1 = bar,};
349	\\ const stdout = &io.getStdOut().outStream().stream;	349	\\ const stdout = &io.getStdOut().outStream().stream;
350	\\ if (!foo.method()) {	350	\\ if (!foo.method()) {
351	\\ stdout.print("BAD\n") catch unreachable;	351	\\ stdout.print("BAD\n", .{}) catch unreachable;
352	\\ }	352	\\ }
353	\\ if (!bar.method()) {	353	\\ if (!bar.method()) {
354	\\ stdout.print("BAD\n") catch unreachable;	354	\\ stdout.print("BAD\n", .{}) catch unreachable;
355	\\ }	355	\\ }
356	\\ stdout.print("OK\n") catch unreachable;	356	\\ stdout.print("OK\n", .{}) catch unreachable;
357	\\}	357	\\}
358	, "OK\n");	358	, "OK\n");
359		359
...	@@ -361,11 +361,11 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -361,11 +361,11 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
361	\\const io = @import("std").io;	361	\\const io = @import("std").io;
362	\\pub fn main() void {	362	\\pub fn main() void {
363	\\ const stdout = &io.getStdOut().outStream().stream;	363	\\ const stdout = &io.getStdOut().outStream().stream;
364	\\ stdout.print("before\n") catch unreachable;	364	\\ stdout.print("before\n", .{}) catch unreachable;
365	\\ defer stdout.print("defer1\n") catch unreachable;	365	\\ defer stdout.print("defer1\n", .{}) catch unreachable;
366	\\ defer stdout.print("defer2\n") catch unreachable;	366	\\ defer stdout.print("defer2\n", .{}) catch unreachable;
367	\\ defer stdout.print("defer3\n") catch unreachable;	367	\\ defer stdout.print("defer3\n", .{}) catch unreachable;
368	\\ stdout.print("after\n") catch unreachable;	368	\\ stdout.print("after\n", .{}) catch unreachable;
369	\\}	369	\\}
370	, "before\nafter\ndefer3\ndefer2\ndefer1\n");	370	, "before\nafter\ndefer3\ndefer2\ndefer1\n");
371		371
...	@@ -374,13 +374,13 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -374,13 +374,13 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
374	\\const os = @import("std").os;	374	\\const os = @import("std").os;
375	\\pub fn main() void {	375	\\pub fn main() void {
376	\\ const stdout = &io.getStdOut().outStream().stream;	376	\\ const stdout = &io.getStdOut().outStream().stream;
377	\\ stdout.print("before\n") catch unreachable;	377	\\ stdout.print("before\n", .{}) catch unreachable;
378	\\ defer stdout.print("defer1\n") catch unreachable;	378	\\ defer stdout.print("defer1\n", .{}) catch unreachable;
379	\\ defer stdout.print("defer2\n") catch unreachable;	379	\\ defer stdout.print("defer2\n", .{}) catch unreachable;
380	\\ var args_it = @import("std").process.args();	380	\\ var args_it = @import("std").process.args();
381	\\ if (args_it.skip() and !args_it.skip()) return;	381	\\ if (args_it.skip() and !args_it.skip()) return;
382	\\ defer stdout.print("defer3\n") catch unreachable;	382	\\ defer stdout.print("defer3\n", .{}) catch unreachable;
383	\\ stdout.print("after\n") catch unreachable;	383	\\ stdout.print("after\n", .{}) catch unreachable;
384	\\}	384	\\}
385	, "before\ndefer2\ndefer1\n");	385	, "before\ndefer2\ndefer1\n");
386		386
...	@@ -391,12 +391,12 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -391,12 +391,12 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
391	\\}	391	\\}
392	\\fn do_test() !void {	392	\\fn do_test() !void {
393	\\ const stdout = &io.getStdOut().outStream().stream;	393	\\ const stdout = &io.getStdOut().outStream().stream;
394	\\ stdout.print("before\n") catch unreachable;	394	\\ stdout.print("before\n", .{}) catch unreachable;
395	\\ defer stdout.print("defer1\n") catch unreachable;	395	\\ defer stdout.print("defer1\n", .{}) catch unreachable;
396	\\ errdefer stdout.print("deferErr\n") catch unreachable;	396	\\ errdefer stdout.print("deferErr\n", .{}) catch unreachable;
397	\\ try its_gonna_fail();	397	\\ try its_gonna_fail();
398	\\ defer stdout.print("defer3\n") catch unreachable;	398	\\ defer stdout.print("defer3\n", .{}) catch unreachable;
399	\\ stdout.print("after\n") catch unreachable;	399	\\ stdout.print("after\n", .{}) catch unreachable;
400	\\}	400	\\}
401	\\fn its_gonna_fail() !void {	401	\\fn its_gonna_fail() !void {
402	\\ return error.IToldYouItWouldFail;	402	\\ return error.IToldYouItWouldFail;
...	@@ -410,12 +410,12 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -410,12 +410,12 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
410	\\}	410	\\}
411	\\fn do_test() !void {	411	\\fn do_test() !void {
412	\\ const stdout = &io.getStdOut().outStream().stream;	412	\\ const stdout = &io.getStdOut().outStream().stream;
413	\\ stdout.print("before\n") catch unreachable;	413	\\ stdout.print("before\n", .{}) catch unreachable;
414	\\ defer stdout.print("defer1\n") catch unreachable;	414	\\ defer stdout.print("defer1\n", .{}) catch unreachable;
415	\\ errdefer stdout.print("deferErr\n") catch unreachable;	415	\\ errdefer stdout.print("deferErr\n", .{}) catch unreachable;
416	\\ try its_gonna_pass();	416	\\ try its_gonna_pass();
417	\\ defer stdout.print("defer3\n") catch unreachable;	417	\\ defer stdout.print("defer3\n", .{}) catch unreachable;
418	\\ stdout.print("after\n") catch unreachable;	418	\\ stdout.print("after\n", .{}) catch unreachable;
419	\\}	419	\\}
420	\\fn its_gonna_pass() anyerror!void { }	420	\\fn its_gonna_pass() anyerror!void { }
421	, "before\nafter\ndefer3\ndefer1\n");	421	, "before\nafter\ndefer3\ndefer1\n");
...	@@ -427,7 +427,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -427,7 +427,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
427	\\	427	\\
428	\\pub fn main() void {	428	\\pub fn main() void {
429	\\ const stdout = &io.getStdOut().outStream().stream;	429	\\ const stdout = &io.getStdOut().outStream().stream;
430	\\ stdout.print(foo_txt) catch unreachable;	430	\\ stdout.print(foo_txt, .{}) catch unreachable;
431	\\}	431	\\}
432	, "1234\nabcd\n");	432	, "1234\nabcd\n");
433		433
...	@@ -452,7 +452,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -452,7 +452,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
452	\\ _ = args_it.skip();	452	\\ _ = args_it.skip();
453	\\ while (args_it.next(allocator)) \|arg_or_err\| : (index += 1) {	453	\\ while (args_it.next(allocator)) \|arg_or_err\| : (index += 1) {
454	\\ const arg = try arg_or_err;	454	\\ const arg = try arg_or_err;
455	\\ try stdout.print("{}: {}\n", index, arg);	455	\\ try stdout.print("{}: {}\n", .{index, arg});
456	\\ }	456	\\ }
457	\\}	457	\\}
458	,	458	,
...	@@ -493,7 +493,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -493,7 +493,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
493	\\ _ = args_it.skip();	493	\\ _ = args_it.skip();
494	\\ while (args_it.next(allocator)) \|arg_or_err\| : (index += 1) {	494	\\ while (args_it.next(allocator)) \|arg_or_err\| : (index += 1) {
495	\\ const arg = try arg_or_err;	495	\\ const arg = try arg_or_err;
496	\\ try stdout.print("{}: {}\n", index, arg);	496	\\ try stdout.print("{}: {}\n", .{index, arg});
497	\\ }	497	\\ }
498	\\}	498	\\}
499	,	499	,

test/compile_errors.zig+2-4

 @@ -2598,14 +2598,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn a(b: fn (*const u8) void) void {
         \\    b('a');
         \\}
-        \\fn c(d: u8) void {
+        \\fn c(d: u8) void {}
-        \\    @import("std").debug.warn("{c}\n", d);
-        \\}
         \\export fn entry() void {
         \\    a(c);
         \\}
     ,
-        "tmp.zig:8:7: error: expected type 'fn(*const u8) void', found 'fn(u8) void'",
+        "tmp.zig:6:7: error: expected type 'fn(*const u8) void', found 'fn(u8) void'",
     );
     cases.add(

test/standalone/cat/main.zig+5-5

...	@@ -23,7 +23,7 @@ pub fn main() !void {	...	@@ -23,7 +23,7 @@ pub fn main() !void {
23	return usage(exe);	23	return usage(exe);
24	} else {	24	} else {
25	const file = cwd.openFile(arg, .{}) catch \|err\| {	25	const file = cwd.openFile(arg, .{}) catch \|err\| {
26	warn("Unable to open file: {}\n", @errorName(err));	26	warn("Unable to open file: {}\n", .{@errorName(err)});
27	return err;	27	return err;
28	};	28	};
29	defer file.close();	29	defer file.close();
...	@@ -38,7 +38,7 @@ pub fn main() !void {	...	@@ -38,7 +38,7 @@ pub fn main() !void {
38	}	38	}
39		39
40	fn usage(exe: []const u8) !void {	40	fn usage(exe: []const u8) !void {
41	warn("Usage: {} [FILE]...\n", exe);	41	warn("Usage: {} [FILE]...\n", .{exe});
42	return error.Invalid;	42	return error.Invalid;
43	}	43	}
44		44
...	@@ -47,7 +47,7 @@ fn cat_file(stdout: fs.File, file: fs.File) !void {	...	@@ -47,7 +47,7 @@ fn cat_file(stdout: fs.File, file: fs.File) !void {
47		47
48	while (true) {	48	while (true) {
49	const bytes_read = file.read(buf[0..]) catch \|err\| {	49	const bytes_read = file.read(buf[0..]) catch \|err\| {
50	warn("Unable to read from stream: {}\n", @errorName(err));	50	warn("Unable to read from stream: {}\n", .{@errorName(err)});
51	return err;	51	return err;
52	};	52	};
53		53
...	@@ -56,7 +56,7 @@ fn cat_file(stdout: fs.File, file: fs.File) !void {	...	@@ -56,7 +56,7 @@ fn cat_file(stdout: fs.File, file: fs.File) !void {
56	}	56	}
57		57
58	stdout.write(buf[0..bytes_read]) catch \|err\| {	58	stdout.write(buf[0..bytes_read]) catch \|err\| {
59	warn("Unable to write to stdout: {}\n", @errorName(err));	59	warn("Unable to write to stdout: {}\n", .{@errorName(err)});
60	return err;	60	return err;
61	};	61	};
62	}	62	}
...	@@ -64,7 +64,7 @@ fn cat_file(stdout: fs.File, file: fs.File) !void {	...	@@ -64,7 +64,7 @@ fn cat_file(stdout: fs.File, file: fs.File) !void {
64		64
65	fn unwrapArg(arg: anyerror![]u8) ![]u8 {	65	fn unwrapArg(arg: anyerror![]u8) ![]u8 {
66	return arg catch \|err\| {	66	return arg catch \|err\| {
67	warn("Unable to parse command line: {}\n", err);	67	warn("Unable to parse command line: {}\n", .{err});
68	return err;	68	return err;
69	};	69	};
70	}	70	}

test/standalone/guess_number/main.zig+8-8

...	@@ -6,11 +6,11 @@ const fmt = std.fmt;	...	@@ -6,11 +6,11 @@ const fmt = std.fmt;
6	pub fn main() !void {	6	pub fn main() !void {
7	const stdout = &io.getStdOut().outStream().stream;	7	const stdout = &io.getStdOut().outStream().stream;
8		8
9	try stdout.print("Welcome to the Guess Number Game in Zig.\n");	9	try stdout.print("Welcome to the Guess Number Game in Zig.\n", .{});
10		10
11	var seed_bytes: [@sizeOf(u64)]u8 = undefined;	11	var seed_bytes: [@sizeOf(u64)]u8 = undefined;
12	std.crypto.randomBytes(seed_bytes[0..]) catch \|err\| {	12	std.crypto.randomBytes(seed_bytes[0..]) catch \|err\| {
13	std.debug.warn("unable to seed random number generator: {}", err);	13	std.debug.warn("unable to seed random number generator: {}", .{err});
14	return err;	14	return err;
15	};	15	};
16	const seed = std.mem.readIntNative(u64, &seed_bytes);	16	const seed = std.mem.readIntNative(u64, &seed_bytes);
...	@@ -19,27 +19,27 @@ pub fn main() !void {	...	@@ -19,27 +19,27 @@ pub fn main() !void {
19	const answer = prng.random.range(u8, 0, 100) + 1;	19	const answer = prng.random.range(u8, 0, 100) + 1;
20		20
21	while (true) {	21	while (true) {
22	try stdout.print("\nGuess a number between 1 and 100: ");	22	try stdout.print("\nGuess a number between 1 and 100: ", .{});
23	var line_buf: [20]u8 = undefined;	23	var line_buf: [20]u8 = undefined;
24		24
25	const line = io.readLineSlice(line_buf[0..]) catch \|err\| switch (err) {	25	const line = io.readLineSlice(line_buf[0..]) catch \|err\| switch (err) {
26	error.OutOfMemory => {	26	error.OutOfMemory => {
27	try stdout.print("Input too long.\n");	27	try stdout.print("Input too long.\n", .{});
28	continue;	28	continue;
29	},	29	},
30	else => return err,	30	else => return err,
31	};	31	};
32		32
33	const guess = fmt.parseUnsigned(u8, line, 10) catch {	33	const guess = fmt.parseUnsigned(u8, line, 10) catch {
34	try stdout.print("Invalid number.\n");	34	try stdout.print("Invalid number.\n", .{});
35	continue;	35	continue;
36	};	36	};
37	if (guess > answer) {	37	if (guess > answer) {
38	try stdout.print("Guess lower.\n");	38	try stdout.print("Guess lower.\n", .{});
39	} else if (guess < answer) {	39	} else if (guess < answer) {
40	try stdout.print("Guess higher.\n");	40	try stdout.print("Guess higher.\n", .{});
41	} else {	41	} else {
42	try stdout.print("You win!\n");	42	try stdout.print("You win!\n", .{});
43	return;	43	return;
44	}	44	}
45	}	45	}

test/tests.zig+94-66

 @@ -411,7 +411,7 @@ pub fn addPkgTests(
     is_qemu_enabled: bool,
     glibc_dir: ?[]const u8,
 ) *build.Step {
-    const step = b.step(b.fmt("test-{}", name), desc);
+    const step = b.step(b.fmt("test-{}", .{name}), desc);
     for (test_targets) |test_target| {
         if (skip_non_native and test_target.target != .Native)
 @@ -454,14 +454,14 @@ pub fn addPkgTests(
             test_target.target.zigTripleNoSubArch(b.allocator) catch unreachable;
         const these_tests = b.addTest(root_src);
-        these_tests.setNamePrefix(b.fmt(
+        const single_threaded_txt = if (test_target.single_threaded) "single" else "multi";
-            "{}-{}-{}-{}-{} ",
+        these_tests.setNamePrefix(b.fmt("{}-{}-{}-{}-{} ", .{
             name,
             triple_prefix,
             @tagName(test_target.mode),
             libc_prefix,
-            if (test_target.single_threaded) "single" else "multi",
+            single_threaded_txt,
-        ));
+        }));
         these_tests.single_threaded = test_target.single_threaded;
         these_tests.setFilter(test_filter);
         these_tests.setBuildMode(test_target.mode);
 @@ -562,7 +562,7 @@ pub const CompareOutputContext = struct {
                 args.append(arg) catch unreachable;
             }
-            warn("Test {}/{} {}...", self.test_index + 1, self.context.test_index, self.name);
+            warn("Test {}/{} {}...", .{ self.test_index + 1, self.context.test_index, self.name });
             const child = std.ChildProcess.init(args.toSliceConst(), b.allocator) catch unreachable;
             defer child.deinit();
 @@ -572,7 +572,7 @@ pub const CompareOutputContext = struct {
             child.stderr_behavior = .Pipe;
             child.env_map = b.env_map;
-            child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
+            child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", .{ full_exe_path, @errorName(err) });
             var stdout = Buffer.initNull(b.allocator);
             var stderr = Buffer.initNull(b.allocator);
 @@ -584,18 +584,18 @@ pub const CompareOutputContext = struct {
             stderr_file_in_stream.stream.readAllBuffer(&stderr, max_stdout_size) catch unreachable;
             const term = child.wait() catch |err| {
-                debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
+                debug.panic("Unable to spawn {}: {}\n", .{ full_exe_path, @errorName(err) });
             };
             switch (term) {
                 .Exited => |code| {
                     if (code != 0) {
-                        warn("Process {} exited with error code {}\n", full_exe_path, code);
+                        warn("Process {} exited with error code {}\n", .{ full_exe_path, code });
                         printInvocation(args.toSliceConst());
                         return error.TestFailed;
                     }
                 },
                 else => {
-                    warn("Process {} terminated unexpectedly\n", full_exe_path);
+                    warn("Process {} terminated unexpectedly\n", .{full_exe_path});
                     printInvocation(args.toSliceConst());
                     return error.TestFailed;
                 },
 @@ -609,10 +609,10 @@ pub const CompareOutputContext = struct {
                     \\========= But found: ====================
                     \\{}
                     \\
-                , self.expected_output, stdout.toSliceConst());
+                , .{ self.expected_output, stdout.toSliceConst() });
                 return error.TestFailed;
             }
-            warn("OK\n");
+            warn("OK\n", .{});
         }
     };
 @@ -644,7 +644,7 @@ pub const CompareOutputContext = struct {
             const full_exe_path = self.exe.getOutputPath();
-            warn("Test {}/{} {}...", self.test_index + 1, self.context.test_index, self.name);
+            warn("Test {}/{} {}...", .{ self.test_index + 1, self.context.test_index, self.name });
             const child = std.ChildProcess.init(&[_][]const u8{full_exe_path}, b.allocator) catch unreachable;
             defer child.deinit();
 @@ -655,28 +655,34 @@ pub const CompareOutputContext = struct {
             child.stderr_behavior = .Ignore;
             const term = child.spawnAndWait() catch |err| {
-                debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
+                debug.panic("Unable to spawn {}: {}\n", .{ full_exe_path, @errorName(err) });
             };
             const expected_exit_code: u32 = 126;
             switch (term) {
                 .Exited => |code| {
                     if (code != expected_exit_code) {
-                        warn("\nProgram expected to exit with code {} " ++ "but exited with code {}\n", expected_exit_code, code);
+                        warn("\nProgram expected to exit with code {} but exited with code {}\n", .{
+                            expected_exit_code, code,
+                        });
                         return error.TestFailed;
                     }
                 },
                 .Signal => |sig| {
-                    warn("\nProgram expected to exit with code {} " ++ "but instead signaled {}\n", expected_exit_code, sig);
+                    warn("\nProgram expected to exit with code {} but instead signaled {}\n", .{
+                        expected_exit_code, sig,
+                    });
                     return error.TestFailed;
                 },
                 else => {
-                    warn("\nProgram expected to exit with code {}" ++ " but exited in an unexpected way\n", expected_exit_code);
+                    warn("\nProgram expected to exit with code {} but exited in an unexpected way\n", .{
+                        expected_exit_code,
+                    });
                     return error.TestFailed;
                 },
             }
-            warn("OK\n");
+            warn("OK\n", .{});
         }
     };
 @@ -729,7 +735,9 @@ pub const CompareOutputContext = struct {
         switch (case.special) {
             Special.Asm => {
-                const annotated_case_name = fmt.allocPrint(self.b.allocator, "assemble-and-link {}", case.name) catch unreachable;
+                const annotated_case_name = fmt.allocPrint(self.b.allocator, "assemble-and-link {}", .{
+                    case.name,
+                }) catch unreachable;
                 if (self.test_filter) |filter| {
                     if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
                 }
 @@ -758,7 +766,11 @@ pub const CompareOutputContext = struct {
             },
             Special.None => {
                 for (self.modes) |mode| {
-                    const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {} ({})", "compare-output", case.name, @tagName(mode)) catch unreachable;
+                    const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {} ({})", .{
+                        "compare-output",
+                        case.name,
+                        @tagName(mode),
+                    }) catch unreachable;
                     if (self.test_filter) |filter| {
                         if (mem.indexOf(u8, annotated_case_name, filter) == null) continue;
                     }
 @@ -790,7 +802,7 @@ pub const CompareOutputContext = struct {
                 }
             },
             Special.RuntimeSafety => {
-                const annotated_case_name = fmt.allocPrint(self.b.allocator, "safety {}", case.name) catch unreachable;
+                const annotated_case_name = fmt.allocPrint(self.b.allocator, "safety {}", .{case.name}) catch unreachable;
                 if (self.test_filter) |filter| {
                     if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
                 }
 @@ -843,7 +855,11 @@ pub const StackTracesContext = struct {
             const expect_for_mode = expect[@enumToInt(mode)];
             if (expect_for_mode.len == 0) continue;
-            const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {} ({})", "stack-trace", name, @tagName(mode)) catch unreachable;
+            const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {} ({})", .{
+                "stack-trace",
+                name,
+                @tagName(mode),
+            }) catch unreachable;
             if (self.test_filter) |filter| {
                 if (mem.indexOf(u8, annotated_case_name, filter) == null) continue;
             }
 @@ -907,7 +923,7 @@ pub const StackTracesContext = struct {
             defer args.deinit();
             args.append(full_exe_path) catch unreachable;
-            warn("Test {}/{} {}...", self.test_index + 1, self.context.test_index, self.name);
+            warn("Test {}/{} {}...", .{ self.test_index + 1, self.context.test_index, self.name });
             const child = std.ChildProcess.init(args.toSliceConst(), b.allocator) catch unreachable;
             defer child.deinit();
 @@ -917,7 +933,7 @@ pub const StackTracesContext = struct {
             child.stderr_behavior = .Pipe;
             child.env_map = b.env_map;
-            child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
+            child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", .{ full_exe_path, @errorName(err) });
             var stdout = Buffer.initNull(b.allocator);
             var stderr = Buffer.initNull(b.allocator);
 @@ -929,30 +945,34 @@ pub const StackTracesContext = struct {
             stderr_file_in_stream.stream.readAllBuffer(&stderr, max_stdout_size) catch unreachable;
             const term = child.wait() catch |err| {
-                debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
+                debug.panic("Unable to spawn {}: {}\n", .{ full_exe_path, @errorName(err) });
             };
             switch (term) {
                 .Exited => |code| {
                     const expect_code: u32 = 1;
                     if (code != expect_code) {
-                        warn("Process {} exited with error code {} but expected code {}\n", full_exe_path, code, expect_code);
+                        warn("Process {} exited with error code {} but expected code {}\n", .{
+                            full_exe_path,
+                            code,
+                            expect_code,
+                        });
                         printInvocation(args.toSliceConst());
                         return error.TestFailed;
                     }
                 },
                 .Signal => |signum| {
-                    warn("Process {} terminated on signal {}\n", full_exe_path, signum);
+                    warn("Process {} terminated on signal {}\n", .{ full_exe_path, signum });
                     printInvocation(args.toSliceConst());
                     return error.TestFailed;
                 },
                 .Stopped => |signum| {
-                    warn("Process {} stopped on signal {}\n", full_exe_path, signum);
+                    warn("Process {} stopped on signal {}\n", .{ full_exe_path, signum });
                     printInvocation(args.toSliceConst());
                     return error.TestFailed;
                 },
                 .Unknown => |code| {
-                    warn("Process {} terminated unexpectedly with error code {}\n", full_exe_path, code);
+                    warn("Process {} terminated unexpectedly with error code {}\n", .{ full_exe_path, code });
                     printInvocation(args.toSliceConst());
                     return error.TestFailed;
                 },
 @@ -1003,10 +1023,10 @@ pub const StackTracesContext = struct {
                     \\================================================
                     \\{}
                     \\
-                , self.expect_output, got);
+                , .{ self.expect_output, got });
                 return error.TestFailed;
             }
-            warn("OK\n");
+            warn("OK\n", .{});
         }
     };
 };
 @@ -1129,7 +1149,7 @@ pub const CompileErrorContext = struct {
                 Mode.ReleaseSmall => zig_args.append("--release-small") catch unreachable,
             }
-            warn("Test {}/{} {}...", self.test_index + 1, self.context.test_index, self.name);
+            warn("Test {}/{} {}...", .{ self.test_index + 1, self.context.test_index, self.name });
             if (b.verbose) {
                 printInvocation(zig_args.toSliceConst());
 @@ -1143,7 +1163,7 @@ pub const CompileErrorContext = struct {
             child.stdout_behavior = .Pipe;
             child.stderr_behavior = .Pipe;
-            child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", zig_args.items[0], @errorName(err));
+            child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", .{ zig_args.items[0], @errorName(err) });
             var stdout_buf = Buffer.initNull(b.allocator);
             var stderr_buf = Buffer.initNull(b.allocator);
 @@ -1155,7 +1175,7 @@ pub const CompileErrorContext = struct {
             stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size) catch unreachable;
             const term = child.wait() catch |err| {
-                debug.panic("Unable to spawn {}: {}\n", zig_args.items[0], @errorName(err));
+                debug.panic("Unable to spawn {}: {}\n", .{ zig_args.items[0], @errorName(err) });
             };
             switch (term) {
                 .Exited => |code| {
 @@ -1165,7 +1185,7 @@ pub const CompileErrorContext = struct {
                     }
                 },
                 else => {
-                    warn("Process {} terminated unexpectedly\n", b.zig_exe);
+                    warn("Process {} terminated unexpectedly\n", .{b.zig_exe});
                     printInvocation(zig_args.toSliceConst());
                     return error.TestFailed;
                 },
 @@ -1182,7 +1202,7 @@ pub const CompileErrorContext = struct {
                     \\{}
                     \\================================================
                     \\
-                , stdout);
+                , .{stdout});
                 return error.TestFailed;
             }
 @@ -1200,9 +1220,9 @@ pub const CompileErrorContext = struct {
                 ok = ok and i == self.case.expected_errors.len;
                 if (!ok) {
-                    warn("\n======== Expected these compile errors: ========\n");
+                    warn("\n======== Expected these compile errors: ========\n", .{});
                     for (self.case.expected_errors.toSliceConst()) |expected| {
-                        warn("{}\n", expected);
+                        warn("{}\n", .{expected});
                     }
                 }
             } else {
 @@ -1213,7 +1233,7 @@ pub const CompileErrorContext = struct {
                             \\=========== Expected compile error: ============
                             \\{}
                             \\
-                        , expected);
+                        , .{expected});
                         ok = false;
                         break;
                     }
 @@ -1225,11 +1245,11 @@ pub const CompileErrorContext = struct {
                     \\================= Full output: =================
                     \\{}
                     \\
-                , stderr);
+                , .{stderr});
                 return error.TestFailed;
             }
-            warn("OK\n");
+            warn("OK\n", .{});
         }
     };
 @@ -1279,7 +1299,9 @@ pub const CompileErrorContext = struct {
     pub fn addCase(self: *CompileErrorContext, case: *const TestCase) void {
         const b = self.b;
-        const annotated_case_name = fmt.allocPrint(self.b.allocator, "compile-error {}", case.name) catch unreachable;
+        const annotated_case_name = fmt.allocPrint(self.b.allocator, "compile-error {}", .{
+            case.name,
+        }) catch unreachable;
         if (self.test_filter) |filter| {
             if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
         }
 @@ -1316,7 +1338,7 @@ pub const StandaloneContext = struct {
     pub fn addBuildFile(self: *StandaloneContext, build_file: []const u8) void {
         const b = self.b;
-        const annotated_case_name = b.fmt("build {} (Debug)", build_file);
+        const annotated_case_name = b.fmt("build {} (Debug)", .{build_file});
         if (self.test_filter) |filter| {
             if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
         }
 @@ -1337,7 +1359,7 @@ pub const StandaloneContext = struct {
         const run_cmd = b.addSystemCommand(zig_args.toSliceConst());
-        const log_step = b.addLog("PASS {}\n", annotated_case_name);
+        const log_step = b.addLog("PASS {}\n", .{annotated_case_name});
         log_step.step.dependOn(&run_cmd.step);
         self.step.dependOn(&log_step.step);
 @@ -1347,7 +1369,10 @@ pub const StandaloneContext = struct {
         const b = self.b;
         for (self.modes) |mode| {
-            const annotated_case_name = fmt.allocPrint(self.b.allocator, "build {} ({})", root_src, @tagName(mode)) catch unreachable;
+            const annotated_case_name = fmt.allocPrint(self.b.allocator, "build {} ({})", .{
+                root_src,
+                @tagName(mode),
+            }) catch unreachable;
             if (self.test_filter) |filter| {
                 if (mem.indexOf(u8, annotated_case_name, filter) == null) continue;
             }
 @@ -1358,7 +1383,7 @@ pub const StandaloneContext = struct {
                 exe.linkSystemLibrary("c");
             }
-            const log_step = b.addLog("PASS {}\n", annotated_case_name);
+            const log_step = b.addLog("PASS {}\n", .{annotated_case_name});
             log_step.step.dependOn(&exe.step);
             self.step.dependOn(&log_step.step);
 @@ -1434,7 +1459,7 @@ pub const TranslateCContext = struct {
             zig_args.append(translate_c_cmd) catch unreachable;
             zig_args.append(b.pathFromRoot(root_src)) catch unreachable;
-            warn("Test {}/{} {}...", self.test_index + 1, self.context.test_index, self.name);
+            warn("Test {}/{} {}...", .{ self.test_index + 1, self.context.test_index, self.name });
             if (b.verbose) {
                 printInvocation(zig_args.toSliceConst());
 @@ -1448,7 +1473,10 @@ pub const TranslateCContext = struct {
             child.stdout_behavior = .Pipe;
             child.stderr_behavior = .Pipe;
-            child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", zig_args.toSliceConst()[0], @errorName(err));
+            child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", .{
+                zig_args.toSliceConst()[0],
+                @errorName(err),
+            });
             var stdout_buf = Buffer.initNull(b.allocator);
             var stderr_buf = Buffer.initNull(b.allocator);
 @@ -1460,23 +1488,23 @@ pub const TranslateCContext = struct {
             stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size) catch unreachable;
             const term = child.wait() catch |err| {
-                debug.panic("Unable to spawn {}: {}\n", zig_args.toSliceConst()[0], @errorName(err));
+                debug.panic("Unable to spawn {}: {}\n", .{ zig_args.toSliceConst()[0], @errorName(err) });
             };
             switch (term) {
                 .Exited => |code| {
                     if (code != 0) {
-                        warn("Compilation failed with exit code {}\n", code);
+                        warn("Compilation failed with exit code {}\n", .{code});
                         printInvocation(zig_args.toSliceConst());
                         return error.TestFailed;
                     }
                 },
                 .Signal => |code| {
-                    warn("Compilation failed with signal {}\n", code);
+                    warn("Compilation failed with signal {}\n", .{code});
                     printInvocation(zig_args.toSliceConst());
                     return error.TestFailed;
                 },
                 else => {
-                    warn("Compilation terminated unexpectedly\n");
+                    warn("Compilation terminated unexpectedly\n", .{});
                     printInvocation(zig_args.toSliceConst());
                     return error.TestFailed;
                 },
 @@ -1491,7 +1519,7 @@ pub const TranslateCContext = struct {
                     \\{}
                     \\============================================
                     \\
-                , stderr);
+                , .{stderr});
                 printInvocation(zig_args.toSliceConst());
                 return error.TestFailed;
             }
 @@ -1505,20 +1533,20 @@ pub const TranslateCContext = struct {
                         \\========= But found: ===========================
                         \\{}
                         \\
-                    , expected_line, stdout);
+                    , .{ expected_line, stdout });
                     printInvocation(zig_args.toSliceConst());
                     return error.TestFailed;
                 }
             }
-            warn("OK\n");
+            warn("OK\n", .{});
         }
     };
     fn printInvocation(args: []const []const u8) void {
         for (args) |arg| {
-            warn("{} ", arg);
+            warn("{} ", .{arg});
         }
-        warn("\n");
+        warn("\n", .{});
     }
     pub fn create(self: *TranslateCContext, allow_warnings: bool, filename: []const u8, name: []const u8, source: []const u8, expected_lines: ...) *TestCase {
 @@ -1586,7 +1614,7 @@ pub const TranslateCContext = struct {
         const b = self.b;
         const translate_c_cmd = if (case.stage2) "translate-c-2" else "translate-c";
-        const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {}", translate_c_cmd, case.name) catch unreachable;
+        const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {}", .{ translate_c_cmd, case.name }) catch unreachable;
         if (self.test_filter) |filter| {
             if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
         }
 @@ -1666,7 +1694,7 @@ pub const GenHContext = struct {
             const self = @fieldParentPtr(GenHCmpOutputStep, "step", step);
             const b = self.context.b;
-            warn("Test {}/{} {}...", self.test_index + 1, self.context.test_index, self.name);
+            warn("Test {}/{} {}...", .{ self.test_index + 1, self.context.test_index, self.name });
             const full_h_path = self.obj.getOutputHPath();
             const actual_h = try io.readFileAlloc(b.allocator, full_h_path);
 @@ -1680,19 +1708,19 @@ pub const GenHContext = struct {
                         \\========= But found: ===========================
                         \\{}
                         \\
-                    , expected_line, actual_h);
+                    , .{ expected_line, actual_h });
                     return error.TestFailed;
                 }
             }
-            warn("OK\n");
+            warn("OK\n", .{});
         }
     };
     fn printInvocation(args: []const []const u8) void {
         for (args) |arg| {
-            warn("{} ", arg);
+            warn("{} ", .{arg});
         }
-        warn("\n");
+        warn("\n", .{});
     }
     pub fn create(self: *GenHContext, filename: []const u8, name: []const u8, source: []const u8, expected_lines: ...) *TestCase {
 @@ -1724,7 +1752,7 @@ pub const GenHContext = struct {
         ) catch unreachable;
         const mode = builtin.Mode.Debug;
-        const annotated_case_name = fmt.allocPrint(self.b.allocator, "gen-h {} ({})", case.name, @tagName(mode)) catch unreachable;
+        const annotated_case_name = fmt.allocPrint(self.b.allocator, "gen-h {} ({})", .{ case.name, @tagName(mode) }) catch unreachable;
         if (self.test_filter) |filter| {
             if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
         }
 @@ -1749,7 +1777,7 @@ pub const GenHContext = struct {
 fn printInvocation(args: []const []const u8) void {
     for (args) |arg| {
-        warn("{} ", arg);
+        warn("{} ", .{arg});
     }
-    warn("\n");
+    warn("\n", .{});
 }

author	Andrew Kelley <andrew@ziglang.org> 2019-12-09 10:51:47-05:00
committer	GitHub <noreply@github.com> 2019-12-09 10:51:47-05:00
log	640e09183d3100c477a26c6cdc26f1eae31472a1
tree	0bddf7eb99d6daaaa2e5ee80b51a6766aefb7d9c
parent	5874cb04bd544ca155d1489bb0bdf9397fa3b41c
parent	8b3c0bbeeef080b77d0cb7999682abc52de437e3
signature	Signed by PGP key 4AEE18F83AFDEB23

...	@@ -16,7 +16,7 @@ pub const Buffer = struct {	...	@@ -16,7 +16,7 @@ pub const Buffer = struct {
16	mem.copy(u8, self.list.items, m);	16	mem.copy(u8, self.list.items, m);
17	return self;	17	return self;
18	}	18	}
19		19
20	/// Initialize memory to size bytes of undefined values.	20	/// Initialize memory to size bytes of undefined values.
21	/// Must deinitialize with deinit.	21	/// Must deinitialize with deinit.
22	pub fn initSize(allocator: *Allocator, size: usize) !Buffer {	22	pub fn initSize(allocator: *Allocator, size: usize) !Buffer {
...	@@ -24,7 +24,7 @@ pub const Buffer = struct {	...	@@ -24,7 +24,7 @@ pub const Buffer = struct {
24	try self.resize(size);	24	try self.resize(size);
25	return self;	25	return self;
26	}	26	}
27		27
28	/// Initialize with capacity to hold at least num bytes.	28	/// Initialize with capacity to hold at least num bytes.
29	/// Must deinitialize with deinit.	29	/// Must deinitialize with deinit.
30	pub fn initCapacity(allocator: *Allocator, num: usize) !Buffer {	30	pub fn initCapacity(allocator: *Allocator, num: usize) !Buffer {
...	@@ -64,7 +64,7 @@ pub const Buffer = struct {	...	@@ -64,7 +64,7 @@ pub const Buffer = struct {
64	return result;	64	return result;
65	}	65	}
66		66
67	pub fn allocPrint(allocator: *Allocator, comptime format: []const u8, args: ...) !Buffer {	67	pub fn allocPrint(allocator: *Allocator, comptime format: []const u8, args: var) !Buffer {
68	const countSize = struct {	68	const countSize = struct {
69	fn countSize(size: *usize, bytes: []const u8) (error{}!void) {	69	fn countSize(size: *usize, bytes: []const u8) (error{}!void) {
70	size.* += bytes.len;	70	size.* += bytes.len;
...	@@ -107,7 +107,7 @@ pub const Buffer = struct {	...	@@ -107,7 +107,7 @@ pub const Buffer = struct {
107	pub fn len(self: Buffer) usize {	107	pub fn len(self: Buffer) usize {
108	return self.list.len - 1;	108	return self.list.len - 1;
109	}	109	}
110		110
111	pub fn capacity(self: Buffer) usize {	111	pub fn capacity(self: Buffer) usize {
112	return if (self.list.items.len > 0)	112	return if (self.list.items.len > 0)
113	self.list.items.len - 1	113	self.list.items.len - 1

...	@@ -29,7 +29,7 @@ test "parse and render IPv6 addresses" {	...	@@ -29,7 +29,7 @@ test "parse and render IPv6 addresses" {
29	};	29	};
30	for (ips) \|ip, i\| {	30	for (ips) \|ip, i\| {
31	var addr = net.Address.parseIp6(ip, 0) catch unreachable;	31	var addr = net.Address.parseIp6(ip, 0) catch unreachable;
32	var newIp = std.fmt.bufPrint(buffer[0..], "{}", addr) catch unreachable;	32	var newIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable;
33	std.testing.expect(std.mem.eql(u8, printed[i], newIp[1 .. newIp.len - 3]));	33	std.testing.expect(std.mem.eql(u8, printed[i], newIp[1 .. newIp.len - 3]));
34	}	34	}
35		35
...	@@ -51,7 +51,7 @@ test "parse and render IPv4 addresses" {	...	@@ -51,7 +51,7 @@ test "parse and render IPv4 addresses" {
51	"127.0.0.1",	51	"127.0.0.1",
52	}) \|ip\| {	52	}) \|ip\| {
53	var addr = net.Address.parseIp4(ip, 0) catch unreachable;	53	var addr = net.Address.parseIp4(ip, 0) catch unreachable;
54	var newIp = std.fmt.bufPrint(buffer[0..], "{}", addr) catch unreachable;	54	var newIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable;
55	std.testing.expect(std.mem.eql(u8, ip, newIp[0 .. newIp.len - 2]));	55	std.testing.expect(std.mem.eql(u8, ip, newIp[0 .. newIp.len - 2]));
56	}	56	}
57		57
...	@@ -118,5 +118,5 @@ fn testServer(server: *net.StreamServer) anyerror!void {	...	@@ -118,5 +118,5 @@ fn testServer(server: *net.StreamServer) anyerror!void {
118	var client = try server.accept();	118	var client = try server.accept();
119		119
120	const stream = &client.file.outStream().stream;	120	const stream = &client.file.outStream().stream;
121	try stream.print("hello from server\n");	121	try stream.print("hello from server\n", .{});
122	}	122	}

...	@@ -323,7 +323,7 @@ pub fn GetQueuedCompletionStatus(	...	@@ -323,7 +323,7 @@ pub fn GetQueuedCompletionStatus(
323	ERROR.HANDLE_EOF => return GetQueuedCompletionStatusResult.EOF,	323	ERROR.HANDLE_EOF => return GetQueuedCompletionStatusResult.EOF,
324	else => \|err\| {	324	else => \|err\| {
325	if (std.debug.runtime_safety) {	325	if (std.debug.runtime_safety) {
326	std.debug.panic("unexpected error: {}\n", err);	326	std.debug.panic("unexpected error: {}\n", .{err});
327	}	327	}
328	},	328	},
329	}	329	}
...	@@ -1039,7 +1039,7 @@ pub fn unexpectedError(err: DWORD) std.os.UnexpectedError {	...	@@ -1039,7 +1039,7 @@ pub fn unexpectedError(err: DWORD) std.os.UnexpectedError {
1039	var buf_u8: [614]u8 = undefined;	1039	var buf_u8: [614]u8 = undefined;
1040	var len = kernel32.FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM \| FORMAT_MESSAGE_IGNORE_INSERTS, null, err, MAKELANGID(LANG.NEUTRAL, SUBLANG.DEFAULT), buf_u16[0..].ptr, buf_u16.len / @sizeOf(TCHAR), null);	1040	var len = kernel32.FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM \| FORMAT_MESSAGE_IGNORE_INSERTS, null, err, MAKELANGID(LANG.NEUTRAL, SUBLANG.DEFAULT), buf_u16[0..].ptr, buf_u16.len / @sizeOf(TCHAR), null);
1041	_ = std.unicode.utf16leToUtf8(&buf_u8, buf_u16[0..len]) catch unreachable;	1041	_ = std.unicode.utf16leToUtf8(&buf_u8, buf_u16[0..len]) catch unreachable;
1042	std.debug.warn("error.Unexpected: GetLastError({}): {}\n", err, buf_u8[0..len]);	1042	std.debug.warn("error.Unexpected: GetLastError({}): {}\n", .{ err, buf_u8[0..len] });
1043	std.debug.dumpCurrentStackTrace(null);	1043	std.debug.dumpCurrentStackTrace(null);
1044	}	1044	}
1045	return error.Unexpected;	1045	return error.Unexpected;
...	@@ -1053,7 +1053,7 @@ pub fn unexpectedWSAError(err: c_int) std.os.UnexpectedError {	...	@@ -1053,7 +1053,7 @@ pub fn unexpectedWSAError(err: c_int) std.os.UnexpectedError {
1053	/// and you get an unexpected status.	1053	/// and you get an unexpected status.
1054	pub fn unexpectedStatus(status: NTSTATUS) std.os.UnexpectedError {	1054	pub fn unexpectedStatus(status: NTSTATUS) std.os.UnexpectedError {
1055	if (std.os.unexpected_error_tracing) {	1055	if (std.os.unexpected_error_tracing) {
1056	std.debug.warn("error.Unexpected NTSTATUS=0x{x}\n", status);	1056	std.debug.warn("error.Unexpected NTSTATUS=0x{x}\n", .{status});
1057	std.debug.dumpCurrentStackTrace(null);	1057	std.debug.dumpCurrentStackTrace(null);
1058	}	1058	}
1059	return error.Unexpected;	1059	return error.Unexpected;

...	@@ -98,15 +98,15 @@ pub const Args = struct {	...	@@ -98,15 +98,15 @@ pub const Args = struct {
98	const flag_args = readFlagArguments(allocator, args, flag.required, flag.allowed_set, &i) catch \|err\| {	98	const flag_args = readFlagArguments(allocator, args, flag.required, flag.allowed_set, &i) catch \|err\| {
99	switch (err) {	99	switch (err) {
100	error.ArgumentNotInAllowedSet => {	100	error.ArgumentNotInAllowedSet => {
101	std.debug.warn("argument '{}' is invalid for flag '{}'\n", args[i], arg);	101	std.debug.warn("argument '{}' is invalid for flag '{}'\n", .{ args[i], arg });
102	std.debug.warn("allowed options are ");	102	std.debug.warn("allowed options are ", .{});
103	for (flag.allowed_set.?) \|possible\| {	103	for (flag.allowed_set.?) \|possible\| {
104	std.debug.warn("'{}' ", possible);	104	std.debug.warn("'{}' ", .{possible});
105	}	105	}
106	std.debug.warn("\n");	106	std.debug.warn("\n", .{});
107	},	107	},
108	error.MissingFlagArguments => {	108	error.MissingFlagArguments => {
109	std.debug.warn("missing argument for flag: {}\n", arg);	109	std.debug.warn("missing argument for flag: {}\n", .{arg});
110	},	110	},
111	else => {},	111	else => {},
112	}	112	}
...	@@ -134,7 +134,7 @@ pub const Args = struct {	...	@@ -134,7 +134,7 @@ pub const Args = struct {
134	}	134	}
135		135
136	// TODO: Better errors with context, global error state and return is sufficient.	136	// TODO: Better errors with context, global error state and return is sufficient.
137	std.debug.warn("could not match flag: {}\n", arg);	137	std.debug.warn("could not match flag: {}\n", .{arg});
138	return error.UnknownFlag;	138	return error.UnknownFlag;
139	} else {	139	} else {
140	try parsed.positionals.append(arg);	140	try parsed.positionals.append(arg);

...	@@ -807,7 +807,7 @@ pub const Compilation = struct {	...	@@ -807,7 +807,7 @@ pub const Compilation = struct {
807	root_scope.realpath,	807	root_scope.realpath,
808	max_src_size,	808	max_src_size,
809	) catch \|err\| {	809	) catch \|err\| {
810	try self.addCompileErrorCli(root_scope.realpath, "unable to open: {}", @errorName(err));	810	try self.addCompileErrorCli(root_scope.realpath, "unable to open: {}", .{@errorName(err)});
811	return;	811	return;
812	};	812	};
813	errdefer self.gpa().free(source_code);	813	errdefer self.gpa().free(source_code);
...	@@ -878,7 +878,7 @@ pub const Compilation = struct {	...	@@ -878,7 +878,7 @@ pub const Compilation = struct {
878	try self.addCompileError(tree_scope, Span{	878	try self.addCompileError(tree_scope, Span{
879	.first = fn_proto.fn_token,	879	.first = fn_proto.fn_token,
880	.last = fn_proto.fn_token + 1,	880	.last = fn_proto.fn_token + 1,
881	}, "missing function name");	881	}, "missing function name", .{});
882	continue;	882	continue;
883	};	883	};
884		884
...	@@ -942,7 +942,7 @@ pub const Compilation = struct {	...	@@ -942,7 +942,7 @@ pub const Compilation = struct {
942	const root_scope = blk: {	942	const root_scope = blk: {
943	// TODO async/await std.fs.realpath	943	// TODO async/await std.fs.realpath
944	const root_src_real_path = std.fs.realpathAlloc(self.gpa(), root_src_path) catch \|err\| {	944	const root_src_real_path = std.fs.realpathAlloc(self.gpa(), root_src_path) catch \|err\| {
945	try self.addCompileErrorCli(root_src_path, "unable to open: {}", @errorName(err));	945	try self.addCompileErrorCli(root_src_path, "unable to open: {}", .{@errorName(err)});
946	return;	946	return;
947	};	947	};
948	errdefer self.gpa().free(root_src_real_path);	948	errdefer self.gpa().free(root_src_real_path);
...	@@ -991,7 +991,7 @@ pub const Compilation = struct {	...	@@ -991,7 +991,7 @@ pub const Compilation = struct {
991	defer unanalyzed_code.destroy(comp.gpa());	991	defer unanalyzed_code.destroy(comp.gpa());
992		992
993	if (comp.verbose_ir) {	993	if (comp.verbose_ir) {
994	std.debug.warn("unanalyzed:\n");	994	std.debug.warn("unanalyzed:\n", .{});
995	unanalyzed_code.dump();	995	unanalyzed_code.dump();
996	}	996	}
997		997
...	@@ -1003,7 +1003,7 @@ pub const Compilation = struct {	...	@@ -1003,7 +1003,7 @@ pub const Compilation = struct {
1003	errdefer analyzed_code.destroy(comp.gpa());	1003	errdefer analyzed_code.destroy(comp.gpa());
1004		1004
1005	if (comp.verbose_ir) {	1005	if (comp.verbose_ir) {
1006	std.debug.warn("analyzed:\n");	1006	std.debug.warn("analyzed:\n", .{});
1007	analyzed_code.dump();	1007	analyzed_code.dump();
1008	}	1008	}
1009		1009
...	@@ -1048,14 +1048,14 @@ pub const Compilation = struct {	...	@@ -1048,14 +1048,14 @@ pub const Compilation = struct {
1048		1048
1049	const gop = try locked_table.getOrPut(decl.name);	1049	const gop = try locked_table.getOrPut(decl.name);
1050	if (gop.found_existing) {	1050	if (gop.found_existing) {
1051	try self.addCompileError(decl.tree_scope, decl.getSpan(), "redefinition of '{}'", decl.name);	1051	try self.addCompileError(decl.tree_scope, decl.getSpan(), "redefinition of '{}'", .{decl.name});
1052	// TODO note: other definition here	1052	// TODO note: other definition here
1053	} else {	1053	} else {
1054	gop.kv.value = decl;	1054	gop.kv.value = decl;
1055	}	1055	}
1056	}	1056	}
1057		1057
1058	fn addCompileError(self: Compilation, tree_scope: Scope.AstTree, span: Span, comptime fmt: []const u8, args: ...) !void {	1058	fn addCompileError(self: Compilation, tree_scope: Scope.AstTree, span: Span, comptime fmt: []const u8, args: var) !void {
1059	const text = try std.fmt.allocPrint(self.gpa(), fmt, args);	1059	const text = try std.fmt.allocPrint(self.gpa(), fmt, args);
1060	errdefer self.gpa().free(text);	1060	errdefer self.gpa().free(text);
1061		1061
...	@@ -1065,7 +1065,7 @@ pub const Compilation = struct {	...	@@ -1065,7 +1065,7 @@ pub const Compilation = struct {
1065	try self.prelink_group.call(addCompileErrorAsync, self, msg);	1065	try self.prelink_group.call(addCompileErrorAsync, self, msg);
1066	}	1066	}
1067		1067
1068	fn addCompileErrorCli(self: *Compilation, realpath: []const u8, comptime fmt: []const u8, args: ...) !void {	1068	fn addCompileErrorCli(self: *Compilation, realpath: []const u8, comptime fmt: []const u8, args: var) !void {
1069	const text = try std.fmt.allocPrint(self.gpa(), fmt, args);	1069	const text = try std.fmt.allocPrint(self.gpa(), fmt, args);
1070	errdefer self.gpa().free(text);	1070	errdefer self.gpa().free(text);
1071		1071
...	@@ -1092,12 +1092,9 @@ pub const Compilation = struct {	...	@@ -1092,12 +1092,9 @@ pub const Compilation = struct {
1092	defer exported_symbol_names.release();	1092	defer exported_symbol_names.release();
1093		1093
1094	if (try exported_symbol_names.value.put(decl.name, decl)) \|other_decl\| {	1094	if (try exported_symbol_names.value.put(decl.name, decl)) \|other_decl\| {
1095	try self.addCompileError(	1095	try self.addCompileError(decl.tree_scope, decl.getSpan(), "exported symbol collision: '{}'", .{
1096	decl.tree_scope,
1097	decl.getSpan(),
1098	"exported symbol collision: '{}'",
1099	decl.name,	1096	decl.name,
1100	);	1097	});
1101	// TODO add error note showing location of other symbol	1098	// TODO add error note showing location of other symbol
1102	}	1099	}
1103	}	1100	}
...	@@ -1162,7 +1159,7 @@ pub const Compilation = struct {	...	@@ -1162,7 +1159,7 @@ pub const Compilation = struct {
1162	const tmp_dir = try self.getTmpDir();	1159	const tmp_dir = try self.getTmpDir();
1163	const file_prefix = self.getRandomFileName();	1160	const file_prefix = self.getRandomFileName();
1164		1161
1165	const file_name = try std.fmt.allocPrint(self.gpa(), "{}{}", file_prefix[0..], suffix);	1162	const file_name = try std.fmt.allocPrint(self.gpa(), "{}{}", .{ file_prefix[0..], suffix });
1166	defer self.gpa().free(file_name);	1163	defer self.gpa().free(file_name);
1167		1164
1168	const full_path = try std.fs.path.join(self.gpa(), &[_][]const u8{ tmp_dir, file_name[0..] });	1165	const full_path = try std.fs.path.join(self.gpa(), &[_][]const u8{ tmp_dir, file_name[0..] });
...	@@ -1303,7 +1300,7 @@ fn generateDeclFn(comp: Compilation, fn_decl: Decl.Fn) !void {	...	@@ -1303,7 +1300,7 @@ fn generateDeclFn(comp: Compilation, fn_decl: Decl.Fn) !void {
1303	try comp.addCompileError(tree_scope, Span{	1300	try comp.addCompileError(tree_scope, Span{
1304	.first = param_decl.firstToken(),	1301	.first = param_decl.firstToken(),
1305	.last = param_decl.type_node.firstToken(),	1302	.last = param_decl.type_node.firstToken(),
1306	}, "missing parameter name");	1303	}, "missing parameter name", .{});
1307	return error.SemanticAnalysisFailed;	1304	return error.SemanticAnalysisFailed;
1308	};	1305	};
1309	const param_name = tree_scope.tree.tokenSlice(name_token);	1306	const param_name = tree_scope.tree.tokenSlice(name_token);

...	@@ -38,7 +38,7 @@ pub const Tokenizer = struct {	...	@@ -38,7 +38,7 @@ pub const Tokenizer = struct {
38	},	38	},
39	.target => \|*target\| switch (char) {	39	.target => \|*target\| switch (char) {
40	'\t', '\n', '\r', ' ' => {	40	'\t', '\n', '\r', ' ' => {
41	return self.errorIllegalChar(self.index, char, "invalid target");	41	return self.errorIllegalChar(self.index, char, "invalid target", .{});
42	},	42	},
43	'$' => {	43	'$' => {
44	self.state = State{ .target_dollar_sign = target.* };	44	self.state = State{ .target_dollar_sign = target.* };
...	@@ -59,7 +59,7 @@ pub const Tokenizer = struct {	...	@@ -59,7 +59,7 @@ pub const Tokenizer = struct {
59	},	59	},
60	.target_reverse_solidus => \|*target\| switch (char) {	60	.target_reverse_solidus => \|*target\| switch (char) {
61	'\t', '\n', '\r' => {	61	'\t', '\n', '\r' => {
62	return self.errorIllegalChar(self.index, char, "bad target escape");	62	return self.errorIllegalChar(self.index, char, "bad target escape", .{});
63	},	63	},
64	' ', '#', '\\' => {	64	' ', '#', '\\' => {
65	try target.appendByte(char);	65	try target.appendByte(char);
...	@@ -84,7 +84,7 @@ pub const Tokenizer = struct {	...	@@ -84,7 +84,7 @@ pub const Tokenizer = struct {
84	break; // advance	84	break; // advance
85	},	85	},
86	else => {	86	else => {
87	return self.errorIllegalChar(self.index, char, "expecting '$'");	87	return self.errorIllegalChar(self.index, char, "expecting '$'", .{});
88	},	88	},
89	},	89	},
90	.target_colon => \|*target\| switch (char) {	90	.target_colon => \|*target\| switch (char) {
...	@@ -161,7 +161,7 @@ pub const Tokenizer = struct {	...	@@ -161,7 +161,7 @@ pub const Tokenizer = struct {
161	break; // advance	161	break; // advance
162	},	162	},
163	else => {	163	else => {
164	return self.errorIllegalChar(self.index, char, "continuation expecting end-of-line");	164	return self.errorIllegalChar(self.index, char, "continuation expecting end-of-line", .{});
165	},	165	},
166	},	166	},
167	.rhs_continuation_linefeed => switch (char) {	167	.rhs_continuation_linefeed => switch (char) {
...	@@ -170,7 +170,7 @@ pub const Tokenizer = struct {	...	@@ -170,7 +170,7 @@ pub const Tokenizer = struct {
170	break; // advance	170	break; // advance
171	},	171	},
172	else => {	172	else => {
173	return self.errorIllegalChar(self.index, char, "continuation expecting end-of-line");	173	return self.errorIllegalChar(self.index, char, "continuation expecting end-of-line", .{});
174	},	174	},
175	},	175	},
176	.prereq_quote => \|*prereq\| switch (char) {	176	.prereq_quote => \|*prereq\| switch (char) {
...	@@ -231,7 +231,7 @@ pub const Tokenizer = struct {	...	@@ -231,7 +231,7 @@ pub const Tokenizer = struct {
231	return Token{ .id = .prereq, .bytes = bytes };	231	return Token{ .id = .prereq, .bytes = bytes };
232	},	232	},
233	else => {	233	else => {
234	return self.errorIllegalChar(self.index, char, "continuation expecting end-of-line");	234	return self.errorIllegalChar(self.index, char, "continuation expecting end-of-line", .{});
235	},	235	},
236	},	236	},
237	}	237	}
...	@@ -249,13 +249,13 @@ pub const Tokenizer = struct {	...	@@ -249,13 +249,13 @@ pub const Tokenizer = struct {
249	.rhs_continuation_linefeed,	249	.rhs_continuation_linefeed,
250	=> {},	250	=> {},
251	.target => \|target\| {	251	.target => \|target\| {
252	return self.errorPosition(idx, target.toSlice(), "incomplete target");	252	return self.errorPosition(idx, target.toSlice(), "incomplete target", .{});
253	},	253	},
254	.target_reverse_solidus,	254	.target_reverse_solidus,
255	.target_dollar_sign,	255	.target_dollar_sign,
256	=> {	256	=> {
257	const index = self.index - 1;	257	const index = self.index - 1;
258	return self.errorIllegalChar(idx, self.bytes[idx], "incomplete escape");	258	return self.errorIllegalChar(idx, self.bytes[idx], "incomplete escape", .{});
259	},	259	},
260	.target_colon => \|target\| {	260	.target_colon => \|target\| {
261	const bytes = target.toSlice();	261	const bytes = target.toSlice();
...	@@ -278,7 +278,7 @@ pub const Tokenizer = struct {	...	@@ -278,7 +278,7 @@ pub const Tokenizer = struct {
278	self.state = State{ .lhs = {} };	278	self.state = State{ .lhs = {} };
279	},	279	},
280	.prereq_quote => \|prereq\| {	280	.prereq_quote => \|prereq\| {
281	return self.errorPosition(idx, prereq.toSlice(), "incomplete quoted prerequisite");	281	return self.errorPosition(idx, prereq.toSlice(), "incomplete quoted prerequisite", .{});
282	},	282	},
283	.prereq => \|prereq\| {	283	.prereq => \|prereq\| {
284	const bytes = prereq.toSlice();	284	const bytes = prereq.toSlice();
...	@@ -299,29 +299,29 @@ pub const Tokenizer = struct {	...	@@ -299,29 +299,29 @@ pub const Tokenizer = struct {
299	return null;	299	return null;
300	}	300	}
301		301
302	fn errorf(self: *Tokenizer, comptime fmt: []const u8, args: ...) Error {	302	fn errorf(self: *Tokenizer, comptime fmt: []const u8, args: var) Error {
303	self.error_text = (try std.Buffer.allocPrint(&self.arena.allocator, fmt, args)).toSlice();	303	self.error_text = (try std.Buffer.allocPrint(&self.arena.allocator, fmt, args)).toSlice();
304	return Error.InvalidInput;	304	return Error.InvalidInput;
305	}	305	}
306		306
307	fn errorPosition(self: *Tokenizer, position: usize, bytes: []const u8, comptime fmt: []const u8, args: ...) Error {	307	fn errorPosition(self: *Tokenizer, position: usize, bytes: []const u8, comptime fmt: []const u8, args: var) Error {
308	var buffer = try std.Buffer.initSize(&self.arena.allocator, 0);	308	var buffer = try std.Buffer.initSize(&self.arena.allocator, 0);
309	std.fmt.format(&buffer, anyerror, std.Buffer.append, fmt, args) catch {};	309	std.fmt.format(&buffer, anyerror, std.Buffer.append, fmt, args) catch {};
310	try buffer.append(" '");	310	try buffer.append(" '");
311	var out = makeOutput(std.Buffer.append, &buffer);	311	var out = makeOutput(std.Buffer.append, &buffer);
312	try printCharValues(&out, bytes);	312	try printCharValues(&out, bytes);
313	try buffer.append("'");	313	try buffer.append("'");
314	std.fmt.format(&buffer, anyerror, std.Buffer.append, " at position {}", position - (bytes.len - 1)) catch {};	314	std.fmt.format(&buffer, anyerror, std.Buffer.append, " at position {}", .{position - (bytes.len - 1)}) catch {};
315	self.error_text = buffer.toSlice();	315	self.error_text = buffer.toSlice();
316	return Error.InvalidInput;	316	return Error.InvalidInput;
317	}	317	}
318		318
319	fn errorIllegalChar(self: *Tokenizer, position: usize, char: u8, comptime fmt: []const u8, args: ...) Error {	319	fn errorIllegalChar(self: *Tokenizer, position: usize, char: u8, comptime fmt: []const u8, args: var) Error {
320	var buffer = try std.Buffer.initSize(&self.arena.allocator, 0);	320	var buffer = try std.Buffer.initSize(&self.arena.allocator, 0);
321	try buffer.append("illegal char ");	321	try buffer.append("illegal char ");
322	var out = makeOutput(std.Buffer.append, &buffer);	322	var out = makeOutput(std.Buffer.append, &buffer);
323	try printUnderstandableChar(&out, char);	323	try printUnderstandableChar(&out, char);
324	std.fmt.format(&buffer, anyerror, std.Buffer.append, " at position {}", position) catch {};	324	std.fmt.format(&buffer, anyerror, std.Buffer.append, " at position {}", .{position}) catch {};
325	if (fmt.len != 0) std.fmt.format(&buffer, anyerror, std.Buffer.append, ": " ++ fmt, args) catch {};	325	if (fmt.len != 0) std.fmt.format(&buffer, anyerror, std.Buffer.append, ": " ++ fmt, args) catch {};
326	self.error_text = buffer.toSlice();	326	self.error_text = buffer.toSlice();
327	return Error.InvalidInput;	327	return Error.InvalidInput;
...	@@ -998,7 +998,7 @@ fn printCharValues(out: var, bytes: []const u8) !void {	...	@@ -998,7 +998,7 @@ fn printCharValues(out: var, bytes: []const u8) !void {
998		998
999	fn printUnderstandableChar(out: var, char: u8) !void {	999	fn printUnderstandableChar(out: var, char: u8) !void {
1000	if (!std.ascii.isPrint(char) or char == ' ') {	1000	if (!std.ascii.isPrint(char) or char == ' ') {
1001	std.fmt.format(out.context, anyerror, out.output, "\\x{X:2}", char) catch {};	1001	std.fmt.format(out.context, anyerror, out.output, "\\x{X:2}", .{char}) catch {};
1002	} else {	1002	} else {
1003	try out.write("'");	1003	try out.write("'");
1004	try out.write(&[_]u8{printable_char_tab[char]});	1004	try out.write(&[_]u8{printable_char_tab[char]});

...	@@ -32,16 +32,16 @@ pub const IrVal = union(enum) {	...	@@ -32,16 +32,16 @@ pub const IrVal = union(enum) {
32		32
33	pub fn dump(self: IrVal) void {	33	pub fn dump(self: IrVal) void {
34	switch (self) {	34	switch (self) {
35	.Unknown => std.debug.warn("Unknown"),	35	.Unknown => std.debug.warn("Unknown", .{}),
36	.KnownType => \|typ\| {	36	.KnownType => \|typ\| {
37	std.debug.warn("KnownType(");	37	std.debug.warn("KnownType(", .{});
38	typ.dump();	38	typ.dump();
39	std.debug.warn(")");	39	std.debug.warn(")", .{});
40	},	40	},
41	.KnownValue => \|value\| {	41	.KnownValue => \|value\| {
42	std.debug.warn("KnownValue(");	42	std.debug.warn("KnownValue(", .{});
43	value.dump();	43	value.dump();
44	std.debug.warn(")");	44	std.debug.warn(")", .{});
45	},	45	},
46	}	46	}
47	}	47	}
...	@@ -90,9 +90,9 @@ pub const Inst = struct {	...	@@ -90,9 +90,9 @@ pub const Inst = struct {
90	inline while (i < @memberCount(Id)) : (i += 1) {	90	inline while (i < @memberCount(Id)) : (i += 1) {
91	if (base.id == @field(Id, @memberName(Id, i))) {	91	if (base.id == @field(Id, @memberName(Id, i))) {
92	const T = @field(Inst, @memberName(Id, i));	92	const T = @field(Inst, @memberName(Id, i));
93	std.debug.warn("#{} = {}(", base.debug_id, @tagName(base.id));	93	std.debug.warn("#{} = {}(", .{ base.debug_id, @tagName(base.id) });
94	@fieldParentPtr(T, "base", base).dump();	94	@fieldParentPtr(T, "base", base).dump();
95	std.debug.warn(")");	95	std.debug.warn(")", .{});
96	return;	96	return;
97	}	97	}
98	}	98	}
...	@@ -173,7 +173,7 @@ pub const Inst = struct {	...	@@ -173,7 +173,7 @@ pub const Inst = struct {
173	if (self.isCompTime()) {	173	if (self.isCompTime()) {
174	return self.val.KnownValue;	174	return self.val.KnownValue;
175	} else {	175	} else {
176	try ira.addCompileError(self.span, "unable to evaluate constant expression");	176	try ira.addCompileError(self.span, "unable to evaluate constant expression", .{});
177	return error.SemanticAnalysisFailed;	177	return error.SemanticAnalysisFailed;
178	}	178	}
179	}	179	}
...	@@ -269,11 +269,11 @@ pub const Inst = struct {	...	@@ -269,11 +269,11 @@ pub const Inst = struct {
269	const ir_val_init = IrVal.Init.Unknown;	269	const ir_val_init = IrVal.Init.Unknown;
270		270
271	pub fn dump(self: *const Call) void {	271	pub fn dump(self: *const Call) void {
272	std.debug.warn("#{}(", self.params.fn_ref.debug_id);	272	std.debug.warn("#{}(", .{self.params.fn_ref.debug_id});
273	for (self.params.args) \|arg\| {	273	for (self.params.args) \|arg\| {
274	std.debug.warn("#{},", arg.debug_id);	274	std.debug.warn("#{},", .{arg.debug_id});
275	}	275	}
276	std.debug.warn(")");	276	std.debug.warn(")", .{});
277	}	277	}
278		278
279	pub fn hasSideEffects(self: *const Call) bool {	279	pub fn hasSideEffects(self: *const Call) bool {
...	@@ -284,19 +284,17 @@ pub const Inst = struct {	...	@@ -284,19 +284,17 @@ pub const Inst = struct {
284	const fn_ref = try self.params.fn_ref.getAsParam();	284	const fn_ref = try self.params.fn_ref.getAsParam();
285	const fn_ref_type = fn_ref.getKnownType();	285	const fn_ref_type = fn_ref.getKnownType();
286	const fn_type = fn_ref_type.cast(Type.Fn) orelse {	286	const fn_type = fn_ref_type.cast(Type.Fn) orelse {
287	try ira.addCompileError(fn_ref.span, "type '{}' not a function", fn_ref_type.name);	287	try ira.addCompileError(fn_ref.span, "type '{}' not a function", .{fn_ref_type.name});
288	return error.SemanticAnalysisFailed;	288	return error.SemanticAnalysisFailed;
289	};	289	};
290		290
291	const fn_type_param_count = fn_type.paramCount();	291	const fn_type_param_count = fn_type.paramCount();
292		292
293	if (fn_type_param_count != self.params.args.len) {	293	if (fn_type_param_count != self.params.args.len) {
294	try ira.addCompileError(	294	try ira.addCompileError(self.base.span, "expected {} arguments, found {}", .{
295	self.base.span,
296	"expected {} arguments, found {}",
297	fn_type_param_count,	295	fn_type_param_count,
298	self.params.args.len,	296	self.params.args.len,
299	);	297	});
300	return error.SemanticAnalysisFailed;	298	return error.SemanticAnalysisFailed;
301	}	299	}
302		300
...	@@ -375,7 +373,7 @@ pub const Inst = struct {	...	@@ -375,7 +373,7 @@ pub const Inst = struct {
375	const ir_val_init = IrVal.Init.NoReturn;	373	const ir_val_init = IrVal.Init.NoReturn;
376		374
377	pub fn dump(self: *const Return) void {	375	pub fn dump(self: *const Return) void {
378	std.debug.warn("#{}", self.params.return_value.debug_id);	376	std.debug.warn("#{}", .{self.params.return_value.debug_id});
379	}	377	}
380		378
381	pub fn hasSideEffects(self: *const Return) bool {	379	pub fn hasSideEffects(self: *const Return) bool {
...	@@ -509,7 +507,7 @@ pub const Inst = struct {	...	@@ -509,7 +507,7 @@ pub const Inst = struct {
509	const ir_val_init = IrVal.Init.Unknown;	507	const ir_val_init = IrVal.Init.Unknown;
510		508
511	pub fn dump(inst: *const VarPtr) void {	509	pub fn dump(inst: *const VarPtr) void {
512	std.debug.warn("{}", inst.params.var_scope.name);	510	std.debug.warn("{}", .{inst.params.var_scope.name});
513	}	511	}
514		512
515	pub fn hasSideEffects(inst: *const VarPtr) bool {	513	pub fn hasSideEffects(inst: *const VarPtr) bool {
...	@@ -567,7 +565,7 @@ pub const Inst = struct {	...	@@ -567,7 +565,7 @@ pub const Inst = struct {
567	const target = try self.params.target.getAsParam();	565	const target = try self.params.target.getAsParam();
568	const target_type = target.getKnownType();	566	const target_type = target.getKnownType();
569	if (target_type.id != .Pointer) {	567	if (target_type.id != .Pointer) {
570	try ira.addCompileError(self.base.span, "dereference of non pointer type '{}'", target_type.name);	568	try ira.addCompileError(self.base.span, "dereference of non pointer type '{}'", .{target_type.name});
571	return error.SemanticAnalysisFailed;	569	return error.SemanticAnalysisFailed;
572	}	570	}
573	const ptr_type = @fieldParentPtr(Type.Pointer, "base", target_type);	571	const ptr_type = @fieldParentPtr(Type.Pointer, "base", target_type);
...	@@ -705,7 +703,7 @@ pub const Inst = struct {	...	@@ -705,7 +703,7 @@ pub const Inst = struct {
705	const ir_val_init = IrVal.Init.Unknown;	703	const ir_val_init = IrVal.Init.Unknown;
706		704
707	pub fn dump(self: *const CheckVoidStmt) void {	705	pub fn dump(self: *const CheckVoidStmt) void {
708	std.debug.warn("#{}", self.params.target.debug_id);	706	std.debug.warn("#{}", .{self.params.target.debug_id});
709	}	707	}
710		708
711	pub fn hasSideEffects(inst: *const CheckVoidStmt) bool {	709	pub fn hasSideEffects(inst: *const CheckVoidStmt) bool {
...	@@ -715,7 +713,7 @@ pub const Inst = struct {	...	@@ -715,7 +713,7 @@ pub const Inst = struct {
715	pub fn analyze(self: const CheckVoidStmt, ira: Analyze) !*Inst {	713	pub fn analyze(self: const CheckVoidStmt, ira: Analyze) !*Inst {
716	const target = try self.params.target.getAsParam();	714	const target = try self.params.target.getAsParam();
717	if (target.getKnownType().id != .Void) {	715	if (target.getKnownType().id != .Void) {
718	try ira.addCompileError(self.base.span, "expression value is ignored");	716	try ira.addCompileError(self.base.span, "expression value is ignored", .{});
719	return error.SemanticAnalysisFailed;	717	return error.SemanticAnalysisFailed;
720	}	718	}
721	return ira.irb.buildConstVoid(self.base.scope, self.base.span, true);	719	return ira.irb.buildConstVoid(self.base.scope, self.base.span, true);
...	@@ -801,7 +799,7 @@ pub const Inst = struct {	...	@@ -801,7 +799,7 @@ pub const Inst = struct {
801	const ir_val_init = IrVal.Init.Unknown;	799	const ir_val_init = IrVal.Init.Unknown;
802		800
803	pub fn dump(inst: *const AddImplicitReturnType) void {	801	pub fn dump(inst: *const AddImplicitReturnType) void {
804	std.debug.warn("#{}", inst.params.target.debug_id);	802	std.debug.warn("#{}", .{inst.params.target.debug_id});
805	}	803	}
806		804
807	pub fn hasSideEffects(inst: *const AddImplicitReturnType) bool {	805	pub fn hasSideEffects(inst: *const AddImplicitReturnType) bool {
...	@@ -826,7 +824,7 @@ pub const Inst = struct {	...	@@ -826,7 +824,7 @@ pub const Inst = struct {
826	const ir_val_init = IrVal.Init.Unknown;	824	const ir_val_init = IrVal.Init.Unknown;
827		825
828	pub fn dump(inst: *const TestErr) void {	826	pub fn dump(inst: *const TestErr) void {
829	std.debug.warn("#{}", inst.params.target.debug_id);	827	std.debug.warn("#{}", .{inst.params.target.debug_id});
830	}	828	}
831		829
832	pub fn hasSideEffects(inst: *const TestErr) bool {	830	pub fn hasSideEffects(inst: *const TestErr) bool {
...	@@ -888,7 +886,7 @@ pub const Inst = struct {	...	@@ -888,7 +886,7 @@ pub const Inst = struct {
888	const ir_val_init = IrVal.Init.Unknown;	886	const ir_val_init = IrVal.Init.Unknown;
889		887
890	pub fn dump(inst: *const TestCompTime) void {	888	pub fn dump(inst: *const TestCompTime) void {
891	std.debug.warn("#{}", inst.params.target.debug_id);	889	std.debug.warn("#{}", .{inst.params.target.debug_id});
892	}	890	}
893		891
894	pub fn hasSideEffects(inst: *const TestCompTime) bool {	892	pub fn hasSideEffects(inst: *const TestCompTime) bool {
...	@@ -971,11 +969,11 @@ pub const Code = struct {	...	@@ -971,11 +969,11 @@ pub const Code = struct {
971	pub fn dump(self: *Code) void {	969	pub fn dump(self: *Code) void {
972	var bb_i: usize = 0;	970	var bb_i: usize = 0;
973	for (self.basic_block_list.toSliceConst()) \|bb\| {	971	for (self.basic_block_list.toSliceConst()) \|bb\| {
974	std.debug.warn("{s}_{}:\n", bb.name_hint, bb.debug_id);	972	std.debug.warn("{s}_{}:\n", .{ bb.name_hint, bb.debug_id });
975	for (bb.instruction_list.toSliceConst()) \|instr\| {	973	for (bb.instruction_list.toSliceConst()) \|instr\| {
976	std.debug.warn(" ");	974	std.debug.warn(" ", .{});
977	instr.dump();	975	instr.dump();
978	std.debug.warn("\n");	976	std.debug.warn("\n", .{});
979	}	977	}
980	}	978	}
981	}	979	}
...	@@ -993,6 +991,7 @@ pub const Code = struct {	...	@@ -993,6 +991,7 @@ pub const Code = struct {
993	self.tree_scope,	991	self.tree_scope,
994	ret_value.span,	992	ret_value.span,
995	"unable to evaluate constant expression",	993	"unable to evaluate constant expression",
		994	.{},
996	);	995	);
997	return error.SemanticAnalysisFailed;	996	return error.SemanticAnalysisFailed;
998	} else if (inst.hasSideEffects()) {	997	} else if (inst.hasSideEffects()) {
...	@@ -1000,6 +999,7 @@ pub const Code = struct {	...	@@ -1000,6 +999,7 @@ pub const Code = struct {
1000	self.tree_scope,	999	self.tree_scope,
1001	inst.span,	1000	inst.span,
1002	"unable to evaluate constant expression",	1001	"unable to evaluate constant expression",
		1002	.{},
1003	);	1003	);
1004	return error.SemanticAnalysisFailed;	1004	return error.SemanticAnalysisFailed;
1005	}	1005	}
...	@@ -1359,7 +1359,7 @@ pub const Builder = struct {	...	@@ -1359,7 +1359,7 @@ pub const Builder = struct {
1359	irb.code.tree_scope,	1359	irb.code.tree_scope,
1360	src_span,	1360	src_span,
1361	"invalid character in string literal: '{c}'",	1361	"invalid character in string literal: '{c}'",
1362	str_token[bad_index],	1362	.{str_token[bad_index]},
1363	);	1363	);
1364	return error.SemanticAnalysisFailed;	1364	return error.SemanticAnalysisFailed;
1365	},	1365	},
...	@@ -1523,6 +1523,7 @@ pub const Builder = struct {	...	@@ -1523,6 +1523,7 @@ pub const Builder = struct {
1523	irb.code.tree_scope,	1523	irb.code.tree_scope,
1524	src_span,	1524	src_span,
1525	"return expression outside function definition",	1525	"return expression outside function definition",
		1526	.{},
1526	);	1527	);
1527	return error.SemanticAnalysisFailed;	1528	return error.SemanticAnalysisFailed;
1528	}	1529	}
...	@@ -1533,6 +1534,7 @@ pub const Builder = struct {	...	@@ -1533,6 +1534,7 @@ pub const Builder = struct {
1533	irb.code.tree_scope,	1534	irb.code.tree_scope,
1534	src_span,	1535	src_span,
1535	"cannot return from defer expression",	1536	"cannot return from defer expression",
		1537	.{},
1536	);	1538	);
1537	scope_defer_expr.reported_err = true;	1539	scope_defer_expr.reported_err = true;
1538	}	1540	}
...	@@ -1629,7 +1631,7 @@ pub const Builder = struct {	...	@@ -1629,7 +1631,7 @@ pub const Builder = struct {
1629	}	1631	}
1630	} else \|err\| switch (err) {	1632	} else \|err\| switch (err) {
1631	error.Overflow => {	1633	error.Overflow => {
1632	try irb.comp.addCompileError(irb.code.tree_scope, src_span, "integer too large");	1634	try irb.comp.addCompileError(irb.code.tree_scope, src_span, "integer too large", .{});
1633	return error.SemanticAnalysisFailed;	1635	return error.SemanticAnalysisFailed;
1634	},	1636	},
1635	error.OutOfMemory => return error.OutOfMemory,	1637	error.OutOfMemory => return error.OutOfMemory,
...	@@ -1663,7 +1665,7 @@ pub const Builder = struct {	...	@@ -1663,7 +1665,7 @@ pub const Builder = struct {
1663	// TODO put a variable of same name with invalid type in global scope	1665	// TODO put a variable of same name with invalid type in global scope
1664	// so that future references to this same name will find a variable with an invalid type	1666	// so that future references to this same name will find a variable with an invalid type
1665		1667
1666	try irb.comp.addCompileError(irb.code.tree_scope, src_span, "unknown identifier '{}'", name);	1668	try irb.comp.addCompileError(irb.code.tree_scope, src_span, "unknown identifier '{}'", .{name});
1667	return error.SemanticAnalysisFailed;	1669	return error.SemanticAnalysisFailed;
1668	}	1670	}
1669		1671
...	@@ -2008,7 +2010,7 @@ const Analyze = struct {	...	@@ -2008,7 +2010,7 @@ const Analyze = struct {
2008	const next_instruction = ira.parent_basic_block.instruction_list.at(ira.instruction_index);	2010	const next_instruction = ira.parent_basic_block.instruction_list.at(ira.instruction_index);
2009		2011
2010	if (!next_instruction.is_generated) {	2012	if (!next_instruction.is_generated) {
2011	try ira.addCompileError(next_instruction.span, "unreachable code");	2013	try ira.addCompileError(next_instruction.span, "unreachable code", .{});
2012	break;	2014	break;
2013	}	2015	}
2014	ira.instruction_index += 1;	2016	ira.instruction_index += 1;
...	@@ -2041,7 +2043,7 @@ const Analyze = struct {	...	@@ -2041,7 +2043,7 @@ const Analyze = struct {
2041	}	2043	}
2042	}	2044	}
2043		2045
2044	fn addCompileError(self: *Analyze, span: Span, comptime fmt: []const u8, args: ...) !void {	2046	fn addCompileError(self: *Analyze, span: Span, comptime fmt: []const u8, args: var) !void {
2045	return self.irb.comp.addCompileError(self.irb.code.tree_scope, span, fmt, args);	2047	return self.irb.comp.addCompileError(self.irb.code.tree_scope, span, fmt, args);
2046	}	2048	}
2047		2049
...	@@ -2330,12 +2332,10 @@ const Analyze = struct {	...	@@ -2330,12 +2332,10 @@ const Analyze = struct {
2330	break :cast;	2332	break :cast;
2331	};	2333	};
2332	if (!fits) {	2334	if (!fits) {
2333	try ira.addCompileError(	2335	try ira.addCompileError(source_instr.span, "integer value '{}' cannot be stored in type '{}'", .{
2334	source_instr.span,
2335	"integer value '{}' cannot be stored in type '{}'",
2336	from_int,	2336	from_int,
2337	dest_type.name,	2337	dest_type.name,
2338	);	2338	});
2339	return error.SemanticAnalysisFailed;	2339	return error.SemanticAnalysisFailed;
2340	}	2340	}
2341		2341
...	@@ -2498,12 +2498,10 @@ const Analyze = struct {	...	@@ -2498,12 +2498,10 @@ const Analyze = struct {
2498	// }	2498	// }
2499	//}	2499	//}
2500		2500
2501	try ira.addCompileError(	2501	try ira.addCompileError(source_instr.span, "expected type '{}', found '{}'", .{
2502	source_instr.span,
2503	"expected type '{}', found '{}'",
2504	dest_type.name,	2502	dest_type.name,
2505	from_type.name,	2503	from_type.name,
2506	);	2504	});
2507	//ErrorMsg *parent_msg = ir_add_error_node(ira, source_instr->source_node,	2505	//ErrorMsg *parent_msg = ir_add_error_node(ira, source_instr->source_node,
2508	// buf_sprintf("expected type '%s', found '%s'",	2506	// buf_sprintf("expected type '%s', found '%s'",
2509	// buf_ptr(&wanted_type->name),	2507	// buf_ptr(&wanted_type->name),

Merge pull request #3873 from ziglang/format-no-var-args