@babel/traverse 7.4.4 → 7.6.0

package/lib/path/context.js

@@ -53,7 +53,7 @@ function _call(fns) {
     const ret = fn.call(this.state, this, this.state);
 
     if (ret && typeof ret === "object" && typeof ret.then === "function") {
-      throw new Error(`You appear to be using a plugin with an async traversal visitor, ` + `which your current version of Babel does not support.` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+      throw new Error(`You appear to be using a plugin with an async traversal visitor, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
     }
 
     if (ret) {

package/lib/path/family.js

@@ -47,6 +47,57 @@ function addCompletionRecords(path, paths) {
   return paths;
 }
 
+function completionRecordForSwitch(cases, paths) {
+  let isLastCaseWithConsequent = true;
+
+  for (let i = cases.length - 1; i >= 0; i--) {
+    const switchCase = cases[i];
+    const consequent = switchCase.get("consequent");
+    let breakStatement;
+
+    findBreak: for (const statement of consequent) {
+      if (statement.isBlockStatement()) {
+        for (const statementInBlock of statement.get("body")) {
+          if (statementInBlock.isBreakStatement()) {
+            breakStatement = statementInBlock;
+            break findBreak;
+          }
+        }
+      } else if (statement.isBreakStatement()) {
+        breakStatement = statement;
+        break;
+      }
+    }
+
+    if (breakStatement) {
+      while (breakStatement.key === 0 && breakStatement.parentPath.isBlockStatement()) {
+        breakStatement = breakStatement.parentPath;
+      }
+
+      const prevSibling = breakStatement.getPrevSibling();
+
+      if (breakStatement.key > 0 && (prevSibling.isExpressionStatement() || prevSibling.isBlockStatement())) {
+        paths = addCompletionRecords(prevSibling, paths);
+        breakStatement.remove();
+      } else {
+        breakStatement.replaceWith(breakStatement.scope.buildUndefinedNode());
+        paths = addCompletionRecords(breakStatement, paths);
+      }
+    } else if (isLastCaseWithConsequent) {
+      const statementFinder = statement => !statement.isBlockStatement() || statement.get("body").some(statementFinder);
+
+      const hasConsequent = consequent.some(statementFinder);
+
+      if (hasConsequent) {
+        paths = addCompletionRecords(consequent[consequent.length - 1], paths);
+        isLastCaseWithConsequent = false;
+      }
+    }
+  }
+
+  return paths;
+}
+
 function getCompletionRecords() {
   let paths = [];
 
@@ -62,9 +113,10 @@ function getCompletionRecords() {
   } else if (this.isTryStatement()) {
     paths = addCompletionRecords(this.get("block"), paths);
     paths = addCompletionRecords(this.get("handler"), paths);
-    paths = addCompletionRecords(this.get("finalizer"), paths);
   } else if (this.isCatchClause()) {
     paths = addCompletionRecords(this.get("body"), paths);
+  } else if (this.isSwitchStatement()) {
+    paths = completionRecordForSwitch(this.get("cases"), paths);
   } else {
     paths.push(this);
   }

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

@@ -69,7 +69,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";
   });
 }

package/lib/path/introspection.js

@@ -172,81 +172,144 @@ 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 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);
+const executionOrderCheckedNodes = new WeakSet();
+
+function _guessExecutionStatusRelativeToDifferentFunctions(target) {
+  if (!target.isFunctionDeclaration()) 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 === target.node);
+    if (childOfFunction) continue;
+
     if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
-      return;
+      return "unknown";
     }
-  }
 
-  let allStatus;
-
-  for (const path of referencePaths) {
-    const childOfFunction = !!path.find(path => path.node === targetFuncPath.node);
-    if (childOfFunction) continue;
+    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;
     }

package/lib/path/modification.js

@@ -44,7 +44,7 @@ function insertBefore(nodes) {
 
   if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
     return parentPath.insertBefore(nodes);
-  } else if (this.isNodeType("Expression") && this.listKey !== "params" && this.listKey !== "arguments" || parentPath.isForStatement() && this.key === "init") {
+  } else if (this.isNodeType("Expression") && !this.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
     if (this.node) nodes.push(this.node);
     return this.replaceExpressionWithStatements(nodes);
   } else if (Array.isArray(this.container)) {
@@ -196,7 +196,7 @@ function unshiftContainer(listKey, nodes) {
     key: 0
   });
 
-  return path.insertBefore(nodes);
+  return path._containerInsertBefore(nodes);
 }
 
 function pushContainer(listKey, nodes) {

package/lib/path/replacement.js

@@ -206,6 +206,8 @@ function replaceExpressionWithStatements(nodes) {
     return this.replaceWith(toSequenceExpression)[0].get("expressions");
   }
 
+  const functionParent = this.getFunctionParent();
+  const isParentAsync = functionParent && functionParent.is("async");
   const container = t().arrowFunctionExpression([], t().blockStatement(nodes));
   this.replaceWith(t().callExpression(container, []));
   this.traverse(hoistVariablesVisitor);
@@ -235,6 +237,12 @@ function replaceExpressionWithStatements(nodes) {
 
   const callee = this.get("callee");
   callee.arrowFunctionToExpression();
+
+  if (isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", t().FUNCTION_TYPES)) {
+    callee.set("async", true);
+    this.replaceWith(t().awaitExpression(this.node));
+  }
+
   return callee.get("body.body");
 }
 

package/lib/scope/index.js

@@ -460,11 +460,7 @@ class Scope {
   }
 
   buildUndefinedNode() {
-    if (this.hasBinding("undefined")) {
-      return t().unaryExpression("void", t().numericLiteral(0), true);
-    } else {
-      return t().identifier("undefined");
-    }
+    return t().unaryExpression("void", t().numericLiteral(0), true);
   }
 
   registerConstantViolation(path) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babel/traverse",
-  "version": "7.4.4",
+  "version": "7.6.0",
   "description": "The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
@@ -11,18 +11,18 @@
   "repository": "https://github.com/babel/babel/tree/master/packages/babel-traverse",
   "main": "lib/index.js",
   "dependencies": {
-    "@babel/code-frame": "^7.0.0",
-    "@babel/generator": "^7.4.4",
+    "@babel/code-frame": "^7.5.5",
+    "@babel/generator": "^7.6.0",
     "@babel/helper-function-name": "^7.1.0",
     "@babel/helper-split-export-declaration": "^7.4.4",
-    "@babel/parser": "^7.4.4",
-    "@babel/types": "^7.4.4",
+    "@babel/parser": "^7.6.0",
+    "@babel/types": "^7.6.0",
     "debug": "^4.1.0",
     "globals": "^11.1.0",
-    "lodash": "^4.17.11"
+    "lodash": "^4.17.13"
   },
   "devDependencies": {
     "@babel/helper-plugin-test-runner": "^7.0.0"
   },
-  "gitHead": "2c88694388831b1e5b88e4bbed6781eb2be1edba"
+  "gitHead": "cbd5a26e57758e3f748174ff84aa570e8780e85d"
 }