lib: remove internal util._extends() usage

This removes all internal calls to the deprecated `_extends()`
function. It is slower than `Object.assign()` and the object spread
notation since V8 6.8 and using the spread notation often also
results in shorter code.

PR-URL: #25105
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>

lib/_http_agent.js

@@ -48,7 +48,7 @@ function Agent(options) {
   this.defaultPort = 80;
   this.protocol = 'http:';
 
-  this.options = util._extend({}, options);
+  this.options = { ...options };
 
   // Don't confuse net and make it think that we're connecting to a pipe
   this.options.path = null;
@@ -146,8 +146,7 @@ Agent.prototype.addRequest = function addRequest(req, options, port/* legacy */,
     };
   }
 
-  options = util._extend({}, options);
-  util._extend(options, this.options);
+  options = { ...options, ...this.options };
   if (options.socketPath)
     options.path = options.socketPath;
 
@@ -194,8 +193,7 @@ Agent.prototype.addRequest = function addRequest(req, options, port/* legacy */,
 };
 
 Agent.prototype.createSocket = function createSocket(req, options, cb) {
-  options = util._extend({}, options);
-  util._extend(options, this.options);
+  options = { ...options, ...this.options };
   if (options.socketPath)
     options.path = options.socketPath;
 

lib/_http_client.js

@@ -21,7 +21,6 @@
 
 'use strict';
 
-const util = require('util');
 const net = require('net');
 const url = require('url');
 const assert = require('assert').ok;
@@ -93,11 +92,11 @@ function ClientRequest(input, options, cb) {
 
   if (typeof options === 'function') {
     cb = options;
-    options = null;
+    options = input || {};
+  } else {
+    options = Object.assign(input || {}, options);
   }
 
-  options = util._extend(input || {}, options || {});
-
   var agent = options.agent;
   var defaultAgent = options._defaultAgent || Agent.globalAgent;
   if (agent === false) {

lib/_http_server.js

@@ -282,7 +282,7 @@ function Server(options, requestListener) {
     requestListener = options;
     options = {};
   } else if (options == null || typeof options === 'object') {
-    options = util._extend({}, options);
+    options = { ...options };
   } else {
     throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
   }

lib/_tls_wrap.js

@@ -1109,22 +1109,22 @@ function SNICallback(servername, callback) {
 //
 //
 function normalizeConnectArgs(listArgs) {
-  var args = net._normalizeArgs(listArgs);
-  var options = args[0];
-  var cb = args[1];
+  const args = net._normalizeArgs(listArgs);
+  const options = args[0];
+  const cb = args[1];
 
   // If args[0] was options, then normalize dealt with it.
   // If args[0] is port, or args[0], args[1] is host, port, we need to
   // find the options and merge them in, normalize's options has only
   // the host/port/path args that it knows about, not the tls options.
   // This means that options.host overrides a host arg.
   if (listArgs[1] !== null && typeof listArgs[1] === 'object') {
-    util._extend(options, listArgs[1]);
+    Object.assign(options, listArgs[1]);
   } else if (listArgs[2] !== null && typeof listArgs[2] === 'object') {
-    util._extend(options, listArgs[2]);
+    Object.assign(options, listArgs[2]);
   }
 
-  return (cb) ? [options, cb] : [options];
+  return cb ? [options, cb] : [options];
 }
 
 function onConnectSecure() {
@@ -1205,14 +1205,14 @@ exports.connect = function connect(...args) {
                         'certificate verification.');
   }
 
-  var defaults = {
+  options = {
     rejectUnauthorized: !allowUnauthorized,
     ciphers: tls.DEFAULT_CIPHERS,
     checkServerIdentity: tls.checkServerIdentity,
-    minDHSize: 1024
+    minDHSize: 1024,
+    ...options
   };
 
-  options = util._extend(defaults, options || {});
   if (!options.keepAlive)
     options.singleUse = true;
 

lib/child_process.js

@@ -79,7 +79,7 @@ exports.fork = function fork(modulePath /* , args, options */) {
       throw new ERR_INVALID_ARG_VALUE(`arguments[${pos}]`, arguments[pos]);
     }
 
-    options = util._extend({}, arguments[pos++]);
+    options = { ...arguments[pos++] };
   }
 
   // Prepare arguments for fork:
@@ -176,28 +176,20 @@ Object.defineProperty(exports.exec, util.promisify.custom, {
 });
 
 exports.execFile = function execFile(file /* , args, options, callback */) {
-  var args = [];
-  var callback;
-  var options = {
-    encoding: 'utf8',
-    timeout: 0,
-    maxBuffer: 200 * 1024,
-    killSignal: 'SIGTERM',
-    cwd: null,
-    env: null,
-    shell: false
-  };
+  let args = [];
+  let callback;
+  let options;
 
   // Parse the optional positional parameters.
-  var pos = 1;
+  let pos = 1;
   if (pos < arguments.length && Array.isArray(arguments[pos])) {
     args = arguments[pos++];
   } else if (pos < arguments.length && arguments[pos] == null) {
     pos++;
   }
 
   if (pos < arguments.length && typeof arguments[pos] === 'object') {
-    util._extend(options, arguments[pos++]);
+    options = arguments[pos++];
   } else if (pos < arguments.length && arguments[pos] == null) {
     pos++;
   }
@@ -210,6 +202,17 @@ exports.execFile = function execFile(file /* , args, options, callback */) {
     throw new ERR_INVALID_ARG_VALUE('args', arguments[pos]);
   }
 
+  options = {
+    encoding: 'utf8',
+    timeout: 0,
+    maxBuffer: 200 * 1024,
+    killSignal: 'SIGTERM',
+    cwd: null,
+    env: null,
+    shell: false,
+    ...options
+  };
+
   // Validate the timeout, if present.
   validateTimeout(options.timeout);
 
@@ -580,15 +583,15 @@ function spawnSync(/* file, args, options */) {
   options.stdio = _validateStdio(options.stdio || 'pipe', true).stdio;
 
   if (options.input) {
-    var stdin = options.stdio[0] = util._extend({}, options.stdio[0]);
+    var stdin = options.stdio[0] = { ...options.stdio[0] };
     stdin.input = options.input;
   }
 
   // We may want to pass data in on any given fd, ensure it is a valid buffer
   for (var i = 0; i < options.stdio.length; i++) {
     var input = options.stdio[i] && options.stdio[i].input;
     if (input != null) {
-      var pipe = options.stdio[i] = util._extend({}, options.stdio[i]);
+      var pipe = options.stdio[i] = { ...options.stdio[i] };
       if (isArrayBufferView(input)) {
         pipe.input = input;
       } else if (typeof input === 'string') {

lib/domain.js

@@ -343,11 +343,9 @@ Domain.prototype.run = function(fn) {
 function intercepted(_this, self, cb, fnargs) {
   if (fnargs[0] && fnargs[0] instanceof Error) {
     var er = fnargs[0];
-    util._extend(er, {
-      domainBound: cb,
-      domainThrown: false,
-      domain: self
-    });
+    er.domainBound = cb;
+    er.domainThrown = false;
+    er.domain = self;
     self.emit('error', er);
     return;
   }

lib/fs.js

@@ -39,7 +39,6 @@ const {
   O_SYMLINK
 } = constants;
 
-const { _extend } = require('util');
 const pathModule = require('path');
 const { isArrayBufferView } = require('internal/util/types');
 const binding = internalBinding('fs');
@@ -1325,21 +1324,20 @@ function watchFile(filename, options, listener) {
   filename = pathModule.resolve(filename);
   let stat;
 
-  const defaults = {
+  if (options === null || typeof options !== 'object') {
+    listener = options;
+    options = null;
+  }
+
+  options = {
     // Poll interval in milliseconds. 5007 is what libev used to use. It's
     // a little on the slow side but let's stick with it for now to keep
     // behavioral changes to a minimum.
     interval: 5007,
-    persistent: true
+    persistent: true,
+    ...options
   };
 
-  if (options !== null && typeof options === 'object') {
-    options = _extend(defaults, options);
-  } else {
-    listener = options;
-    options = defaults;
-  }
-
   if (typeof listener !== 'function') {
     throw new ERR_INVALID_ARG_TYPE('listener', 'Function', listener);
   }

lib/https.js

@@ -46,7 +46,7 @@ function Server(opts, requestListener) {
     requestListener = opts;
     opts = undefined;
   }
-  opts = util._extend({}, opts);
+  opts = { ...opts };
 
   if (!opts.ALPNProtocols) {
     // http/1.0 is not defined as Protocol IDs in IANA
@@ -110,9 +110,10 @@ function createConnection(port, host, options) {
     const session = this._getSession(options._agentKey);
     if (session) {
       debug('reuse session for %j', options._agentKey);
-      options = util._extend({
-        session: session
-      }, options);
+      options = {
+        session,
+        ...options
+      };
     }
   }
 
@@ -292,7 +293,7 @@ function request(...args) {
   }
 
   if (args[0] && typeof args[0] !== 'function') {
-    options = util._extend(options, args.shift());
+    Object.assign(options, args.shift());
   }
 
   options._defaultAgent = globalAgent;

lib/internal/cluster/child.js

@@ -1,6 +1,5 @@
 'use strict';
 const assert = require('assert');
-const util = require('util');
 const path = require('path');
 const EventEmitter = require('events');
 const { owner_symbol } = require('internal/async_hooks').symbols;
@@ -71,11 +70,12 @@ cluster._getServer = function(obj, options, cb) {
 
   indexes.set(indexesKey, index);
 
-  const message = util._extend({
+  const message = {
     act: 'queryServer',
     index,
-    data: null
-  }, options);
+    data: null,
+    ...options
+  };
 
   message.address = address;
 
@@ -151,7 +151,7 @@ function rr(message, indexesKey, cb) {
 
   function getsockname(out) {
     if (key)
-      util._extend(out, message.sockname);
+      Object.assign(out, message.sockname);
 
     return 0;
   }

lib/internal/cluster/master.js

@@ -1,7 +1,6 @@
 'use strict';
 const assert = require('assert');
 const { fork } = require('child_process');
-const util = require('util');
 const path = require('path');
 const EventEmitter = require('events');
 const RoundRobinHandle = require('internal/cluster/round_robin_handle');
@@ -47,14 +46,14 @@ if (schedulingPolicy === undefined) {
 cluster.schedulingPolicy = schedulingPolicy;
 
 cluster.setupMaster = function(options) {
-  var settings = {
+  const settings = {
     args: process.argv.slice(2),
     exec: process.argv[1],
     execArgv: process.execArgv,
-    silent: false
+    silent: false,
+    ...cluster.settings,
+    ...options
   };
-  util._extend(settings, cluster.settings);
-  util._extend(settings, options || {});
 
   // Tell V8 to write profile data for each process to a separate file.
   // Without --logfile=v8-%p.log, everything ends up in a single, unusable
@@ -101,15 +100,12 @@ function setupSettingsNT(settings) {
 }
 
 function createWorkerProcess(id, env) {
-  const workerEnv = util._extend({}, process.env);
+  const workerEnv = { ...process.env, ...env, NODE_UNIQUE_ID: `${id}` };
   const execArgv = cluster.settings.execArgv.slice();
   const debugArgRegex = /--inspect(?:-brk|-port)?|--debug-port/;
   const nodeOptions = process.env.NODE_OPTIONS ?
     process.env.NODE_OPTIONS : '';
 
-  util._extend(workerEnv, env);
-  workerEnv.NODE_UNIQUE_ID = '' + id;
-
   if (execArgv.some((arg) => arg.match(debugArgRegex)) ||
       nodeOptions.match(debugArgRegex)) {
     let inspectPort;
@@ -315,17 +311,18 @@ function queryServer(worker, message) {
 
   // Set custom server data
   handle.add(worker, (errno, reply, handle) => {
-    reply = util._extend({
-      errno: errno,
-      key: key,
-      ack: message.seq,
-      data: handles.get(key).data
-    }, reply);
+    const { data } = handles.get(key);
 
     if (errno)
       handles.delete(key);  // Gives other workers a chance to retry.
 
-    send(worker, reply, handle);
+    send(worker, {
+      errno,
+      key,
+      ack: message.seq,
+      data,
+      ...reply
+    }, handle);
   });
 }
 

lib/internal/cluster/utils.js

@@ -1,5 +1,4 @@
 'use strict';
-const util = require('util');
 
 module.exports = {
   sendHelper,
@@ -14,12 +13,11 @@ function sendHelper(proc, message, handle, cb) {
     return false;
 
   // Mark message as internal. See INTERNAL_PREFIX in lib/child_process.js
-  message = util._extend({ cmd: 'NODE_CLUSTER' }, message);
+  message = { cmd: 'NODE_CLUSTER', ...message, seq };
 
   if (typeof cb === 'function')
     callbacks.set(seq, cb);
 
-  message.seq = seq;
   seq += 1;
   return proc.send(message, handle);
 }