babel-schmooze-sprockets 0.1.2 → 0.1.3

data/node_modules/babel-core/node_modules/babel-traverse/lib/path/inference/inferer-reference.js

@@ -0,0 +1,225 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.default = function (node) {
+  if (!this.isReferenced()) return;
+
+  // check if a binding exists of this value and if so then return a union type of all
+  // possible types that the binding could be
+  var binding = this.scope.getBinding(node.name);
+  if (binding) {
+    if (binding.identifier.typeAnnotation) {
+      return binding.identifier.typeAnnotation;
+    } else {
+      return getTypeAnnotationBindingConstantViolations(this, node.name);
+    }
+  }
+
+  // built-in values
+  if (node.name === "undefined") {
+    return t.voidTypeAnnotation();
+  } else if (node.name === "NaN" || node.name === "Infinity") {
+    return t.numberTypeAnnotation();
+  } else if (node.name === "arguments") {
+    // todo
+  }
+};
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getTypeAnnotationBindingConstantViolations(path, name) {
+  var binding = path.scope.getBinding(name);
+
+  var types = [];
+  path.typeAnnotation = t.unionTypeAnnotation(types);
+
+  var functionConstantViolations = [];
+  var constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
+
+  var testType = getConditionalAnnotation(path, name);
+  if (testType) {
+    (function () {
+      var testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
+
+      // remove constant violations observed before the IfStatement
+      constantViolations = constantViolations.filter(function (path) {
+        return testConstantViolations.indexOf(path) < 0;
+      });
+
+      // clear current types and add in observed test type
+      types.push(testType.typeAnnotation);
+    })();
+  }
+
+  if (constantViolations.length) {
+    // pick one constant from each scope which will represent the last possible
+    // control flow path that it could've taken/been
+    /* This code is broken for the following problems:
+     * It thinks that assignments can only happen in scopes.
+     * What about conditionals, if statements without block,
+     * or guarded assignments.
+     * It also checks to see if one of the assignments is in the
+     * same scope and uses that as the only "violation". However,
+     * the binding is returned by `getConstantViolationsBefore` so we for
+     * sure always going to return that as the only "violation".
+    let rawConstantViolations = constantViolations.reverse();
+    let visitedScopes = [];
+    constantViolations = [];
+    for (let violation of (rawConstantViolations: Array<NodePath>)) {
+      let violationScope = violation.scope;
+      if (visitedScopes.indexOf(violationScope) >= 0) continue;
+       visitedScopes.push(violationScope);
+      constantViolations.push(violation);
+       if (violationScope === path.scope) {
+        constantViolations = [violation];
+        break;
+      }
+    }*/
+
+    // add back on function constant violations since we can't track calls
+    constantViolations = constantViolations.concat(functionConstantViolations);
+
+    // push on inferred types of violated paths
+    for (var _iterator = constantViolations, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      var violation = _ref;
+
+      types.push(violation.getTypeAnnotation());
+    }
+  }
+
+  if (types.length) {
+    return t.createUnionTypeAnnotation(types);
+  }
+}
+
+function getConstantViolationsBefore(binding, path, functions) {
+  var violations = binding.constantViolations.slice();
+  violations.unshift(binding.path);
+  return violations.filter(function (violation) {
+    violation = violation.resolve();
+    var status = violation._guessExecutionStatusRelativeTo(path);
+    if (functions && status === "function") functions.push(violation);
+    return status === "before";
+  });
+}
+
+function inferAnnotationFromBinaryExpression(name, path) {
+  var operator = path.node.operator;
+
+  var right = path.get("right").resolve();
+  var left = path.get("left").resolve();
+
+  var target = void 0;
+  if (left.isIdentifier({ name: name })) {
+    target = right;
+  } else if (right.isIdentifier({ name: name })) {
+    target = left;
+  }
+  if (target) {
+    if (operator === "===") {
+      return target.getTypeAnnotation();
+    } else if (t.BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+      return t.numberTypeAnnotation();
+    } else {
+      return;
+    }
+  } else {
+    if (operator !== "===") return;
+  }
+
+  //
+  var typeofPath = void 0;
+  var typePath = void 0;
+  if (left.isUnaryExpression({ operator: "typeof" })) {
+    typeofPath = left;
+    typePath = right;
+  } else if (right.isUnaryExpression({ operator: "typeof" })) {
+    typeofPath = right;
+    typePath = left;
+  }
+  if (!typePath && !typeofPath) return;
+
+  // ensure that the type path is a Literal
+  typePath = typePath.resolve();
+  if (!typePath.isLiteral()) return;
+
+  // and that it's a string so we can infer it
+  var typeValue = typePath.node.value;
+  if (typeof typeValue !== "string") return;
+
+  // and that the argument of the typeof path references us!
+  if (!typeofPath.get("argument").isIdentifier({ name: name })) return;
+
+  // turn type value into a type annotation
+  return t.createTypeAnnotationBasedOnTypeof(typePath.node.value);
+}
+
+function getParentConditionalPath(path) {
+  var parentPath = void 0;
+  while (parentPath = path.parentPath) {
+    if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
+      if (path.key === "test") {
+        return;
+      } else {
+        return parentPath;
+      }
+    } else {
+      path = parentPath;
+    }
+  }
+}
+
+function getConditionalAnnotation(path, name) {
+  var ifStatement = getParentConditionalPath(path);
+  if (!ifStatement) return;
+
+  var test = ifStatement.get("test");
+  var paths = [test];
+  var types = [];
+
+  do {
+    var _path = paths.shift().resolve();
+
+    if (_path.isLogicalExpression()) {
+      paths.push(_path.get("left"));
+      paths.push(_path.get("right"));
+    }
+
+    if (_path.isBinaryExpression()) {
+      var type = inferAnnotationFromBinaryExpression(name, _path);
+      if (type) types.push(type);
+    }
+  } while (paths.length);
+
+  if (types.length) {
+    return {
+      typeAnnotation: t.createUnionTypeAnnotation(types),
+      ifStatement: ifStatement
+    };
+  } else {
+    return getConditionalAnnotation(ifStatement, name);
+  }
+}
+module.exports = exports["default"];

data/node_modules/babel-core/node_modules/babel-traverse/lib/path/inference/inferers.js

@@ -0,0 +1,198 @@
+"use strict";
+
+exports.__esModule = true;
+exports.Class = exports.Function = exports.Identifier = undefined;
+
+var _infererReference = require("./inferer-reference");
+
+Object.defineProperty(exports, "Identifier", {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_infererReference).default;
+  }
+});
+exports.VariableDeclarator = VariableDeclarator;
+exports.TypeCastExpression = TypeCastExpression;
+exports.NewExpression = NewExpression;
+exports.TemplateLiteral = TemplateLiteral;
+exports.UnaryExpression = UnaryExpression;
+exports.BinaryExpression = BinaryExpression;
+exports.LogicalExpression = LogicalExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.SequenceExpression = SequenceExpression;
+exports.AssignmentExpression = AssignmentExpression;
+exports.UpdateExpression = UpdateExpression;
+exports.StringLiteral = StringLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.BooleanLiteral = BooleanLiteral;
+exports.NullLiteral = NullLiteral;
+exports.RegExpLiteral = RegExpLiteral;
+exports.ObjectExpression = ObjectExpression;
+exports.ArrayExpression = ArrayExpression;
+exports.RestElement = RestElement;
+exports.CallExpression = CallExpression;
+exports.TaggedTemplateExpression = TaggedTemplateExpression;
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function VariableDeclarator() {
+  var id = this.get("id");
+
+  if (id.isIdentifier()) {
+    return this.get("init").getTypeAnnotation();
+  } else {
+    return;
+  }
+}
+
+function TypeCastExpression(node) {
+  return node.typeAnnotation;
+}
+
+TypeCastExpression.validParent = true;
+
+function NewExpression(node) {
+  if (this.get("callee").isIdentifier()) {
+    // only resolve identifier callee
+    return t.genericTypeAnnotation(node.callee);
+  }
+}
+
+function TemplateLiteral() {
+  return t.stringTypeAnnotation();
+}
+
+function UnaryExpression(node) {
+  var operator = node.operator;
+
+  if (operator === "void") {
+    return t.voidTypeAnnotation();
+  } else if (t.NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t.numberTypeAnnotation();
+  } else if (t.STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t.stringTypeAnnotation();
+  } else if (t.BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t.booleanTypeAnnotation();
+  }
+}
+
+function BinaryExpression(node) {
+  var operator = node.operator;
+
+  if (t.NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return t.numberTypeAnnotation();
+  } else if (t.BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return t.booleanTypeAnnotation();
+  } else if (operator === "+") {
+    var right = this.get("right");
+    var left = this.get("left");
+
+    if (left.isBaseType("number") && right.isBaseType("number")) {
+      // both numbers so this will be a number
+      return t.numberTypeAnnotation();
+    } else if (left.isBaseType("string") || right.isBaseType("string")) {
+      // one is a string so the result will be a string
+      return t.stringTypeAnnotation();
+    }
+
+    // unsure if left and right are strings or numbers so stay on the safe side
+    return t.unionTypeAnnotation([t.stringTypeAnnotation(), t.numberTypeAnnotation()]);
+  }
+}
+
+function LogicalExpression() {
+  return t.createUnionTypeAnnotation([this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()]);
+}
+
+function ConditionalExpression() {
+  return t.createUnionTypeAnnotation([this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()]);
+}
+
+function SequenceExpression() {
+  return this.get("expressions").pop().getTypeAnnotation();
+}
+
+function AssignmentExpression() {
+  return this.get("right").getTypeAnnotation();
+}
+
+function UpdateExpression(node) {
+  var operator = node.operator;
+  if (operator === "++" || operator === "--") {
+    return t.numberTypeAnnotation();
+  }
+}
+
+function StringLiteral() {
+  return t.stringTypeAnnotation();
+}
+
+function NumericLiteral() {
+  return t.numberTypeAnnotation();
+}
+
+function BooleanLiteral() {
+  return t.booleanTypeAnnotation();
+}
+
+function NullLiteral() {
+  return t.nullLiteralTypeAnnotation();
+}
+
+function RegExpLiteral() {
+  return t.genericTypeAnnotation(t.identifier("RegExp"));
+}
+
+function ObjectExpression() {
+  return t.genericTypeAnnotation(t.identifier("Object"));
+}
+
+function ArrayExpression() {
+  return t.genericTypeAnnotation(t.identifier("Array"));
+}
+
+function RestElement() {
+  return ArrayExpression();
+}
+
+RestElement.validParent = true;
+
+function Func() {
+  return t.genericTypeAnnotation(t.identifier("Function"));
+}
+
+exports.Function = Func;
+exports.Class = Func;
+function CallExpression() {
+  return resolveCall(this.get("callee"));
+}
+
+function TaggedTemplateExpression() {
+  return resolveCall(this.get("tag"));
+}
+
+function resolveCall(callee) {
+  callee = callee.resolve();
+
+  if (callee.isFunction()) {
+    if (callee.is("async")) {
+      if (callee.is("generator")) {
+        return t.genericTypeAnnotation(t.identifier("AsyncIterator"));
+      } else {
+        return t.genericTypeAnnotation(t.identifier("Promise"));
+      }
+    } else {
+      if (callee.node.returnType) {
+        return callee.node.returnType;
+      } else {
+        // todo: get union type of all return arguments
+      }
+    }
+  }
+}

data/node_modules/babel-core/node_modules/babel-traverse/lib/path/introspection.js

@@ -0,0 +1,518 @@
+"use strict";
+
+exports.__esModule = true;
+exports.is = undefined;
+
+var _typeof2 = require("babel-runtime/helpers/typeof");
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.matchesPattern = matchesPattern;
+exports.has = has;
+exports.isStatic = isStatic;
+exports.isnt = isnt;
+exports.equals = equals;
+exports.isNodeType = isNodeType;
+exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression;
+exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement;
+exports.isCompletionRecord = isCompletionRecord;
+exports.isStatementOrBlock = isStatementOrBlock;
+exports.referencesImport = referencesImport;
+exports.getSource = getSource;
+exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
+exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
+exports._guessExecutionStatusRelativeToDifferentFunctions = _guessExecutionStatusRelativeToDifferentFunctions;
+exports.resolve = resolve;
+exports._resolve = _resolve;
+
+var _includes = require("lodash/includes");
+
+var _includes2 = _interopRequireDefault(_includes);
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Match the current node if it matches the provided `pattern`.
+ *
+ * For example, given the match `React.createClass` it would match the
+ * parsed nodes of `React.createClass` and `React["createClass"]`.
+ */
+
+function matchesPattern(pattern, allowPartial) {
+  // not a member expression
+  if (!this.isMemberExpression()) return false;
+
+  var parts = pattern.split(".");
+  var search = [this.node];
+  var i = 0;
+
+  function matches(name) {
+    var part = parts[i];
+    return part === "*" || name === part;
+  }
+
+  while (search.length) {
+    var node = search.shift();
+
+    if (allowPartial && i === parts.length) {
+      return true;
+    }
+
+    if (t.isIdentifier(node)) {
+      // this part doesn't match
+      if (!matches(node.name)) return false;
+    } else if (t.isLiteral(node)) {
+      // this part doesn't match
+      if (!matches(node.value)) return false;
+    } else if (t.isMemberExpression(node)) {
+      if (node.computed && !t.isLiteral(node.property)) {
+        // we can't deal with this
+        return false;
+      } else {
+        search.unshift(node.property);
+        search.unshift(node.object);
+        continue;
+      }
+    } else if (t.isThisExpression(node)) {
+      if (!matches("this")) return false;
+    } else {
+      // we can't deal with this
+      return false;
+    }
+
+    // too many parts
+    if (++i > parts.length) {
+      return false;
+    }
+  }
+
+  return i === parts.length;
+}
+
+/**
+ * Check whether we have the input `key`. If the `key` references an array then we check
+ * if the array has any items, otherwise we just check if it's falsy.
+ */
+
+// This file contains methods responsible for introspecting the current path for certain values.
+
+function has(key) {
+  var val = this.node && this.node[key];
+  if (val && Array.isArray(val)) {
+    return !!val.length;
+  } else {
+    return !!val;
+  }
+}
+
+/**
+ * Description
+ */
+
+function isStatic() {
+  return this.scope.isStatic(this.node);
+}
+
+/**
+ * Alias of `has`.
+ */
+
+var is = exports.is = has;
+
+/**
+ * Opposite of `has`.
+ */
+
+function isnt(key) {
+  return !this.has(key);
+}
+
+/**
+ * Check whether the path node `key` strict equals `value`.
+ */
+
+function equals(key, value) {
+  return this.node[key] === value;
+}
+
+/**
+ * Check the type against our stored internal type of the node. This is handy when a node has
+ * been removed yet we still internally know the type and need it to calculate node replacement.
+ */
+
+function isNodeType(type) {
+  return t.isType(this.type, type);
+}
+
+/**
+ * This checks whether or not we're in one of the following positions:
+ *
+ *   for (KEY in right);
+ *   for (KEY;;);
+ *
+ * This is because these spots allow VariableDeclarations AND normal expressions so we need
+ * to tell the path replacement that it's ok to replace this with an expression.
+ */
+
+function canHaveVariableDeclarationOrExpression() {
+  return (this.key === "init" || this.key === "left") && this.parentPath.isFor();
+}
+
+/**
+ * This checks whether we are swapping an arrow function's body between an
+ * expression and a block statement (or vice versa).
+ *
+ * This is because arrow functions may implicitly return an expression, which
+ * is the same as containing a block statement.
+ */
+
+function canSwapBetweenExpressionAndStatement(replacement) {
+  if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) {
+    return false;
+  }
+
+  if (this.isExpression()) {
+    return t.isBlockStatement(replacement);
+  } else if (this.isBlockStatement()) {
+    return t.isExpression(replacement);
+  }
+
+  return false;
+}
+
+/**
+ * Check whether the current path references a completion record
+ */
+
+function isCompletionRecord(allowInsideFunction) {
+  var path = this;
+  var first = true;
+
+  do {
+    var container = path.container;
+
+    // we're in a function so can't be a completion record
+    if (path.isFunction() && !first) {
+      return !!allowInsideFunction;
+    }
+
+    first = false;
+
+    // check to see if we're the last item in the container and if we are
+    // we're a completion record!
+    if (Array.isArray(container) && path.key !== container.length - 1) {
+      return false;
+    }
+  } while ((path = path.parentPath) && !path.isProgram());
+
+  return true;
+}
+
+/**
+ * Check whether or not the current `key` allows either a single statement or block statement
+ * so we can explode it if necessary.
+ */
+
+function isStatementOrBlock() {
+  if (this.parentPath.isLabeledStatement() || t.isBlockStatement(this.container)) {
+    return false;
+  } else {
+    return (0, _includes2.default)(t.STATEMENT_OR_BLOCK_KEYS, this.key);
+  }
+}
+
+/**
+ * Check if the currently assigned path references the `importName` of `moduleSource`.
+ */
+
+function referencesImport(moduleSource, importName) {
+  if (!this.isReferencedIdentifier()) return false;
+
+  var binding = this.scope.getBinding(this.node.name);
+  if (!binding || binding.kind !== "module") return false;
+
+  var path = binding.path;
+  var parent = path.parentPath;
+  if (!parent.isImportDeclaration()) return false;
+
+  // check moduleSource
+  if (parent.node.source.value === moduleSource) {
+    if (!importName) return true;
+  } else {
+    return false;
+  }
+
+  if (path.isImportDefaultSpecifier() && importName === "default") {
+    return true;
+  }
+
+  if (path.isImportNamespaceSpecifier() && importName === "*") {
+    return true;
+  }
+
+  if (path.isImportSpecifier() && path.node.imported.name === importName) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get the source code associated with this node.
+ */
+
+function getSource() {
+  var node = this.node;
+  if (node.end) {
+    return this.hub.file.code.slice(node.start, node.end);
+  } else {
+    return "";
+  }
+}
+
+function willIMaybeExecuteBefore(target) {
+  return this._guessExecutionStatusRelativeTo(target) !== "after";
+}
+
+/**
+ * Given a `target` check the execution status of it relative to the current path.
+ *
+ * "Execution status" simply refers to where or not we **think** this will execuete
+ * before or after the input `target` element.
+ */
+
+function _guessExecutionStatusRelativeTo(target) {
+  // check if the two paths are in different functions, we can't track execution of these
+  var targetFuncParent = target.scope.getFunctionParent();
+  var selfFuncParent = this.scope.getFunctionParent();
+
+  // here we check the `node` equality as sometimes we may have different paths for the
+  // same node due to path thrashing
+  if (targetFuncParent.node !== selfFuncParent.node) {
+    var status = this._guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent);
+    if (status) {
+      return status;
+    } else {
+      target = targetFuncParent.path;
+    }
+  }
+
+  var targetPaths = target.getAncestry();
+  if (targetPaths.indexOf(this) >= 0) return "after";
+
+  var selfPaths = this.getAncestry();
+
+  // get ancestor where the branches intersect
+  var commonPath = void 0;
+  var targetIndex = void 0;
+  var selfIndex = void 0;
+  for (selfIndex = 0; selfIndex < selfPaths.length; selfIndex++) {
+    var selfPath = selfPaths[selfIndex];
+    targetIndex = targetPaths.indexOf(selfPath);
+    if (targetIndex >= 0) {
+      commonPath = selfPath;
+      break;
+    }
+  }
+  if (!commonPath) {
+    return "before";
+  }
+
+  // get the relationship paths that associate these nodes to their common ancestor
+  var targetRelationship = targetPaths[targetIndex - 1];
+  var selfRelationship = selfPaths[selfIndex - 1];
+  if (!targetRelationship || !selfRelationship) {
+    return "before";
+  }
+
+  // container list so let's see which one is after the other
+  if (targetRelationship.listKey && targetRelationship.container === selfRelationship.container) {
+    return targetRelationship.key > selfRelationship.key ? "before" : "after";
+  }
+
+  // otherwise we're associated by a parent node, check which key comes before the other
+  var targetKeyPosition = t.VISITOR_KEYS[targetRelationship.type].indexOf(targetRelationship.key);
+  var selfKeyPosition = t.VISITOR_KEYS[selfRelationship.type].indexOf(selfRelationship.key);
+  return targetKeyPosition > selfKeyPosition ? "before" : "after";
+}
+
+function _guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent) {
+  var targetFuncPath = targetFuncParent.path;
+  if (!targetFuncPath.isFunctionDeclaration()) return;
+
+  // so we're in a completely different function, if this is a function declaration
+  // then we can be a bit smarter and handle cases where the function is either
+  // a. not called at all (part of an export)
+  // b. called directly
+  var binding = targetFuncPath.scope.getBinding(targetFuncPath.node.id.name);
+
+  // no references!
+  if (!binding.references) return "before";
+
+  var referencePaths = binding.referencePaths;
+
+  // verify that all of the references are calls
+  for (var _iterator = referencePaths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    var path = _ref;
+
+    if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
+      return;
+    }
+  }
+
+  var allStatus = void 0;
+
+  // verify that all the calls have the same execution status
+  for (var _iterator2 = referencePaths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
+    var _ref2;
+
+    if (_isArray2) {
+      if (_i2 >= _iterator2.length) break;
+      _ref2 = _iterator2[_i2++];
+    } else {
+      _i2 = _iterator2.next();
+      if (_i2.done) break;
+      _ref2 = _i2.value;
+    }
+
+    var _path = _ref2;
+
+    // if a reference is a child of the function we're checking against then we can
+    // safelty ignore it
+    var childOfFunction = !!_path.find(function (path) {
+      return path.node === targetFuncPath.node;
+    });
+    if (childOfFunction) continue;
+
+    var status = this._guessExecutionStatusRelativeTo(_path);
+
+    if (allStatus) {
+      if (allStatus !== status) return;
+    } else {
+      allStatus = status;
+    }
+  }
+
+  return allStatus;
+}
+
+/**
+ * Resolve a "pointer" `NodePath` to it's absolute path.
+ */
+
+function resolve(dangerous, resolved) {
+  return this._resolve(dangerous, resolved) || this;
+}
+
+function _resolve(dangerous, resolved) {
+  var _this = this;
+
+  // detect infinite recursion
+  // todo: possibly have a max length on this just to be safe
+  if (resolved && resolved.indexOf(this) >= 0) return;
+
+  // we store all the paths we've "resolved" in this array to prevent infinite recursion
+  resolved = resolved || [];
+  resolved.push(this);
+
+  if (this.isVariableDeclarator()) {
+    if (this.get("id").isIdentifier()) {
+      return this.get("init").resolve(dangerous, resolved);
+    } else {
+      // otherwise it's a request for a pattern and that's a bit more tricky
+    }
+  } else if (this.isReferencedIdentifier()) {
+      var binding = this.scope.getBinding(this.node.name);
+      if (!binding) return;
+
+      // reassigned so we can't really resolve it
+      if (!binding.constant) return;
+
+      // todo - lookup module in dependency graph
+      if (binding.kind === "module") return;
+
+      if (binding.path !== this) {
+        var _ret = function () {
+          var ret = binding.path.resolve(dangerous, resolved);
+          // If the identifier resolves to parent node then we can't really resolve it.
+          if (_this.find(function (parent) {
+            return parent.node === ret.node;
+          })) return {
+              v: void 0
+            };
+          return {
+            v: ret
+          };
+        }();
+
+        if ((typeof _ret === "undefined" ? "undefined" : (0, _typeof3.default)(_ret)) === "object") return _ret.v;
+      }
+    } else if (this.isTypeCastExpression()) {
+      return this.get("expression").resolve(dangerous, resolved);
+    } else if (dangerous && this.isMemberExpression()) {
+      // this is dangerous, as non-direct target assignments will mutate it's state
+      // making this resolution inaccurate
+
+      var targetKey = this.toComputedKey();
+      if (!t.isLiteral(targetKey)) return;
+
+      var targetName = targetKey.value;
+
+      var target = this.get("object").resolve(dangerous, resolved);
+
+      if (target.isObjectExpression()) {
+        var props = target.get("properties");
+        for (var _iterator3 = props, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) {
+          var _ref3;
+
+          if (_isArray3) {
+            if (_i3 >= _iterator3.length) break;
+            _ref3 = _iterator3[_i3++];
+          } else {
+            _i3 = _iterator3.next();
+            if (_i3.done) break;
+            _ref3 = _i3.value;
+          }
+
+          var prop = _ref3;
+
+          if (!prop.isProperty()) continue;
+
+          var key = prop.get("key");
+
+          // { foo: obj }
+          var match = prop.isnt("computed") && key.isIdentifier({ name: targetName });
+
+          // { "foo": "obj" } or { ["foo"]: "obj" }
+          match = match || key.isLiteral({ value: targetName });
+
+          if (match) return prop.get("value").resolve(dangerous, resolved);
+        }
+      } else if (target.isArrayExpression() && !isNaN(+targetName)) {
+        var elems = target.get("elements");
+        var elem = elems[targetName];
+        if (elem) return elem.resolve(dangerous, resolved);
+      }
+    }
+}