Try to resolve MemberExpression to initialization value

This change enables `resolveToValue` to handle `MemberExpression`s.
When it encounters a MemberExpression it tries to find the definition
of the root object of that expression and then tries to resolve the
property inside that ObjectExpression.
If it cannot resolve the root object to an ObjectExpression
(ie. because it was declared externally), it will stop and return the
path to the original MemberExpression - or if the original expression
did resolve to an Object but the properties inside that object were
Identifier which could not resolve to an ObjectExpression it returns
that MemberExpression instead.

Author: ZauberNerd

src/utils/__tests__/resolveToValue-test.js

@@ -143,4 +143,62 @@ describe('resolveToValue', () => {
 
   });
 
+  describe('MemberExpression', () => {
+
+    it('resolves a MemberExpression to it\'s init value', () => {
+      var path = parse([
+        'var foo = { bar: 1 };',
+        'foo.bar;',
+      ].join('\n'));
+
+      expect(resolveToValue(path).node).toEqualASTNode(builders.literal(1));
+    });
+
+    it('resolves a MemberExpression in the scope chain', () => {
+      var path = parse([
+        'var foo = 1;',
+        'var bar = { baz: foo };',
+        'bar.baz;',
+      ].join('\n'));
+
+      expect(resolveToValue(path).node).toEqualASTNode(builders.literal(1));
+    });
+
+    it('resolves a nested MemberExpression in the scope chain', () => {
+      var path = parse([
+        'var foo = { bar: 1 };',
+        'var bar = { baz: foo.bar };',
+        'bar.baz;',
+      ].join('\n'));
+
+      expect(resolveToValue(path).node).toEqualASTNode(builders.literal(1));
+    });
+
+    it('returns the last resolvable MemberExpression', () => {
+      var path = parse([
+        'import foo from "bar";',
+        'var bar = { baz: foo.bar };',
+        'bar.baz;',
+      ].join('\n'));
+
+      expect(resolveToValue(path).node).toEqualASTNode(
+        builders.memberExpression(
+          builders.identifier('foo'),
+          builders.identifier('bar')
+        )
+      );
+    });
+
+    it('returns the path itself if it can not resolve it any further', () => {
+      var path = parse([
+        'var foo = {};',
+        'foo.bar = 1;',
+        'foo.bar;',
+      ].join('\n'));
+
+      expect(resolveToValue(path).node).toEqualASTNode(path.node);
+    });
+
+  });
+
 });

src/utils/resolveToValue.js

@@ -11,6 +11,9 @@
  */
 
 import recast from 'recast';
+import getMemberExpressionRoot from './getMemberExpressionRoot';
+import getPropertyValuePath from './getPropertyValuePath';
+import {Array as toArray} from './expressionTo';
 import {traverseShallow} from './traverse';
 
 var {
@@ -105,6 +108,7 @@ function findLastAssignedValue(scope, name) {
 /**
  * If the path is an identifier, it is resolved in the scope chain.
  * If it is an assignment expression, it resolves to the right hand side.
+ * If it is a member expression it is resolved to it's initialization value.
  *
  * Else the path itself is returned.
  */
@@ -114,6 +118,18 @@ export default function resolveToValue(path: NodePath): NodePath {
      if (node.init) {
        return resolveToValue(path.get('init'));
      }
+  } else if (types.MemberExpression.check(node)) {
+    const resolved = resolveToValue(getMemberExpressionRoot(path));
+    if (types.ObjectExpression.check(resolved.node)) {
+      const memberParts = toArray(path).slice(1);
+      const init = memberParts.reduce((propertyPath, propertyName) => {
+        propertyPath = resolveToValue(propertyPath);
+        return types.ObjectExpression.check(propertyPath.node) ?
+          getPropertyValuePath(propertyPath, propertyName) :
+          null;
+      }, resolved);
+      return init ? resolveToValue(init) : path;
+    }
   } else if (
     types.ImportDefaultSpecifier.check(node) ||
     types.ImportNamespaceSpecifier.check(node) ||