ai slop

src/bun.js/bindings/JSMockFunction.cpp

@@ -86,6 +86,7 @@
 }
 
 JSC_DECLARE_HOST_FUNCTION(jsMockFunctionCall);
+JSC_DECLARE_HOST_FUNCTION(jsMockFunctionConstruct);
 JSC_DECLARE_CUSTOM_GETTER(jsMockFunctionGetter_protoImpl);
 JSC_DECLARE_CUSTOM_GETTER(jsMockFunctionGetter_mock);
 JSC_DECLARE_HOST_FUNCTION(jsMockFunctionGetter_mockGetLastCall);
@@ -462,7 +463,7 @@
     }
 
     JSMockFunction(JSC::VM& vm, JSC::Structure* structure, CallbackKind wrapKind)
-        : Base(vm, structure, jsMockFunctionCall, jsMockFunctionCall)
+        : Base(vm, structure, jsMockFunctionCall, jsMockFunctionConstruct)
     {
         initMock();
     }
@@ -978,9 +979,21 @@
     }
 
     setReturnValue(createMockResult(vm, globalObject, "return"_s, jsUndefined()));
     return JSValue::encode(jsUndefined());
 }
 
+JSC_DEFINE_HOST_FUNCTION(jsMockFunctionConstruct, (JSGlobalObject * lexicalGlobalObject, CallFrame* callframe))
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSC::EncodedJSValue encodedResult = jsMockFunctionCall(lexicalGlobalObject, callframe);
+    RETURN_IF_EXCEPTION(scope, {});
+    JSValue result = JSValue::decode(encodedResult);
+    if (!result.isObject())
+        return JSValue::encode(JSC::constructEmptyObject(lexicalGlobalObject));
+    return encodedResult;
+}
+
 void JSMockFunctionPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);

src/bun.js/bindings/webcore/Worker.cpp

@@ -133,12 +133,21 @@ extern "C" void WebWorker__setRef(
 
 void Worker::setKeepAlive(bool keepAlive)
 {
-    WebWorker__setRef(impl_, keepAlive);
+    Locker locker { m_implLock };
+    if (impl_)
+        WebWorker__setRef(impl_, keepAlive);
+}
+
+void Worker::clearZigImpl()
+{
+    Locker locker { m_implLock };
+    impl_ = nullptr;
 }
 
 bool Worker::updatePtr()
 {
     if (!WebWorker__updatePtr(impl_, this)) {
+        clearZigImpl();
         m_onlineClosingFlags = ClosingFlag;
         m_terminationFlags.fetch_or(TerminatedFlag);
         return false;
@@ -263,7 +272,9 @@ void Worker::terminate()
 {
     // m_contextProxy.terminateWorkerGlobalScope();
     m_terminationFlags.fetch_or(TerminateRequestedFlag);
-    WebWorker__notifyNeedTermination(impl_);
+    Locker locker { m_implLock };
+    if (impl_)
+        WebWorker__notifyNeedTermination(impl_);
 }
 
 // const char* Worker::activeDOMObjectName() const
@@ -468,6 +479,8 @@ void Worker::forEachWorker(const Function<Function<void(ScriptExecutionContext&)
 extern "C" void WebWorker__dispatchExit(Zig::GlobalObject* globalObject, Worker* worker, int32_t exitCode)
 {
     worker->dispatchExit(exitCode);
+    // The Zig WebWorker is about to be freed; prevent terminate()/ref()/unref() from touching it.
+    worker->clearZigImpl();
     // no longer referenced by Zig
     worker->deref();
 

src/bun.js/bindings/webcore/Worker.h

@@ -76,6 +76,7 @@ class Worker final : public ThreadSafeRefCounted<Worker>, public EventTargetWith
     void dispatchEvent(Event&);
     void dispatchCloseEvent(Event&);
     void setKeepAlive(bool);
+    void clearZigImpl();
 
     void postTaskToWorkerGlobalScope(Function<void(ScriptExecutionContext&)>&&);
 
@@ -119,6 +120,7 @@ class Worker final : public ThreadSafeRefCounted<Worker>, public EventTargetWith
     // Tracks TerminateRequestedFlag and TerminatedFlag
     std::atomic<uint8_t> m_terminationFlags { 0 };
     const ScriptExecutionContextIdentifier m_clientIdentifier;
+    Lock m_implLock;
     void* impl_ { nullptr };
 };
 

test/js/bun/test/mock-construct.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, mock, test } from "bun:test";
+
+describe("mock() used as a constructor", () => {
+  test("Reflect.construct with no implementation returns an object", () => {
+    const m = mock();
+    const r = Reflect.construct(m, []);
+    expect(typeof r).toBe("object");
+    expect(r).not.toBeNull();
+  });
+
+  test("Reflect.construct with a different newTarget returns an object", () => {
+    const m = mock();
+    const r = Reflect.construct(m, [], function () {});
+    expect(typeof r).toBe("object");
+    expect(r).not.toBeNull();
+  });
+
+  test("Reflect.construct with implementation returning a primitive returns an object", () => {
+    const m = mock(() => 42);
+    const r = Reflect.construct(m, []);
+    expect(typeof r).toBe("object");
+    expect(r).not.toBeNull();
+  });
+
+  test("Reflect.construct with mockReturnValue(primitive) returns an object", () => {
+    const m = mock().mockReturnValue(7);
+    const r = Reflect.construct(m, []);
+    expect(typeof r).toBe("object");
+    expect(r).not.toBeNull();
+  });
+
+  test("Reflect.construct preserves object return values", () => {
+    const obj = { hello: "world" };
+    const m = mock(() => obj);
+    const r = Reflect.construct(m, []);
+    expect(r).toBe(obj);
+  });
+
+  test("calling without new still returns the implementation's value", () => {
+    const m1 = mock();
+    expect(m1()).toBeUndefined();
+    const m2 = mock(() => 42);
+    expect(m2()).toBe(42);
+    const m3 = mock().mockReturnValue("x");
+    expect(m3()).toBe("x");
+  });
+});

test/js/web/workers/worker-terminate-after-exit.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+
+describe("Worker", () => {
+  test("terminate()/ref()/unref() after the worker has exited does not crash", async () => {
+    const url = URL.createObjectURL(new Blob(["/* exits immediately */"], { type: "application/javascript" }));
+    try {
+      const workers: Worker[] = [];
+      for (let i = 0; i < 4; i++) {
+        const w = new Worker(url);
+        workers.push(w);
+      }
+
+      await Promise.all(
+        workers.map(w => {
+          const { promise, resolve } = Promise.withResolvers<void>();
+          w.addEventListener("close", () => resolve(), { once: true });
+          return promise;
+        }),
+      );
+
+      Bun.gc(true);
+
+      for (const w of workers) {
+        w.terminate();
+        w.ref();
+        w.unref();
+        w.terminate();
+      }
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+
+    expect(true).toBe(true);
+  });
+});