@babel/traverse 7.18.6 → 7.18.8

package/lib/path/inference/index.js

@@ -17,6 +17,7 @@ var _t = require("@babel/types");
 const {
   anyTypeAnnotation,
   isAnyTypeAnnotation,
+  isArrayTypeAnnotation,
   isBooleanTypeAnnotation,
   isEmptyTypeAnnotation,
   isFlowBaseAnnotation,
@@ -25,6 +26,10 @@ const {
   isMixedTypeAnnotation,
   isNumberTypeAnnotation,
   isStringTypeAnnotation,
+  isTSArrayType,
+  isTSTypeAnnotation,
+  isTSTypeReference,
+  isTupleTypeAnnotation,
   isTypeAnnotation,
   isUnionTypeAnnotation,
   isVoidTypeAnnotation,
@@ -40,7 +45,11 @@ function getTypeAnnotation() {
   }
 
   type = this._getTypeAnnotation() || anyTypeAnnotation();
-  if (isTypeAnnotation(type)) type = type.typeAnnotation;
+
+  if (isTypeAnnotation(type) || isTSTypeAnnotation(type)) {
+    type = type.typeAnnotation;
+  }
+
   this.setData("typeAnnotation", type);
   return type;
 }
@@ -156,7 +165,16 @@ function baseTypeStrictlyMatches(rightArg) {
 
 function isGenericType(genericName) {
   const type = this.getTypeAnnotation();
+
+  if (genericName === "Array") {
+    if (isTSArrayType(type) || isArrayTypeAnnotation(type) || isTupleTypeAnnotation(type)) {
+      return true;
+    }
+  }
+
   return isGenericTypeAnnotation(type) && isIdentifier(type.id, {
     name: genericName
+  }) || isTSTypeReference(type) && isIdentifier(type.typeName, {
+    name: genericName
   });
 }

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

@@ -7,13 +7,11 @@ exports.default = _default;
 
 var _t = require("@babel/types");
 
+var _util = require("./util");
+
 const {
   BOOLEAN_NUMBER_BINARY_OPERATORS,
-  createFlowUnionType,
-  createTSUnionType,
   createTypeAnnotationBasedOnTypeof,
-  createUnionTypeAnnotation,
-  isTSTypeAnnotation,
   numberTypeAnnotation,
   voidTypeAnnotation
 } = _t;
@@ -61,15 +59,7 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
     return;
   }
 
-  if (isTSTypeAnnotation(types[0]) && createTSUnionType) {
-    return createTSUnionType(types);
-  }
-
-  if (createFlowUnionType) {
-    return createFlowUnionType(types);
-  }
-
-  return createUnionTypeAnnotation(types);
+  return (0, _util.createUnionType)(types);
 }
 
 function getConstantViolationsBefore(binding, path, functions) {
@@ -182,22 +172,8 @@ function getConditionalAnnotation(binding, path, name) {
   }
 
   if (types.length) {
-    if (isTSTypeAnnotation(types[0]) && createTSUnionType) {
-      return {
-        typeAnnotation: createTSUnionType(types),
-        ifStatement
-      };
-    }
-
-    if (createFlowUnionType) {
-      return {
-        typeAnnotation: createFlowUnionType(types),
-        ifStatement
-      };
-    }
-
     return {
-      typeAnnotation: createUnionTypeAnnotation(types),
+      typeAnnotation: (0, _util.createUnionType)(types),
       ifStatement
     };
   }

package/lib/path/inference/inferers.js

@@ -26,6 +26,8 @@ exports.RegExpLiteral = RegExpLiteral;
 exports.RestElement = RestElement;
 exports.SequenceExpression = SequenceExpression;
 exports.StringLiteral = StringLiteral;
+exports.TSAsExpression = TSAsExpression;
+exports.TSNonNullExpression = TSNonNullExpression;
 exports.TaggedTemplateExpression = TaggedTemplateExpression;
 exports.TemplateLiteral = TemplateLiteral;
 exports.TypeCastExpression = TypeCastExpression;
@@ -37,6 +39,8 @@ var _t = require("@babel/types");
 
 var _infererReference = require("./inferer-reference");
 
+var _util = require("./util");
+
 const {
   BOOLEAN_BINARY_OPERATORS,
   BOOLEAN_UNARY_OPERATORS,
@@ -47,37 +51,20 @@ const {
   arrayTypeAnnotation,
   booleanTypeAnnotation,
   buildMatchMemberExpression,
-  createFlowUnionType,
-  createTSUnionType,
-  createUnionTypeAnnotation,
   genericTypeAnnotation,
   identifier,
-  isTSTypeAnnotation,
   nullLiteralTypeAnnotation,
   numberTypeAnnotation,
   stringTypeAnnotation,
   tupleTypeAnnotation,
   unionTypeAnnotation,
-  voidTypeAnnotation
+  voidTypeAnnotation,
+  isIdentifier
 } = _t;
 
 function VariableDeclarator() {
-  var _type;
-
-  const id = this.get("id");
-  if (!id.isIdentifier()) return;
-  const init = this.get("init");
-  let type = init.getTypeAnnotation();
-
-  if (((_type = type) == null ? void 0 : _type.type) === "AnyTypeAnnotation") {
-    if (init.isCallExpression() && init.get("callee").isIdentifier({
-      name: "Array"
-    }) && !init.scope.hasBinding("Array", true)) {
-      type = ArrayExpression();
-    }
-  }
-
-  return type;
+  if (!this.get("id").isIdentifier()) return;
+  return this.get("init").getTypeAnnotation();
 }
 
 function TypeCastExpression(node) {
@@ -86,6 +73,16 @@ function TypeCastExpression(node) {
 
 TypeCastExpression.validParent = true;
 
+function TSAsExpression(node) {
+  return node.typeAnnotation;
+}
+
+TSAsExpression.validParent = true;
+
+function TSNonNullExpression() {
+  return this.get("expression").getTypeAnnotation();
+}
+
 function NewExpression(node) {
   if (node.callee.type === "Identifier") {
     return genericTypeAnnotation(node.callee);
@@ -133,30 +130,12 @@ function BinaryExpression(node) {
 
 function LogicalExpression() {
   const argumentTypes = [this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()];
-
-  if (isTSTypeAnnotation(argumentTypes[0]) && createTSUnionType) {
-    return createTSUnionType(argumentTypes);
-  }
-
-  if (createFlowUnionType) {
-    return createFlowUnionType(argumentTypes);
-  }
-
-  return createUnionTypeAnnotation(argumentTypes);
+  return (0, _util.createUnionType)(argumentTypes);
 }
 
 function ConditionalExpression() {
   const argumentTypes = [this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()];
-
-  if (isTSTypeAnnotation(argumentTypes[0]) && createTSUnionType) {
-    return createTSUnionType(argumentTypes);
-  }
-
-  if (createFlowUnionType) {
-    return createFlowUnionType(argumentTypes);
-  }
-
-  return createUnionTypeAnnotation(argumentTypes);
+  return (0, _util.createUnionType)(argumentTypes);
 }
 
 function SequenceExpression() {
@@ -229,7 +208,9 @@ function CallExpression() {
 
   if (isObjectKeys(callee)) {
     return arrayTypeAnnotation(stringTypeAnnotation());
-  } else if (isArrayFrom(callee) || isObjectValues(callee)) {
+  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier(callee, {
+    name: "Array"
+  })) {
     return arrayTypeAnnotation(anyTypeAnnotation());
   } else if (isObjectEntries(callee)) {
     return arrayTypeAnnotation(tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]));
@@ -246,14 +227,20 @@ function resolveCall(callee) {
   callee = callee.resolve();
 
   if (callee.isFunction()) {
-    if (callee.is("async")) {
-      if (callee.is("generator")) {
+    const {
+      node
+    } = callee;
+
+    if (node.async) {
+      if (node.generator) {
         return genericTypeAnnotation(identifier("AsyncIterator"));
       } else {
         return genericTypeAnnotation(identifier("Promise"));
       }
     } else {
-      if (callee.node.returnType) {
+      if (node.generator) {
+        return genericTypeAnnotation(identifier("Iterator"));
+      } else if (callee.node.returnType) {
         return callee.node.returnType;
       } else {}
     }

package/lib/path/inference/util.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createUnionType = createUnionType;
+
+var _t = require("@babel/types");
+
+const {
+  createFlowUnionType,
+  createTSUnionType,
+  createUnionTypeAnnotation,
+  isFlowType,
+  isTSType
+} = _t;
+
+function createUnionType(types) {
+  {
+    if (isFlowType(types[0])) {
+      if (createFlowUnionType) {
+        return createFlowUnionType(types);
+      }
+
+      return createUnionTypeAnnotation(types);
+    } else {
+      if (createTSUnionType) {
+        return createTSUnionType(types);
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babel/traverse",
-  "version": "7.18.6",
+  "version": "7.18.8",
   "description": "The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes",
   "author": "The Babel Team (https://babel.dev/team)",
   "homepage": "https://babel.dev/docs/en/next/babel-traverse",
@@ -17,13 +17,13 @@
   "main": "./lib/index.js",
   "dependencies": {
     "@babel/code-frame": "^7.18.6",
-    "@babel/generator": "^7.18.6",
+    "@babel/generator": "^7.18.7",
     "@babel/helper-environment-visitor": "^7.18.6",
     "@babel/helper-function-name": "^7.18.6",
     "@babel/helper-hoist-variables": "^7.18.6",
     "@babel/helper-split-export-declaration": "^7.18.6",
-    "@babel/parser": "^7.18.6",
-    "@babel/types": "^7.18.6",
+    "@babel/parser": "^7.18.8",
+    "@babel/types": "^7.18.8",
     "debug": "^4.1.0",
     "globals": "^11.1.0"
   },