benchmark,lib,test: use braces for multiline block

benchmark/buffers/buffer-iterate.js

@@ -29,20 +29,23 @@ function main(conf) {
 function benchFor(buffer, n) {
   bench.start();
 
-  for (var k = 0; k < n; k++)
-    for (var i = 0; i < buffer.length; i++)
+  for (var k = 0; k < n; k++) {
+    for (var i = 0; i < buffer.length; i++) {
       assert(buffer[i] === 0);
+    }
+  }
 
   bench.end(n);
 }
 
 function benchForOf(buffer, n) {
   bench.start();
 
-  for (var k = 0; k < n; k++)
-    for (var b of buffer)
+  for (var k = 0; k < n; k++) {
+    for (var b of buffer) {
       assert(b === 0);
-
+    }
+  }
   bench.end(n);
 }
 

benchmark/dgram/array-vs-concat.js

@@ -46,17 +46,19 @@ function server() {
   var onsend = type === 'concat' ? onsendConcat : onsendMulti;
 
   function onsendConcat() {
-    if (sent++ % num === 0)
+    if (sent++ % num === 0) {
       for (var i = 0; i < num; i++) {
         socket.send(Buffer.concat(chunk), PORT, '127.0.0.1', onsend);
       }
+    }
   }
 
   function onsendMulti() {
-    if (sent++ % num === 0)
+    if (sent++ % num === 0) {
       for (var i = 0; i < num; i++) {
         socket.send(chunk, PORT, '127.0.0.1', onsend);
       }
+    }
   }
 
   socket.on('listening', function() {

benchmark/dgram/multi-buffer.js

@@ -45,9 +45,11 @@ function server() {
   var socket = dgram.createSocket('udp4');
 
   function onsend() {
-    if (sent++ % num === 0)
-      for (var i = 0; i < num; i++)
+    if (sent++ % num === 0) {
+      for (var i = 0; i < num; i++) {
         socket.send(chunk, PORT, '127.0.0.1', onsend);
+      }
+    }
   }
 
   socket.on('listening', function() {

benchmark/dgram/offset-length.js

@@ -37,9 +37,11 @@ function server() {
   var socket = dgram.createSocket('udp4');
 
   function onsend() {
-    if (sent++ % num === 0)
-      for (var i = 0; i < num; i++)
+    if (sent++ % num === 0) {
+      for (var i = 0; i < num; i++) {
         socket.send(chunk, 0, chunk.length, PORT, '127.0.0.1', onsend);
+      }
+    }
   }
 
   socket.on('listening', function() {

benchmark/dgram/single-buffer.js

@@ -37,9 +37,11 @@ function server() {
   var socket = dgram.createSocket('udp4');
 
   function onsend() {
-    if (sent++ % num === 0)
-      for (var i = 0; i < num; i++)
+    if (sent++ % num === 0) {
+      for (var i = 0; i < num; i++) {
         socket.send(chunk, PORT, '127.0.0.1', onsend);
+      }
+    }
   }
 
   socket.on('listening', function() {

benchmark/url/url-searchparams-iteration.js

@@ -32,11 +32,12 @@ function iterator(n) {
   const noDead = [];
 
   bench.start();
-  for (var i = 0; i < n; i += 1)
+  for (var i = 0; i < n; i += 1) {
     for (var pair of params) {
       noDead[0] = pair[0];
       noDead[1] = pair[1];
     }
+  }
   bench.end(n);
 
   assert.strictEqual(noDead[0], 'three');

lib/_http_client.js

@@ -319,12 +319,13 @@ ClientRequest.prototype.abort = function abort() {
   this.aborted = Date.now();
 
   // If we're aborting, we don't care about any more response data.
-  if (this.res)
+  if (this.res) {
     this.res._dump();
-  else
+  } else {
     this.once('response', function(res) {
       res._dump();
     });
+  }
 
   // In the event that we don't have a socket, we will pop out of
   // the request queue through handling in onSocket.

lib/_http_outgoing.js

@@ -219,12 +219,13 @@ OutgoingMessage.prototype.setTimeout = function setTimeout(msecs, callback) {
 // any messages, before ever calling this.  In that case, just skip
 // it, since something else is destroying this connection anyway.
 OutgoingMessage.prototype.destroy = function destroy(error) {
-  if (this.socket)
+  if (this.socket) {
     this.socket.destroy(error);
-  else
+  } else {
     this.once('socket', function(socket) {
       socket.destroy(error);
     });
+  }
 };
 
 
@@ -505,8 +506,7 @@ function matchHeader(self, state, field, value) {
 
 function validateHeader(msg, name, value) {
   if (typeof name !== 'string' || !name || !checkIsHttpToken(name))
-    throw new TypeError(
-      'Header name must be a valid HTTP Token ["' + name + '"]');
+    throw new TypeError(`Header name must be a valid HTTP Token ["${name}"]`);
   if (value === undefined)
     throw new Error('"value" required in setHeader("' + name + '", value)');
   if (msg._header)

lib/_http_server.js

@@ -185,9 +185,10 @@ function writeHead(statusCode, reason, obj) {
   var originalStatusCode = statusCode;
 
   statusCode |= 0;
-  if (statusCode < 100 || statusCode > 999)
+  if (statusCode < 100 || statusCode > 999) {
     throw new errors.RangeError('ERR_HTTP_INVALID_STATUS_CODE',
                                  originalStatusCode);
+  }
 
 
   if (typeof reason === 'string') {
@@ -224,9 +225,10 @@ function writeHead(statusCode, reason, obj) {
     headers = obj;
   }
 
-  if (common._checkInvalidHeaderChar(this.statusMessage))
+  if (common._checkInvalidHeaderChar(this.statusMessage)) {
     throw new errors.Error('ERR_HTTP_INVALID_CHAR',
                            'Invalid character in statusMessage.');
+  }
 
   var statusLine = 'HTTP/1.1 ' + statusCode + ' ' + this.statusMessage + CRLF;
 

lib/buffer.js

@@ -207,13 +207,14 @@ Object.setPrototypeOf(Buffer, Uint8Array);
 function assertSize(size) {
   let err = null;
 
-  if (typeof size !== 'number')
+  if (typeof size !== 'number') {
     err = new TypeError('"size" argument must be a number');
-  else if (size < 0)
+  } else if (size < 0) {
     err = new RangeError('"size" argument must not be negative');
-  else if (size > binding.kMaxLength)
+  } else if (size > binding.kMaxLength) {
     err = new RangeError('"size" argument must not be larger ' +
                          'than ' + binding.kMaxLength);
+  }
 
   if (err) {
     Error.captureStackTrace(err, assertSize);

lib/child_process.js

@@ -533,15 +533,16 @@ function spawnSync(/*file, args, options*/) {
     var input = options.stdio[i] && options.stdio[i].input;
     if (input != null) {
       var pipe = options.stdio[i] = util._extend({}, options.stdio[i]);
-      if (isUint8Array(input))
+      if (isUint8Array(input)) {
         pipe.input = input;
-      else if (typeof input === 'string')
+      } else if (typeof input === 'string') {
         pipe.input = Buffer.from(input, options.encoding);
-      else
+      } else {
         throw new TypeError(util.format(
             'stdio[%d] should be Buffer, Uint8Array or string not %s',
             i,
             typeof input));
+      }
     }
   }
 

lib/fs.js

@@ -1951,10 +1951,11 @@ ReadStream.prototype.open = function() {
 };
 
 ReadStream.prototype._read = function(n) {
-  if (typeof this.fd !== 'number')
+  if (typeof this.fd !== 'number') {
     return this.once('open', function() {
       this._read(n);
     });
+  }
 
   if (this.destroyed)
     return;
@@ -2116,10 +2117,11 @@ WriteStream.prototype._write = function(data, encoding, cb) {
   if (!(data instanceof Buffer))
     return this.emit('error', new Error('Invalid data'));
 
-  if (typeof this.fd !== 'number')
+  if (typeof this.fd !== 'number') {
     return this.once('open', function() {
       this._write(data, encoding, cb);
     });
+  }
 
   var self = this;
   fs.write(this.fd, data, 0, data.length, this.pos, function(er, bytes) {
@@ -2151,10 +2153,11 @@ function writev(fd, chunks, position, callback) {
 
 
 WriteStream.prototype._writev = function(data, cb) {
-  if (typeof this.fd !== 'number')
+  if (typeof this.fd !== 'number') {
     return this.once('open', function() {
       this._writev(data, cb);
     });
+  }
 
   const self = this;
   const len = data.length;

lib/inspector.js

@@ -41,22 +41,26 @@ class Session extends EventEmitter {
   }
 
   post(method, params, callback) {
-    if (typeof method !== 'string')
+    if (typeof method !== 'string') {
       throw new TypeError(
           `"method" must be a string, got ${typeof method} instead`);
+    }
     if (!callback && util.isFunction(params)) {
       callback = params;
       params = null;
     }
-    if (params && typeof params !== 'object')
+    if (params && typeof params !== 'object') {
       throw new TypeError(
           `"params" must be an object, got ${typeof params} instead`);
-    if (callback && typeof callback !== 'function')
+    }
+    if (callback && typeof callback !== 'function') {
       throw new TypeError(
           `"callback" must be a function, got ${typeof callback} instead`);
+    }
 
-    if (!this[connectionSymbol])
+    if (!this[connectionSymbol]) {
       throw new Error('Session is not connected');
+    }
     const id = this[nextIdSymbol]++;
     const message = {id, method};
     if (params) {

lib/internal/process.js

@@ -46,10 +46,12 @@ function setup_cpuUsage() {
     }
 
     // If a previous value was passed in, return diff of current from previous.
-    if (prevValue) return {
-      user: cpuValues[0] - prevValue.user,
-      system: cpuValues[1] - prevValue.system
-    };
+    if (prevValue) {
+      return {
+        user: cpuValues[0] - prevValue.user,
+        system: cpuValues[1] - prevValue.system
+      };
+    }
 
     // If no previous value passed in, return current value.
     return {

lib/net.js

@@ -1005,19 +1005,23 @@ function lookupAndConnect(self, options) {
   var localAddress = options.localAddress;
   var localPort = options.localPort;
 
-  if (localAddress && !cares.isIP(localAddress))
+  if (localAddress && !cares.isIP(localAddress)) {
     throw new TypeError('"localAddress" option must be a valid IP: ' +
                         localAddress);
+  }
 
-  if (localPort && typeof localPort !== 'number')
+  if (localPort && typeof localPort !== 'number') {
     throw new TypeError('"localPort" option should be a number: ' + localPort);
+  }
 
   if (typeof port !== 'undefined') {
-    if (typeof port !== 'number' && typeof port !== 'string')
+    if (typeof port !== 'number' && typeof port !== 'string') {
       throw new TypeError('"port" option should be a number or string: ' +
                           port);
-    if (!isLegalPort(port))
+    }
+    if (!isLegalPort(port)) {
       throw new RangeError('"port" option should be >= 0 and < 65536: ' + port);
+    }
   }
   port |= 0;
 

lib/readline.js

@@ -285,16 +285,18 @@ Interface.prototype._onLine = function(line) {
 };
 
 Interface.prototype._writeToOutput = function _writeToOutput(stringToWrite) {
-  if (typeof stringToWrite !== 'string')
+  if (typeof stringToWrite !== 'string') {
     throw new errors.TypeError(
       'ERR_INVALID_ARG_TYPE',
       'stringToWrite',
       'string',
       stringToWrite
     );
+  }
 
-  if (this.output !== null && this.output !== undefined)
+  if (this.output !== null && this.output !== undefined) {
     this.output.write(stringToWrite);
+  }
 };
 
 Interface.prototype._addHistory = function() {

lib/tls.js

@@ -122,9 +122,10 @@ function check(hostParts, pattern, wildcards) {
     return false;
 
   // Check host parts from right to left first.
-  for (var i = hostParts.length - 1; i > 0; i -= 1)
+  for (var i = hostParts.length - 1; i > 0; i -= 1) {
     if (hostParts[i] !== patternParts[i])
       return false;
+  }
 
   const hostSubdomain = hostParts[0];
   const patternSubdomain = patternParts[0];

lib/util.js

@@ -960,9 +960,10 @@ exports.inherits = function(ctor, superCtor) {
   if (superCtor === undefined || superCtor === null)
     throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'superCtor', 'function');
 
-  if (superCtor.prototype === undefined)
+  if (superCtor.prototype === undefined) {
     throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'superCtor.prototype',
                                'function');
+  }
   ctor.super_ = superCtor;
   Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
 };