events: avoid cloning listeners array on every emit

PR-URL: #62261
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>

Author: gurgunday

lib/events.js

@@ -87,6 +87,7 @@ const { addAbortListener } = require('internal/events/abort_listener');
 constkCapture=Symbol('kCapture');
 constkErrorMonitor=Symbol('events.errorMonitor');
 constkShapeMode=Symbol('shapeMode');
+constkEmitting=Symbol('events.emitting');
 constkMaxEventTargetListeners=Symbol('events.maxEventTargetListeners');
 constkMaxEventTargetListenersWarned=
 Symbol('events.maxEventTargetListenersWarned');
@@ -514,19 +515,22 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
 addCatch(this,result,type,args);
 }
 }else{
-constlen=handler.length;
-constlisteners=arrayClone(handler);
-for(leti=0;i<len;++i){
-constresult=ReflectApply(listeners[i],this,args);
-
-// We check if result is undefined first because that
-// is the most common case so we do not pay any perf
-// penalty.
-// This code is duplicated because extracting it away
-// would make it non-inlineable.
-if(result!==undefined&&result!==null){
-addCatch(this,result,type,args);
+handler[kEmitting]++;
+try{
+for(leti=0;i<handler.length;++i){
+constresult=ReflectApply(handler[i],this,args);
+
+// We check if result is undefined first because that
+// is the most common case so we do not pay any perf
+// penalty.
+// This code is duplicated because extracting it away
+// would make it non-inlineable.
+if(result!==undefined&&result!==null){
+addCatch(this,result,type,args);
+}
 }
+}finally{
+handler[kEmitting]--;
 }
 }
 
@@ -565,13 +569,17 @@ function _addListener(target, type, listener, prepend) {
 }else{
 if(typeofexisting==='function'){
 // Adding the second element, need to change to array.
-existing=events[type]=
-prepend ? [listener,existing] : [existing,listener];
+existing=prepend ? [listener,existing] : [existing,listener];
+existing[kEmitting]=0;
+events[type]=existing;
 // If we've already got an array, just append.
-}elseif(prepend){
-existing.unshift(listener);
 }else{
-existing.push(listener);
+existing=ensureMutableListenerArray(events,type,existing);
+if(prepend){
+existing.unshift(listener);
+}else{
+existing.push(listener);
+}
 }
 
 // Check for listener leak
@@ -674,7 +682,7 @@ EventEmitter.prototype.removeListener =
 if(events===undefined)
 returnthis;
 
-constlist=events[type];
+letlist=events[type];
 if(list===undefined)
 returnthis;
 
@@ -692,6 +700,7 @@ EventEmitter.prototype.removeListener =
 if(events.removeListener!==undefined)
 this.emit('removeListener',type,list.listener||listener);
 }elseif(typeoflist!=='function'){
+list=ensureMutableListenerArray(events,type,list);
 letposition=-1;
 
 for(leti=list.length-1;i>=0;i--){
@@ -875,6 +884,24 @@ function arrayClone(arr) {
 returnArrayPrototypeSlice(arr);
 }
 
+functioncloneEventListenerArray(arr){
+constcopy=arrayClone(arr);
+copy[kEmitting]=0;
+if(arr.warned){
+copy.warned=true;
+}
+returncopy;
+}
+
+functionensureMutableListenerArray(events,type,handler){
+if(handler[kEmitting]>0){
+constcopy=cloneEventListenerArray(handler);
+events[type]=copy;
+returncopy;
+}
+returnhandler;
+}
+
 functionunwrapListeners(arr){
 constret=arrayClone(arr);
 for(leti=0;i<ret.length;++i){

test/parallel/test-event-emitter-modify-in-emit.js

@@ -78,3 +78,21 @@ assert.strictEqual(e.listeners('foo').length, 2);
 e.emit('foo');
 assert.deepStrictEqual(['callback2','callback3'],callbacks_called);
 assert.strictEqual(e.listeners('foo').length,0);
+
+// Verify that removing all callbacks while in emit allows the current emit to
+// propagate to all listeners.
+callbacks_called=[];
+
+functioncallback4(){
+callbacks_called.push('callback4');
+e.removeAllListeners('foo');
+}
+
+e.on('foo',callback4);
+e.on('foo',callback2);
+e.on('foo',callback3);
+assert.strictEqual(e.listeners('foo').length,3);
+e.emit('foo');
+assert.deepStrictEqual(['callback4','callback2','callback3'],
+callbacks_called);
+assert.strictEqual(e.listeners('foo').length,0);