@babel/traverse 7.13.0 → 7.14.0

package/lib/context.js

@@ -32,7 +32,7 @@ class TraversalContext {
     if (opts.enter || opts.exit) return true;
     if (opts[node.type]) return true;
     const keys = t.VISITOR_KEYS[node.type];
-    if (!(keys == null ? void 0 : keys.length)) return false;
+    if (!(keys != null && keys.length)) return false;
 
     for (const key of keys) {
       if (node[key]) return true;

package/lib/index.js

@@ -101,7 +101,7 @@ function hasDenylistedType(path, state) {
 }
 
 traverse.hasType = function (tree, type, denylistTypes) {
-  if (denylistTypes == null ? void 0 : denylistTypes.includes(tree.type)) return false;
+  if (denylistTypes != null && denylistTypes.includes(tree.type)) return false;
   if (tree.type === type) return true;
   const state = {
     has: false,

package/lib/path/evaluation.js

@@ -129,7 +129,7 @@ function _evaluate(path, state) {
       return deopt(binding.path, state);
     }
 
-    if (binding == null ? void 0 : binding.hasValue) {
+    if (binding != null && binding.hasValue) {
       return binding.value;
     } else {
       if (path.node.name === "undefined") {

package/lib/path/family.js

@@ -28,6 +28,23 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const NORMAL_COMPLETION = 0;
+const BREAK_COMPLETION = 1;
+
+function NormalCompletion(path) {
+  return {
+    type: NORMAL_COMPLETION,
+    path
+  };
+}
+
+function BreakCompletion(path) {
+  return {
+    type: BREAK_COMPLETION,
+    path
+  };
+}
+
 function getOpposite() {
   if (this.key === "left") {
     return this.getSibling("right");
@@ -38,102 +55,163 @@ function getOpposite() {
   return null;
 }
 
-function addCompletionRecords(path, paths) {
-  if (path) return paths.concat(path.getCompletionRecords());
-  return paths;
+function addCompletionRecords(path, records, context) {
+  if (path) return records.concat(_getCompletionRecords(path, context));
+  return records;
 }
 
-function findBreak(statements) {
-  let breakStatement;
+function completionRecordForSwitch(cases, records, context) {
+  let lastNormalCompletions = [];
 
-  if (!Array.isArray(statements)) {
-    statements = [statements];
-  }
+  for (let i = 0; i < cases.length; i++) {
+    const casePath = cases[i];
+
+    const caseCompletions = _getCompletionRecords(casePath, context);
 
-  for (const statement of statements) {
-    if (statement.isDoExpression() || statement.isProgram() || statement.isBlockStatement() || statement.isCatchClause() || statement.isLabeledStatement()) {
-      breakStatement = findBreak(statement.get("body"));
-    } else if (statement.isIfStatement()) {
-      var _findBreak;
+    const normalCompletions = [];
+    const breakCompletions = [];
 
-      breakStatement = (_findBreak = findBreak(statement.get("consequent"))) != null ? _findBreak : findBreak(statement.get("alternate"));
-    } else if (statement.isTryStatement()) {
-      var _findBreak2;
+    for (const c of caseCompletions) {
+      if (c.type === NORMAL_COMPLETION) {
+        normalCompletions.push(c);
+      }
 
-      breakStatement = (_findBreak2 = findBreak(statement.get("block"))) != null ? _findBreak2 : findBreak(statement.get("handler"));
-    } else if (statement.isBreakStatement()) {
-      breakStatement = statement;
+      if (c.type === BREAK_COMPLETION) {
+        breakCompletions.push(c);
+      }
     }
 
-    if (breakStatement) {
-      return breakStatement;
+    if (normalCompletions.length) {
+      lastNormalCompletions = normalCompletions;
     }
+
+    records = records.concat(breakCompletions);
   }
 
-  return null;
+  records = records.concat(lastNormalCompletions);
+  return records;
 }
 
-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(consequent);
+function normalCompletionToBreak(completions) {
+  completions.forEach(c => {
+    c.type = BREAK_COMPLETION;
+  });
+}
 
-    if (breakStatement) {
-      while (breakStatement.key === 0 && breakStatement.parentPath.isBlockStatement()) {
-        breakStatement = breakStatement.parentPath;
+function replaceBreakStatementInBreakCompletion(completions, reachable) {
+  completions.forEach(c => {
+    if (c.path.isBreakStatement({
+      label: null
+    })) {
+      if (reachable) {
+        c.path.replaceWith(t.unaryExpression("void", t.numericLiteral(0)));
+      } else {
+        c.path.remove();
       }
+    }
+  });
+}
 
-      const prevSibling = breakStatement.getPrevSibling();
+function getStatementListCompletion(paths, context) {
+  let completions = [];
 
-      if (breakStatement.key > 0 && (prevSibling.isExpressionStatement() || prevSibling.isBlockStatement())) {
-        paths = addCompletionRecords(prevSibling, paths);
-        breakStatement.remove();
-      } else {
-        breakStatement.replaceWith(breakStatement.scope.buildUndefinedNode());
-        paths = addCompletionRecords(breakStatement, paths);
+  if (context.canHaveBreak) {
+    let lastNormalCompletions = [];
+
+    for (let i = 0; i < paths.length; i++) {
+      const path = paths[i];
+      const newContext = Object.assign({}, context, {
+        inCaseClause: false
+      });
+
+      if (path.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) {
+          newContext.shouldPopulateBreak = true;
+        } else {
+        newContext.shouldPopulateBreak = false;
       }
-    } else if (isLastCaseWithConsequent) {
-      const statementFinder = statement => !statement.isBlockStatement() || statement.get("body").some(statementFinder);
 
-      const hasConsequent = consequent.some(statementFinder);
+      const statementCompletions = _getCompletionRecords(path, newContext);
+
+      if (statementCompletions.length > 0 && statementCompletions.every(c => c.type === BREAK_COMPLETION)) {
+        if (lastNormalCompletions.length > 0 && statementCompletions.every(c => c.path.isBreakStatement({
+          label: null
+        }))) {
+          normalCompletionToBreak(lastNormalCompletions);
+          completions = completions.concat(lastNormalCompletions);
+
+          if (lastNormalCompletions.some(c => c.path.isDeclaration())) {
+            completions = completions.concat(statementCompletions);
+            replaceBreakStatementInBreakCompletion(statementCompletions, true);
+          }
 
-      if (hasConsequent) {
-        paths = addCompletionRecords(consequent[consequent.length - 1], paths);
-        isLastCaseWithConsequent = false;
+          replaceBreakStatementInBreakCompletion(statementCompletions, false);
+        } else {
+          completions = completions.concat(statementCompletions);
+
+          if (!context.shouldPopulateBreak) {
+            replaceBreakStatementInBreakCompletion(statementCompletions, true);
+          }
+        }
+
+        break;
+      }
+
+      if (i === paths.length - 1) {
+        completions = completions.concat(statementCompletions);
+      } else {
+        completions = completions.concat(statementCompletions.filter(c => c.type === BREAK_COMPLETION));
+        lastNormalCompletions = statementCompletions.filter(c => c.type === NORMAL_COMPLETION);
       }
     }
+  } else if (paths.length) {
+    completions = completions.concat(_getCompletionRecords(paths[paths.length - 1], context));
   }
 
-  return paths;
+  return completions;
 }
 
-function getCompletionRecords() {
-  let paths = [];
-
-  if (this.isIfStatement()) {
-    paths = addCompletionRecords(this.get("consequent"), paths);
-    paths = addCompletionRecords(this.get("alternate"), paths);
-  } else if (this.isDoExpression() || this.isFor() || this.isWhile()) {
-    paths = addCompletionRecords(this.get("body"), paths);
-  } else if (this.isProgram() || this.isBlockStatement()) {
-    paths = addCompletionRecords(this.get("body").pop(), paths);
-  } else if (this.isFunction()) {
-    return this.get("body").getCompletionRecords();
-  } else if (this.isTryStatement()) {
-    paths = addCompletionRecords(this.get("block"), paths);
-    paths = addCompletionRecords(this.get("handler"), paths);
-  } else if (this.isCatchClause()) {
-    paths = addCompletionRecords(this.get("body"), paths);
-  } else if (this.isSwitchStatement()) {
-    paths = completionRecordForSwitch(this.get("cases"), paths);
+function _getCompletionRecords(path, context) {
+  let records = [];
+
+  if (path.isIfStatement()) {
+    records = addCompletionRecords(path.get("consequent"), records, context);
+    records = addCompletionRecords(path.get("alternate"), records, context);
+  } else if (path.isDoExpression() || path.isFor() || path.isWhile() || path.isLabeledStatement()) {
+    records = addCompletionRecords(path.get("body"), records, context);
+  } else if (path.isProgram() || path.isBlockStatement()) {
+    records = records.concat(getStatementListCompletion(path.get("body"), context));
+  } else if (path.isFunction()) {
+    return _getCompletionRecords(path.get("body"), context);
+  } else if (path.isTryStatement()) {
+    records = addCompletionRecords(path.get("block"), records, context);
+    records = addCompletionRecords(path.get("handler"), records, context);
+  } else if (path.isCatchClause()) {
+    records = addCompletionRecords(path.get("body"), records, context);
+  } else if (path.isSwitchStatement()) {
+    records = completionRecordForSwitch(path.get("cases"), records, context);
+  } else if (path.isSwitchCase()) {
+    records = records.concat(getStatementListCompletion(path.get("consequent"), {
+      canHaveBreak: true,
+      shouldPopulateBreak: false,
+      inCaseClause: true
+    }));
+  } else if (path.isBreakStatement()) {
+    records.push(BreakCompletion(path));
   } else {
-    paths.push(this);
+    records.push(NormalCompletion(path));
   }
 
-  return paths;
+  return records;
+}
+
+function getCompletionRecords() {
+  const records = _getCompletionRecords(this, {
+    canHaveBreak: false,
+    shouldPopulateBreak: false,
+    inCaseClause: false
+  });
+
+  return records.map(r => r.path);
 }
 
 function getSibling(key) {

package/lib/path/index.js

@@ -7,8 +7,6 @@ exports.default = exports.SHOULD_SKIP = exports.SHOULD_STOP = exports.REMOVED =
 
 var virtualTypes = _interopRequireWildcard(require("./lib/virtual-types"));
 
-var _debug = _interopRequireDefault(require("debug"));
-
 var _index = _interopRequireDefault(require("../index"));
 
 var _scope = _interopRequireDefault(require("../scope"));
@@ -47,7 +45,9 @@ function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; 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; }
 
-const debug = (0, _debug.default)("babel");
+const buildDebug = require("debug");
+
+const debug = buildDebug("babel");
 const REMOVED = 1 << 0;
 exports.REMOVED = REMOVED;
 const SHOULD_STOP = 1 << 1;

package/lib/path/inference/index.js

@@ -70,7 +70,7 @@ function _getTypeAnnotation() {
 
     inferer = inferers[this.parentPath.type];
 
-    if ((_inferer = inferer) == null ? void 0 : _inferer.validParent) {
+    if ((_inferer = inferer) != null && _inferer.validParent) {
       return this.parentPath.getTypeAnnotation();
     }
   } finally {

package/lib/path/removal.js

@@ -27,7 +27,7 @@ function remove() {
 
   this.resync();
 
-  if (!((_this$opts = this.opts) == null ? void 0 : _this$opts.noScope)) {
+  if (!((_this$opts = this.opts) != null && _this$opts.noScope)) {
     this._removeFromScope();
   }
 

package/lib/path/replacement.js

@@ -194,6 +194,7 @@ function replaceExpressionWithStatements(nodes) {
 
   const functionParent = this.getFunctionParent();
   const isParentAsync = functionParent == null ? void 0 : functionParent.is("async");
+  const isParentGenerator = functionParent == null ? void 0 : functionParent.is("generator");
   const container = t.arrowFunctionExpression([], t.blockStatement(nodes));
   this.replaceWith(t.callExpression(container, []));
   this.traverse(hoistVariablesVisitor);
@@ -224,9 +225,21 @@ function replaceExpressionWithStatements(nodes) {
   const callee = this.get("callee");
   callee.arrowFunctionToExpression();
 
-  if (isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", t.FUNCTION_TYPES)) {
+  const needToAwaitFunction = isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", t.FUNCTION_TYPES);
+
+  const needToYieldFunction = isParentGenerator && _index.default.hasType(this.get("callee.body").node, "YieldExpression", t.FUNCTION_TYPES);
+
+  if (needToAwaitFunction) {
     callee.set("async", true);
-    this.replaceWith(t.awaitExpression(this.node));
+
+    if (!needToYieldFunction) {
+      this.replaceWith(t.awaitExpression(this.node));
+    }
+  }
+
+  if (needToYieldFunction) {
+    callee.set("generator", true);
+    this.replaceWith(t.yieldExpression(this.node, true));
   }
 
   return callee.get("body.body");

package/lib/scope/index.js

@@ -11,8 +11,6 @@ var _index = _interopRequireDefault(require("../index"));
 
 var _binding = _interopRequireDefault(require("./binding"));
 
-var _globals = _interopRequireDefault(require("globals"));
-
 var t = _interopRequireWildcard(require("@babel/types"));
 
 var _cache = require("../cache");
@@ -23,6 +21,8 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const globals = require("globals");
+
 function gatherNodeParts(node, parts) {
   switch (node == null ? void 0 : node.type) {
     default:
@@ -470,7 +470,7 @@ class Scope {
     if (t.isIdentifier(node)) {
       const binding = this.getBinding(node.name);
 
-      if ((binding == null ? void 0 : binding.constant) && binding.path.isGenericType("Array")) {
+      if (binding != null && binding.constant && binding.path.isGenericType("Array")) {
         return node;
       }
     }
@@ -891,7 +891,7 @@ class Scope {
       if (binding) {
         var _previousPath;
 
-        if (((_previousPath = previousPath) == null ? void 0 : _previousPath.isPattern()) && binding.kind !== "param") {} else {
+        if ((_previousPath = previousPath) != null && _previousPath.isPattern() && binding.kind !== "param") {} else {
           return binding;
         }
       }
@@ -965,5 +965,5 @@ class Scope {
 }
 
 exports.default = Scope;
-Scope.globals = Object.keys(_globals.default.builtin);
+Scope.globals = Object.keys(globals.builtin);
 Scope.contextVariables = ["arguments", "undefined", "Infinity", "NaN"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babel/traverse",
-  "version": "7.13.0",
+  "version": "7.14.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://babel.dev/docs/en/next/babel-traverse",
@@ -17,16 +17,15 @@
   "main": "lib/index.js",
   "dependencies": {
     "@babel/code-frame": "^7.12.13",
-    "@babel/generator": "^7.13.0",
+    "@babel/generator": "^7.14.0",
     "@babel/helper-function-name": "^7.12.13",
     "@babel/helper-split-export-declaration": "^7.12.13",
-    "@babel/parser": "^7.13.0",
-    "@babel/types": "^7.13.0",
+    "@babel/parser": "^7.14.0",
+    "@babel/types": "^7.14.0",
     "debug": "^4.1.0",
-    "globals": "^11.1.0",
-    "lodash": "^4.17.19"
+    "globals": "^11.1.0"
   },
   "devDependencies": {
-    "@babel/helper-plugin-test-runner": "7.12.13"
+    "@babel/helper-plugin-test-runner": "7.13.10"
   }
 }