@babel/traverse 7.16.0 → 7.16.8

package/lib/index.js

@@ -23,8 +23,6 @@ Object.defineProperty(exports, "Scope", {
 });
 exports.visitors = exports.default = void 0;
 
-var _context = require("./context");
-
 var visitors = require("./visitors");
 
 exports.visitors = visitors;
@@ -33,6 +31,8 @@ var _t = require("@babel/types");
 
 var cache = require("./cache");
 
+var _traverseNode = require("./traverse-node");
+
 var _path = require("./path");
 
 var _scope = require("./scope");
@@ -59,7 +59,7 @@ function traverse(parent, opts = {}, scope, state, parentPath) {
   }
 
   visitors.explode(opts);
-  traverse.node(parent, opts, scope, state, parentPath);
+  (0, _traverseNode.traverseNode)(parent, opts, scope, state, parentPath);
 }
 
 var _default = traverse;
@@ -72,15 +72,8 @@ traverse.cheap = function (node, enter) {
   return traverseFast(node, enter);
 };
 
-traverse.node = function (node, opts, scope, state, parentPath, skipKeys) {
-  const keys = VISITOR_KEYS[node.type];
-  if (!keys) return;
-  const context = new _context.default(scope, opts, state, parentPath);
-
-  for (const key of keys) {
-    if (skipKeys && skipKeys[key]) continue;
-    if (context.visit(node, key)) return;
-  }
+traverse.node = function (node, opts, scope, state, path, skipKeys) {
+  (0, _traverseNode.traverseNode)(node, opts, scope, state, path, skipKeys);
 };
 
 traverse.clearNode = function (node, opts) {

package/lib/path/context.js

@@ -24,9 +24,9 @@ exports.skipKey = skipKey;
 exports.stop = stop;
 exports.visit = visit;
 
-var _index = require("../index");
+var _traverseNode = require("../traverse-node");
 
-var _index2 = require("./index");
+var _index = require("./index");
 
 function call(key) {
   const opts = this.opts;
@@ -104,9 +104,7 @@ function visit() {
 
   restoreContext(this, currentContext);
   this.debug("Recursing into...");
-
-  _index.default.node(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
-
+  this.shouldStop = (0, _traverseNode.traverseNode)(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
   restoreContext(this, currentContext);
   this.call("exit");
   return this.shouldStop;
@@ -125,7 +123,7 @@ function skipKey(key) {
 }
 
 function stop() {
-  this._traverseFlags |= _index2.SHOULD_SKIP | _index2.SHOULD_STOP;
+  this._traverseFlags |= _index.SHOULD_SKIP | _index.SHOULD_STOP;
 }
 
 function setScope() {

package/lib/path/conversion.js

@@ -11,8 +11,12 @@ exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
 
 var _t = require("@babel/types");
 
+var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor");
+
 var _helperFunctionName = require("@babel/helper-function-name");
 
+var _visitors = require("../visitors");
+
 const {
   arrowFunctionExpression,
   assignmentExpression,
@@ -35,6 +39,7 @@ const {
   stringLiteral,
   super: _super,
   thisExpression,
+  toExpression,
   unaryExpression
 } = _t;
 
@@ -121,35 +126,68 @@ function arrowFunctionToExpression({
     throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
   }
 
-  const thisBinding = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow);
-  this.ensureBlock();
-  this.node.type = "FunctionExpression";
+  const {
+    thisBinding,
+    fnPath: fn
+  } = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow);
+  fn.ensureBlock();
+  fn.node.type = "FunctionExpression";
 
   if (!noNewArrows) {
-    const checkBinding = thisBinding ? null : this.parentPath.scope.generateUidIdentifier("arrowCheckId");
+    const checkBinding = thisBinding ? null : fn.scope.generateUidIdentifier("arrowCheckId");
 
     if (checkBinding) {
-      this.parentPath.scope.push({
+      fn.parentPath.scope.push({
         id: checkBinding,
         init: objectExpression([])
       });
     }
 
-    this.get("body").unshiftContainer("body", expressionStatement(callExpression(this.hub.addHelper("newArrowCheck"), [thisExpression(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)])));
-    this.replaceWith(callExpression(memberExpression((0, _helperFunctionName.default)(this, true) || this.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression()]));
+    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()]));
   }
 }
 
+const getSuperCallsVisitor = (0, _visitors.merge)([{
+  CallExpression(child, {
+    allSuperCalls
+  }) {
+    if (!child.get("callee").isSuper()) return;
+    allSuperCalls.push(child);
+  }
+
+}, _helperEnvironmentVisitor.default]);
+
 function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow = true) {
-  const thisEnvFn = fnPath.findParent(p => {
-    return p.isFunction() && !p.isArrowFunctionExpression() || p.isProgram() || p.isClassProperty({
+  let arrowParent;
+  let thisEnvFn = fnPath.findParent(p => {
+    if (p.isArrowFunctionExpression()) {
+      var _arrowParent;
+
+      (_arrowParent = arrowParent) != null ? _arrowParent : arrowParent = p;
+      return false;
+    }
+
+    return p.isFunction() || p.isProgram() || p.isClassProperty({
+      static: false
+    }) || p.isClassPrivateProperty({
       static: false
     });
   });
-  const inConstructor = (thisEnvFn == null ? void 0 : thisEnvFn.node.kind) === "constructor";
+  const inConstructor = thisEnvFn.isClassMethod({
+    kind: "constructor"
+  });
 
-  if (thisEnvFn.isClassProperty()) {
-    throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
+  if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) {
+    if (arrowParent) {
+      thisEnvFn = arrowParent;
+    } else if (allowInsertArrow) {
+      fnPath.replaceWith(callExpression(arrowFunctionExpression([], toExpression(fnPath.node)), []));
+      thisEnvFn = fnPath.get("callee");
+      fnPath = thisEnvFn.get("body");
+    } else {
+      throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
+    }
   }
 
   const {
@@ -166,21 +204,8 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
     }
 
     const allSuperCalls = [];
-    thisEnvFn.traverse({
-      Function(child) {
-        if (child.isArrowFunctionExpression()) return;
-        child.skip();
-      },
-
-      ClassProperty(child) {
-        child.skip();
-      },
-
-      CallExpression(child) {
-        if (!child.get("callee").isSuper()) return;
-        allSuperCalls.push(child);
-      }
-
+    thisEnvFn.traverse(getSuperCallsVisitor, {
+      allSuperCalls
     });
     const superBinding = getSuperBinding(thisEnvFn);
     allSuperCalls.forEach(superCall => {
@@ -271,7 +296,10 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
     }
   }
 
-  return thisBinding;
+  return {
+    thisBinding,
+    fnPath
+  };
 }
 
 function standardizeSuperProperty(superProp) {
@@ -314,27 +342,25 @@ function hasSuperClass(thisEnvFn) {
   return thisEnvFn.isClassMethod() && !!thisEnvFn.parentPath.parentPath.node.superClass;
 }
 
+const assignSuperThisVisitor = (0, _visitors.merge)([{
+  CallExpression(child, {
+    supers,
+    thisBinding
+  }) {
+    if (!child.get("callee").isSuper()) return;
+    if (supers.has(child.node)) return;
+    supers.add(child.node);
+    child.replaceWithMultiple([child.node, assignmentExpression("=", identifier(thisBinding), identifier("this"))]);
+  }
+
+}, _helperEnvironmentVisitor.default]);
+
 function getThisBinding(thisEnvFn, inConstructor) {
   return getBinding(thisEnvFn, "this", thisBinding => {
     if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();
-    const supers = new WeakSet();
-    thisEnvFn.traverse({
-      Function(child) {
-        if (child.isArrowFunctionExpression()) return;
-        child.skip();
-      },
-
-      ClassProperty(child) {
-        child.skip();
-      },
-
-      CallExpression(child) {
-        if (!child.get("callee").isSuper()) return;
-        if (supers.has(child.node)) return;
-        supers.add(child.node);
-        child.replaceWithMultiple([child.node, assignmentExpression("=", identifier(thisBinding), identifier("this"))]);
-      }
-
+    thisEnvFn.traverse(assignSuperThisVisitor, {
+      supers: new WeakSet(),
+      thisBinding
     });
   });
 }
@@ -387,76 +413,89 @@ function getBinding(thisEnvFn, key, init) {
   return data;
 }
 
+const getScopeInformationVisitor = (0, _visitors.merge)([{
+  ThisExpression(child, {
+    thisPaths
+  }) {
+    thisPaths.push(child);
+  },
+
+  JSXIdentifier(child, {
+    thisPaths
+  }) {
+    if (child.node.name !== "this") return;
+
+    if (!child.parentPath.isJSXMemberExpression({
+      object: child.node
+    }) && !child.parentPath.isJSXOpeningElement({
+      name: child.node
+    })) {
+      return;
+    }
+
+    thisPaths.push(child);
+  },
+
+  CallExpression(child, {
+    superCalls
+  }) {
+    if (child.get("callee").isSuper()) superCalls.push(child);
+  },
+
+  MemberExpression(child, {
+    superProps
+  }) {
+    if (child.get("object").isSuper()) superProps.push(child);
+  },
+
+  Identifier(child, {
+    argumentsPaths
+  }) {
+    if (!child.isReferencedIdentifier({
+      name: "arguments"
+    })) return;
+    let curr = child.scope;
+
+    do {
+      if (curr.hasOwnBinding("arguments")) {
+        curr.rename("arguments");
+        return;
+      }
+
+      if (curr.path.isFunction() && !curr.path.isArrowFunctionExpression()) {
+        break;
+      }
+    } while (curr = curr.parent);
+
+    argumentsPaths.push(child);
+  },
+
+  MetaProperty(child, {
+    newTargetPaths
+  }) {
+    if (!child.get("meta").isIdentifier({
+      name: "new"
+    })) return;
+    if (!child.get("property").isIdentifier({
+      name: "target"
+    })) return;
+    newTargetPaths.push(child);
+  }
+
+}, _helperEnvironmentVisitor.default]);
+
 function getScopeInformation(fnPath) {
   const thisPaths = [];
   const argumentsPaths = [];
   const newTargetPaths = [];
   const superProps = [];
   const superCalls = [];
-  fnPath.traverse({
-    ClassProperty(child) {
-      child.skip();
-    },
-
-    Function(child) {
-      if (child.isArrowFunctionExpression()) return;
-      child.skip();
-    },
-
-    ThisExpression(child) {
-      thisPaths.push(child);
-    },
-
-    JSXIdentifier(child) {
-      if (child.node.name !== "this") return;
-
-      if (!child.parentPath.isJSXMemberExpression({
-        object: child.node
-      }) && !child.parentPath.isJSXOpeningElement({
-        name: child.node
-      })) {
-        return;
-      }
-
-      thisPaths.push(child);
-    },
-
-    CallExpression(child) {
-      if (child.get("callee").isSuper()) superCalls.push(child);
-    },
-
-    MemberExpression(child) {
-      if (child.get("object").isSuper()) superProps.push(child);
-    },
-
-    ReferencedIdentifier(child) {
-      if (child.node.name !== "arguments") return;
-      let curr = child.scope;
-
-      do {
-        if (curr.hasOwnBinding("arguments")) {
-          curr.rename("arguments");
-          return;
-        }
-
-        if (curr.path.isFunction() && !curr.path.isArrowFunctionExpression()) {
-          break;
-        }
-      } while (curr = curr.parent);
-
-      argumentsPaths.push(child);
-    },
-
-    MetaProperty(child) {
-      if (!child.get("meta").isIdentifier({
-        name: "new"
-      })) return;
-      if (!child.get("property").isIdentifier({
-        name: "target"
-      })) return;
-      newTargetPaths.push(child);
-    }
-
+  fnPath.traverse(getScopeInformationVisitor, {
+    thisPaths,
+    argumentsPaths,
+    newTargetPaths,
+    superProps,
+    superCalls
   });
   return {
     thisPaths,

package/lib/scope/index.js

@@ -467,7 +467,7 @@ class Scope {
   checkBlockScopedCollisions(local, kind, name, id) {
     if (kind === "param") return;
     if (local.kind === "local") return;
-    const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && (kind === "let" || kind === "const");
+    const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && kind === "const";
 
     if (duplicate) {
       throw this.hub.buildError(id, `Duplicate declaration "${name}"`, TypeError);
@@ -575,6 +575,7 @@ class Scope {
         this.registerBinding(path.node.kind, declar);
       }
     } else if (path.isClassDeclaration()) {
+      if (path.node.declare) return;
       this.registerBinding("let", path);
     } else if (path.isImportDeclaration()) {
       const specifiers = path.get("specifiers");
@@ -940,6 +941,8 @@ class Scope {
         if ((_previousPath = previousPath) != null && _previousPath.isPattern() && binding.kind !== "param" && binding.kind !== "local") {} else {
           return binding;
         }
+      } else if (!binding && name === "arguments" && scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
+        break;
       }
 
       previousPath = scope.path;

package/lib/traverse-node.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.traverseNode = traverseNode;
+
+var _context = require("./context");
+
+var _t = require("@babel/types");
+
+const {
+  VISITOR_KEYS
+} = _t;
+
+function traverseNode(node, opts, scope, state, path, skipKeys) {
+  const keys = VISITOR_KEYS[node.type];
+  if (!keys) return false;
+  const context = new _context.default(scope, opts, state, path);
+
+  for (const key of keys) {
+    if (skipKeys && skipKeys[key]) continue;
+
+    if (context.visit(node, key)) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babel/traverse",
-  "version": "7.16.0",
+  "version": "7.16.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",
@@ -16,18 +16,19 @@
   },
   "main": "./lib/index.js",
   "dependencies": {
-    "@babel/code-frame": "^7.16.0",
-    "@babel/generator": "^7.16.0",
-    "@babel/helper-function-name": "^7.16.0",
-    "@babel/helper-hoist-variables": "^7.16.0",
-    "@babel/helper-split-export-declaration": "^7.16.0",
-    "@babel/parser": "^7.16.0",
-    "@babel/types": "^7.16.0",
+    "@babel/code-frame": "^7.16.7",
+    "@babel/generator": "^7.16.8",
+    "@babel/helper-environment-visitor": "^7.16.7",
+    "@babel/helper-function-name": "^7.16.7",
+    "@babel/helper-hoist-variables": "^7.16.7",
+    "@babel/helper-split-export-declaration": "^7.16.7",
+    "@babel/parser": "^7.16.8",
+    "@babel/types": "^7.16.8",
     "debug": "^4.1.0",
     "globals": "^11.1.0"
   },
   "devDependencies": {
-    "@babel/helper-plugin-test-runner": "^7.16.0"
+    "@babel/helper-plugin-test-runner": "^7.16.7"
   },
   "engines": {
     "node": ">=6.9.0"

package/scripts/generators/validators.js

@@ -1,6 +1,5 @@
 import t from "@babel/types";
 import virtualTypes from "../../lib/path/lib/virtual-types.js";
-import definitions from "@babel/types/lib/definitions/index.js";
 
 export default function generateValidators() {
   let output = `/*
@@ -21,7 +20,7 @@ export interface NodePathValidators {
   for (const type of Object.keys(virtualTypes)) {
     const { types } = virtualTypes[type];
     if (type[0] === "_") continue;
-    if (definitions.NODE_FIELDS[type] || definitions.FLIPPED_ALIAS_KEYS[type]) {
+    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}"]>;`;