aboutsummaryrefslogtreecommitdiff
path: root/src/bun.js
diff options
context:
space:
mode:
Diffstat (limited to 'src/bun.js')
-rw-r--r--src/bun.js/api/bun.zig36
-rw-r--r--src/bun.js/api/ffi.zig38
-rw-r--r--src/bun.js/api/html_rewriter.zig4
-rw-r--r--src/bun.js/api/transpiler.zig2
-rw-r--r--src/bun.js/base.zig34
-rw-r--r--src/bun.js/node/types.zig6
-rw-r--r--src/bun.js/webcore/streams.zig16
7 files changed, 69 insertions, 67 deletions
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 {
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-26 18:12:23 +0000