@babel/traverse 7.14.7 → 7.15.4

package/lib/path/lib/virtual-types.js

@@ -5,8 +5,32 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ForAwaitStatement = exports.NumericLiteralTypeAnnotation = exports.ExistentialTypeParam = exports.SpreadProperty = exports.RestProperty = exports.Flow = exports.Pure = exports.Generated = exports.User = exports.Var = exports.BlockScoped = exports.Referenced = exports.Scope = exports.Expression = exports.Statement = exports.BindingIdentifier = exports.ReferencedMemberExpression = exports.ReferencedIdentifier = void 0;
 
-var t = require("@babel/types");
-
+var _t = require("@babel/types");
+
+const {
+  isBinding,
+  isBlockScoped,
+  isExportDeclaration,
+  isExpression,
+  isFlow,
+  isForStatement,
+  isForXStatement,
+  isIdentifier,
+  isImportDeclaration,
+  isImportSpecifier,
+  isJSXIdentifier,
+  isJSXMemberExpression,
+  isMemberExpression,
+  isReferenced,
+  isScope,
+  isStatement,
+  isVar,
+  isVariableDeclaration,
+  react
+} = _t;
+const {
+  isCompatTag
+} = react;
 const ReferencedIdentifier = {
   types: ["Identifier", "JSXIdentifier"],
 
@@ -16,15 +40,15 @@ const ReferencedIdentifier = {
       parent
     } = path;
 
-    if (!t.isIdentifier(node, opts) && !t.isJSXMemberExpression(parent, opts)) {
-      if (t.isJSXIdentifier(node, opts)) {
-        if (t.react.isCompatTag(node.name)) return false;
+    if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {
+      if (isJSXIdentifier(node, opts)) {
+        if (isCompatTag(node.name)) return false;
       } else {
         return false;
       }
     }
 
-    return t.isReferenced(node, parent, path.parentPath.parent);
+    return isReferenced(node, parent, path.parentPath.parent);
   }
 
 };
@@ -36,7 +60,7 @@ const ReferencedMemberExpression = {
     node,
     parent
   }) {
-    return t.isMemberExpression(node) && t.isReferenced(node, parent);
+    return isMemberExpression(node) && isReferenced(node, parent);
   }
 
 };
@@ -50,7 +74,7 @@ const BindingIdentifier = {
       parent
     } = path;
     const grandparent = path.parentPath.parent;
-    return t.isIdentifier(node) && t.isBinding(node, parent, grandparent);
+    return isIdentifier(node) && isBinding(node, parent, grandparent);
   }
 
 };
@@ -62,12 +86,12 @@ const Statement = {
     node,
     parent
   }) {
-    if (t.isStatement(node)) {
-      if (t.isVariableDeclaration(node)) {
-        if (t.isForXStatement(parent, {
+    if (isStatement(node)) {
+      if (isVariableDeclaration(node)) {
+        if (isForXStatement(parent, {
           left: node
         })) return false;
-        if (t.isForStatement(parent, {
+        if (isForStatement(parent, {
           init: node
         })) return false;
       }
@@ -87,7 +111,7 @@ const Expression = {
     if (path.isIdentifier()) {
       return path.isReferencedIdentifier();
     } else {
-      return t.isExpression(path.node);
+      return isExpression(path.node);
     }
   }
 
@@ -97,21 +121,21 @@ const Scope = {
   types: ["Scopable", "Pattern"],
 
   checkPath(path) {
-    return t.isScope(path.node, path.parent);
+    return isScope(path.node, path.parent);
   }
 
 };
 exports.Scope = Scope;
 const Referenced = {
   checkPath(path) {
-    return t.isReferenced(path.node, path.parent);
+    return isReferenced(path.node, path.parent);
   }
 
 };
 exports.Referenced = Referenced;
 const BlockScoped = {
   checkPath(path) {
-    return t.isBlockScoped(path.node);
+    return isBlockScoped(path.node);
   }
 
 };
@@ -120,7 +144,7 @@ const Var = {
   types: ["VariableDeclaration"],
 
   checkPath(path) {
-    return t.isVar(path.node);
+    return isVar(path.node);
   }
 
 };
@@ -152,13 +176,13 @@ const Flow = {
   checkPath({
     node
   }) {
-    if (t.isFlow(node)) {
+    if (isFlow(node)) {
       return true;
-    } else if (t.isImportDeclaration(node)) {
+    } else if (isImportDeclaration(node)) {
       return node.importKind === "type" || node.importKind === "typeof";
-    } else if (t.isExportDeclaration(node)) {
+    } else if (isExportDeclaration(node)) {
       return node.exportKind === "type";
-    } else if (t.isImportSpecifier(node)) {
+    } else if (isImportSpecifier(node)) {
       return node.importKind === "type" || node.importKind === "typeof";
     } else {
       return false;

package/lib/path/modification.js

@@ -20,7 +20,18 @@ var _hoister = require("./lib/hoister");
 
 var _index = require("./index");
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
+
+const {
+  arrowFunctionExpression,
+  assertExpression,
+  assignmentExpression,
+  blockStatement,
+  callExpression,
+  cloneNode,
+  expressionStatement,
+  isExpression
+} = _t;
 
 function insertBefore(nodes_) {
   this._assertUnremoved();
@@ -41,7 +52,7 @@ function insertBefore(nodes_) {
   } else if (this.isStatementOrBlock()) {
     const node = this.node;
     const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
-    this.replaceWith(t.blockStatement(shouldInsertCurrentNode ? [node] : []));
+    this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
     return this.unshiftContainer("body", nodes);
   } else {
     throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
@@ -96,7 +107,7 @@ function insertAfter(nodes_) {
 
   if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
     return parentPath.insertAfter(nodes.map(node => {
-      return t.isExpression(node) ? t.expressionStatement(node) : node;
+      return isExpression(node) ? expressionStatement(node) : node;
     }));
   } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
     if (this.node) {
@@ -106,8 +117,8 @@ function insertAfter(nodes_) {
       } = this;
 
       if (scope.path.isPattern()) {
-        t.assertExpression(node);
-        this.replaceWith(t.callExpression(t.arrowFunctionExpression([], node), []));
+        assertExpression(node);
+        this.replaceWith(callExpression(arrowFunctionExpression([], node), []));
         this.get("callee.body").insertAfter(nodes);
         return [this];
       }
@@ -120,8 +131,8 @@ function insertAfter(nodes_) {
       }
 
       const temp = scope.generateDeclaredUidIdentifier();
-      nodes.unshift(t.expressionStatement(t.assignmentExpression("=", t.cloneNode(temp), node)));
-      nodes.push(t.expressionStatement(t.cloneNode(temp)));
+      nodes.unshift(expressionStatement(assignmentExpression("=", cloneNode(temp), node)));
+      nodes.push(expressionStatement(cloneNode(temp)));
     }
 
     return this.replaceExpressionWithStatements(nodes);
@@ -130,7 +141,7 @@ function insertAfter(nodes_) {
   } else if (this.isStatementOrBlock()) {
     const node = this.node;
     const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
-    this.replaceWith(t.blockStatement(shouldInsertCurrentNode ? [node] : []));
+    this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
     return this.pushContainer("body", nodes);
   } else {
     throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");

package/lib/path/replacement.js

@@ -20,17 +20,40 @@ var _cache = require("../cache");
 
 var _parser = require("@babel/parser");
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
 
 var _helperHoistVariables = require("@babel/helper-hoist-variables");
 
+const {
+  FUNCTION_TYPES,
+  arrowFunctionExpression,
+  assignmentExpression,
+  awaitExpression,
+  blockStatement,
+  callExpression,
+  cloneNode,
+  expressionStatement,
+  identifier,
+  inheritLeadingComments,
+  inheritTrailingComments,
+  inheritsComments,
+  isExpression,
+  isProgram,
+  isStatement,
+  removeComments,
+  returnStatement,
+  toSequenceExpression,
+  validate,
+  yieldExpression
+} = _t;
+
 function replaceWithMultiple(nodes) {
   var _pathCache$get;
 
   this.resync();
   nodes = this._verifyNodeList(nodes);
-  t.inheritLeadingComments(nodes[0], this.node);
-  t.inheritTrailingComments(nodes[nodes.length - 1], this.node);
+  inheritLeadingComments(nodes[0], this.node);
+  inheritTrailingComments(nodes[nodes.length - 1], this.node);
   (_pathCache$get = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get.delete(this.node);
   this.node = this.container[this.key] = null;
   const paths = this.insertAfter(nodes);
@@ -92,7 +115,7 @@ function replaceWith(replacement) {
     return [this];
   }
 
-  if (this.isProgram() && !t.isProgram(replacement)) {
+  if (this.isProgram() && !isProgram(replacement)) {
     throw new Error("You can only replace a Program root node with another Program node");
   }
 
@@ -106,14 +129,14 @@ function replaceWith(replacement) {
 
   let nodePath = "";
 
-  if (this.isNodeType("Statement") && t.isExpression(replacement)) {
+  if (this.isNodeType("Statement") && isExpression(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
-      replacement = t.expressionStatement(replacement);
+      replacement = expressionStatement(replacement);
       nodePath = "expression";
     }
   }
 
-  if (this.isNodeType("Expression") && t.isStatement(replacement)) {
+  if (this.isNodeType("Expression") && isStatement(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
       return this.replaceExpressionWithStatements([replacement]);
     }
@@ -122,8 +145,8 @@ function replaceWith(replacement) {
   const oldNode = this.node;
 
   if (oldNode) {
-    t.inheritsComments(replacement, oldNode);
-    t.removeComments(oldNode);
+    inheritsComments(replacement, oldNode);
+    removeComments(oldNode);
   }
 
   this._replaceWith(replacement);
@@ -142,9 +165,9 @@ function _replaceWith(node) {
   }
 
   if (this.inList) {
-    t.validate(this.parent, this.key, [node]);
+    validate(this.parent, this.key, [node]);
   } else {
-    t.validate(this.parent, this.key, node);
+    validate(this.parent, this.key, node);
   }
 
   this.debug(`Replace with ${node == null ? void 0 : node.type}`);
@@ -154,17 +177,17 @@ function _replaceWith(node) {
 
 function replaceExpressionWithStatements(nodes) {
   this.resync();
-  const toSequenceExpression = t.toSequenceExpression(nodes, this.scope);
+  const nodesAsSequenceExpression = toSequenceExpression(nodes, this.scope);
 
-  if (toSequenceExpression) {
-    return this.replaceWith(toSequenceExpression)[0].get("expressions");
+  if (nodesAsSequenceExpression) {
+    return this.replaceWith(nodesAsSequenceExpression)[0].get("expressions");
   }
 
   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, []));
+  const container = arrowFunctionExpression([], blockStatement(nodes));
+  this.replaceWith(callExpression(container, []));
   const callee = this.get("callee");
   (0, _helperHoistVariables.default)(callee.get("body"), id => {
     this.scope.push({
@@ -182,36 +205,36 @@ function replaceExpressionWithStatements(nodes) {
 
       if (!uid) {
         uid = callee.scope.generateDeclaredUidIdentifier("ret");
-        callee.get("body").pushContainer("body", t.returnStatement(t.cloneNode(uid)));
+        callee.get("body").pushContainer("body", returnStatement(cloneNode(uid)));
         loop.setData("expressionReplacementReturnUid", uid);
       } else {
-        uid = t.identifier(uid.name);
+        uid = identifier(uid.name);
       }
 
-      path.get("expression").replaceWith(t.assignmentExpression("=", t.cloneNode(uid), path.node.expression));
+      path.get("expression").replaceWith(assignmentExpression("=", cloneNode(uid), path.node.expression));
     } else {
-      path.replaceWith(t.returnStatement(path.node.expression));
+      path.replaceWith(returnStatement(path.node.expression));
     }
   }
 
   callee.arrowFunctionToExpression();
   const newCallee = callee;
 
-  const needToAwaitFunction = 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", FUNCTION_TYPES);
 
-  const needToYieldFunction = isParentGenerator && _index.default.hasType(this.get("callee.body").node, "YieldExpression", t.FUNCTION_TYPES);
+  const needToYieldFunction = isParentGenerator && _index.default.hasType(this.get("callee.body").node, "YieldExpression", FUNCTION_TYPES);
 
   if (needToAwaitFunction) {
     newCallee.set("async", true);
 
     if (!needToYieldFunction) {
-      this.replaceWith(t.awaitExpression(this.node));
+      this.replaceWith(awaitExpression(this.node));
     }
   }
 
   if (needToYieldFunction) {
     newCallee.set("generator", true);
-    this.replaceWith(t.yieldExpression(this.node, true));
+    this.replaceWith(yieldExpression(this.node, true));
   }
 
   return newCallee.get("body.body");