@babel/traverse 7.14.7 → 7.15.4

package/lib/path/inference/index.js

@@ -12,12 +12,30 @@ exports.isGenericType = isGenericType;
 
 var inferers = require("./inferers");
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
+
+const {
+  anyTypeAnnotation,
+  isAnyTypeAnnotation,
+  isBooleanTypeAnnotation,
+  isEmptyTypeAnnotation,
+  isFlowBaseAnnotation,
+  isGenericTypeAnnotation,
+  isIdentifier,
+  isMixedTypeAnnotation,
+  isNumberTypeAnnotation,
+  isStringTypeAnnotation,
+  isTypeAnnotation,
+  isUnionTypeAnnotation,
+  isVoidTypeAnnotation,
+  stringTypeAnnotation,
+  voidTypeAnnotation
+} = _t;
 
 function getTypeAnnotation() {
   if (this.typeAnnotation) return this.typeAnnotation;
-  let type = this._getTypeAnnotation() || t.anyTypeAnnotation();
-  if (t.isTypeAnnotation(type)) type = type.typeAnnotation;
+  let type = this._getTypeAnnotation() || anyTypeAnnotation();
+  if (isTypeAnnotation(type)) type = type.typeAnnotation;
   return this.typeAnnotation = type;
 }
 
@@ -32,14 +50,14 @@ function _getTypeAnnotation() {
       const declarParent = declar.parentPath;
 
       if (declar.key === "left" && declarParent.isForInStatement()) {
-        return t.stringTypeAnnotation();
+        return stringTypeAnnotation();
       }
 
       if (declar.key === "left" && declarParent.isForOfStatement()) {
-        return t.anyTypeAnnotation();
+        return anyTypeAnnotation();
       }
 
-      return t.voidTypeAnnotation();
+      return voidTypeAnnotation();
     } else {
       return;
     }
@@ -80,19 +98,19 @@ function isBaseType(baseName, soft) {
 
 function _isBaseType(baseName, type, soft) {
   if (baseName === "string") {
-    return t.isStringTypeAnnotation(type);
+    return isStringTypeAnnotation(type);
   } else if (baseName === "number") {
-    return t.isNumberTypeAnnotation(type);
+    return isNumberTypeAnnotation(type);
   } else if (baseName === "boolean") {
-    return t.isBooleanTypeAnnotation(type);
+    return isBooleanTypeAnnotation(type);
   } else if (baseName === "any") {
-    return t.isAnyTypeAnnotation(type);
+    return isAnyTypeAnnotation(type);
   } else if (baseName === "mixed") {
-    return t.isMixedTypeAnnotation(type);
+    return isMixedTypeAnnotation(type);
   } else if (baseName === "empty") {
-    return t.isEmptyTypeAnnotation(type);
+    return isEmptyTypeAnnotation(type);
   } else if (baseName === "void") {
-    return t.isVoidTypeAnnotation(type);
+    return isVoidTypeAnnotation(type);
   } else {
     if (soft) {
       return false;
@@ -104,11 +122,11 @@ function _isBaseType(baseName, type, soft) {
 
 function couldBeBaseType(name) {
   const type = this.getTypeAnnotation();
-  if (t.isAnyTypeAnnotation(type)) return true;
+  if (isAnyTypeAnnotation(type)) return true;
 
-  if (t.isUnionTypeAnnotation(type)) {
+  if (isUnionTypeAnnotation(type)) {
     for (const type2 of type.types) {
-      if (t.isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
+      if (isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
         return true;
       }
     }
@@ -123,7 +141,7 @@ function baseTypeStrictlyMatches(rightArg) {
   const left = this.getTypeAnnotation();
   const right = rightArg.getTypeAnnotation();
 
-  if (!t.isAnyTypeAnnotation(left) && t.isFlowBaseAnnotation(left)) {
+  if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) {
     return right.type === left.type;
   }
 
@@ -132,7 +150,7 @@ function baseTypeStrictlyMatches(rightArg) {
 
 function isGenericType(genericName) {
   const type = this.getTypeAnnotation();
-  return t.isGenericTypeAnnotation(type) && t.isIdentifier(type.id, {
+  return isGenericTypeAnnotation(type) && isIdentifier(type.id, {
     name: genericName
   });
 }

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

@@ -5,7 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = _default;
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
+
+const {
+  BOOLEAN_NUMBER_BINARY_OPERATORS,
+  createFlowUnionType,
+  createTSUnionType,
+  createTypeAnnotationBasedOnTypeof,
+  createUnionTypeAnnotation,
+  isTSTypeAnnotation,
+  numberTypeAnnotation,
+  voidTypeAnnotation
+} = _t;
 
 function _default(node) {
   if (!this.isReferenced()) return;
@@ -20,9 +31,9 @@ function _default(node) {
   }
 
   if (node.name === "undefined") {
-    return t.voidTypeAnnotation();
+    return voidTypeAnnotation();
   } else if (node.name === "NaN" || node.name === "Infinity") {
-    return t.numberTypeAnnotation();
+    return numberTypeAnnotation();
   } else if (node.name === "arguments") {}
 }
 
@@ -39,7 +50,7 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
   }
 
   if (constantViolations.length) {
-    constantViolations = constantViolations.concat(functionConstantViolations);
+    constantViolations.push(...functionConstantViolations);
 
     for (const violation of constantViolations) {
       types.push(violation.getTypeAnnotation());
@@ -50,15 +61,15 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
     return;
   }
 
-  if (t.isTSTypeAnnotation(types[0]) && t.createTSUnionType) {
-    return t.createTSUnionType(types);
+  if (isTSTypeAnnotation(types[0]) && createTSUnionType) {
+    return createTSUnionType(types);
   }
 
-  if (t.createFlowUnionType) {
-    return t.createFlowUnionType(types);
+  if (createFlowUnionType) {
+    return createFlowUnionType(types);
   }
 
-  return t.createUnionTypeAnnotation(types);
+  return createUnionTypeAnnotation(types);
 }
 
 function getConstantViolationsBefore(binding, path, functions) {
@@ -95,8 +106,8 @@ function inferAnnotationFromBinaryExpression(name, path) {
       return target.getTypeAnnotation();
     }
 
-    if (t.BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
-      return t.numberTypeAnnotation();
+    if (BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+      return numberTypeAnnotation();
     }
 
     return;
@@ -126,7 +137,7 @@ function inferAnnotationFromBinaryExpression(name, path) {
   if (!typePath.isLiteral()) return;
   const typeValue = typePath.node.value;
   if (typeof typeValue !== "string") return;
-  return t.createTypeAnnotationBasedOnTypeof(typeValue);
+  return createTypeAnnotationBasedOnTypeof(typeValue);
 }
 
 function getParentConditionalPath(binding, path, name) {
@@ -171,22 +182,22 @@ function getConditionalAnnotation(binding, path, name) {
   }
 
   if (types.length) {
-    if (t.isTSTypeAnnotation(types[0]) && t.createTSUnionType) {
+    if (isTSTypeAnnotation(types[0]) && createTSUnionType) {
       return {
-        typeAnnotation: t.createTSUnionType(types),
+        typeAnnotation: createTSUnionType(types),
         ifStatement
       };
     }
 
-    if (t.createFlowUnionType) {
+    if (createFlowUnionType) {
       return {
-        typeAnnotation: t.createFlowUnionType(types),
+        typeAnnotation: createFlowUnionType(types),
         ifStatement
       };
     }
 
     return {
-      typeAnnotation: t.createUnionTypeAnnotation(types),
+      typeAnnotation: createUnionTypeAnnotation(types),
       ifStatement
     };
   }

package/lib/path/inference/inferers.js

@@ -33,10 +33,34 @@ Object.defineProperty(exports, "Identifier", {
   }
 });
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
 
 var _infererReference = require("./inferer-reference");
 
+const {
+  BOOLEAN_BINARY_OPERATORS,
+  BOOLEAN_UNARY_OPERATORS,
+  NUMBER_BINARY_OPERATORS,
+  NUMBER_UNARY_OPERATORS,
+  STRING_UNARY_OPERATORS,
+  anyTypeAnnotation,
+  arrayTypeAnnotation,
+  booleanTypeAnnotation,
+  buildMatchMemberExpression,
+  createFlowUnionType,
+  createTSUnionType,
+  createUnionTypeAnnotation,
+  genericTypeAnnotation,
+  identifier,
+  isTSTypeAnnotation,
+  nullLiteralTypeAnnotation,
+  numberTypeAnnotation,
+  stringTypeAnnotation,
+  tupleTypeAnnotation,
+  unionTypeAnnotation,
+  voidTypeAnnotation
+} = _t;
+
 function VariableDeclarator() {
   var _type;
 
@@ -64,75 +88,75 @@ TypeCastExpression.validParent = true;
 
 function NewExpression(node) {
   if (this.get("callee").isIdentifier()) {
-    return t.genericTypeAnnotation(node.callee);
+    return genericTypeAnnotation(node.callee);
   }
 }
 
 function TemplateLiteral() {
-  return t.stringTypeAnnotation();
+  return stringTypeAnnotation();
 }
 
 function UnaryExpression(node) {
   const operator = node.operator;
 
   if (operator === "void") {
-    return t.voidTypeAnnotation();
-  } else if (t.NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.numberTypeAnnotation();
-  } else if (t.STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.stringTypeAnnotation();
-  } else if (t.BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.booleanTypeAnnotation();
+    return voidTypeAnnotation();
+  } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return numberTypeAnnotation();
+  } else if (STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return stringTypeAnnotation();
+  } else if (BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return booleanTypeAnnotation();
   }
 }
 
 function BinaryExpression(node) {
   const operator = node.operator;
 
-  if (t.NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.numberTypeAnnotation();
-  } else if (t.BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.booleanTypeAnnotation();
+  if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return numberTypeAnnotation();
+  } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return booleanTypeAnnotation();
   } else if (operator === "+") {
     const right = this.get("right");
     const left = this.get("left");
 
     if (left.isBaseType("number") && right.isBaseType("number")) {
-      return t.numberTypeAnnotation();
+      return numberTypeAnnotation();
     } else if (left.isBaseType("string") || right.isBaseType("string")) {
-      return t.stringTypeAnnotation();
+      return stringTypeAnnotation();
     }
 
-    return t.unionTypeAnnotation([t.stringTypeAnnotation(), t.numberTypeAnnotation()]);
+    return unionTypeAnnotation([stringTypeAnnotation(), numberTypeAnnotation()]);
   }
 }
 
 function LogicalExpression() {
   const argumentTypes = [this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()];
 
-  if (t.isTSTypeAnnotation(argumentTypes[0]) && t.createTSUnionType) {
-    return t.createTSUnionType(argumentTypes);
+  if (isTSTypeAnnotation(argumentTypes[0]) && createTSUnionType) {
+    return createTSUnionType(argumentTypes);
   }
 
-  if (t.createFlowUnionType) {
-    return t.createFlowUnionType(argumentTypes);
+  if (createFlowUnionType) {
+    return createFlowUnionType(argumentTypes);
   }
 
-  return t.createUnionTypeAnnotation(argumentTypes);
+  return createUnionTypeAnnotation(argumentTypes);
 }
 
 function ConditionalExpression() {
   const argumentTypes = [this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()];
 
-  if (t.isTSTypeAnnotation(argumentTypes[0]) && t.createTSUnionType) {
-    return t.createTSUnionType(argumentTypes);
+  if (isTSTypeAnnotation(argumentTypes[0]) && createTSUnionType) {
+    return createTSUnionType(argumentTypes);
   }
 
-  if (t.createFlowUnionType) {
-    return t.createFlowUnionType(argumentTypes);
+  if (createFlowUnionType) {
+    return createFlowUnionType(argumentTypes);
   }
 
-  return t.createUnionTypeAnnotation(argumentTypes);
+  return createUnionTypeAnnotation(argumentTypes);
 }
 
 function SequenceExpression() {
@@ -151,36 +175,36 @@ function UpdateExpression(node) {
   const operator = node.operator;
 
   if (operator === "++" || operator === "--") {
-    return t.numberTypeAnnotation();
+    return numberTypeAnnotation();
   }
 }
 
 function StringLiteral() {
-  return t.stringTypeAnnotation();
+  return stringTypeAnnotation();
 }
 
 function NumericLiteral() {
-  return t.numberTypeAnnotation();
+  return numberTypeAnnotation();
 }
 
 function BooleanLiteral() {
-  return t.booleanTypeAnnotation();
+  return booleanTypeAnnotation();
 }
 
 function NullLiteral() {
-  return t.nullLiteralTypeAnnotation();
+  return nullLiteralTypeAnnotation();
 }
 
 function RegExpLiteral() {
-  return t.genericTypeAnnotation(t.identifier("RegExp"));
+  return genericTypeAnnotation(identifier("RegExp"));
 }
 
 function ObjectExpression() {
-  return t.genericTypeAnnotation(t.identifier("Object"));
+  return genericTypeAnnotation(identifier("Object"));
 }
 
 function ArrayExpression() {
-  return t.genericTypeAnnotation(t.identifier("Array"));
+  return genericTypeAnnotation(identifier("Array"));
 }
 
 function RestElement() {
@@ -190,13 +214,13 @@ function RestElement() {
 RestElement.validParent = true;
 
 function Func() {
-  return t.genericTypeAnnotation(t.identifier("Function"));
+  return genericTypeAnnotation(identifier("Function"));
 }
 
-const isArrayFrom = t.buildMatchMemberExpression("Array.from");
-const isObjectKeys = t.buildMatchMemberExpression("Object.keys");
-const isObjectValues = t.buildMatchMemberExpression("Object.values");
-const isObjectEntries = t.buildMatchMemberExpression("Object.entries");
+const isArrayFrom = buildMatchMemberExpression("Array.from");
+const isObjectKeys = buildMatchMemberExpression("Object.keys");
+const isObjectValues = buildMatchMemberExpression("Object.values");
+const isObjectEntries = buildMatchMemberExpression("Object.entries");
 
 function CallExpression() {
   const {
@@ -204,11 +228,11 @@ function CallExpression() {
   } = this.node;
 
   if (isObjectKeys(callee)) {
-    return t.arrayTypeAnnotation(t.stringTypeAnnotation());
+    return arrayTypeAnnotation(stringTypeAnnotation());
   } else if (isArrayFrom(callee) || isObjectValues(callee)) {
-    return t.arrayTypeAnnotation(t.anyTypeAnnotation());
+    return arrayTypeAnnotation(anyTypeAnnotation());
   } else if (isObjectEntries(callee)) {
-    return t.arrayTypeAnnotation(t.tupleTypeAnnotation([t.stringTypeAnnotation(), t.anyTypeAnnotation()]));
+    return arrayTypeAnnotation(tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]));
   }
 
   return resolveCall(this.get("callee"));
@@ -224,9 +248,9 @@ function resolveCall(callee) {
   if (callee.isFunction()) {
     if (callee.is("async")) {
       if (callee.is("generator")) {
-        return t.genericTypeAnnotation(t.identifier("AsyncIterator"));
+        return genericTypeAnnotation(identifier("AsyncIterator"));
       } else {
-        return t.genericTypeAnnotation(t.identifier("Promise"));
+        return genericTypeAnnotation(identifier("Promise"));
       }
     } else {
       if (callee.node.returnType) {

package/lib/path/introspection.js

@@ -24,10 +24,22 @@ exports.isConstantExpression = isConstantExpression;
 exports.isInStrictMode = isInStrictMode;
 exports.is = void 0;
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
+
+const {
+  STATEMENT_OR_BLOCK_KEYS,
+  VISITOR_KEYS,
+  isBlockStatement,
+  isExpression,
+  isIdentifier,
+  isLiteral,
+  isStringLiteral,
+  isType,
+  matchesPattern: _matchesPattern
+} = _t;
 
 function matchesPattern(pattern, allowPartial) {
-  return t.matchesPattern(this.node, pattern, allowPartial);
+  return _matchesPattern(this.node, pattern, allowPartial);
 }
 
 function has(key) {
@@ -56,7 +68,7 @@ function equals(key, value) {
 }
 
 function isNodeType(type) {
-  return t.isType(this.type, type);
+  return isType(this.type, type);
 }
 
 function canHaveVariableDeclarationOrExpression() {
@@ -69,9 +81,9 @@ function canSwapBetweenExpressionAndStatement(replacement) {
   }
 
   if (this.isExpression()) {
-    return t.isBlockStatement(replacement);
+    return isBlockStatement(replacement);
   } else if (this.isBlockStatement()) {
-    return t.isExpression(replacement);
+    return isExpression(replacement);
   }
 
   return false;
@@ -99,16 +111,16 @@ function isCompletionRecord(allowInsideFunction) {
 }
 
 function isStatementOrBlock() {
-  if (this.parentPath.isLabeledStatement() || t.isBlockStatement(this.container)) {
+  if (this.parentPath.isLabeledStatement() || isBlockStatement(this.container)) {
     return false;
   } else {
-    return t.STATEMENT_OR_BLOCK_KEYS.includes(this.key);
+    return STATEMENT_OR_BLOCK_KEYS.includes(this.key);
   }
 }
 
 function referencesImport(moduleSource, importName) {
   if (!this.isReferencedIdentifier()) {
-    if ((this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? t.isStringLiteral(this.node.property, {
+    if ((this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? isStringLiteral(this.node.property, {
       value: importName
     }) : this.node.property.name === importName)) {
       const object = this.get("object");
@@ -138,7 +150,7 @@ function referencesImport(moduleSource, importName) {
     return true;
   }
 
-  if (path.isImportSpecifier() && t.isIdentifier(path.node.imported, {
+  if (path.isImportSpecifier() && isIdentifier(path.node.imported, {
     name: importName
   })) {
     return true;
@@ -266,7 +278,7 @@ function _guessExecutionStatusRelativeTo(target) {
     return divergence.target.key > divergence.this.key ? "before" : "after";
   }
 
-  const keys = t.VISITOR_KEYS[commonPath.type];
+  const keys = VISITOR_KEYS[commonPath.type];
   const keyPosition = {
     this: keys.indexOf(divergence.this.parentKey),
     target: keys.indexOf(divergence.target.parentKey)
@@ -339,7 +351,7 @@ function _resolve(dangerous, resolved) {
     return this.get("expression").resolve(dangerous, resolved);
   } else if (dangerous && this.isMemberExpression()) {
     const targetKey = this.toComputedKey();
-    if (!t.isLiteral(targetKey)) return;
+    if (!isLiteral(targetKey)) return;
     const targetName = targetKey.value;
     const target = this.get("object").resolve(dangerous, resolved);
 

package/lib/path/lib/hoister.js

@@ -5,11 +5,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var t = require("@babel/types");
-
+var _t = require("@babel/types");
+
+var _t2 = _t;
+const {
+  react
+} = _t;
+const {
+  cloneNode,
+  jsxExpressionContainer,
+  variableDeclaration,
+  variableDeclarator
+} = _t2;
 const referenceVisitor = {
   ReferencedIdentifier(path, state) {
-    if (path.isJSXIdentifier() && t.react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
+    if (path.isJSXIdentifier() && react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
       return;
     }
 
@@ -178,16 +188,16 @@ class PathHoister {
     if (!attachTo) return;
     if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;
     let uid = attachTo.scope.generateUidIdentifier("ref");
-    const declarator = t.variableDeclarator(uid, this.path.node);
+    const declarator = variableDeclarator(uid, this.path.node);
     const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
-    const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : t.variableDeclaration("var", [declarator])]);
+    const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : variableDeclaration("var", [declarator])]);
     const parent = this.path.parentPath;
 
     if (parent.isJSXElement() && this.path.container === parent.node.children) {
-      uid = t.jsxExpressionContainer(uid);
+      uid = jsxExpressionContainer(uid);
     }
 
-    this.path.replaceWith(t.cloneNode(uid));
+    this.path.replaceWith(cloneNode(uid));
     return attachTo.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init");
   }