@babel/traverse 7.14.9 → 7.16.3

package/lib/context.js

@@ -7,7 +7,11 @@ exports.default = void 0;
 
 var _path = require("./path");
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
+
+const {
+  VISITOR_KEYS
+} = _t;
 
 class TraversalContext {
   constructor(scope, opts, state, parentPath) {
@@ -23,7 +27,7 @@ class TraversalContext {
     const opts = this.opts;
     if (opts.enter || opts.exit) return true;
     if (opts[node.type]) return true;
-    const keys = t.VISITOR_KEYS[node.type];
+    const keys = VISITOR_KEYS[node.type];
     if (!(keys != null && keys.length)) return false;
 
     for (const key of keys) {

package/lib/index.js

@@ -3,22 +3,22 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "NodePath", {
+Object.defineProperty(exports, "Hub", {
   enumerable: true,
   get: function () {
-    return _path.default;
+    return _hub.default;
   }
 });
-Object.defineProperty(exports, "Scope", {
+Object.defineProperty(exports, "NodePath", {
   enumerable: true,
   get: function () {
-    return _scope.default;
+    return _path.default;
   }
 });
-Object.defineProperty(exports, "Hub", {
+Object.defineProperty(exports, "Scope", {
   enumerable: true,
   get: function () {
-    return _hub.default;
+    return _scope.default;
   }
 });
 exports.visitors = exports.default = void 0;
@@ -29,7 +29,7 @@ var visitors = require("./visitors");
 
 exports.visitors = visitors;
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
 
 var cache = require("./cache");
 
@@ -39,6 +39,12 @@ var _scope = require("./scope");
 
 var _hub = require("./hub");
 
+const {
+  VISITOR_KEYS,
+  removeProperties,
+  traverseFast
+} = _t;
+
 function traverse(parent, opts = {}, scope, state, parentPath) {
   if (!parent) return;
 
@@ -48,7 +54,7 @@ function traverse(parent, opts = {}, scope, state, parentPath) {
     }
   }
 
-  if (!t.VISITOR_KEYS[parent.type]) {
+  if (!VISITOR_KEYS[parent.type]) {
     return;
   }
 
@@ -63,11 +69,11 @@ traverse.verify = visitors.verify;
 traverse.explode = visitors.explode;
 
 traverse.cheap = function (node, enter) {
-  return t.traverseFast(node, enter);
+  return traverseFast(node, enter);
 };
 
 traverse.node = function (node, opts, scope, state, parentPath, skipKeys) {
-  const keys = t.VISITOR_KEYS[node.type];
+  const keys = VISITOR_KEYS[node.type];
   if (!keys) return;
   const context = new _context.default(scope, opts, state, parentPath);
 
@@ -78,12 +84,12 @@ traverse.node = function (node, opts, scope, state, parentPath, skipKeys) {
 };
 
 traverse.clearNode = function (node, opts) {
-  t.removeProperties(node, opts);
+  removeProperties(node, opts);
   cache.path.delete(node);
 };
 
 traverse.removeProperties = function (tree, opts) {
-  t.traverseFast(tree, traverse.clearNode, opts);
+  traverseFast(tree, traverse.clearNode, opts);
   return tree;
 };
 

package/lib/path/ancestry.js

@@ -3,21 +3,25 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.findParent = findParent;
 exports.find = find;
+exports.findParent = findParent;
+exports.getAncestry = getAncestry;
+exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom;
+exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom;
 exports.getFunctionParent = getFunctionParent;
 exports.getStatementParent = getStatementParent;
-exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom;
-exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom;
-exports.getAncestry = getAncestry;
+exports.inType = inType;
 exports.isAncestor = isAncestor;
 exports.isDescendant = isDescendant;
-exports.inType = inType;
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
 
 var _index = require("./index");
 
+const {
+  VISITOR_KEYS
+} = _t;
+
 function findParent(callback) {
   let path = this;
 
@@ -63,7 +67,7 @@ function getStatementParent() {
 function getEarliestCommonAncestorFrom(paths) {
   return this.getDeepestCommonAncestorFrom(paths, function (deepest, i, ancestries) {
     let earliest;
-    const keys = t.VISITOR_KEYS[deepest.type];
+    const keys = VISITOR_KEYS[deepest.type];
 
     for (const ancestry of ancestries) {
       const path = ancestry[i + 1];

package/lib/path/comments.js

@@ -3,11 +3,16 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
 exports.addComment = addComment;
 exports.addComments = addComments;
+exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
+
+var _t = require("@babel/types");
 
-var t = require("@babel/types");
+const {
+  addComment: _addComment,
+  addComments: _addComments
+} = _t;
 
 function shareCommentsWithSiblings() {
   if (typeof this.key === "string") return;
@@ -29,9 +34,9 @@ function shareCommentsWithSiblings() {
 }
 
 function addComment(type, content, line) {
-  t.addComment(this.node, type, content, line);
+  _addComment(this.node, type, content, line);
 }
 
 function addComments(type, comments) {
-  t.addComments(this.node, type, comments);
+  _addComments(this.node, type, comments);
 }

package/lib/path/context.js

@@ -3,26 +3,26 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.call = call;
 exports._call = _call;
-exports.isBlacklisted = exports.isDenylisted = isDenylisted;
-exports.visit = visit;
-exports.skip = skip;
-exports.skipKey = skipKey;
-exports.stop = stop;
-exports.setScope = setScope;
-exports.setContext = setContext;
-exports.resync = resync;
-exports._resyncParent = _resyncParent;
+exports._getQueueContexts = _getQueueContexts;
 exports._resyncKey = _resyncKey;
 exports._resyncList = _resyncList;
+exports._resyncParent = _resyncParent;
 exports._resyncRemoved = _resyncRemoved;
+exports.call = call;
+exports.isBlacklisted = exports.isDenylisted = isDenylisted;
 exports.popContext = popContext;
 exports.pushContext = pushContext;
-exports.setup = setup;
-exports.setKey = setKey;
 exports.requeue = requeue;
-exports._getQueueContexts = _getQueueContexts;
+exports.resync = resync;
+exports.setContext = setContext;
+exports.setKey = setKey;
+exports.setScope = setScope;
+exports.setup = setup;
+exports.skip = skip;
+exports.skipKey = skipKey;
+exports.stop = stop;
+exports.visit = visit;
 
 var _index = require("../index");
 
@@ -74,6 +74,14 @@ function isDenylisted() {
   return denylist && denylist.indexOf(this.node.type) > -1;
 }
 
+function restoreContext(path, context) {
+  if (path.context !== context) {
+    path.context = context;
+    path.state = context.state;
+    path.opts = context.opts;
+  }
+}
+
 function visit() {
   if (!this.node) {
     return false;
@@ -87,15 +95,19 @@ function visit() {
     return false;
   }
 
-  if (this.shouldSkip || this.call("enter") || this.shouldSkip) {
+  const currentContext = this.context;
+
+  if (this.shouldSkip || this.call("enter")) {
     this.debug("Skip...");
     return this.shouldStop;
   }
 
+  restoreContext(this, currentContext);
   this.debug("Recursing into...");
 
   _index.default.node(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
 
+  restoreContext(this, currentContext);
   this.call("exit");
   return this.shouldStop;
 }

package/lib/path/conversion.js

@@ -3,16 +3,42 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.toComputedKey = toComputedKey;
-exports.ensureBlock = ensureBlock;
+exports.arrowFunctionToExpression = arrowFunctionToExpression;
 exports.arrowFunctionToShadowed = arrowFunctionToShadowed;
+exports.ensureBlock = ensureBlock;
+exports.toComputedKey = toComputedKey;
 exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
-exports.arrowFunctionToExpression = arrowFunctionToExpression;
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
 
 var _helperFunctionName = require("@babel/helper-function-name");
 
+const {
+  arrowFunctionExpression,
+  assignmentExpression,
+  binaryExpression,
+  blockStatement,
+  callExpression,
+  conditionalExpression,
+  expressionStatement,
+  identifier,
+  isIdentifier,
+  jsxIdentifier,
+  memberExpression,
+  metaProperty,
+  numericLiteral,
+  objectExpression,
+  restElement,
+  returnStatement,
+  sequenceExpression,
+  spreadElement,
+  stringLiteral,
+  super: _super,
+  thisExpression,
+  toExpression,
+  unaryExpression
+} = _t;
+
 function toComputedKey() {
   let key;
 
@@ -25,7 +51,7 @@ function toComputedKey() {
   }
 
   if (!this.node.computed) {
-    if (t.isIdentifier(key)) key = t.stringLiteral(key.name);
+    if (isIdentifier(key)) key = stringLiteral(key.name);
   }
 
   return key;
@@ -61,14 +87,14 @@ function ensureBlock() {
 
     if (this.isFunction()) {
       key = "argument";
-      statements.push(t.returnStatement(body.node));
+      statements.push(returnStatement(body.node));
     } else {
       key = "expression";
-      statements.push(t.expressionStatement(body.node));
+      statements.push(expressionStatement(body.node));
     }
   }
 
-  this.node.body = t.blockStatement(statements);
+  this.node.body = blockStatement(statements);
   const parentPath = this.get(stringPath);
   body.setup(parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
   return this.node;
@@ -96,35 +122,58 @@ function arrowFunctionToExpression({
     throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
   }
 
-  const thisBinding = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow);
-  this.ensureBlock();
-  this.node.type = "FunctionExpression";
+  const {
+    thisBinding,
+    fnPath: fn
+  } = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow);
+  fn.ensureBlock();
+  fn.node.type = "FunctionExpression";
 
   if (!noNewArrows) {
-    const checkBinding = thisBinding ? null : this.parentPath.scope.generateUidIdentifier("arrowCheckId");
+    const checkBinding = thisBinding ? null : fn.scope.generateUidIdentifier("arrowCheckId");
 
     if (checkBinding) {
-      this.parentPath.scope.push({
+      fn.parentPath.scope.push({
         id: checkBinding,
-        init: t.objectExpression([])
+        init: objectExpression([])
       });
     }
 
-    this.get("body").unshiftContainer("body", t.expressionStatement(t.callExpression(this.hub.addHelper("newArrowCheck"), [t.thisExpression(), checkBinding ? t.identifier(checkBinding.name) : t.identifier(thisBinding)])));
-    this.replaceWith(t.callExpression(t.memberExpression((0, _helperFunctionName.default)(this, true) || this.node, t.identifier("bind")), [checkBinding ? t.identifier(checkBinding.name) : t.thisExpression()]));
+    fn.get("body").unshiftContainer("body", expressionStatement(callExpression(this.hub.addHelper("newArrowCheck"), [thisExpression(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)])));
+    fn.replaceWith(callExpression(memberExpression((0, _helperFunctionName.default)(this, true) || fn.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression()]));
   }
 }
 
 function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow = true) {
-  const thisEnvFn = fnPath.findParent(p => {
-    return p.isFunction() && !p.isArrowFunctionExpression() || p.isProgram() || p.isClassProperty({
+  let arrowParent;
+  let thisEnvFn = fnPath.findParent(p => {
+    if (p.isArrowFunctionExpression()) {
+      var _arrowParent;
+
+      (_arrowParent = arrowParent) != null ? _arrowParent : arrowParent = p;
+      return false;
+    }
+
+    return p.isFunction() || p.isProgram() || p.isClassProperty({
+      static: false
+    }) || p.isClassPrivateProperty({
       static: false
     });
   });
-  const inConstructor = (thisEnvFn == null ? void 0 : thisEnvFn.node.kind) === "constructor";
+  const inConstructor = thisEnvFn.isClassMethod({
+    kind: "constructor"
+  });
 
-  if (thisEnvFn.isClassProperty()) {
-    throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
+  if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) {
+    if (arrowParent) {
+      thisEnvFn = arrowParent;
+    } else if (allowInsertArrow) {
+      fnPath.replaceWith(callExpression(arrowFunctionExpression([], toExpression(fnPath.node)), []));
+      thisEnvFn = fnPath.get("callee");
+      fnPath = thisEnvFn.get("body");
+    } else {
+      throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
+    }
   }
 
   const {
@@ -159,7 +208,7 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
     });
     const superBinding = getSuperBinding(thisEnvFn);
     allSuperCalls.forEach(superCall => {
-      const callee = t.identifier(superBinding);
+      const callee = identifier(superBinding);
       callee.loc = superCall.node.callee.loc;
       superCall.get("callee").replaceWith(callee);
     });
@@ -167,25 +216,25 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
 
   if (argumentsPaths.length > 0) {
     const argumentsBinding = getBinding(thisEnvFn, "arguments", () => {
-      const args = () => t.identifier("arguments");
+      const args = () => identifier("arguments");
 
       if (thisEnvFn.scope.path.isProgram()) {
-        return t.conditionalExpression(t.binaryExpression("===", t.unaryExpression("typeof", args()), t.stringLiteral("undefined")), thisEnvFn.scope.buildUndefinedNode(), args());
+        return conditionalExpression(binaryExpression("===", unaryExpression("typeof", args()), stringLiteral("undefined")), thisEnvFn.scope.buildUndefinedNode(), args());
       } else {
         return args();
       }
     });
     argumentsPaths.forEach(argumentsChild => {
-      const argsRef = t.identifier(argumentsBinding);
+      const argsRef = identifier(argumentsBinding);
       argsRef.loc = argumentsChild.node.loc;
       argumentsChild.replaceWith(argsRef);
     });
   }
 
   if (newTargetPaths.length > 0) {
-    const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => t.metaProperty(t.identifier("new"), t.identifier("target")));
+    const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => metaProperty(identifier("new"), identifier("target")));
     newTargetPaths.forEach(targetChild => {
-      const targetRef = t.identifier(newTargetBinding);
+      const targetRef = identifier(newTargetBinding);
       targetRef.loc = targetChild.node.loc;
       targetChild.replaceWith(targetRef);
     });
@@ -217,11 +266,11 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
         args.push(value);
       }
 
-      const call = t.callExpression(t.identifier(superBinding), args);
+      const call = callExpression(identifier(superBinding), args);
 
       if (isCall) {
-        superProp.parentPath.unshiftContainer("arguments", t.thisExpression());
-        superProp.replaceWith(t.memberExpression(call, t.identifier("call")));
+        superProp.parentPath.unshiftContainer("arguments", thisExpression());
+        superProp.replaceWith(memberExpression(call, identifier("call")));
         thisPaths.push(superProp.parentPath.get("arguments.0"));
       } else if (isAssignment) {
         superProp.parentPath.replaceWith(call);
@@ -238,7 +287,7 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
 
     if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) {
       thisPaths.forEach(thisChild => {
-        const thisRef = thisChild.isJSX() ? t.jsxIdentifier(thisBinding) : t.identifier(thisBinding);
+        const thisRef = thisChild.isJSX() ? jsxIdentifier(thisBinding) : identifier(thisBinding);
         thisRef.loc = thisChild.node.loc;
         thisChild.replaceWith(thisRef);
       });
@@ -246,7 +295,10 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
     }
   }
 
-  return thisBinding;
+  return {
+    thisBinding,
+    fnPath
+  };
 }
 
 function standardizeSuperProperty(superProp) {
@@ -258,11 +310,11 @@ function standardizeSuperProperty(superProp) {
 
     if (superProp.node.computed) {
       const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
-      assignmentPath.get("left").replaceWith(t.memberExpression(superProp.node.object, t.assignmentExpression("=", tmp, superProp.node.property), true));
-      assignmentPath.get("right").replaceWith(t.binaryExpression(op, t.memberExpression(superProp.node.object, t.identifier(tmp.name), true), value));
+      assignmentPath.get("left").replaceWith(memberExpression(superProp.node.object, assignmentExpression("=", tmp, superProp.node.property), true));
+      assignmentPath.get("right").replaceWith(binaryExpression(op, memberExpression(superProp.node.object, identifier(tmp.name), true), value));
     } else {
-      assignmentPath.get("left").replaceWith(t.memberExpression(superProp.node.object, superProp.node.property));
-      assignmentPath.get("right").replaceWith(t.binaryExpression(op, t.memberExpression(superProp.node.object, t.identifier(superProp.node.property.name)), value));
+      assignmentPath.get("left").replaceWith(memberExpression(superProp.node.object, superProp.node.property));
+      assignmentPath.get("right").replaceWith(binaryExpression(op, memberExpression(superProp.node.object, identifier(superProp.node.property.name)), value));
     }
 
     return [assignmentPath.get("left"), assignmentPath.get("right").get("left")];
@@ -270,13 +322,13 @@ function standardizeSuperProperty(superProp) {
     const updateExpr = superProp.parentPath;
     const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
     const computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
-    const parts = [t.assignmentExpression("=", tmp, t.memberExpression(superProp.node.object, computedKey ? t.assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), t.assignmentExpression("=", t.memberExpression(superProp.node.object, computedKey ? t.identifier(computedKey.name) : superProp.node.property, superProp.node.computed), t.binaryExpression("+", t.identifier(tmp.name), t.numericLiteral(1)))];
+    const parts = [assignmentExpression("=", tmp, memberExpression(superProp.node.object, computedKey ? assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression("=", memberExpression(superProp.node.object, computedKey ? identifier(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression("+", identifier(tmp.name), numericLiteral(1)))];
 
     if (!superProp.parentPath.node.prefix) {
-      parts.push(t.identifier(tmp.name));
+      parts.push(identifier(tmp.name));
     }
 
-    updateExpr.replaceWith(t.sequenceExpression(parts));
+    updateExpr.replaceWith(sequenceExpression(parts));
     const left = updateExpr.get("expressions.0.right");
     const right = updateExpr.get("expressions.1.left");
     return [left, right];
@@ -291,7 +343,7 @@ function hasSuperClass(thisEnvFn) {
 
 function getThisBinding(thisEnvFn, inConstructor) {
   return getBinding(thisEnvFn, "this", thisBinding => {
-    if (!inConstructor || !hasSuperClass(thisEnvFn)) return t.thisExpression();
+    if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();
     const supers = new WeakSet();
     thisEnvFn.traverse({
       Function(child) {
@@ -307,7 +359,7 @@ function getThisBinding(thisEnvFn, inConstructor) {
         if (!child.get("callee").isSuper()) return;
         if (supers.has(child.node)) return;
         supers.add(child.node);
-        child.replaceWithMultiple([child.node, t.assignmentExpression("=", t.identifier(thisBinding), t.identifier("this"))]);
+        child.replaceWithMultiple([child.node, assignmentExpression("=", identifier(thisBinding), identifier("this"))]);
       }
 
     });
@@ -317,7 +369,7 @@ function getThisBinding(thisEnvFn, inConstructor) {
 function getSuperBinding(thisEnvFn) {
   return getBinding(thisEnvFn, "supercall", () => {
     const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
-    return t.arrowFunctionExpression([t.restElement(argsBinding)], t.callExpression(t.super(), [t.spreadElement(t.identifier(argsBinding.name))]));
+    return arrowFunctionExpression([restElement(argsBinding)], callExpression(_super(), [spreadElement(identifier(argsBinding.name))]));
   });
 }
 
@@ -328,20 +380,20 @@ function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
     let fnBody;
 
     if (propName) {
-      fnBody = t.memberExpression(t.super(), t.identifier(propName));
+      fnBody = memberExpression(_super(), identifier(propName));
     } else {
       const method = thisEnvFn.scope.generateUidIdentifier("prop");
       argsList.unshift(method);
-      fnBody = t.memberExpression(t.super(), t.identifier(method.name), true);
+      fnBody = memberExpression(_super(), identifier(method.name), true);
     }
 
     if (isAssignment) {
       const valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
       argsList.push(valueIdent);
-      fnBody = t.assignmentExpression("=", fnBody, t.identifier(valueIdent.name));
+      fnBody = assignmentExpression("=", fnBody, identifier(valueIdent.name));
     }
 
-    return t.arrowFunctionExpression(argsList, fnBody);
+    return arrowFunctionExpression(argsList, fnBody);
   });
 }
 

package/lib/path/evaluation.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.evaluateTruthy = evaluateTruthy;
 exports.evaluate = evaluate;
+exports.evaluateTruthy = evaluateTruthy;
 const VALID_CALLEES = ["String", "Number", "Math"];
 const INVALID_METHODS = ["random"];