events: add fast and slow path

lib/internal/events/fast_event_emitter.js

@@ -0,0 +1,169 @@
+'use strict';
+
+const { kShapeMode, kErrorMonitor } = require('internal/events/symbols');
+const {
+  throwErrorOnMissingErrorHandler,
+  addCatch,
+} = require('internal/events/shared_internal_event_emitter');
+
+/**
+ * This class is optimized for the case where there is only a single listener for each event.
+ * it supports kCapture
+ * but does not support event types that {@link isEventUnsupportedForFastPath} returns false for
+ */
+function FastEventEmitter(eventEmitterTranslationLayer, _events) {
+  this.eventEmitterTranslationLayer = eventEmitterTranslationLayer;
+  this._events = _events;
+}
+
+/**
+ * The events are stored here as Record<string, function | undefined>
+ */
+FastEventEmitter.prototype._events = undefined;
+FastEventEmitter.prototype[kShapeMode] = undefined;
+FastEventEmitter.prototype._eventsCount = 0;
+FastEventEmitter.prototype.eventEmitterTranslationLayer = undefined;
+
+/**
+ * Synchronously calls each of the listeners registered
+ * for the event.
+ * @param {string | symbol} type
+ * @param {...any} [args]
+ * @returns {boolean}
+ */
+FastEventEmitter.prototype.emit = function emit(type, ...args) {
+  const events = this._events;
+
+  if (type === 'error' && events?.error === undefined) {
+    throwErrorOnMissingErrorHandler.apply(this.eventEmitterTranslationLayer, args);
+  }
+
+  const handler = events[type];
+
+  if (handler === undefined) {
+    return false;
+  }
+
+  const result = handler.apply(this.eventEmitterTranslationLayer, args);
+
+  // We check if result is undefined first because that
+  // is the most common case so we do not pay any perf
+  // penalty
+  if (result !== undefined && result !== null) {
+    addCatch(this.eventEmitterTranslationLayer, result, type, args);
+  }
+
+  return true;
+};
+
+FastEventEmitter.prototype.isListenerAlreadyExists = function isListenerAlreadyExists(type) {
+  return this._events?.[type] !== undefined;
+};
+
+/**
+ * Adds a listener to the event emitter.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @param {boolean} prepend not used here as we are in fast mode and only have single listener
+ */
+FastEventEmitter.prototype.addListener = function addListener(type, listener, prepend = undefined) {
+  let events;
+
+  events = this._events;
+  if (events === undefined) {
+    events = this._events = {};
+    this._eventsCount = 0;
+
+    // Not emitting `newListener` here as in fast path we don't have it
+  }
+
+  // Optimize the case of one listener. Don't need the extra array object.
+  events[type] = listener;
+  ++this._eventsCount;
+};
+
+/**
+ * Removes the specified `listener`.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ */
+FastEventEmitter.prototype.removeListener = function removeListener(type, listener) {
+  const events = this._events;
+  if (events === undefined)
+    return undefined;
+
+  const list = events[type];
+  if (list === undefined || (list !== listener && list.listener !== listener))
+    return undefined;
+
+  this._eventsCount -= 1;
+
+  if (this[kShapeMode]) {
+    events[type] = undefined;
+  } else if (this._eventsCount === 0) {
+    this._events = { };
+  } else {
+    delete events[type];
+    // Not emitting `removeListener` here as in fast path we don't have it
+  }
+};
+
+
+/**
+ * Removes all listeners from the event emitter. (Only
+ * removes listeners for a specific event name if specified
+ * as `type`).
+ * @param {string | symbol} [type]
+ */
+FastEventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
+  const events = this._events;
+  if (events === undefined)
+    return undefined;
+
+  if (arguments.length === 0) {
+    this._events = { };
+    this._eventsCount = 0;
+  } else if (events[type] !== undefined) {
+    if (--this._eventsCount === 0)
+      this._events = { };
+    else
+      delete events[type];
+  }
+
+  this[kShapeMode] = false;
+
+  return undefined;
+};
+
+
+function isEventUnsupportedForFastPath(type) {
+  return (
+    // Not supporting newListener and removeListener events in fast path
+    // as they can add new listeners in the middle of the process
+    type === 'newListener' ||
+    type === 'removeListener' ||
+
+    // Not supporting errorMonitor event as it has special handling
+    type === kErrorMonitor ||
+
+    // Not supporting Object prototype keys as fast path object is not an object with null prototype
+    type === 'constructor' ||
+    type === '__defineGetter__' ||
+    type === '__defineSetter__' ||
+    type === 'hasOwnProperty' ||
+    type === '__lookupGetter__' ||
+    type === '__lookupSetter__' ||
+    type === 'isPrototypeOf' ||
+    type === 'propertyIsEnumerable' ||
+    type === 'toString' ||
+    type === 'valueOf' ||
+    type === '__proto__' ||
+    type === 'toLocaleString'
+  );
+}
+
+
+module.exports = {
+  FastEventEmitter,
+  isEventUnsupportedForFastPath,
+};

lib/internal/events/shared_internal_event_emitter.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const {
+  ArrayPrototypeJoin,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSplice,
+  Error,
+  ErrorCaptureStackTrace,
+  FunctionPrototypeBind,
+  ObjectDefineProperty,
+  StringPrototypeSplit,
+} = primordials;
+
+const { kCapture, kRejection } = require('internal/events/symbols');
+const { inspect, identicalSequenceRange } = require('internal/util/inspect');
+
+const {
+  codes: {
+    ERR_UNHANDLED_ERROR,
+  },
+  kEnhanceStackBeforeInspector,
+} = require('internal/errors');
+
+let EventEmitter;
+
+function arrayClone(arr) {
+  // At least since V8 8.3, this implementation is faster than the previous
+  // which always used a simple for-loop
+  switch (arr.length) {
+    case 2: return [arr[0], arr[1]];
+    case 3: return [arr[0], arr[1], arr[2]];
+    case 4: return [arr[0], arr[1], arr[2], arr[3]];
+    case 5: return [arr[0], arr[1], arr[2], arr[3], arr[4]];
+    case 6: return [arr[0], arr[1], arr[2], arr[3], arr[4], arr[5]];
+  }
+  return ArrayPrototypeSlice(arr);
+}
+
+
+function addCatch(that, promise, type, args) {
+  if (!that[kCapture]) {
+    return;
+  }
+
+  // Handle Promises/A+ spec, then could be a getter
+  // that throws on second use.
+  try {
+    const then = promise.then;
+
+    if (typeof then === 'function') {
+      then.call(promise, undefined, function(err) {
+        // The callback is called with nextTick to avoid a follow-up
+        // rejection from this promise.
+        process.nextTick(emitUnhandledRejectionOrErr, that, err, type, args);
+      });
+    }
+  } catch (err) {
+    that.emit('error', err);
+  }
+}
+
+function emitUnhandledRejectionOrErr(ee, err, type, args) {
+  if (typeof ee[kRejection] === 'function') {
+    ee[kRejection](err, type, ...args);
+  } else {
+    // We have to disable the capture rejections mechanism, otherwise
+    // we might end up in an infinite loop.
+    const prev = ee[kCapture];
+
+    // If the error handler throws, it is not catchable and it
+    // will end up in 'uncaughtException'. We restore the previous
+    // value of kCapture in case the uncaughtException is present
+    // and the exception is handled.
+    try {
+      ee[kCapture] = false;
+      ee.emit('error', err);
+    } finally {
+      ee[kCapture] = prev;
+    }
+  }
+}
+
+
+function throwErrorOnMissingErrorHandler(...args) {
+  let er;
+  if (args.length > 0)
+    er = args[0];
+
+  if (er instanceof Error) {
+    try {
+      const capture = {};
+      EventEmitter ??= require('internal/events/event_emitter').EventEmitter;
+      ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);
+      ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {
+        __proto__: null,
+        value: FunctionPrototypeBind(enhanceStackTrace, this, er, capture),
+        configurable: true,
+      });
+    } catch {
+      // Continue regardless of error.
+    }
+
+    // Note: The comments on the `throw` lines are intentional, they show
+    // up in Node's output if this results in an unhandled exception.
+    throw er; // Unhandled 'error' event
+  }
+
+  let stringifiedEr;
+  try {
+    stringifiedEr = inspect(er);
+  } catch {
+    stringifiedEr = er;
+  }
+
+  // At least give some kind of context to the user
+  const err = new ERR_UNHANDLED_ERROR(stringifiedEr);
+  err.context = er;
+  throw err; // Unhandled 'error' event
+}
+
+
+function enhanceStackTrace(err, own) {
+  let ctorInfo = '';
+  try {
+    const { name } = this.constructor;
+    if (name !== 'EventEmitter')
+      ctorInfo = ` on ${name} instance`;
+  } catch {
+    // Continue regardless of error.
+  }
+  const sep = `\nEmitted 'error' event${ctorInfo} at:\n`;
+
+  const errStack = ArrayPrototypeSlice(
+    StringPrototypeSplit(err.stack, '\n'), 1);
+  const ownStack = ArrayPrototypeSlice(
+    StringPrototypeSplit(own.stack, '\n'), 1);
+
+  const { len, offset } = identicalSequenceRange(ownStack, errStack);
+  if (len > 0) {
+    ArrayPrototypeSplice(ownStack, offset + 1, len - 2,
+                         '    [... lines matching original stack trace ...]');
+  }
+
+  return err.stack + sep + ArrayPrototypeJoin(ownStack, '\n');
+}
+
+module.exports = {
+  arrayClone,
+  addCatch,
+  throwErrorOnMissingErrorHandler,
+};