...

core.js

@@ -2,9 +2,13 @@ var utils = require('./utils'),
     scope = require('./scope'),
     _global = require('./core/global'),
     _array = require('./core/array'),
+    _console = require('./core/console'),
     _date = require('./core/date'),
     _function = require('./core/function'),
     _json = require('./core/json'),
+    _object = require('./core/object'),
+    _promise = require('./core/promise'),
+    _regexp = require('./core/regexp'),
     _string = require('./core/string'),
     _math = require('./core/math'),
     _number = require('./core/number');
@@ -13,13 +17,67 @@ module.exports = {
 
   evaluate: function(node) {
     var handler = undefined;
+    var get = function(obj, name) {
+      if (obj.hasOwnProperty(name)) { return obj[name]; }
+      return undefined;
+    };
 
-    if (node.property) {
-      var method = node.property.name;
-      handler = _array[method] || _date[method] || _function[method] || _json[method] || _string[method] || _math[method] || _number[method];
+    if (utils.isType(node.object, 'MemberExpression')) {
+      var newNode = module.exports.evaluate(node.object);
+      if (newNode !== node.object) {
+        node.object = newNode;
+        newNode.parent = node;
+      }
+    }
+
+    // Handle Array.prototype.slice.call(...)
+    if (utils.isId(node.property, 'call') &&
+        utils.isType(node.object, 'MemberExpression') &&
+        utils.isType(node.object.object, 'MemberExpression') &&
+        utils.isId(node.object.object.object, /^(Array)$/) &&
+        utils.isId(node.object.object.property, 'prototype')) {
+      var type = node.object.object.object.name;
+      var method = node.object.property.name;
+      var longName = type + '#' + method;
+      handler = get(_array, longName);
+      if (handler) {
+        // move the 1st argument to be the reciever
+        var args = utils.clone(node.parent.arguments);
+        var thisArg = args.shift();
+        node = {
+          type: 'CallExpression',
+          callee: {
+            type: 'MemberExpression',
+            object: thisArg,
+            property: node.object.property,
+            isCallee: true,
+          },
+          arguments: args,
+          parent: node.parent,
+        };
+        node.parent.arguments = false;
+      }
+    }
 
+    if (utils.isType(node.object, 'Literal')) {
+      var method = node.property.name;
+      if (!(utils.isType(node.parent, 'CallExpression') && node === node.parent.callee)) {
+        method = '.' + method;
+      }
+      handler = node.object.regex ? get(_regexp, method) : get(_string, method);
+    } else if (utils.isId(node.object, /^(Array|Date|JSON|Math|Object|Promise|console)$/)) {
+      var longName = node.object.name + '.' + node.property.name;
+      handler = get(_array, longName) || get(_date, longName) || get(_json, longName) || get(_math, longName) || get(_object, longName) || get(_promise, longName) || get(_console, longName);
+    } else if (utils.isType(node.property, 'Identifier')) {
+      var method = node.property.name;
+      if (!(utils.isType(node.parent, 'CallExpression') && node === node.parent.callee)) {
+        method = '.' + method;
+      }
+      // _array should be before _string here so we pick up the correct
+      // multitype version of #length and #indexOf
+      handler = get(_array, method) || get(_date, method) || get(_function, method) || get(_json, method) || get(_regexp, method) || get(_string, method) || get(_math, method) || get(_number, method);
     } else if (node.callee) {
-      handler = _global[node.callee.name];
+      handler = get(_global, node.callee.name);
     }
 
     if (handler) {

core/array.js

@@ -3,23 +3,39 @@ var utils = require('../utils'),
     string = require('./string');
 
 module.exports = {
+  'Array.isArray': function(node) {
+    var args = utils.clone(node.parent.arguments);
+    node.parent.arguments = false;
+    return {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'is_array',
+      },
+      arguments: args,
+    };
+  },
 
   unshift: function(node) {
     var args = utils.clone(node.parent.arguments);
     node.parent.arguments = false;
+    if (args.length === 1) { args[0].suppressParens = true; }
+    args.unshift(node.parent.callee.object);
+    scope.get(node).getDefinition(node.parent.callee.object);
 
     return {
       type: 'CallExpression',
       callee: {
         type: 'Identifier',
         name: 'array_unshift',
       },
-      arguments: [node.parent.callee.object, args[0]]
+      arguments: args,
     };
   },
 
   shift: function(node) {
     node.parent.arguments = false;
+    scope.get(node).getDefinition(node.parent.callee.object);
     return {
       type: 'CallExpression',
       callee: {
@@ -31,6 +47,8 @@ module.exports = {
   },
 
   reverse: function(node) {
+    node.parent.arguments = false;
+    scope.get(node).getDefinition(node.parent.callee.object);
     return {
       type: 'CallExpression',
       callee: {
@@ -44,18 +62,23 @@ module.exports = {
   push: function(node) {
     var args = utils.clone(node.parent.arguments);
     node.parent.arguments = false;
+    scope.get(node).getDefinition(node.parent.callee.object);
+    if (args.length === 1) { args[0].suppressParens = true; }
+    args.unshift(node.parent.callee.object);
 
     return {
       type: 'CallExpression',
       callee: {
         type: 'Identifier',
         name: 'array_push',
       },
-      arguments: [ node.parent.callee.object, args[0] ]
+      arguments: args,
     };
   },
 
   pop: function(node) {
+    node.parent.arguments = false;
+    scope.get(node).getDefinition(node.parent.callee.object);
     return {
       type: 'CallExpression',
       callee: {
@@ -69,22 +92,89 @@ module.exports = {
   join: function(node) {
     var args = utils.clone(node.parent.arguments);
     node.parent.arguments = false;
+    scope.get(node).getDefinition(node.parent.callee.object);
+    args[0].suppressParens = true;
 
     return {
       type: 'CallExpression',
       callee: {
         type: 'Identifier',
-        name: 'join',
+        name: 'implode',
       },
       arguments: [ args[0], node.parent.callee.object ]
     };
   },
 
-  splice: function(node) {
+  map: function(node) {
     var args = utils.clone(node.parent.arguments);
+    node.parent.arguments = false;
+    scope.get(node).getDefinition(node.parent.callee.object);
+    args[0].suppressParens = true;
+
+    return {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'array_map',
+      },
+      arguments: [ node.parent.callee.object, args[0] ]
+    };
+  },
+
+  reduce: function(node) {
+    var args = utils.clone(node.parent.arguments);
+    node.parent.arguments = false;
+    scope.get(node).getDefinition(node.parent.callee.object);
+    if (args.length === 1) {
+      args[0].suppressParens = true;
+    }
     args.unshift(node.parent.callee.object);
 
+    return {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'array_reduce',
+      },
+      arguments: args,
+    };
+  },
+
+  slice: function(node) {
+    var args = utils.clone(node.parent.arguments);
+    if (node.parent.arguments.length > 1) {
+      // Second argument to array_slice is very different from Array#slice
+      // unless it is negative.
+      if (args[1].type === 'UnaryExpression' && args[1].operator==='-' &&
+          args[1].argument.type==='Literal') {
+        /* this is okay */
+      } else {
+        args[1].trailingComments = [{ type: 'Block', value: 'CHECK THIS'}];
+      }
+    } else if (node.parent.arguments.length === 0) {
+        args.unshift({ type: 'Literal', value: 0, raw: '0' });
+    } else {
+      args[0].suppressParens = true;
+    }
+    args.unshift(node.parent.callee.object);
+    node.parent.arguments = false;
+    scope.get(node).getDefinition(node.parent.callee.object);
+
+    return {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'array_slice',
+      },
+      arguments: args
+    };
+  },
+
+  splice: function(node) {
+    var args = utils.clone(node.parent.arguments);
+    args.unshift(node.parent.callee.object);
     node.parent.arguments = false;
+    scope.get(node).getDefinition(node.parent.callee.object);
 
     return {
       type: 'CallExpression',
@@ -101,6 +191,8 @@ module.exports = {
         args = utils.clone(node.parent.arguments);
 
     node.parent.arguments = false;
+    scope.get(node).getDefinition(node.parent.callee.object);
+    args[0].suppressParens = true;
 
     var targetDefinition = scope.get(node).getDefinition(node.parent.callee.object);
     if (utils.isString(node.parent.callee.object) || (targetDefinition && targetDefinition.dataType == "String")) {
@@ -122,15 +214,15 @@ module.exports = {
 
   },
 
-  length: function(node) {
+  '.length': function(node) {
     var method,
         object = (node.parent.callee && node.parent.callee.object) || node.object,
         isString = utils.isString(object);
 
     var targetDefinition = scope.get(node).getDefinition(object);
 
     if (!isString && targetDefinition) {
-      if (targetDefinition.type == "Identifier" && targetDefinition.name == "string") {
+      if (utils.isId(targetDefinition, "string")) {
         isString = true;
       } else if (targetDefinition.dataType == "String") {
         isString = true;
@@ -155,4 +247,6 @@ module.exports = {
     };
   },
 
-}
+};
+
+utils.coreAddHash(module.exports, 'Array');

core/console.js

@@ -0,0 +1,19 @@
+var utils = require('../utils');
+
+module.exports = {
+  'console.assert': function(node) {
+    return {
+      type: 'MemberExpression',
+      object: {
+        type: 'Identifier',
+        name: 'Assert',
+      },
+      property: {
+        type: 'Identifier',
+        name: 'invariant',
+      }
+    };
+  }
+};
+
+utils.coreAddHash(module.exports, 'console');

core/date.js

@@ -1,27 +1,21 @@
 var utils = require('../utils');
 
-function isDateClass(node) {
-  return node.object.name == "Date";
-}
-
 module.exports = {
 
-  now: function(node) {
-    if (isDateClass(node)) {
-      var args = utils.clone(node.parent.arguments);
-      node.parent.arguments = false;
+  'Date.now': function(node) {
+    var args = utils.clone(node.parent.arguments);
+    node.parent.arguments = false;
 
-      return {
-        type: 'CallExpression',
-        callee: {
-          type: 'Identifier',
-          name: 'time',
-        },
-        arguments: []
-      };
-    } else {
-      return node;
-    }
+    return {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'time',
+      },
+      arguments: []
+    };
   }
 
-}
+};
+
+utils.coreAddHash(module.exports, 'Date');

core/function.js

@@ -1,3 +1,5 @@
+var utils = require('../utils');
+
 function apply(node, isCall) {
   var method, arguments = [];
 
@@ -25,10 +27,14 @@ function apply(node, isCall) {
   } else {
     // .apply use call_user_func_array
     method = "call_user_func_array";
-    arguments.push({
-      type: "ArrayExpression",
-      elements: (node.parent.arguments[0] || {elements:[]}).elements
-    });
+    if (node.parent.arguments[0]) {
+      arguments.push(node.parent.arguments[0]);
+    } else {
+      arguments.push({
+        type: "ArrayExpression",
+        elements: [],
+      });
+    }
   }
 
   node.parent.arguments = false;
@@ -53,4 +59,6 @@ module.exports = {
     return apply(node, false)
   },
 
-}
+};
+
+utils.coreAddHash(module.exports, 'Function');

core/global.js

@@ -14,4 +14,4 @@ module.exports = {
       return newNode;
   }
 
-}
+};