@babel/traverse 7.5.0 → 7.6.3

package/lib/path/inference/index.js

@@ -12,22 +12,16 @@ exports.isGenericType = isGenericType;
 
 var inferers = _interopRequireWildcard(require("./inferers"));
 
-function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+var t = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
-    return data;
-  };
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 
-  return data;
-}
-
-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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function getTypeAnnotation() {
   if (this.typeAnnotation) return this.typeAnnotation;
-  let type = this._getTypeAnnotation() || t().anyTypeAnnotation();
-  if (t().isTypeAnnotation(type)) type = type.typeAnnotation;
+  let type = this._getTypeAnnotation() || t.anyTypeAnnotation();
+  if (t.isTypeAnnotation(type)) type = type.typeAnnotation;
   return this.typeAnnotation = type;
 }
 
@@ -40,14 +34,14 @@ function _getTypeAnnotation() {
       const declarParent = declar.parentPath;
 
       if (declar.key === "left" && declarParent.isForInStatement()) {
-        return t().stringTypeAnnotation();
+        return t.stringTypeAnnotation();
       }
 
       if (declar.key === "left" && declarParent.isForOfStatement()) {
-        return t().anyTypeAnnotation();
+        return t.anyTypeAnnotation();
       }
 
-      return t().voidTypeAnnotation();
+      return t.voidTypeAnnotation();
     } else {
       return;
     }
@@ -76,19 +70,19 @@ function isBaseType(baseName, soft) {
 
 function _isBaseType(baseName, type, soft) {
   if (baseName === "string") {
-    return t().isStringTypeAnnotation(type);
+    return t.isStringTypeAnnotation(type);
   } else if (baseName === "number") {
-    return t().isNumberTypeAnnotation(type);
+    return t.isNumberTypeAnnotation(type);
   } else if (baseName === "boolean") {
-    return t().isBooleanTypeAnnotation(type);
+    return t.isBooleanTypeAnnotation(type);
   } else if (baseName === "any") {
-    return t().isAnyTypeAnnotation(type);
+    return t.isAnyTypeAnnotation(type);
   } else if (baseName === "mixed") {
-    return t().isMixedTypeAnnotation(type);
+    return t.isMixedTypeAnnotation(type);
   } else if (baseName === "empty") {
-    return t().isEmptyTypeAnnotation(type);
+    return t.isEmptyTypeAnnotation(type);
   } else if (baseName === "void") {
-    return t().isVoidTypeAnnotation(type);
+    return t.isVoidTypeAnnotation(type);
   } else {
     if (soft) {
       return false;
@@ -100,11 +94,11 @@ function _isBaseType(baseName, type, soft) {
 
 function couldBeBaseType(name) {
   const type = this.getTypeAnnotation();
-  if (t().isAnyTypeAnnotation(type)) return true;
+  if (t.isAnyTypeAnnotation(type)) return true;
 
-  if (t().isUnionTypeAnnotation(type)) {
+  if (t.isUnionTypeAnnotation(type)) {
     for (const type2 of type.types) {
-      if (t().isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
+      if (t.isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
         return true;
       }
     }
@@ -119,14 +113,14 @@ function baseTypeStrictlyMatches(right) {
   const left = this.getTypeAnnotation();
   right = right.getTypeAnnotation();
 
-  if (!t().isAnyTypeAnnotation(left) && t().isFlowBaseAnnotation(left)) {
+  if (!t.isAnyTypeAnnotation(left) && t.isFlowBaseAnnotation(left)) {
     return right.type === left.type;
   }
 }
 
 function isGenericType(genericName) {
   const type = this.getTypeAnnotation();
-  return t().isGenericTypeAnnotation(type) && t().isIdentifier(type.id, {
+  return t.isGenericTypeAnnotation(type) && t.isIdentifier(type.id, {
     name: genericName
   });
 }

package/lib/path/inference/inferer-reference.js

@@ -5,17 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = _default;
 
-function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+var t = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
-    return data;
-  };
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 
-  return data;
-}
-
-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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _default(node) {
   if (!this.isReferenced()) return;
@@ -30,9 +24,9 @@ function _default(node) {
   }
 
   if (node.name === "undefined") {
-    return t().voidTypeAnnotation();
+    return t.voidTypeAnnotation();
   } else if (node.name === "NaN" || node.name === "Infinity") {
-    return t().numberTypeAnnotation();
+    return t.numberTypeAnnotation();
   } else if (node.name === "arguments") {}
 }
 
@@ -57,7 +51,7 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
   }
 
   if (types.length) {
-    return t().createUnionTypeAnnotation(types);
+    return t.createUnionTypeAnnotation(types);
   }
 }
 
@@ -69,7 +63,7 @@ function getConstantViolationsBefore(binding, path, functions) {
 
     const status = violation._guessExecutionStatusRelativeTo(path);
 
-    if (functions && status === "function") functions.push(violation);
+    if (functions && status === "unknown") functions.push(violation);
     return status === "before";
   });
 }
@@ -95,8 +89,8 @@ function inferAnnotationFromBinaryExpression(name, path) {
       return target.getTypeAnnotation();
     }
 
-    if (t().BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
-      return t().numberTypeAnnotation();
+    if (t.BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+      return t.numberTypeAnnotation();
     }
 
     return;
@@ -126,7 +120,7 @@ function inferAnnotationFromBinaryExpression(name, path) {
   if (!typePath.isLiteral()) return;
   const typeValue = typePath.node.value;
   if (typeof typeValue !== "string") return;
-  return t().createTypeAnnotationBasedOnTypeof(typeValue);
+  return t.createTypeAnnotationBasedOnTypeof(typeValue);
 }
 
 function getParentConditionalPath(binding, path, name) {
@@ -172,7 +166,7 @@ function getConditionalAnnotation(binding, path, name) {
 
   if (types.length) {
     return {
-      typeAnnotation: t().createUnionTypeAnnotation(types),
+      typeAnnotation: t.createUnionTypeAnnotation(types),
       ifStatement
     };
   }

package/lib/path/inference/inferers.js

@@ -33,21 +33,15 @@ Object.defineProperty(exports, "Identifier", {
   }
 });
 
-function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
-
-  t = function () {
-    return data;
-  };
-
-  return data;
-}
+var t = _interopRequireWildcard(require("@babel/types"));
 
 var _infererReference = _interopRequireDefault(require("./inferer-reference"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function VariableDeclarator() {
   const id = this.get("id");
@@ -74,55 +68,55 @@ TypeCastExpression.validParent = true;
 
 function NewExpression(node) {
   if (this.get("callee").isIdentifier()) {
-    return t().genericTypeAnnotation(node.callee);
+    return t.genericTypeAnnotation(node.callee);
   }
 }
 
 function TemplateLiteral() {
-  return t().stringTypeAnnotation();
+  return t.stringTypeAnnotation();
 }
 
 function UnaryExpression(node) {
   const 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();
+    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) {
   const 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();
+  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 === "+") {
     const right = this.get("right");
     const left = this.get("left");
 
     if (left.isBaseType("number") && right.isBaseType("number")) {
-      return t().numberTypeAnnotation();
+      return t.numberTypeAnnotation();
     } else if (left.isBaseType("string") || right.isBaseType("string")) {
-      return t().stringTypeAnnotation();
+      return t.stringTypeAnnotation();
     }
 
-    return t().unionTypeAnnotation([t().stringTypeAnnotation(), t().numberTypeAnnotation()]);
+    return t.unionTypeAnnotation([t.stringTypeAnnotation(), t.numberTypeAnnotation()]);
   }
 }
 
 function LogicalExpression() {
-  return t().createUnionTypeAnnotation([this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()]);
+  return t.createUnionTypeAnnotation([this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()]);
 }
 
 function ConditionalExpression() {
-  return t().createUnionTypeAnnotation([this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()]);
+  return t.createUnionTypeAnnotation([this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()]);
 }
 
 function SequenceExpression() {
@@ -141,36 +135,36 @@ function UpdateExpression(node) {
   const operator = node.operator;
 
   if (operator === "++" || operator === "--") {
-    return t().numberTypeAnnotation();
+    return t.numberTypeAnnotation();
   }
 }
 
 function StringLiteral() {
-  return t().stringTypeAnnotation();
+  return t.stringTypeAnnotation();
 }
 
 function NumericLiteral() {
-  return t().numberTypeAnnotation();
+  return t.numberTypeAnnotation();
 }
 
 function BooleanLiteral() {
-  return t().booleanTypeAnnotation();
+  return t.booleanTypeAnnotation();
 }
 
 function NullLiteral() {
-  return t().nullLiteralTypeAnnotation();
+  return t.nullLiteralTypeAnnotation();
 }
 
 function RegExpLiteral() {
-  return t().genericTypeAnnotation(t().identifier("RegExp"));
+  return t.genericTypeAnnotation(t.identifier("RegExp"));
 }
 
 function ObjectExpression() {
-  return t().genericTypeAnnotation(t().identifier("Object"));
+  return t.genericTypeAnnotation(t.identifier("Object"));
 }
 
 function ArrayExpression() {
-  return t().genericTypeAnnotation(t().identifier("Array"));
+  return t.genericTypeAnnotation(t.identifier("Array"));
 }
 
 function RestElement() {
@@ -180,13 +174,13 @@ function RestElement() {
 RestElement.validParent = true;
 
 function Func() {
-  return t().genericTypeAnnotation(t().identifier("Function"));
+  return t.genericTypeAnnotation(t.identifier("Function"));
 }
 
-const isArrayFrom = t().buildMatchMemberExpression("Array.from");
-const isObjectKeys = t().buildMatchMemberExpression("Object.keys");
-const isObjectValues = t().buildMatchMemberExpression("Object.values");
-const isObjectEntries = t().buildMatchMemberExpression("Object.entries");
+const isArrayFrom = t.buildMatchMemberExpression("Array.from");
+const isObjectKeys = t.buildMatchMemberExpression("Object.keys");
+const isObjectValues = t.buildMatchMemberExpression("Object.values");
+const isObjectEntries = t.buildMatchMemberExpression("Object.entries");
 
 function CallExpression() {
   const {
@@ -194,11 +188,11 @@ function CallExpression() {
   } = this.node;
 
   if (isObjectKeys(callee)) {
-    return t().arrayTypeAnnotation(t().stringTypeAnnotation());
+    return t.arrayTypeAnnotation(t.stringTypeAnnotation());
   } else if (isArrayFrom(callee) || isObjectValues(callee)) {
-    return t().arrayTypeAnnotation(t().anyTypeAnnotation());
+    return t.arrayTypeAnnotation(t.anyTypeAnnotation());
   } else if (isObjectEntries(callee)) {
-    return t().arrayTypeAnnotation(t().tupleTypeAnnotation([t().stringTypeAnnotation(), t().anyTypeAnnotation()]));
+    return t.arrayTypeAnnotation(t.tupleTypeAnnotation([t.stringTypeAnnotation(), t.anyTypeAnnotation()]));
   }
 
   return resolveCall(this.get("callee"));
@@ -214,9 +208,9 @@ function resolveCall(callee) {
   if (callee.isFunction()) {
     if (callee.is("async")) {
       if (callee.is("generator")) {
-        return t().genericTypeAnnotation(t().identifier("AsyncIterator"));
+        return t.genericTypeAnnotation(t.identifier("AsyncIterator"));
       } else {
-        return t().genericTypeAnnotation(t().identifier("Promise"));
+        return t.genericTypeAnnotation(t.identifier("Promise"));
       }
     } else {
       if (callee.node.returnType) {

package/lib/path/introspection.js

@@ -24,32 +24,18 @@ exports.isConstantExpression = isConstantExpression;
 exports.isInStrictMode = isInStrictMode;
 exports.is = void 0;
 
-function _includes() {
-  const data = _interopRequireDefault(require("lodash/includes"));
+var _includes = _interopRequireDefault(require("lodash/includes"));
 
-  _includes = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+var t = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
-    return data;
-  };
-
-  return data;
-}
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 
-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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function matchesPattern(pattern, allowPartial) {
-  return t().matchesPattern(this.node, pattern, allowPartial);
+  return t.matchesPattern(this.node, pattern, allowPartial);
 }
 
 function has(key) {
@@ -78,7 +64,7 @@ function equals(key, value) {
 }
 
 function isNodeType(type) {
-  return t().isType(this.type, type);
+  return t.isType(this.type, type);
 }
 
 function canHaveVariableDeclarationOrExpression() {
@@ -91,9 +77,9 @@ function canSwapBetweenExpressionAndStatement(replacement) {
   }
 
   if (this.isExpression()) {
-    return t().isBlockStatement(replacement);
+    return t.isBlockStatement(replacement);
   } else if (this.isBlockStatement()) {
-    return t().isExpression(replacement);
+    return t.isExpression(replacement);
   }
 
   return false;
@@ -121,10 +107,10 @@ function isCompletionRecord(allowInsideFunction) {
 }
 
 function isStatementOrBlock() {
-  if (this.parentPath.isLabeledStatement() || t().isBlockStatement(this.container)) {
+  if (this.parentPath.isLabeledStatement() || t.isBlockStatement(this.container)) {
     return false;
   } else {
-    return (0, _includes().default)(t().STATEMENT_OR_BLOCK_KEYS, this.key);
+    return (0, _includes.default)(t.STATEMENT_OR_BLOCK_KEYS, this.key);
   }
 }
 
@@ -172,81 +158,147 @@ function willIMaybeExecuteBefore(target) {
   return this._guessExecutionStatusRelativeTo(target) !== "after";
 }
 
-function _guessExecutionStatusRelativeTo(target) {
-  const targetFuncParent = target.scope.getFunctionParent() || target.scope.getProgramParent();
-  const selfFuncParent = this.scope.getFunctionParent() || target.scope.getProgramParent();
+function getOuterFunction(path) {
+  return (path.scope.getFunctionParent() || path.scope.getProgramParent()).path;
+}
 
-  if (targetFuncParent.node !== selfFuncParent.node) {
-    const status = this._guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent);
+function isExecutionUncertain(type, key) {
+  switch (type) {
+    case "LogicalExpression":
+      return key === "right";
 
-    if (status) {
-      return status;
-    } else {
-      target = targetFuncParent.path;
+    case "ConditionalExpression":
+    case "IfStatement":
+      return key === "consequent" || key === "alternate";
+
+    case "WhileStatement":
+    case "DoWhileStatement":
+    case "ForInStatement":
+    case "ForOfStatement":
+      return key === "body";
+
+    case "ForStatement":
+      return key === "body" || key === "update";
+
+    case "SwitchStatement":
+      return key === "cases";
+
+    case "TryStatement":
+      return key === "handler";
+
+    case "AssignmentPattern":
+      return key === "right";
+
+    case "OptionalMemberExpression":
+      return key === "property";
+
+    case "OptionalCallExpression":
+      return key === "arguments";
+
+    default:
+      return false;
+  }
+}
+
+function isExecutionUncertainInList(paths, maxIndex) {
+  for (let i = 0; i < maxIndex; i++) {
+    const path = paths[i];
+
+    if (isExecutionUncertain(path.parent.type, path.parentKey)) {
+      return true;
     }
   }
 
-  const targetPaths = target.getAncestry();
-  if (targetPaths.indexOf(this) >= 0) return "after";
-  const selfPaths = this.getAncestry();
+  return false;
+}
+
+function _guessExecutionStatusRelativeTo(target) {
+  const funcParent = {
+    this: getOuterFunction(this),
+    target: getOuterFunction(target)
+  };
+
+  if (funcParent.target.node !== funcParent.this.node) {
+    return this._guessExecutionStatusRelativeToDifferentFunctions(funcParent.target);
+  }
+
+  const paths = {
+    target: target.getAncestry(),
+    this: this.getAncestry()
+  };
+  if (paths.target.indexOf(this) >= 0) return "after";
+  if (paths.this.indexOf(target) >= 0) return "before";
   let commonPath;
-  let targetIndex;
-  let selfIndex;
+  const commonIndex = {
+    target: 0,
+    this: 0
+  };
 
-  for (selfIndex = 0; selfIndex < selfPaths.length; selfIndex++) {
-    const selfPath = selfPaths[selfIndex];
-    targetIndex = targetPaths.indexOf(selfPath);
+  while (!commonPath && commonIndex.this < paths.this.length) {
+    const path = paths.this[commonIndex.this];
+    commonIndex.target = paths.target.indexOf(path);
 
-    if (targetIndex >= 0) {
-      commonPath = selfPath;
-      break;
+    if (commonIndex.target >= 0) {
+      commonPath = path;
+    } else {
+      commonIndex.this++;
     }
   }
 
   if (!commonPath) {
-    return "before";
+    throw new Error("Internal Babel error - The two compared nodes" + " don't appear to belong to the same program.");
   }
 
-  const targetRelationship = targetPaths[targetIndex - 1];
-  const selfRelationship = selfPaths[selfIndex - 1];
-
-  if (!targetRelationship || !selfRelationship) {
-    return "before";
+  if (isExecutionUncertainInList(paths.this, commonIndex.this - 1) || isExecutionUncertainInList(paths.target, commonIndex.target - 1)) {
+    return "unknown";
   }
 
-  if (targetRelationship.listKey && targetRelationship.container === selfRelationship.container) {
-    return targetRelationship.key > selfRelationship.key ? "before" : "after";
+  const divergence = {
+    this: paths.this[commonIndex.this - 1],
+    target: paths.target[commonIndex.target - 1]
+  };
+
+  if (divergence.target.listKey && divergence.this.listKey && divergence.target.container === divergence.this.container) {
+    return divergence.target.key > divergence.this.key ? "before" : "after";
   }
 
-  const keys = t().VISITOR_KEYS[commonPath.type];
-  const targetKeyPosition = keys.indexOf(targetRelationship.key);
-  const selfKeyPosition = keys.indexOf(selfRelationship.key);
-  return targetKeyPosition > selfKeyPosition ? "before" : "after";
+  const keys = t.VISITOR_KEYS[commonPath.type];
+  const keyPosition = {
+    this: keys.indexOf(divergence.this.parentKey),
+    target: keys.indexOf(divergence.target.parentKey)
+  };
+  return keyPosition.target > keyPosition.this ? "before" : "after";
 }
 
-function _guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent) {
-  const targetFuncPath = targetFuncParent.path;
-  if (!targetFuncPath.isFunctionDeclaration()) return;
-  const binding = targetFuncPath.scope.getBinding(targetFuncPath.node.id.name);
-  if (!binding.references) return "before";
-  const referencePaths = binding.referencePaths;
+const executionOrderCheckedNodes = new WeakSet();
 
-  for (const path of referencePaths) {
-    if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
-      return;
-    }
+function _guessExecutionStatusRelativeToDifferentFunctions(target) {
+  if (!target.isFunctionDeclaration() || target.parentPath.isExportDeclaration()) {
+    return "unknown";
   }
 
+  const binding = target.scope.getBinding(target.node.id.name);
+  if (!binding.references) return "before";
+  const referencePaths = binding.referencePaths;
   let allStatus;
 
   for (const path of referencePaths) {
-    const childOfFunction = !!path.find(path => path.node === targetFuncPath.node);
+    const childOfFunction = !!path.find(path => path.node === target.node);
     if (childOfFunction) continue;
 
+    if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
+      return "unknown";
+    }
+
+    if (executionOrderCheckedNodes.has(path.node)) continue;
+    executionOrderCheckedNodes.add(path.node);
+
     const status = this._guessExecutionStatusRelativeTo(path);
 
-    if (allStatus) {
-      if (allStatus !== status) return;
+    executionOrderCheckedNodes.delete(path.node);
+
+    if (allStatus && allStatus !== status) {
+      return "unknown";
     } else {
       allStatus = status;
     }
@@ -283,7 +335,7 @@ function _resolve(dangerous, resolved) {
     return this.get("expression").resolve(dangerous, resolved);
   } else if (dangerous && this.isMemberExpression()) {
     const targetKey = this.toComputedKey();
-    if (!t().isLiteral(targetKey)) return;
+    if (!t.isLiteral(targetKey)) return;
     const targetName = targetKey.value;
     const target = this.get("object").resolve(dangerous, resolved);