Infer type for variable declarations and class properties

This infers the type from Flow type annotations for variable
declarations and class properties.

This also moves the logic for setting the `type` for typedefs
to the same type inferrer.

Author: arv

index.js

@@ -20,7 +20,7 @@ var fs = require('fs'),
   inferMembership = require('./lib/infer/membership'),
   inferReturn = require('./lib/infer/return'),
   inferAccess = require('./lib/infer/access'),
-  inferTypedefType = require('./lib/infer/typedef_type'),
+  inferType = require('./lib/infer/type'),
   formatLint = require('./lib/lint').formatLint,
   garbageCollect = require('./lib/garbage_collect'),
   lintComments = require('./lib/lint').lintComments,
@@ -175,7 +175,7 @@ function buildSync(indexes, options) {
     inferProperties(),
     inferReturn(),
     inferMembership(),
-    inferTypedefType(),
+    inferType(),
     nest,
     options.github && github,
     garbageCollect);
@@ -245,7 +245,7 @@ function lint(indexes, options, callback) {
     inferProperties(),
     inferReturn(),
     inferMembership(),
-    inferTypedefType(),
+    inferType(),
     nest);
 
   return expandInputs(indexes, options, function (error, inputs) {

lib/infer/type.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var finders = require('./finders'),
+  shouldSkipInference = require('./should_skip_inference'),
+  flowDoctrine = require('../flow_doctrine'),
+  t = require('babel-types');
+
+/**
+ * Infers type tags by using Flow type annotations
+ *
+ * @name inferType
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with type tag inferred
+ */
+module.exports = function () {
+  return shouldSkipInference(function inferType(comment) {
+    if (comment.type) {
+      return comment;
+    }
+
+    var n = finders.findTarget(comment.context.ast);
+    if (!n) {
+      return comment;
+    }
+
+    var type;
+    switch (n.type) {
+    case 'VariableDeclarator':
+      type = n.id.typeAnnotation;
+      break;
+    case 'ClassProperty':
+      type = n.typeAnnotation;
+      break;
+    case 'TypeAlias':
+      type = n.right;
+      break;
+    }
+    if (type) {
+      if (t.isTypeAnnotation(type)) {
+        type = type.typeAnnotation;
+      }
+      comment.type = flowDoctrine(type);
+    }
+    return comment;
+  });
+};

lib/infer/typedef_type.js

@@ -3,7 +3,7 @@
 var test = require('tap').test,
   parse = require('../../../lib/parsers/javascript'),
   inferKind = require('../../../lib/infer/kind')(),
-  inferTypedefType = require('../../../lib/infer/typedef_type')();
+  inferType = require('../../../lib/infer/type')();
 
 function toComment(code) {
   return parse({
@@ -12,10 +12,10 @@ function toComment(code) {
 }
 
 function evaluate(code) {
-  return inferTypedefType(inferKind(toComment(code)));
+  return inferType(inferKind(toComment(code)));
 }
 
-test('inferTypedefType', function (t) {
+test('inferType', function (t) {
   t.deepEqual(evaluate(
     '/** @typedef {T} V */'
   ).type, {
@@ -64,6 +64,48 @@ test('inferTypedefType', function (t) {
     type: 'TypeApplication'
   });
 
+  t.deepEqual(evaluate(
+    '/** */' +
+    'var x: number'
+  ).type, {
+    name: 'number',
+    type: 'NameExpression'
+  });
+
+  t.deepEqual(evaluate(
+    '/** */' +
+    'let x: number'
+  ).type, {
+    name: 'number',
+    type: 'NameExpression'
+  });
+
+  t.deepEqual(evaluate(
+    '/** */' +
+    'const x: number = 42;'
+  ).type, {
+    name: 'number',
+    type: 'NameExpression'
+  });
+
+  t.deepEqual(evaluate(
+    'let x,' +
+    '/** */' +
+    'y: number'
+  ).type, {
+    name: 'number',
+    type: 'NameExpression'
+  });
+
+  t.deepEqual(evaluate(
+    'class C {' +
+    '/** */' +
+    'x: number;' +
+    '}'
+  ).type, {
+    name: 'number',
+    type: 'NameExpression'
+  });
 
   t.end();
 });