@babel/traverse 7.18.6 → 7.18.10

package/lib/path/conversion.js

@@ -119,6 +119,10 @@ function unwrapFunctionEnvironment() {
   hoistFunctionEnvironment(this);
 }
 
+function setType(path, type) {
+  path.node.type = type;
+}
+
 function arrowFunctionToExpression({
   allowInsertArrow = true,
   specCompliant = false,
@@ -133,7 +137,7 @@ function arrowFunctionToExpression({
     fnPath: fn
   } = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow);
   fn.ensureBlock();
-  fn.node.type = "FunctionExpression";
+  setType(fn, "FunctionExpression");
 
   if (!noNewArrows) {
     const checkBinding = thisBinding ? null : fn.scope.generateUidIdentifier("arrowCheckId");
@@ -147,7 +151,10 @@ function arrowFunctionToExpression({
 
     fn.get("body").unshiftContainer("body", expressionStatement(callExpression(this.hub.addHelper("newArrowCheck"), [thisExpression(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)])));
     fn.replaceWith(callExpression(memberExpression((0, _helperFunctionName.default)(this, true) || fn.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression()]));
+    return fn.get("callee.object");
   }
+
+  return fn;
 }
 
 const getSuperCallsVisitor = (0, _visitors.merge)([{

package/lib/path/generated/validators.js

@@ -1,5 +0,0 @@
-"use strict";
-
-var t = require("@babel/types");
-
-var _index = require("../index");

package/lib/path/index.js

@@ -43,6 +43,8 @@ var NodePath_family = require("./family");
 
 var NodePath_comments = require("./comments");
 
+var NodePath_virtual_types_validator = require("./lib/virtual-types-validator");
+
 const {
   validate
 } = _t;
@@ -246,14 +248,11 @@ for (const type of t.TYPES) {
   };
 }
 
+Object.assign(NodePath.prototype, NodePath_virtual_types_validator);
+
 for (const type of Object.keys(virtualTypes)) {
   if (type[0] === "_") continue;
-  if (t.TYPES.indexOf(type) < 0) t.TYPES.push(type);
-  const virtualType = virtualTypes[type];
-
-  NodePath.prototype[`is${type}`] = function (opts) {
-    return virtualType.checkPath(this, opts);
-  };
+  if (!t.TYPES.includes(type)) t.TYPES.push(type);
 }
 
 var _default = NodePath;

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/lib/path/introspection.js

@@ -441,13 +441,20 @@ function isInStrictMode() {
       sourceType: "module"
     })) return true;
     if (path.isClass()) return true;
-    if (!path.isProgram() && !path.isFunction()) return false;
 
     if (path.isArrowFunctionExpression() && !path.get("body").isBlockStatement()) {
       return false;
     }
 
-    const body = path.isFunction() ? path.node.body : path.node;
+    let body;
+
+    if (path.isFunction()) {
+      body = path.node.body;
+    } else if (path.isProgram()) {
+      body = path.node;
+    } else {
+      return false;
+    }
 
     for (const directive of body.directives) {
       if (directive.value.value === "use strict") {

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

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBindingIdentifier = isBindingIdentifier;
+exports.isBlockScoped = isBlockScoped;
+exports.isExistentialTypeParam = isExistentialTypeParam;
+exports.isExpression = isExpression;
+exports.isFlow = isFlow;
+exports.isForAwaitStatement = isForAwaitStatement;
+exports.isGenerated = isGenerated;
+exports.isNumericLiteralTypeAnnotation = isNumericLiteralTypeAnnotation;
+exports.isPure = isPure;
+exports.isReferenced = isReferenced;
+exports.isReferencedIdentifier = isReferencedIdentifier;
+exports.isReferencedMemberExpression = isReferencedMemberExpression;
+exports.isRestProperty = isRestProperty;
+exports.isScope = isScope;
+exports.isSpreadProperty = isSpreadProperty;
+exports.isStatement = isStatement;
+exports.isUser = isUser;
+exports.isVar = isVar;
+
+var _t = require("@babel/types");
+
+const {
+  isBinding,
+  isBlockScoped: nodeIsBlockScoped,
+  isExportDeclaration,
+  isExpression: nodeIsExpression,
+  isFlow: nodeIsFlow,
+  isForStatement,
+  isForXStatement,
+  isIdentifier,
+  isImportDeclaration,
+  isImportSpecifier,
+  isJSXIdentifier,
+  isJSXMemberExpression,
+  isMemberExpression,
+  isRestElement: nodeIsRestElement,
+  isReferenced: nodeIsReferenced,
+  isScope: nodeIsScope,
+  isStatement: nodeIsStatement,
+  isVar: nodeIsVar,
+  isVariableDeclaration,
+  react
+} = _t;
+const {
+  isCompatTag
+} = react;
+
+function isReferencedIdentifier(opts) {
+  const {
+    node,
+    parent
+  } = this;
+
+  if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {
+    if (isJSXIdentifier(node, opts)) {
+      if (isCompatTag(node.name)) return false;
+    } else {
+      return false;
+    }
+  }
+
+  return nodeIsReferenced(node, parent, this.parentPath.parent);
+}
+
+function isReferencedMemberExpression() {
+  const {
+    node,
+    parent
+  } = this;
+  return isMemberExpression(node) && nodeIsReferenced(node, parent);
+}
+
+function isBindingIdentifier() {
+  const {
+    node,
+    parent
+  } = this;
+  const grandparent = this.parentPath.parent;
+  return isIdentifier(node) && isBinding(node, parent, grandparent);
+}
+
+function isStatement() {
+  const {
+    node,
+    parent
+  } = this;
+
+  if (nodeIsStatement(node)) {
+    if (isVariableDeclaration(node)) {
+      if (isForXStatement(parent, {
+        left: node
+      })) return false;
+      if (isForStatement(parent, {
+        init: node
+      })) return false;
+    }
+
+    return true;
+  } else {
+    return false;
+  }
+}
+
+function isExpression() {
+  if (this.isIdentifier()) {
+    return this.isReferencedIdentifier();
+  } else {
+    return nodeIsExpression(this.node);
+  }
+}
+
+function isScope() {
+  return nodeIsScope(this.node, this.parent);
+}
+
+function isReferenced() {
+  return nodeIsReferenced(this.node, this.parent);
+}
+
+function isBlockScoped() {
+  return nodeIsBlockScoped(this.node);
+}
+
+function isVar() {
+  return nodeIsVar(this.node);
+}
+
+function isUser() {
+  return this.node && !!this.node.loc;
+}
+
+function isGenerated() {
+  return !this.isUser();
+}
+
+function isPure(constantsOnly) {
+  return this.scope.isPure(this.node, constantsOnly);
+}
+
+function isFlow() {
+  const {
+    node
+  } = this;
+
+  if (nodeIsFlow(node)) {
+    return true;
+  } else if (isImportDeclaration(node)) {
+    return node.importKind === "type" || node.importKind === "typeof";
+  } else if (isExportDeclaration(node)) {
+    return node.exportKind === "type";
+  } else if (isImportSpecifier(node)) {
+    return node.importKind === "type" || node.importKind === "typeof";
+  } else {
+    return false;
+  }
+}
+
+function isRestProperty() {
+  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern();
+}
+
+function isSpreadProperty() {
+  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression();
+}
+
+function isForAwaitStatement() {
+  return isForStatement(this.node, {
+    await: true
+  });
+}
+
+function isExistentialTypeParam() {
+  throw new Error("`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.");
+}
+
+function isNumericLiteralTypeAnnotation() {
+  throw new Error("`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.");
+}

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

@@ -4,227 +4,39 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Var = exports.User = exports.Statement = exports.SpreadProperty = exports.Scope = exports.RestProperty = exports.ReferencedMemberExpression = exports.ReferencedIdentifier = exports.Referenced = exports.Pure = exports.NumericLiteralTypeAnnotation = exports.Generated = exports.ForAwaitStatement = exports.Flow = exports.Expression = exports.ExistentialTypeParam = exports.BlockScoped = exports.BindingIdentifier = void 0;
-
-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"],
-
-  checkPath(path, opts) {
-    const {
-      node,
-      parent
-    } = path;
-
-    if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {
-      if (isJSXIdentifier(node, opts)) {
-        if (isCompatTag(node.name)) return false;
-      } else {
-        return false;
-      }
-    }
-
-    return isReferenced(node, parent, path.parentPath.parent);
-  }
-
-};
+const ReferencedIdentifier = ["Identifier", "JSXIdentifier"];
 exports.ReferencedIdentifier = ReferencedIdentifier;
-const ReferencedMemberExpression = {
-  types: ["MemberExpression"],
-
-  checkPath({
-    node,
-    parent
-  }) {
-    return isMemberExpression(node) && isReferenced(node, parent);
-  }
-
-};
+const ReferencedMemberExpression = ["MemberExpression"];
 exports.ReferencedMemberExpression = ReferencedMemberExpression;
-const BindingIdentifier = {
-  types: ["Identifier"],
-
-  checkPath(path) {
-    const {
-      node,
-      parent
-    } = path;
-    const grandparent = path.parentPath.parent;
-    return isIdentifier(node) && isBinding(node, parent, grandparent);
-  }
-
-};
+const BindingIdentifier = ["Identifier"];
 exports.BindingIdentifier = BindingIdentifier;
-const Statement = {
-  types: ["Statement"],
-
-  checkPath({
-    node,
-    parent
-  }) {
-    if (isStatement(node)) {
-      if (isVariableDeclaration(node)) {
-        if (isForXStatement(parent, {
-          left: node
-        })) return false;
-        if (isForStatement(parent, {
-          init: node
-        })) return false;
-      }
-
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-};
+const Statement = ["Statement"];
 exports.Statement = Statement;
-const Expression = {
-  types: ["Expression"],
-
-  checkPath(path) {
-    if (path.isIdentifier()) {
-      return path.isReferencedIdentifier();
-    } else {
-      return isExpression(path.node);
-    }
-  }
-
-};
+const Expression = ["Expression"];
 exports.Expression = Expression;
-const Scope = {
-  types: ["Scopable", "Pattern"],
-
-  checkPath(path) {
-    return isScope(path.node, path.parent);
-  }
-
-};
+const Scope = ["Scopable", "Pattern"];
 exports.Scope = Scope;
-const Referenced = {
-  checkPath(path) {
-    return isReferenced(path.node, path.parent);
-  }
-
-};
+const Referenced = null;
 exports.Referenced = Referenced;
-const BlockScoped = {
-  checkPath(path) {
-    return isBlockScoped(path.node);
-  }
-
-};
+const BlockScoped = null;
 exports.BlockScoped = BlockScoped;
-const Var = {
-  types: ["VariableDeclaration"],
-
-  checkPath(path) {
-    return isVar(path.node);
-  }
-
-};
+const Var = ["VariableDeclaration"];
 exports.Var = Var;
-const User = {
-  checkPath(path) {
-    return path.node && !!path.node.loc;
-  }
-
-};
+const User = null;
 exports.User = User;
-const Generated = {
-  checkPath(path) {
-    return !path.isUser();
-  }
-
-};
+const Generated = null;
 exports.Generated = Generated;
-const Pure = {
-  checkPath(path, constantsOnly) {
-    return path.scope.isPure(path.node, constantsOnly);
-  }
-
-};
+const Pure = null;
 exports.Pure = Pure;
-const Flow = {
-  types: ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"],
-
-  checkPath({
-    node
-  }) {
-    if (isFlow(node)) {
-      return true;
-    } else if (isImportDeclaration(node)) {
-      return node.importKind === "type" || node.importKind === "typeof";
-    } else if (isExportDeclaration(node)) {
-      return node.exportKind === "type";
-    } else if (isImportSpecifier(node)) {
-      return node.importKind === "type" || node.importKind === "typeof";
-    } else {
-      return false;
-    }
-  }
-
-};
+const Flow = ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"];
 exports.Flow = Flow;
-const RestProperty = {
-  types: ["RestElement"],
-
-  checkPath(path) {
-    return path.parentPath && path.parentPath.isObjectPattern();
-  }
-
-};
+const RestProperty = ["RestElement"];
 exports.RestProperty = RestProperty;
-const SpreadProperty = {
-  types: ["RestElement"],
-
-  checkPath(path) {
-    return path.parentPath && path.parentPath.isObjectExpression();
-  }
-
-};
+const SpreadProperty = ["RestElement"];
 exports.SpreadProperty = SpreadProperty;
-const ExistentialTypeParam = {
-  types: ["ExistsTypeAnnotation"]
-};
+const ExistentialTypeParam = ["ExistsTypeAnnotation"];
 exports.ExistentialTypeParam = ExistentialTypeParam;
-const NumericLiteralTypeAnnotation = {
-  types: ["NumberLiteralTypeAnnotation"]
-};
+const NumericLiteralTypeAnnotation = ["NumberLiteralTypeAnnotation"];
 exports.NumericLiteralTypeAnnotation = NumericLiteralTypeAnnotation;
-const ForAwaitStatement = {
-  types: ["ForOfStatement"],
-
-  checkPath({
-    node
-  }) {
-    return node.await === true;
-  }
-
-};
+const ForAwaitStatement = ["ForOfStatement"];
 exports.ForAwaitStatement = ForAwaitStatement;

package/lib/types.js

@@ -1,5 +1,3 @@
 "use strict";
 
-var _index = require("./index");
-
-var _virtualTypes = require("./path/generated/virtual-types");
+var _index = require("./index");

package/lib/visitors.js

@@ -17,6 +17,10 @@ const {
   TYPES
 } = _t;
 
+function isVirtualType(type) {
+  return type in virtualTypes;
+}
+
 function explode(visitor) {
   if (visitor._exploded) return visitor;
   visitor._exploded = true;
@@ -40,18 +44,18 @@ function explode(visitor) {
 
   for (const nodeType of Object.keys(visitor)) {
     if (shouldIgnoreKey(nodeType)) continue;
-    const wrapper = virtualTypes[nodeType];
-    if (!wrapper) continue;
+    if (!isVirtualType(nodeType)) continue;
     const fns = visitor[nodeType];
 
     for (const type of Object.keys(fns)) {
-      fns[type] = wrapCheck(wrapper, fns[type]);
+      fns[type] = wrapCheck(nodeType, fns[type]);
     }
 
     delete visitor[nodeType];
+    const types = virtualTypes[nodeType];
 
-    if (wrapper.types) {
-      for (const type of wrapper.types) {
+    if (types !== null) {
+      for (const type of types) {
         if (visitor[type]) {
           mergePair(visitor[type], fns);
         } else {
@@ -212,9 +216,9 @@ function ensureCallbackArrays(obj) {
   if (obj.exit && !Array.isArray(obj.exit)) obj.exit = [obj.exit];
 }
 
-function wrapCheck(wrapper, fn) {
+function wrapCheck(nodeType, fn) {
   const newFn = function (path) {
-    if (wrapper.checkPath(path)) {
+    if (path[`is${nodeType}`]()) {
       return fn.apply(this, arguments);
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babel/traverse",
-  "version": "7.18.6",
+  "version": "7.18.10",
   "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/helper-environment-visitor": "^7.18.6",
-    "@babel/helper-function-name": "^7.18.6",
+    "@babel/generator": "^7.18.10",
+    "@babel/helper-environment-visitor": "^7.18.9",
+    "@babel/helper-function-name": "^7.18.9",
     "@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.10",
+    "@babel/types": "^7.18.10",
     "debug": "^4.1.0",
     "globals": "^11.1.0"
   },

package/scripts/generators/validators.js

@@ -1,46 +1,26 @@
 import * as t from "@babel/types";
-import * as virtualTypes from "../../lib/path/lib/virtual-types.js";
 
 export default function generateValidators() {
   let output = `/*
  * This file is auto-generated! Do not modify it directly.
  * To re-generate run 'make build'
  */
-import * as t from "@babel/types";
-import NodePath from "../index";
-import type { VirtualTypeAliases } from "./virtual-types";
+import type * as t from "@babel/types";
+import type NodePath from "../index";
+import type { VirtualTypeNodePathValidators } from "../lib/virtual-types-validator";
 
-export interface NodePathValidators {
+interface BaseNodePathValidators {
 `;
 
   for (const type of [...t.TYPES].sort()) {
-    output += `is${type}(opts?: object): this is NodePath<t.${type}>;`;
-  }
-
-  for (const type of Object.keys(virtualTypes)) {
-    // TODO: Remove this check once we stop compiling to CJS
-    if (type === "default" || type === "__esModule") continue;
-
-    const { types } = virtualTypes[type];
-    if (type[0] === "_") continue;
-    if (t.NODE_FIELDS[type] || t.FLIPPED_ALIAS_KEYS[type]) {
-      output += `is${type}(opts?: object): this is NodePath<t.${type}>;`;
-    } else if (types /* in VirtualTypeAliases */) {
-      output += `is${type}(opts?: object): this is NodePath<VirtualTypeAliases["${type}"]>;`;
-    } else if (type === "Pure") {
-      output += `isPure(constantsOnly?: boolean): boolean;`;
-    } else {
-      // if it don't have types, then VirtualTypeAliases[type] is t.Node
-      // which TS marked as always true
-      // eg. if (path.isBlockScope()) return;
-      //     path resolved to `never` here
-      // so we have to return boolean instead of this is NodePath<t.Node> here
-      output += `is${type}(opts?: object): boolean;`;
-    }
+    output += `is${type}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & t.${type}>;`;
   }
 
   output += `
 }
+
+export interface NodePathValidators
+  extends BaseNodePathValidators, VirtualTypeNodePathValidators {}
 `;
 
   return output;

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

@@ -1,3 +0,0 @@
-"use strict";
-
-var t = require("@babel/types");

package/scripts/generators/virtual-types.js

@@ -1,27 +0,0 @@
-import * as virtualTypes from "../../lib/path/lib/virtual-types.js";
-
-export default function generateValidators() {
-  let output = `/*
- * This file is auto-generated! Do not modify it directly.
- * To re-generate run 'make build'
- */
-import * as t from "@babel/types";
-
-export interface VirtualTypeAliases {
-`;
-
-  for (const type of Object.keys(virtualTypes)) {
-    // TODO: Remove this check once we stop compiling to CJS
-    if (type === "default" || type === "__esModule") continue;
-
-    output += `  ${type}: ${(virtualTypes[type].types || ["Node"])
-      .map(t => `t.${t}`)
-      .join(" | ")};`;
-  }
-
-  output += `
-}
-`;
-
-  return output;
-}