lib: macro-ify type checks

Increases the grep factor. Makes it easier to harmonize type checks
across the code base.

lib/_debugger.js

@@ -182,7 +182,7 @@ exports.Client = Client;
 
 
 Client.prototype._addHandle = function(desc) {
-  if (typeof desc != 'object' || typeof desc.handle != 'number') {
+  if (!IS_OBJECT(desc) || !IS_NUMBER(desc.handle)) {
     return;
   }
 
@@ -296,7 +296,7 @@ Client.prototype.reqLookup = function(refs, cb) {
   this.req(req, function(err, res) {
     if (err) return cb(err);
     for (var ref in res) {
-      if (typeof res[ref] == 'object') {
+      if (IS_OBJECT(res[ref])) {
         self._addHandle(res[ref]);
       }
     }
@@ -559,8 +559,7 @@ Client.prototype.mirrorObject = function(handle, depth, cb) {
         }
 
 
-        if (Array.isArray(mirror) &&
-            typeof prop.name != 'number') {
+        if (IS_ARRAY(mirror) && !IS_NUMBER(prop.name)) {
           // Skip the 'length' property.
           return;
         }
@@ -593,7 +592,7 @@ Client.prototype.mirrorObject = function(handle, depth, cb) {
     val = function() {};
   } else if (handle.type === 'null') {
     val = null;
-  } else if (handle.value !== undefined) {
+  } else if (!IS_UNDEFINED(handle.value)) {
     val = handle.value;
   } else if (handle.type === 'undefined') {
     val = undefined;
@@ -892,7 +891,7 @@ Interface.prototype.print = function(text, oneline) {
   if (this.killed) return;
   this.clearline();
 
-  this.stdout.write(typeof text === 'string' ? text : util.inspect(text));
+  this.stdout.write(IS_STRING(text) ? text : util.inspect(text));
 
   if (oneline !== true) {
     this.stdout.write('\n');
@@ -1214,7 +1213,7 @@ Interface.prototype.scripts = function() {
   this.pause();
   for (var id in client.scripts) {
     var script = client.scripts[id];
-    if (typeof script == 'object' && script.name) {
+    if (IS_OBJECT(script) && script.name) {
       if (displayNatives ||
           script.name == client.currentScript ||
           !script.isNative) {
@@ -1351,13 +1350,13 @@ Interface.prototype.setBreakpoint = function(script, line,
       ambiguous;
 
   // setBreakpoint() should insert breakpoint on current line
-  if (script === undefined) {
+  if (IS_UNDEFINED(script)) {
     script = this.client.currentScript;
     line = this.client.currentSourceLine + 1;
   }
 
   // setBreakpoint(line-number) should insert breakpoint in current script
-  if (line === undefined && typeof script === 'number') {
+  if (IS_UNDEFINED(line) && IS_NUMBER(script)) {
     line = script;
     script = this.client.currentScript;
   }
@@ -1452,7 +1451,7 @@ Interface.prototype.clearBreakpoint = function(script, line) {
     if (bp.scriptId === script ||
         bp.scriptReq === script ||
         (bp.script && bp.script.indexOf(script) !== -1)) {
-      if (index !== undefined) {
+      if (!IS_UNDEFINED(index)) {
         ambiguous = true;
       }
       if (bp.line === line) {
@@ -1465,7 +1464,7 @@ Interface.prototype.clearBreakpoint = function(script, line) {
 
   if (ambiguous) return this.error('Script name is ambiguous');
 
-  if (breakpoint === undefined) {
+  if (IS_UNDEFINED(breakpoint)) {
     return this.error('Script : ' + script + ' not found');
   }
 

lib/_http_agent.js

@@ -246,7 +246,7 @@ Agent.prototype.destroy = function() {
 };
 
 Agent.prototype.request = function(options, cb) {
-  if (typeof options === 'string') {
+  if (IS_STRING(options)) {
     options = url.parse(options);
   }
   // don't try to do dns lookups of foo.com:8080, just foo.com

lib/_http_client.js

@@ -44,14 +44,14 @@ function ClientRequest(options, cb) {
   var self = this;
   OutgoingMessage.call(self);
 
-  self.agent = options.agent === undefined ? globalAgent : options.agent;
+  self.agent = IS_UNDEFINED(options.agent) ? globalAgent : options.agent;
 
   var defaultPort = options.defaultPort || 80;
 
   var port = options.port || defaultPort;
   var host = options.hostname || options.host || 'localhost';
 
-  if (options.setHost === undefined) {
+  if (IS_UNDEFINED(options.setHost)) {
     var setHost = true;
   }
 
@@ -63,7 +63,7 @@ function ClientRequest(options, cb) {
     self.once('response', cb);
   }
 
-  if (!Array.isArray(options.headers)) {
+  if (!IS_ARRAY(options.headers)) {
     if (options.headers) {
       var keys = Object.keys(options.headers);
       for (var i = 0, l = keys.length; i < l; i++) {
@@ -92,7 +92,7 @@ function ClientRequest(options, cb) {
     self.useChunkedEncodingByDefault = true;
   }
 
-  if (Array.isArray(options.headers)) {
+  if (IS_ARRAY(options.headers)) {
     self._storeHeader(self.method + ' ' + self.path + ' HTTP/1.1\r\n',
                       options.headers);
   } else if (self.getHeader('expect')) {
@@ -413,7 +413,7 @@ ClientRequest.prototype.onSocket = function(socket) {
     httpSocketSetup(socket);
 
     // Propagate headers limit from request object to parser
-    if (typeof req.maxHeadersCount === 'number') {
+    if (IS_NUMBER(req.maxHeadersCount)) {
       parser.maxHeaderPairs = req.maxHeadersCount << 1;
     } else {
       // Set default value because parser may be reused from FreeList

lib/_http_incoming.js

@@ -125,7 +125,7 @@ IncomingMessage.prototype._addHeaderLine = function(field, value) {
   switch (field) {
     // Array headers:
     case 'set-cookie':
-      if (dest[field] !== undefined) {
+      if (!IS_UNDEFINED(dest[field])) {
         dest[field].push(value);
       } else {
         dest[field] = [value];
@@ -145,7 +145,7 @@ IncomingMessage.prototype._addHeaderLine = function(field, value) {
     case 'proxy-authenticate':
     case 'sec-websocket-extensions':
     case 'sec-websocket-protocol':
-      if (dest[field] !== undefined) {
+      if (!IS_UNDEFINED(dest[field])) {
         dest[field] += ', ' + value;
       } else {
         dest[field] = value;
@@ -156,14 +156,14 @@ IncomingMessage.prototype._addHeaderLine = function(field, value) {
     default:
       if (field.slice(0, 2) == 'x-') {
         // except for x-
-        if (dest[field] !== undefined) {
+        if (!IS_UNDEFINED(dest[field])) {
           dest[field] += ', ' + value;
         } else {
           dest[field] = value;
         }
       } else {
         // drop duplicates
-        if (dest[field] === undefined) dest[field] = value;
+        if (IS_UNDEFINED(dest[field])) dest[field] = value;
       }
       break;
   }

lib/_http_outgoing.js

@@ -115,7 +115,7 @@ OutgoingMessage.prototype._send = function(data, encoding) {
   // the same packet. Future versions of Node are going to take care of
   // this at a lower level and in a more general way.
   if (!this._headerSent) {
-    if (typeof data === 'string') {
+    if (IS_STRING(data)) {
       data = this._header + data;
     } else {
       this.output.unshift(this._header);
@@ -166,7 +166,7 @@ OutgoingMessage.prototype._buffer = function(data, encoding) {
 
   var length = this.output.length;
 
-  if (length === 0 || typeof data != 'string') {
+  if (length === 0 || !IS_STRING(data)) {
     this.output.push(data);
     this.outputEncodings.push(encoding);
     return false;
@@ -205,7 +205,7 @@ OutgoingMessage.prototype._storeHeader = function(firstLine, headers) {
 
   if (headers) {
     var keys = Object.keys(headers);
-    var isArray = (Array.isArray(headers));
+    var isArray = IS_ARRAY(headers);
     var field, value;
 
     for (var i = 0, l = keys.length; i < l; i++) {
@@ -218,7 +218,7 @@ OutgoingMessage.prototype._storeHeader = function(firstLine, headers) {
         value = headers[key];
       }
 
-      if (Array.isArray(value)) {
+      if (IS_ARRAY(value)) {
         for (var j = 0; j < value.length; j++) {
           storeHeader(this, state, field, value[j]);
         }
@@ -401,7 +401,7 @@ OutgoingMessage.prototype.write = function(chunk, encoding) {
     return true;
   }
 
-  if (typeof chunk !== 'string' && !Buffer.isBuffer(chunk)) {
+  if (!IS_STRING(chunk) && !IS_BUFFER(chunk)) {
     throw new TypeError('first argument must be a string or Buffer');
   }
 
@@ -412,7 +412,7 @@ OutgoingMessage.prototype.write = function(chunk, encoding) {
 
   var len, ret;
   if (this.chunkedEncoding) {
-    if (typeof(chunk) === 'string' &&
+    if (IS_STRING(chunk) &&
         encoding !== 'hex' &&
         encoding !== 'base64' &&
         encoding !== 'binary') {
@@ -444,7 +444,7 @@ OutgoingMessage.prototype.write = function(chunk, encoding) {
 OutgoingMessage.prototype.addTrailers = function(headers) {
   this._trailer = '';
   var keys = Object.keys(headers);
-  var isArray = (Array.isArray(headers));
+  var isArray = IS_ARRAY(headers);
   var field, value;
   for (var i = 0, l = keys.length; i < l; i++) {
     var key = keys[i];
@@ -466,7 +466,7 @@ var crlf_buf = new Buffer('\r\n');
 
 
 OutgoingMessage.prototype.end = function(data, encoding) {
-  if (data && typeof data !== 'string' && !Buffer.isBuffer(data)) {
+  if (data && !IS_STRING(data) && !IS_BUFFER(data)) {
     throw new TypeError('first argument must be a string or Buffer');
   }
 

lib/_http_server.js

@@ -173,7 +173,7 @@ ServerResponse.prototype._implicitHeader = function() {
 ServerResponse.prototype.writeHead = function(statusCode) {
   var reasonPhrase, headers, headerIndex;
 
-  if (typeof arguments[1] == 'string') {
+  if (IS_STRING(arguments[1])) {
     reasonPhrase = arguments[1];
     headerIndex = 2;
   } else {
@@ -188,13 +188,13 @@ ServerResponse.prototype.writeHead = function(statusCode) {
     // Slow-case: when progressive API and header fields are passed.
     headers = this._renderHeaders();
 
-    if (Array.isArray(obj)) {
+    if (IS_ARRAY(obj)) {
       // handle array case
       // TODO: remove when array is no longer accepted
       var field;
       for (var i = 0, len = obj.length; i < len; ++i) {
         field = obj[i][0];
-        if (headers[field] !== undefined) {
+        if (!IS_UNDEFINED(headers[field])) {
           obj.push([field, headers[field]]);
         }
       }
@@ -332,7 +332,7 @@ function connectionListener(socket) {
   parser.incoming = null;
 
   // Propagate headers limit from server instance to parser
-  if (typeof this.maxHeadersCount === 'number') {
+  if (IS_NUMBER(this.maxHeadersCount)) {
     parser.maxHeaderPairs = this.maxHeadersCount << 1;
   } else {
     // Set default value because parser may be reused from FreeList
@@ -442,7 +442,7 @@ function connectionListener(socket) {
       }
     });
 
-    if (req.headers.expect !== undefined &&
+    if (!IS_UNDEFINED(req.headers.expect) &&
         (req.httpVersionMajor == 1 && req.httpVersionMinor == 1) &&
         continueExpression.test(req.headers['expect'])) {
       res._expect_continue = true;

lib/_stream_readable.js

@@ -117,7 +117,7 @@ function Readable(options) {
 Readable.prototype.push = function(chunk, encoding) {
   var state = this._readableState;
 
-  if (typeof chunk === 'string' && !state.objectMode) {
+  if (IS_STRING(chunk) && !state.objectMode) {
     encoding = encoding || state.defaultEncoding;
     if (encoding !== state.encoding) {
       chunk = new Buffer(chunk, encoding);
@@ -138,7 +138,7 @@ function readableAddChunk(stream, state, chunk, encoding, addToFront) {
   var er = chunkInvalid(state, chunk);
   if (er) {
     stream.emit('error', er);
-  } else if (chunk === null || chunk === undefined) {
+  } else if (IS_NULL_OR_UNDEFINED(chunk)) {
     state.reading = false;
     if (!state.ended)
       onEofChunk(stream, state);
@@ -219,7 +219,7 @@ function howMuchToRead(n, state) {
   if (state.objectMode)
     return n === 0 ? 0 : 1;
 
-  if (isNaN(n) || n === null) {
+  if (isNaN(n) || IS_NULL(n)) {
     // only flow one buffer at a time
     if (state.flowing && state.buffer.length)
       return state.buffer[0].length;
@@ -256,7 +256,7 @@ Readable.prototype.read = function(n) {
   state.calledRead = true;
   var nOrig = n;
 
-  if (typeof n !== 'number' || n > 0)
+  if (!IS_NUMBER(n) || n > 0)
     state.emittedReadable = false;
 
   // if we're doing read(0) to trigger a readable event, but we
@@ -345,7 +345,7 @@ Readable.prototype.read = function(n) {
   else
     ret = null;
 
-  if (ret === null) {
+  if (IS_NULL(ret)) {
     state.needReadable = true;
     n = 0;
   }
@@ -363,17 +363,16 @@ Readable.prototype.read = function(n) {
   if (state.ended && !state.endEmitted && state.length === 0)
     endReadable(this);
 
-  if (ret !== null)
+  if (!IS_NULL(ret))
     this.emit('data', ret);
   return ret;
 };
 
 function chunkInvalid(state, chunk) {
   var er = null;
-  if (!Buffer.isBuffer(chunk) &&
-      'string' !== typeof chunk &&
-      chunk !== null &&
-      chunk !== undefined &&
+  if (!IS_BUFFER(chunk) &&
+      !IS_STRING(chunk) &&
+      !IS_NULL_OR_UNDEFINED(chunk) &&
       !state.objectMode &&
       !er) {
     er = new TypeError('Invalid non-string/buffer chunk');
@@ -775,8 +774,7 @@ Readable.prototype.wrap = function(stream) {
   // proxy all the other methods.
   // important when wrapping filters and duplexes.
   for (var i in stream) {
-    if (typeof stream[i] === 'function' &&
-        typeof this[i] === 'undefined') {
+    if (IS_FUNCTION(stream[i]) && IS_UNDEFINED(this[i])) {
       this[i] = function(method) { return function() {
         return stream[method].apply(stream, arguments);
       }}(i);

lib/_stream_transform.js

@@ -92,7 +92,7 @@ function afterTransform(stream, er, data) {
   ts.writechunk = null;
   ts.writecb = null;
 
-  if (data !== null && data !== undefined)
+  if (!IS_NULL_OR_UNDEFINED(data))
     stream.push(data);
 
   if (cb)
@@ -126,7 +126,7 @@ function Transform(options) {
   this._readableState.sync = false;
 
   this.once('prefinish', function() {
-    if ('function' === typeof this._flush)
+    if (IS_FUNCTION(this._flush))
       this._flush(function(er) {
         done(stream, er);
       });
@@ -174,7 +174,7 @@ Transform.prototype._write = function(chunk, encoding, cb) {
 Transform.prototype._read = function(n) {
   var ts = this._transformState;
 
-  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+  if (!IS_NULL(ts.writechunk) && ts.writecb && !ts.transforming) {
     ts.transforming = true;
     this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
   } else {