From b4b0efeb60a25a333247928cc4406f9b6f4bef02 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 3 Nov 2018 19:53:06 +0100
Subject: [PATCH 1/3] fs,net: standardize `pending` stream property

Use the same property name as http2 does to indicate that
the stream is in the state before the `ready` event is emitted.
---
 doc/api/fs.md                               | 20 ++++++++++++++++++++
 doc/api/net.md                              | 12 ++++++++++++
 lib/internal/fs/streams.js                  | 10 ++++++++++
 lib/internal/http2/core.js                  |  2 +-
 lib/net.js                                  |  8 +++++++-
 test/parallel/test-fs-ready-event-stream.js | 11 +++++++++--
 test/parallel/test-net-connect-buffer.js    |  3 +++
 7 files changed, 62 insertions(+), 4 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 9de798c6ff7ca2..38da782d3c1a0c 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -488,6 +488,16 @@ argument to `fs.createReadStream()`. If `path` is passed as a string, then
 `readStream.path` will be a string. If `path` is passed as a `Buffer`, then
 `readStream.path` will be a `Buffer`.
 
+### readStream.pending
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+This property is `true` if the underlying file has not been opened yet,
+i.e. before the `'ready'` event is emitted.
+
 ## Class: fs.Stats
 <!-- YAML
 added: v0.1.21
@@ -833,6 +843,16 @@ argument to [`fs.createWriteStream()`][]. If `path` is passed as a string, then
 `writeStream.path` will be a string. If `path` is passed as a `Buffer`, then
 `writeStream.path` will be a `Buffer`.
 
+### readStream.pending
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+This property is `true` if the underlying file has not been opened yet,
+i.e. before the `'ready'` event is emitted.
+
 ## fs.access(path[, mode], callback)
 <!-- YAML
 added: v0.11.15
diff --git a/doc/api/net.md b/doc/api/net.md
index eb48ab8d00c87f..6e824ec72a9717 100644
--- a/doc/api/net.md
+++ b/doc/api/net.md
@@ -724,6 +724,17 @@ The numeric representation of the local port. For example, `80` or `21`.
 Pauses the reading of data. That is, [`'data'`][] events will not be emitted.
 Useful to throttle back an upload.
 
+### socket.pending
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+This is true if the socket is not connected yet, either because `.connect()`
+has not yet been called or because it is still in the process of connecting
+(see [`socket.connecting`][]).
+
 ### socket.ref()
 <!-- YAML
 added: v0.9.1
@@ -1168,6 +1179,7 @@ Returns `true` if input is a version 6 IP address, otherwise returns `false`.
 [`socket.connect(options)`]: #net_socket_connect_options_connectlistener
 [`socket.connect(path)`]: #net_socket_connect_path_connectlistener
 [`socket.connect(port, host)`]: #net_socket_connect_port_host_connectlistener
+[`socket.connecting`]: #net_socket_connecting
 [`socket.destroy()`]: #net_socket_destroy_exception
 [`socket.end()`]: #net_socket_end_data_encoding_callback
 [`socket.pause()`]: #net_socket_pause
diff --git a/lib/internal/fs/streams.js b/lib/internal/fs/streams.js
index a2ae1c9787d288..de0ac9eb625480 100644
--- a/lib/internal/fs/streams.js
+++ b/lib/internal/fs/streams.js
@@ -228,6 +228,11 @@ ReadStream.prototype.close = function(cb) {
   this.destroy(null, cb);
 };
 
+Object.defineProperty(ReadStream.prototype, 'pending', {
+  get() { return this.fd === null; },
+  configurable: true
+});
+
 function WriteStream(path, options) {
   if (!(this instanceof WriteStream))
     return new WriteStream(path, options);
@@ -394,6 +399,11 @@ WriteStream.prototype.close = function(cb) {
 // There is no shutdown() for files.
 WriteStream.prototype.destroySoon = WriteStream.prototype.end;
 
+Object.defineProperty(ReadStream.prototype, 'pending', {
+  get() { return this.fd === null; },
+  configurable: true
+});
+
 module.exports = {
   ReadStream,
   WriteStream
diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index ded26644c590d5..40e1821c166c8d 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -1823,7 +1823,7 @@ class Http2Stream extends Duplex {
 
   _final(cb) {
     const handle = this[kHandle];
-    if (this[kID] === undefined) {
+    if (this.pending) {
       this.once('ready', () => this._final(cb));
     } else if (handle !== undefined) {
       debug(`Http2Stream ${this[kID]} [Http2Session ` +
diff --git a/lib/net.js b/lib/net.js
index 3fec2c7dde8ec7..f26570eea4f48b 100644
--- a/lib/net.js
+++ b/lib/net.js
@@ -348,7 +348,7 @@ function shutdownSocket(self, callback) {
 // sent out to the other side.
 Socket.prototype._final = function(cb) {
   // If still connecting - defer handling `_final` until 'connect' will happen
-  if (this.connecting) {
+  if (this.pending) {
     debug('_final: not yet connected');
     return this.once('connect', () => this._final(cb));
   }
@@ -494,6 +494,12 @@ Object.defineProperty(Socket.prototype, '_connecting', {
   }
 });
 
+Object.defineProperty(Socket.prototype, 'pending', {
+  get: function() {
+    return !this._handle || this.connecting;
+  }
+});
+
 
 Object.defineProperty(Socket.prototype, 'readyState', {
   get: function() {
diff --git a/test/parallel/test-fs-ready-event-stream.js b/test/parallel/test-fs-ready-event-stream.js
index 71f7aa76e36c76..4913940891788b 100644
--- a/test/parallel/test-fs-ready-event-stream.js
+++ b/test/parallel/test-fs-ready-event-stream.js
@@ -1,13 +1,20 @@
 'use strict';
 const common = require('../common');
+const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
 
 const readStream = fs.createReadStream(__filename);
-readStream.on('ready', common.mustCall(() => {}, 1));
+assert.strictEqual(readStream.pending, true);
+readStream.on('ready', common.mustCall(() => {
+  assert.strictEqual(readStream.pending, false);
+}));
 
 const writeFile = path.join(tmpdir.path, 'write-fsreadyevent.txt');
 tmpdir.refresh();
 const writeStream = fs.createWriteStream(writeFile, { autoClose: true });
-writeStream.on('ready', common.mustCall(() => {}, 1));
+assert.strictEqual(readStream.pending, true);
+writeStream.on('ready', common.mustCall(() => {
+  assert.strictEqual(readStream.pending, false);
+}));
diff --git a/test/parallel/test-net-connect-buffer.js b/test/parallel/test-net-connect-buffer.js
index f58820d58edfdd..0425aad636e2b3 100644
--- a/test/parallel/test-net-connect-buffer.js
+++ b/test/parallel/test-net-connect-buffer.js
@@ -44,8 +44,10 @@ tcp.listen(0, common.mustCall(function() {
   const socket = net.Stream({ highWaterMark: 0 });
 
   let connected = false;
+  assert.strictEqual(socket.pending, true);
   socket.connect(this.address().port, common.mustCall(() => connected = true));
 
+  assert.strictEqual(socket.pending, true);
   assert.strictEqual(socket.connecting, true);
   assert.strictEqual(socket.readyState, 'opening');
 
@@ -87,6 +89,7 @@ tcp.listen(0, common.mustCall(function() {
     console.error('write cb');
     assert.ok(connected);
     assert.strictEqual(socket.bytesWritten, Buffer.from(a + b).length);
+    assert.strictEqual(socket.pending, false);
   }));
 
   assert.strictEqual(socket.bytesWritten, Buffer.from(a).length);

From 3b61d8778b00d841f07f05cdf7556249688eb9cb Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 3 Nov 2018 20:23:58 +0100
Subject: [PATCH 2/3] fixup! fs,net: standardize `pending` stream property

---
 doc/api/fs.md  | 2 +-
 doc/api/net.md | 2 +-
 lib/net.js     | 5 +++--
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 38da782d3c1a0c..cb9240a2a92074 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -843,7 +843,7 @@ argument to [`fs.createWriteStream()`][]. If `path` is passed as a string, then
 `writeStream.path` will be a string. If `path` is passed as a `Buffer`, then
 `writeStream.path` will be a `Buffer`.
 
-### readStream.pending
+### writeStream.pending
 <!-- YAML
 added: REPLACEME
 -->
diff --git a/doc/api/net.md b/doc/api/net.md
index 6e824ec72a9717..90c3354e803e20 100644
--- a/doc/api/net.md
+++ b/doc/api/net.md
@@ -731,7 +731,7 @@ added: REPLACEME
 
 * {boolean}
 
-This is true if the socket is not connected yet, either because `.connect()`
+This is `true` if the socket is not connected yet, either because `.connect()`
 has not yet been called or because it is still in the process of connecting
 (see [`socket.connecting`][]).
 
diff --git a/lib/net.js b/lib/net.js
index f26570eea4f48b..de798faa10ee9b 100644
--- a/lib/net.js
+++ b/lib/net.js
@@ -495,9 +495,10 @@ Object.defineProperty(Socket.prototype, '_connecting', {
 });
 
 Object.defineProperty(Socket.prototype, 'pending', {
-  get: function() {
+  get() {
     return !this._handle || this.connecting;
-  }
+  },
+  configurable: true
 });
 
 

From 653c298d354ae6aec205efe3d170ae30f9f684b8 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 3 Nov 2018 22:01:51 +0100
Subject: [PATCH 3/3] fixup! fs,net: standardize `pending` stream property

---
 lib/internal/fs/streams.js                  | 2 +-
 test/parallel/test-fs-ready-event-stream.js | 4 ++--
 test/parallel/test-net-connect-buffer.js    | 3 +++
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/lib/internal/fs/streams.js b/lib/internal/fs/streams.js
index de0ac9eb625480..8c9ed35f81c2f4 100644
--- a/lib/internal/fs/streams.js
+++ b/lib/internal/fs/streams.js
@@ -399,7 +399,7 @@ WriteStream.prototype.close = function(cb) {
 // There is no shutdown() for files.
 WriteStream.prototype.destroySoon = WriteStream.prototype.end;
 
-Object.defineProperty(ReadStream.prototype, 'pending', {
+Object.defineProperty(WriteStream.prototype, 'pending', {
   get() { return this.fd === null; },
   configurable: true
 });
diff --git a/test/parallel/test-fs-ready-event-stream.js b/test/parallel/test-fs-ready-event-stream.js
index 4913940891788b..f6b380cf26d42c 100644
--- a/test/parallel/test-fs-ready-event-stream.js
+++ b/test/parallel/test-fs-ready-event-stream.js
@@ -14,7 +14,7 @@ readStream.on('ready', common.mustCall(() => {
 const writeFile = path.join(tmpdir.path, 'write-fsreadyevent.txt');
 tmpdir.refresh();
 const writeStream = fs.createWriteStream(writeFile, { autoClose: true });
-assert.strictEqual(readStream.pending, true);
+assert.strictEqual(writeStream.pending, true);
 writeStream.on('ready', common.mustCall(() => {
-  assert.strictEqual(readStream.pending, false);
+  assert.strictEqual(writeStream.pending, false);
 }));
diff --git a/test/parallel/test-net-connect-buffer.js b/test/parallel/test-net-connect-buffer.js
index 0425aad636e2b3..81dd8f0c569c71 100644
--- a/test/parallel/test-net-connect-buffer.js
+++ b/test/parallel/test-net-connect-buffer.js
@@ -91,6 +91,9 @@ tcp.listen(0, common.mustCall(function() {
     assert.strictEqual(socket.bytesWritten, Buffer.from(a + b).length);
     assert.strictEqual(socket.pending, false);
   }));
+  socket.on('close', common.mustCall(() => {
+    assert.strictEqual(socket.pending, true);
+  }));
 
   assert.strictEqual(socket.bytesWritten, Buffer.from(a).length);
   assert.strictEqual(r, false);