@babel/traverse 7.1.0 → 7.23.2

package/lib/path/conversion.js

@@ -3,150 +3,169 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.toComputedKey = toComputedKey;
+exports.arrowFunctionToExpression = arrowFunctionToExpression;
 exports.ensureBlock = ensureBlock;
-exports.arrowFunctionToShadowed = arrowFunctionToShadowed;
+exports.toComputedKey = toComputedKey;
 exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
-exports.arrowFunctionToExpression = arrowFunctionToExpression;
-
-function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
-
-  t = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _helperFunctionName() {
-  const data = _interopRequireDefault(require("@babel/helper-function-name"));
-
-  _helperFunctionName = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
-
+var _t = require("@babel/types");
+var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor");
+var _helperFunctionName = require("@babel/helper-function-name");
+var _visitors = require("../visitors.js");
+const {
+  arrowFunctionExpression,
+  assignmentExpression,
+  binaryExpression,
+  blockStatement,
+  callExpression,
+  conditionalExpression,
+  expressionStatement,
+  identifier,
+  isIdentifier,
+  jsxIdentifier,
+  logicalExpression,
+  LOGICAL_OPERATORS,
+  memberExpression,
+  metaProperty,
+  numericLiteral,
+  objectExpression,
+  restElement,
+  returnStatement,
+  sequenceExpression,
+  spreadElement,
+  stringLiteral,
+  super: _super,
+  thisExpression,
+  toExpression,
+  unaryExpression
+} = _t;
 function toComputedKey() {
-  const node = this.node;
   let key;
-
   if (this.isMemberExpression()) {
-    key = node.property;
+    key = this.node.property;
   } else if (this.isProperty() || this.isMethod()) {
-    key = node.key;
+    key = this.node.key;
   } else {
     throw new ReferenceError("todo");
   }
-
-  if (!node.computed) {
-    if (t().isIdentifier(key)) key = t().stringLiteral(key.name);
+  if (!this.node.computed) {
+    if (isIdentifier(key)) key = stringLiteral(key.name);
   }
-
   return key;
 }
-
 function ensureBlock() {
   const body = this.get("body");
   const bodyNode = body.node;
-
   if (Array.isArray(body)) {
     throw new Error("Can't convert array path to a block statement");
   }
-
   if (!bodyNode) {
     throw new Error("Can't convert node without a body");
   }
-
   if (body.isBlockStatement()) {
     return bodyNode;
   }
-
   const statements = [];
   let stringPath = "body";
   let key;
   let listKey;
-
   if (body.isStatement()) {
     listKey = "body";
     key = 0;
     statements.push(body.node);
   } else {
     stringPath += ".body.0";
-
     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;
 }
-
-function arrowFunctionToShadowed() {
-  if (!this.isArrowFunctionExpression()) return;
-  this.arrowFunctionToExpression();
+{
+  exports.arrowFunctionToShadowed = function () {
+    if (!this.isArrowFunctionExpression()) return;
+    this.arrowFunctionToExpression();
+  };
 }
-
 function unwrapFunctionEnvironment() {
   if (!this.isArrowFunctionExpression() && !this.isFunctionExpression() && !this.isFunctionDeclaration()) {
     throw this.buildCodeFrameError("Can only unwrap the environment of a function.");
   }
-
   hoistFunctionEnvironment(this);
 }
-
+function setType(path, type) {
+  path.node.type = type;
+}
 function arrowFunctionToExpression({
   allowInsertArrow = true,
-  specCompliant = false
+  allowInsertArrowWithRest = allowInsertArrow,
+  noNewArrows = !(_arguments$ => (_arguments$ = arguments[0]) == null ? void 0 : _arguments$.specCompliant)()
 } = {}) {
   if (!this.isArrowFunctionExpression()) {
     throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
   }
-
-  const thisBinding = hoistFunctionEnvironment(this, specCompliant, allowInsertArrow);
-  this.ensureBlock();
-  this.node.type = "FunctionExpression";
-
-  if (specCompliant) {
-    const checkBinding = thisBinding ? null : this.parentPath.scope.generateUidIdentifier("arrowCheckId");
-
+  const {
+    thisBinding,
+    fnPath: fn
+  } = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow, allowInsertArrowWithRest);
+  fn.ensureBlock();
+  setType(fn, "FunctionExpression");
+  if (!noNewArrows) {
+    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()]));
+    return fn.get("callee.object");
   }
+  return fn;
 }
-
-function hoistFunctionEnvironment(fnPath, specCompliant = false, allowInsertArrow = true) {
-  const thisEnvFn = fnPath.findParent(p => {
-    return p.isFunction() && !p.isArrowFunctionExpression() || p.isProgram() || p.isClassProperty({
+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, allowInsertArrowWithRest = true) {
+  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 && thisEnvFn.node.kind === "constructor";
-
-  if (thisEnvFn.isClassProperty()) {
-    throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
+  const inConstructor = thisEnvFn.isClassMethod({
+    kind: "constructor"
+  });
+  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 {
     thisPaths,
     argumentsPaths,
@@ -154,236 +173,206 @@ function hoistFunctionEnvironment(fnPath, specCompliant = false, allowInsertArro
     superProps,
     superCalls
   } = getScopeInformation(fnPath);
-
   if (inConstructor && superCalls.length > 0) {
     if (!allowInsertArrow) {
-      throw superCalls[0].buildCodeFrameError("Unable to handle nested super() usage in arrow");
+      throw superCalls[0].buildCodeFrameError("When using '@babel/plugin-transform-arrow-functions', " + "it's not possible to compile `super()` in an arrow function without compiling classes.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
+    }
+    if (!allowInsertArrowWithRest) {
+      throw superCalls[0].buildCodeFrameError("When using '@babel/plugin-transform-parameters', " + "it's not possible to compile `super()` in an arrow function with default or rest parameters without compiling classes.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
     }
-
     const allSuperCalls = [];
-    thisEnvFn.traverse({
-      Function(child) {
-        if (child.isArrowFunctionExpression()) return;
-        child.skip();
-      },
-
-      ClassProperty(child) {
-        if (child.node.static) return;
-        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);
     });
   }
-
-  let thisBinding;
-
-  if (thisPaths.length > 0 || specCompliant) {
-    thisBinding = getThisBinding(thisEnvFn, inConstructor);
-
-    if (!specCompliant || inConstructor && hasSuperClass(thisEnvFn)) {
-      thisPaths.forEach(thisChild => {
-        const thisRef = thisChild.isJSX() ? t().jsxIdentifier(thisBinding) : t().identifier(thisBinding);
-        thisRef.loc = thisChild.node.loc;
-        thisChild.replaceWith(thisRef);
-      });
-      if (specCompliant) thisBinding = null;
-    }
-  }
-
   if (argumentsPaths.length > 0) {
-    const argumentsBinding = getBinding(thisEnvFn, "arguments", () => t().identifier("arguments"));
+    const argumentsBinding = getBinding(thisEnvFn, "arguments", () => {
+      const args = () => identifier("arguments");
+      if (thisEnvFn.scope.path.isProgram()) {
+        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);
     });
   }
-
   if (superProps.length > 0) {
     if (!allowInsertArrow) {
-      throw superProps[0].buildCodeFrameError("Unable to handle nested super.prop usage");
+      throw superProps[0].buildCodeFrameError("When using '@babel/plugin-transform-arrow-functions', " + "it's not possible to compile `super.prop` in an arrow function without compiling classes.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
     }
-
     const flatSuperProps = superProps.reduce((acc, superProp) => acc.concat(standardizeSuperProperty(superProp)), []);
     flatSuperProps.forEach(superProp => {
       const key = superProp.node.computed ? "" : superProp.get("property").node.name;
-
-      if (superProp.parentPath.isCallExpression({
+      const superParentPath = superProp.parentPath;
+      const isAssignment = superParentPath.isAssignmentExpression({
+        left: superProp.node
+      });
+      const isCall = superParentPath.isCallExpression({
         callee: superProp.node
-      })) {
-        const superBinding = getSuperPropCallBinding(thisEnvFn, key);
-
-        if (superProp.node.computed) {
-          const prop = superProp.get("property").node;
-          superProp.replaceWith(t().identifier(superBinding));
-          superProp.parentPath.node.arguments.unshift(prop);
-        } else {
-          superProp.replaceWith(t().identifier(superBinding));
-        }
+      });
+      const isTaggedTemplate = superParentPath.isTaggedTemplateExpression({
+        tag: superProp.node
+      });
+      const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
+      const args = [];
+      if (superProp.node.computed) {
+        args.push(superProp.get("property").node);
+      }
+      if (isAssignment) {
+        const value = superParentPath.node.right;
+        args.push(value);
+      }
+      const call = callExpression(identifier(superBinding), args);
+      if (isCall) {
+        superParentPath.unshiftContainer("arguments", thisExpression());
+        superProp.replaceWith(memberExpression(call, identifier("call")));
+        thisPaths.push(superParentPath.get("arguments.0"));
+      } else if (isAssignment) {
+        superParentPath.replaceWith(call);
+      } else if (isTaggedTemplate) {
+        superProp.replaceWith(callExpression(memberExpression(call, identifier("bind"), false), [thisExpression()]));
+        thisPaths.push(superProp.get("arguments.0"));
       } else {
-        const isAssignment = superProp.parentPath.isAssignmentExpression({
-          left: superProp.node
-        });
-        const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
-        const args = [];
-
-        if (superProp.node.computed) {
-          args.push(superProp.get("property").node);
-        }
-
-        if (isAssignment) {
-          const value = superProp.parentPath.node.right;
-          args.push(value);
-          superProp.parentPath.replaceWith(t().callExpression(t().identifier(superBinding), args));
-        } else {
-          superProp.replaceWith(t().callExpression(t().identifier(superBinding), args));
-        }
+        superProp.replaceWith(call);
       }
     });
   }
-
-  return thisBinding;
+  let thisBinding;
+  if (thisPaths.length > 0 || !noNewArrows) {
+    thisBinding = getThisBinding(thisEnvFn, inConstructor);
+    if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) {
+      thisPaths.forEach(thisChild => {
+        const thisRef = thisChild.isJSX() ? jsxIdentifier(thisBinding) : identifier(thisBinding);
+        thisRef.loc = thisChild.node.loc;
+        thisChild.replaceWith(thisRef);
+      });
+      if (!noNewArrows) thisBinding = null;
+    }
+  }
+  return {
+    thisBinding,
+    fnPath
+  };
+}
+function isLogicalOp(op) {
+  return LOGICAL_OPERATORS.includes(op);
 }
-
 function standardizeSuperProperty(superProp) {
   if (superProp.parentPath.isAssignmentExpression() && superProp.parentPath.node.operator !== "=") {
     const assignmentPath = superProp.parentPath;
     const op = assignmentPath.node.operator.slice(0, -1);
     const value = assignmentPath.node.right;
-    assignmentPath.node.operator = "=";
-
+    const isLogicalAssignment = isLogicalOp(op);
     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));
+      const object = superProp.node.object;
+      const property = superProp.node.property;
+      assignmentPath.get("left").replaceWith(memberExpression(object, assignmentExpression("=", tmp, property), true));
+      assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(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));
+      const object = superProp.node.object;
+      const property = superProp.node.property;
+      assignmentPath.get("left").replaceWith(memberExpression(object, property));
+      assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(property.name)), value));
+    }
+    if (isLogicalAssignment) {
+      assignmentPath.replaceWith(logicalExpression(op, assignmentPath.node.left, assignmentPath.node.right));
+    } else {
+      assignmentPath.node.operator = "=";
     }
-
     return [assignmentPath.get("left"), assignmentPath.get("right").get("left")];
   } else if (superProp.parentPath.isUpdateExpression()) {
     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(superProp.parentPath.node.operator[0], 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];
   }
-
   return [superProp];
+  function rightExpression(op, left, right) {
+    if (op === "=") {
+      return assignmentExpression("=", left, right);
+    } else {
+      return binaryExpression(op, left, right);
+    }
+  }
 }
-
 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) {
-        if (child.node.static) return;
-        child.skip();
-      },
-
-      CallExpression(child) {
-        if (!child.get("callee").isSuper()) return;
-        if (supers.has(child.node)) return;
-        supers.add(child.node);
-        child.replaceWith(t().assignmentExpression("=", t().identifier(thisBinding), child.node));
-      }
-
+    if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();
+    thisEnvFn.traverse(assignSuperThisVisitor, {
+      supers: new WeakSet(),
+      thisBinding
     });
   });
 }
-
 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))]));
-  });
-}
-
-function getSuperPropCallBinding(thisEnvFn, propName) {
-  return getBinding(thisEnvFn, `superprop_call:${propName || ""}`, () => {
-    const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
-    const argsList = [t().restElement(argsBinding)];
-    let fnBody;
-
-    if (propName) {
-      fnBody = t().callExpression(t().memberExpression(t().super(), t().identifier(propName)), [t().spreadElement(t().identifier(argsBinding.name))]);
-    } else {
-      const method = thisEnvFn.scope.generateUidIdentifier("prop");
-      argsList.unshift(method);
-      fnBody = t().callExpression(t().memberExpression(t().super(), t().identifier(method.name), true), [t().spreadElement(t().identifier(argsBinding.name))]);
-    }
-
-    return t().arrowFunctionExpression(argsList, fnBody);
+    return arrowFunctionExpression([restElement(argsBinding)], callExpression(_super(), [spreadElement(identifier(argsBinding.name))]));
   });
 }
-
 function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
   const op = isAssignment ? "set" : "get";
   return getBinding(thisEnvFn, `superprop_${op}:${propName || ""}`, () => {
     const argsList = [];
     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);
   });
 }
-
 function getBinding(thisEnvFn, key, init) {
   const cacheKey = "binding:" + key;
   let data = thisEnvFn.getData(cacheKey);
-
   if (!data) {
     const id = thisEnvFn.scope.generateUidIdentifier(key);
     data = id.name;
@@ -393,68 +382,79 @@ function getBinding(thisEnvFn, key, init) {
       init: init(data)
     });
   }
-
   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) {
-      if (child.node.static) return;
-      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;
-      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,
@@ -463,4 +463,6 @@ function getScopeInformation(fnPath) {
     superProps,
     superCalls
   };
-}
+}
+
+//# sourceMappingURL=conversion.js.map