@babel/traverse 7.18.9 → 7.18.13

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/evaluation.js

@@ -267,6 +267,11 @@ function _evaluate(path, state) {
         state.confident = leftConfident && (!left || rightConfident);
         if (!state.confident) return;
         return left && right;
+
+      case "??":
+        state.confident = leftConfident && (left != null || rightConfident);
+        if (!state.confident) return;
+        return left != null ? left : right;
     }
   }
 

package/lib/path/family.js

@@ -402,6 +402,6 @@ function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
   return ids;
 }
 
-function getOuterBindingIdentifierPaths(duplicates) {
+function getOuterBindingIdentifierPaths(duplicates = false) {
   return this.getBindingIdentifierPaths(duplicates, true);
 }

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/lib/removal-hooks.js

@@ -30,7 +30,7 @@ const hooks = [function (self, parent) {
     return true;
   }
 }, function (self, parent) {
-  if (parent.isIfStatement() && (self.key === "consequent" || self.key === "alternate") || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
+  if (parent.isIfStatement() && self.key === "consequent" || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
     self.replaceWith({
       type: "BlockStatement",
       body: []

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 {
@@ -155,7 +159,7 @@ function merge(visitors, states = [], wrapper) {
         visitorType = wrapWithStateOrWrapper(visitorType, state, wrapper);
       }
 
-      const nodeVisitor = rootVisitor[type] = rootVisitor[type] || {};
+      const nodeVisitor = rootVisitor[type] || (rootVisitor[type] = {});
       mergePair(nodeVisitor, visitorType);
     }
   }
@@ -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.9",
+  "version": "7.18.13",
   "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.9",
+    "@babel/generator": "^7.18.13",
     "@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.9",
-    "@babel/types": "^7.18.9",
+    "@babel/parser": "^7.18.13",
+    "@babel/types": "^7.18.13",
     "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}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & 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}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & t.${type}>;`;
-    } else if (types /* in VirtualTypeAliases */) {
-      output += `is${type}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & 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 += `
 }
+
+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;
-}