@babel/traverse 7.14.8 → 7.16.0

package/lib/path/modification.js

@@ -3,16 +3,16 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.insertBefore = insertBefore;
 exports._containerInsert = _containerInsert;
-exports._containerInsertBefore = _containerInsertBefore;
 exports._containerInsertAfter = _containerInsertAfter;
-exports.insertAfter = insertAfter;
-exports.updateSiblingKeys = updateSiblingKeys;
+exports._containerInsertBefore = _containerInsertBefore;
 exports._verifyNodeList = _verifyNodeList;
-exports.unshiftContainer = unshiftContainer;
-exports.pushContainer = pushContainer;
 exports.hoist = hoist;
+exports.insertAfter = insertAfter;
+exports.insertBefore = insertBefore;
+exports.pushContainer = pushContainer;
+exports.unshiftContainer = unshiftContainer;
+exports.updateSiblingKeys = updateSiblingKeys;
 
 var _cache = require("../cache");
 
@@ -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/removal.js

@@ -3,12 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.remove = remove;
-exports._removeFromScope = _removeFromScope;
+exports._assertUnremoved = _assertUnremoved;
 exports._callRemovalHooks = _callRemovalHooks;
-exports._remove = _remove;
 exports._markRemoved = _markRemoved;
-exports._assertUnremoved = _assertUnremoved;
+exports._remove = _remove;
+exports._removeFromScope = _removeFromScope;
+exports.remove = remove;
 
 var _removalHooks = require("./lib/removal-hooks");
 

package/lib/path/replacement.js

@@ -3,12 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.replaceWithMultiple = replaceWithMultiple;
-exports.replaceWithSourceString = replaceWithSourceString;
-exports.replaceWith = replaceWith;
 exports._replaceWith = _replaceWith;
 exports.replaceExpressionWithStatements = replaceExpressionWithStatements;
 exports.replaceInline = replaceInline;
+exports.replaceWith = replaceWith;
+exports.replaceWithMultiple = replaceWithMultiple;
+exports.replaceWithSourceString = replaceWithSourceString;
 
 var _codeFrame = require("@babel/code-frame");
 
@@ -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");

package/lib/scope/index.js

@@ -13,24 +13,63 @@ var _binding = require("./binding");
 
 var _globals = require("globals");
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
 
 var _cache = require("../cache");
 
+const {
+  NOT_LOCAL_BINDING,
+  callExpression,
+  cloneNode,
+  getBindingIdentifiers,
+  identifier,
+  isArrayExpression,
+  isBinary,
+  isClass,
+  isClassBody,
+  isClassDeclaration,
+  isExportAllDeclaration,
+  isExportDefaultDeclaration,
+  isExportNamedDeclaration,
+  isFunctionDeclaration,
+  isIdentifier,
+  isImportDeclaration,
+  isLiteral,
+  isMethod,
+  isModuleDeclaration,
+  isModuleSpecifier,
+  isObjectExpression,
+  isProperty,
+  isPureish,
+  isSuper,
+  isTaggedTemplateExpression,
+  isTemplateLiteral,
+  isThisExpression,
+  isUnaryExpression,
+  isVariableDeclaration,
+  matchesPattern,
+  memberExpression,
+  numericLiteral,
+  toIdentifier,
+  unaryExpression,
+  variableDeclaration,
+  variableDeclarator
+} = _t;
+
 function gatherNodeParts(node, parts) {
   switch (node == null ? void 0 : node.type) {
     default:
-      if (t.isModuleDeclaration(node)) {
-        if ((t.isExportAllDeclaration(node) || t.isExportNamedDeclaration(node) || t.isImportDeclaration(node)) && node.source) {
+      if (isModuleDeclaration(node)) {
+        if ((isExportAllDeclaration(node) || isExportNamedDeclaration(node) || isImportDeclaration(node)) && node.source) {
           gatherNodeParts(node.source, parts);
-        } else if ((t.isExportNamedDeclaration(node) || t.isImportDeclaration(node)) && node.specifiers && node.specifiers.length) {
+        } else if ((isExportNamedDeclaration(node) || isImportDeclaration(node)) && node.specifiers && node.specifiers.length) {
           for (const e of node.specifiers) gatherNodeParts(e, parts);
-        } else if ((t.isExportDefaultDeclaration(node) || t.isExportNamedDeclaration(node)) && node.declaration) {
+        } else if ((isExportDefaultDeclaration(node) || isExportNamedDeclaration(node)) && node.declaration) {
           gatherNodeParts(node.declaration, parts);
         }
-      } else if (t.isModuleSpecifier(node)) {
+      } else if (isModuleSpecifier(node)) {
         gatherNodeParts(node.local, parts);
-      } else if (t.isLiteral(node)) {
+      } else if (isLiteral(node)) {
         parts.push(node.value);
       }
 
@@ -159,14 +198,15 @@ function gatherNodeParts(node, parts) {
 }
 
 const collectorVisitor = {
-  For(path) {
-    for (const key of t.FOR_INIT_KEYS) {
-      const declar = path.get(key);
+  ForStatement(path) {
+    const declar = path.get("init");
 
-      if (declar.isVar()) {
-        const parentScope = path.scope.getFunctionParent() || path.scope.getProgramParent();
-        parentScope.registerBinding("var", declar);
-      }
+    if (declar.isVar()) {
+      const {
+        scope
+      } = path;
+      const parentScope = scope.getFunctionParent() || scope.getProgramParent();
+      parentScope.registerBinding("var", declar);
     }
   },
 
@@ -192,6 +232,12 @@ const collectorVisitor = {
 
     if (left.isPattern() || left.isIdentifier()) {
       state.constantViolations.push(path);
+    } else if (left.isVar()) {
+      const {
+        scope
+      } = path;
+      const parentScope = scope.getFunctionParent() || scope.getProgramParent();
+      parentScope.registerBinding("var", left);
     }
   },
 
@@ -201,19 +247,19 @@ const collectorVisitor = {
         node,
         scope
       } = path;
-      if (t.isExportAllDeclaration(node)) return;
+      if (isExportAllDeclaration(node)) return;
       const declar = node.declaration;
 
-      if (t.isClassDeclaration(declar) || t.isFunctionDeclaration(declar)) {
+      if (isClassDeclaration(declar) || isFunctionDeclaration(declar)) {
         const id = declar.id;
         if (!id) return;
         const binding = scope.getBinding(id.name);
-        if (binding) binding.reference(path);
-      } else if (t.isVariableDeclaration(declar)) {
+        binding == null ? void 0 : binding.reference(path);
+      } else if (isVariableDeclaration(declar)) {
         for (const decl of declar.declarations) {
-          for (const name of Object.keys(t.getBindingIdentifiers(decl))) {
+          for (const name of Object.keys(getBindingIdentifiers(decl))) {
             const binding = scope.getBinding(name);
-            if (binding) binding.reference(path);
+            binding == null ? void 0 : binding.reference(path);
           }
         }
       }
@@ -257,19 +303,19 @@ const collectorVisitor = {
   },
 
   Function(path) {
-    if (path.isFunctionExpression() && path.has("id") && !path.get("id").node[t.NOT_LOCAL_BINDING]) {
-      path.scope.registerBinding("local", path.get("id"), path);
-    }
-
     const params = path.get("params");
 
     for (const param of params) {
       path.scope.registerBinding("param", param);
     }
+
+    if (path.isFunctionExpression() && path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
+      path.scope.registerBinding("local", path.get("id"), path);
+    }
   },
 
   ClassExpression(path) {
-    if (path.has("id") && !path.get("id").node[t.NOT_LOCAL_BINDING]) {
+    if (path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
       path.scope.registerBinding("local", path);
     }
   }
@@ -342,15 +388,15 @@ class Scope {
     this.push({
       id
     });
-    return t.cloneNode(id);
+    return cloneNode(id);
   }
 
   generateUidIdentifier(name) {
-    return t.identifier(this.generateUid(name));
+    return identifier(this.generateUid(name));
   }
 
   generateUid(name = "temp") {
-    name = t.toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
+    name = toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
     let uid;
     let i = 1;
 
@@ -380,15 +426,15 @@ class Scope {
   }
 
   generateUidIdentifierBasedOnNode(node, defaultName) {
-    return t.identifier(this.generateUidBasedOnNode(node, defaultName));
+    return identifier(this.generateUidBasedOnNode(node, defaultName));
   }
 
   isStatic(node) {
-    if (t.isThisExpression(node) || t.isSuper(node)) {
+    if (isThisExpression(node) || isSuper(node)) {
       return true;
     }
 
-    if (t.isIdentifier(node)) {
+    if (isIdentifier(node)) {
       const binding = this.getBinding(node.name);
 
       if (binding) {
@@ -411,7 +457,7 @@ class Scope {
         this.push({
           id
         });
-        return t.cloneNode(id);
+        return cloneNode(id);
       }
 
       return id;
@@ -467,7 +513,7 @@ class Scope {
   }
 
   toArray(node, i, arrayLikeIsIterable) {
-    if (t.isIdentifier(node)) {
+    if (isIdentifier(node)) {
       const binding = this.getBinding(node.name);
 
       if (binding != null && binding.constant && binding.path.isGenericType("Array")) {
@@ -475,14 +521,14 @@ class Scope {
       }
     }
 
-    if (t.isArrayExpression(node)) {
+    if (isArrayExpression(node)) {
       return node;
     }
 
-    if (t.isIdentifier(node, {
+    if (isIdentifier(node, {
       name: "arguments"
     })) {
-      return t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.identifier("Array"), t.identifier("prototype")), t.identifier("slice")), t.identifier("call")), [node]);
+      return callExpression(memberExpression(memberExpression(memberExpression(identifier("Array"), identifier("prototype")), identifier("slice")), identifier("call")), [node]);
     }
 
     let helperName;
@@ -491,7 +537,7 @@ class Scope {
     if (i === true) {
       helperName = "toConsumableArray";
     } else if (i) {
-      args.push(t.numericLiteral(i));
+      args.push(numericLiteral(i));
       helperName = "slicedToArray";
     } else {
       helperName = "toArray";
@@ -502,7 +548,7 @@ class Scope {
       helperName = "maybeArrayLike";
     }
 
-    return t.callExpression(this.hub.addHelper(helperName), args);
+    return callExpression(this.hub.addHelper(helperName), args);
   }
 
   hasLabel(name) {
@@ -548,7 +594,7 @@ class Scope {
   }
 
   buildUndefinedNode() {
-    return t.unaryExpression("void", t.numericLiteral(0), true);
+    return unaryExpression("void", numericLiteral(0), true);
   }
 
   registerConstantViolation(path) {
@@ -630,56 +676,56 @@ class Scope {
   }
 
   isPure(node, constantsOnly) {
-    if (t.isIdentifier(node)) {
+    if (isIdentifier(node)) {
       const binding = this.getBinding(node.name);
       if (!binding) return false;
       if (constantsOnly) return binding.constant;
       return true;
-    } else if (t.isClass(node)) {
+    } else if (isClass(node)) {
       if (node.superClass && !this.isPure(node.superClass, constantsOnly)) {
         return false;
       }
 
       return this.isPure(node.body, constantsOnly);
-    } else if (t.isClassBody(node)) {
+    } else if (isClassBody(node)) {
       for (const method of node.body) {
         if (!this.isPure(method, constantsOnly)) return false;
       }
 
       return true;
-    } else if (t.isBinary(node)) {
+    } else if (isBinary(node)) {
       return this.isPure(node.left, constantsOnly) && this.isPure(node.right, constantsOnly);
-    } else if (t.isArrayExpression(node)) {
+    } else if (isArrayExpression(node)) {
       for (const elem of node.elements) {
         if (!this.isPure(elem, constantsOnly)) return false;
       }
 
       return true;
-    } else if (t.isObjectExpression(node)) {
+    } else if (isObjectExpression(node)) {
       for (const prop of node.properties) {
         if (!this.isPure(prop, constantsOnly)) return false;
       }
 
       return true;
-    } else if (t.isMethod(node)) {
+    } else if (isMethod(node)) {
       if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
       if (node.kind === "get" || node.kind === "set") return false;
       return true;
-    } else if (t.isProperty(node)) {
+    } else if (isProperty(node)) {
       if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
       return this.isPure(node.value, constantsOnly);
-    } else if (t.isUnaryExpression(node)) {
+    } else if (isUnaryExpression(node)) {
       return this.isPure(node.argument, constantsOnly);
-    } else if (t.isTaggedTemplateExpression(node)) {
-      return t.matchesPattern(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly);
-    } else if (t.isTemplateLiteral(node)) {
+    } else if (isTaggedTemplateExpression(node)) {
+      return matchesPattern(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly);
+    } else if (isTemplateLiteral(node)) {
       for (const expression of node.expressions) {
         if (!this.isPure(expression, constantsOnly)) return false;
       }
 
       return true;
     } else {
-      return t.isPureish(node);
+      return isPureish(node);
     }
   }
 
@@ -794,13 +840,13 @@ class Scope {
     let declarPath = !unique && path.getData(dataKey);
 
     if (!declarPath) {
-      const declar = t.variableDeclaration(kind, []);
+      const declar = variableDeclaration(kind, []);
       declar._blockHoist = blockHoist;
       [declarPath] = path.unshiftContainer("body", [declar]);
       if (!unique) path.setData(dataKey, declarPath);
     }
 
-    const declarator = t.variableDeclarator(opts.id, opts.init);
+    const declarator = variableDeclarator(opts.id, opts.init);
     declarPath.node.declarations.push(declarator);
     this.registerBinding(kind, declarPath.get("declarations").pop());
   }
@@ -891,7 +937,7 @@ class Scope {
       if (binding) {
         var _previousPath;
 
-        if ((_previousPath = previousPath) != null && _previousPath.isPattern() && binding.kind !== "param") {} else {
+        if ((_previousPath = previousPath) != null && _previousPath.isPattern() && binding.kind !== "param" && binding.kind !== "local") {} else {
           return binding;
         }
       }

package/lib/scope/lib/renamer.js

@@ -9,8 +9,16 @@ var _binding = require("../binding");
 
 var _helperSplitExportDeclaration = require("@babel/helper-split-export-declaration");
 
-var t = require("@babel/types");
-
+var _t = require("@babel/types");
+
+const {
+  VISITOR_KEYS,
+  assignmentExpression,
+  identifier,
+  toExpression,
+  variableDeclaration,
+  variableDeclarator
+} = _t;
 const renameVisitor = {
   ReferencedIdentifier({
     node
@@ -62,20 +70,20 @@ class Renamer {
     return;
     if (!path.isFunctionDeclaration() && !path.isClassDeclaration()) return;
     if (this.binding.kind !== "hoisted") return;
-    path.node.id = t.identifier(this.oldName);
+    path.node.id = identifier(this.oldName);
     path.node._blockHoist = 3;
-    path.replaceWith(t.variableDeclaration("let", [t.variableDeclarator(t.identifier(this.newName), t.toExpression(path.node))]));
+    path.replaceWith(variableDeclaration("let", [variableDeclarator(identifier(this.newName), toExpression(path.node))]));
   }
 
   maybeConvertFromClassFunctionExpression(path) {
     return;
     if (!path.isFunctionExpression() && !path.isClassExpression()) return;
     if (this.binding.kind !== "local") return;
-    path.node.id = t.identifier(this.oldName);
+    path.node.id = identifier(this.oldName);
     this.binding.scope.parent.push({
-      id: t.identifier(this.newName)
+      id: identifier(this.newName)
     });
-    path.replaceWith(t.assignmentExpression("=", t.identifier(this.newName), path.node));
+    path.replaceWith(assignmentExpression("=", identifier(this.newName), path.node));
   }
 
   rename(block) {
@@ -130,7 +138,7 @@ function skipAllButComputedMethodKey(path) {
     return;
   }
 
-  const keys = t.VISITOR_KEYS[path.type];
+  const keys = VISITOR_KEYS[path.type];
 
   for (const key of keys) {
     if (key !== "key") path.skipKey(key);