Zig 0.10.0

Makefile

@@ -64,6 +64,7 @@ WEBKIT_RELEASE_DIR_LTO ?= $(WEBKIT_DIR)/WebKitBuild/ReleaseLTO
 
 NPM_CLIENT ?= $(shell which bun || which npm)
 ZIG ?= $(shell which zig || echo -e "error: Missing zig. Please make sure zig is in PATH. Or set ZIG=/path/to-zig-executable")
+ZIG_FLAGS ?= "-fstage1"
 
 # We must use the same compiler version for the JavaScriptCore bindings and JavaScriptCore
 # If we don't do this, strange memory allocation failures occur.
@@ -377,7 +378,7 @@ endif
 SHARED_LIB_EXTENSION = .so
 
 JSC_BINDINGS = $(BINDINGS_OBJ) $(JSC_FILES)
-JSC_BINDINGS_DEBUG = $(DEBUG_BINDINGS_OBJ) $(JSC_FILES_DEBUG) 
+JSC_BINDINGS_DEBUG = $(DEBUG_BINDINGS_OBJ) $(JSC_FILES_DEBUG)
 
 RELEASE_FLAGS=
 DEBUG_FLAGS=
@@ -405,7 +406,7 @@ ARCHIVE_FILES_WITHOUT_LIBCRYPTO = $(MINIMUM_ARCHIVE_FILES) \
 		-lusockets \
 		$(BUN_DEPS_OUT_DIR)/libuwsockets.o
 
-ARCHIVE_FILES = $(ARCHIVE_FILES_WITHOUT_LIBCRYPTO) 
+ARCHIVE_FILES = $(ARCHIVE_FILES_WITHOUT_LIBCRYPTO)
 
 STATIC_MUSL_FLAG ?=
 
@@ -426,9 +427,9 @@ PLATFORM_LINKER_FLAGS = $(BUN_CFLAGS) \
 		-flto \
 		-Wl,--allow-multiple-definition \
 		-rdynamic
-
 
-
+
+
 endif
 
 
@@ -870,7 +871,7 @@ CLANG_FORMAT := $(shell command -v clang-format 2> /dev/null)
 headers:
 	rm -f /tmp/build-jsc-headers src/bun.js/bindings/headers.zig
 	touch src/bun.js/bindings/headers.zig
-	$(ZIG) build headers-obj
+	$(ZIG) build headers-obj $(ZIG_FLAGS)
 	$(CXX) $(PLATFORM_LINKER_FLAGS) $(JSC_FILES_DEBUG) ${ICU_FLAGS} $(DEBUG_IO_FILES) $(BUN_LLD_FLAGS_WITHOUT_JSC)  -g $(DEBUG_BIN)/headers.o -W -o /tmp/build-jsc-headers -lc;
 	/tmp/build-jsc-headers
 	$(ZIG) translate-c src/bun.js/bindings/headers.h > src/bun.js/bindings/headers.zig
@@ -1681,7 +1682,7 @@ webcrypto:
 
 sizegen:
 	mkdir -p $(BUN_TMP_DIR)
-	$(CXX) src/bun.js/headergen/sizegen.cpp -Wl,-dead_strip -Wl,-dead_strip_dylibs -fuse-ld=lld -o $(BUN_TMP_DIR)/sizegen $(CLANG_FLAGS) -O1 
+	$(CXX) src/bun.js/headergen/sizegen.cpp -Wl,-dead_strip -Wl,-dead_strip_dylibs -fuse-ld=lld -o $(BUN_TMP_DIR)/sizegen $(CLANG_FLAGS) -O1
 	$(BUN_TMP_DIR)/sizegen > src/bun.js/bindings/sizes.zig
 
 

build.zig

@@ -6,13 +6,13 @@ fn pkgPath(comptime out: []const u8) std.build.FileSource {
     return .{ .path = outpath };
 }
 pub fn addPicoHTTP(step: *std.build.LibExeObjStep, comptime with_obj: bool) void {
-    step.addIncludeDir("src/deps");
+    step.addIncludePath("src/deps");
 
     if (with_obj) {
         step.addObjectFile("src/deps/picohttpparser.o");
     }
 
-    step.addIncludeDir("src/deps");
+    step.addIncludePath("src/deps");
 
     if (with_obj) {
         step.addObjectFile(panicIfNotFound("src/deps/picohttpparser.o"));
@@ -187,7 +187,7 @@ const BunBuildOptions = struct {
 var output_dir: []const u8 = "";
 fn panicIfNotFound(comptime filepath: []const u8) []const u8 {
     var file = std.fs.cwd().openFile(filepath, .{ .mode = .read_only }) catch |err| {
-        std.debug.panic("error: {s} opening {s}. Please ensure you've downloaded git submodules, and ran `make vendor`, `make jsc`.", .{ filepath, @errorName(err) });
+        std.debug.panic("error: {any} opening {any}. Please ensure you've downloaded git submodules, and ran `make vendor`, `make jsc`.", .{ filepath, @errorName(err) });
     };
     file.close();
 
@@ -274,7 +274,7 @@ pub fn build(b: *std.build.Builder) !void {
     if (std.os.getenv("OUTPUT_DIR")) |output_dir_| {
         output_dir = output_dir_;
     } else {
-        const output_dir_base = try std.fmt.bufPrint(&output_dir_buf, "{s}{s}", .{ bin_label, triplet });
+        const output_dir_base = try std.fmt.bufPrint(&output_dir_buf, "{any}{any}", .{ bin_label, triplet });
         output_dir = b.pathFromRoot(output_dir_base);
     }
 
@@ -304,9 +304,9 @@ pub fn build(b: *std.build.Builder) !void {
     else .{ .major = 0, .minor = 0, .patch = 0 };
 
     // exe.want_lto = true;
-    defer b.default_step.dependOn(&b.addLog("Output: {s}/{s}\n", .{ output_dir, bun_executable_name }).step);
+    defer b.default_step.dependOn(&b.addLog("Output: {any}/{any}\n", .{ output_dir, bun_executable_name }).step);
     defer b.default_step.dependOn(&b.addLog(
-        "Build {s} v{} - v{}\n",
+        "Build {any} v{} - v{}\n",
         .{
             triplet,
             min_version,
@@ -377,7 +377,7 @@ pub fn build(b: *std.build.Builder) !void {
 
         {
             obj_step.dependOn(&b.addLog(
-                "Build {s} v{} - v{} ({s})\n",
+                "Build {any} v{} - v{} ({any})\n",
                 .{
                     triplet,
                     min_version,
@@ -415,7 +415,7 @@ pub fn build(b: *std.build.Builder) !void {
             obj.link_function_sections = true;
         }
 
-        var log_step = b.addLog("Destination: {s}/{s}\n", .{ output_dir, bun_executable_name });
+        var log_step = b.addLog("Destination: {any}/{any}\n", .{ output_dir, bun_executable_name });
         log_step.step.dependOn(&obj.step);
     }
 
@@ -515,7 +515,7 @@ pub fn build(b: *std.build.Builder) !void {
         try linkObjectFiles(b, headers_obj, target);
 
         {
-            var before = b.addLog("\x1b[" ++ color_map.get("magenta").? ++ "\x1b[" ++ color_map.get("b").? ++ "[{s} tests]" ++ "\x1b[" ++ color_map.get("d").? ++ " ----\n\n" ++ "\x1b[0m", .{"bun"});
+            var before = b.addLog("\x1b[" ++ color_map.get("magenta").? ++ "\x1b[" ++ color_map.get("b").? ++ "[{any} tests]" ++ "\x1b[" ++ color_map.get("d").? ++ " ----\n\n" ++ "\x1b[0m", .{"bun"});
             var after = b.addLog("\x1b[" ++ color_map.get("d").? ++ "–––---\n\n" ++ "\x1b[0m", .{});
             headers_step.dependOn(&before.step);
             headers_step.dependOn(&headers_obj.step);
@@ -539,7 +539,7 @@ pub fn build(b: *std.build.Builder) !void {
                 try test_.packages.appendSlice(children);
             }
 
-            var before = b.addLog("\x1b[" ++ color_map.get("magenta").? ++ "\x1b[" ++ color_map.get("b").? ++ "[{s} tests]" ++ "\x1b[" ++ color_map.get("d").? ++ " ----\n\n" ++ "\x1b[0m", .{pkg.name});
+            var before = b.addLog("\x1b[" ++ color_map.get("magenta").? ++ "\x1b[" ++ color_map.get("b").? ++ "[{any} tests]" ++ "\x1b[" ++ color_map.get("d").? ++ " ----\n\n" ++ "\x1b[0m", .{pkg.name});
             var after = b.addLog("\x1b[" ++ color_map.get("d").? ++ "–––---\n\n" ++ "\x1b[0m", .{});
             headers_step.dependOn(&before.step);
             headers_step.dependOn(&test_.step);
@@ -593,13 +593,13 @@ pub fn linkObjectFiles(b: *std.build.Builder, obj: *std.build.LibExeObjStep, tar
     });
 
     for (dirs_to_search.slice()) |deps_path| {
-        var deps_dir = std.fs.cwd().openDir(deps_path, .{ .iterate = true }) catch continue;
+        var deps_dir = std.fs.cwd().openIterableDir(deps_path, .{}) catch continue;
         var iterator = deps_dir.iterate();
-        obj.addIncludeDir(deps_path);
-        obj.addLibPath(deps_path);
+        obj.addIncludePath(deps_path);
+        obj.addLibraryPath(deps_path);
 
         while (iterator.next() catch null) |entr| {
-            const entry: std.fs.Dir.Entry = entr;
+            const entry: std.fs.IterableDir.Entry = entr;
             if (files_we_care_about.get(entry.name)) |obj_name| {
                 var has_added = try added.getOrPut(std.hash.Wyhash.hash(0, obj_name));
                 if (!has_added.found_existing) {

misctools/fetch.zig

@@ -114,12 +114,12 @@ pub const Arguments = struct {
                 var absolute_path_ = file_path_buf[0..absolute_path_len :0];
 
                 var body_file = std.fs.openFileAbsoluteZ(absolute_path_, .{ .mode = .read_only }) catch |err| {
-                    Output.printErrorln("<r><red>{s}<r> opening file {s}", .{ @errorName(err), absolute_path });
+                    Output.printErrorln("<r><red>{any}<r> opening file {any}", .{ @errorName(err), absolute_path });
                     Global.exit(1);
                 };
 
                 var file_contents = body_file.readToEndAlloc(allocator, try body_file.getEndPos()) catch |err| {
-                    Output.printErrorln("<r><red>{s}<r> reading file {s}", .{ @errorName(err), absolute_path });
+                    Output.printErrorln("<r><red>{any}<r> reading file {any}", .{ @errorName(err), absolute_path });
                     Global.exit(1);
                 };
                 body_string = file_contents;

misctools/http_bench.zig

@@ -120,12 +120,12 @@ pub const Arguments = struct {
                 var absolute_path_ = file_path_buf[0..absolute_path_len :0];
 
                 var body_file = std.fs.openFileAbsoluteZ(absolute_path_, .{ .mode = .read_only }) catch |err| {
-                    Output.printErrorln("<r><red>{s}<r> opening file {s}", .{ @errorName(err), absolute_path });
+                    Output.printErrorln("<r><red>{any}<r> opening file {any}", .{ @errorName(err), absolute_path });
                     Global.exit(1);
                 };
 
                 var file_contents = body_file.readToEndAlloc(allocator, try body_file.getEndPos()) catch |err| {
-                    Output.printErrorln("<r><red>{s}<r> reading file {s}", .{ @errorName(err), absolute_path });
+                    Output.printErrorln("<r><red>{any}<r> reading file {any}", .{ @errorName(err), absolute_path });
                     Global.exit(1);
                 };
                 body_string = file_contents;
@@ -166,11 +166,11 @@ pub const Arguments = struct {
             .concurrency = std.fmt.parseInt(u16, args.option("--max-concurrency") orelse "32", 10) catch 32,
             .turbo = args.flag("--turbo"),
             .timeout = std.fmt.parseInt(usize, args.option("--timeout") orelse "0", 10) catch |err| {
-                Output.prettyErrorln("<r><red>{s}<r> parsing timeout", .{@errorName(err)});
+                Output.prettyErrorln("<r><red>{any}<r> parsing timeout", .{@errorName(err)});
                 Global.exit(1);
             },
             .count = std.fmt.parseInt(usize, args.option("--count") orelse "10", 10) catch |err| {
-                Output.prettyErrorln("<r><red>{s}<r> parsing count", .{@errorName(err)});
+                Output.prettyErrorln("<r><red>{any}<r> parsing count", .{@errorName(err)});
                 Global.exit(1);
             },
         };
@@ -252,8 +252,8 @@ pub fn main() anyerror!void {
                     fail_count += 1;
                 }
 
-                max_duration = @maximum(max_duration, http.elapsed);
-                min_duration = @minimum(min_duration, http.elapsed);
+                max_duration = @max(max_duration, http.elapsed);
+                min_duration = @min(min_duration, http.elapsed);
 
                 switch (resp.status_code) {
                     200, 202, 302 => {
@@ -265,26 +265,26 @@ pub fn main() anyerror!void {
                 }
 
                 if (http.gzip_elapsed > 0) {
-                    Output.prettyError(" <d>{s}<r><d> - {s}<r> <d>({d} bytes, ", .{
+                    Output.prettyError(" <d>{any}<r><d> - {any}<r> <d>({d} bytes, ", .{
                         @tagName(http.client.method),
                         http.client.url.href,
                         http.response_buffer.list.items.len,
                     });
                     Output.printElapsed(@floatCast(f64, @intToFloat(f128, http.gzip_elapsed) / std.time.ns_per_ms));
                     Output.prettyError("<d> gzip)<r>\n", .{});
                 } else {
-                    Output.prettyError(" <d>{s}<r><d> - {s}<r> <d>({d} bytes)<r>\n", .{
+                    Output.prettyError(" <d>{any}<r><d> - {any}<r> <d>({d} bytes)<r>\n", .{
                         @tagName(http.client.method),
                         http.client.url.href,
                         http.response_buffer.list.items.len,
                     });
                 }
             } else if (http.err) |err| {
                 fail_count += 1;
-                Output.printError(" err: {s}\n", .{@errorName(err)});
+                Output.printError(" err: {any}\n", .{@errorName(err)});
             } else {
                 fail_count += 1;
-                Output.prettyError(" Uh-oh: {s}\n", .{@tagName(http.state.loadUnchecked())});
+                Output.prettyError(" Uh-oh: {any}\n", .{@tagName(http.state.loadUnchecked())});
             }
 
             Output.flush();

misctools/readlink-getfd.zig

@@ -49,7 +49,7 @@ pub fn main() anyerror!void {
         var file = std.os.openZ(joined_z, O_PATH | std.os.O.CLOEXEC, 0) catch |err| {
             switch (err) {
                 error.NotDir, error.FileNotFound => {
-                    Output.prettyError("<r><red>404 Not Found<r>: <b>\"{s}\"<r>", .{joined_z});
+                    Output.prettyError("<r><red>404 Not Found<r>: <b>\"{any}\"<r>", .{joined_z});
                     Global.exit(1);
                 },
                 else => {
@@ -62,5 +62,5 @@ pub fn main() anyerror!void {
         file.close();
     }
 
-    Output.print("{s}", .{path});
+    Output.print("{any}", .{path});
 }

misctools/readlink-realpath.zig

@@ -35,5 +35,5 @@ pub fn main() anyerror!void {
         path = try std.os.realpathZ(to_resolve, &out_buffer);
     }
 
-    Output.print("{s}", .{path});
+    Output.print("{any}", .{path});
 }

misctools/tgz.zig

@@ -48,7 +48,7 @@ pub fn main() anyerror!void {
     };
 
     const tarball_path = path_handler.joinAbsStringBuf(try std.process.getCwdAlloc(std.heap.c_allocator), &tarball_path_buf, &parts, .auto);
-    Output.prettyErrorln("Tarball Path: {s}", .{tarball_path});
+    Output.prettyErrorln("Tarball Path: {any}", .{tarball_path});
     var folder = basename;
 
     // var dir = try std.fs.cwd().makeOpenPath(folder, .{ .iterate = true });

src/__global.zig

@@ -16,9 +16,9 @@ else
 pub const package_json_version_with_sha = if (Environment.git_sha.len == 0)
     package_json_version
 else if (Environment.isDebug)
-    std.fmt.comptimePrint(BASE_VERSION ++ ".{d}_debug ({s})", .{ build_id, Environment.git_sha[0..@minimum(Environment.git_sha.len, 8)] })
+    std.fmt.comptimePrint(BASE_VERSION ++ ".{d}_debug ({s})", .{ build_id, Environment.git_sha[0..@min(Environment.git_sha.len, 8)] })
 else
-    std.fmt.comptimePrint(BASE_VERSION ++ ".{d} ({s})", .{ build_id, Environment.git_sha[0..@minimum(Environment.git_sha.len, 8)] });
+    std.fmt.comptimePrint(BASE_VERSION ++ ".{d} ({s})", .{ build_id, Environment.git_sha[0..@min(Environment.git_sha.len, 8)] });
 
 pub const os_name = if (Environment.isWindows)
     "win32"

src/analytics/analytics_schema.zig

@@ -17,7 +17,7 @@ pub const Reader = struct {
     }
 
     pub fn read(this: *Self, count: usize) ![]u8 {
-        const read_count = @minimum(count, this.remain.len);
+        const read_count = @min(count, this.remain.len);
         if (read_count < count) {
             return error.EOF;
         }

src/api/demo/schema.zig

@@ -17,7 +17,7 @@ pub const Reader = struct {
     }
 
     pub fn read(this: *Self, count: usize) ![]u8 {
-        const read_count = @minimum(count, this.remain.len);
+        const read_count = @min(count, this.remain.len);
         if (read_count < count) {
             return error.EOF;
         }

src/api/schema.zig

@@ -17,7 +17,7 @@ pub const Reader = struct {
     }
 
     pub fn read(this: *Self, count: usize) ![]u8 {
-        const read_count = @minimum(count, this.remain.len);
+        const read_count = @min(count, this.remain.len);
         if (read_count < count) {
             return error.EOF;
         }

src/baby_list.zig

@@ -166,7 +166,7 @@ const bun = @import("./global.zig");
 
 //     pub fn writeLatin1(this: *Delayer, list_: BabyList(u8), str: []const u8, allocator: std.mem.Allocator) !BabyList(u8) {
 //         var list = list_;
-//         log("writeLatin1({any}, {s})", .{ .delayer = this, .str = str });
+//         log("writeLatin1({any}, {any})", .{ .delayer = this, .str = str });
 
 //         {
 //             switch (this.last_encoding) {

src/bench/string-handling.zig

@@ -21,9 +21,9 @@ pub fn main() anyerror!void {
         }
 
         if (index == std.math.maxInt(usize)) {
-            std.debug.print("manual        [{d} byte file] {s} NOT found in {}\n", .{ contents.len, find, std.fmt.fmtDuration(timer.read()) });
+            std.debug.print("manual        [{d} byte file] {any} NOT found in {}\n", .{ contents.len, find, std.fmt.fmtDuration(timer.read()) });
         } else {
-            std.debug.print("manual        [{d} byte file] {s} found at {d} in {}\n", .{ contents.len, find, index, std.fmt.fmtDuration(timer.read()) });
+            std.debug.print("manual        [{d} byte file] {any} found at {d} in {}\n", .{ contents.len, find, index, std.fmt.fmtDuration(timer.read()) });
         }
     }
 
@@ -38,9 +38,9 @@ pub fn main() anyerror!void {
         }
 
         if (index == std.math.maxInt(usize)) {
-            std.debug.print("memcpy      [{d} byte file] {s} NOT found in {}\n", .{ contents.len, find, std.fmt.fmtDuration(timer.read()) });
+            std.debug.print("memcpy      [{d} byte file] {any} NOT found in {}\n", .{ contents.len, find, std.fmt.fmtDuration(timer.read()) });
         } else {
-            std.debug.print("memcpy      [{d} byte file] {s} found at {d} in {}\n", .{ contents.len, find, index, std.fmt.fmtDuration(timer.read()) });
+            std.debug.print("memcpy      [{d} byte file] {any} found at {d} in {}\n", .{ contents.len, find, index, std.fmt.fmtDuration(timer.read()) });
         }
     }
 
@@ -56,9 +56,9 @@ pub fn main() anyerror!void {
         }
 
         if (index == std.math.maxInt(usize)) {
-            std.debug.print("ArrayList  [{d} byte file] {s} NOT found in {}\n", .{ contents.len, find, std.fmt.fmtDuration(timer.read()) });
+            std.debug.print("ArrayList  [{d} byte file] {any} NOT found in {}\n", .{ contents.len, find, std.fmt.fmtDuration(timer.read()) });
         } else {
-            std.debug.print("ArrayList  [{d} byte file] {s} found at {d} in {}\n", .{ contents.len, find, index, std.fmt.fmtDuration(timer.read()) });
+            std.debug.print("ArrayList  [{d} byte file] {any} found at {d} in {}\n", .{ contents.len, find, index, std.fmt.fmtDuration(timer.read()) });
         }
     }
 }