events: refactor to use more primordials

lib/events.js

@@ -22,10 +22,19 @@
 'use strict';
 
 const {
+ ArrayPrototypeForEach,
+ ArrayPrototypeIndexOf,
+ ArrayPrototypeJoin,
  ArrayPrototypePush,
+ ArrayPrototypeShift,
+ ArrayPrototypeSlice,
+ ArrayPrototypeSplice,
+ ArrayPrototypeUnshift,
  Boolean,
  Error,
  ErrorCaptureStackTrace,
+ FunctionPrototypeBind,
+ FunctionPrototypeCall,
  MathMin,
  NumberIsNaN,
  ObjectCreate,
@@ -39,6 +48,7 @@ const {
  ReflectApply,
  ReflectOwnKeys,
  String,
+ StringPrototypeSplit,
  Symbol,
  SymbolFor,
  SymbolAsyncIterator
@@ -173,7 +183,7 @@ EventEmitter.setMaxListeners =
  isEventTarget = require('internal/event_target').isEventTarget;
 
  // Performance for forEach is now comparable with regular for-loop
- eventTargets.forEach((target) => {
+ ArrayPrototypeForEach(eventTargets, (target) => {
  if (isEventTarget(target)) {
  target[kMaxEventTargetListeners] = n;
  target[kMaxEventTargetListenersWarned] = false;
@@ -224,7 +234,7 @@ function addCatch(that, promise, type, args) {
  const then = promise.then;
 
  if (typeof then === 'function') {
- then.call(promise, undefined, function(err) {
+ FunctionPrototypeCall(then, 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);
@@ -281,7 +291,7 @@ EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
 function identicalSequenceRange(a, b) {
  for (let i = 0; i < a.length - 3; i++) {
  // Find the first entry of b that matches the current entry of a.
- const pos = b.indexOf(a[i]);
+ const pos = ArrayPrototypeIndexOf(b, a[i]);
  if (pos !== -1) {
  const rest = b.length - pos;
  if (rest > 3) {
@@ -310,16 +320,18 @@ function enhanceStackTrace(err, own) {
  } catch {}
  const sep = `\nEmitted 'error' event${ctorInfo} at:\n`;
 
- const errStack = err.stack.split('\n').slice(1);
- const ownStack = own.stack.split('\n').slice(1);
+ const errStack = ArrayPrototypeSlice(
+ StringPrototypeSplit(err.stack, '\n'), 1);
+ const ownStack = ArrayPrototypeSlice(
+ StringPrototypeSplit(own.stack, '\n'), 1);
 
  const [ len, off ] = identicalSequenceRange(ownStack, errStack);
  if (len > 0) {
- ownStack.splice(off + 1, len - 2,
- ' [... lines matching original stack trace ...]');
+ ArrayPrototypeSplice(ownStack, off + 1, len - 2,
+  ' [... lines matching original stack trace ...]');
  }
 
- return err.stack + sep + ownStack.join('\n');
+ return err.stack + sep + ArrayPrototypeJoin(ownStack, '\n');
 }
 
 EventEmitter.prototype.emit = function emit(type, ...args) {
@@ -343,7 +355,7 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
  const capture = {};
  ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);
  ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {
- value: enhanceStackTrace.bind(this, er, capture),
+ value: FunctionPrototypeBind(enhanceStackTrace, this, er, capture),
  configurable: true
  });
  } catch {}
@@ -437,9 +449,9 @@ function _addListener(target, type, listener, prepend) {
  prepend ? [listener, existing] : [existing, listener];
  // If we've already got an array, just append.
  } else if (prepend) {
- existing.unshift(listener);
+ ArrayPrototypeUnshift(existing, listener);
  } else {
- existing.push(listener);
+ ArrayPrototypePush(existing, listener);
  }
 
  // Check for listener leak
@@ -486,7 +498,7 @@ function onceWrapper() {
 
 function _onceWrap(target, type, listener) {
  const state = { fired: false, wrapFn: undefined, target, type, listener };
- const wrapped = onceWrapper.bind(state);
+ const wrapped = FunctionPrototypeBind(onceWrapper, state);
  wrapped.listener = listener;
  state.wrapFn = wrapped;
  return wrapped;
@@ -542,7 +554,7 @@ EventEmitter.prototype.removeListener =
  return this;
 
  if (position === 0)
- list.shift();
+ ArrayPrototypeShift(list);
  else {
  if (spliceOne === undefined)
  spliceOne = require('internal/util').spliceOne;
@@ -636,7 +648,7 @@ EventEmitter.listenerCount = function(emitter, type) {
  if (typeof emitter.listenerCount === 'function') {
  return emitter.listenerCount(type);
  }
- return listenerCount.call(emitter, type);
+ return FunctionPrototypeCall(listenerCount, emitter, type);
 };
 
 EventEmitter.prototype.listenerCount = listenerCount;
@@ -670,7 +682,7 @@ function arrayClone(arr) {
  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 arr.slice();
+ return ArrayPrototypeSlice(arr);
 }
 
 function unwrapListeners(arr) {
@@ -791,7 +803,7 @@ function on(emitter, event, options) {
  const iterator = ObjectSetPrototypeOf({
  next() {
  // First, we consume all unread events
- const value = unconsumedEvents.shift();
+ const value = ArrayPrototypeShift(unconsumedEvents);
  if (value) {
  return PromiseResolve(createIterResult(value, false));
  }
@@ -813,7 +825,7 @@ function on(emitter, event, options) {
 
  // Wait until an event happens
  return new Promise(function(resolve, reject) {
- unconsumedPromises.push({ resolve, reject });
+ ArrayPrototypePush(unconsumedPromises, { resolve, reject });
  });
  },
 
@@ -873,18 +885,18 @@ function on(emitter, event, options) {
  }
 
  function eventHandler(...args) {
- const promise = unconsumedPromises.shift();
+ const promise = ArrayPrototypeShift(unconsumedPromises);
  if (promise) {
  promise.resolve(createIterResult(args, false));
  } else {
- unconsumedEvents.push(args);
+ ArrayPrototypePush(unconsumedEvents, args);
  }
  }
 
  function errorHandler(err) {
  finished = true;
 
- const toError = unconsumedPromises.shift();
+ const toError = ArrayPrototypeShift(unconsumedPromises);
 
  if (toError) {
  toError.reject(err);