stream: avoid caching prepend check

This removes the cached check for EE.prototype.prependListener
because we can't have nice things. More specifically some
libraries will bundle their own event emitter implementation.

PR-URL: https://github.com/nodejs/node/pull/8018
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

lib/_stream_readable.js

@@ -13,13 +13,12 @@ var StringDecoder;
 
 util.inherits(Readable, Stream);
 
-var prependListener;
+function prependListener(emitter, event, fn) {
-if (typeof EE.prototype.prependListener === 'function') {
+  // Sadly this is not cacheable as some libraries bundle their own
-  prependListener = function prependListener(emitter, event, fn) {
+  // event emitter implementation with them.
+  if (typeof emitter.prependListener === 'function') {
     return emitter.prependListener(event, fn);
-  };
+  } else {
-} else {
-  prependListener = function prependListener(emitter, event, fn) {
     // This is a hack to make sure that our error handler is attached before any
     // userland ones.  NEVER DO THIS. This is here only because this code needs
     // to continue to work with older versions of Node.js that do not include
@@ -30,7 +29,7 @@ if (typeof EE.prototype.prependListener === 'function') {
       emitter._events[event].unshift(fn);
     else
       emitter._events[event] = [fn, emitter._events[event]];
-  };
+  }
 }
 
 function ReadableState(options, stream) {

test/parallel/test-stream-events-prepend.js

@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+const util = require('util');
+
+function Writable() {
+  this.writable = true;
+  stream.Writable.call(this);
+  this.prependListener = undefined;
+}
+util.inherits(Writable, stream.Writable);
+Writable.prototype._write = function(chunk, end, cb) {
+  cb();
+};
+
+function Readable() {
+  this.readable = true;
+  stream.Readable.call(this);
+}
+util.inherits(Readable, stream.Readable);
+Readable.prototype._read = function() {
+  this.push(null);
+};
+
+const w = new Writable();
+w.on('pipe', common.mustCall(function() {}));
+
+const r = new Readable();
+r.pipe(w);