From cf7248766717168eab46d886fea4f0f0fe13b761 Mon Sep 17 00:00:00 2001
From: Jay Patel <0807Jpatel@gmail.com>
Date: Sun, 10 May 2020 18:23:56 -0400
Subject: [PATCH 1/9] feat(stream): added mutable highwatermark and object mode

---
 doc/api/stream.md                             | 36 ++++++++++++++
 lib/_stream_readable.js                       | 35 +++++++++++++-
 lib/_stream_writable.js                       | 28 ++++++++++-
 .../test-stream-readable-hwm-mutable.js       | 45 ++++++++++++++++++
 .../test-stream-writable-hwm-mutable.js       | 47 +++++++++++++++++++
 5 files changed, 188 insertions(+), 3 deletions(-)
 create mode 100644 test/parallel/test-stream-readable-hwm-mutable.js
 create mode 100644 test/parallel/test-stream-writable-hwm-mutable.js

diff --git a/doc/api/stream.md b/doc/api/stream.md
index 6229704eb91bc4..41f77dd3a1096d 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -568,6 +568,24 @@ added: v12.3.0
 
 Getter for the property `objectMode` of a given `Writable` stream.
 
+##### `writable.updateWritableHighwaterMark(highwaterMark)`
+<!-- YAML
+added: v9.3.0
+-->
+
+* `highwaterMark` {number} new highwaterMark
+
+Update the value of `highWaterMark` of a given `Writable` stream.
+
+##### `writable.updateWritableObjectMode(objectMode)`
+<!-- YAML
+added: v12.3.0
+-->
+
+* `objectMode` {boolean} new objectMode
+
+Update the value of `objectMode` of a given `Writable` stream.
+
 ##### `writable.write(chunk[, encoding][, callback])`
 <!-- YAML
 added: v0.9.4
@@ -1211,6 +1229,24 @@ added: v12.3.0
 
 Getter for the property `objectMode` of a given `Readable` stream.
 
+##### `readable.updateReadableHighWaterMark(highwaterMark)`
+<!-- YAML
+added: v9.3.0
+-->
+
+* `highwaterMark` {number} new highwaterMark
+
+Update the value of `highWaterMark` of a given `Readable` stream.
+
+##### `readable.updateReadableObjectMode(objectMode)`
+<!-- YAML
+added: v12.3.0
+-->
+
+* `objectMode` {boolean} new objectMode
+
+Update the value of `objectMode` of a given `Readable` stream.
+
 ##### `readable.resume()`
 <!-- YAML
 added: v0.9.4
diff --git a/lib/_stream_readable.js b/lib/_stream_readable.js
index aac65e9cb30298..01ba72026f70a4 100644
--- a/lib/_stream_readable.js
+++ b/lib/_stream_readable.js
@@ -170,6 +170,10 @@ function ReadableState(options, stream, isDuplex) {
   // If true, a maybeReadMore has been scheduled.
   this.readingMore = false;
 
+  // Flags to update highwatermark and objectMode
+  this.updateHighwaterMark = null;
+  this.updateObjectMode = null;
+
   this.decoder = null;
   this.encoding = null;
   if (options && options.encoding) {
@@ -396,6 +400,17 @@ Readable.prototype.read = function(n) {
   const state = this._readableState;
   const nOrig = n;
 
+  // If they called updateHighwaterMark since last read
+  if (state.updateHighwaterMark !== null) {
+    state.highWaterMark = state.updateHighwaterMark;
+    state.updateHighwaterMark = null;
+  }
+
+  if (state.updateObjectMode !== null && state.length === 0) {
+    state.objectMode = state.updateObjectMode;
+    state.updateObjectMode = null;
+  }
+
   // If we're asking for more than the current hwm, then raise the hwm.
   if (n > state.highWaterMark)
     state.highWaterMark = computeNewHighWaterMark(n);
@@ -461,12 +476,18 @@ Readable.prototype.read = function(n) {
     debug('length less than watermark', doRead);
   }
 
+  const objectModeUpdateRequest = state.updateObjectMode !== null;
+
   // However, if we've ended, then there's no point, if we're already
   // reading, then it's unnecessary, and if we're destroyed or errored,
   // then it's not allowed.
-  if (state.ended || state.reading || state.destroyed || state.errored) {
+  if (state.ended ||
+      state.reading ||
+      state.destroyed ||
+      state.errored ||
+      objectModeUpdateRequest) {
     doRead = false;
-    debug('reading or ended', doRead);
+    debug('reading or ended or objectMode update', doRead);
   } else if (doRead) {
     debug('do read');
     state.reading = true;
@@ -936,6 +957,16 @@ function nReadingNextTick(self) {
   self.read(0);
 }
 
+Readable.prototype.updateReadableHighwaterMark = function(newHighwaterMark) {
+  this._readableState.updateHighwaterMark = newHighwaterMark;
+};
+
+Readable.prototype.updateReadableObjectMode = function(objectMode) {
+  objectMode = !!objectMode;
+  if (objectMode !== this._readableState.objectMode)
+    this._readableState.updateObjectMode = objectMode;
+};
+
 // pause() and resume() are remnants of the legacy readable stream API
 // If the user uses them, then switch into old mode.
 Readable.prototype.resume = function() {
diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index 4e0f40b432a213..fe7bf79e40eaab 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -179,6 +179,10 @@ function WritableState(options, stream, isDuplex) {
   // True if close has been emitted or would have been emitted
   // depending on emitClose.
   this.closeEmitted = false;
+
+  // Flags to update highwatermark and objectMode
+  this.updateHighwaterMark = null;
+  this.updateObjectMode = null;
 }
 
 function resetBuffer(state) {
@@ -262,6 +266,11 @@ Writable.prototype.pipe = function() {
 Writable.prototype.write = function(chunk, encoding, cb) {
   const state = this._writableState;
 
+  if (state.updateHighwaterMark !== null) {
+    state.highWaterMark = state.updateHighwaterMark;
+    state.updateHighwaterMark = null;
+  }
+
   if (typeof encoding === 'function') {
     cb = encoding;
     encoding = state.defaultEncoding;
@@ -339,6 +348,13 @@ Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
 // in the queue, and wait our turn.  Otherwise, call _write
 // If we return false, then we need a drain event, so set that flag.
 function writeOrBuffer(stream, state, chunk, encoding, callback) {
+  let needObjectModeUpdate = state.updateObjectMode !== null;
+  if (needObjectModeUpdate && state.length === 0) {
+    state.objectMode = state.updateObjectMode;
+    state.updateObjectMode = null;
+    needObjectModeUpdate = false;
+  }
+
   const len = state.objectMode ? 1 : chunk.length;
 
   state.length += len;
@@ -368,7 +384,7 @@ function writeOrBuffer(stream, state, chunk, encoding, callback) {
 
   // Return false if errored or destroyed in order to break
   // any synchronous while(stream.write(data)) loops.
-  return ret && !state.errored && !state.destroyed;
+  return ret && !needObjectModeUpdate && !state.errored && !state.destroyed;
 }
 
 function doWrite(stream, state, writev, len, chunk, encoding, cb) {
@@ -553,6 +569,16 @@ Writable.prototype._write = function(chunk, encoding, cb) {
 
 Writable.prototype._writev = null;
 
+Writable.prototype.updateWritableHighwaterMark = function(newHighwaterMark) {
+  this._writableState.updateHighwaterMark = newHighwaterMark;
+};
+
+Writable.prototype.updateWritableObjectMode = function(objectMode) {
+  objectMode = !!objectMode;
+  if (objectMode !== this._writableState.objectMode)
+    this._writableState.updateObjectMode = objectMode;
+};
+
 Writable.prototype.end = function(chunk, encoding, cb) {
   const state = this._writableState;
 
diff --git a/test/parallel/test-stream-readable-hwm-mutable.js b/test/parallel/test-stream-readable-hwm-mutable.js
new file mode 100644
index 00000000000000..ead4fb2051da28
--- /dev/null
+++ b/test/parallel/test-stream-readable-hwm-mutable.js
@@ -0,0 +1,45 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+let currHighWaterMark = 20;
+let currObjectMode = true;
+let pushes = 0;
+const rs = new stream.Readable({
+  highWaterMark: currHighWaterMark,
+  objectMode: currObjectMode,
+  read: common.mustCall(function() {
+    if (pushes++ === 100) {
+      this.push(null);
+      return;
+    }
+
+    const highWaterMark = this._readableState.highWaterMark;
+    const objectMode = this._readableState.objectMode;
+
+    // Both highwatermark and objectmode should update
+    // before it makes next _read request.
+    assert.strictEqual(highWaterMark, currHighWaterMark);
+    assert.strictEqual(objectMode, currObjectMode);
+
+    this.push(Buffer.alloc(1024));
+
+    if (pushes === 30) {
+      this.updateReadableHighwaterMark(2048);
+      this.updateReadableObjectMode(false);
+      currHighWaterMark = 2048;
+      currObjectMode = false;
+    }
+
+  }, 101)
+});
+
+const ws = stream.Writable({
+  write: common.mustCall(function(data, enc, cb) {
+    setImmediate(cb);
+  }, 100)
+});
+
+rs.pipe(ws);
diff --git a/test/parallel/test-stream-writable-hwm-mutable.js b/test/parallel/test-stream-writable-hwm-mutable.js
new file mode 100644
index 00000000000000..da5b370858e898
--- /dev/null
+++ b/test/parallel/test-stream-writable-hwm-mutable.js
@@ -0,0 +1,47 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+let pushes = 0;
+const rs = new stream.Readable({
+  read: common.mustCall(function() {
+    if (pushes++ === 100) {
+      this.push(null);
+      return;
+    }
+
+    this.push(Buffer.alloc(1024));
+  }, 101)
+});
+
+let currHighWaterMark = 0;
+let currObjectMode = true;
+let read = 0;
+const ws = stream.Writable({
+  highWaterMark: currHighWaterMark,
+  objectMode: currObjectMode,
+  write: common.mustCall(function(data, enc, cb) {
+
+    const highWaterMark = this._writableState.highWaterMark;
+    const objectMode = this._writableState.objectMode;
+
+    // Should update highwatermark and objectmode
+    // after emptying current buffer
+    assert.strictEqual(highWaterMark, currHighWaterMark);
+    assert.strictEqual(objectMode, currObjectMode);
+
+    if (read++ === 30) {
+      this.updateWritableHighwaterMark(2048);
+      this.updateWritableObjectMode(false);
+      currHighWaterMark = 2048;
+      currObjectMode = false;
+    }
+
+    setImmediate(cb);
+
+  }, 100)
+});
+
+rs.pipe(ws);

From 134c20479174cb3d333146f473a62b8c3a91294e Mon Sep 17 00:00:00 2001
From: Jay Patel <0807Jpatel@gmail.com>
Date: Mon, 11 May 2020 06:47:58 -0400
Subject: [PATCH 2/9] fix(readme): added REPLACEME in place of version

---
 bigFile.txt             | Bin 0 -> 32769 bytes
 doc/api/stream.md       |   8 ++++----
 lib/_stream_writable.js |   2 ++
 3 files changed, 6 insertions(+), 4 deletions(-)
 create mode 100644 bigFile.txt

diff --git a/bigFile.txt b/bigFile.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d9354e3ef80764039420649a6832821ce30fd40e
GIT binary patch
literal 32769
zcmeIufdBvi0Dz$VsTV1P3IhfV7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd
z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA
zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj
HFkqkofB^sj

literal 0
HcmV?d00001

diff --git a/doc/api/stream.md b/doc/api/stream.md
index 41f77dd3a1096d..2b5ddf17a6f19b 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -570,7 +570,7 @@ Getter for the property `objectMode` of a given `Writable` stream.
 
 ##### `writable.updateWritableHighwaterMark(highwaterMark)`
 <!-- YAML
-added: v9.3.0
+added: REPLACEME
 -->
 
 * `highwaterMark` {number} new highwaterMark
@@ -579,7 +579,7 @@ Update the value of `highWaterMark` of a given `Writable` stream.
 
 ##### `writable.updateWritableObjectMode(objectMode)`
 <!-- YAML
-added: v12.3.0
+added: REPLACEME
 -->
 
 * `objectMode` {boolean} new objectMode
@@ -1231,7 +1231,7 @@ Getter for the property `objectMode` of a given `Readable` stream.
 
 ##### `readable.updateReadableHighWaterMark(highwaterMark)`
 <!-- YAML
-added: v9.3.0
+added: REPLACEME
 -->
 
 * `highwaterMark` {number} new highwaterMark
@@ -1240,7 +1240,7 @@ Update the value of `highWaterMark` of a given `Readable` stream.
 
 ##### `readable.updateReadableObjectMode(objectMode)`
 <!-- YAML
-added: v12.3.0
+added: REPLACEME
 -->
 
 * `objectMode` {boolean} new objectMode
diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index fe7bf79e40eaab..f59f273f2ba708 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -37,6 +37,7 @@ const {
 module.exports = Writable;
 Writable.WritableState = WritableState;
 
+const debug = require('internal/util/debuglog').debuglog('stream');
 const EE = require('events');
 const Stream = require('stream');
 const { Buffer } = require('buffer');
@@ -264,6 +265,7 @@ Writable.prototype.pipe = function() {
 };
 
 Writable.prototype.write = function(chunk, encoding, cb) {
+  debug('write', chunk, encoding);
   const state = this._writableState;
 
   if (state.updateHighwaterMark !== null) {

From 8ab362bbc79271cdff8aa56295b94167e861d3cd Mon Sep 17 00:00:00 2001
From: Jay Patel <0807Jpatel@gmail.com>
Date: Mon, 11 May 2020 07:42:33 -0400
Subject: [PATCH 3/9] fix: remove debug statements from writable stream

---
 lib/_stream_writable.js | 2 --
 1 file changed, 2 deletions(-)

diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index f59f273f2ba708..fe7bf79e40eaab 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -37,7 +37,6 @@ const {
 module.exports = Writable;
 Writable.WritableState = WritableState;
 
-const debug = require('internal/util/debuglog').debuglog('stream');
 const EE = require('events');
 const Stream = require('stream');
 const { Buffer } = require('buffer');
@@ -265,7 +264,6 @@ Writable.prototype.pipe = function() {
 };
 
 Writable.prototype.write = function(chunk, encoding, cb) {
-  debug('write', chunk, encoding);
   const state = this._writableState;
 
   if (state.updateHighwaterMark !== null) {

From 5ca4f8c8b25cb52b0fa187d33029695419b8bc6a Mon Sep 17 00:00:00 2001
From: Jay Patel <0807Jpatel@gmail.com>
Date: Tue, 12 May 2020 20:19:37 -0400
Subject: [PATCH 4/9] chore: removed mutable objectMode and highWaterMark uses
 setter

---
 doc/api/stream.md                             | 54 +++++++------------
 lib/_stream_readable.js                       | 31 +++--------
 lib/_stream_writable.js                       | 23 +++-----
 .../test-stream-readable-hwm-mutable.js       | 15 +++---
 .../test-stream-writable-hwm-mutable.js       | 21 ++++----
 5 files changed, 48 insertions(+), 96 deletions(-)

diff --git a/doc/api/stream.md b/doc/api/stream.md
index 2b5ddf17a6f19b..6b38427e75ff84 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -548,6 +548,15 @@ added: v9.3.0
 Return the value of `highWaterMark` passed when constructing this
 `Writable`.
 
+##### `writable.writableHighWaterMark`
+<!-- YAML
+added: REPLACEME
+-->
+
+* `highwaterMark` {number} new highwaterMark
+
+Update the value of `highWaterMark` of a given `Writable` stream.
+
 ##### `writable.writableLength`
 <!-- YAML
 added: v9.4.0
@@ -568,24 +577,6 @@ added: v12.3.0
 
 Getter for the property `objectMode` of a given `Writable` stream.
 
-##### `writable.updateWritableHighwaterMark(highwaterMark)`
-<!-- YAML
-added: REPLACEME
--->
-
-* `highwaterMark` {number} new highwaterMark
-
-Update the value of `highWaterMark` of a given `Writable` stream.
-
-##### `writable.updateWritableObjectMode(objectMode)`
-<!-- YAML
-added: REPLACEME
--->
-
-* `objectMode` {boolean} new objectMode
-
-Update the value of `objectMode` of a given `Writable` stream.
-
 ##### `writable.write(chunk[, encoding][, callback])`
 <!-- YAML
 added: v0.9.4
@@ -1209,6 +1200,15 @@ added: v9.3.0
 Returns the value of `highWaterMark` passed when constructing this
 `Readable`.
 
+##### `readable.readableHighWaterMark`
+<!-- YAML
+added: REPLACEME
+-->
+
+* `highwaterMark` {number} new highwaterMark
+
+Update the value of `highWaterMark` of a given `Readable` stream.
+
 ##### `readable.readableLength`
 <!-- YAML
 added: v9.4.0
@@ -1229,24 +1229,6 @@ added: v12.3.0
 
 Getter for the property `objectMode` of a given `Readable` stream.
 
-##### `readable.updateReadableHighWaterMark(highwaterMark)`
-<!-- YAML
-added: REPLACEME
--->
-
-* `highwaterMark` {number} new highwaterMark
-
-Update the value of `highWaterMark` of a given `Readable` stream.
-
-##### `readable.updateReadableObjectMode(objectMode)`
-<!-- YAML
-added: REPLACEME
--->
-
-* `objectMode` {boolean} new objectMode
-
-Update the value of `objectMode` of a given `Readable` stream.
-
 ##### `readable.resume()`
 <!-- YAML
 added: v0.9.4
diff --git a/lib/_stream_readable.js b/lib/_stream_readable.js
index 01ba72026f70a4..76cac54bf25888 100644
--- a/lib/_stream_readable.js
+++ b/lib/_stream_readable.js
@@ -170,9 +170,8 @@ function ReadableState(options, stream, isDuplex) {
   // If true, a maybeReadMore has been scheduled.
   this.readingMore = false;
 
-  // Flags to update highwatermark and objectMode
+  // Flags to update highwatermark
   this.updateHighwaterMark = null;
-  this.updateObjectMode = null;
 
   this.decoder = null;
   this.encoding = null;
@@ -406,11 +405,6 @@ Readable.prototype.read = function(n) {
     state.updateHighwaterMark = null;
   }
 
-  if (state.updateObjectMode !== null && state.length === 0) {
-    state.objectMode = state.updateObjectMode;
-    state.updateObjectMode = null;
-  }
-
   // If we're asking for more than the current hwm, then raise the hwm.
   if (n > state.highWaterMark)
     state.highWaterMark = computeNewHighWaterMark(n);
@@ -476,16 +470,11 @@ Readable.prototype.read = function(n) {
     debug('length less than watermark', doRead);
   }
 
-  const objectModeUpdateRequest = state.updateObjectMode !== null;
 
   // However, if we've ended, then there's no point, if we're already
   // reading, then it's unnecessary, and if we're destroyed or errored,
   // then it's not allowed.
-  if (state.ended ||
-      state.reading ||
-      state.destroyed ||
-      state.errored ||
-      objectModeUpdateRequest) {
+  if (state.ended || state.reading || state.destroyed || state.errored) {
     doRead = false;
     debug('reading or ended or objectMode update', doRead);
   } else if (doRead) {
@@ -957,16 +946,6 @@ function nReadingNextTick(self) {
   self.read(0);
 }
 
-Readable.prototype.updateReadableHighwaterMark = function(newHighwaterMark) {
-  this._readableState.updateHighwaterMark = newHighwaterMark;
-};
-
-Readable.prototype.updateReadableObjectMode = function(objectMode) {
-  objectMode = !!objectMode;
-  if (objectMode !== this._readableState.objectMode)
-    this._readableState.updateObjectMode = objectMode;
-};
-
 // pause() and resume() are remnants of the legacy readable stream API
 // If the user uses them, then switch into old mode.
 Readable.prototype.resume = function() {
@@ -1119,6 +1098,12 @@ ObjectDefineProperties(Readable.prototype, {
     enumerable: false,
     get: function() {
       return this._readableState.highWaterMark;
+    },
+    set: function(val) {
+      if (this._readableState.reading) {
+        this._readableState.updateHighwaterMark = val;
+      }
+      this._readableState.highWaterMark = val;
     }
   },
 
diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index fe7bf79e40eaab..af1aab03117b45 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -182,7 +182,6 @@ function WritableState(options, stream, isDuplex) {
 
   // Flags to update highwatermark and objectMode
   this.updateHighwaterMark = null;
-  this.updateObjectMode = null;
 }
 
 function resetBuffer(state) {
@@ -348,13 +347,6 @@ Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
 // in the queue, and wait our turn.  Otherwise, call _write
 // If we return false, then we need a drain event, so set that flag.
 function writeOrBuffer(stream, state, chunk, encoding, callback) {
-  let needObjectModeUpdate = state.updateObjectMode !== null;
-  if (needObjectModeUpdate && state.length === 0) {
-    state.objectMode = state.updateObjectMode;
-    state.updateObjectMode = null;
-    needObjectModeUpdate = false;
-  }
-
   const len = state.objectMode ? 1 : chunk.length;
 
   state.length += len;
@@ -384,7 +376,7 @@ function writeOrBuffer(stream, state, chunk, encoding, callback) {
 
   // Return false if errored or destroyed in order to break
   // any synchronous while(stream.write(data)) loops.
-  return ret && !needObjectModeUpdate && !state.errored && !state.destroyed;
+  return ret && !state.errored && !state.destroyed;
 }
 
 function doWrite(stream, state, writev, len, chunk, encoding, cb) {
@@ -570,13 +562,6 @@ Writable.prototype._write = function(chunk, encoding, cb) {
 Writable.prototype._writev = null;
 
 Writable.prototype.updateWritableHighwaterMark = function(newHighwaterMark) {
-  this._writableState.updateHighwaterMark = newHighwaterMark;
-};
-
-Writable.prototype.updateWritableObjectMode = function(objectMode) {
-  objectMode = !!objectMode;
-  if (objectMode !== this._writableState.objectMode)
-    this._writableState.updateObjectMode = objectMode;
 };
 
 Writable.prototype.end = function(chunk, encoding, cb) {
@@ -784,6 +769,12 @@ ObjectDefineProperties(Writable.prototype, {
   writableHighWaterMark: {
     get() {
       return this._writableState && this._writableState.highWaterMark;
+    },
+    set(val) {
+      if (this._writableState.writing) {
+        this._writableState.updateHighwaterMark = val;
+      }
+      this._writableState.highWaterMark = val;
     }
   },
 
diff --git a/test/parallel/test-stream-readable-hwm-mutable.js b/test/parallel/test-stream-readable-hwm-mutable.js
index ead4fb2051da28..7e56c7db3bc58c 100644
--- a/test/parallel/test-stream-readable-hwm-mutable.js
+++ b/test/parallel/test-stream-readable-hwm-mutable.js
@@ -5,32 +5,25 @@ const assert = require('assert');
 const stream = require('stream');
 
 let currHighWaterMark = 20;
-let currObjectMode = true;
 let pushes = 0;
 const rs = new stream.Readable({
-  highWaterMark: currHighWaterMark,
-  objectMode: currObjectMode,
   read: common.mustCall(function() {
     if (pushes++ === 100) {
       this.push(null);
       return;
     }
 
-    const highWaterMark = this._readableState.highWaterMark;
-    const objectMode = this._readableState.objectMode;
+    const highWaterMark = this.readableHighWaterMark;
 
     // Both highwatermark and objectmode should update
     // before it makes next _read request.
     assert.strictEqual(highWaterMark, currHighWaterMark);
-    assert.strictEqual(objectMode, currObjectMode);
 
     this.push(Buffer.alloc(1024));
 
     if (pushes === 30) {
-      this.updateReadableHighwaterMark(2048);
-      this.updateReadableObjectMode(false);
+      this.readableHighWaterMark = 2048;
       currHighWaterMark = 2048;
-      currObjectMode = false;
     }
 
   }, 101)
@@ -42,4 +35,8 @@ const ws = stream.Writable({
   }, 100)
 });
 
+assert.strictEqual(rs.readableHighWaterMark, 16384); // default HWM
+rs.readableHighWaterMark = currHighWaterMark;
+assert.strictEqual(rs.readableHighWaterMark, currHighWaterMark);
+
 rs.pipe(ws);
diff --git a/test/parallel/test-stream-writable-hwm-mutable.js b/test/parallel/test-stream-writable-hwm-mutable.js
index da5b370858e898..deaf33720a5fa6 100644
--- a/test/parallel/test-stream-writable-hwm-mutable.js
+++ b/test/parallel/test-stream-writable-hwm-mutable.js
@@ -17,26 +17,19 @@ const rs = new stream.Readable({
 });
 
 let currHighWaterMark = 0;
-let currObjectMode = true;
-let read = 0;
+let write = 0;
 const ws = stream.Writable({
-  highWaterMark: currHighWaterMark,
-  objectMode: currObjectMode,
   write: common.mustCall(function(data, enc, cb) {
 
-    const highWaterMark = this._writableState.highWaterMark;
-    const objectMode = this._writableState.objectMode;
+    const highWaterMark = this.writableHighWaterMark;
 
-    // Should update highwatermark and objectmode
+    // Should update highwatermark
     // after emptying current buffer
     assert.strictEqual(highWaterMark, currHighWaterMark);
-    assert.strictEqual(objectMode, currObjectMode);
 
-    if (read++ === 30) {
-      this.updateWritableHighwaterMark(2048);
-      this.updateWritableObjectMode(false);
+    if (write++ === 30) {
+      this.writableHighWaterMark = 2048;
       currHighWaterMark = 2048;
-      currObjectMode = false;
     }
 
     setImmediate(cb);
@@ -44,4 +37,8 @@ const ws = stream.Writable({
   }, 100)
 });
 
+assert.strictEqual(ws.writableHighWaterMark, 16384); // default HWM
+ws.writableHighWaterMark = currHighWaterMark;
+assert.strictEqual(ws.writableHighWaterMark, currHighWaterMark);
+
 rs.pipe(ws);

From ef07cf6e3564fd50f4110696d8800b7b903e5e28 Mon Sep 17 00:00:00 2001
From: Jay Patel <0807Jpatel@gmail.com>
Date: Tue, 12 May 2020 23:00:10 -0400
Subject: [PATCH 5/9] chore: removed useless function declaration and
 bigFile.txt

---
 bigFile.txt             | Bin 32769 -> 0 bytes
 lib/_stream_writable.js |   3 ---
 2 files changed, 3 deletions(-)
 delete mode 100644 bigFile.txt

diff --git a/bigFile.txt b/bigFile.txt
deleted file mode 100644
index d9354e3ef80764039420649a6832821ce30fd40e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 32769
zcmeIufdBvi0Dz$VsTV1P3IhfV7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd
z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA
zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj
HFkqkofB^sj

diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index af1aab03117b45..544867738ab001 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -561,9 +561,6 @@ Writable.prototype._write = function(chunk, encoding, cb) {
 
 Writable.prototype._writev = null;
 
-Writable.prototype.updateWritableHighwaterMark = function(newHighwaterMark) {
-};
-
 Writable.prototype.end = function(chunk, encoding, cb) {
   const state = this._writableState;
 

From e0e232f84883a9e6b9a7911a0f5ad8df709668a6 Mon Sep 17 00:00:00 2001
From: Jay Patel <0807Jpatel@gmail.com>
Date: Tue, 12 May 2020 23:04:26 -0400
Subject: [PATCH 6/9] chore: updated doc to merge getter and setter

---
 doc/api/stream.md | 28 ++++------------------------
 1 file changed, 4 insertions(+), 24 deletions(-)

diff --git a/doc/api/stream.md b/doc/api/stream.md
index 6b38427e75ff84..441f4a87870686 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -538,24 +538,14 @@ added: v12.6.0
 
 Is set to `true` immediately before the [`'finish'`][] event is emitted.
 
-##### `writable.writableHighWaterMark`
-<!-- YAML
-added: v9.3.0
--->
-
-* {number}
-
-Return the value of `highWaterMark` passed when constructing this
-`Writable`.
-
 ##### `writable.writableHighWaterMark`
 <!-- YAML
 added: REPLACEME
 -->
 
-* `highwaterMark` {number} new highwaterMark
+* {number}
 
-Update the value of `highWaterMark` of a given `Writable` stream.
+Get or set the value of `highWaterMark` for a given `Writable` stream.
 
 ##### `writable.writableLength`
 <!-- YAML
@@ -1190,24 +1180,14 @@ added: v9.4.0
 This property reflects the current state of a `Readable` stream as described
 in the [Stream Three States][] section.
 
-##### `readable.readableHighWaterMark`
-<!-- YAML
-added: v9.3.0
--->
-
-* {number}
-
-Returns the value of `highWaterMark` passed when constructing this
-`Readable`.
-
 ##### `readable.readableHighWaterMark`
 <!-- YAML
 added: REPLACEME
 -->
 
-* `highwaterMark` {number} new highwaterMark
+* {number}
 
-Update the value of `highWaterMark` of a given `Readable` stream.
+Get or set the value of `highWaterMark` for a given `Readable` stream.
 
 ##### `readable.readableLength`
 <!-- YAML

From 04c41459ea173f71771378fb456fcaa08f38264a Mon Sep 17 00:00:00 2001
From: Jay Patel <0807Jpatel@gmail.com>
Date: Thu, 14 May 2020 19:47:27 -0400
Subject: [PATCH 7/9] chore: highwatermark getter throws error in _read and
 _write

---
 doc/api/errors.md                             | 19 ++++++++++++++
 doc/api/stream.md                             |  6 +++--
 lib/_stream_readable.js                       | 20 ++++++---------
 lib/_stream_writable.js                       | 11 +++++---
 lib/internal/errors.js                        |  4 +++
 .../test-stream-readable-hwm-error.js         | 22 ++++++++++++++++
 .../test-stream-readable-hwm-mutable.js       | 21 ++--------------
 .../test-stream-writable-hwm-error.js         | 24 ++++++++++++++++++
 .../test-stream-writable-hwm-mutable.js       | 25 +++----------------
 9 files changed, 92 insertions(+), 60 deletions(-)
 create mode 100644 test/parallel/test-stream-readable-hwm-error.js
 create mode 100644 test/parallel/test-stream-writable-hwm-error.js

diff --git a/doc/api/errors.md b/doc/api/errors.md
index 82f59190bbb9e9..89da6f5b20c9de 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1810,6 +1810,24 @@ pushed to the stream.
 An attempt was made to call [`stream.unshift()`][] after the `'end'` event was
 emitted.
 
+<a id="ERR_STREAM_UPDATING_HIGHWATERMARK_IN_READ"></a>
+### `ERR_STREAM_UPDATING_HIGHWATERMARK_IN_READ`
+<!-- YAML
+added: REPLACEME
+-->
+
+An attempt was made to update `readableHighWarkMark` from [`stream.read()`][]
+function.
+
+<a id="ERR_STREAM_UPDATING_HIGHWATERMARK_IN_WRITE"></a>
+### `ERR_STREAM_UPDATING_HIGHWATERMARK_IN_WRITE`
+<!-- YAML
+added: REPLACEME
+-->
+
+An attempt was made to update `writableHighWaterMark` from [`stream.write()`][]
+function.
+
 <a id="ERR_STREAM_WRAP"></a>
 ### `ERR_STREAM_WRAP`
 
@@ -2569,6 +2587,7 @@ such as `process.stdout.on('data')`.
 [`stream.push()`]: stream.html#stream_readable_push_chunk_encoding
 [`stream.unshift()`]: stream.html#stream_readable_unshift_chunk_encoding
 [`stream.write()`]: stream.html#stream_writable_write_chunk_encoding_callback
+[`stream.read()`]: stream.html#stream_readable_read_size
 [`subprocess.kill()`]: child_process.html#child_process_subprocess_kill_signal
 [`subprocess.send()`]: child_process.html#child_process_subprocess_send_message_sendhandle_options_callback
 [`util.getSystemErrorName(error.errno)`]: util.html#util_util_getsystemerrorname_err
diff --git a/doc/api/stream.md b/doc/api/stream.md
index 441f4a87870686..96353ffd795703 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -545,7 +545,8 @@ added: REPLACEME
 
 * {number}
 
-Get or set the value of `highWaterMark` for a given `Writable` stream.
+Get or set the value of `highWaterMark` for a given `Writable` stream. Should
+not update `writableHighWaterMark` from [`stream.write`][stream-write]
 
 ##### `writable.writableLength`
 <!-- YAML
@@ -1187,7 +1188,8 @@ added: REPLACEME
 
 * {number}
 
-Get or set the value of `highWaterMark` for a given `Readable` stream.
+Get or set the value of `highWaterMark` for a given `Readable` stream. Should
+not update `readableHighWaterMark` from [`stream.read()`][stream-read].
 
 ##### `readable.readableLength`
 <!-- YAML
diff --git a/lib/_stream_readable.js b/lib/_stream_readable.js
index 76cac54bf25888..387ad8300a780a 100644
--- a/lib/_stream_readable.js
+++ b/lib/_stream_readable.js
@@ -50,7 +50,8 @@ const {
   ERR_INVALID_ARG_TYPE,
   ERR_STREAM_PUSH_AFTER_EOF,
   ERR_METHOD_NOT_IMPLEMENTED,
-  ERR_STREAM_UNSHIFT_AFTER_END_EVENT
+  ERR_STREAM_UNSHIFT_AFTER_END_EVENT,
+  ERR_STREAM_UPDATING_HIGHWATERMARK_IN_READ,
 } = require('internal/errors').codes;
 
 const kPaused = Symbol('kPaused');
@@ -170,9 +171,6 @@ function ReadableState(options, stream, isDuplex) {
   // If true, a maybeReadMore has been scheduled.
   this.readingMore = false;
 
-  // Flags to update highwatermark
-  this.updateHighwaterMark = null;
-
   this.decoder = null;
   this.encoding = null;
   if (options && options.encoding) {
@@ -399,12 +397,6 @@ Readable.prototype.read = function(n) {
   const state = this._readableState;
   const nOrig = n;
 
-  // If they called updateHighwaterMark since last read
-  if (state.updateHighwaterMark !== null) {
-    state.highWaterMark = state.updateHighwaterMark;
-    state.updateHighwaterMark = null;
-  }
-
   // If we're asking for more than the current hwm, then raise the hwm.
   if (n > state.highWaterMark)
     state.highWaterMark = computeNewHighWaterMark(n);
@@ -1100,10 +1092,12 @@ ObjectDefineProperties(Readable.prototype, {
       return this._readableState.highWaterMark;
     },
     set: function(val) {
-      if (this._readableState.reading) {
-        this._readableState.updateHighwaterMark = val;
+      const state = this._readableState;
+      if (state.reading) {
+        errorOrDestroy(this, new ERR_STREAM_UPDATING_HIGHWATERMARK_IN_READ());
+        return;
       }
-      this._readableState.highWaterMark = val;
+      state.highWaterMark = val;
     }
   },
 
diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index 544867738ab001..4eca393f750b5a 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -54,7 +54,8 @@ const {
   ERR_STREAM_ALREADY_FINISHED,
   ERR_STREAM_NULL_VALUES,
   ERR_STREAM_WRITE_AFTER_END,
-  ERR_UNKNOWN_ENCODING
+  ERR_UNKNOWN_ENCODING,
+  ERR_STREAM_UPDATING_HIGHWATERMARK_IN_WRITE
 } = require('internal/errors').codes;
 
 const { errorOrDestroy } = destroyImpl;
@@ -768,10 +769,12 @@ ObjectDefineProperties(Writable.prototype, {
       return this._writableState && this._writableState.highWaterMark;
     },
     set(val) {
-      if (this._writableState.writing) {
-        this._writableState.updateHighwaterMark = val;
+      const state = this._writableState;
+      if (state.writing) {
+        errorOrDestroy(this, new ERR_STREAM_UPDATING_HIGHWATERMARK_IN_WRITE());
+        return;
       }
-      this._writableState.highWaterMark = val;
+      state.highWaterMark = val;
     }
   },
 
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 2a162f14b24206..2d619a002963d8 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -1346,6 +1346,10 @@ E('ERR_STREAM_PREMATURE_CLOSE', 'Premature close', Error);
 E('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF', Error);
 E('ERR_STREAM_UNSHIFT_AFTER_END_EVENT',
   'stream.unshift() after end event', Error);
+E('ERR_STREAM_UPDATING_HIGHWATERMARK_IN_READ',
+  'Cannot update highwatermark while reading', Error);
+E('ERR_STREAM_UPDATING_HIGHWATERMARK_IN_WRITE',
+  'Cannot update highwatermark while writing', Error);
 E('ERR_STREAM_WRAP', 'Stream has StringDecoder set or is in objectMode', Error);
 E('ERR_STREAM_WRITE_AFTER_END', 'write after end', Error);
 E('ERR_SYNTHETIC', 'JavaScript Callstack', Error);
diff --git a/test/parallel/test-stream-readable-hwm-error.js b/test/parallel/test-stream-readable-hwm-error.js
new file mode 100644
index 00000000000000..c93aea304fcb8e
--- /dev/null
+++ b/test/parallel/test-stream-readable-hwm-error.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+const rs = new stream.Readable({
+  read: function() {
+    this.readableHighWaterMark = 200;
+    this.push(null);
+  }
+});
+
+const ws = stream.Writable({ write() {} });
+
+rs.on('error', common.mustCall((err) => {
+  assert.strictEqual(err.code, 'ERR_STREAM_UPDATING_HIGHWATERMARK_IN_READ');
+  assert.strictEqual(err.message, 'Cannot update highwatermark while reading');
+}));
+rs.on('end', common.mustNotCall());
+
+rs.pipe(ws);
diff --git a/test/parallel/test-stream-readable-hwm-mutable.js b/test/parallel/test-stream-readable-hwm-mutable.js
index 7e56c7db3bc58c..5e10b67ec6c596 100644
--- a/test/parallel/test-stream-readable-hwm-mutable.js
+++ b/test/parallel/test-stream-readable-hwm-mutable.js
@@ -4,28 +4,11 @@ const common = require('../common');
 const assert = require('assert');
 const stream = require('stream');
 
-let currHighWaterMark = 20;
+const currHighWaterMark = 20;
 let pushes = 0;
 const rs = new stream.Readable({
   read: common.mustCall(function() {
-    if (pushes++ === 100) {
-      this.push(null);
-      return;
-    }
-
-    const highWaterMark = this.readableHighWaterMark;
-
-    // Both highwatermark and objectmode should update
-    // before it makes next _read request.
-    assert.strictEqual(highWaterMark, currHighWaterMark);
-
-    this.push(Buffer.alloc(1024));
-
-    if (pushes === 30) {
-      this.readableHighWaterMark = 2048;
-      currHighWaterMark = 2048;
-    }
-
+    (pushes++ < 100) ? this.push(Buffer.alloc(1024)) : this.push(null);
   }, 101)
 });
 
diff --git a/test/parallel/test-stream-writable-hwm-error.js b/test/parallel/test-stream-writable-hwm-error.js
new file mode 100644
index 00000000000000..ae9dc025490c20
--- /dev/null
+++ b/test/parallel/test-stream-writable-hwm-error.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+const rs = new stream.Readable({
+  read: function() {
+    this.push(Buffer.alloc(1024));
+    this.push(null);
+  }
+});
+
+const ws = stream.Writable({ write() {
+  this.writableHighWaterMark = 20;
+} });
+
+ws.on('error', common.mustCall((err) => {
+  assert.strictEqual(err.code, 'ERR_STREAM_UPDATING_HIGHWATERMARK_IN_WRITE');
+  assert.strictEqual(err.message, 'Cannot update highwatermark while writing');
+}));
+ws.on('end', common.mustNotCall());
+
+rs.pipe(ws);
diff --git a/test/parallel/test-stream-writable-hwm-mutable.js b/test/parallel/test-stream-writable-hwm-mutable.js
index deaf33720a5fa6..8070b0b0ed583c 100644
--- a/test/parallel/test-stream-writable-hwm-mutable.js
+++ b/test/parallel/test-stream-writable-hwm-mutable.js
@@ -7,33 +7,14 @@ const stream = require('stream');
 let pushes = 0;
 const rs = new stream.Readable({
   read: common.mustCall(function() {
-    if (pushes++ === 100) {
-      this.push(null);
-      return;
-    }
-
-    this.push(Buffer.alloc(1024));
+    pushes++ < 100 ? this.push(Buffer.alloc(1024)) : this.push(null);
   }, 101)
 });
 
-let currHighWaterMark = 0;
-let write = 0;
+const currHighWaterMark = 0;
 const ws = stream.Writable({
-  write: common.mustCall(function(data, enc, cb) {
-
-    const highWaterMark = this.writableHighWaterMark;
-
-    // Should update highwatermark
-    // after emptying current buffer
-    assert.strictEqual(highWaterMark, currHighWaterMark);
-
-    if (write++ === 30) {
-      this.writableHighWaterMark = 2048;
-      currHighWaterMark = 2048;
-    }
-
+  write: common.mustCall(function(_data, _enc, cb) {
     setImmediate(cb);
-
   }, 100)
 });
 

From cf280522fb112e829243f5106aedfa58a737470c Mon Sep 17 00:00:00 2001
From: Jay Patel <0807Jpatel@gmail.com>
Date: Thu, 14 May 2020 20:07:47 -0400
Subject: [PATCH 8/9] fix: removed unused highwatermark flags from writable
 stream

---
 lib/_stream_writable.js | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index 4eca393f750b5a..eff03937b7f349 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -180,9 +180,6 @@ function WritableState(options, stream, isDuplex) {
   // True if close has been emitted or would have been emitted
   // depending on emitClose.
   this.closeEmitted = false;
-
-  // Flags to update highwatermark and objectMode
-  this.updateHighwaterMark = null;
 }
 
 function resetBuffer(state) {
@@ -266,11 +263,6 @@ Writable.prototype.pipe = function() {
 Writable.prototype.write = function(chunk, encoding, cb) {
   const state = this._writableState;
 
-  if (state.updateHighwaterMark !== null) {
-    state.highWaterMark = state.updateHighwaterMark;
-    state.updateHighwaterMark = null;
-  }
-
   if (typeof encoding === 'function') {
     cb = encoding;
     encoding = state.defaultEncoding;

From 0b7b1ea6e2b8f1c452c8e2319a653f5107b1dfe3 Mon Sep 17 00:00:00 2001
From: Jay Patel <0807Jpatel@gmail.com>
Date: Thu, 14 May 2020 20:09:26 -0400
Subject: [PATCH 9/9] chore: updated debug statement

---
 lib/_stream_readable.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/_stream_readable.js b/lib/_stream_readable.js
index 387ad8300a780a..79d89584f93d3b 100644
--- a/lib/_stream_readable.js
+++ b/lib/_stream_readable.js
@@ -468,7 +468,7 @@ Readable.prototype.read = function(n) {
   // then it's not allowed.
   if (state.ended || state.reading || state.destroyed || state.errored) {
     doRead = false;
-    debug('reading or ended or objectMode update', doRead);
+    debug('reading or ended', doRead);
   } else if (doRead) {
     debug('do read');
     state.reading = true;