events: repurpose events.listenerCount() to accept EventTargets

PR-URL: nodejs#60214
Reviewed-By: Matteo Collina <[email protected]>
Reviewed-By: Benjamin Gruenbaum <[email protected]>

Author: Renegade334

doc/api/deprecations.md

@@ -786,6 +786,9 @@ The [`domain`][] module is deprecated and should not be used.
 
 <!-- YAML
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/60214
+    description: Deprecation revoked.
   - version:
     - v6.12.0
     - v4.8.6
@@ -796,10 +799,12 @@ changes:
     description: Documentation-only deprecation.
 -->
 
-Type: Documentation-only
+Type: Revoked
 
-The [`events.listenerCount(emitter, eventName)`][] API is
-deprecated. Please use [`emitter.listenerCount(eventName)`][] instead.
+The [`events.listenerCount(emitter, eventName)`][] API was deprecated, as it
+provided identical fuctionality to [`emitter.listenerCount(eventName)`][]. The
+deprecation was revoked because this function has been repurposed to also
+accept {EventTarget} arguments.
 
 ### DEP0034: `fs.exists(path, callback)`
 
@@ -4428,7 +4433,7 @@ import { opendir } from 'node:fs/promises';
 [`domain`]: domain.md
 [`ecdh.setPublicKey()`]: crypto.md#ecdhsetpublickeypublickey-encoding
 [`emitter.listenerCount(eventName)`]: events.md#emitterlistenercounteventname-listener
-[`events.listenerCount(emitter, eventName)`]: events.md#eventslistenercountemitter-eventname
+[`events.listenerCount(emitter, eventName)`]: events.md#eventslistenercountemitterortarget-eventname
 [`fs.Dir`]: fs.md#class-fsdir
 [`fs.FileHandle`]: fs.md#class-filehandle
 [`fs.access()`]: fs.md#fsaccesspath-mode-callback

doc/api/events.md

@@ -1622,39 +1622,66 @@ changes:
 
 See how to write a custom [rejection handler][rejection].
 
-## `events.listenerCount(emitter, eventName)`
+## `events.listenerCount(emitterOrTarget, eventName)`
 
 <!-- YAML
 added: v0.9.12
-deprecated: v3.2.0
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/60214
+    description: Now accepts EventTarget arguments.
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/60214
+    description: Deprecation revoked.
+  - version: v3.2.0
+    pr-url: https://github.com/nodejs/node/pull/2349
+    description: Documentation-only deprecation.
 -->
 
-> Stability: 0 - Deprecated: Use [`emitter.listenerCount()`][] instead.
+* `emitterOrTarget` {EventEmitter|EventTarget}
+* `eventName` {string|symbol}
+* Returns: {integer}
+
+Returns the number of registered listeners for the event named `eventName`.
 
-* `emitter` {EventEmitter} The emitter to query
-* `eventName` {string|symbol} The event name
+For `EventEmitter`s this behaves exactly the same as calling `.listenerCount`
+on the emitter.
 
-A class method that returns the number of listeners for the given `eventName`
-registered on the given `emitter`.
+For `EventTarget`s this is the only way to obtain the listener count. This can
+be useful for debugging and diagnostic purposes.
 
 ```mjs
 import { EventEmitter, listenerCount } from 'node:events';
 
-const myEmitter = new EventEmitter();
-myEmitter.on('event', () => {});
-myEmitter.on('event', () => {});
-console.log(listenerCount(myEmitter, 'event'));
-// Prints: 2
+{
+  const ee = new EventEmitter();
+  ee.on('event', () => {});
+  ee.on('event', () => {});
+  console.log(listenerCount(ee, 'event')); // 2
+}
+{
+  const et = new EventTarget();
+  et.addEventListener('event', () => {});
+  et.addEventListener('event', () => {});
+  console.log(listenerCount(et, 'event')); // 2
+}
 ```
 
 ```cjs
 const { EventEmitter, listenerCount } = require('node:events');
 
-const myEmitter = new EventEmitter();
-myEmitter.on('event', () => {});
-myEmitter.on('event', () => {});
-console.log(listenerCount(myEmitter, 'event'));
-// Prints: 2
+{
+  const ee = new EventEmitter();
+  ee.on('event', () => {});
+  ee.on('event', () => {});
+  console.log(listenerCount(ee, 'event')); // 2
+}
+{
+  const et = new EventTarget();
+  et.addEventListener('event', () => {});
+  et.addEventListener('event', () => {});
+  console.log(listenerCount(et, 'event')); // 2
+}
 ```
 
 ## `events.on(emitter, eventName[, options])`
@@ -2648,7 +2675,6 @@ to the `EventTarget`.
 [`Event` Web API]: https://dom.spec.whatwg.org/#event
 [`domain`]: domain.md
 [`e.stopImmediatePropagation()`]: #eventstopimmediatepropagation
-[`emitter.listenerCount()`]: #emitterlistenercounteventname-listener
 [`emitter.removeListener()`]: #emitterremovelistenereventname-listener
 [`emitter.setMaxListeners(n)`]: #emittersetmaxlistenersn
 [`event.defaultPrevented`]: #eventdefaultprevented

lib/events.js

@@ -33,7 +33,6 @@ const {
   Error,
   ErrorCaptureStackTrace,
   FunctionPrototypeBind,
-  FunctionPrototypeCall,
   NumberMAX_SAFE_INTEGER,
   ObjectDefineProperties,
   ObjectDefineProperty,
@@ -215,6 +214,7 @@ module.exports.once = once;
 module.exports.on = on;
 module.exports.getEventListeners = getEventListeners;
 module.exports.getMaxListeners = getMaxListeners;
+module.exports.listenerCount = listenerCount;
 // Backwards-compat with node 0.10.x
 EventEmitter.EventEmitter = EventEmitter;
 
@@ -813,31 +813,14 @@ EventEmitter.prototype.rawListeners = function rawListeners(type) {
   return _listeners(this, type, false);
 };
 
-/**
- * Returns the number of listeners listening to the event name
- * specified as `type`.
- * @deprecated since v3.2.0
- * @param {EventEmitter} emitter
- * @param {string | symbol} type
- * @returns {number}
- */
-EventEmitter.listenerCount = function(emitter, type) {
-  if (typeof emitter.listenerCount === 'function') {
-    return emitter.listenerCount(type);
-  }
-  return FunctionPrototypeCall(listenerCount, emitter, type);
-};
-
-EventEmitter.prototype.listenerCount = listenerCount;
-
 /**
  * Returns the number of listeners listening to event name
  * specified as `type`.
  * @param {string | symbol} type
- * @param {Function} listener
+ * @param {Function} [listener]
  * @returns {number}
  */
-function listenerCount(type, listener) {
+EventEmitter.prototype.listenerCount = function listenerCount(type, listener) {
   const events = this._events;
 
   if (events !== undefined) {
@@ -867,7 +850,7 @@ function listenerCount(type, listener) {
   }
 
   return 0;
-}
+};
 
 /**
  * Returns an array listing the events for which
@@ -949,6 +932,25 @@ function getMaxListeners(emitterOrTarget) {
                                  emitterOrTarget);
 }
 
+/**
+ * Returns the number of registered listeners for `type`.
+ * @param {EventEmitter | EventTarget} emitterOrTarget
+ * @param {string | symbol} type
+ * @returns {number}
+ */
+function listenerCount(emitterOrTarget, type) {
+  if (typeof emitterOrTarget.listenerCount === 'function') {
+    return emitterOrTarget.listenerCount(type);
+  }
+  const { isEventTarget, kEvents } = require('internal/event_target');
+  if (isEventTarget(emitterOrTarget)) {
+    return emitterOrTarget[kEvents].get(type)?.size ?? 0;
+  }
+  throw new ERR_INVALID_ARG_TYPE('emitter',
+                                 ['EventEmitter', 'EventTarget'],
+                                 emitterOrTarget);
+}
+
 /**
  * Creates a `Promise` that is fulfilled when the emitter
  * emits the given event.

lib/internal/streams/legacy.js

@@ -59,7 +59,8 @@ Stream.prototype.pipe = function(dest, options) {
   // Don't leave dangling pipes when there are errors.
   function onerror(er) {
     cleanup();
-    if (EE.listenerCount(this, 'error') === 0) {
+    // If we removed the last error handler, trigger an unhandled error event.
+    if (this.listenerCount?.('error') === 0) {
       this.emit('error', er);
     }
   }

test/parallel/test-aborted-util.js

@@ -4,7 +4,7 @@
 const common = require('../common');
 const { aborted } = require('util');
 const assert = require('assert');
-const { getEventListeners } = require('events');
+const { listenerCount } = require('events');
 const { inspect } = require('util');
 
 const {
@@ -17,7 +17,7 @@ test('Aborted works when provided a resource', async () => {
   ac.abort();
   await promise;
   assert.strictEqual(ac.signal.aborted, true);
-  assert.strictEqual(getEventListeners(ac.signal, 'abort').length, 0);
+  assert.strictEqual(listenerCount(ac.signal, 'abort'), 0);
 });
 
 test('Aborted with gc cleanup', async () => {
@@ -31,7 +31,7 @@ test('Aborted with gc cleanup', async () => {
     globalThis.gc();
     ac.abort();
     assert.strictEqual(ac.signal.aborted, true);
-    assert.strictEqual(getEventListeners(ac.signal, 'abort').length, 0);
+    assert.strictEqual(listenerCount(ac.signal, 'abort'), 0);
     resolve();
   }));
 

test/parallel/test-child-process-execfile.js

@@ -3,7 +3,7 @@
 const common = require('../common');
 const assert = require('assert');
 const { execFile, execFileSync } = require('child_process');
-const { getEventListeners } = require('events');
+const { listenerCount } = require('events');
 const { getSystemErrorName } = require('util');
 const fixtures = require('../common/fixtures');
 const os = require('os');
@@ -106,7 +106,7 @@ common.expectWarning(
   const { signal } = ac;
 
   const callback = common.mustCall((err) => {
-    assert.strictEqual(getEventListeners(ac.signal).length, 0);
+    assert.strictEqual(listenerCount(ac.signal, 'abort'), 0);
     assert.strictEqual(err, null);
   });
   execFile(process.execPath, [fixture, 0], { signal }, callback);

test/parallel/test-child-process-fork-timeout-kill-signal.js

@@ -4,7 +4,7 @@ const { mustCall } = require('../common');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const { fork } = require('child_process');
-const { getEventListeners } = require('events');
+const { listenerCount } = require('events');
 
 {
   // Verify default signal
@@ -43,8 +43,8 @@ const { getEventListeners } = require('events');
     timeout: 6,
     signal,
   });
-  assert.strictEqual(getEventListeners(signal, 'abort').length, 1);
+  assert.strictEqual(listenerCount(signal, 'abort'), 1);
   cp.on('exit', mustCall(() => {
-    assert.strictEqual(getEventListeners(signal, 'abort').length, 0);
+    assert.strictEqual(listenerCount(signal, 'abort'), 0);
   }));
 }

test/parallel/test-child-process-spawn-timeout-kill-signal.js

@@ -4,7 +4,7 @@ const { mustCall } = require('../common');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const { spawn } = require('child_process');
-const { getEventListeners } = require('events');
+const { listenerCount } = require('events');
 
 const aliveForeverFile = 'child-process-stay-alive-forever.js';
 {
@@ -43,8 +43,8 @@ const aliveForeverFile = 'child-process-stay-alive-forever.js';
     timeout: 6,
     signal,
   });
-  assert.strictEqual(getEventListeners(signal, 'abort').length, 1);
+  assert.strictEqual(listenerCount(signal, 'abort'), 1);
   cp.on('exit', mustCall(() => {
-    assert.strictEqual(getEventListeners(signal, 'abort').length, 0);
+    assert.strictEqual(listenerCount(signal, 'abort'), 0);
   }));
 }

test/parallel/test-events-once.js

@@ -2,7 +2,7 @@
 // Flags: --no-warnings
 
 const common = require('../common');
-const { once, EventEmitter, getEventListeners } = require('events');
+const { once, EventEmitter, listenerCount } = require('events');
 const assert = require('assert');
 
 async function onceAnEvent() {
@@ -72,7 +72,7 @@ async function catchesErrorsWithAbortSignal() {
   try {
     const promise = once(ee, 'myevent', { signal });
     assert.strictEqual(ee.listenerCount('error'), 1);
-    assert.strictEqual(getEventListeners(signal, 'abort').length, 1);
+    assert.strictEqual(listenerCount(signal, 'abort'), 1);
 
     await promise;
   } catch (e) {
@@ -81,7 +81,7 @@ async function catchesErrorsWithAbortSignal() {
   assert.strictEqual(err, expected);
   assert.strictEqual(ee.listenerCount('error'), 0);
   assert.strictEqual(ee.listenerCount('myevent'), 0);
-  assert.strictEqual(getEventListeners(signal, 'abort').length, 0);
+  assert.strictEqual(listenerCount(signal, 'abort'), 0);
 }
 
 async function stopListeningAfterCatchingError() {
@@ -191,9 +191,9 @@ async function abortSignalAfterEvent() {
     ac.abort();
   });
   const promise = once(ee, 'foo', { signal: ac.signal });
-  assert.strictEqual(getEventListeners(ac.signal, 'abort').length, 1);
+  assert.strictEqual(listenerCount(ac.signal, 'abort'), 1);
   await promise;
-  assert.strictEqual(getEventListeners(ac.signal, 'abort').length, 0);
+  assert.strictEqual(listenerCount(ac.signal, 'abort'), 0);
 }
 
 async function abortSignalRemoveListener() {

test/parallel/test-eventtarget.js

@@ -9,7 +9,7 @@ const {
 
 const assert = require('assert');
 
-const { once } = require('events');
+const { listenerCount, once } = require('events');
 
 const { inspect } = require('util');
 const { setTimeout: delay } = require('timers/promises');
@@ -141,10 +141,13 @@ let asyncTest = Promise.resolve();
 
   eventTarget.addEventListener('foo', ev1);
   eventTarget.addEventListener('foo', ev2, { once: true });
+  assert.strictEqual(listenerCount(eventTarget, 'foo'), 2);
   assert.ok(eventTarget.dispatchEvent(new Event('foo')));
+  assert.strictEqual(listenerCount(eventTarget, 'foo'), 1);
   eventTarget.dispatchEvent(new Event('foo'));
 
   eventTarget.removeEventListener('foo', ev1);
+  assert.strictEqual(listenerCount(eventTarget, 'foo'), 0);
   eventTarget.dispatchEvent(new Event('foo'));
 }
 {