visit flow types - fixes #108

acorn-to-esprima.js

@@ -117,7 +117,7 @@ function convertTemplateType(tokens) {
   // create Template token
   function replaceWithTemplateType(start, end) {
     var templateToken = {
-      type: 'Template',
+      type: "Template",
       value: createTemplateValue(start, end),
       range: [tokens[start].start, tokens[end].end],
       loc: {
@@ -183,16 +183,35 @@ var astTransformVisitor = {
       delete node.argument;
     }
 
-    if (this.isTypeCastExpression()) {
-      return node.expression;
+    if (this.isRestElement()) {
+      return node.argument;
     }
 
-    if (this.isFlow()) {
-      return this.remove();
+    // prevent "no-undef"
+    // for "Component" in: "let x: React.Component"
+    if (this.isQualifiedTypeIdentifier()) {
+      delete node.id;
+    }
+    // for "b" in: "var a: { b: Foo }"
+    if (this.isObjectTypeProperty()) {
+      delete node.key;
+    }
+    // for "indexer" in: "var a: {[indexer: string]: number}"
+    if (this.isObjectTypeIndexer()) {
+      delete node.id;
+    }
+    // for "param" in: "var a: { func(param: Foo): Bar };"
+    if (this.isFunctionTypeParam()) {
+      delete node.name;
     }
 
-    if (this.isRestElement()) {
-      return node.argument;
+    // flow
+
+    if (this.isDeclareModule() ||
+        this.isDeclareClass() ||
+        this.isDeclareFunction() ||
+        this.isDeclareVariable()) {
+      return this.remove();
     }
 
     // modules

index.js

@@ -1,6 +1,7 @@
 var acornToEsprima = require("./acorn-to-esprima");
 var traverse       = require("babel-core").traverse;
 var assign         = require("lodash.assign");
+var pick           = require("lodash.pick");
 var Module         = require("module");
 var parse          = require("babel-core").parse;
 var path           = require("path");
@@ -46,12 +47,7 @@ function monkeypatch() {
   escope.analyze = function (ast, opts) {
     opts.ecmaVersion = 6;
     opts.sourceType = "module";
-    // Don't visit TypeAlias when analyzing scope, but retain them for other
-    // eslint rules.
-    var TypeAliasKeys = estraverse.VisitorKeys.TypeAlias;
-    estraverse.VisitorKeys.TypeAlias = [];
     var results = analyze.call(this, ast, opts);
-    estraverse.VisitorKeys.TypeAlias = TypeAliasKeys;
     return results;
   };
 
@@ -62,8 +58,18 @@ function monkeypatch() {
   } catch (err) {
     throw new ReferenceError("couldn't resolve escope/referencer");
   }
+  var referencerMod = createModule(referencerLoc);
   var referencer = require(referencerLoc);
 
+  // reference Definition
+  var definitionLoc;
+  try {
+    var definitionLoc = Module._resolveFilename("./definition", referencerMod);
+  } catch (err) {
+    throw new ReferenceError("couldn't resolve escope/definition");
+  }
+  var Definition = require(definitionLoc).Definition;
+
   // if there are decotators, then visit each
   function visitDecorators(node) {
     if (!node.decorators) {
@@ -76,18 +82,182 @@ function monkeypatch() {
     }
   }
 
-  // monkeypatch referencer methods to visit decorators
+  // iterate through part of t.VISITOR_KEYS
+  var visitorKeysMap = pick(t.VISITOR_KEYS, function(k) {
+    return t.FLIPPED_ALIAS_KEYS.Flow.concat([
+      "ArrayPattern",
+      "ClassDeclaration",
+      "ClassExpression",
+      "FunctionDeclaration",
+      "FunctionExpression",
+      "Identifier",
+      "ObjectPattern",
+      "RestElement"
+    ]).indexOf(k) === -1;
+  });
+
+  var propertyTypes = {
+    // loops
+    callProperties: { type: "loop", values: ["value"] },
+    indexers: { type: "loop", values: ["key", "value"] },
+    properties: { type: "loop", values: ["value"] },
+    types: { type: "loop" },
+    params: { type: "loop" },
+    // single property
+    argument: { type: "single" },
+    elementType: { type: "single" },
+    qualification: { type: "single" },
+    rest: { type: "single" },
+    returnType: { type: "single" },
+    // others
+    typeAnnotation: { type: "typeAnnotation" },
+    typeParameters: { type: "typeParameters" },
+    id: { type: "id" }
+  };
+
+  function visitTypeAnnotation(node) {
+    // get property to check (params, id, etc...)
+    var visitorValues = visitorKeysMap[node.type];
+    if (!visitorValues) {
+      return;
+    }
+
+    // can have multiple properties
+    for (var i = 0; i < visitorValues.length; i++) {
+      var visitorValue = visitorValues[i];
+      var propertyType = propertyTypes[visitorValue];
+      var nodeProperty = node[visitorValue];
+      // check if property or type is defined
+      if (propertyType == null || nodeProperty == null) {
+        continue;
+      }
+      if (propertyType.type === "loop") {
+        for (var j = 0; j < nodeProperty.length; j++) {
+          if (Array.isArray(propertyType.values)) {
+            for (var k = 0; k < propertyType.values.length; k++) {
+              checkIdentifierOrVisit.call(this, nodeProperty[j][propertyType.values[k]]);
+            }
+          } else {
+            checkIdentifierOrVisit.call(this, nodeProperty[j]);
+          }
+        }
+      } else if (propertyType.type === "single") {
+        checkIdentifierOrVisit.call(this, nodeProperty);
+      } else if (propertyType.type === "typeAnnotation") {
+        visitTypeAnnotation.call(this, node.typeAnnotation);
+      } else if (propertyType.type === "typeParameters") {
+        for (var j = 0; j < node.typeParameters.params.length; j++) {
+          checkIdentifierOrVisit.call(this, node.typeParameters.params[j]);
+        }
+      } else if (propertyType.type === "id") {
+        if (node.id.type === "Identifier") {
+          checkIdentifierOrVisit.call(this, node.id);
+        } else {
+          visitTypeAnnotation.call(this, node.id);
+        }
+      }
+    }
+  }
+
+  function checkIdentifierOrVisit(node) {
+    if (node.typeAnnotation) {
+      visitTypeAnnotation.call(this, node.typeAnnotation);
+    } else if (node.type === "Identifier") {
+      this.visit(node);
+    } else {
+      visitTypeAnnotation.call(this, node);
+    }
+  }
+
+  // visit decorators that are in: ClassDeclaration / ClassExpression
   var visitClass = referencer.prototype.visitClass;
-  referencer.prototype.visitClass = function (node) {
-    // visit decorators that are in: Class Declaration
+  referencer.prototype.visitClass = function(node) {
     visitDecorators.call(this, node);
+    // visit class
+    if (node.id) {
+      this.visit(node.id);
+    }
+    // visit flow type: ClassImplements
+    if (node.implements) {
+      for (var i = 0; i < node.implements.length; i++) {
+        checkIdentifierOrVisit.call(this, node.implements[i]);
+      }
+    }
+    if (node.typeParameters) {
+      for (var i = 0; i < node.typeParameters.params.length; i++) {
+        checkIdentifierOrVisit.call(this, node.typeParameters.params[i]);
+      }
+    }
+    if (node.superTypeParameters) {
+      for (var i = 0; i < node.superTypeParameters.params.length; i++) {
+        checkIdentifierOrVisit.call(this, node.superTypeParameters.params[i]);
+      }
+    }
     visitClass.call(this, node);
-  }
+  };
+    // visit decorators that are in: Property / MethodDefinition
   var visitProperty = referencer.prototype.visitProperty;
-  referencer.prototype.visitProperty = function (node) {
-    // visit decorators that are in: Visit Property / MethodDefinition
+  referencer.prototype.visitProperty = function(node) {
+    if (node.value.type === 'TypeCastExpression') {
+      visitTypeAnnotation.call(this, node.value);
+    }
     visitDecorators.call(this, node);
     visitProperty.call(this, node);
+  };
+
+  // visit flow type in FunctionDeclaration, FunctionExpression, ArrowFunctionExpression
+  var visitFunction = referencer.prototype.visitFunction;
+  referencer.prototype.visitFunction = function(node) {
+    if (node.returnType) {
+      checkIdentifierOrVisit.call(this, node.returnType);
+    }
+    // only visit if function parameters have types
+    if (node.params) {
+      for (var i = 0; i < node.params.length; i++) {
+        if (node.params[i].typeAnnotation) {
+          checkIdentifierOrVisit.call(this, node.params[i]);
+        }
+      }
+    }
+    if (node.typeParameters) {
+      for (var i = 0; i < node.typeParameters.params.length; i++) {
+        checkIdentifierOrVisit.call(this, node.typeParameters.params[i]);
+      }
+    }
+    visitFunction.call(this, node);
+  };
+
+  // visit flow type in VariableDeclaration
+  var variableDeclaration = referencer.prototype.VariableDeclaration;
+  referencer.prototype.VariableDeclaration = function(node) {
+    if (node.declarations) {
+      for (var i = 0; i < node.declarations.length; i++) {
+        checkIdentifierOrVisit.call(this, node.declarations[i].id);
+      }
+    }
+    variableDeclaration.call(this, node);
+  };
+
+  referencer.prototype.TypeAlias = function(node) {
+    this.currentScope().__define(
+      node.id,
+      new Definition(
+          "Variable",
+          node.id,
+          node,
+          null,
+          null,
+          null
+      )
+    );
+    if (node.right) {
+      visitTypeAnnotation.call(this, node.right);
+    }
+    if (node.typeParameters) {
+      for (var i = 0; i < node.typeParameters.params.length; i++) {
+        checkIdentifierOrVisit.call(this, node.typeParameters.params[i]);
+      }
+    }
   }
 }
 

package.json

@@ -9,7 +9,8 @@
   },
   "dependencies": {
     "babel-core": "^5.1.8",
-    "lodash.assign": "^3.0.0"
+    "lodash.assign": "^3.0.0",
+    "lodash.pick": "^3.1.0"
   },
   "scripts": {
     "test": "mocha"