@babel/traverse 7.15.0 → 7.16.5

package/lib/path/conversion.js

@@ -3,16 +3,46 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.toComputedKey = toComputedKey;
-exports.ensureBlock = ensureBlock;
+exports.arrowFunctionToExpression = arrowFunctionToExpression;
 exports.arrowFunctionToShadowed = arrowFunctionToShadowed;
+exports.ensureBlock = ensureBlock;
+exports.toComputedKey = toComputedKey;
 exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
-exports.arrowFunctionToExpression = arrowFunctionToExpression;
 
-var t = require("@babel/types");
+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,
+  binaryExpression,
+  blockStatement,
+  callExpression,
+  conditionalExpression,
+  expressionStatement,
+  identifier,
+  isIdentifier,
+  jsxIdentifier,
+  memberExpression,
+  metaProperty,
+  numericLiteral,
+  objectExpression,
+  restElement,
+  returnStatement,
+  sequenceExpression,
+  spreadElement,
+  stringLiteral,
+  super: _super,
+  thisExpression,
+  toExpression,
+  unaryExpression
+} = _t;
+
 function toComputedKey() {
   let key;
 
@@ -25,7 +55,7 @@ function toComputedKey() {
   }
 
   if (!this.node.computed) {
-    if (t.isIdentifier(key)) key = t.stringLiteral(key.name);
+    if (isIdentifier(key)) key = stringLiteral(key.name);
   }
 
   return key;
@@ -61,14 +91,14 @@ function ensureBlock() {
 
     if (this.isFunction()) {
       key = "argument";
-      statements.push(t.returnStatement(body.node));
+      statements.push(returnStatement(body.node));
     } else {
       key = "expression";
-      statements.push(t.expressionStatement(body.node));
+      statements.push(expressionStatement(body.node));
     }
   }
 
-  this.node.body = t.blockStatement(statements);
+  this.node.body = blockStatement(statements);
   const parentPath = this.get(stringPath);
   body.setup(parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
   return this.node;
@@ -96,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: t.objectExpression([])
+        init: objectExpression([])
       });
     }
 
-    this.get("body").unshiftContainer("body", t.expressionStatement(t.callExpression(this.hub.addHelper("newArrowCheck"), [t.thisExpression(), checkBinding ? t.identifier(checkBinding.name) : t.identifier(thisBinding)])));
-    this.replaceWith(t.callExpression(t.memberExpression((0, _helperFunctionName.default)(this, true) || this.node, t.identifier("bind")), [checkBinding ? t.identifier(checkBinding.name) : t.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 {
@@ -141,25 +204,12 @@ 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 => {
-      const callee = t.identifier(superBinding);
+      const callee = identifier(superBinding);
       callee.loc = superCall.node.callee.loc;
       superCall.get("callee").replaceWith(callee);
     });
@@ -167,25 +217,25 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
 
   if (argumentsPaths.length > 0) {
     const argumentsBinding = getBinding(thisEnvFn, "arguments", () => {
-      const args = () => t.identifier("arguments");
+      const args = () => identifier("arguments");
 
       if (thisEnvFn.scope.path.isProgram()) {
-        return t.conditionalExpression(t.binaryExpression("===", t.unaryExpression("typeof", args()), t.stringLiteral("undefined")), thisEnvFn.scope.buildUndefinedNode(), args());
+        return conditionalExpression(binaryExpression("===", unaryExpression("typeof", args()), stringLiteral("undefined")), thisEnvFn.scope.buildUndefinedNode(), args());
       } else {
         return args();
       }
     });
     argumentsPaths.forEach(argumentsChild => {
-      const argsRef = t.identifier(argumentsBinding);
+      const argsRef = identifier(argumentsBinding);
       argsRef.loc = argumentsChild.node.loc;
       argumentsChild.replaceWith(argsRef);
     });
   }
 
   if (newTargetPaths.length > 0) {
-    const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => t.metaProperty(t.identifier("new"), t.identifier("target")));
+    const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => metaProperty(identifier("new"), identifier("target")));
     newTargetPaths.forEach(targetChild => {
-      const targetRef = t.identifier(newTargetBinding);
+      const targetRef = identifier(newTargetBinding);
       targetRef.loc = targetChild.node.loc;
       targetChild.replaceWith(targetRef);
     });
@@ -217,11 +267,11 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
         args.push(value);
       }
 
-      const call = t.callExpression(t.identifier(superBinding), args);
+      const call = callExpression(identifier(superBinding), args);
 
       if (isCall) {
-        superProp.parentPath.unshiftContainer("arguments", t.thisExpression());
-        superProp.replaceWith(t.memberExpression(call, t.identifier("call")));
+        superProp.parentPath.unshiftContainer("arguments", thisExpression());
+        superProp.replaceWith(memberExpression(call, identifier("call")));
         thisPaths.push(superProp.parentPath.get("arguments.0"));
       } else if (isAssignment) {
         superProp.parentPath.replaceWith(call);
@@ -238,7 +288,7 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
 
     if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) {
       thisPaths.forEach(thisChild => {
-        const thisRef = thisChild.isJSX() ? t.jsxIdentifier(thisBinding) : t.identifier(thisBinding);
+        const thisRef = thisChild.isJSX() ? jsxIdentifier(thisBinding) : identifier(thisBinding);
         thisRef.loc = thisChild.node.loc;
         thisChild.replaceWith(thisRef);
       });
@@ -246,7 +296,10 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
     }
   }
 
-  return thisBinding;
+  return {
+    thisBinding,
+    fnPath
+  };
 }
 
 function standardizeSuperProperty(superProp) {
@@ -258,11 +311,11 @@ function standardizeSuperProperty(superProp) {
 
     if (superProp.node.computed) {
       const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
-      assignmentPath.get("left").replaceWith(t.memberExpression(superProp.node.object, t.assignmentExpression("=", tmp, superProp.node.property), true));
-      assignmentPath.get("right").replaceWith(t.binaryExpression(op, t.memberExpression(superProp.node.object, t.identifier(tmp.name), true), value));
+      assignmentPath.get("left").replaceWith(memberExpression(superProp.node.object, assignmentExpression("=", tmp, superProp.node.property), true));
+      assignmentPath.get("right").replaceWith(binaryExpression(op, memberExpression(superProp.node.object, identifier(tmp.name), true), value));
     } else {
-      assignmentPath.get("left").replaceWith(t.memberExpression(superProp.node.object, superProp.node.property));
-      assignmentPath.get("right").replaceWith(t.binaryExpression(op, t.memberExpression(superProp.node.object, t.identifier(superProp.node.property.name)), value));
+      assignmentPath.get("left").replaceWith(memberExpression(superProp.node.object, superProp.node.property));
+      assignmentPath.get("right").replaceWith(binaryExpression(op, memberExpression(superProp.node.object, identifier(superProp.node.property.name)), value));
     }
 
     return [assignmentPath.get("left"), assignmentPath.get("right").get("left")];
@@ -270,13 +323,13 @@ function standardizeSuperProperty(superProp) {
     const updateExpr = superProp.parentPath;
     const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
     const computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
-    const parts = [t.assignmentExpression("=", tmp, t.memberExpression(superProp.node.object, computedKey ? t.assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), t.assignmentExpression("=", t.memberExpression(superProp.node.object, computedKey ? t.identifier(computedKey.name) : superProp.node.property, superProp.node.computed), t.binaryExpression("+", t.identifier(tmp.name), t.numericLiteral(1)))];
+    const parts = [assignmentExpression("=", tmp, memberExpression(superProp.node.object, computedKey ? assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression("=", memberExpression(superProp.node.object, computedKey ? identifier(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression("+", identifier(tmp.name), numericLiteral(1)))];
 
     if (!superProp.parentPath.node.prefix) {
-      parts.push(t.identifier(tmp.name));
+      parts.push(identifier(tmp.name));
     }
 
-    updateExpr.replaceWith(t.sequenceExpression(parts));
+    updateExpr.replaceWith(sequenceExpression(parts));
     const left = updateExpr.get("expressions.0.right");
     const right = updateExpr.get("expressions.1.left");
     return [left, right];
@@ -289,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 t.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, t.assignmentExpression("=", t.identifier(thisBinding), t.identifier("this"))]);
-      }
-
+    if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();
+    thisEnvFn.traverse(assignSuperThisVisitor, {
+      supers: new WeakSet(),
+      thisBinding
     });
   });
 }
@@ -317,7 +368,7 @@ function getThisBinding(thisEnvFn, inConstructor) {
 function getSuperBinding(thisEnvFn) {
   return getBinding(thisEnvFn, "supercall", () => {
     const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
-    return t.arrowFunctionExpression([t.restElement(argsBinding)], t.callExpression(t.super(), [t.spreadElement(t.identifier(argsBinding.name))]));
+    return arrowFunctionExpression([restElement(argsBinding)], callExpression(_super(), [spreadElement(identifier(argsBinding.name))]));
   });
 }
 
@@ -328,20 +379,20 @@ function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
     let fnBody;
 
     if (propName) {
-      fnBody = t.memberExpression(t.super(), t.identifier(propName));
+      fnBody = memberExpression(_super(), identifier(propName));
     } else {
       const method = thisEnvFn.scope.generateUidIdentifier("prop");
       argsList.unshift(method);
-      fnBody = t.memberExpression(t.super(), t.identifier(method.name), true);
+      fnBody = memberExpression(_super(), identifier(method.name), true);
     }
 
     if (isAssignment) {
       const valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
       argsList.push(valueIdent);
-      fnBody = t.assignmentExpression("=", fnBody, t.identifier(valueIdent.name));
+      fnBody = assignmentExpression("=", fnBody, identifier(valueIdent.name));
     }
 
-    return t.arrowFunctionExpression(argsList, fnBody);
+    return arrowFunctionExpression(argsList, fnBody);
   });
 }
 
@@ -362,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/path/evaluation.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.evaluateTruthy = evaluateTruthy;
 exports.evaluate = evaluate;
+exports.evaluateTruthy = evaluateTruthy;
 const VALID_CALLEES = ["String", "Number", "Math"];
 const INVALID_METHODS = ["random"];