diff options
51 files changed, 549 insertions, 464 deletions
@@ -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: {any} opening {any}. Please ensure you've downloaded git submodules, and ran `make vendor`, `make jsc`.", .{ filepath, @errorName(err) }); + std.debug.panic("error: {s} opening {s}. Please ensure you've downloaded git submodules, and ran `make vendor`, `make jsc`.", .{ filepath, @errorName(err) }); }; file.close(); @@ -202,7 +202,7 @@ fn updateRuntime() anyerror!void { ); const runtime_version_file = std.fs.cwd().createFile("src/runtime.version", .{ .truncate = true }) catch std.debug.panic("Failed to create src/runtime.version", .{}); defer runtime_version_file.close(); - runtime_version_file.writer().print("{x}", .{runtime_hash}) catch unreachable; + runtime_version_file.writer().print("{any}", .{std.fmt.fmtSliceHexLower(std.mem.asBytes(&runtime_hash))}) catch unreachable; var fallback_out_file = try std.fs.cwd().openFile("src/fallback.out.js", .{ .mode = .read_only }); const fallback_hash = std.hash.Wyhash.hash( 0, @@ -211,7 +211,7 @@ fn updateRuntime() anyerror!void { const fallback_version_file = std.fs.cwd().createFile("src/fallback.version", .{ .truncate = true }) catch std.debug.panic("Failed to create src/fallback.version", .{}); - fallback_version_file.writer().print("{x}", .{fallback_hash}) catch unreachable; + fallback_version_file.writer().print("{any}", .{std.fmt.fmtSliceHexLower(std.mem.asBytes(&fallback_hash))}) catch unreachable; fallback_version_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, "{any}{any}", .{ bin_label, triplet }); + const output_dir_base = try std.fmt.bufPrint(&output_dir_buf, "{s}{s}", .{ 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: {any}/{any}\n", .{ output_dir, bun_executable_name }).step); + defer b.default_step.dependOn(&b.addLog("Output: {s}/{s}\n", .{ output_dir, bun_executable_name }).step); defer b.default_step.dependOn(&b.addLog( - "Build {any} v{} - v{}\n", + "Build {s} v{} - v{}\n", .{ triplet, min_version, @@ -377,7 +377,7 @@ pub fn build(b: *std.build.Builder) !void { { obj_step.dependOn(&b.addLog( - "Build {any} v{} - v{} ({any})\n", + "Build {s} v{} - v{} ({s})\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: {any}/{any}\n", .{ output_dir, bun_executable_name }); + var log_step = b.addLog("Destination: {s}/{s}\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").? ++ "[{any} 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").? ++ "[{s} 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").? ++ "[{any} 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").? ++ "[{s} 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); @@ -557,6 +557,8 @@ pub var original_make_fn: ?fn (step: *std.build.Step) anyerror!void = null; pub fn linkObjectFiles(b: *std.build.Builder, obj: *std.build.LibExeObjStep, target: anytype) !void { if (target.getOsTag() == .freestanding) return; + + var dirs_to_search = std.BoundedArray([]const u8, 32).init(0) catch unreachable; const arm_brew_prefix: []const u8 = "/opt/homebrew"; const x86_brew_prefix: []const u8 = "/usr/local"; diff --git a/misctools/fetch.zig b/misctools/fetch.zig index 2828f0a99..0b990572f 100644 --- a/misctools/fetch.zig +++ b/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>{any}<r> opening file {any}", .{ @errorName(err), absolute_path }); + Output.printErrorln("<r><red>{s}<r> opening file {s}", .{ @errorName(err), absolute_path }); Global.exit(1); }; var file_contents = body_file.readToEndAlloc(allocator, try body_file.getEndPos()) catch |err| { - Output.printErrorln("<r><red>{any}<r> reading file {any}", .{ @errorName(err), absolute_path }); + Output.printErrorln("<r><red>{s}<r> reading file {s}", .{ @errorName(err), absolute_path }); Global.exit(1); }; body_string = file_contents; diff --git a/misctools/http_bench.zig b/misctools/http_bench.zig index 5064a7da7..11f0f23fa 100644 --- a/misctools/http_bench.zig +++ b/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>{any}<r> opening file {any}", .{ @errorName(err), absolute_path }); + Output.printErrorln("<r><red>{s}<r> opening file {s}", .{ @errorName(err), absolute_path }); Global.exit(1); }; var file_contents = body_file.readToEndAlloc(allocator, try body_file.getEndPos()) catch |err| { - Output.printErrorln("<r><red>{any}<r> reading file {any}", .{ @errorName(err), absolute_path }); + Output.printErrorln("<r><red>{s}<r> reading file {s}", .{ @errorName(err), absolute_path }); Global.exit(1); }; body_string = file_contents; diff --git a/src/bun.js/api/bun.zig b/src/bun.js/api/bun.zig index e37ed0862..f8f7b55a8 100644 --- a/src/bun.js/api/bun.zig +++ b/src/bun.js/api/bun.zig @@ -307,7 +307,7 @@ pub fn registerMacro( } if (!arguments[1].?.value().isCell() or !arguments[1].?.value().isCallable(ctx.vm())) { - JSError(getAllocator(ctx), "Macro must be a function. Received: {any}", .{@tagName(js.JSValueGetType(ctx, arguments[1]))}, ctx, exception); + JSError(getAllocator(ctx), "Macro must be a function. Received: {s}", .{@tagName(js.JSValueGetType(ctx, arguments[1]))}, ctx, exception); return js.JSValueMakeUndefined(ctx); } @@ -591,26 +591,26 @@ pub fn readFileAsStringCallback( ) js.JSValueRef { const path = buf_z.ptr[0..buf_z.len]; var file = std.fs.cwd().openFileZ(buf_z, .{ .mode = .read_only }) catch |err| { - JSError(getAllocator(ctx), "Opening file {any} for path: \"{any}\"", .{ @errorName(err), path }, ctx, exception); + JSError(getAllocator(ctx), "Opening file {s} for path: \"{s}\"", .{ @errorName(err), path }, ctx, exception); return js.JSValueMakeUndefined(ctx); }; defer file.close(); const stat = file.stat() catch |err| { - JSError(getAllocator(ctx), "Getting file size {any} for \"{any}\"", .{ @errorName(err), path }, ctx, exception); + JSError(getAllocator(ctx), "Getting file size {s} for \"{s}\"", .{ @errorName(err), path }, ctx, exception); return js.JSValueMakeUndefined(ctx); }; if (stat.kind != .File) { - JSError(getAllocator(ctx), "Can't read a {any} as a string (\"{any}\")", .{ @tagName(stat.kind), path }, ctx, exception); + JSError(getAllocator(ctx), "Can't read a {s} as a string (\"{s}\")", .{ @tagName(stat.kind), path }, ctx, exception); return js.JSValueMakeUndefined(ctx); } var contents_buf = VirtualMachine.vm.allocator.alloc(u8, stat.size + 2) catch unreachable; // OOM defer VirtualMachine.vm.allocator.free(contents_buf); const contents_len = file.readAll(contents_buf) catch |err| { - JSError(getAllocator(ctx), "{any} reading file (\"{any}\")", .{ @errorName(err), path }, ctx, exception); + JSError(getAllocator(ctx), "{s} reading file (\"{s}\")", .{ @errorName(err), path }, ctx, exception); return js.JSValueMakeUndefined(ctx); }; @@ -631,26 +631,26 @@ pub fn readFileAsBytesCallback( const path = buf_z.ptr[0..buf_z.len]; var file = std.fs.cwd().openFileZ(buf_z, .{ .mode = .read_only }) catch |err| { - JSError(getAllocator(ctx), "Opening file {any} for path: \"{any}\"", .{ @errorName(err), path }, ctx, exception); + JSError(getAllocator(ctx), "Opening file {s} for path: \"{s}\"", .{ @errorName(err), path }, ctx, exception); return js.JSValueMakeUndefined(ctx); }; defer file.close(); const stat = file.stat() catch |err| { - JSError(getAllocator(ctx), "Getting file size {any} for \"{any}\"", .{ @errorName(err), path }, ctx, exception); + JSError(getAllocator(ctx), "Getting file size {s} for \"{s}\"", .{ @errorName(err), path }, ctx, exception); return js.JSValueMakeUndefined(ctx); }; if (stat.kind != .File) { - JSError(getAllocator(ctx), "Can't read a {any} as a string (\"{any}\")", .{ @tagName(stat.kind), path }, ctx, exception); + JSError(getAllocator(ctx), "Can't read a {s} as a string (\"{s}\")", .{ @tagName(stat.kind), path }, ctx, exception); return js.JSValueMakeUndefined(ctx); } var contents_buf = VirtualMachine.vm.allocator.alloc(u8, stat.size + 2) catch unreachable; // OOM errdefer VirtualMachine.vm.allocator.free(contents_buf); const contents_len = file.readAll(contents_buf) catch |err| { - JSError(getAllocator(ctx), "{any} reading file (\"{any}\")", .{ @errorName(err), path }, ctx, exception); + JSError(getAllocator(ctx), "{s} reading file (\"{s}\")", .{ @errorName(err), path }, ctx, exception); return js.JSValueMakeUndefined(ctx); }; @@ -743,7 +743,7 @@ pub fn openInEditor( editor_choice = edit.editor; if (editor_choice == null) { edit.* = prev; - JSError(getAllocator(ctx), "Could not find editor \"{any}\"", .{sliced.slice()}, ctx, exception); + JSError(getAllocator(ctx), "Could not find editor \"{s}\"", .{sliced.slice()}, ctx, exception); return js.JSValueMakeUndefined(ctx); } else if (edit.name.ptr == edit.path.ptr) { edit.name = bun.default_allocator.dupe(u8, edit.path) catch unreachable; @@ -778,7 +778,7 @@ pub fn openInEditor( } editor.open(edit.path, path, line, column, bun.default_allocator) catch |err| { - JSC.JSError(bun.default_allocator, "Opening editor failed {any}", .{@errorName(err)}, ctx, exception); + JSC.JSError(bun.default_allocator, "Opening editor failed {s}", .{@errorName(err)}, ctx, exception); return null; }; @@ -1049,7 +1049,7 @@ pub fn readAllStdinSync( var stdin = std.io.getStdIn(); var result = stdin.readToEndAlloc(allocator, std.math.maxInt(u32)) catch |err| { - JSError(undefined, "{any} reading stdin", .{@errorName(err)}, ctx, exception); + JSError(undefined, "{s} reading stdin", .{@errorName(err)}, ctx, exception); return null; }; var out = ZigString.init(result); @@ -1375,7 +1375,7 @@ pub const Crypto = struct { switch (string_or_buffer) { .string => |str| { const encoding = JSC.Node.Encoding.from(str) orelse { - globalThis.throwInvalidArguments("Unknown encoding: {any}", .{str}); + globalThis.throwInvalidArguments("Unknown encoding: {s}", .{str}); return JSC.JSValue.zero; }; @@ -1428,7 +1428,7 @@ pub const Crypto = struct { switch (string_or_buffer) { .string => |str| { const encoding = JSC.Node.Encoding.from(str) orelse { - globalThis.throwInvalidArguments("Unknown encoding: {any}", .{str}); + globalThis.throwInvalidArguments("Unknown encoding: {s}", .{str}); return JSC.JSValue.zero; }; @@ -2124,19 +2124,19 @@ pub const Unsafe = struct { // defer getAllocator(ctx).destroy(lockfile); // switch (cause.step) { // .open_file => { -// JSError(undefined, "error opening lockfile: {any}", .{ +// JSError(undefined, "error opening lockfile: {s}", .{ // @errorName(cause.value), // }, ctx, exception); // return null; // }, // .parse_file => { -// JSError(undefined, "error parsing lockfile: {any}", .{ +// JSError(undefined, "error parsing lockfile: {s}", .{ // @errorName(cause.value), // }, ctx, exception); // return null; // }, // .read_file => { -// JSError(undefined, "error reading lockfile: {any}", .{ +// JSError(undefined, "error reading lockfile: {s}", .{ // @errorName(cause.value), // }, ctx, exception); // return null; @@ -2934,7 +2934,7 @@ pub const FFI = struct { } const array_buffer = value.asArrayBuffer(globalThis) orelse { - return JSC.toInvalidArguments("Expected ArrayBufferView but received {any}", .{@tagName(value.jsType())}, globalThis); + return JSC.toInvalidArguments("Expected ArrayBufferView but received {s}", .{@tagName(value.jsType())}, globalThis); }; if (array_buffer.len == 0) { diff --git a/src/bun.js/api/ffi.zig b/src/bun.js/api/ffi.zig index 7d97d50dc..53ced79b3 100644 --- a/src/bun.js/api/ffi.zig +++ b/src/bun.js/api/ffi.zig @@ -331,7 +331,7 @@ pub const FFI = struct { // optional if the user passed "ptr" if (function.symbol_from_dynamic_library == null) { var resolved_symbol = dylib.lookup(*anyopaque, function_name) orelse { - const ret = JSC.toInvalidArguments("Symbol \"{any}\" not found in \"{any}\"", .{ std.mem.span(function_name), name_slice.slice() }, global); + const ret = JSC.toInvalidArguments("Symbol \"{s}\" not found in \"{s}\"", .{ std.mem.span(function_name), name_slice.slice() }, global); for (symbols.values()) |*value| { allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?))); value.arg_types.clearAndFree(allocator); @@ -345,7 +345,7 @@ pub const FFI = struct { } function.compile(allocator) catch |err| { - const ret = JSC.toInvalidArguments("{any} when compiling symbol \"{any}\" in \"{any}\"", .{ + const ret = JSC.toInvalidArguments("{s} when compiling symbol \"{s}\" in \"{s}\"", .{ std.mem.span(@errorName(err)), std.mem.span(function_name), name_slice.slice(), @@ -434,7 +434,7 @@ pub const FFI = struct { const function_name = function.base_name.?; if (function.symbol_from_dynamic_library == null) { - const ret = JSC.toInvalidArguments("Symbol for \"{any}\" not found", .{std.mem.span(function_name)}, global); + const ret = JSC.toInvalidArguments("Symbol for \"{s}\" not found", .{std.mem.span(function_name)}, global); for (symbols.values()) |*value| { allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?))); value.arg_types.clearAndFree(allocator); @@ -444,7 +444,7 @@ pub const FFI = struct { } function.compile(allocator) catch |err| { - const ret = JSC.toInvalidArguments("{any} when compiling symbol \"{any}\"", .{ + const ret = JSC.toInvalidArguments("{s} when compiling symbol \"{s}\"", .{ std.mem.span(@errorName(err)), std.mem.span(function_name), }, global); @@ -544,7 +544,7 @@ pub const FFI = struct { defer type_name.deinit(); abi_types.appendAssumeCapacity(ABIType.label.get(type_name.slice()) orelse { abi_types.clearAndFree(allocator); - return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Unknown type {any}", .{type_name.slice()}, global); + return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Unknown type {s}", .{type_name.slice()}, global); }); } } @@ -576,7 +576,7 @@ pub const FFI = struct { defer ret_slice.deinit(); return_type = ABIType.label.get(ret_slice.slice()) orelse { abi_types.clearAndFree(allocator); - return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Unknown return type {any}", .{ret_slice.slice()}, global); + return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Unknown return type {s}", .{ret_slice.slice()}, global); }; } @@ -624,7 +624,7 @@ pub const FFI = struct { const value = symbols_iter.value; if (value.isEmptyOrUndefinedOrNull()) { - return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Expected an object for key \"{any}\"", .{prop}, global); + return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Expected an object for key \"{s}\"", .{prop}, global); } var function: Function = .{}; @@ -1143,7 +1143,7 @@ pub const FFI = struct { try this.return_type.typename(writer); try writer.writeAll(" return_value = "); } - try writer.print("{any}(", .{std.mem.span(this.base_name.?)}); + try writer.print("{s}(", .{std.mem.span(this.base_name.?)}); first = true; arg_buf[0..3].* = "arg".*; for (this.arg_types.items) |arg, i| { @@ -1296,7 +1296,7 @@ pub const FFI = struct { const len = inner_buf.len + 1; inner_buf = inner_buf_[0..len]; inner_buf[0] = '_'; - try writer.print("return {any}", .{this.return_type.toCExact(inner_buf)}); + try writer.print("return {s}", .{this.return_type.toCExact(inner_buf)}); } try writer.writeAll(";\n}\n\n"); @@ -1449,7 +1449,7 @@ pub const FFI = struct { }, .char, .int8_t, .uint8_t, .int16_t, .uint16_t, .int32_t, .uint32_t => { if (self.exact) - try writer.print("({any})", .{std.mem.span(@tagName(self.tag))}); + try writer.print("({s})", .{std.mem.span(@tagName(self.tag))}); try writer.writeAll("JSVALUE_TO_INT32("); }, @@ -1498,31 +1498,31 @@ pub const FFI = struct { switch (self.tag) { .void => {}, .bool => { - try writer.print("BOOLEAN_TO_JSVALUE({any})", .{self.symbol}); + try writer.print("BOOLEAN_TO_JSVALUE({s})", .{self.symbol}); }, .char, .int8_t, .uint8_t, .int16_t, .uint16_t, .int32_t => { - try writer.print("INT32_TO_JSVALUE((int32_t){any})", .{self.symbol}); + try writer.print("INT32_TO_JSVALUE((int32_t){s})", .{self.symbol}); }, .uint32_t, .i64_fast => { - try writer.print("INT64_TO_JSVALUE(JS_GLOBAL_OBJECT, (int64_t){any})", .{self.symbol}); + try writer.print("INT64_TO_JSVALUE(JS_GLOBAL_OBJECT, (int64_t){s})", .{self.symbol}); }, .int64_t => { - try writer.print("INT64_TO_JSVALUE_SLOW(JS_GLOBAL_OBJECT, {any})", .{self.symbol}); + try writer.print("INT64_TO_JSVALUE_SLOW(JS_GLOBAL_OBJECT, {s})", .{self.symbol}); }, .u64_fast => { - try writer.print("UINT64_TO_JSVALUE(JS_GLOBAL_OBJECT, {any})", .{self.symbol}); + try writer.print("UINT64_TO_JSVALUE(JS_GLOBAL_OBJECT, {s})", .{self.symbol}); }, .uint64_t => { - try writer.print("UINT64_TO_JSVALUE_SLOW(JS_GLOBAL_OBJECT, {any})", .{self.symbol}); + try writer.print("UINT64_TO_JSVALUE_SLOW(JS_GLOBAL_OBJECT, {s})", .{self.symbol}); }, .function, .cstring, .ptr => { - try writer.print("PTR_TO_JSVALUE({any})", .{self.symbol}); + try writer.print("PTR_TO_JSVALUE({s})", .{self.symbol}); }, .double => { - try writer.print("DOUBLE_TO_JSVALUE({any})", .{self.symbol}); + try writer.print("DOUBLE_TO_JSVALUE({s})", .{self.symbol}); }, .float => { - try writer.print("FLOAT_TO_JSVALUE({any})", .{self.symbol}); + try writer.print("FLOAT_TO_JSVALUE({s})", .{self.symbol}); }, } } diff --git a/src/bun.js/api/html_rewriter.zig b/src/bun.js/api/html_rewriter.zig index 252915f56..a3632bf32 100644 --- a/src/bun.js/api/html_rewriter.zig +++ b/src/bun.js/api/html_rewriter.zig @@ -735,7 +735,7 @@ const DocumentHandler = struct { .Object, .ProxyObject, .Cell, .FinalObject => {}, else => |kind| { JSC.throwInvalidArguments( - "Expected object but received {any}", + "Expected object but received {s}", .{@as(string, @tagName(kind))}, global, exception, @@ -886,7 +886,7 @@ const ElementHandler = struct { .Object, .ProxyObject, .Cell, .FinalObject => {}, else => |kind| { JSC.throwInvalidArguments( - "Expected object but received {any}", + "Expected object but received {s}", .{@as(string, @tagName(kind))}, global, exception, diff --git a/src/bun.js/api/transpiler.zig b/src/bun.js/api/transpiler.zig index 75b5866bf..eba9ef7aa 100644 --- a/src/bun.js/api/transpiler.zig +++ b/src/bun.js/api/transpiler.zig @@ -667,7 +667,7 @@ fn transformOptionsFromJSC(ctx: JSC.C.JSContextRef, temp_allocator: std.mem.Allo var key = try key_.toOwnedSlice(bun.default_allocator); if (!JSLexer.isIdentifier(key)) { - JSC.throwInvalidArguments("\"{any}\" is not a valid ECMAScript identifier", .{key}, ctx, exception); + JSC.throwInvalidArguments("\"{s}\" is not a valid ECMAScript identifier", .{key}, ctx, exception); bun.default_allocator.free(key); return transpiler; } diff --git a/src/bun.js/base.zig b/src/bun.js/base.zig index 259a04934..b014b2430 100644 --- a/src/bun.js/base.zig +++ b/src/bun.js/base.zig @@ -273,7 +273,7 @@ pub const To = struct { if (comptime Info == .Struct) { if (comptime @hasDecl(Type, "Class") and @hasDecl(Type.Class, "isJavaScriptCoreClass")) { if (comptime !@hasDecl(Type, "finalize")) { - @compileError(comptime std.fmt.comptimePrint("JSC class {any} must implement finalize to prevent memory leaks", .{Type.Class.name})); + @compileError(comptime std.fmt.comptimePrint("JSC class {s} must implement finalize to prevent memory leaks", .{Type.Class.name})); } if (comptime !@hasDecl(Type, "toJS")) { @@ -583,12 +583,12 @@ pub const d = struct { } if (no_type) { - buf = buf ++ printIndented("{any}({any});\n", .{ + buf = buf ++ printIndented("{s}({s});\n", .{ func.name, args, }, indent); } else { - buf = buf ++ printIndented("{any}({any}): {any};\n", .{ + buf = buf ++ printIndented("{s}({s}): {s};\n", .{ func.name, args, func.@"return", @@ -618,12 +618,12 @@ pub const d = struct { } if (no_type) { - buf = buf ++ printIndented("function {any}({any});\n", .{ + buf = buf ++ printIndented("function {s}({s});\n", .{ func.name, args, }, indent); } else { - buf = buf ++ printIndented("function {any}({any}): {any};\n", .{ + buf = buf ++ printIndented("function {s}({s}): {s};\n", .{ func.name, args, func.@"return", @@ -676,7 +676,7 @@ pub const d = struct { if (klass.global) { buf = buf ++ printIndented("declare global {{\n", .{}, indent); } else { - buf = buf ++ printIndented("declare module \"{any}\" {{\n", .{klass.path}, indent); + buf = buf ++ printIndented("declare module \"{s}\" {{\n", .{klass.path}, indent); } indent += indent_level; @@ -734,9 +734,9 @@ pub const d = struct { const qualifier = if (!klass.default_export) "export " else ""; if (klass.interface) { - buf = buf ++ printIndented("export interface {any} {{\n", .{klass.name}, indent); + buf = buf ++ printIndented("export interface {s} {{\n", .{klass.name}, indent); } else { - buf = buf ++ printIndented("{any}class {any} {{\n", .{ qualifier, klass.name }, indent); + buf = buf ++ printIndented("{s}class {s} {{\n", .{ qualifier, klass.name }, indent); } indent += indent_level; @@ -781,7 +781,7 @@ pub const d = struct { buf = buf ++ printIndented("}}\n", .{}, indent); if (klass.default_export) { - buf = buf ++ printIndented("export = {any};\n", .{klass.name}, indent); + buf = buf ++ printIndented("export = {s};\n", .{klass.name}, indent); } break :brk; @@ -797,14 +797,14 @@ pub const d = struct { const first = splitter.next() orelse break :brk; const second = splitter.next() orelse { - buf = buf ++ printIndented("/** {any} */\n", .{std.mem.trim(u8, first, " ")}, indent); + buf = buf ++ printIndented("/** {s} */\n", .{std.mem.trim(u8, first, " ")}, indent); break :brk; }; buf = buf ++ printIndented("/**\n", .{}, indent); - buf = buf ++ printIndented(" * {any}\n", .{std.mem.trim(u8, first, " ")}, indent); - buf = buf ++ printIndented(" * {any}\n", .{std.mem.trim(u8, second, " ")}, indent); + buf = buf ++ printIndented(" * {s}\n", .{std.mem.trim(u8, first, " ")}, indent); + buf = buf ++ printIndented(" * {s}\n", .{std.mem.trim(u8, second, " ")}, indent); while (splitter.next()) |line| { - buf = buf ++ printIndented(" * {any}\n", .{std.mem.trim(u8, line, " ")}, indent); + buf = buf ++ printIndented(" * {s}\n", .{std.mem.trim(u8, line, " ")}, indent); } buf = buf ++ printIndented("*/\n", .{}, indent); } @@ -1441,7 +1441,7 @@ pub fn NewClassWithInstanceType( try writer.writeAll(" "); } - try writer.print("{any} ", .{GetterNameFormatter{ .index = i }}); + try writer.print("{s} ", .{GetterNameFormatter{ .index = i }}); k = 0; @@ -1473,7 +1473,7 @@ pub fn NewClassWithInstanceType( try writer.writeAll(" "); } - try writer.print("{any} ", .{FunctionNameFormatter{ .index = i }}); + try writer.print("{s} ", .{FunctionNameFormatter{ .index = i }}); k = 0; while (k < middle_padding - name_.len) : (k += 1) { @@ -3278,7 +3278,7 @@ pub fn DOMCall( try writer.writeAll("JSC::DOMJIT::Effect::forPure(),\n "); } else if (effect.writes[0] == DOMEffect.pure.writes[0]) { try writer.print( - "JSC::DOMJIT::Effect::forReadKinds(JSC::DFG::AbstractHeapKind::{any}, JSC::DFG::AbstractHeapKind::{any}, JSC::DFG::AbstractHeapKind::{any}, JSC::DFG::AbstractHeapKind::{any}),\n ", + "JSC::DOMJIT::Effect::forReadKinds(JSC::DFG::AbstractHeapKind::{s}, JSC::DFG::AbstractHeapKind::{s}, JSC::DFG::AbstractHeapKind::{s}, JSC::DFG::AbstractHeapKind::{s}),\n ", .{ @tagName(effect.reads[0]), @tagName(effect.reads[1]), @@ -3288,7 +3288,7 @@ pub fn DOMCall( ); } else if (effect.reads[0] == DOMEffect.pure.reads[0]) { try writer.print( - "JSC::DOMJIT::Effect::forWriteKinds(JSC::DFG::AbstractHeapKind::{any}, JSC::DFG::AbstractHeapKind::{any}, JSC::DFG::AbstractHeapKind::{any}, JSC::DFG::AbstractHeapKind::{any}),\n ", + "JSC::DOMJIT::Effect::forWriteKinds(JSC::DFG::AbstractHeapKind::{s}, JSC::DFG::AbstractHeapKind::{s}, JSC::DFG::AbstractHeapKind::{s}, JSC::DFG::AbstractHeapKind::{s}),\n ", .{ @tagName(effect.writes[0]), @tagName(effect.writes[1]), diff --git a/src/bun.js/node/types.zig b/src/bun.js/node/types.zig index bb7ef85ca..89d466c4e 100644 --- a/src/bun.js/node/types.zig +++ b/src/bun.js/node/types.zig @@ -1564,7 +1564,7 @@ pub const Path = struct { if (name_.isEmpty()) { return JSC.ZigString.Empty.toValue(globalThis); } - const out = std.fmt.allocPrint(allocator, "{any}{any}", .{ name_, ext }) catch unreachable; + const out = std.fmt.allocPrint(allocator, "{s}{s}", .{ name_, ext }) catch unreachable; defer allocator.free(out); return JSC.ZigString.init(out).withEncoding().toValueGC(globalThis); @@ -1573,13 +1573,13 @@ pub const Path = struct { if (insert_separator) { const separator = if (!isWindows) "/" else "\\"; if (name_with_ext.isEmpty()) { - const out = std.fmt.allocPrint(allocator, "{}{any}{}{}", .{ dir, separator, name_, ext }) catch unreachable; + const out = std.fmt.allocPrint(allocator, "{}{s}{}{}", .{ dir, separator, name_, ext }) catch unreachable; defer allocator.free(out); return JSC.ZigString.init(out).withEncoding().toValueGC(globalThis); } { - const out = std.fmt.allocPrint(allocator, "{}{any}{}", .{ + const out = std.fmt.allocPrint(allocator, "{}{s}{}", .{ dir, separator, name_with_ext, diff --git a/src/bun.js/webcore/streams.zig b/src/bun.js/webcore/streams.zig index 6d4fcb6bf..49e214bb7 100644 --- a/src/bun.js/webcore/streams.zig +++ b/src/bun.js/webcore/streams.zig @@ -3162,6 +3162,7 @@ pub const FileBlobLoader = struct { resume this.concurrent.read_frame; } + const ScheduleReadFrame = @Frame(scheduleRead); pub fn scheduleRead(this: *FileBlobLoader) void { if (comptime Environment.isMac) { var remaining = this.buf[this.concurrent.read..]; @@ -3209,14 +3210,15 @@ pub const FileBlobLoader = struct { null, ); - suspend { - var _frame = @frame(); - var this_frame = bun.default_allocator.create(std.meta.Child(@TypeOf(_frame))) catch unreachable; - this_frame.* = _frame.*; - this.concurrent.read_frame = this_frame; - } + // suspend { + // var _frame = @frame(); + // var this_frame = bun.allocateFrame(ScheduleReadFrame) catch unreachable; + // this_frame.* = _frame.*; + // this.concurrent.read_frame = this_frame; + // } + unreachable; - scheduleMainThreadTask(this); + // scheduleMainThreadTask(this); } pub fn onJSThread(task_ctx: *anyopaque) void { diff --git a/src/bun_js.zig b/src/bun_js.zig index 8f05eb560..d406033a1 100644 --- a/src/bun_js.zig +++ b/src/bun_js.zig @@ -101,7 +101,7 @@ pub const Run = struct { null, logger.Loc.Empty, run.vm.allocator, - "BUN_CONFIG_MAX_HTTP_REQUESTS value \"{any}\" is not a valid integer between 1 and 65535", + "BUN_CONFIG_MAX_HTTP_REQUESTS value \"{s}\" is not a valid integer between 1 and 65535", .{max_http_requests}, ) catch unreachable; break :load; diff --git a/src/bundler.zig b/src/bundler.zig index f9ff22a38..b8a32b5a5 100644 --- a/src/bundler.zig +++ b/src/bundler.zig @@ -253,13 +253,13 @@ pub const PluginRunner = struct { if (static_namespace) { return Fs.Path.initWithNamespace( - std.fmt.allocPrint(this.allocator, "{any}", .{file_path}) catch unreachable, + std.fmt.allocPrint(this.allocator, "{s}", .{file_path}) catch unreachable, user_namespace.slice(), ); } else { return Fs.Path.initWithNamespace( - std.fmt.allocPrint(this.allocator, "{any}", .{file_path}) catch unreachable, - std.fmt.allocPrint(this.allocator, "{any}", .{user_namespace}) catch unreachable, + std.fmt.allocPrint(this.allocator, "{s}", .{file_path}) catch unreachable, + std.fmt.allocPrint(this.allocator, "{s}", .{user_namespace}) catch unreachable, ); } } @@ -347,7 +347,7 @@ pub const PluginRunner = struct { // Our super slow way of cloning the string into memory owned by JSC var combined_string = std.fmt.allocPrint( this.allocator, - "{any}:{any}", + "{s}:{s}", .{ user_namespace, file_path }, ) catch unreachable; const out = JSC.ZigString.init(combined_string).toValueGC(this.global_object).getZigString(this.global_object); @@ -411,13 +411,13 @@ pub const Bundler = struct { }; if (has_dot_slash_form) { - bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{any} resolving \"{any}\". Did you mean: \"./{any}\"", .{ + bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{s} resolving \"{s}\". Did you mean: \"./{s}\"", .{ @errorName(err), entry_point, entry_point, }) catch unreachable; } else { - bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{any} resolving \"{any}\" (entry point)", .{ @errorName(err), entry_point }) catch unreachable; + bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{s} resolving \"{s}\" (entry point)", .{ @errorName(err), entry_point }) catch unreachable; } return err; @@ -965,7 +965,7 @@ pub const Bundler = struct { var file: std.fs.File = undefined; if (Outstream == Dir) { - const output_dir = outstream; + const output_dir = outstream.dir; if (std.fs.path.dirname(file_path.pretty)) |dirname| { try output_dir.makePath(dirname); @@ -1033,7 +1033,7 @@ pub const Bundler = struct { file_op.is_tmpdir = false; if (Outstream == Dir) { - file_op.dir = outstream.fd; + file_op.dir = outstream.dir.fd; if (bundler.fs.fs.needToCloseFiles()) { file.close(); @@ -1091,7 +1091,7 @@ pub const Bundler = struct { file_op.is_tmpdir = false; if (Outstream == Dir) { - file_op.dir = outstream.fd; + file_op.dir = outstream.dir.fd; if (bundler.fs.fs.needToCloseFiles()) { file.close(); @@ -1374,7 +1374,7 @@ pub const Bundler = struct { true, file_descriptor, ) catch |err| { - bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{any} reading \"{any}\"", .{ @errorName(err), path.text }) catch {}; + bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{s} reading \"{s}\"", .{ @errorName(err), path.text }) catch {}; return null; }; input_fd = entry.fd; @@ -1513,7 +1513,7 @@ pub const Bundler = struct { null, logger.Loc.Empty, bundler.allocator, - "Invalid wasm file \"{any}\" (missing magic header)", + "Invalid wasm file \"{s}\" (missing magic header)", .{path.text}, ) catch {}; return null; @@ -1528,7 +1528,7 @@ pub const Bundler = struct { } }, .css => {}, - else => Global.panic("Unsupported loader {any} for path: {any}", .{ loader, source.path.text }), + else => Global.panic("Unsupported loader {any} for path: {s}", .{ loader, source.path.text }), } return null; @@ -1682,12 +1682,12 @@ pub const Bundler = struct { } const result = bundler.resolver.resolve(bundler.fs.top_level_dir, entry, .entry_point) catch |err| { - Output.prettyError("Error resolving \"{any}\": {any}\n", .{ entry, @errorName(err) }); + Output.prettyError("Error resolving \"{s}\": {s}\n", .{ entry, @errorName(err) }); continue; }; if (result.pathConst() == null) { - Output.prettyError("\"{any}\" is disabled due to \"browser\" field in package.json.\n", .{ + Output.prettyError("\"{s}\" is disabled due to \"browser\" field in package.json.\n", .{ entry, }); continue; @@ -1767,10 +1767,10 @@ pub const Bundler = struct { }; } } else { - const output_dir = bundler.options.output_dir_handle orelse { + const output_dir: Dir = .{.dir = bundler.options.output_dir_handle orelse { Output.printError("Invalid or missing output directory.", .{}); Global.crash(); - }; + }}; if (load_from_routes) { if (bundler.options.framework) |*framework| { diff --git a/src/bundler/entry_points.zig b/src/bundler/entry_points.zig index 563544d1d..e391be277 100644 --- a/src/bundler/entry_points.zig +++ b/src/bundler/entry_points.zig @@ -279,7 +279,7 @@ pub const MacroEntryPoint = struct { hasher.update(function_name); const truncated_u32 = @truncate(u32, hasher.final()); - const specifier = std.fmt.bufPrint(buf, js_ast.Macro.namespaceWithColon ++ "//{x}.js", .{truncated_u32}) catch unreachable; + const specifier = std.fmt.bufPrint(buf, js_ast.Macro.namespaceWithColon ++ "//{any}.js", .{bun.fmt.x(truncated_u32)}) catch unreachable; len.* = @truncate(u32, specifier.len); return generateIDFromSpecifier(specifier); diff --git a/src/bundler/generate_node_modules_bundle.zig b/src/bundler/generate_node_modules_bundle.zig index 1b18bc7e4..149c647b8 100644 --- a/src/bundler/generate_node_modules_bundle.zig +++ b/src/bundler/generate_node_modules_bundle.zig @@ -684,11 +684,11 @@ pub fn generate( fixed_buffer_writer.print( \\if ('window' in globalThis) {{ \\ (function() {{ - \\ BUN_RUNTIME.__injectFastRefresh(${x}()); + \\ BUN_RUNTIME.__injectFastRefresh(${any}()); \\ }})(); \\}} , - .{refresh_runtime_module_id}, + .{bun.fmt.x(refresh_runtime_module_id)}, ) catch unreachable; try this.tmpfile.writeAll(fixed_buffer.buffer[0..fixed_buffer.pos]); } @@ -793,7 +793,7 @@ pub fn generate( const etag_u64 = hasher.final(); // We store the etag as a ascii hex encoded u64 // This is so we can send the bytes directly in the HTTP server instead of formatting it as hex each time. - javascript_bundle.etag = try std.fmt.allocPrint(allocator, "{x}", .{etag_u64}); + javascript_bundle.etag = try std.fmt.allocPrint(allocator, "{any}", .{bun.fmt.x(etag_u64)}); javascript_bundle.generated_at = @truncate(u32, @intCast(u64, std.time.milliTimestamp())); const basename = std.fs.path.basename(std.mem.span(destination)); @@ -803,10 +803,10 @@ pub fn generate( else try std.fmt.allocPrint( this.allocator, - "/{s}.{x}.bun", + "/{s}.{any}.bun", .{ basename[0 .. basename.len - extname.len], - etag_u64, + bun.fmt.x(etag_u64), }, ); diff --git a/src/bunfig.zig b/src/bunfig.zig index 0224f04eb..ea4b93993 100644 --- a/src/bunfig.zig +++ b/src/bunfig.zig @@ -64,11 +64,11 @@ pub const Bunfig = struct { // Token if (url.username.len == 0 and url.password.len > 0) { registry.token = url.password; - registry.url = try std.fmt.allocPrint(this.allocator, "{any}://{any}/{any}", .{ url.displayProtocol(), url.displayHostname(), std.mem.trimLeft(u8, url.pathname, "/") }); + registry.url = try std.fmt.allocPrint(this.allocator, "{any}://{any}/{s}", .{ url.displayProtocol(), url.displayHostname(), std.mem.trimLeft(u8, url.pathname, "/") }); } else if (url.username.len > 0 and url.password.len > 0) { registry.username = url.username; registry.password = url.password; - registry.url = try std.fmt.allocPrint(this.allocator, "{any}://{any}/{any}", .{ url.displayProtocol(), url.displayHostname(), std.mem.trimLeft(u8, url.pathname, "/") }); + registry.url = try std.fmt.allocPrint(this.allocator, "{any}://{any}/{s}", .{ url.displayProtocol(), url.displayHostname(), std.mem.trimLeft(u8, url.pathname, "/") }); } else { registry.url = url.href; } diff --git a/src/cache.zig b/src/cache.zig index 3ee2138d4..10e5b588f 100644 --- a/src/cache.zig +++ b/src/cache.zig @@ -119,14 +119,14 @@ pub const Fs = struct { const file = if (this.stream) rfs.readFileWithHandle(path, null, file_handle, true, shared, true) catch |err| { if (comptime Environment.isDebug) { - Output.printError("{any}: readFile error -- {any}", .{ path, @errorName(err) }); + Output.printError("{s}: readFile error -- {s}", .{ path, @errorName(err) }); } return err; } else rfs.readFileWithHandle(path, null, file_handle, true, shared, false) catch |err| { if (comptime Environment.isDebug) { - Output.printError("{any}: readFile error -- {any}", .{ path, @errorName(err) }); + Output.printError("{s}: readFile error -- {s}", .{ path, @errorName(err) }); } return err; }; diff --git a/src/cli.zig b/src/cli.zig index b8b31add4..f0e7526b5 100644 --- a/src/cli.zig +++ b/src/cli.zig @@ -129,7 +129,7 @@ pub const Arguments = struct { } pub fn fileReadError(err: anyerror, stderr: anytype, filename: string, kind: string) noreturn { - stderr.writer().print("Error reading file \"{any}\" for {any}: {any}", .{ filename, kind, @errorName(err) }) catch {}; + stderr.writer().print("Error reading file \"{s}\" for {s}: {s}", .{ filename, kind, @errorName(err) }) catch {}; std.process.exit(1); } @@ -223,7 +223,7 @@ pub const Arguments = struct { fn loadConfigPath(allocator: std.mem.Allocator, auto_loaded: bool, config_path: [:0]const u8, ctx: *Command.Context, comptime cmd: Command.Tag) !void { var config_file = std.fs.openFileAbsoluteZ(config_path, .{ .mode = .read_only }) catch |err| { if (auto_loaded) return; - Output.prettyErrorln("<r><red>error<r>: {any} opening config \"{any}\"", .{ + Output.prettyErrorln("<r><red>error<r>: {s} opening config \"{s}\"", .{ @errorName(err), std.mem.span(config_path), }); @@ -232,7 +232,7 @@ pub const Arguments = struct { defer config_file.close(); var contents = config_file.readToEndAlloc(allocator, std.math.maxInt(usize)) catch |err| { if (auto_loaded) return; - Output.prettyErrorln("<r><red>error<r>: {any} reading config \"{any}\"", .{ + Output.prettyErrorln("<r><red>error<r>: {s} reading config \"{s}\"", .{ @errorName(err), std.mem.span(config_path), }); @@ -453,7 +453,7 @@ pub const Arguments = struct { } else if (enum_value.len == 0) { ctx.debug.global_cache = options.GlobalCache.force; } else { - Output.prettyErrorln("Invalid value for --install: \"{any}\". Must be either \"auto\", \"fallback\", \"force\", or \"disable\"\n", .{enum_value}); + Output.prettyErrorln("Invalid value for --install: \"{s}\". Must be either \"auto\", \"fallback\", \"force\", or \"disable\"\n", .{enum_value}); Global.exit(1); } } @@ -477,7 +477,7 @@ pub const Arguments = struct { } else if (strings.eqlComptime(setting, "external")) { opts.source_map = Api.SourceMapMode.external; } else { - Output.prettyErrorln("<r><red>error<r>: Invalid sourcemap setting: \"{any}\"", .{setting}); + Output.prettyErrorln("<r><red>error<r>: Invalid sourcemap setting: \"{s}\"", .{setting}); Global.crash(); } } @@ -1225,12 +1225,12 @@ pub const Command = struct { } if (was_js_like) { - Output.prettyErrorln("<r><red>error<r>: Module not found \"<b>{any}<r>\"", .{ + Output.prettyErrorln("<r><red>error<r>: Module not found \"<b>{s}<r>\"", .{ ctx.positionals[0], }); Global.exit(1); } else if (ctx.positionals.len > 0) { - Output.prettyErrorln("<r><red>error<r>: File not found \"<b>{any}<r>\"", .{ + Output.prettyErrorln("<r><red>error<r>: File not found \"<b>{s}<r>\"", .{ ctx.positionals[0], }); Global.exit(1); @@ -1299,7 +1299,7 @@ pub const Command = struct { ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false) catch {}; } - Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{any}<r> due to error <b>{any}<r>", .{ + Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{ std.fs.path.basename(file_path), @errorName(err), }); diff --git a/src/cli/create_command.zig b/src/cli/create_command.zig index 43494c893..c2b08bc99 100644 --- a/src/cli/create_command.zig +++ b/src/cli/create_command.zig @@ -87,7 +87,7 @@ const UnsupportedPackages = struct { pub fn print(this: UnsupportedPackages) void { inline for (comptime std.meta.fieldNames(UnsupportedPackages)) |field_name| { if (@field(this, field_name)) { - Output.prettyErrorln("<r><yellow>warn<r><d>:<r> <b>\"{any}\"<r> won't work in bun yet\n", .{field_name}); + Output.prettyErrorln("<r><yellow>warn<r><d>:<r> <b>\"{s}\"<r> won't work in bun yet\n", .{field_name}); } } } @@ -132,9 +132,9 @@ fn execTask(allocator: std.mem.Allocator, task_: string, cwd: string, _: string, Output.pretty("\n<r><d>$<b>", .{}); for (argv) |arg, i| { if (i > argv.len - 1) { - Output.print(" {any} ", .{arg}); + Output.print(" {s} ", .{arg}); } else { - Output.print(" {any}", .{arg}); + Output.print(" {s}", .{arg}); } } Output.pretty("<r>", .{}); @@ -285,7 +285,7 @@ pub const CreateCommand = struct { var outdir_path_ = home_dir_buf[0..outdir_path.len :0]; std.fs.accessAbsoluteZ(outdir_path_, .{}) catch break :outer; if (create_options.verbose) { - Output.prettyErrorln("reading from {any}", .{outdir_path}); + Output.prettyErrorln("reading from {s}", .{outdir_path}); } example_tag = Example.Tag.local_folder; break :brk outdir_path; @@ -299,7 +299,7 @@ pub const CreateCommand = struct { var outdir_path_ = home_dir_buf[0..outdir_path.len :0]; std.fs.accessAbsoluteZ(outdir_path_, .{}) catch break :outer; if (create_options.verbose) { - Output.prettyErrorln("reading from {any}", .{outdir_path}); + Output.prettyErrorln("reading from {s}", .{outdir_path}); } example_tag = Example.Tag.local_folder; break :brk outdir_path; @@ -313,7 +313,7 @@ pub const CreateCommand = struct { var outdir_path_ = home_dir_buf[0..outdir_path.len :0]; std.fs.accessAbsoluteZ(outdir_path_, .{}) catch break :outer; if (create_options.verbose) { - Output.prettyErrorln("reading from {any}", .{outdir_path}); + Output.prettyErrorln("reading from {s}", .{outdir_path}); } example_tag = Example.Tag.local_folder; break :brk outdir_path; @@ -379,7 +379,7 @@ pub const CreateCommand = struct { const destination = try filesystem.dirname_store.append([]const u8, resolve_path.joinAbs(filesystem.top_level_dir, .auto, dirname)); var progress = std.Progress{}; - var node = progress.start(try ProgressBuf.print("Loading {any}", .{template}), 0); + var node = progress.start(try ProgressBuf.print("Loading {s}", .{template}), 0); progress.supports_ansi_escape_codes = Output.enable_ansi_colors_stderr; // alacritty is fast @@ -399,7 +399,7 @@ pub const CreateCommand = struct { var package_json_file: ?std.fs.File = null; if (create_options.verbose) { - Output.prettyErrorln("Downloading as {any}\n", .{@tagName(example_tag)}); + Output.prettyErrorln("Downloading as {s}\n", .{@tagName(example_tag)}); } switch (example_tag) { @@ -411,7 +411,7 @@ pub const CreateCommand = struct { node.end(); progress.refresh(); - Output.prettyError("\n<r><red>error:<r> <b>\"{any}\"<r> was not found. Here are templates you can use:\n\n", .{ + Output.prettyError("\n<r><red>error:<r> <b>\"{s}\"<r> was not found. Here are templates you can use:\n\n", .{ template, }); Output.flush(); @@ -444,7 +444,7 @@ pub const CreateCommand = struct { node.end(); progress.refresh(); - Output.prettyError("\n<r><red>error:<r> <b>\"{any}\"<r> was not found on GitHub. Here are templates you can use:\n\n", .{ + Output.prettyError("\n<r><red>error:<r> <b>\"{s}\"<r> was not found on GitHub. Here are templates you can use:\n\n", .{ template, }); Output.flush(); @@ -466,7 +466,7 @@ pub const CreateCommand = struct { else => unreachable, }; - node.name = try ProgressBuf.print("Decompressing {any}", .{template}); + node.name = try ProgressBuf.print("Decompressing {s}", .{template}); node.setCompletedItems(0); node.setEstimatedTotalItems(0); @@ -479,7 +479,7 @@ pub const CreateCommand = struct { try gunzip.readAll(); gunzip.deinit(); - node.name = try ProgressBuf.print("Extracting {any}", .{template}); + node.name = try ProgressBuf.print("Extracting {s}", .{template}); node.setCompletedItems(0); node.setEstimatedTotalItems(0); @@ -516,21 +516,21 @@ pub const CreateCommand = struct { // Thank you create-react-app for this copy (and idea) Output.prettyErrorln( - "<r>\n<red>error<r><d>: <r>The directory <b><blue>{any}<r>/ contains files that could conflict:\n\n", + "<r>\n<red>error<r><d>: <r>The directory <b><blue>{s}<r>/ contains files that could conflict:\n\n", .{ std.fs.path.basename(destination), }, ); for (archive_context.overwrite_list.keys()) |path| { if (strings.endsWith(path, std.fs.path.sep_str)) { - Output.prettyError("<r> <blue>{any}<r>", .{path[0 .. std.math.max(path.len, 1) - 1]}); + Output.prettyError("<r> <blue>{s}<r>", .{path[0 .. std.math.max(path.len, 1) - 1]}); Output.prettyErrorln(std.fs.path.sep_str, .{}); } else { - Output.prettyErrorln("<r> {any}", .{path}); + Output.prettyErrorln("<r> {s}", .{path}); } } - Output.prettyErrorln("<r>\n<d>To download {any} anyway, use --force<r>", .{template}); + Output.prettyErrorln("<r>\n<d>To download {s} anyway, use --force<r>", .{template}); Global.exit(1); } } @@ -568,7 +568,7 @@ pub const CreateCommand = struct { node.end(); progress.refresh(); - Output.prettyErrorln("<r><red>{any}<r>: opening dir {any}", .{ @errorName(err), template }); + Output.prettyErrorln("<r><red>{s}<r>: opening dir {s}", .{ @errorName(err), template }); Global.exit(1); }; @@ -578,7 +578,7 @@ pub const CreateCommand = struct { progress.refresh(); - Output.prettyErrorln("<r><red>{any}<r>: creating dir {any}", .{ @errorName(err), destination }); + Output.prettyErrorln("<r><red>{s}<r>: creating dir {s}", .{ @errorName(err), destination }); Global.exit(1); }; @@ -605,14 +605,14 @@ pub const CreateCommand = struct { progress_.refresh(); - Output.prettyErrorln("<r><red>{any}<r>: copying file {any}", .{ @errorName(err), entry.path }); + Output.prettyErrorln("<r><red>{s}<r>: copying file {s}", .{ @errorName(err), entry.path }); Global.exit(1); }; }; defer outfile.close(); defer node_.completeOne(); - var infile = try entry.dir.openFile(entry.basename, .{ .mode = .read_only }); + var infile = try entry.dir.dir.openFile(entry.basename, .{ .mode = .read_only }); defer infile.close(); // Assumption: you only really care about making sure something that was executable is still executable @@ -620,12 +620,12 @@ pub const CreateCommand = struct { _ = C.fchmod(outfile.handle, stat.mode); CopyFile.copy(infile.handle, outfile.handle) catch { - entry.dir.copyFile(entry.basename, destination_dir_, entry.path, .{}) catch |err| { + entry.dir.dir.copyFile(entry.basename, destination_dir_, entry.path, .{}) catch |err| { node_.end(); progress_.refresh(); - Output.prettyErrorln("<r><red>{any}<r>: copying file {any}", .{ @errorName(err), entry.path }); + Output.prettyErrorln("<r><red>{s}<r>: copying file {s}", .{ @errorName(err), entry.path }); Global.exit(1); }; }; @@ -633,9 +633,9 @@ pub const CreateCommand = struct { } }; - try FileCopier.copy(destination_dir, &walker_, node, &progress); + try FileCopier.copy(destination_dir.dir, &walker_, node, &progress); - package_json_file = destination_dir.openFile("package.json", .{ .mode = .read_write }) catch null; + package_json_file = destination_dir.dir.openFile("package.json", .{ .mode = .read_write }) catch null; read_package_json: { if (package_json_file) |pkg| { @@ -645,7 +645,7 @@ pub const CreateCommand = struct { progress.refresh(); package_json_file = null; - Output.prettyErrorln("Error reading package.json: <r><red>{any}", .{@errorName(err)}); + Output.prettyErrorln("Error reading package.json: <r><red>{s}", .{@errorName(err)}); break :read_package_json; }; @@ -666,7 +666,7 @@ pub const CreateCommand = struct { progress.refresh(); - Output.prettyErrorln("Error reading package.json: <r><red>{any}", .{@errorName(err)}); + Output.prettyErrorln("Error reading package.json: <r><red>{s}", .{@errorName(err)}); break :read_package_json; }; // The printer doesn't truncate, so we must do so manually @@ -1280,7 +1280,7 @@ pub const CreateCommand = struct { create_react_app_entry_point_path = std.fmt.allocPrint( ctx.allocator, - "./{any}", + "./{s}", .{ std.mem.trimLeft( @@ -1292,7 +1292,7 @@ pub const CreateCommand = struct { ) catch break :bail; html_writer.print( - "<script type=\"module\" async src=\"/{any}\"></script>\n{any}", + "<script type=\"module\" async src=\"/{s}\"></script>\n{s}", .{ create_react_app_entry_point_path[2..], public_index_file_contents[body_closing_tag..], @@ -1321,7 +1321,7 @@ pub const CreateCommand = struct { std.os.ftruncate(public_index_html_file.handle, outfile.len + 1) catch break :bail; bun_bun_for_react_scripts = true; is_create_react_app = true; - Output.prettyln("<r><d>[package.json] Added entry point {any} to public/index.html", .{create_react_app_entry_point_path}); + Output.prettyln("<r><d>[package.json] Added entry point {s} to public/index.html", .{create_react_app_entry_point_path}); } } @@ -1352,7 +1352,7 @@ pub const CreateCommand = struct { strings.contains(script, "react-scripts eject")) { if (create_options.verbose) { - Output.prettyErrorln("<r><d>[package.json] Pruned unnecessary script: {any}<r>", .{script}); + Output.prettyErrorln("<r><d>[package.json] Pruned unnecessary script: {s}<r>", .{script}); } continue; @@ -1451,7 +1451,7 @@ pub const CreateCommand = struct { var package_json_writer = JSPrinter.NewFileWriter(package_json_file.?); const written = JSPrinter.printJSON(@TypeOf(package_json_writer), package_json_writer, package_json_expr, &source) catch |err| { - Output.prettyErrorln("package.json failed to write due to error {any}", .{@errorName(err)}); + Output.prettyErrorln("package.json failed to write due to error {s}", .{@errorName(err)}); package_json_file = null; break :process_package_json; }; @@ -1462,7 +1462,7 @@ pub const CreateCommand = struct { if (needs.bun_bun_for_nextjs) { try postinstall_tasks.append(ctx.allocator, InjectionPrefill.bun_bun_for_nextjs_task); } else if (bun_bun_for_react_scripts) { - try postinstall_tasks.append(ctx.allocator, try std.fmt.allocPrint(ctx.allocator, "bun bun {any}", .{create_react_app_entry_point_path})); + try postinstall_tasks.append(ctx.allocator, try std.fmt.allocPrint(ctx.allocator, "bun bun {s}", .{create_react_app_entry_point_path})); } } } @@ -1505,12 +1505,12 @@ pub const CreateCommand = struct { const start_time = std.time.nanoTimestamp(); const install_args = &[_]string{ npm_client.bin, "install" }; Output.flush(); - Output.pretty("\n<r><d>$ <b><cyan>{any}<r><d> install", .{@tagName(npm_client.tag)}); + Output.pretty("\n<r><d>$ <b><cyan>{s}<r><d> install", .{@tagName(npm_client.tag)}); if (install_args.len > 2) { for (install_args[2..]) |arg| { Output.pretty(" ", .{}); - Output.pretty("{any}", .{arg}); + Output.pretty("{s}", .{arg}); } } @@ -1523,7 +1523,7 @@ pub const CreateCommand = struct { defer { Output.printErrorln("\n", .{}); Output.printStartEnd(start_time, std.time.nanoTimestamp()); - Output.prettyError(" <r><d>{any} install<r>\n", .{@tagName(npm_client.tag)}); + Output.prettyError(" <r><d>{s} install<r>\n", .{@tagName(npm_client.tag)}); Output.flush(); Output.print("\n", .{}); @@ -1547,7 +1547,7 @@ pub const CreateCommand = struct { Output.printError("\n", .{}); Output.printStartEnd(ctx.start_time, std.time.nanoTimestamp()); - Output.prettyErrorln(" <r><d>bun create {any}<r>", .{template}); + Output.prettyErrorln(" <r><d>bun create {s}<r>", .{template}); Output.flush(); @@ -1604,13 +1604,13 @@ pub const CreateCommand = struct { Output.pretty( \\ - \\<b><green>Success!<r> <b>{any}<r> loaded into <b>{any}<r> + \\<b><green>Success!<r> <b>{s}<r> loaded into <b>{s}<r> \\ , .{ display_name, std.fs.path.basename(destination) }); } else { Output.pretty( \\ - \\<b>Created <green>{any}<r> project successfully + \\<b>Created <green>{s}<r> project successfully \\ , .{std.fs.path.basename(template)}); } @@ -1628,7 +1628,7 @@ pub const CreateCommand = struct { \\ \\<r><d>#<r> When dependencies change, run this to update node_modules.bun: \\ - \\ <b><cyan>bun bun {any}<r> + \\ <b><cyan>bun bun {s}<r> \\ , .{create_react_app_entry_point_path}); } @@ -1637,8 +1637,8 @@ pub const CreateCommand = struct { \\ \\<d>#<r><b> To get started, run:<r> \\ - \\ <b><cyan>cd {any}<r> - \\ <b><cyan>{any}<r> + \\ <b><cyan>cd {s}<r> + \\ <b><cyan>{s}<r> \\ \\ , .{ @@ -1698,16 +1698,16 @@ pub const Example = struct { var app_name_buf: [512]u8 = undefined; pub fn print(examples: []const Example, default_app_name: ?string) void { for (examples) |example| { - var app_name = default_app_name orelse (std.fmt.bufPrint(&app_name_buf, "./{any}-app", .{example.name[0..std.math.min(example.name.len, 492)]}) catch unreachable); + var app_name = default_app_name orelse (std.fmt.bufPrint(&app_name_buf, "./{s}-app", .{example.name[0..std.math.min(example.name.len, 492)]}) catch unreachable); if (example.description.len > 0) { - Output.pretty(" <r># {any}<r>\n <b>bun create <cyan>{any}<r><b> {any}<r>\n<d> \n\n", .{ + Output.pretty(" <r># {s}<r>\n <b>bun create <cyan>{s}<r><b> {s}<r>\n<d> \n\n", .{ example.description, example.name, app_name, }); } else { - Output.pretty(" <r><b>bun create <cyan>{any}<r><b> {any}<r>\n\n", .{ + Output.pretty(" <r><b>bun create <cyan>{s}<r><b> {s}<r>\n\n", .{ example.name, app_name, }); @@ -1721,28 +1721,28 @@ pub const Example = struct { var examples = std.ArrayList(Example).fromOwnedSlice(ctx.allocator, remote_examples); { - var folders = [3]std.fs.IterableDir{ std.fs.Dir{ .fd = 0 }, std.fs.Dir{ .fd = 0 }, std.fs.Dir{ .fd = 0 } }; + var folders = [3]std.fs.IterableDir{ .{.dir = .{ .fd = 0 }}, .{.dir = .{ .fd = 0 }}, .{.dir = .{ .fd = 0 }} }; if (env_loader.map.get("BUN_CREATE_DIR")) |home_dir| { var parts = [_]string{home_dir}; var outdir_path = filesystem.absBuf(&parts, &home_dir_buf); - folders[0] = std.fs.openIterableDirAbsolute(outdir_path, .{}) catch std.fs.Dir{ .fd = 0 }; + folders[0] = std.fs.openIterableDirAbsolute(outdir_path, .{}) catch .{.dir = .{ .fd = 0 }}; } { var parts = [_]string{ filesystem.top_level_dir, BUN_CREATE_DIR }; var outdir_path = filesystem.absBuf(&parts, &home_dir_buf); - folders[1] = std.fs.openIterableDirAbsolute(outdir_path, .{}) catch std.fs.Dir{ .fd = 0 }; + folders[1] = std.fs.openIterableDirAbsolute(outdir_path, .{}) catch .{.dir = .{ .fd = 0 }}; } if (env_loader.map.get("HOME")) |home_dir| { var parts = [_]string{ home_dir, BUN_CREATE_DIR }; var outdir_path = filesystem.absBuf(&parts, &home_dir_buf); - folders[2] = std.fs.openIterableDirAbsolute(outdir_path, .{}) catch std.fs.Dir{ .fd = 0 }; + folders[2] = std.fs.openIterableDirAbsolute(outdir_path, .{}) catch .{.dir = .{ .fd = 0 }}; } // subfolders with package.json for (folders) |folder_| { - if (folder_.fd != 0) { + if (folder_.dir.fd != 0) { const folder: std.fs.IterableDir = folder_; var iter = folder.iterate(); @@ -1764,7 +1764,7 @@ pub const Example = struct { var path: [:0]u8 = home_dir_buf[0 .. entry.name.len + 1 + "package.json".len :0]; - folder.accessZ(path, .{ .mode = .read_only }) catch continue :loop; + folder.dir.accessZ(path, .{ .mode = .read_only }) catch continue :loop; try examples.append( Example{ @@ -1802,7 +1802,7 @@ pub const Example = struct { repository = repository[0..i]; } - progress.name = try ProgressBuf.pretty("<d>[github] <b>GET<r> <blue>{any}/{any}<r>", .{ owner, repository }); + progress.name = try ProgressBuf.pretty("<d>[github] <b>GET<r> <blue>{s}/{s}<r>", .{ owner, repository }); refresher.refresh(); var github_api_domain: string = "api.github.com"; @@ -1815,7 +1815,7 @@ pub const Example = struct { var api_url = URL.parse( try std.fmt.bufPrint( &github_repository_url_buf, - "https://{any}/repos/{any}/{any}/tarball", + "https://{s}/repos/{s}/{s}/tarball", .{ github_api_domain, owner, repository }, ), ); @@ -1825,7 +1825,7 @@ pub const Example = struct { if (env_loader.map.get("GITHUB_ACCESS_TOKEN")) |access_token| { if (access_token.len > 0) { - headers_buf = try std.fmt.allocPrint(ctx.allocator, "Access-TokenBearer {any}", .{access_token}); + headers_buf = try std.fmt.allocPrint(ctx.allocator, "Access-TokenBearer {s}", .{access_token}); try header_entries.append( ctx.allocator, Headers.Kv{ @@ -1887,7 +1887,7 @@ pub const Example = struct { refresher.refresh(); if (content_type.len > 0) { - Output.prettyErrorln("<r><red>error<r>: Unexpected content type from GitHub: {any}", .{content_type}); + Output.prettyErrorln("<r><red>error<r>: Unexpected content type from GitHub: {s}", .{content_type}); Global.crash(); } else { Output.prettyErrorln("<r><red>error<r>: Invalid response from GitHub (missing content type)", .{}); @@ -1914,7 +1914,7 @@ pub const Example = struct { var mutable = try ctx.allocator.create(MutableString); mutable.* = try MutableString.init(ctx.allocator, 2048); - url = URL.parse(try std.fmt.bufPrint(&url_buf, "https://registry.npmjs.org/@bun-examples/{any}/latest", .{name})); + url = URL.parse(try std.fmt.bufPrint(&url_buf, "https://registry.npmjs.org/@bun-examples/{s}/latest", .{name})); // ensure very stable memory address var async_http: *HTTP.AsyncHTTP = ctx.allocator.create(HTTP.AsyncHTTP) catch unreachable; @@ -1956,7 +1956,7 @@ pub const Example = struct { } Global.exit(1); } else { - Output.prettyErrorln("Error parsing package: <r><red>{any}<r>", .{@errorName(err)}); + Output.prettyErrorln("Error parsing package: <r><red>{s}<r>", .{@errorName(err)}); Global.exit(1); } }; @@ -2058,14 +2058,14 @@ pub const Example = struct { Global.exit(1); }, else => { - Output.prettyErrorln("<r><red>{any}<r> while trying to fetch examples list. Please try again", .{@errorName(err)}); + Output.prettyErrorln("<r><red>{s}<r> while trying to fetch examples list. Please try again", .{@errorName(err)}); Global.exit(1); }, } }; if (response.status_code != 200) { - Output.prettyErrorln("<r><red>{d}<r> fetching examples :( {any}", .{ response.status_code, mutable.list.items }); + Output.prettyErrorln("<r><red>{d}<r> fetching examples :( {s}", .{ response.status_code, mutable.list.items }); Global.exit(1); } @@ -2080,7 +2080,7 @@ pub const Example = struct { } Global.exit(1); } else { - Output.prettyErrorln("Error parsing examples: <r><red>{any}<r>", .{@errorName(err)}); + Output.prettyErrorln("Error parsing examples: <r><red>{s}<r>", .{@errorName(err)}); Global.exit(1); } }; @@ -2114,7 +2114,7 @@ pub const Example = struct { } } - Output.prettyErrorln("Corrupt examples data: expected object but received {any}", .{@tagName(examples_object.data)}); + Output.prettyErrorln("Corrupt examples data: expected object but received {s}", .{@tagName(examples_object.data)}); Global.exit(1); } }; @@ -2146,7 +2146,7 @@ pub const CreateListExamplesCommand = struct { if (env_loader.map.get("HOME")) |homedir| { Output.prettyln( - "<d>This command is completely optional. To add a new local template, create a folder in {any}/.bun-create/. To publish a new template, git clone https://github.com/oven-sh/bun, add a new folder to the \"examples\" folder, and submit a PR.<r>", + "<d>This command is completely optional. To add a new local template, create a folder in {s}/.bun-create/. To publish a new template, git clone https://github.com/oven-sh/bun, add a new folder to the \"examples\" folder, and submit a PR.<r>", .{homedir}, ); } else { @@ -2171,7 +2171,7 @@ const GitHandler = struct { success = std.atomic.Atomic(u32).init(0); thread = std.Thread.spawn(.{}, spawnThread, .{ destination, PATH, verbose }) catch |err| { - Output.prettyErrorln("<r><red>{any}<r>", .{@errorName(err)}); + Output.prettyErrorln("<r><red>{s}<r>", .{@errorName(err)}); Global.exit(1); }; } @@ -2233,7 +2233,7 @@ const GitHandler = struct { }; if (comptime verbose) { - Output.prettyErrorln("git backend: {any}", .{git}); + Output.prettyErrorln("git backend: {s}", .{git}); } // same names, just comptime known values diff --git a/src/cli/install_completions_command.zig b/src/cli/install_completions_command.zig index b24800ef1..70a4519a6 100644 --- a/src/cli/install_completions_command.zig +++ b/src/cli/install_completions_command.zig @@ -70,7 +70,7 @@ pub const InstallCompletionsCommand = struct { } var completions_dir: string = ""; - var output_dir: std.fs.Dir = found: { + var output_dir: std.fs.IterableDir = found: { var cwd_buf: [bun.MAX_PATH_BYTES]u8 = undefined; var cwd = std.os.getcwd(&cwd_buf) catch { Output.prettyErrorln("<r><red>error<r>: Could not get current working directory", .{}); @@ -93,14 +93,14 @@ pub const InstallCompletionsCommand = struct { } if (!std.fs.path.isAbsolute(completions_dir)) { - Output.prettyErrorln("<r><red>error:<r> Please pass an absolute path. {any} is invalid", .{completions_dir}); + Output.prettyErrorln("<r><red>error:<r> Please pass an absolute path. {s} is invalid", .{completions_dir}); Global.exit(fail_exit_code); } break :found std.fs.openIterableDirAbsolute(completions_dir, .{ }) catch |err| { - Output.prettyErrorln("<r><red>error:<r> accessing {any} errored {any}", .{ completions_dir, @errorName(err) }); + Output.prettyErrorln("<r><red>error:<r> accessing {s} errored {s}", .{ completions_dir, @errorName(err) }); Global.exit(fail_exit_code); }; } @@ -302,10 +302,10 @@ pub const InstallCompletionsCommand = struct { std.debug.assert(completions_dir.len > 0); - var output_file = output_dir.createFileZ(filename, .{ + var output_file = output_dir.dir.createFileZ(filename, .{ .truncate = true, }) catch |err| { - Output.prettyErrorln("<r><red>error:<r> Could not open {any} for writing: {any}", .{ + Output.prettyErrorln("<r><red>error:<r> Could not open {s} for writing: {s}", .{ filename, @errorName(err), }); @@ -313,7 +313,7 @@ pub const InstallCompletionsCommand = struct { }; output_file.writeAll(shell.completions()) catch |err| { - Output.prettyErrorln("<r><red>error:<r> Could not write to {any}: {any}", .{ + Output.prettyErrorln("<r><red>error:<r> Could not write to {s}: {s}", .{ filename, @errorName(err), }); @@ -321,7 +321,7 @@ pub const InstallCompletionsCommand = struct { }; defer output_file.close(); - output_dir.close(); + output_dir.dir.close(); // Check if they need to load the zsh completions file into their .zshrc if (shell == .zsh) { @@ -394,7 +394,7 @@ pub const InstallCompletionsCommand = struct { // We need to add it to the end of the file var remaining = buf[read..]; - var extra = std.fmt.bufPrint(remaining, "\n# bun completions\n[ -s \"{any}\" ] && source \"{any}\"\n", .{ + var extra = std.fmt.bufPrint(remaining, "\n# bun completions\n[ -s \"{s}\" ] && source \"{s}\"\n", .{ completions_path, completions_path, }) catch unreachable; @@ -406,14 +406,14 @@ pub const InstallCompletionsCommand = struct { }; if (needs_to_tell_them_to_add_completions_file) { - Output.prettyErrorln("<r>To enable completions, add this to your .zshrc:\n <b>[ -s \"{any}\" ] && source \"{any}\"", .{ + Output.prettyErrorln("<r>To enable completions, add this to your .zshrc:\n <b>[ -s \"{s}\" ] && source \"{s}\"", .{ completions_path, completions_path, }); } } - Output.prettyErrorln("<r><d>Installed completions to {any}/{any}<r>\n", .{ + Output.prettyErrorln("<r><d>Installed completions to {s}/{s}<r>\n", .{ completions_dir, filename, }); diff --git a/src/cli/package_manager_command.zig b/src/cli/package_manager_command.zig index d81d8cba7..36e062efd 100644 --- a/src/cli/package_manager_command.zig +++ b/src/cli/package_manager_command.zig @@ -27,7 +27,7 @@ pub const PackageManagerCommand = struct { if (load_lockfile == .err) { if (pm.options.log_level != .silent) - Output.prettyError("Error loading lockfile: {any}", .{@errorName(load_lockfile.err.value)}); + Output.prettyError("Error loading lockfile: {s}", .{@errorName(load_lockfile.err.value)}); Global.exit(1); } @@ -59,7 +59,7 @@ pub const PackageManagerCommand = struct { if (strings.eqlComptime(first, "bin")) { var output_path = Path.joinAbs(Fs.FileSystem.instance.top_level_dir, .auto, std.mem.span(pm.options.bin_path)); - Output.prettyln("{any}", .{output_path}); + Output.prettyln("{s}", .{output_path}); if (Output.stdout_descriptor_type == .terminal) { Output.prettyln("\n", .{}); } @@ -93,7 +93,7 @@ pub const PackageManagerCommand = struct { if (load_lockfile == .err) { if (pm.options.log_level != .silent) - Output.prettyError("Error loading lockfile: {any}", .{@errorName(load_lockfile.err.value)}); + Output.prettyError("Error loading lockfile: {s}", .{@errorName(load_lockfile.err.value)}); Global.exit(1); } @@ -114,7 +114,7 @@ pub const PackageManagerCommand = struct { if (load_lockfile == .err) { if (pm.options.log_level != .silent) - Output.prettyError("Error loading lockfile: {any}", .{@errorName(load_lockfile.err.value)}); + Output.prettyError("Error loading lockfile: {s}", .{@errorName(load_lockfile.err.value)}); Global.exit(1); } @@ -133,7 +133,7 @@ pub const PackageManagerCommand = struct { if (load_lockfile == .err) { if (pm.options.log_level != .silent) - Output.prettyError("Error loading lockfile: {any}", .{@errorName(load_lockfile.err.value)}); + Output.prettyError("Error loading lockfile: {s}", .{@errorName(load_lockfile.err.value)}); Global.exit(1); } @@ -143,16 +143,16 @@ pub const PackageManagerCommand = struct { var dir: [bun.MAX_PATH_BYTES]u8 = undefined; var fd = pm.getCacheDirectory(); var outpath = std.os.getFdPath(fd.fd, &dir) catch |err| { - Output.prettyErrorln("{any} getting cache directory", .{@errorName(err)}); + Output.prettyErrorln("{s} getting cache directory", .{@errorName(err)}); Global.crash(); }; if (pm.options.positionals.len > 0 and strings.eqlComptime(pm.options.positionals[0], "rm")) { std.fs.deleteTreeAbsolute(outpath) catch |err| { - Output.prettyErrorln("{any} deleting cache directory", .{@errorName(err)}); + Output.prettyErrorln("{s} deleting cache directory", .{@errorName(err)}); Global.crash(); }; - Output.prettyln("Cache directory deleted:\n {any}", .{outpath}); + Output.prettyln("Cache directory deleted:\n {s}", .{outpath}); Global.exit(0); } Output.writer().writeAll(outpath) catch {}; @@ -173,7 +173,7 @@ pub const PackageManagerCommand = struct { , .{}); if (first.len > 0) { - Output.prettyErrorln("\n<red>error<r>: \"{any}\" unknown command\n", .{first}); + Output.prettyErrorln("\n<red>error<r>: \"{s}\" unknown command\n", .{first}); Output.flush(); Global.exit(1); diff --git a/src/cli/run_command.zig b/src/cli/run_command.zig index 7685f466d..161b1362b 100644 --- a/src/cli/run_command.zig +++ b/src/cli/run_command.zig @@ -82,7 +82,7 @@ pub const RunCommand = struct { } const BUN_BIN_NAME = if (Environment.isDebug) "bun-debug" else "bun"; - const BUN_RUN = std.fmt.comptimePrint("{any} run", .{BUN_BIN_NAME}); + const BUN_RUN = std.fmt.comptimePrint("{s} run", .{BUN_BIN_NAME}); // Look for invocations of any: // - yarn run @@ -244,7 +244,7 @@ pub const RunCommand = struct { var child_process = std.ChildProcess.init(&argv, allocator); if (!silent) { - Output.prettyErrorln("<r><d><magenta>$<r> <d><b>{any}<r>", .{combined_script}); + Output.prettyErrorln("<r><d><magenta>$<r> <d><b>{s}<r>", .{combined_script}); Output.flush(); } @@ -257,13 +257,13 @@ pub const RunCommand = struct { child_process.stdout_behavior = .Inherit; const result = child_process.spawnAndWait() catch |err| { - Output.prettyErrorln("<r><red>error<r>: Failed to run script <b>{any}<r> due to error <b>{any}<r>", .{ name, @errorName(err) }); + Output.prettyErrorln("<r><red>error<r>: Failed to run script <b>{s}<r> due to error <b>{s}<r>", .{ name, @errorName(err) }); Output.flush(); return true; }; if (result.Exited > 0) { - Output.prettyErrorln("<r><red>Script error<r> <b>\"{any}\"<r> exited with {d} status<r>", .{ name, result.Exited }); + Output.prettyErrorln("<r><red>Script error<r> <b>\"{s}\"<r> exited with {d} status<r>", .{ name, result.Exited }); Output.flush(); Global.exit(result.Exited); @@ -304,30 +304,30 @@ pub const RunCommand = struct { const rc = bun.C.stat(std.meta.assumeSentinel(executable, 0), &stat); if (rc == 0) { if (std.os.S.ISDIR(stat.mode)) { - Output.prettyErrorln("<r><red>error<r>: Failed to run directory \"<b>{any}<r>\"\n", .{executable}); + Output.prettyErrorln("<r><red>error<r>: Failed to run directory \"<b>{s}<r>\"\n", .{executable}); Global.exit(1); } } } } - Output.prettyErrorln("<r><red>error<r>: Failed to run \"<b>{any}<r>\" due to error <b>{any}<r>", .{ std.fs.path.basename(executable), @errorName(err) }); + Output.prettyErrorln("<r><red>error<r>: Failed to run \"<b>{s}<r>\" due to error <b>{s}<r>", .{ std.fs.path.basename(executable), @errorName(err) }); Global.exit(1); }; switch (result) { .Exited => |code| { - Output.prettyErrorln("<r><red>error<r> \"<b>{any}<r>\" exited with {d} status<r>", .{ std.fs.path.basename(executable), code }); + Output.prettyErrorln("<r><red>error<r> \"<b>{s}<r>\" exited with {d} status<r>", .{ std.fs.path.basename(executable), code }); Global.exit(code); }, .Signal => |sig| { - Output.prettyErrorln("<r><red>error<r> \"<b>{any}<r>\" signaled {d}<r>", .{ std.fs.path.basename(executable), sig }); + Output.prettyErrorln("<r><red>error<r> \"<b>{s}<r>\" signaled {d}<r>", .{ std.fs.path.basename(executable), sig }); Global.exit(1); }, .Stopped => |sig| { - Output.prettyErrorln("<r><red>error<r> \"<b>{any}<r>\" stopped: {d}<r>", .{ std.fs.path.basename(executable), sig }); + Output.prettyErrorln("<r><red>error<r> \"<b>{s}<r>\" stopped: {d}<r>", .{ std.fs.path.basename(executable), sig }); Global.exit(1); }, .Unknown => |sig| { - Output.prettyErrorln("<r><red>error<r> \"<b>{any}<r>\" stopped: {d}<r>", .{ std.fs.path.basename(executable), sig }); + Output.prettyErrorln("<r><red>error<r> \"<b>{s}<r>\" stopped: {d}<r>", .{ std.fs.path.basename(executable), sig }); Global.exit(1); }, } @@ -379,7 +379,7 @@ pub const RunCommand = struct { } else { ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false) catch {}; } - Output.prettyErrorln("Error loading directory: \"{any}\"", .{@errorName(err)}); + Output.prettyErrorln("Error loading directory: \"{s}\"", .{@errorName(err)}); Output.flush(); return err; } orelse { @@ -761,7 +761,7 @@ pub const RunCommand = struct { // "White space after #! is optional." var shebang_buf: [64]u8 = undefined; const shebang_size = file.pread(&shebang_buf, 0) catch |err| { - Output.prettyErrorln("<r><red>error<r>: Failed to read file <b>{any}<r> due to error <b>{any}<r>", .{ file_path, @errorName(err) }); + Output.prettyErrorln("<r><red>error<r>: Failed to read file <b>{s}<r> due to error <b>{s}<r>", .{ file_path, @errorName(err) }); Global.exit(1); }; @@ -786,7 +786,7 @@ pub const RunCommand = struct { ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false) catch {}; } - Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{any}<r> due to error <b>{any}<r>", .{ + Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{ std.fs.path.basename(file_path), @errorName(err), }); @@ -824,11 +824,11 @@ pub const RunCommand = struct { if (scripts.count() > 0) { did_print = true; - Output.prettyln("<r><blue><b>{any}<r> scripts:<r>\n", .{display_name}); + Output.prettyln("<r><blue><b>{s}<r> scripts:<r>\n", .{display_name}); while (iterator.next()) |entry| { Output.prettyln("\n", .{}); - Output.prettyln(" bun run <blue>{any}<r>\n", .{entry.key_ptr.*}); - Output.prettyln(" <d> {any}<r>\n", .{entry.value_ptr.*}); + Output.prettyln(" bun run <blue>{s}<r>\n", .{entry.key_ptr.*}); + Output.prettyln(" <d> {s}<r>\n", .{entry.value_ptr.*}); } Output.prettyln("\n<d>{d} scripts<r>", .{scripts.count()}); @@ -837,7 +837,7 @@ pub const RunCommand = struct { return true; } else { - Output.prettyln("<r><blue><b>{any}<r> has no \"scripts\" in package.json.", .{display_name}); + Output.prettyln("<r><blue><b>{s}<r> has no \"scripts\" in package.json.", .{display_name}); Output.flush(); return true; } @@ -845,7 +845,7 @@ pub const RunCommand = struct { else => { if (scripts.get(script_name_to_search)) |script_content| { // allocate enough to hold "post${scriptname}" - var temp_script_buffer = try std.fmt.allocPrint(ctx.allocator, "ppre{any}", .{script_name_to_search}); + var temp_script_buffer = try std.fmt.allocPrint(ctx.allocator, "ppre{s}", .{script_name_to_search}); if (scripts.get(temp_script_buffer[1..])) |prescript| { if (!try runPackageScript( @@ -918,13 +918,13 @@ pub const RunCommand = struct { // var file = std.fs.openFileAbsoluteZ(destination, .{ .mode = .read_only }) catch |err| { // if (!log_errors) return false; - // Output.prettyErrorln("<r>error: <red>{any}<r> opening file: \"{any}\"", .{ err, std.mem.span(destination) }); + // Output.prettyErrorln("<r>error: <red>{s}<r> opening file: \"{s}\"", .{ err, std.mem.span(destination) }); // Output.flush(); // return err; // }; // // var outbuf = std.os.getFdPath(file.handle, &path_buf2) catch |err| { // // if (!log_errors) return false; - // // Output.prettyErrorln("<r>error: <red>{any}<r> resolving file: \"{any}\"", .{ err, std.mem.span(destination) }); + // // Output.prettyErrorln("<r>error: <red>{s}<r> resolving file: \"{s}\"", .{ err, std.mem.span(destination) }); // // Output.flush(); // // return err; // // }; @@ -943,7 +943,7 @@ pub const RunCommand = struct { } if (comptime log_errors) { - Output.prettyError("<r><red>error:<r> Missing script \"<b>{any}<r>\"\n", .{script_name_to_search}); + Output.prettyError("<r><red>error:<r> Missing script \"<b>{s}<r>\"\n", .{script_name_to_search}); Global.exit(0); } diff --git a/src/cli/test_command.zig b/src/cli/test_command.zig index 5f11ce889..455f51dbe 100644 --- a/src/cli/test_command.zig +++ b/src/cli/test_command.zig @@ -180,7 +180,7 @@ const Scanner = struct { name: strings.StringOrTinyString, }; - fn readDirWithName(this: *Scanner, name: string, handle: ?std.fs.Dir) !*FileSystem.RealFS.EntriesOption { + fn readDirWithName(this: *Scanner, name: string, handle: ?std.fs.IterableDir) !*FileSystem.RealFS.EntriesOption { return try this.fs.fs.readDirectoryWithIterator(name, handle, *Scanner, this); } @@ -215,9 +215,9 @@ const Scanner = struct { var path2 = this.fs.absBuf(parts2, &this.open_dir_buf); this.open_dir_buf[path2.len] = 0; var pathZ = this.open_dir_buf[path2.len - entry.name.slice().len .. path2.len :0]; - var child_dir = dir.openIterableDirZ(pathZ, .{}) catch continue; + var child_dir = bun.openIterableDirZFromDir(dir, pathZ) catch continue; path2 = this.fs.dirname_store.append(string, path2) catch unreachable; - FileSystem.setMaxFd(child_dir.fd); + FileSystem.setMaxFd(child_dir.dir.fd); _ = this.readDirWithName(path2, child_dir) catch continue; } } diff --git a/src/cli/upgrade_command.zig b/src/cli/upgrade_command.zig index 90e3fc376..44230a488 100644 --- a/src/cli/upgrade_command.zig +++ b/src/cli/upgrade_command.zig @@ -62,7 +62,7 @@ pub const Version = struct { return std.fmt.allocPrint( bun.default_allocator, - "bun-canary-timestamp-{any}", + "bun-canary-timestamp-{s}", .{ std.fmt.fmtSliceHexLower( std.mem.asBytes( @@ -92,7 +92,7 @@ pub const Version = struct { const current_version: string = "bun-v" ++ Global.package_json_version; - pub export const Bun__githubURL: [*:0]const u8 = std.fmt.comptimePrint("https://github.com/oven-sh/bun/release/bun-v{any}/{any}", .{ + pub export const Bun__githubURL: [*:0]const u8 = std.fmt.comptimePrint("https://github.com/oven-sh/bun/release/bun-v{s}/{s}", .{ Global.package_json_version, zip_filename, }); @@ -133,7 +133,7 @@ pub const UpgradeCheckerThread = struct { if (!version.isCurrent()) { if (version.name()) |name| { - Output.prettyErrorln("\n<r><d>bun v{any} is out. Run <b><cyan>bun upgrade<r> to upgrade.\n", .{name}); + Output.prettyErrorln("\n<r><d>bun v{s} is out. Run <b><cyan>bun upgrade<r> to upgrade.\n", .{name}); Output.flush(); } } @@ -144,7 +144,7 @@ pub const UpgradeCheckerThread = struct { fn run(env_loader: *DotEnv.Loader) void { _run(env_loader) catch |err| { if (Environment.isDebug) { - std.debug.print("\n[UpgradeChecker] ERROR: {any}\n", .{@errorName(err)}); + std.debug.print("\n[UpgradeChecker] ERROR: {s}\n", .{@errorName(err)}); } }; } @@ -193,7 +193,7 @@ pub const UpgradeCommand = struct { var api_url = URL.parse( try std.fmt.bufPrint( &github_repository_url_buf, - "https://{any}/repos/Jarred-Sumner/bun-releases-for-updater/releases/latest", + "https://{s}/repos/Jarred-Sumner/bun-releases-for-updater/releases/latest", .{ github_api_domain, }, @@ -202,7 +202,7 @@ pub const UpgradeCommand = struct { if (env_loader.map.get("GITHUB_ACCESS_TOKEN")) |access_token| { if (access_token.len > 0) { - headers_buf = try std.fmt.allocPrint(allocator, default_github_headers ++ "Access-TokenBearer {any}", .{access_token}); + headers_buf = try std.fmt.allocPrint(allocator, default_github_headers ++ "Access-TokenBearer {s}", .{access_token}); try header_entries.append( allocator, Headers.Kv{ @@ -262,7 +262,7 @@ pub const UpgradeCommand = struct { } Global.exit(1); } else { - Output.prettyErrorln("Error parsing releases from GitHub: <r><red>{any}<r>", .{@errorName(err)}); + Output.prettyErrorln("Error parsing releases from GitHub: <r><red>{s}<r>", .{@errorName(err)}); Global.exit(1); } } @@ -294,7 +294,7 @@ pub const UpgradeCommand = struct { refresher.refresh(); const json_type: js_ast.Expr.Tag = @as(js_ast.Expr.Tag, expr.data); - Output.prettyErrorln("JSON error - expected an object but received {any}", .{@tagName(json_type)}); + Output.prettyErrorln("JSON error - expected an object but received {s}", .{@tagName(json_type)}); Global.exit(1); } @@ -312,7 +312,7 @@ pub const UpgradeCommand = struct { progress.end(); refresher.refresh(); - Output.prettyErrorln("JSON Error parsing releases from GitHub: <r><red>tag_name<r> is missing?\n{any}", .{metadata_body.list.items}); + Output.prettyErrorln("JSON Error parsing releases from GitHub: <r><red>tag_name<r> is missing?\n{s}", .{metadata_body.list.items}); Global.exit(1); } @@ -327,7 +327,7 @@ pub const UpgradeCommand = struct { if (asset.asProperty("content_type")) |content_type| { const content_type_ = (content_type.expr.asString(allocator)) orelse continue; if (comptime Environment.isDebug) { - Output.prettyln("Content-type: {any}", .{content_type_}); + Output.prettyln("Content-type: {s}", .{content_type_}); Output.flush(); } @@ -338,7 +338,7 @@ pub const UpgradeCommand = struct { if (name_.expr.asString(allocator)) |name| { if (comptime Environment.isDebug) { const filename = if (!use_profile) Version.zip_filename else Version.profile_zip_filename; - Output.prettyln("Comparing {any} vs {any}", .{ name, filename }); + Output.prettyln("Comparing {s} vs {s}", .{ name, filename }); Output.flush(); } @@ -347,7 +347,7 @@ pub const UpgradeCommand = struct { version.zip_url = (asset.asProperty("browser_download_url") orelse break :get_asset).expr.asString(allocator) orelse break :get_asset; if (comptime Environment.isDebug) { - Output.prettyln("Found Zip {any}", .{version.zip_url}); + Output.prettyln("Found Zip {s}", .{version.zip_url}); Output.flush(); } @@ -366,7 +366,7 @@ pub const UpgradeCommand = struct { progress.end(); refresher.refresh(); if (version.name()) |name| { - Output.prettyErrorln("bun v{any} is out, but not for this platform ({any}) yet.", .{ + Output.prettyErrorln("bun v{s} is out, but not for this platform ({s}) yet.", .{ name, Version.triplet, }); } @@ -383,7 +383,7 @@ pub const UpgradeCommand = struct { @setCold(true); _exec(ctx) catch |err| { - Output.prettyErrorln("<r>bun upgrade failed with error: <red><b>{any}<r>\n\n<cyan>Please upgrade manually<r>:\n <b>curl -fsSL https://bun.sh/install | bash<r>\n\n", .{@errorName(err)}); + Output.prettyErrorln("<r>bun upgrade failed with error: <red><b>{s}<r>\n\n<cyan>Please upgrade manually<r>:\n <b>curl -fsSL https://bun.sh/install | bash<r>\n\n", .{@errorName(err)}); Global.exit(1); }; } @@ -425,7 +425,7 @@ pub const UpgradeCommand = struct { if (version.name() != null and version.isCurrent()) { Output.prettyErrorln( - "<r><green>Congrats!<r> You're already on the latest version of bun <d>(which is v{any})<r>", + "<r><green>Congrats!<r> You're already on the latest version of bun <d>(which is v{s})<r>", .{ version.name().?, }, @@ -441,7 +441,7 @@ pub const UpgradeCommand = struct { Global.exit(1); } - Output.prettyErrorln("<r><b>bun <cyan>v{any}<r> is out<r>! You're on <blue>{any}<r>\n", .{ version.name().?, Global.package_json_version }); + Output.prettyErrorln("<r><b>bun <cyan>v{s}<r> is out<r>! You're on <blue>{s}<r>\n", .{ version.name().?, Global.package_json_version }); Output.flush(); } else { version = Version{ @@ -481,7 +481,7 @@ pub const UpgradeCommand = struct { \\<r><red>error:<r> Canary builds are not available for this platform yet \\ \\ Release: <cyan>https://github.com/oven-sh/bun/releases/tag/canary<r> - \\ Filename: <b>{any}<r> + \\ Filename: <b>{s}<r> \\ , .{ Version.zip_filename, @@ -511,10 +511,11 @@ pub const UpgradeCommand = struct { const version_name = version.name().?; var save_dir_ = filesystem.tmpdir(); - var save_dir = save_dir_.makeOpenPathIterable(version_name, .{}) catch { + var save_dir_iterable = save_dir_.makeOpenPathIterable(version_name, .{}) catch { Output.prettyErrorln("<r><red>error:<r> Failed to open temporary directory", .{}); Global.exit(1); }; + var save_dir = save_dir_iterable.dir; var tmpdir_path = std.os.getFdPath(save_dir.fd, &tmpdir_path_buf) catch { Output.prettyErrorln("<r><red>error:<r> Failed to read temporary directory", .{}); Global.exit(1); @@ -529,14 +530,14 @@ pub const UpgradeCommand = struct { if (use_profile) profile_exe_subpath else exe_subpath; var zip_file = save_dir.createFileZ(tmpname, .{ .truncate = true }) catch |err| { - Output.prettyErrorln("<r><red>error:<r> Failed to open temp file {any}", .{@errorName(err)}); + Output.prettyErrorln("<r><red>error:<r> Failed to open temp file {s}", .{@errorName(err)}); Global.exit(1); }; { _ = zip_file.writeAll(bytes) catch |err| { save_dir.deleteFileZ(tmpname) catch {}; - Output.prettyErrorln("<r><red>error:<r> Failed to write to temp file {any}", .{@errorName(err)}); + Output.prettyErrorln("<r><red>error:<r> Failed to write to temp file {s}", .{@errorName(err)}); Global.exit(1); }; zip_file.close(); @@ -572,7 +573,7 @@ pub const UpgradeCommand = struct { const unzip_result = unzip_process.spawnAndWait() catch |err| { save_dir.deleteFileZ(tmpname) catch {}; - Output.prettyErrorln("<r><red>error:<r> Failed to spawn unzip due to {any}.", .{@errorName(err)}); + Output.prettyErrorln("<r><red>error:<r> Failed to spawn unzip due to {s}.", .{@errorName(err)}); Global.exit(1); }; @@ -595,7 +596,7 @@ pub const UpgradeCommand = struct { .max_output_bytes = 512, }) catch |err| { save_dir_.deleteTree(version_name) catch {}; - Output.prettyErrorln("<r><red>error<r> Failed to verify bun {any}<r>)", .{@errorName(err)}); + Output.prettyErrorln("<r><red>error<r> Failed to verify bun {s}<r>)", .{@errorName(err)}); Global.exit(1); }; @@ -617,7 +618,7 @@ pub const UpgradeCommand = struct { save_dir_.deleteTree(version_name) catch {}; Output.prettyErrorln( - "<r><red>error<r>: The downloaded version of bun (<red>{any}<r>) doesn't match the expected version (<b>{any}<r>)<r>. Cancelled upgrade", + "<r><red>error<r>: The downloaded version of bun (<red>{s}<r>) doesn't match the expected version (<b>{s}<r>)<r>. Cancelled upgrade", .{ version_string[0..@min(version_string.len, 512)], version_name, @@ -637,24 +638,25 @@ pub const UpgradeCommand = struct { // safe because the slash will no longer be in use current_executable_buf[target_dir_.len] = 0; var target_dirname = current_executable_buf[0..target_dir_.len :0]; - var target_dir = std.fs.openIterableDirAbsoluteZ(target_dirname, .{}) catch |err| { + var target_dir_iteratable = std.fs.openIterableDirAbsoluteZ(target_dirname, .{}) catch |err| { save_dir_.deleteTree(version_name) catch {}; - Output.prettyErrorln("<r><red>error:<r> Failed to open bun's install directory {any}", .{@errorName(err)}); + Output.prettyErrorln("<r><red>error:<r> Failed to open bun's install directory {s}", .{@errorName(err)}); Global.exit(1); }; + var target_dir = target_dir_iteratable.dir; if (use_canary) { // Check if the versions are the same const target_stat = target_dir.statFile(target_filename) catch |err| { save_dir_.deleteTree(version_name) catch {}; - Output.prettyErrorln("<r><red>error:<r> Failed to stat target bun {any}", .{@errorName(err)}); + Output.prettyErrorln("<r><red>error:<r> Failed to stat target bun {s}", .{@errorName(err)}); Global.exit(1); }; const dest_stat = save_dir.statFile(exe) catch |err| { save_dir_.deleteTree(version_name) catch {}; - Output.prettyErrorln("<r><red>error:<r> Failed to stat source bun {any}", .{@errorName(err)}); + Output.prettyErrorln("<r><red>error:<r> Failed to stat source bun {s}", .{@errorName(err)}); Global.exit(1); }; @@ -663,13 +665,13 @@ pub const UpgradeCommand = struct { const target_hash = std.hash.Wyhash.hash(0, target_dir.readFile(target_filename, input_buf) catch |err| { save_dir_.deleteTree(version_name) catch {}; - Output.prettyErrorln("<r><red>error:<r> Failed to read target bun {any}", .{@errorName(err)}); + Output.prettyErrorln("<r><red>error:<r> Failed to read target bun {s}", .{@errorName(err)}); Global.exit(1); }); const source_hash = std.hash.Wyhash.hash(0, save_dir.readFile(exe, input_buf) catch |err| { save_dir_.deleteTree(version_name) catch {}; - Output.prettyErrorln("<r><red>error:<r> Failed to read source bun {any}", .{@errorName(err)}); + Output.prettyErrorln("<r><red>error:<r> Failed to read source bun {s}", .{@errorName(err)}); Global.exit(1); }); @@ -687,7 +689,7 @@ pub const UpgradeCommand = struct { if (env_loader.map.get("BUN_DRY_RUN") == null) { C.moveFileZ(save_dir.fd, exe, target_dir.fd, target_filename) catch |err| { save_dir_.deleteTree(version_name) catch {}; - Output.prettyErrorln("<r><red>error:<r> Failed to move new version of bun due to {any}. You could try the install script instead:\n curl -fsSL https://bun.sh/install | bash", .{@errorName(err)}); + Output.prettyErrorln("<r><red>error:<r> Failed to move new version of bun due to {s}. You could try the install script instead:\n curl -fsSL https://bun.sh/install | bash", .{@errorName(err)}); Global.exit(1); }; } @@ -724,7 +726,7 @@ pub const UpgradeCommand = struct { \\ \\Changelog: \\ - \\ https://github.com/oven-sh/bun/compare/{any}...main + \\ https://github.com/oven-sh/bun/compare/{s}...main \\ , .{Environment.git_sha}, @@ -735,7 +737,7 @@ pub const UpgradeCommand = struct { Output.prettyErrorln( \\<r> Upgraded. \\ - \\<b><green>Welcome to bun v{any}!<r> + \\<b><green>Welcome to bun v{s}!<r> \\ \\Report any bugs: \\ @@ -743,11 +745,11 @@ pub const UpgradeCommand = struct { \\ \\What's new: \\ - \\ <cyan>https://github.com/oven-sh/bun/releases/tag/{any}<r> + \\ <cyan>https://github.com/oven-sh/bun/releases/tag/{s}<r> \\ \\Changelog: \\ - \\ https://github.com/oven-sh/bun/compare/{any}...{any} + \\ https://github.com/oven-sh/bun/compare/{s}...{s} \\ , .{ version_name, version.tag, bun_v, version.tag }, diff --git a/src/comptime_string_map.zig b/src/comptime_string_map.zig index 1c159d2e8..b19e2f5f8 100644 --- a/src/comptime_string_map.zig +++ b/src/comptime_string_map.zig @@ -8,7 +8,7 @@ const strings = @import("./string_immutable.zig"); /// /// `kvs` expects a list literal containing list literals or an array/slice of structs /// where `.@"0"` is the `[]const u8` key and `.@"1"` is the associated value of type `V`. -/// TODO: https://github.com/ziglang/zig/issues/4335 + pub fn ComptimeStringMapWithKeyType(comptime KeyType: type, comptime V: type, comptime kvs_list: anytype) type { const KV = struct { key: []const KeyType, diff --git a/src/defines.zig b/src/defines.zig index ce3410204..a0c885f34 100644 --- a/src/defines.zig +++ b/src/defines.zig @@ -79,9 +79,9 @@ pub const DefineData = struct { while (splitter.next()) |part| { if (!js_lexer.isIdentifier(part)) { if (strings.eql(part, entry.key_ptr)) { - try log.addErrorFmt(null, logger.Loc{}, allocator, "define key \"{any}\" must be a valid identifier", .{entry.key_ptr.*}); + try log.addErrorFmt(null, logger.Loc{}, allocator, "define key \"{s}\" must be a valid identifier", .{entry.key_ptr.*}); } else { - try log.addErrorFmt(null, logger.Loc{}, allocator, "define key \"{any}\" contains invalid identifier \"{any}\"", .{ part, entry.value_ptr.* }); + try log.addErrorFmt(null, logger.Loc{}, allocator, "define key \"{s}\" contains invalid identifier \"{s}\"", .{ part, entry.value_ptr.* }); } break; } diff --git a/src/deps/picohttp.zig b/src/deps/picohttp.zig index 115cc976b..d9c4ad2cb 100644 --- a/src/deps/picohttp.zig +++ b/src/deps/picohttp.zig @@ -21,15 +21,15 @@ pub const Header = struct { pub fn format(self: Header, comptime _: []const u8, _: fmt.FormatOptions, writer: anytype) !void { if (Output.enable_ansi_colors) { if (self.isMultiline()) { - try fmt.format(writer, comptime Output.prettyFmt("<r><cyan>{any}", true), .{self.value}); + try fmt.format(writer, comptime Output.prettyFmt("<r><cyan>{s}", true), .{self.value}); } else { - try fmt.format(writer, comptime Output.prettyFmt("<r><cyan>{any}<r><d>: <r>{any}", true), .{ self.name, self.value }); + try fmt.format(writer, comptime Output.prettyFmt("<r><cyan>{s}<r><d>: <r>{s}", true), .{ self.name, self.value }); } } else { if (self.isMultiline()) { - try fmt.format(writer, comptime Output.prettyFmt("<r><cyan>{any}", false), .{self.value}); + try fmt.format(writer, comptime Output.prettyFmt("<r><cyan>{s}", false), .{self.value}); } else { - try fmt.format(writer, comptime Output.prettyFmt("<r><cyan>{any}<r><d>: <r>{any}", false), .{ self.name, self.value }); + try fmt.format(writer, comptime Output.prettyFmt("<r><cyan>{s}<r><d>: <r>{s}", false), .{ self.name, self.value }); } } } @@ -74,7 +74,7 @@ pub const Request = struct { } pub fn format(self: Request, comptime _: []const u8, _: fmt.FormatOptions, writer: anytype) !void { - try fmt.format(writer, "{any} {any}\n", .{ self.method, self.path }); + try fmt.format(writer, "{any} {s}\n", .{ self.method, self.path }); for (self.headers) |header| { _ = try writer.write("\t"); try fmt.format(writer, "{any}\n", .{header}); diff --git a/src/deps/zig-clap/clap.zig b/src/deps/zig-clap/clap.zig index 17ce0c7da..a05703d3f 100644 --- a/src/deps/zig-clap/clap.zig +++ b/src/deps/zig-clap/clap.zig @@ -221,13 +221,13 @@ pub const Diagnostic = struct { Arg{ .prefix = "", .name = diag.arg }; switch (err) { - error.DoesntTakeValue => try stream.print("The argument '{any}{any}' does not take a value\n", .{ a.prefix, a.name }), - error.MissingValue => try stream.print("The argument '{any}{any}' requires a value but none was supplied\n", .{ a.prefix, a.name }), + error.DoesntTakeValue => try stream.print("The argument '{s}{s}' does not take a value\n", .{ a.prefix, a.name }), + error.MissingValue => try stream.print("The argument '{s}{s}' requires a value but none was supplied\n", .{ a.prefix, a.name }), error.InvalidArgument => if (a.prefix.len > 0 and a.name.len > 0) - try stream.print("Invalid argument '{any}{any}'\n", .{ a.prefix, a.name }) + try stream.print("Invalid argument '{s}{s}'\n", .{ a.prefix, a.name }) else try stream.print("Failed to parse argument due to unexpected single dash\n", .{}), - else => try stream.print("Error while parsing arguments: {any}\n", .{@errorName(err)}), + else => try stream.print("Error while parsing arguments: {s}\n", .{@errorName(err)}), } } }; @@ -386,9 +386,9 @@ fn printParam( switch (param.takes_value) { .none => {}, - .one => try stream.print(" <{any}>", .{valueText(context, param)}), - .one_optional => try stream.print(" <{any}>?", .{valueText(context, param)}), - .many => try stream.print(" <{any}>...", .{valueText(context, param)}), + .one => try stream.print(" <{s}>", .{try valueText(context, param)}), + .one_optional => try stream.print(" <{s}>?", .{try valueText(context, param)}), + .many => try stream.print(" <{s}>...", .{try valueText(context, param)}), } } @@ -489,12 +489,12 @@ pub fn usageFull( if (cos.bytes_written != 0) try cs.writeByte(' '); - try cs.print("[{any}{any}", .{ prefix, name }); + try cs.print("[{s}{s}", .{ prefix, name }); switch (param.takes_value) { .none => {}, - .one => try cs.print(" <{any}>", .{try valueText(context, param)}), - .one_optional => try cs.print(" <{any}>?", .{try valueText(context, param)}), - .many => try cs.print(" <{any}>...", .{try valueText(context, param)}), + .one => try cs.print(" <{s}>", .{try valueText(context, param)}), + .one_optional => try cs.print(" <{s}>?", .{try valueText(context, param)}), + .many => try cs.print(" <{s}>...", .{try valueText(context, param)}), } try cs.writeByte(']'); @@ -503,7 +503,7 @@ pub fn usageFull( if (positional) |p| { if (cos.bytes_written != 0) try cs.writeByte(' '); - try cs.print("<{any}>", .{try valueText(context, p)}); + try cs.print("<{s}>", .{try valueText(context, p)}); } } diff --git a/src/env_loader.zig b/src/env_loader.zig index 5363a443e..1d6018088 100644 --- a/src/env_loader.zig +++ b/src/env_loader.zig @@ -534,7 +534,7 @@ pub const Loader = struct { const value: string = entry.value_ptr.*; if (strings.startsWith(entry.key_ptr.*, prefix)) { - const key_str = std.fmt.allocPrint(key_allocator, "process.env.{any}", .{entry.key_ptr.*}) catch unreachable; + const key_str = std.fmt.allocPrint(key_allocator, "process.env.{s}", .{entry.key_ptr.*}) catch unreachable; e_strings[0] = js_ast.E.String{ .data = if (value.len > 0) @@ -720,9 +720,9 @@ pub const Loader = struct { if (yes) { loaded_i += 1; if (count == 1 or (loaded_i >= count and count > 1)) { - Output.prettyError("\"{any}\"", .{all[i]}); + Output.prettyError("\"{s}\"", .{all[i]}); } else { - Output.prettyError("\"{any}\", ", .{all[i]}); + Output.prettyError("\"{s}\", ", .{all[i]}); } } } @@ -744,7 +744,7 @@ pub const Loader = struct { }, error.FileBusy, error.DeviceBusy, error.AccessDenied, error.IsDir => { if (!this.quiet) { - Output.prettyErrorln("<r><red>{any}<r> error loading {any} file", .{ @errorName(err), base }); + Output.prettyErrorln("<r><red>{s}<r> error loading {s} file", .{ @errorName(err), base }); } // prevent retrying diff --git a/src/feature_flags.zig b/src/feature_flags.zig index 3d016efb6..602d14fbd 100644 --- a/src/feature_flags.zig +++ b/src/feature_flags.zig @@ -105,3 +105,5 @@ pub const disable_lolhtml = false; /// other ipv4 hosts. This is a workaround for that. /// "localhost" fails to connect. pub const hardcode_localhost_to_127_0_0_1 = true; + +pub const dump_recv_to_stdout = true; diff --git a/src/fs.zig b/src/fs.zig index 97e296074..a421803a6 100644 --- a/src/fs.zig +++ b/src/fs.zig @@ -67,7 +67,7 @@ pub const BytecodeCacheFetcher = struct { this.fd = @truncate(StoredFileDescriptorType, cache_file.handle); return @truncate(StoredFileDescriptorType, cache_file.handle); } else |err| { - Output.prettyWarnln("<r><yellow>Warn<r>: Bytecode caching unavailable due to error: {any}", .{@errorName(err)}); + Output.prettyWarnln("<r><yellow>Warn<r>: Bytecode caching unavailable due to error: {s}", .{@errorName(err)}); Output.flush(); this.fd = 0; return null; @@ -103,7 +103,7 @@ pub const FileSystem = struct { pub fn tmpdir(fs: *FileSystem) std.fs.Dir { if (tmpdir_handle == null) { - tmpdir_handle = fs.fs.openTmpDir() catch unreachable; + tmpdir_handle = (fs.fs.openTmpDir() catch unreachable).dir; } return tmpdir_handle.?; @@ -117,7 +117,7 @@ pub const FileSystem = struct { pub fn tmpname(_: *const FileSystem, extname: string, buf: []u8, hash: u64) ![*:0]u8 { // PRNG was...not so random - return try std.fmt.bufPrintZ(buf, ".{x}{any}", .{ @truncate(u64, @intCast(u128, hash) * @intCast(u128, std.time.nanoTimestamp())), extname }); + return try std.fmt.bufPrintZ(buf, ".{any}{s}", .{ bun.fmt.x(@truncate(u64, @intCast(u128, hash) * @intCast(u128, std.time.nanoTimestamp()))), extname }); } pub var max_fd: FileDescriptorType = 0; @@ -256,16 +256,16 @@ pub const FileSystem = struct { if (comptime FeatureFlags.verbose_fs) { if (_kind == .dir) { - Output.prettyln(" + {any}/", .{stored_name}); + Output.prettyln(" + {s}/", .{stored_name}); } else { - Output.prettyln(" + {any}", .{stored_name}); + Output.prettyln(" + {s}", .{stored_name}); } } } pub fn init(dir: string) DirEntry { if (comptime FeatureFlags.verbose_fs) { - Output.prettyln("\n {any}", .{dir}); + Output.prettyln("\n {s}", .{dir}); } return DirEntry{ .dir = dir, .data = EntryMap{} }; @@ -561,7 +561,7 @@ pub const FileSystem = struct { pub var tmpdir_path: []const u8 = undefined; pub var tmpdir_path_set = false; - pub fn openTmpDir(_: *const RealFS) !std.fs.Dir { + pub fn openTmpDir(_: *const RealFS) !std.fs.IterableDir { if (!tmpdir_path_set) { tmpdir_path = std.os.getenvZ("BUN_TMPDIR") orelse std.os.getenvZ("TMPDIR") orelse PLATFORM_TMP_DIR; tmpdir_path_set = true; @@ -611,8 +611,8 @@ pub const FileSystem = struct { var tmpdir_ = try rfs.openTmpDir(); const flags = std.os.O.CREAT | std.os.O.RDWR | std.os.O.CLOEXEC; - this.dir_fd = tmpdir_.fd; - this.fd = try std.os.openatZ(tmpdir_.fd, name, flags, std.os.S.IRWXO); + this.dir_fd = tmpdir_.dir.fd; + this.fd = try std.os.openatZ(tmpdir_.dir.fd, name, flags, std.os.S.IRWXO); } pub fn promote(this: *Tmpfile, from_name: [*:0]const u8, destination_fd: std.os.fd_t, name: [*:0]const u8) !void { @@ -729,10 +729,10 @@ pub const FileSystem = struct { ) !string { return try std.fmt.bufPrint( &hash_name_buf, - "{any}-{x}", + "{s}-{any}", .{ basename, - this.hash(), + bun.fmt.x(this.hash()), }, ); } @@ -1285,7 +1285,7 @@ pub const Path = struct { } pub fn generateKey(p: *Path, allocator: std.mem.Allocator) !string { - return try std.fmt.allocPrint(allocator, "{any}://{any}", .{ p.namespace, p.text }); + return try std.fmt.allocPrint(allocator, "{s}://{s}", .{ p.namespace, p.text }); } pub fn init(text: string) Path { diff --git a/src/global.zig b/src/global.zig index fe4f5246a..ff0d7a450 100644 --- a/src/global.zig +++ b/src/global.zig @@ -31,6 +31,55 @@ pub const path = @import("./resolver/resolve_path.zig"); pub const fmt = struct { pub usingnamespace std.fmt; +fn formatSliceHexImpl(comptime case: fmt.Case) type { + const charset = "0123456789" ++ if (case == .upper) "ABCDEF" else "abcdef"; + + return struct { + pub fn f( + bytes: []const u8, + comptime _: []const u8, + _: std.fmt.FormatOptions, + writer: anytype, + ) !void { + var buf: [2]u8 = undefined; + + for (bytes) |c| { + buf[0] = charset[c >> 4]; + buf[1] = charset[c & 15]; + try writer.writeAll(&buf); + } + } + }; +} + + +const formatSliceHexLower = formatSliceHexImpl(.lower).f; +const formatSliceHexUpper = formatSliceHexImpl(.upper).f; + + + + + + pub fn x(to_lower_hex: anytype) std.fmt.Formatter(formatSliceHexLower) { + return std.fmt.Formatter(formatSliceHexLower){.data = asBytesWithType(@TypeOf(to_lower_hex), to_lower_hex)}; + } + + fn asBytesWithType(comptime Type: type, value: Type) []const u8 { + if (comptime Type == i64 or Type == u64 or Type == f64) { + return @bitCast([8]u8, value)[0..]; + } else if (comptime Type == i32 or Type == u32 or Type == f32) { + return @bitCast([4]u8, value)[0..]; + } else if (comptime Type == i16 or Type == u16) { + return @bitCast([2]u8, value)[0..]; + } else if (comptime Type == i8 or Type == u8) { + return @bitCast([1]u8, value)[0..]; + } else { + return std.mem.asBytes(value); + } + + } + + pub const SizeFormatter = struct { value: usize = 0, pub fn format(self: SizeFormatter, comptime _: []const u8, opts: fmt.FormatOptions, writer: anytype) !void { @@ -378,3 +427,26 @@ pub const Bunfig = @import("./bunfig.zig").Bunfig; pub const HTTPThead = @import("./http_client_async.zig").HTTPThread; pub const Analytics = @import("./analytics/analytics_thread.zig"); + + +pub fn allocateFrame(comptime Type: type) error{OutOfMemory}!Type { + const Mimalloc = @import("./memory_allocator.zig"); + if (Mimalloc.alignedAlloc(@sizeOf(Type), @alignOf(Type))) |ptr| { + return @ptrCast(*Type, ptr); + } else { + return error.OutOfMemory; + } +} + +pub fn openIterableDirZ(fd: std.os.fd_t, path_: [:0]const u8) !std.fs.IterableDir { + const dir_fd = try std.os.openatZ(fd, path_, std.os.O.DIRECTORY, 0); + return std.fs.IterableDir{.dir = .{.fd = dir_fd} }; +} + +pub fn openIterableDirZFromDir(dir: std.fs.Dir, path_: [:0]const u8) !std.fs.IterableDir { + return openIterableDirZ(dir.fd, path_); +} + +pub fn openIterableDirZFromIterableDir(dir: std.fs.IterableDir, path_: [:0]const u8) !std.fs.IterableDir { + return openIterableDirZFromIterableDir(dir.dir, path_); +}
\ No newline at end of file diff --git a/src/http.zig b/src/http.zig index e22e94cc0..907801e5b 100644 --- a/src/http.zig +++ b/src/http.zig @@ -238,14 +238,14 @@ pub const RequestContext = struct { display_port = "80"; } } - this.origin = ZigURL.parse(std.fmt.allocPrint(this.allocator, "{any}://{any}:{any}/", .{ display_protocol, display_host, display_port }) catch unreachable); + this.origin = ZigURL.parse(std.fmt.allocPrint(this.allocator, "{s}://{s}:{s}/", .{ display_protocol, display_host, display_port }) catch unreachable); } } pub fn getFullURL(this: *RequestContext) [:0]const u8 { if (this.full_url.len == 0) { if (this.origin.isAbsolute()) { - this.full_url = std.fmt.allocPrintZ(this.allocator, "{any}{any}", .{ this.origin.origin, this.request.path }) catch unreachable; + this.full_url = std.fmt.allocPrintZ(this.allocator, "{s}{s}", .{ this.origin.origin, this.request.path }) catch unreachable; } else { this.full_url = this.allocator.dupeZ(u8, this.request.path) catch unreachable; } @@ -257,9 +257,9 @@ pub const RequestContext = struct { pub fn getFullURLForSourceMap(this: *RequestContext) [:0]const u8 { if (this.full_url.len == 0) { if (this.origin.isAbsolute()) { - this.full_url = std.fmt.allocPrintZ(this.allocator, "{any}{any}.map", .{ this.origin.origin, this.request.path }) catch unreachable; + this.full_url = std.fmt.allocPrintZ(this.allocator, "{s}{s}.map", .{ this.origin.origin, this.request.path }) catch unreachable; } else { - this.full_url = std.fmt.allocPrintZ(this.allocator, "{any}.map", .{this.request.path}) catch unreachable; + this.full_url = std.fmt.allocPrintZ(this.allocator, "{s}.map", .{this.request.path}) catch unreachable; } } @@ -378,7 +378,7 @@ pub const RequestContext = struct { if (this.bundler.options.node_modules_bundle_url.len > 0) { add_preload: { - const node_modules_preload_header_value = std.fmt.bufPrint(remaining, "<{any}>; rel=modulepreload", .{ + const node_modules_preload_header_value = std.fmt.bufPrint(remaining, "<{s}>; rel=modulepreload", .{ this.bundler.options.node_modules_bundle_url, }) catch break :add_preload; @@ -480,8 +480,8 @@ pub const RequestContext = struct { // On Windows, we don't keep the directory handle open forever because Windows doesn't like that. const public_dir: std.fs.Dir = this.bundler.options.routes.static_dir_handle orelse std.fs.openDirAbsolute(this.bundler.options.routes.static_dir, .{}) catch |err| { - this.bundler.log.addErrorFmt(null, logger.Loc.Empty, this.allocator, "Opening public directory failed: {any}", .{@errorName(err)}) catch unreachable; - Output.printErrorln("Opening public directory failed: {any}", .{@errorName(err)}); + this.bundler.log.addErrorFmt(null, logger.Loc.Empty, this.allocator, "Opening public directory failed: {s}", .{@errorName(err)}) catch unreachable; + Output.printErrorln("Opening public directory failed: {s}", .{@errorName(err)}); this.bundler.options.routes.static_dir_enabled = false; return null; }; @@ -618,7 +618,7 @@ pub const RequestContext = struct { } pub fn printStatusLineError(err: anyerror, buf: []u8) []const u8 { - return std.fmt.bufPrint(buf, "HTTP/1.1 500 {any}\r\n", .{@errorName(err)}) catch unreachable; + return std.fmt.bufPrint(buf, "HTTP/1.1 500 {s}\r\n", .{@errorName(err)}) catch unreachable; } pub fn prepareToSendBody( @@ -685,7 +685,7 @@ pub const RequestContext = struct { return error.SocketClosed; } - Output.prettyErrorln("send() error: {any}", .{err.toSystemError().message.slice()}); + Output.prettyErrorln("send() error: {s}", .{err.toSystemError().message.slice()}); return erro; }, @@ -785,9 +785,9 @@ pub const RequestContext = struct { pub fn sendInternalError(ctx: *RequestContext, err: anytype) !void { defer ctx.done(); try ctx.writeStatusError(err); - const printed = std.fmt.bufPrint(&error_buf, "error: {any}\nPlease see your terminal for more details", .{@errorName(err)}) catch |err2| brk: { + const printed = std.fmt.bufPrint(&error_buf, "error: {s}\nPlease see your terminal for more details", .{@errorName(err)}) catch |err2| brk: { if (Environment.isDebug or Environment.isTest) { - Global.panic("error while printing error: {any}", .{@errorName(err2)}); + Global.panic("error while printing error: {s}", .{@errorName(err2)}); } break :brk "Internal error"; @@ -913,7 +913,7 @@ pub const RequestContext = struct { defer ctx.done(); const stats = file.stat() catch |err| { - Output.prettyErrorln("<r><red>Error {any}<r> reading index.html", .{@errorName(err)}); + Output.prettyErrorln("<r><red>Error {s}<r> reading index.html", .{@errorName(err)}); ctx.writeStatus(500) catch {}; return; }; @@ -1223,7 +1223,7 @@ pub const RequestContext = struct { step, err, - "<r>JavaScript VM failed to start due to <red>{any}<r>.", + "<r>JavaScript VM failed to start due to <red>{s}<r>.", .{ @errorName(err), }, @@ -1390,7 +1390,7 @@ pub const RequestContext = struct { handler.handleJSErrorFmt( .load_entry_point, err, - "<r>JavaScript VM failed to start.\n<red>{any}:<r> while loading <r><b>\"{any}\"", + "<r>JavaScript VM failed to start.\n<red>{s}:<r> while loading <r><b>\"{s}\"", .{ @errorName(err), entry_point }, ) catch {}; vm.flush(); @@ -1406,7 +1406,7 @@ pub const RequestContext = struct { handler.handleRuntimeJSError( result, .eval_entry_point, - "<r>JavaScript VM failed to start.\nwhile loading <r><b>\"{any}\"", + "<r>JavaScript VM failed to start.\nwhile loading <r><b>\"{s}\"", .{entry_point}, ) catch {}; vm.flush(); @@ -1435,7 +1435,7 @@ pub const RequestContext = struct { if (vm.bundler.options.framework.?.display_name.len > 0) { Output.prettyError( - " {any} ready<d>! (powered by bun)\n<r>", + " {s} ready<d>! (powered by bun)\n<r>", .{ vm.bundler.options.framework.?.display_name, }, @@ -1519,7 +1519,7 @@ pub const RequestContext = struct { handler.handleJSErrorFmt( .resolve_entry_point, error.EntryPointDisabled, - "<r>JavaScript VM failed to start due to disabled entry point: <r><b>\"{any}\"", + "<r>JavaScript VM failed to start due to disabled entry point: <r><b>\"{s}\"", .{resolved_entry_point.path_pair.primary.text}, ) catch {}; javascript_disabled = true; @@ -1914,7 +1914,7 @@ pub const RequestContext = struct { defer Output.flush(); handler.conn.client.getError() catch |err| { - Output.prettyErrorln("<r><red>Websocket ERR:<r> <b>{any}<r>", .{err}); + Output.prettyErrorln("<r><red>Websocket ERR:<r> <b>{s}<r>", .{@errorName(err)}); handler.tombstone = true; is_socket_closed = true; }; @@ -1928,7 +1928,7 @@ pub const RequestContext = struct { continue; }, else => { - Output.prettyErrorln("<r><red>Websocket ERR:<r> <b>{any}<r>", .{err}); + Output.prettyErrorln("<r><red>Websocket ERR:<r> <b>{s}<r>", .{@errorName(err)}); }, } return; @@ -1962,7 +1962,7 @@ pub const RequestContext = struct { ); if (Watcher.getHash(file_path) != full_build.id) { - Output.prettyErrorln("<r><red>ERR:<r> <b>File path hash mismatch for {any}.<r>", .{full_build.file_path}); + Output.prettyErrorln("<r><red>ERR:<r> <b>File path hash mismatch for {s}.<r>", .{full_build.file_path}); continue; } // save because WebSocket's buffer is 8096 @@ -1971,7 +1971,7 @@ pub const RequestContext = struct { path_buf.ptr[path_buf.len] = 0; var file_path_z: [:0]u8 = path_buf.ptr[0..path_buf.len :0]; const file = std.fs.openFileAbsoluteZ(file_path_z, .{ .mode = .read_only }) catch |err| { - Output.prettyErrorln("<r><red>ERR:<r>{any} opening file <b>{any}<r> <r>", .{ @errorName(err), full_build.file_path }); + Output.prettyErrorln("<r><red>ERR:<r>{s} opening file <b>{s}<r> <r>", .{ @errorName(err), full_build.file_path }); continue; }; Fs.FileSystem.setMaxFd(file.handle); @@ -2040,7 +2040,7 @@ pub const RequestContext = struct { switch (build_result.value) { .fail => { Output.prettyErrorln( - "error: <b>{any}<r><b>", + "error: <b>{s}<r><b>", .{ file_path, }, @@ -2049,7 +2049,7 @@ pub const RequestContext = struct { .success => { if (build_result.timestamp > cmd.timestamp) { Output.prettyErrorln( - "<r><b><green>{d}ms<r> <d>built<r> <b>{any}<r><b> <r><d>({d}+ LOC)", + "<r><b><green>{d}ms<r> <d>built<r> <b>{s}<r><b> <r><d>({d}+ LOC)", .{ build_result.timestamp - cmd.timestamp, file_path, @@ -2123,7 +2123,7 @@ pub const RequestContext = struct { _ = try handler.websocket.writeDataFrame(pong); }, else => { - Output.prettyErrorln("Websocket unknown opcode: {any}", .{@tagName(frame.header.opcode)}); + Output.prettyErrorln("Websocket unknown opcode: {s}", .{@tagName(frame.header.opcode)}); }, } } @@ -2162,7 +2162,7 @@ pub const RequestContext = struct { }; // this error is noisy // return std.fmt.parseInt(u8, v, 10) catch { - // Output.prettyErrorln("HMR WebSocket error: Sec-WebSocket-Version is invalid {any}", .{v}); + // Output.prettyErrorln("HMR WebSocket error: Sec-WebSocket-Version is invalid {s}", .{v}); // return error.BadRequest; // }; } @@ -2173,7 +2173,7 @@ pub const RequestContext = struct { var request: *RequestContext = &self.ctx; const key = (request.header("Sec-WebSocket-Key") orelse return error.BadRequest); if (key.len < 8) { - Output.prettyErrorln("HMR WebSocket error: Sec-WebSocket-Key is less than 8 characters long: {any}", .{key}); + Output.prettyErrorln("HMR WebSocket error: Sec-WebSocket-Key is less than 8 characters long: {s}", .{key}); return error.BadRequest; } @@ -2584,7 +2584,7 @@ pub const RequestContext = struct { )) { if (ctx.watcher.watchloop_handle == null) { ctx.watcher.start() catch |err| { - Output.prettyErrorln("Failed to start watcher: {any}", .{@errorName(err)}); + Output.prettyErrorln("Failed to start watcher: {s}", .{@errorName(err)}); }; } } else |_| {} @@ -2982,7 +2982,7 @@ pub const RequestContext = struct { if (editor != .none) { editor.open(http_editor_context.path, path.text, line, column, bun.default_allocator) catch |err| { if (editor != .other) { - Output.prettyErrorln("Error {any} opening in {any}", .{ @errorName(err), @tagName(editor) }); + Output.prettyErrorln("Error {s} opening in {s}", .{ @errorName(err), @tagName(editor) }); } http_editor_context.editor = Editor.none; @@ -3006,7 +3006,7 @@ pub const RequestContext = struct { resolve_result.file_fd else brk: { var file = std.fs.openFileAbsoluteZ(path.textZ(), .{ .mode = .read_only }) catch |err| { - Output.prettyErrorln("Failed to open {any} due to error {any}", .{ path.text, @errorName(err) }); + Output.prettyErrorln("Failed to open {s} due to error {s}", .{ path.text, @errorName(err) }); return try ctx.sendInternalError(err); }; needs_close = true; @@ -3021,7 +3021,7 @@ pub const RequestContext = struct { const content_length = brk: { var file = std.fs.File{ .handle = fd }; var stat = file.stat() catch |err| { - Output.prettyErrorln("Failed to read {any} due to error {any}", .{ path.text, @errorName(err) }); + Output.prettyErrorln("Failed to read {s} due to error {s}", .{ path.text, @errorName(err) }); return try ctx.sendInternalError(err); }; break :brk stat.size; @@ -3314,7 +3314,7 @@ pub const Server = struct { var hinted_content_fbs = std.io.fixedBufferStream(filechange_buf_hinted[header.len..]); if (comptime Environment.isDebug) { - Output.prettyErrorln("[watcher] {any}: -- {}", .{ @tagName(kind), event.op }); + Output.prettyErrorln("[watcher] {s}: -- {}", .{ @tagName(kind), event.op }); } switch (kind) { @@ -3328,7 +3328,7 @@ pub const Server = struct { ); if (comptime FeatureFlags.verbose_watcher) { - Output.prettyErrorln("<r><d>File changed: {any}<r>", .{ctx.bundler.fs.relativeTo(file_path)}); + Output.prettyErrorln("<r><d>File changed: {s}<r>", .{ctx.bundler.fs.relativeTo(file_path)}); } } else { const change_message = Api.WebsocketMessageFileChangeNotification{ @@ -3341,12 +3341,12 @@ pub const Server = struct { const change_buf = content_fbs.getWritten(); const written_buf = filechange_buf[0 .. header.len + change_buf.len]; RequestContext.WebsocketHandler.broadcast(written_buf) catch |err| { - Output.prettyErrorln("Error writing change notification: {any}<r>", .{@errorName(err)}); + Output.prettyErrorln("Error writing change notification: {s}<r>", .{@errorName(err)}); }; if (comptime is_emoji_enabled) { - Output.prettyErrorln("<r>📜 <d>File change: {any}<r>", .{ctx.bundler.fs.relativeTo(file_path)}); + Output.prettyErrorln("<r>📜 <d>File change: {s}<r>", .{ctx.bundler.fs.relativeTo(file_path)}); } else { - Output.prettyErrorln("<r> <d>File change: {any}<r>", .{ctx.bundler.fs.relativeTo(file_path)}); + Output.prettyErrorln("<r> <d>File change: {s}<r>", .{ctx.bundler.fs.relativeTo(file_path)}); } } }, @@ -3411,12 +3411,12 @@ pub const Server = struct { const change_buf = hinted_content_fbs.getWritten(); const written_buf = filechange_buf_hinted[0 .. header.len + change_buf.len]; RequestContext.WebsocketHandler.broadcast(written_buf) catch |err| { - Output.prettyErrorln("Error writing change notification: {any}<r>", .{@errorName(err)}); + Output.prettyErrorln("Error writing change notification: {s}<r>", .{@errorName(err)}); }; if (comptime is_emoji_enabled) { - Output.prettyErrorln("<r>📜 <d>File change: {any}<r>", .{ctx.bundler.fs.relativeTo(abs_path)}); + Output.prettyErrorln("<r>📜 <d>File change: {s}<r>", .{ctx.bundler.fs.relativeTo(abs_path)}); } else { - Output.prettyErrorln("<r> <d>File change: {any}<r>", .{ctx.bundler.fs.relativeTo(abs_path)}); + Output.prettyErrorln("<r> <d>File change: {s}<r>", .{ctx.bundler.fs.relativeTo(abs_path)}); } } } @@ -3425,9 +3425,9 @@ pub const Server = struct { // if (event.op.delete or event.op.rename) // ctx.watcher.removeAtIndex(event.index, hashes[event.index], parent_hashes, .directory); if (comptime is_emoji_enabled) { - Output.prettyErrorln("<r>📁 <d>Dir change: {any}<r>", .{ctx.bundler.fs.relativeTo(file_path)}); + Output.prettyErrorln("<r>📁 <d>Dir change: {s}<r>", .{ctx.bundler.fs.relativeTo(file_path)}); } else { - Output.prettyErrorln("<r> <d>Dir change: {any}<r>", .{ctx.bundler.fs.relativeTo(file_path)}); + Output.prettyErrorln("<r> <d>Dir change: {s}<r>", .{ctx.bundler.fs.relativeTo(file_path)}); } }, } @@ -3480,7 +3480,7 @@ pub const Server = struct { continue :restart; }, else => { - Output.prettyErrorln("<r><red>{any} while trying to start listening on port {d}.\n\n", .{ @errorName(err), port }); + Output.prettyErrorln("<r><red>{s} while trying to start listening on port {d}.\n\n", .{ @errorName(err), port }); Global.exit(1); }, } @@ -3537,7 +3537,7 @@ pub const Server = struct { if (std.mem.readIntNative(u32, &addr.ipv4.host.octets) == 0 or std.mem.readIntNative(u128, &addr.ipv6.host.octets) == 0) { if (server.bundler.options.routes.single_page_app_routing) { Output.prettyError( - " bun!! <d>v{any}<r>\n\n\n Link:<r> <b><cyan>http://localhost:{d}<r>\n <d>{any}/index.html<r> \n\n\n", + " bun!! <d>v{s}<r>\n\n\n Link:<r> <b><cyan>http://localhost:{d}<r>\n <d>{s}/index.html<r> \n\n\n", .{ Global.package_json_version_with_sha, addr.ipv4.port, @@ -3545,20 +3545,20 @@ pub const Server = struct { }, ); } else { - Output.prettyError(" bun!! <d>v{any}<r>\n\n\n<d> Link:<r> <b><cyan>http://localhost:{d}<r>\n\n\n", .{ + Output.prettyError(" bun!! <d>v{s}<r>\n\n\n<d> Link:<r> <b><cyan>http://localhost:{d}<r>\n\n\n", .{ Global.package_json_version_with_sha, addr.ipv4.port, }); } } else { if (server.bundler.options.routes.single_page_app_routing) { - Output.prettyError(" bun!! <d>v{any}<r>\n\n\n<d> Link:<r> <b><cyan>http://{any}<r>\n <d>{any}/index.html<r> \n\n\n", .{ + Output.prettyError(" bun!! <d>v{s}<r>\n\n\n<d> Link:<r> <b><cyan>http://{any}<r>\n <d>{s}/index.html<r> \n\n\n", .{ Global.package_json_version_with_sha, addr, display_path, }); } else { - Output.prettyError(" bun!! <d>v{any}\n\n\n<d> Link:<r> <b><cyan>http://{any}<r>\n\n\n", .{ + Output.prettyError(" bun!! <d>v{s}\n\n\n<d> Link:<r> <b><cyan>http://{any}<r>\n\n\n", .{ Global.package_json_version_with_sha, addr, }); @@ -3641,7 +3641,7 @@ pub const Server = struct { var req = picohttp.Request.parse(req_buf_node.data[0..read_size], &req_headers_buf) catch |err| { _ = conn.client.write(RequestContext.printStatusLine(400) ++ "\r\n\r\n", SOCKET_FLAGS) catch {}; _ = Syscall.close(conn.client.socket.fd); - Output.printErrorln("ERR: {any}", .{@errorName(err)}); + Output.printErrorln("ERR: {s}", .{@errorName(err)}); return; }; @@ -3657,7 +3657,7 @@ pub const Server = struct { server.watcher, server.timer, ) catch |err| { - Output.prettyErrorln("<r>[<red>{any}<r>] - <b>{any}<r>: {any}", .{ @errorName(err), req.method, req.path }); + Output.prettyErrorln("<r>[<red>{s}<r>] - <b>{s}<r>: {s}", .{ @errorName(err), req.method, req.path }); _ = Syscall.close(conn.client.socket.fd); request_arena.deinit(); return; @@ -3682,7 +3682,7 @@ pub const Server = struct { if (req_ctx.url.needs_redirect) { req_ctx.handleRedirect(req_ctx.url.path) catch |err| { - Output.prettyErrorln("<r>[<red>{any}<r>] - <b>{any}<r>: {any}", .{ @errorName(err), req.method, req.path }); + Output.prettyErrorln("<r>[<red>{s}<r>] - <b>{s}<r>: {s}", .{ @errorName(err), req.method, req.path }); conn.client.deinit(); return; }; @@ -3726,13 +3726,13 @@ pub const Server = struct { 200, 304, 101 => {}, 201...303, 305...399 => { - Output.prettyErrorln("<r><green>{d}<r><d> {any} <r>{any}<d> as {any}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); + Output.prettyErrorln("<r><green>{d}<r><d> {s} <r>{s}<d> as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); }, 400...499 => { - Output.prettyErrorln("<r><yellow>{d}<r><d> {any} <r>{any}<d> as {any}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); + Output.prettyErrorln("<r><yellow>{d}<r><d> {s} <r>{s}<d> as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); }, else => { - Output.prettyErrorln("<r><red>{d}<r><d> {any} <r>{any}<d> as {any}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); + Output.prettyErrorln("<r><red>{d}<r><d> {s} <r>{s}<d> as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); }, } } @@ -3748,13 +3748,13 @@ pub const Server = struct { 200, 304, 101 => {}, 201...303, 305...399 => { - Output.prettyErrorln("<r><green>{d}<r><d> <r>{any}<d> {any} as {any}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); + Output.prettyErrorln("<r><green>{d}<r><d> <r>{s}<d> {s} as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); }, 400...499 => { - Output.prettyErrorln("<r><yellow>{d}<r><d> <r>{any}<d> {any} as {any}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); + Output.prettyErrorln("<r><yellow>{d}<r><d> <r>{s}<d> {s} as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); }, else => { - Output.prettyErrorln("<r><red>{d}<r><d> <r>{any}<d> {any} as {any}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); + Output.prettyErrorln("<r><red>{d}<r><d> <r>{s}<d> {s} as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value }); }, } } @@ -3772,7 +3772,7 @@ pub const Server = struct { } var finished = req_ctx.handleReservedRoutes(server) catch |err| { - Output.printErrorln("FAIL [{any}] - {any}: {any}", .{ @errorName(err), req.method, req.path }); + Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path }); did_print = true; return; }; @@ -3783,7 +3783,7 @@ pub const Server = struct { if (comptime features.single_page_app_routing) { if (req_ctx.url.isRoot(server.bundler.options.routes.asset_prefix_path)) { req_ctx.sendSinglePageHTML() catch |err| { - Output.printErrorln("FAIL [{any}] - {any}: {any}", .{ @errorName(err), req.method, req.path }); + Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path }); did_print = true; }; finished = true; @@ -3798,7 +3798,7 @@ pub const Server = struct { if (req_ctx.matchPublicFolder(comptime features.public_folder == .last or features.single_page_app_routing)) |result| { finished = true; req_ctx.renderServeResult(result) catch |err| { - Output.printErrorln("FAIL [{any}] - {any}: {any}", .{ @errorName(err), req.method, req.path }); + Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path }); did_print = true; return; }; @@ -3816,7 +3816,7 @@ pub const Server = struct { switch (err) { error.ModuleNotFound => {}, else => { - Output.printErrorln("FAIL [{any}] - {any}: {any}", .{ @errorName(err), req.method, req.path }); + Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path }); did_print = true; }, } @@ -3832,7 +3832,7 @@ pub const Server = struct { break :request_handler; }, else => { - Output.printErrorln("FAIL [{any}] - {any}: {any}", .{ @errorName(err), req.method, req.path }); + Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path }); did_print = true; }, } @@ -3847,7 +3847,7 @@ pub const Server = struct { if (req_ctx.matchPublicFolder(false)) |result| { finished = true; req_ctx.renderServeResult(result) catch |err| { - Output.printErrorln("FAIL [{any}] - {any}: {any}", .{ @errorName(err), req.method, req.path }); + Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path }); did_print = true; }; } @@ -3860,7 +3860,7 @@ pub const Server = struct { if (!finished and (req_ctx.bundler.options.routes.single_page_app_routing and req_ctx.url.extname.len == 0)) { if (!finished) { req_ctx.sendSinglePageHTML() catch |err| { - Output.printErrorln("FAIL [{any}] - {any}: {any}", .{ @errorName(err), req.method, req.path }); + Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path }); did_print = true; }; } @@ -3872,7 +3872,7 @@ pub const Server = struct { // if we're about to 404 and it's the favicon, use our stand-in if (strings.eqlComptime(req_ctx.url.path, "favicon.ico")) { req_ctx.sendFavicon() catch |err| { - Output.printErrorln("FAIL [{any}] - {any}: {any}", .{ @errorName(err), req.method, req.path }); + Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path }); did_print = true; }; return; diff --git a/src/http/websocket_http_client.zig b/src/http/websocket_http_client.zig index 2d7ddf47b..24aeaf472 100644 --- a/src/http/websocket_http_client.zig +++ b/src/http/websocket_http_client.zig @@ -51,8 +51,8 @@ fn buildRequestBody(vm: *JSC.VirtualMachine, pathname: *const JSC.ZigString, hos const pico_headers = PicoHTTP.Headers{ .headers = headers_ }; return try std.fmt.allocPrint( allocator, - "GET {any} HTTP/1.1\r\n" ++ - "Host: {any}\r\n" ++ + "GET {s} HTTP/1.1\r\n" ++ + "Host: {s}\r\n" ++ "Pragma: no-cache\r\n" ++ "Cache-Control: no-cache\r\n" ++ "Connection: Upgrade\r\n" ++ @@ -978,7 +978,7 @@ pub fn NewWebSocketClient(comptime ssl: bool) type { var header_bytes: [@sizeOf(usize)]u8 = [_]u8{0} ** @sizeOf(usize); while (true) { - log("onData ({any})", .{@tagName(receive_state)}); + log("onData ({s})", .{@tagName(receive_state)}); switch (receive_state) { // 0 1 2 3 diff --git a/src/http_client_async.zig b/src/http_client_async.zig index 1e50199d3..818b8cb71 100644 --- a/src/http_client_async.zig +++ b/src/http_client_async.zig @@ -128,7 +128,7 @@ fn NewHTTPContext(comptime ssl: bool) type { pending.hostname_len = @truncate(u8, hostname.len); pending.port = port; - log("- Keep-Alive release {any}:{d}", .{ hostname, port }); + log("- Keep-Alive release {s}:{d}", .{ hostname, port }); return; } } @@ -293,7 +293,7 @@ fn NewHTTPContext(comptime ssl: bool) type { continue; } - log("+ Keep-Alive reuse {any}:{d}", .{ hostname, port }); + log("+ Keep-Alive reuse {s}:{d}", .{ hostname, port }); return http_socket; } } @@ -480,7 +480,7 @@ pub fn onOpen( std.debug.assert(is_ssl == client.url.isHTTPS()); } - log("Connected {any} \n", .{client.url.href}); + log("Connected {s} \n", .{client.url.href}); if (comptime is_ssl) { var ssl: *BoringSSL.SSL = @ptrCast(*BoringSSL.SSL, socket.getNativeHandle()); @@ -512,7 +512,7 @@ pub fn onClose( comptime is_ssl: bool, socket: NewHTTPContext(is_ssl).HTTPSocket, ) void { - log("Closed {any}\n", .{client.url.href}); + log("Closed {s}\n", .{client.url.href}); const in_progress = client.state.stage != .done and client.state.stage != .fail; @@ -545,7 +545,7 @@ pub fn onTimeout( socket: NewHTTPContext(is_ssl).HTTPSocket, ) void { _ = socket; - log("Timeout {any}\n", .{client.url.href}); + log("Timeout {s}\n", .{client.url.href}); if (client.state.stage != .done and client.state.stage != .fail) client.fail(error.Timeout); @@ -556,7 +556,7 @@ pub fn onConnectError( socket: NewHTTPContext(is_ssl).HTTPSocket, ) void { _ = socket; - log("onConnectError {any}\n", .{client.url.href}); + log("onConnectError {s}\n", .{client.url.href}); if (client.state.stage != .done and client.state.stage != .fail) client.fail(error.ConnectionRefused); @@ -566,7 +566,7 @@ pub fn onEnd( comptime is_ssl: bool, _: NewHTTPContext(is_ssl).HTTPSocket, ) void { - log("onEnd {any}\n", .{client.url.href}); + log("onEnd {s}\n", .{client.url.href}); if (client.state.stage != .done and client.state.stage != .fail) client.fail(error.ConnectionClosed); @@ -1032,7 +1032,7 @@ pub const AsyncHTTP = struct { this.real.?.* = this.*; this.real.?.response_buffer = this.response_buffer; - log("onAsyncHTTPComplete: {any}", .{bun.fmt.fmtDuration(this.elapsed)}); + log("onAsyncHTTPComplete: {s}", .{bun.fmt.fmtDuration(this.elapsed)}); default_allocator.destroy(this); @@ -1062,7 +1062,7 @@ pub const AsyncHTTP = struct { } this.client.start(this.request_body, this.response_buffer); - log("onStart: {any}", .{bun.fmt.fmtDuration(this.elapsed)}); + log("onStart: {s}", .{bun.fmt.fmtDuration(this.elapsed)}); } }; @@ -1893,7 +1893,7 @@ pub fn handleResponseMetadata( const original_url = this.url; this.url = URL.parse(std.fmt.bufPrint( &url_buf.data, - "{any}://{any}{any}", + "{any}://{any}{s}", .{ original_url.displayProtocol(), original_url.displayHostname(), location }, ) catch return error.RedirectURLTooLong); diff --git a/src/install/bin.zig b/src/install/bin.zig index b0d67c01e..51ae962a6 100644 --- a/src/install/bin.zig +++ b/src/install/bin.zig @@ -146,7 +146,7 @@ pub const Bin = extern struct { bin: Bin, i: usize = 0, done: bool = false, - dir_iterator: ?std.fs.Dir.Iterator = null, + dir_iterator: ?std.fs.IterableDir.Iterator = null, package_name: String, package_installed_node_modules: std.fs.Dir = std.fs.Dir{ .fd = std.math.maxInt(std.os.fd_t) }, buf: [bun.MAX_PATH_BYTES]u8 = undefined, @@ -167,7 +167,7 @@ pub const Bin = extern struct { var joined = Path.joinStringBuf(&this.buf, &parts, .auto); this.buf[joined.len] = 0; var joined_: [:0]u8 = this.buf[0..joined.len :0]; - var child_dir = try dir.openIterableDirZ(joined_, .{}); + var child_dir = try bun.openIterableDirZ(dir.fd, joined_); this.dir_iterator = child_dir.iterate(); } @@ -419,15 +419,16 @@ pub const Bin = extern struct { var joined = Path.joinStringBuf(&target_buf, &parts, .auto); @intToPtr([*]u8, @ptrToInt(joined.ptr))[joined.len] = 0; var joined_: [:0]const u8 = joined.ptr[0..joined.len :0]; - var child_dir = dir.openIterableDirZ(joined_, .{}) catch |err| { - this.err = err; - return; - }; + var child_dir = bun.openIterableDirZ(dir.fd, joined_) catch |err| { + this.err = err; + return; + }; + defer child_dir.close(); var iter = child_dir.iterate(); - var basedir_path = std.os.getFdPath(child_dir.fd, &target_buf) catch |err| { + var basedir_path = std.os.getFdPath(child_dir.dir.fd, &target_buf) catch |err| { this.err = err; return; }; @@ -436,9 +437,9 @@ pub const Bin = extern struct { var prev_target_buf_remain = target_buf_remain; while (iter.next() catch null) |entry_| { - const entry: std.fs.Dir.Entry = entry_; + const entry: std.fs.IterableDir.Entry = entry_; switch (entry.kind) { - std.fs.Dir.Entry.Kind.SymLink, std.fs.Dir.Entry.Kind.File => { + std.fs.IterableDir.Entry.Kind.SymLink, std.fs.IterableDir.Entry.Kind.File => { target_buf_remain = prev_target_buf_remain; std.mem.copy(u8, target_buf_remain, entry.name); target_buf_remain = target_buf_remain[entry.name.len..]; @@ -571,7 +572,7 @@ pub const Bin = extern struct { var joined = Path.joinStringBuf(&target_buf, &parts, .auto); @intToPtr([*]u8, @ptrToInt(joined.ptr))[joined.len] = 0; var joined_: [:0]const u8 = joined.ptr[0..joined.len :0]; - var child_dir = dir.openIterableDirZ(joined_, .{}) catch |err| { + var child_dir = bun.openIterableDirZFromDir(dir, joined_) catch |err| { this.err = err; return; }; @@ -579,7 +580,7 @@ pub const Bin = extern struct { var iter = child_dir.iterate(); - var basedir_path = std.os.getFdPath(child_dir.fd, &target_buf) catch |err| { + var basedir_path = std.os.getFdPath(child_dir.dir.fd, &target_buf) catch |err| { this.err = err; return; }; @@ -588,9 +589,9 @@ pub const Bin = extern struct { var prev_target_buf_remain = target_buf_remain; while (iter.next() catch null) |entry_| { - const entry: std.fs.Dir.Entry = entry_; + const entry: std.fs.IterableDir.Entry = entry_; switch (entry.kind) { - std.fs.Dir.Entry.Kind.SymLink, std.fs.Dir.Entry.Kind.File => { + std.fs.IterableDir.Entry.Kind.SymLink, std.fs.IterableDir.Entry.Kind.File => { target_buf_remain = prev_target_buf_remain; std.mem.copy(u8, target_buf_remain, entry.name); target_buf_remain = target_buf_remain[entry.name.len..]; diff --git a/src/install/install.zig b/src/install/install.zig index 8d9701611..bdf16faa9 100644 --- a/src/install/install.zig +++ b/src/install/install.zig @@ -889,10 +889,10 @@ const PackageInstall = struct { fn installWithClonefileEachDir(this: *PackageInstall) !Result { const Walker = @import("../walker_skippable.zig"); - var cached_package_dir = this.cache_dir.openDirZ(this.cache_dir_subpath, .{}, true) catch |err| return Result{ + var cached_package_dir = bun.openIterableDirZFromDir(this.cache_dir, this.cache_dir_subpath) catch |err| return Result{ .fail = .{ .err = err, .step = .opening_cache_dir }, }; - defer cached_package_dir.close(); + defer cached_package_dir.dir.close(); var walker_ = Walker.walk( cached_package_dir, this.allocator, @@ -921,7 +921,7 @@ const PackageInstall = struct { var path: [:0]u8 = stackpath[0..entry.path.len :0]; var basename: [:0]u8 = stackpath[entry.path.len - entry.basename.len .. entry.path.len :0]; switch (C.clonefileat( - entry.dir.fd, + entry.dir.dir.fd, basename, destination_dir_.fd, path, @@ -1003,7 +1003,7 @@ const PackageInstall = struct { const Walker = @import("../walker_skippable.zig"); const CopyFile = @import("../copy_file.zig"); - var cached_package_dir = this.cache_dir.openDirZ(this.cache_dir_subpath, .{}, true) catch |err| return Result{ + var cached_package_dir = bun.openIterableDirZFromDir(this.cache_dir, this.cache_dir_subpath) catch |err| return Result{ .fail = .{ .err = err, .step = .opening_cache_dir }, }; defer cached_package_dir.close(); @@ -1043,14 +1043,14 @@ const PackageInstall = struct { }; defer outfile.close(); - var infile = try entry.dir.openFile(entry.basename, .{ .mode = .read_only }); + var infile = try entry.dir.dir.openFile(entry.basename, .{ .mode = .read_only }); defer infile.close(); const stat = infile.stat() catch continue; _ = C.fchmod(outfile.handle, stat.mode); CopyFile.copy(infile.handle, outfile.handle) catch { - entry.dir.copyFile(entry.basename, destination_dir_, entry.path, .{}) catch |err| { + entry.dir.dir.copyFile(entry.basename, destination_dir_, entry.path, .{}) catch |err| { progress_.root.end(); progress_.refresh(); @@ -1083,7 +1083,7 @@ const PackageInstall = struct { fn installWithHardlink(this: *PackageInstall) !Result { const Walker = @import("../walker_skippable.zig"); - var cached_package_dir = this.cache_dir.openDirZ(this.cache_dir_subpath, .{}, true) catch |err| return Result{ + var cached_package_dir = bun.openIterableDirZFromDir(this.cache_dir, this.cache_dir_subpath) catch |err| return Result{ .fail = .{ .err = err, .step = .opening_cache_dir }, }; defer cached_package_dir.close(); @@ -1109,7 +1109,7 @@ const PackageInstall = struct { std.os.mkdirat(destination_dir_.fd, entry.path, 0o755) catch {}; }, .File => { - try std.os.linkat(entry.dir.fd, entry.basename, destination_dir_.fd, entry.path, 0); + try std.os.linkat(entry.dir.dir.fd, entry.basename, destination_dir_.fd, entry.path, 0); real_file_count += 1; }, else => {}, @@ -1144,7 +1144,7 @@ const PackageInstall = struct { fn installWithSymlink(this: *PackageInstall) !Result { const Walker = @import("../walker_skippable.zig"); - var cached_package_dir = this.cache_dir.openDirZ(this.cache_dir_subpath, .{}, true) catch |err| return Result{ + var cached_package_dir = bun.openIterableDirZFromDir(this.cache_dir, this.cache_dir_subpath) catch |err| return Result{ .fail = .{ .err = err, .step = .opening_cache_dir }, }; defer cached_package_dir.close(); @@ -1221,7 +1221,7 @@ const PackageInstall = struct { this.file_count = FileCopier.copy( subdir.fd, - cached_package_dir.fd, + cached_package_dir.dir.fd, &walker_, ) catch |err| return Result{ @@ -1868,7 +1868,7 @@ pub const PackageManager = struct { var end: []u8 = undefined; if (scope.url.hostname.len > 32 or available.len < 64) { const visible_hostname = scope.url.hostname[0..@min(scope.url.hostname.len, 12)]; - end = std.fmt.bufPrint(available, "@@{s}__{x}", .{ visible_hostname, String.Builder.stringHash(scope.url.href) }) catch unreachable; + end = std.fmt.bufPrint(available, "@@{s}__{any}", .{ visible_hostname, bun.fmt.x(String.Builder.stringHash(scope.url.href)) }) catch unreachable; } else { end = std.fmt.bufPrint(available, "@@{s}", .{scope.url.hostname}) catch unreachable; } @@ -1893,14 +1893,14 @@ pub const PackageManager = struct { } else if (version.tag.hasPre() and version.tag.hasBuild()) { return std.fmt.bufPrintZ( buf, - "{s}@{d}.{d}.{d}-{x}+{X}", - .{ name, version.major, version.minor, version.patch, version.tag.pre.hash, version.tag.build.hash }, + "{s}@{d}.{d}.{d}-{any}+{X}", + .{ name, version.major, version.minor, version.patch, version.tag.pre.hash, bun.fmt.x(version.tag.build.hash) }, ) catch unreachable; } else if (version.tag.hasPre()) { return std.fmt.bufPrintZ( buf, - "{s}@{d}.{d}.{d}-{x}", - .{ name, version.major, version.minor, version.patch, version.tag.pre.hash }, + "{s}@{d}.{d}.{d}-{any}", + .{ name, version.major, version.minor, version.patch, bun.fmt.x(version.tag.pre.hash) }, ) catch unreachable; } else if (version.tag.hasBuild()) { return std.fmt.bufPrintZ( @@ -5464,10 +5464,10 @@ pub const PackageManager = struct { if (cwd.openDirZ(manager.options.bin_path, .{}, true)) |node_modules_bin_| { var node_modules_bin: std.fs.Dir = node_modules_bin_; const iterable_dir = std.fs.IterableDir{ .dir = .{ .fd = node_modules_bin.fd } }; - var iter: std.fs.Dir.Iterator = iterable_dir.iterate(); + var iter: std.fs.IterableDir.Iterator = iterable_dir.iterate(); iterator: while (iter.next() catch null) |entry| { switch (entry.kind) { - std.fs.Dir.Entry.Kind.SymLink => { + std.fs.IterableDir.Entry.Kind.SymLink => { // any symlinks which we are unable to open are assumed to be dangling // note that using access won't work here, because access doesn't resolve symlinks @@ -6684,7 +6684,7 @@ pub const PackageManager = struct { // bun install may have installed new bins, so we need to update the PATH // this can happen if node_modules/.bin didn't previously exist // note: it is harmless to have the same directory in the PATH multiple times - const current_path = manager.env.map.get("PATH"); + const current_path = manager.env.map.get("PATH") orelse "/"; // TODO: windows const cwd_without_trailing_slash = if (Fs.FileSystem.instance.top_level_dir.len > 1 and Fs.FileSystem.instance.top_level_dir[Fs.FileSystem.instance.top_level_dir.len - 1] == '/') @@ -6696,7 +6696,7 @@ pub const PackageManager = struct { ctx.allocator, "{s}:{s}/node_modules/.bin", .{ - current_path, + current_path , cwd_without_trailing_slash, }, )); diff --git a/src/install/npm.zig b/src/install/npm.zig index 112580c4c..ef45f956b 100644 --- a/src/install/npm.zig +++ b/src/install/npm.zig @@ -31,6 +31,7 @@ const ObjectPool = @import("../pool.zig").ObjectPool; const Api = @import("../api/schema.zig").Api; const DotEnv = @import("../env_loader.zig"); const ComptimeStringMap = @import("../comptime_string_map.zig").ComptimeStringMap; +const bun = @import("../global.zig"); const Npm = @This(); @@ -556,18 +557,18 @@ pub const PackageManifest = struct { var out_path_buf: ["-18446744073709551615".len + ".npm".len + 1]u8 = undefined; var dest_path_stream = std.io.fixedBufferStream(&dest_path_buf); var dest_path_stream_writer = dest_path_stream.writer(); - try dest_path_stream_writer.print("{x}.npm-{x}", .{ file_id, @max(std.time.milliTimestamp(), 0) }); + try dest_path_stream_writer.print("{any}.npm-{any}", .{ bun.fmt.x(file_id), bun.fmt.x(@max(std.time.milliTimestamp(), 0)) }); try dest_path_stream_writer.writeByte(0); var tmp_path: [:0]u8 = dest_path_buf[0 .. dest_path_stream.pos - 1 :0]; try writeFile(this, tmp_path, tmpdir); - var out_path = std.fmt.bufPrintZ(&out_path_buf, "{x}.npm", .{file_id}) catch unreachable; + var out_path = std.fmt.bufPrintZ(&out_path_buf, "{any}.npm", .{bun.fmt.x(file_id)}) catch unreachable; try std.os.renameatZ(tmpdir.fd, tmp_path, cache_dir.fd, out_path); } pub fn load(allocator: std.mem.Allocator, cache_dir: std.fs.Dir, package_name: string) !?PackageManifest { const file_id = std.hash.Wyhash.hash(0, package_name); var file_path_buf: [512 + 64]u8 = undefined; - var file_path = try std.fmt.bufPrintZ(&file_path_buf, "{x}.npm", .{file_id}); + var file_path = try std.fmt.bufPrintZ(&file_path_buf, "{any}.npm", .{bun.fmt.x(file_id)}); var cache_file = cache_dir.openFileZ( file_path, .{ .mode = .read_only }, diff --git a/src/io/io_darwin.zig b/src/io/io_darwin.zig index c2160d5d9..104da0507 100644 --- a/src/io/io_darwin.zig +++ b/src/io/io_darwin.zig @@ -746,7 +746,7 @@ fn flush(self: *IO, comptime _: @Type(.EnumLiteral)) !void { ); if (new_events_ < 0) { - return std.debug.panic("kevent() failed {any}", .{@tagName(std.c.getErrno(new_events_))}); + return std.debug.panic("kevent() failed {s}", .{@tagName(std.c.getErrno(new_events_))}); } const new_events = @intCast(usize, new_events_); diff --git a/src/js_ast.zig b/src/js_ast.zig index 7eede039c..1e608b54b 100644 --- a/src/js_ast.zig +++ b/src/js_ast.zig @@ -1626,6 +1626,14 @@ pub const E = struct { rope_len: u32 = 0, is_utf16: bool = false, + pub fn format(this: String, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void { + if (this.isUTF8()) { + try writer.writeAll(this.data); + } else { + try writer.print("{any}", .{JSC.ZigString.init16(this.slice16())}); + } + } + pub var class = E.String{ .data = "class" }; pub fn push(this: *String, other: *String) void { std.debug.assert(this.isUTF8()); @@ -4872,7 +4880,7 @@ pub const Macro = struct { source, import_range, log.msgs.allocator, - "Macro \"{any}\" not found", + "Macro \"{s}\" not found", .{import_record_path}, .stmt, err, @@ -4884,7 +4892,7 @@ pub const Macro = struct { source, import_range, log.msgs.allocator, - "{any} resolving macro \"{any}\"", + "{s} resolving macro \"{s}\"", .{ @errorName(err), import_record_path }, ) catch unreachable; return err; @@ -5547,7 +5555,7 @@ pub const Macro = struct { }, else => { if (comptime Environment.isDebug) { - Output.prettyWarnln("initExpr fail: {any}", .{@tagName(this.data)}); + Output.prettyWarnln("initExpr fail: {s}", .{@tagName(this.data)}); } return JSNode{ .loc = this.loc, .data = .{ .e_missing = .{} } }; }, @@ -5957,7 +5965,7 @@ pub const Macro = struct { if (!@hasField(JSNode.Tag, name)) { @compileError( "JSNode.Tag does not have a \"" ++ name ++ "\" field. Valid fields are " ++ std.fmt.comptimePrint( - "{any}", + "{s}", .{ std.meta.fieldNames(@TypeOf(valid_tags)), }, @@ -6709,7 +6717,7 @@ pub const Macro = struct { Tag.e_super, Tag.e_null, Tag.e_undefined, Tag.e_missing, Tag.inline_true, Tag.inline_false, Tag.e_this => { self.args.append(Expr{ .loc = loc, .data = Tag.ids.get(tag) }) catch unreachable; }, - else => Global.panic("Tag \"{any}\" is not implemented yet.", .{@tagName(tag)}), + else => Global.panic("Tag \"{s}\" is not implemented yet.", .{@tagName(tag)}), } return true; @@ -6745,7 +6753,7 @@ pub const Macro = struct { tag_expr.loc, ); }, - else => Global.panic("Not implemented yet top-level jsx element: {any}", .{@tagName(tag_expr.data)}), + else => Global.panic("Not implemented yet top-level jsx element: {s}", .{@tagName(tag_expr.data)}), } } else { const loc = logger.Loc.Empty; @@ -6782,16 +6790,12 @@ pub const Macro = struct { var p = self.p; const node_type: JSNode.Tag = JSNode.Tag.names.get(str.data) orelse { - if (!str.isUTF8()) { - self.log.addErrorFmt(p.source, tag_expr.loc, p.allocator, "Tag \"{any}\" is invalid", .{strings.toUTF8Alloc(self.p.allocator, str.slice16())}) catch unreachable; - } else { - self.log.addErrorFmt(p.source, tag_expr.loc, p.allocator, "Tag \"{any}\" is invalid", .{str.data}) catch unreachable; - } + self.log.addErrorFmt(p.source, tag_expr.loc, p.allocator, "Tag \"{any}\" is invalid", .{str}) catch unreachable; return false; }; if (!valid_tags.get(node_type)) { - self.log.addErrorFmt(p.source, tag_expr.loc, p.allocator, "Tag \"{any}\" is invalid here", .{str.data}) catch unreachable; + self.log.addErrorFmt(p.source, tag_expr.loc, p.allocator, "Tag \"{s}\" is invalid here", .{str}) catch unreachable; } return self.writeNodeType(node_type, element.properties.slice(), element.children.slice(), tag_expr.loc); @@ -6805,9 +6809,9 @@ pub const Macro = struct { const node_type: JSNode.Tag = JSNode.Tag.names.get(str.data) orelse { if (!str.isUTF8()) { - self.log.addErrorFmt(p.source, tag_expr.loc, p.allocator, "Tag \"{any}\" is invalid", .{strings.toUTF8Alloc(self.p.allocator, str.slice16())}) catch unreachable; + self.log.addErrorFmt(p.source, tag_expr.loc, p.allocator, "Tag \"{s}\" is invalid", .{strings.toUTF8Alloc(self.p.allocator, str.slice16()) catch unreachable}) catch unreachable; } else { - self.log.addErrorFmt(p.source, tag_expr.loc, p.allocator, "Tag \"{any}\" is invalid", .{str.data}) catch unreachable; + self.log.addErrorFmt(p.source, tag_expr.loc, p.allocator, "Tag \"{s}\" is invalid", .{str.data}) catch unreachable; } return false; }; @@ -7838,7 +7842,7 @@ pub const Macro = struct { this.source, this.caller.loc, this.allocator, - "cannot coerce {any} to Bun's AST. Please return a valid macro using the JSX syntax", + "cannot coerce {s} to Bun's AST. Please return a valid macro using the JSX syntax", .{@tagName(value.jsType())}, ) catch unreachable; break :brk error.MacroFailed; @@ -8085,7 +8089,7 @@ pub const Macro = struct { this.source, this.caller.loc, this.allocator, - "cannot coerce {any} to Bun's AST. Please return a valid macro using the JSX syntax", + "cannot coerce {s} to Bun's AST. Please return a valid macro using the JSX syntax", .{@tagName(value.jsType())}, ) catch unreachable; return error.MacroFailed; @@ -8106,7 +8110,7 @@ pub const Macro = struct { visitor: Visitor, javascript_object: JSC.JSValue, ) MacroError!Expr { - if (comptime Environment.isDebug) Output.prettyln("<r><d>[macro]<r> call <d><b>{any}<r>", .{function_name}); + if (comptime Environment.isDebug) Output.prettyln("<r><d>[macro]<r> call <d><b>{s}<r>", .{function_name}); exception_holder = Zig.ZigException.Holder.init(); expr_nodes_buf[0] = JSNode.initExpr(caller); diff --git a/src/js_lexer.zig b/src/js_lexer.zig index 19591c2a6..0b3ce2a2b 100644 --- a/src/js_lexer.zig +++ b/src/js_lexer.zig @@ -196,7 +196,7 @@ fn NewLexer_( pub fn addDefaultError(self: *LexerType, msg: []const u8) !void { @setCold(true); - self.addError(self.start, "{any}", .{msg}, true); + self.addError(self.start, "{s}", .{msg}, true); return Error.SyntaxError; } @@ -816,7 +816,7 @@ fn NewLexer_( } pub fn addUnsupportedSyntaxError(self: *LexerType, msg: []const u8) !void { - self.addError(self.end, "Unsupported syntax: {any}", .{msg}, true); + self.addError(self.end, "Unsupported syntax: {s}", .{msg}, true); return Error.SyntaxError; } @@ -936,7 +936,7 @@ fn NewLexer_( if (!isIdentifier(identifier)) { try lexer.addRangeError( .{ .loc = logger.usize2Loc(lexer.start), .len = @intCast(i32, lexer.end - lexer.start) }, - "Invalid identifier: \"{any}\"", + "Invalid identifier: \"{s}\"", .{result.contents}, true, ); @@ -965,13 +965,13 @@ fn NewLexer_( pub fn expectContextualKeyword(self: *LexerType, comptime keyword: string) !void { if (!self.isContextualKeyword(keyword)) { if (@import("builtin").mode == std.builtin.Mode.Debug) { - self.addError(self.start, "Expected \"{any}\" but found \"{any}\" (token: {any})", .{ + self.addError(self.start, "Expected \"{s}\" but found \"{s}\" (token: {any})", .{ keyword, self.raw(), self.token, }, true); } else { - self.addError(self.start, "Expected \"{any}\" but found \"{any}\"", .{ keyword, self.raw() }, true); + self.addError(self.start, "Expected \"{s}\" but found \"{s}\"", .{ keyword, self.raw() }, true); } return Error.UnexpectedSyntax; } @@ -1743,7 +1743,7 @@ fn NewLexer_( } }; - try lexer.addRangeError(lexer.range(), "Unexpected {any}", .{found}, true); + try lexer.addRangeError(lexer.range(), "Unexpected {s}", .{found}, true); } pub fn raw(self: *LexerType) []const u8 { @@ -1763,7 +1763,7 @@ fn NewLexer_( } }; - try self.addRangeError(self.range(), "Expected {any} but found \"{any}\"", .{ text, found }, true); + try self.addRangeError(self.range(), "Expected {s} but found \"{s}\"", .{ text, found }, true); } fn scanCommentText(lexer: *LexerType) void { @@ -2090,7 +2090,7 @@ fn NewLexer_( lexer.step(); } } else { - try lexer.addSyntaxError(lexer.range().endI(), "Expected identifier after \"{any}\" in namespaced JSX name", .{lexer.raw()}); + try lexer.addSyntaxError(lexer.range().endI(), "Expected identifier after \"{s}\" in namespaced JSX name", .{lexer.raw()}); } } @@ -2329,10 +2329,10 @@ fn NewLexer_( cursor.c = std.fmt.parseInt(i32, number, base) catch |err| brk: { switch (err) { error.InvalidCharacter => { - lexer.addError(lexer.start, "Invalid JSX entity escape: {any}", .{entity}, false); + lexer.addError(lexer.start, "Invalid JSX entity escape: {s}", .{entity}, false); }, error.Overflow => { - lexer.addError(lexer.start, "JSX entity escape is too big: {any}", .{entity}, false); + lexer.addError(lexer.start, "JSX entity escape is too big: {s}", .{entity}, false); }, } @@ -2630,7 +2630,7 @@ fn NewLexer_( if (std.fmt.parseFloat(f64, text)) |num| { lexer.number = num; } else |_| { - try lexer.addSyntaxError(lexer.start, "Invalid number {any}", .{text}); + try lexer.addSyntaxError(lexer.start, "Invalid number {s}", .{text}); } } } diff --git a/src/js_parser.zig b/src/js_parser.zig index 8e87a9753..970bb63dc 100644 --- a/src/js_parser.zig +++ b/src/js_parser.zig @@ -977,7 +977,7 @@ const StaticSymbolName = struct { pub const List = struct { fn NewStaticSymbol(comptime basename: string) StaticSymbolName { return comptime StaticSymbolName{ - .internal = basename ++ "_" ++ std.fmt.comptimePrint("{x}", .{std.hash.Wyhash.hash(0, basename)}), + .internal = basename ++ "_" ++ std.fmt.comptimePrint("{any}", .{bun.fmt.x(std.hash.Wyhash.hash(0, basename))}), .primary = basename, .backup = "_" ++ basename ++ "$", }; @@ -985,7 +985,7 @@ const StaticSymbolName = struct { fn NewStaticSymbolWithBackup(comptime basename: string, comptime backup: string) StaticSymbolName { return comptime StaticSymbolName{ - .internal = basename ++ "_" ++ std.fmt.comptimePrint("{x}", .{std.hash.Wyhash.hash(0, basename)}), + .internal = basename ++ "_" ++ std.fmt.comptimePrint("{any}", .{bun.fmt.x(std.hash.Wyhash.hash(0, basename))}), .primary = basename, .backup = backup, }; @@ -4263,19 +4263,20 @@ fn NewParser_( p.import_records.items[import_record_index].was_originally_require = true; p.import_records.items[import_record_index].contains_import_star = true; - const symbol_name = p.import_records.items[import_record_index].path.name.nonUniqueNameString(p.allocator); + const symbol_name = p.import_records.items[import_record_index].path.name.nonUniqueNameString(p.allocator) catch unreachable; const cjs_import_name = std.fmt.allocPrint( p.allocator, - "{any}_{x}_{d}", + "{s}_{s}_{d}", .{ + // THIS WASN'T ERRORING BEFORE symbol_name, - @truncate( + bun.fmt.x(@truncate( u16, std.hash.Wyhash.hash( 0, p.import_records.items[import_record_index].path.text, ), - ), + )), p.cjs_import_stmts.items.len, }, ) catch unreachable; @@ -4714,7 +4715,7 @@ fn NewParser_( // Duplicate exports are an error var notes = try p.allocator.alloc(logger.Data, 1); notes[0] = logger.Data{ - .text = try std.fmt.allocPrint(p.allocator, "\"{any}\" was originally exported here", .{alias}), + .text = try std.fmt.allocPrint(p.allocator, "\"{s}\" was originally exported here", .{alias}), .location = logger.Location.init_or_nil(p.source, js_lexer.rangeOfIdentifier(p.source, name.alias_loc)), }; try p.log.addRangeErrorFmtWithNotes( @@ -4722,7 +4723,7 @@ fn NewParser_( js_lexer.rangeOfIdentifier(p.source, loc), p.allocator, notes, - "Multiple exports with the same name \"{any}\"", + "Multiple exports with the same name \"{s}\"", .{std.mem.trim(u8, alias, "\"'")}, ); } else { diff --git a/src/libarchive/libarchive.zig b/src/libarchive/libarchive.zig index 8493f3fab..55212f6f2 100644 --- a/src/libarchive/libarchive.zig +++ b/src/libarchive/libarchive.zig @@ -406,9 +406,9 @@ pub const Archive = struct { // if the destination doesn't exist, we skip the whole thing since nothing can overwrite it. if (std.fs.path.isAbsolute(root)) { - break :brk std.fs.openIterableDirAbsolute(root, .{}) catch return; + break :brk (std.fs.openIterableDirAbsolute(root, .{}) catch return).dir; } else { - break :brk cwd.openIterableDir(root, .{}) catch return; + break :brk (cwd.openIterableDir(root, .{}) catch return).dir; } }; @@ -648,7 +648,7 @@ pub const Archive = struct { comptime close_handles: bool, comptime log: bool, ) !u32 { - var dir: std.fs.Dir = brk: { + var dir: std.fs.IterableDir = brk: { const cwd = std.fs.cwd(); cwd.makePath( root, @@ -661,7 +661,7 @@ pub const Archive = struct { } }; - defer if (comptime close_handles) dir.close(); + defer if (comptime close_handles) dir.dir.close(); return try extractToDir(file_buffer, dir, ctx, FilePathAppender, appender, depth_to_skip, close_handles, log); } }; diff --git a/src/linker.zig b/src/linker.zig index 61b5488fb..7427ef3b5 100644 --- a/src/linker.zig +++ b/src/linker.zig @@ -924,7 +924,7 @@ pub const Linker = struct { return Fs.Path.init(try origin.joinAlloc( linker.allocator, - std.fmt.bufPrint(&hash_buf, "hash:{x}/", .{modkey.hash()}) catch unreachable, + std.fmt.bufPrint(&hash_buf, "hash:{any}/", .{bun.fmt.x(modkey.hash())}) catch unreachable, dirname, basename, absolute_pathname.ext, diff --git a/src/main.zig b/src/main.zig index 22ba7e97d..dfcea84b5 100644 --- a/src/main.zig +++ b/src/main.zig @@ -26,9 +26,7 @@ const JavaScript = @import("bun.js/javascript.zig"); pub const io_mode = .blocking; pub const bindgen = if (@import("builtin").is_test) undefined else @import("build_options").bindgen; const Report = @import("./report.zig"); -pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn { - MainPanicHandler.handle_panic(msg, error_return_trace); -} +pub const panic = MainPanicHandler.handle_panic; const CrashReporter = @import("./crash_reporter.zig"); diff --git a/src/napi/napi.zig b/src/napi/napi.zig index a1c424247..dc685ffe1 100644 --- a/src/napi/napi.zig +++ b/src/napi/napi.zig @@ -1030,10 +1030,10 @@ pub export fn napi_fatal_error(location_ptr: ?[*:0]const u8, location_len: usize const location = napiSpan(location_ptr, location_len); if (location.len > 0) { - bun.Global.panic("napi: {any}\n {any}", .{ message, location }); + bun.Global.panic("napi: {s}\n {s}", .{ message, location }); } - bun.Global.panic("napi: {any}", .{message}); + bun.Global.panic("napi: {s}", .{message}); } pub export fn napi_create_buffer(env: napi_env, length: usize, data: [*]*anyopaque, result: *napi_value) napi_status { var buf = JSC.ExternalBuffer.create(null, @ptrCast([*]u8, data)[0..length], env, null, env.bunVM().allocator) catch { diff --git a/src/node_module_bundle.zig b/src/node_module_bundle.zig index 37f9f9984..22ef3010a 100644 --- a/src/node_module_bundle.zig +++ b/src/node_module_bundle.zig @@ -174,9 +174,9 @@ pub const NodeModuleBundle = struct { ) !string { return try std.fmt.allocPrint( allocator, - "{x}/{any}", + "{any}/{s}", .{ - this.bundle.packages[to.package_id].hash, + bun.fmt.x(this.bundle.packages[to.package_id].hash), this.str(to.path), 123, }, diff --git a/src/panic_handler.zig b/src/panic_handler.zig index f07d2f6bb..cb7877b87 100644 --- a/src/panic_handler.zig +++ b/src/panic_handler.zig @@ -16,7 +16,7 @@ const Features = @import("./analytics/analytics_thread.zig").Features; const HTTP = @import("http").AsyncHTTP; const Report = @import("./report.zig"); -pub fn NewPanicHandler(comptime panic_func: fn (msg: []const u8, error_return_type: ?*std.builtin.StackTrace) noreturn) type { +pub fn NewPanicHandler(comptime panic_func: @TypeOf(std.builtin.default_panic)) type { return struct { panic_count: usize = 0, skip_next_panic: bool = false, @@ -30,7 +30,7 @@ pub fn NewPanicHandler(comptime panic_func: fn (msg: []const u8, error_return_ty .log = log, }; } - pub inline fn handle_panic(msg: []const u8, error_return_type: ?*std.builtin.StackTrace) noreturn { + pub fn handle_panic(msg: []const u8, error_return_type: ?*std.builtin.StackTrace, addr: ?usize) noreturn { // This exists to ensure we flush all buffered output before panicking. Output.flush(); @@ -39,7 +39,7 @@ pub fn NewPanicHandler(comptime panic_func: fn (msg: []const u8, error_return_ty Output.disableBuffering(); // // We want to always inline the panic handler so it doesn't show up in the stacktrace. - @call(.{ .modifier = .always_inline }, panic_func, .{ msg, error_return_type }); + @call(.{ .modifier = .always_inline }, panic_func, .{ msg, error_return_type, addr }); } }; } diff --git a/src/report.zig b/src/report.zig index 0a47a9e98..1e4259f6d 100644 --- a/src/report.zig +++ b/src/report.zig @@ -93,9 +93,9 @@ pub const CrashReportWriter = struct { } if (tilda) { - Output.prettyError("\nCrash report saved to:\n <b>~{any}<r>\n", .{display_path}); + Output.prettyError("\nCrash report saved to:\n <b>~{s}<r>\n", .{display_path}); } else { - Output.prettyError("\nCrash report saved to:\n <b>{any}<r>\n", .{display_path}); + Output.prettyError("\nCrash report saved to:\n <b>{s}<r>\n", .{display_path}); } } } @@ -118,8 +118,8 @@ pub fn printMetadata() void { crash_report_writer.print( \\ \\<r>----- bun meta ----- - ++ "\nBun v" ++ Global.package_json_version_with_sha ++ " " ++ platform ++ " " ++ arch ++ " {any}\n" ++ - \\{any}: {} + ++ "\nBun v" ++ Global.package_json_version_with_sha ++ " " ++ platform ++ " " ++ arch ++ " {s}\n" ++ + \\{s}: {} \\ , .{ analytics_platform.version, diff --git a/src/sync.zig b/src/sync.zig index 262f5fa0d..9b73be127 100644 --- a/src/sync.zig +++ b/src/sync.zig @@ -610,7 +610,7 @@ pub const RwLock = if (@import("builtin").os.tag != .windows and @import("builti .netbsd => extern struct { ptr_magic: c_uint = 0x99990009, ptr_interlock: switch (@import("builtin").target.cpu.arch) { - .aarch64, .sparc, .x86_64, .i386 => u8, + .aarch64, .sparc, .x86_64, => u8, .arm, .powerpc => c_int, else => unreachable, } = 0, diff --git a/src/toml/toml_lexer.zig b/src/toml/toml_lexer.zig index 585d1c913..2ec11c72b 100644 --- a/src/toml/toml_lexer.zig +++ b/src/toml/toml_lexer.zig @@ -95,7 +95,7 @@ pub const Lexer = struct { pub fn addDefaultError(self: *Lexer, msg: []const u8) !void { @setCold(true); - self.addError(self.start, "{any}", .{msg}, true); + self.addError(self.start, "{s}", .{msg}, true); return Error.SyntaxError; } @@ -325,7 +325,7 @@ pub const Lexer = struct { if (std.fmt.parseFloat(f64, text)) |num| { lexer.number = num; } else |_| { - try lexer.addSyntaxError(lexer.start, "Invalid number {any}", .{text}); + try lexer.addSyntaxError(lexer.start, "Invalid number {s}", .{text}); } } } @@ -1124,7 +1124,7 @@ pub const Lexer = struct { } }; - try lexer.addRangeError(lexer.range(), "Unexpected {any}", .{found}, true); + try lexer.addRangeError(lexer.range(), "Unexpected {s}", .{found}, true); } pub fn expectedString(self: *Lexer, text: string) !void { @@ -1136,7 +1136,7 @@ pub const Lexer = struct { } }; - try self.addRangeError(self.range(), "Expected {any} but found {any}", .{ text, found }, true); + try self.addRangeError(self.range(), "Expected {s} but found {s}", .{ text, found }, true); } pub fn range(self: *Lexer) logger.Range { diff --git a/src/walker_skippable.zig b/src/walker_skippable.zig index 14cbcb9ce..c166d2324 100644 --- a/src/walker_skippable.zig +++ b/src/walker_skippable.zig @@ -92,7 +92,7 @@ pub fn next(self: *Walker) !?WalkerEntry { } } return WalkerEntry{ - .dir = top.iter.dir, + .dir = .{.dir = top.iter.dir}, .basename = self.name_buffer.items[dirname_len..], .path = self.name_buffer.items, .kind = base.kind, |