fix the rest of node:buffer

cmake/tools/SetupWebKit.cmake

@@ -2,7 +2,7 @@ option(WEBKIT_VERSION "The version of WebKit to use")
 option(WEBKIT_LOCAL "If a local version of WebKit should be used instead of downloading")
 
 if(NOT WEBKIT_VERSION)
-  set(WEBKIT_VERSION 58549ddc4d9e7164823fe9d4e86c46c003e46a19)
+  set(WEBKIT_VERSION 801394a84b529e1186e92103307e3c09adcc86e5)
 endif()
 
 if(WEBKIT_LOCAL)

scripts/check-node-all.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+i=0
+j=0
+
+for x in $(find test/js/node/test/parallel -type f -name "test-$1*.js")
+do
+  i=$((i+1))
+  echo ./$x
+  if timeout 2 $PWD/build/debug/bun-debug ./$x
+  then
+    j=$((j+1))
+  fi
+  echo
+done
+
+echo $i tests tested
+echo $j tests passed

src/bun.js/ConsoleObject.zig

@@ -724,7 +724,6 @@ pub const FormatOptions = struct {
             if (try arg1.getBooleanLoose(globalThis, "sorted")) |opt| {
                 formatOptions.ordered_properties = opt;
             }
-
             if (try arg1.getBooleanLoose(globalThis, "compact")) |opt| {
                 formatOptions.single_line = opt;
             }
@@ -2148,7 +2147,7 @@ pub const Formatter = struct {
                     this.addForNewLine(description.len + "()".len);
                     writer.print(comptime Output.prettyFmt("<r><blue>Symbol({any})<r>", enable_ansi_colors), .{description});
                 } else {
-                    writer.print(comptime Output.prettyFmt("<r><blue>Symbol<r>", enable_ansi_colors), .{});
+                    writer.print(comptime Output.prettyFmt("<r><blue>Symbol()<r>", enable_ansi_colors), .{});
                 }
             },
             .Error => {

src/bun.js/api/BunObject.zig

@@ -536,6 +536,19 @@ pub fn inspect(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.J
     return ret;
 }
 
+export fn Bun__inspect(globalThis: *JSGlobalObject, value: JSValue) ZigString {
+    // very stable memory address
+    var array = MutableString.init(getAllocator(globalThis), 0) catch unreachable;
+    var buffered_writer = MutableString.BufferedWriter{ .context = &array };
+    const writer = buffered_writer.writer();
+
+    var formatter = ConsoleObject.Formatter{ .globalThis = globalThis };
+    writer.print("{}", .{value.toFmt(&formatter)}) catch return ZigString.Empty;
+    buffered_writer.flush() catch return ZigString.Empty;
+
+    return ZigString.init(array.slice()).withEncoding();
+}
+
 pub fn getInspect(globalObject: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     const fun = JSC.createCallback(globalObject, ZigString.static("inspect"), 2, inspect);
     var str = ZigString.init("nodejs.util.inspect.custom");

src/bun.js/bindings/ErrorCode.cpp

@@ -175,6 +175,9 @@ JSObject* createError(Zig::JSGlobalObject* globalObject, ErrorCode code, JSC::JS
     return createError(vm, globalObject, code, message);
 }
 
+// export fn Bun__inspect(globalThis: *JSGlobalObject, value: JSValue) ZigString
+extern "C" ZigString Bun__inspect(JSC::JSGlobalObject* globalObject, JSValue value);
+
 WTF::String JSValueToStringSafe(JSC::JSGlobalObject* globalObject, JSValue arg)
 {
     ASSERT(!arg.isEmpty());
@@ -201,14 +204,14 @@ WTF::String JSValueToStringSafe(JSC::JSGlobalObject* globalObject, JSValue arg)
         auto name = JSC::getCalculatedDisplayName(vm, cell->getObject());
         if (catchScope.exception()) {
             catchScope.clearException();
-            name = "Function"_s;
+            name = ""_s;
         }
 
         if (!name.isNull() && name.length() > 0) {
             return makeString("[Function: "_s, name, ']');
         }
 
-        return "Function"_s;
+        return "[Function: (anonymous)]"_s;
         break;
     }
 
@@ -217,34 +220,133 @@ WTF::String JSValueToStringSafe(JSC::JSGlobalObject* globalObject, JSValue arg)
     }
     }
 
-    return arg.toWTFStringForConsole(globalObject);
+    // return arg.toWTFString(globalObject); // this threw an exception on `{ __proto__: null }`
+    ZigString zstring = Bun__inspect(globalObject, arg);
+    BunString bstring(BunStringTag::ZigString, BunStringImpl(zstring));
+    return bstring.toWTFString();
+}
+
+WTF::String determineSpecificType(JSC::JSGlobalObject* globalObject, JSValue value)
+{
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_CATCH_SCOPE(vm);
+
+    if (value.isNull()) {
+        return String("null"_s);
+    }
+    if (value.isUndefined()) {
+        return String("undefined"_s);
+    }
+    if (value.isBigInt()) {
+        auto str = value.toStringOrNull(globalObject);
+        if (!str) return {};
+        return makeString("type bigint ("_s, str->getString(globalObject), "n)"_s);
+    }
+    if (value.isNumber()) {
+        double d = value.asNumber();
+        double infinity = std::numeric_limits<double>::infinity();
+        if (value == 0) return (1 / d == -infinity) ? String("type number (-0)"_s) : String("type number (0)"_s);
+        if (d != d) return String("type number (NaN)"_s);
+        if (d == infinity) return String("type number (Infinity)"_s);
+        if (d == -infinity) return String("type number (-Infinity)"_s);
+        auto str = value.toStringOrNull(globalObject);
+        if (!str) return {};
+        return makeString("type number ("_s, str->getString(globalObject), ")"_s);
+    }
+    if (value.isBoolean()) {
+        return value.asBoolean() ? String("type boolean (true)"_s) : String("type boolean (false)"_s);
+    }
+    if (value.isSymbol()) {
+        auto cell = value.asCell();
+        auto symbol = jsCast<Symbol*>(cell);
+        auto result = symbol->tryGetDescriptiveString();
+        auto description = result.has_value() ? result.value() : String("Symbol()"_s);
+        return makeString("type symbol ("_s, description, ")"_s);
+    }
+    if (value.isCallable()) {
+        auto& vm = globalObject->vm();
+        auto scope = DECLARE_CATCH_SCOPE(vm);
+        auto cell = value.asCell();
+        auto name = JSC::getCalculatedDisplayName(vm, cell->getObject());
+        if (scope.exception()) {
+            scope.clearException();
+            name = String(""_s);
+        }
+        if (!name.isNull() && name.length() > 0) {
+            return makeString("function "_s, name);
+        }
+        return String("function"_s);
+    }
+    if (value.isObject()) {
+        auto constructor = value.get(globalObject, vm.propertyNames->constructor);
+        RETURN_IF_EXCEPTION(scope, {});
+        if (constructor.toBoolean(globalObject)) {
+            auto name = constructor.get(globalObject, vm.propertyNames->name);
+            RETURN_IF_EXCEPTION(scope, {});
+            auto str = name.toString(globalObject);
+            RETURN_IF_EXCEPTION(scope, {});
+            return makeString("an instance of "_s, str->getString(globalObject));
+        }
+        // return `${lazyInternalUtilInspect().inspect(value, { depth: -1 })}`;
+        auto str = JSValueToStringSafe(globalObject, value);
+        RETURN_IF_EXCEPTION(scope, {});
+        return str;
+    }
+    if (value.isString()) {
+        auto str = value.toString(globalObject)->getString(globalObject);
+        if (str.length() > 28) {
+            str = str.substring(0, 25);
+            str = makeString(str, "..."_s);
+            if (!str.contains('\'')) {
+                return makeString("type string ('"_s, str, "')"_s);
+            }
+        }
+        //       return `type string (${JSONStringify(value)})`;
+        str = JSValueToStringSafe(globalObject, value);
+        RETURN_IF_EXCEPTION(scope, {});
+        return makeString("type string ("_s, str, ")"_s);
+    }
+
+    //       value = lazyInternalUtilInspect().inspect(value, { colors: false });
+    auto str = JSValueToStringSafe(globalObject, value);
+    RETURN_IF_EXCEPTION(scope, {});
+    return str;
 }
 
 namespace Message {
 
 WTF::String ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, const StringView& arg_name, const StringView& expected_type, JSValue actual_value)
 {
-    auto actual_value_string = JSValueToStringSafe(globalObject, actual_value);
+    auto actual_value_string = determineSpecificType(globalObject, actual_value);
     RETURN_IF_EXCEPTION(scope, {});
 
-    return makeString("The \""_s, arg_name, "\" argument must be of type "_s, expected_type, ". Received: "_s, actual_value_string);
+    return makeString("The \""_s, arg_name, "\" argument must be of type "_s, expected_type, ". Received "_s, actual_value_string);
 }
 
 WTF::String ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, const StringView& arg_name, ArgList expected_types, JSValue actual_value)
 {
     WTF::StringBuilder result;
 
-    auto actual_value_string = JSValueToStringSafe(globalObject, actual_value);
+    auto actual_value_string = determineSpecificType(globalObject, actual_value);
     RETURN_IF_EXCEPTION(scope, {});
 
-    result.append("The \""_s, arg_name, "\" argument must be of type "_s);
+    result.append("The "_s);
+
+    if (arg_name.contains(' ')) {
+        result.append(arg_name);
+    } else {
+        result.append("\""_s);
+        result.append(arg_name);
+        result.append("\" argument"_s);
+    }
+    result.append(" must be of type "_s);
 
     unsigned length = expected_types.size();
     if (length == 1) {
         result.append(expected_types.at(0).toWTFString(globalObject));
     } else if (length == 2) {
         result.append(expected_types.at(0).toWTFString(globalObject));
-        result.append(" or "_s);
+        result.append(", or "_s);
         result.append(expected_types.at(1).toWTFString(globalObject));
     } else {
         for (unsigned i = 0; i < length - 1; i++) {
@@ -253,11 +355,11 @@ WTF::String ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalObject* gl
             JSValue expected_type = expected_types.at(i);
             result.append(expected_type.toWTFString(globalObject));
         }
-        result.append(" or "_s);
+        result.append(", or "_s);
         result.append(expected_types.at(length - 1).toWTFString(globalObject));
     }
 
-    result.append(". Received: "_s, actual_value_string);
+    result.append(". Received "_s, actual_value_string);
 
     return result.toString();
 }
@@ -295,27 +397,33 @@ WTF::String ERR_OUT_OF_RANGE(JSC::ThrowScope& scope, JSC::JSGlobalObject* global
     auto input = JSValueToStringSafe(globalObject, val_input);
     RETURN_IF_EXCEPTION(scope, {});
 
-    return makeString("The value of \""_s, arg_name, "\" is out of range. It must be "_s, range, ". Received: "_s, input);
+    return makeString("The value of \""_s, arg_name, "\" is out of range. It must be "_s, range, ". Received "_s, input);
 }
 
 }
 
 namespace ERR {
 
-JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, WTF::ASCIILiteral arg_name, WTF::ASCIILiteral expected_type, JSC::JSValue val_actual_value)
+JSC::EncodedJSValue throwCode(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, ErrorCode code, const WTF::String& message)
+{
+    throwScope.throwException(globalObject, createError(globalObject, code, message));
+    return {};
+}
+
+JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& arg_name, const WTF::String& expected_type, JSC::JSValue val_actual_value)
 {
     auto arg_kind = String(arg_name).startsWith("options."_s) ? "property"_s : "argument"_s;
     auto ty_first_char = expected_type[0];
     auto ty_kind = ty_first_char >= 'A' && ty_first_char <= 'Z' ? "an instance of"_s : "of type"_s;
 
-    auto actual_value = JSValueToStringSafe(globalObject, val_actual_value);
+    auto actual_value = determineSpecificType(globalObject, val_actual_value);
     RETURN_IF_EXCEPTION(throwScope, {});
 
     auto message = makeString("The \""_s, arg_name, "\" "_s, arg_kind, " must be "_s, ty_kind, " "_s, expected_type, ". Received "_s, actual_value);
     throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_INVALID_ARG_TYPE, message));
     return {};
 }
-JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue val_arg_name, WTF::ASCIILiteral expected_type, JSC::JSValue val_actual_value)
+JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue val_arg_name, const WTF::String& expected_type, JSC::JSValue val_actual_value)
 {
     auto arg_name = val_arg_name.toWTFString(globalObject);
     RETURN_IF_EXCEPTION(throwScope, {});
@@ -324,7 +432,7 @@ JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalO
     auto ty_first_char = expected_type[0];
     auto ty_kind = ty_first_char >= 'A' && ty_first_char <= 'Z' ? "an instance of"_s : "of type"_s;
 
-    auto actual_value = JSValueToStringSafe(globalObject, val_actual_value);
+    auto actual_value = determineSpecificType(globalObject, val_actual_value);
     RETURN_IF_EXCEPTION(throwScope, {});
 
     auto message = makeString("The \""_s, arg_name, "\" "_s, arg_kind, " must be "_s, ty_kind, " "_s, expected_type, ". Received "_s, actual_value);
@@ -442,8 +550,12 @@ JSC::EncodedJSValue STRING_TOO_LONG(JSC::ThrowScope& throwScope, JSC::JSGlobalOb
     return {};
 }
 
-JSC::EncodedJSValue BUFFER_OUT_OF_BOUNDS(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject)
+JSC::EncodedJSValue BUFFER_OUT_OF_BOUNDS(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& name)
 {
+    if (!name.isEmpty()) {
+        throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_BUFFER_OUT_OF_BOUNDS, makeString("\""_s, name, "\" is outside of buffer bounds"_s)));
+        return {};
+    }
     throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_BUFFER_OUT_OF_BOUNDS, "Attempt to access memory outside buffer bounds"_s));
     return {};
 }

src/bun.js/bindings/ErrorCode.h

@@ -75,8 +75,10 @@ enum Bound {
 
 namespace ERR {
 
-JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, WTF::ASCIILiteral arg_name, WTF::ASCIILiteral expected_type, JSC::JSValue val_actual_value);
-JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue arg_name, WTF::ASCIILiteral expected_type, JSC::JSValue val_actual_value);
+JSC::EncodedJSValue throwCode(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, ErrorCode code, const WTF::String& message);
+
+JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& arg_name, const WTF::String& expected_type, JSC::JSValue val_actual_value);
+JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue val_arg_name, const WTF::String& val_expected_type, JSC::JSValue val_actual_value);
 JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& arg_name, size_t lower, size_t upper, JSC::JSValue actual);
 JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue arg_name, size_t lower, size_t upper, JSC::JSValue actual);
 JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue arg_name_val, size_t bound_num, Bound bound, JSC::JSValue actual);
@@ -87,7 +89,7 @@ JSC::EncodedJSValue INVALID_ARG_VALUE(JSC::ThrowScope& throwScope, JSC::JSGlobal
 JSC::EncodedJSValue UNKNOWN_ENCODING(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& encoding);
 JSC::EncodedJSValue INVALID_STATE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& statemsg);
 JSC::EncodedJSValue STRING_TOO_LONG(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject);
-JSC::EncodedJSValue BUFFER_OUT_OF_BOUNDS(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject);
+JSC::EncodedJSValue BUFFER_OUT_OF_BOUNDS(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& name);
 JSC::EncodedJSValue UNKNOWN_SIGNAL(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue signal, bool triedUppercase = false);
 JSC::EncodedJSValue SOCKET_BAD_PORT(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue name, JSC::JSValue port, bool allowZero);