Revert mustCall to process-exit pattern matching Node.js common.mustCall

Use a regular function wrapper with fn.apply(this, args) to preserve
receiver binding, and verify call counts on process exit instead of
returning a [wrapper, called] Promise tuple.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: kraenhansen

implementors/node/must-call.js

@@ -1,27 +1,26 @@
+const pendingCalls = [];
+
 /**
- * Wraps a function and returns a [wrapper, called] tuple.
- * - `wrapper` — call this in place of the original function
- * - `called` — a Promise that resolves (with the return value of fn) once
- *   wrapper has been invoked
- *
- * If `fn` is omitted, a no-op function is used.
+ * Wraps a function and asserts it is called exactly `exact` times before the
+ * process exits. If `fn` is omitted, a no-op function is used.
  *
  * Usage:
- *   const [onResolve, resolved] = mustCall((result) => {
+ *   promise.then(mustCall((result) => {
  *     assert.strictEqual(result, 42);
- *   });
- *   promise.then(onResolve);
- *   await resolved;
+ *   }));
  */
-const mustCall = (fn) => {
-  let resolve;
-  const called = new Promise((r) => { resolve = r; });
-  const wrapper = (...args) => {
-    const result = fn ? fn(...args) : undefined;
-    resolve(result);
-    return result;
+const mustCall = (fn, exact = 1) => {
+  const entry = {
+    exact,
+    actual: 0,
+    name: fn?.name || "<anonymous>",
+    error: new Error(), // capture call-site stack
+  };
+  pendingCalls.push(entry);
+  return function(...args) {
+    entry.actual++;
+    if (fn) return fn.apply(this, args);
   };
-  return [wrapper, called];
 };
 
 /**
@@ -33,4 +32,15 @@ const mustNotCall = (msg) => {
   };
 };
 
+process.on("exit", () => {
+  for (const entry of pendingCalls) {
+    if (entry.actual !== entry.exact) {
+      entry.error.message =
+        `mustCall "${entry.name}" expected ${entry.exact} call(s) ` +
+        `but got ${entry.actual}`;
+      throw entry.error;
+    }
+  }
+});
+
 Object.assign(globalThis, { mustCall, mustNotCall });

tests/harness/must-call.js

@@ -3,34 +3,27 @@ if (typeof mustCall !== 'function') {
   throw new Error('Expected a global mustCall function');
 }
 
-// mustCall returns a [wrapper, called] tuple
+// mustCall returns a wrapper function (not a tuple)
 {
-  const [wrapper, called] = mustCall();
+  const wrapper = mustCall();
   if (typeof wrapper !== 'function') {
-    throw new Error('mustCall()[0] must be a function');
-  }
-  if (!(called instanceof Promise)) {
-    throw new Error('mustCall()[1] must be a Promise');
+    throw new Error('mustCall() must return a function');
   }
   wrapper();
-  await called;
 }
 
 // mustCall forwards arguments and return value
 {
-  const [wrapper, called] = mustCall((a, b) => a + b);
+  const wrapper = mustCall((a, b) => a + b);
   const result = wrapper(2, 3);
   assert.strictEqual(result, 5);
-  const resolvedValue = await called;
-  assert.strictEqual(resolvedValue, 5);
 }
 
 // mustCall without fn argument works as a no-op wrapper
 {
-  const [wrapper, called] = mustCall();
+  const wrapper = mustCall();
   const result = wrapper('ignored');
   assert.strictEqual(result, undefined);
-  await called;
 }
 
 // mustNotCall is a function

tests/js-native-api/3_callbacks/test.js

@@ -1,20 +1,14 @@
 'use strict';
 const addon = loadAddon('3_callbacks');
 
-let called = false;
-addon.RunCallback((msg) => {
+addon.RunCallback(mustCall((msg) => {
   assert.strictEqual(msg, 'hello world');
-  called = true;
-});
-assert(called);
+}));
 
 function testRecv(desiredRecv) {
-  let recvCalled = false;
-  addon.RunCallbackWithRecv(function() {
+  addon.RunCallbackWithRecv(mustCall(function() {
     assert.strictEqual(this, desiredRecv);
-    recvCalled = true;
-  }, desiredRecv);
-  assert(recvCalled);
+  }), desiredRecv);
 }
 
 testRecv(undefined);

tests/js-native-api/test_promise/test.js

@@ -5,37 +5,35 @@ const test_promise = loadAddon('test_promise');
 {
   const expected_result = 42;
   const promise = test_promise.createPromise();
-  const [onResolve, resolved] = mustCall((result) => {
-    assert.strictEqual(result, expected_result);
-  });
-  promise.then(onResolve);
+  promise.then(
+    mustCall((result) => {
+      assert.strictEqual(result, expected_result);
+    }));
   test_promise.concludeCurrentPromise(expected_result, true);
-  await resolved;
 }
 
 // A rejection
 {
   const expected_result = 'It\'s not you, it\'s me.';
   const promise = test_promise.createPromise();
-  const [onReject, rejected] = mustCall((result) => {
-    assert.strictEqual(result, expected_result);
-  });
-  const [onThen, thenCalled] = mustCall();
-  promise.then(mustNotCall(), onReject).then(onThen);
+  promise.then(
+    mustNotCall(),
+    mustCall(function(result) {
+      assert.strictEqual(result, expected_result);
+    }))
+    .then(mustCall());
   test_promise.concludeCurrentPromise(expected_result, false);
-  await thenCalled;
 }
 
 // Chaining
 {
   const expected_result = 'chained answer';
   const promise = test_promise.createPromise();
-  const [onResolve, resolved] = mustCall((result) => {
-    assert.strictEqual(result, expected_result);
-  });
-  promise.then(onResolve);
+  promise.then(
+    mustCall((result) => {
+      assert.strictEqual(result, expected_result);
+    }));
   test_promise.concludeCurrentPromise(Promise.resolve('chained answer'), true);
-  await resolved;
 }
 
 const promiseTypeTestPromise = test_promise.createPromise();
@@ -45,11 +43,9 @@ test_promise.concludeCurrentPromise(undefined, true);
 const rejectPromise = Promise.reject(-1);
 const expected_reason = -1;
 assert.strictEqual(test_promise.isPromise(rejectPromise), true);
-const [onCatch, caught] = mustCall((reason) => {
+rejectPromise.catch(mustCall((reason) => {
   assert.strictEqual(reason, expected_reason);
-});
-rejectPromise.catch(onCatch);
-await caught;
+}));
 
 assert.strictEqual(test_promise.isPromise(2.4), false);
 assert.strictEqual(test_promise.isPromise('I promise!'), false);