Update recast to v0.7.0 and use the visitor API.

Author: eventualbuddha

lib/index.js

@@ -7,6 +7,7 @@ var recast = require('recast');
 var types = recast.types;
 var n = types.namedTypes;
 var b = types.builders;
+var PathVisitor = types.PathVisitor;
 
 var util = require('ast-util');
 
@@ -17,51 +18,104 @@ assert.ok(
 
 /**
  * Visits a node of an AST looking for arrow function expressions. This is
- * intended to be used with the ast-types `traverse()` function.
+ * intended to be used with the ast-types `visit()` function.
  *
- * @param {Object} node
- * @this {ast-types.Path}
+ * @constructor
+ * @extends PathVisitor
  */
-function visitNode(node) {
-  if (!n.ArrowFunctionExpression.check(node)) {
-    return;
-  }
+function ArrowFunctionExpressionVisitor() {
+  PathVisitor.call(this);
+}
+ArrowFunctionExpressionVisitor.prototype = Object.create(PathVisitor.prototype);
+ArrowFunctionExpressionVisitor.prototype.constructor = ArrowFunctionExpressionVisitor;
+
+/**
+ * Visits arrow function expressions and replaces them with normal functions.
+ *
+ * @param {types.NodePath} path
+ * @return {?Node}
+ */
+ArrowFunctionExpressionVisitor.prototype.visitArrowFunctionExpression = function(path) {
+  var node = path.node;
+
+  this.traverse(path);
+
+  // In the future, ArrowFunctionExpression and FunctionExpression nodes may
+  // get new fields (like .async) that we can't anticipate yet, so we simply
+  // switch the type and let all the other fields carry over.
+  node.type = 'FunctionExpression';
 
   if (node.expression) {
     node.expression = false;
     node.body = b.blockStatement([b.returnStatement(node.body)]);
   }
 
-  // In the future, ArrowFunctionExpression and FunctionExpression nodes
-  // may get new fields (like .async) that we can't anticipate yet, so we
-  // simply switch the type and let all the other fields carry over.
-  node.type = 'FunctionExpression';
+  if (node.hasThisExpression) {
+    return b.callExpression(
+      b.memberExpression(node, b.identifier('bind'), false),
+      [b.thisExpression()]
+    );
+  }
+};
 
-  var foundThisExpression = false;
-  var scope = this.scope.parent;
+/**
+ * Ensures that any arrow function directly containing `this` is appropriately
+ * marked as such.
+ *
+ * @param {types.NodePath} path
+ * @return {?Node}
+ */
+ArrowFunctionExpressionVisitor.prototype.visitThisExpression = function(path) {
+  var arrowFnPath = this.associatedArrowFunctionPath(path);
+  if (arrowFnPath) {
+    arrowFnPath.node.hasThisExpression = true;
+  }
+  this.traverse(path);
+};
 
-  types.traverse(node.body, function(child) {
-    // don't look inside non-arrow functions
-    if (n.Function.check(child) && !n.ArrowFunctionExpression.check(child)) {
-      return false;
-    }
+/**
+ * Ensures that `arguments` directly contained in arrow functions is hoisted.
+ *
+ * @param {types.NodePath} path
+ * @return {?Node}
+ */
+ArrowFunctionExpressionVisitor.prototype.visitIdentifier = function(path) {
+  var node = path.node;
 
-    if (n.ThisExpression.check(child)) {
-      foundThisExpression = true;
+  if (node.name === 'arguments' && util.isReference(path)) {
+    var functionScope = this.associatedFunctionScope(path);
+    if (functionScope) {
+      return util.sharedFor(functionScope, node.name);
     }
+  }
 
-    if (util.isReference(this) && child.name === 'arguments') {
-      this.replace(util.sharedFor(scope, 'arguments'));
-    }
-  });
+  this.traverse(path);
+};
 
-  if (foundThisExpression) {
-    this.replace(b.callExpression(
-      b.memberExpression(node, b.identifier('bind'), false),
-      [b.thisExpression()]
-    ));
+/**
+ * @private
+ * @param {types.NodePath} path
+ * @return {?types.NodePath} The arrow function directly `path`, if any.
+ */
+ArrowFunctionExpressionVisitor.prototype.associatedArrowFunctionPath = function(path) {
+  var scope = path.scope;
+  if (n.ArrowFunctionExpression.check(scope.path.node)) {
+    return scope.path;
   }
-}
+};
+
+/**
+ * @private
+ * @param {types.NodePath} path
+ * @return {?types.Scope} The nearest non-arrow function scope above `path`.
+ */
+ArrowFunctionExpressionVisitor.prototype.associatedFunctionScope = function(path) {
+  var scope = path.scope;
+  while (scope && n.ArrowFunctionExpression.check(scope.path.node)) {
+    scope = scope.parent;
+  }
+  return scope;
+};
 
 /**
  * Transform an Esprima AST generated from ES6 by replacing all
@@ -77,7 +131,7 @@ function visitNode(node) {
  * @return {Object}
  */
 function transform(ast) {
-  return types.traverse(ast, visitNode);
+  return types.visit(ast, new ArrowFunctionExpressionVisitor());
 }
 
 /**
@@ -87,6 +141,7 @@ function transform(ast) {
  *   compile('() => 42'); // 'function() { return 42; };'
  *
  * @param {string} source
+ * @param {object} mapOptions
  * @return {string}
  */
 function compile(source, mapOptions) {

package.json

@@ -14,7 +14,7 @@
   "dependencies": {
     "ast-util": "^0.4.1",
     "esprima-fb": "^5001.1.0-dev-harmony-fb",
-    "recast": "~0.5.12",
+    "recast": "^0.7.0",
     "through": "~2.3.4"
   },
   "devDependencies": {
@@ -25,4 +25,4 @@
   },
   "author": "Square, Inc.",
   "license": "Apache 2"
-}
+}