@babel/traverse 7.14.9 → 7.16.3

package/lib/path/family.js

@@ -3,25 +3,32 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getOpposite = getOpposite;
-exports.getCompletionRecords = getCompletionRecords;
-exports.getSibling = getSibling;
-exports.getPrevSibling = getPrevSibling;
-exports.getNextSibling = getNextSibling;
-exports.getAllNextSiblings = getAllNextSiblings;
-exports.getAllPrevSiblings = getAllPrevSiblings;
-exports.get = get;
 exports._getKey = _getKey;
 exports._getPattern = _getPattern;
-exports.getBindingIdentifiers = getBindingIdentifiers;
-exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
+exports.get = get;
+exports.getAllNextSiblings = getAllNextSiblings;
+exports.getAllPrevSiblings = getAllPrevSiblings;
 exports.getBindingIdentifierPaths = getBindingIdentifierPaths;
+exports.getBindingIdentifiers = getBindingIdentifiers;
+exports.getCompletionRecords = getCompletionRecords;
+exports.getNextSibling = getNextSibling;
+exports.getOpposite = getOpposite;
 exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths;
+exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
+exports.getPrevSibling = getPrevSibling;
+exports.getSibling = getSibling;
 
 var _index = require("./index");
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
 
+const {
+  getBindingIdentifiers: _getBindingIdentifiers,
+  getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
+  isDeclaration,
+  numericLiteral,
+  unaryExpression
+} = _t;
 const NORMAL_COMPLETION = 0;
 const BREAK_COMPLETION = 1;
 
@@ -50,7 +57,10 @@ function getOpposite() {
 }
 
 function addCompletionRecords(path, records, context) {
-  if (path) return records.concat(_getCompletionRecords(path, context));
+  if (path) {
+    records.push(..._getCompletionRecords(path, context));
+  }
+
   return records;
 }
 
@@ -79,10 +89,10 @@ function completionRecordForSwitch(cases, records, context) {
       lastNormalCompletions = normalCompletions;
     }
 
-    records = records.concat(breakCompletions);
+    records.push(...breakCompletions);
   }
 
-  records = records.concat(lastNormalCompletions);
+  records.push(...lastNormalCompletions);
   return records;
 }
 
@@ -98,7 +108,7 @@ function replaceBreakStatementInBreakCompletion(completions, reachable) {
       label: null
     })) {
       if (reachable) {
-        c.path.replaceWith(t.unaryExpression("void", t.numericLiteral(0)));
+        c.path.replaceWith(unaryExpression("void", numericLiteral(0)));
       } else {
         c.path.remove();
       }
@@ -107,7 +117,7 @@ function replaceBreakStatementInBreakCompletion(completions, reachable) {
 }
 
 function getStatementListCompletion(paths, context) {
-  let completions = [];
+  const completions = [];
 
   if (context.canHaveBreak) {
     let lastNormalCompletions = [];
@@ -119,8 +129,8 @@ function getStatementListCompletion(paths, context) {
       });
 
       if (path.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) {
-          newContext.shouldPopulateBreak = true;
-        } else {
+        newContext.shouldPopulateBreak = true;
+      } else {
         newContext.shouldPopulateBreak = false;
       }
 
@@ -131,16 +141,16 @@ function getStatementListCompletion(paths, context) {
           label: null
         }))) {
           normalCompletionToBreak(lastNormalCompletions);
-          completions = completions.concat(lastNormalCompletions);
+          completions.push(...lastNormalCompletions);
 
           if (lastNormalCompletions.some(c => c.path.isDeclaration())) {
-            completions = completions.concat(statementCompletions);
+            completions.push(...statementCompletions);
             replaceBreakStatementInBreakCompletion(statementCompletions, true);
           }
 
           replaceBreakStatementInBreakCompletion(statementCompletions, false);
         } else {
-          completions = completions.concat(statementCompletions);
+          completions.push(...statementCompletions);
 
           if (!context.shouldPopulateBreak) {
             replaceBreakStatementInBreakCompletion(statementCompletions, true);
@@ -151,10 +161,21 @@ function getStatementListCompletion(paths, context) {
       }
 
       if (i === paths.length - 1) {
-        completions = completions.concat(statementCompletions);
+        completions.push(...statementCompletions);
       } else {
-        completions = completions.concat(statementCompletions.filter(c => c.type === BREAK_COMPLETION));
-        lastNormalCompletions = statementCompletions.filter(c => c.type === NORMAL_COMPLETION);
+        lastNormalCompletions = [];
+
+        for (let i = 0; i < statementCompletions.length; i++) {
+          const c = statementCompletions[i];
+
+          if (c.type === BREAK_COMPLETION) {
+            completions.push(c);
+          }
+
+          if (c.type === NORMAL_COMPLETION) {
+            lastNormalCompletions.push(c);
+          }
+        }
       }
     }
   } else if (paths.length) {
@@ -162,7 +183,7 @@ function getStatementListCompletion(paths, context) {
       const pathCompletions = _getCompletionRecords(paths[i], context);
 
       if (pathCompletions.length > 1 || pathCompletions.length === 1 && !pathCompletions[0].path.isVariableDeclaration()) {
-        completions = completions.concat(pathCompletions);
+        completions.push(...pathCompletions);
         break;
       }
     }
@@ -178,24 +199,24 @@ function _getCompletionRecords(path, context) {
     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);
+    return addCompletionRecords(path.get("body"), records, context);
   } else if (path.isProgram() || path.isBlockStatement()) {
-    records = records.concat(getStatementListCompletion(path.get("body"), context));
+    return 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);
+    return addCompletionRecords(path.get("body"), records, context);
   } else if (path.isSwitchStatement()) {
-    records = completionRecordForSwitch(path.get("cases"), records, context);
+    return completionRecordForSwitch(path.get("cases"), records, context);
   } else if (path.isSwitchCase()) {
-    records = records.concat(getStatementListCompletion(path.get("consequent"), {
+    return getStatementListCompletion(path.get("consequent"), {
       canHaveBreak: true,
       shouldPopulateBreak: false,
       inCaseClause: true
-    }));
+    });
   } else if (path.isBreakStatement()) {
     records.push(BreakCompletion(path));
   } else {
@@ -313,23 +334,23 @@ function _getPattern(parts, context) {
 }
 
 function getBindingIdentifiers(duplicates) {
-  return t.getBindingIdentifiers(this.node, duplicates);
+  return _getBindingIdentifiers(this.node, duplicates);
 }
 
 function getOuterBindingIdentifiers(duplicates) {
-  return t.getOuterBindingIdentifiers(this.node, duplicates);
+  return _getOuterBindingIdentifiers(this.node, duplicates);
 }
 
 function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
   const path = this;
-  let search = [].concat(path);
+  const search = [path];
   const ids = Object.create(null);
 
   while (search.length) {
     const id = search.shift();
     if (!id) continue;
     if (!id.node) continue;
-    const keys = t.getBindingIdentifiers.keys[id.node.type];
+    const keys = _getBindingIdentifiers.keys[id.node.type];
 
     if (id.isIdentifier()) {
       if (duplicates) {
@@ -346,7 +367,7 @@ function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
     if (id.isExportDeclaration()) {
       const declaration = id.get("declaration");
 
-      if (declaration.isDeclaration()) {
+      if (isDeclaration(declaration)) {
         search.push(declaration);
       }
 
@@ -369,8 +390,10 @@ function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
         const key = keys[i];
         const child = id.get(key);
 
-        if (Array.isArray(child) || child.node) {
-          search = search.concat(child);
+        if (Array.isArray(child)) {
+          search.push(...child);
+        } else if (child.node) {
+          search.push(child);
         }
       }
     }

package/lib/path/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.SHOULD_SKIP = exports.SHOULD_STOP = exports.REMOVED = void 0;
+exports.default = exports.SHOULD_STOP = exports.SHOULD_SKIP = exports.REMOVED = void 0;
 
 var virtualTypes = require("./lib/virtual-types");
 
@@ -13,7 +13,9 @@ var _index = require("../index");
 
 var _scope = require("../scope");
 
-var t = require("@babel/types");
+var _t = require("@babel/types");
+
+var t = _t;
 
 var _cache = require("../cache");
 
@@ -41,6 +43,10 @@ var NodePath_family = require("./family");
 
 var NodePath_comments = require("./comments");
 
+const {
+  validate
+} = _t;
+
 const debug = _debug("babel");
 
 const REMOVED = 1 << 0;
@@ -138,7 +144,7 @@ class NodePath {
   }
 
   set(key, node) {
-    t.validate(this.node, key, node);
+    validate(this.node, key, node);
     this.node[key] = node;
   }
 

package/lib/path/inference/index.js

@@ -3,21 +3,39 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getTypeAnnotation = getTypeAnnotation;
 exports._getTypeAnnotation = _getTypeAnnotation;
-exports.isBaseType = isBaseType;
-exports.couldBeBaseType = couldBeBaseType;
 exports.baseTypeStrictlyMatches = baseTypeStrictlyMatches;
+exports.couldBeBaseType = couldBeBaseType;
+exports.getTypeAnnotation = getTypeAnnotation;
+exports.isBaseType = isBaseType;
 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
     };
   }