Add support for destructuring resolution.

Until now, the propTypeHandler would not be able to recognize that

```
var {PropTypes} = require('react');
```

refers to the React module, and thus not recognize the types properly.

This extends `resolveToValue` to return a MemberExpression if the path
resolves to an ObjectPattern. I.e. `bar` in

```
var {foo: {bar}} = baz;
bar;
```

would resolve to a path representing `baz.foo.bar`.

Author: fkling

src/handlers/__tests__/propTypeHandler-test.js

@@ -60,6 +60,7 @@ describe('propTypeHandler', () => {
       '  propTypes: {',
       '    foo: PropTypes.bool,',
       '    bar: require("react").PropTypes.bool,',
+      '    baz: OtherPropTypes.bool,',
       '  }',
       '})',
     ].join('\n'));
@@ -74,6 +75,10 @@ describe('propTypeHandler', () => {
       bar: {
         type: {},
         required: false
+      },
+      baz: {
+        type: {},
+        required: false
       }
     });
   });

src/utils/__tests__/resolveToModule-test.js

@@ -0,0 +1,62 @@
+/*
+ *  Copyright (c) 2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ *
+ */
+
+/*global jest, describe, beforeEach, it, expect*/
+
+"use strict";
+
+jest.autoMockOff();
+
+describe('resolveToModule', () => {
+  var utils;
+  var resolveToModule;
+
+  function parse(src) {
+    var root = utils.parse(src);
+    return root.get('body', root.node.body.length - 1, 'expression');
+  }
+
+  beforeEach(() => {
+    resolveToModule = require('../resolveToModule');
+    utils = require('../../../tests/utils');
+  });
+
+  it('resolves identifiers', () => {
+    var path = parse([
+      'var foo = require("Foo");',
+      'foo;'
+    ].join('\n'));
+    expect(resolveToModule(path)).toBe('Foo');
+  });
+
+  it('resolves function calls', () => {
+    var path = parse([
+      'var foo = require("Foo");',
+      'foo();'
+    ].join('\n'));
+    expect(resolveToModule(path)).toBe('Foo');
+  });
+
+  it('resolves member expressions', () => {
+    var path = parse([
+      'var foo = require("Foo");',
+      'foo.bar().baz;'
+    ].join('\n'));
+    expect(resolveToModule(path)).toBe('Foo');
+  });
+
+  it('understands destructuring', () => {
+    var path = parse([
+      'var {foo} = require("Foo");',
+      'foo;'
+    ].join('\n'));
+    expect(resolveToModule(path)).toBe('Foo');
+  });
+});

src/utils/__tests__/resolveToValue-test.js

@@ -0,0 +1,89 @@
+/*
+ *  Copyright (c) 2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ *
+ */
+
+/*global jest, describe, beforeEach, it, expect*/
+
+"use strict";
+
+jest.autoMockOff();
+
+describe('resolveToValue', () => {
+  var astNodesAreEquivalent;
+  var builders;
+  var utils;
+  var resolveToValue;
+
+  function parse(src) {
+    var root = utils.parse(src);
+    return root.get('body', root.node.body.length - 1, 'expression');
+  }
+
+  beforeEach(() => {
+    var recast = require('recast');
+    astNodesAreEquivalent = recast.types.astNodesAreEquivalent;
+    builders = recast.types.builders;
+    resolveToValue = require('../resolveToValue');
+    utils = require('../../../tests/utils');
+  });
+
+  it('resolves simple variable declarations', () => {
+    var path = parse([
+      'var foo  = 42;',
+      'foo;'
+    ].join('\n'));
+    expect(astNodesAreEquivalent(
+      resolveToValue(path).node,
+      builders.literal(42)
+    )).toBe(true);
+  });
+
+  it('resolves object destructuring', () => {
+    var path = parse([
+      'var {foo: {bar: baz}} = bar;',
+      'baz;'
+    ].join('\n'));
+
+    // Node should be equal to bar.foo.bar
+    expect(astNodesAreEquivalent(
+      resolveToValue(path).node,
+      builders.memberExpression(
+        builders.memberExpression(
+          builders.identifier('bar'),
+          builders.identifier('foo')
+        ),
+        builders.identifier('bar')
+      )
+    )).toBe(true);
+  });
+
+  it('handles SpreadProperties properly', () => {
+    var path = parse([
+      'var {foo: {bar}, ...baz} = bar;',
+      'baz;'
+    ].join('\n'));
+
+    expect(astNodesAreEquivalent(
+      resolveToValue(path).node,
+      path.node
+    )).toBe(true);
+  });
+
+  it('returns the original path if it cannot be resolved', () => {
+    var path = parse([
+      'function foo() {}',
+      'foo()'
+    ].join('\n'));
+
+    expect(astNodesAreEquivalent(
+      resolveToValue(path).node,
+      path.node
+    )).toBe(true);
+  });
+});

src/utils/resolveToValue.js

@@ -13,7 +13,33 @@
  */
 "use strict";
 
-var types = require('recast').types.namedTypes;
+var {
+  NodePath,
+  builders,
+  namedTypes: types
+} = require('recast').types;
+
+function buildMemberExpressionFromPattern(path: NodePath): ?Node {
+  var node = path.node;
+  if (types.Property.check(node)) {
+    var objPath = buildMemberExpressionFromPattern(path.parent);
+    if (objPath) {
+      return new NodePath(
+        builders.memberExpression(
+          objPath.node,
+          node.key,
+          types.Literal.check(node.key)
+        ),
+        objPath
+      );
+    }
+  } else if (types.ObjectPattern.check(node)) {
+    return buildMemberExpressionFromPattern(path.parent);
+  } else if (types.VariableDeclarator.check(node)) {
+    return path.get('init');
+  }
+  return null;
+}
 
 /**
  * If the path is an identifier, it is resolved in the scope chain.
@@ -32,11 +58,22 @@ function resolveToValue(path: NodePath): NodePath {
     if (scope) {
       var bindings = scope.getBindings()[node.name];
       if (bindings.length > 0) {
-        var parentPath = scope.getBindings()[node.name][0].parent;
+        var resultPath = scope.getBindings()[node.name][0];
+        var parentPath = resultPath.parent;
         if (types.VariableDeclarator.check(parentPath.node)) {
-          parentPath = parentPath.get('init');
+          resultPath = parentPath.get('init');
+        } else if (types.Property.check(parentPath.node)) {
+          // must be inside a pattern
+          var memberExpressionPath = buildMemberExpressionFromPattern(
+            parentPath
+          );
+          if (memberExpressionPath) {
+            return memberExpressionPath;
+          }
         }
-        return resolveToValue(parentPath);
+        return resultPath.node !== path.node ?
+          resolveToValue(resultPath) :
+          path;
       }
     }
   }

tests/utils.js

@@ -33,6 +33,7 @@ function parseWithTemplate(src, template) {
 var REACT_TEMPLATE = [
   'var React = require("React");',
   'var PropTypes = React.PropTypes;',
+  'var {PropTypes: OtherPropTypes} = require("React");',
   '%s;',
 ].join('\n');