@babel/traverse 7.0.0-beta.5 → 7.0.0-beta.53

package/lib/path/conversion.js

@@ -1,23 +1,41 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.toComputedKey = toComputedKey;
 exports.ensureBlock = ensureBlock;
 exports.arrowFunctionToShadowed = arrowFunctionToShadowed;
 exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
 exports.arrowFunctionToExpression = arrowFunctionToExpression;
 
-var t = _interopRequireWildcard(require("@babel/types"));
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
 
-var _helperFunctionName = _interopRequireDefault(require("@babel/helper-function-name"));
+  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)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+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; } }
 
 function toComputedKey() {
-  var node = this.node;
-  var key;
+  const node = this.node;
+  let key;
 
   if (this.isMemberExpression()) {
     key = node.property;
@@ -28,15 +46,15 @@ function toComputedKey() {
   }
 
   if (!node.computed) {
-    if (t.isIdentifier(key)) key = t.stringLiteral(key.name);
+    if (t().isIdentifier(key)) key = t().stringLiteral(key.name);
   }
 
   return key;
 }
 
 function ensureBlock() {
-  var body = this.get("body");
-  var bodyNode = body.node;
+  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");
@@ -50,10 +68,10 @@ function ensureBlock() {
     return bodyNode;
   }
 
-  var statements = [];
-  var stringPath = "body";
-  var key;
-  var listKey;
+  const statements = [];
+  let stringPath = "body";
+  let key;
+  let listKey;
 
   if (body.isStatement()) {
     listKey = "body";
@@ -64,15 +82,15 @@ function ensureBlock() {
 
     if (this.isFunction()) {
       key = "argument";
-      statements.push(t.returnStatement(body.node));
+      statements.push(t().returnStatement(body.node));
     } else {
       key = "expression";
-      statements.push(t.expressionStatement(body.node));
+      statements.push(t().expressionStatement(body.node));
     }
   }
 
-  this.node.body = t.blockStatement(statements);
-  var parentPath = this.get(stringPath);
+  this.node.body = t().blockStatement(statements);
+  const parentPath = this.get(stringPath);
   body.setup(parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
   return this.node;
 }
@@ -90,117 +108,114 @@ function unwrapFunctionEnvironment() {
   hoistFunctionEnvironment(this);
 }
 
-function arrowFunctionToExpression(_temp) {
-  var _ref = _temp === void 0 ? {} : _temp,
-      _ref$allowInsertArrow = _ref.allowInsertArrow,
-      allowInsertArrow = _ref$allowInsertArrow === void 0 ? true : _ref$allowInsertArrow,
-      _ref$specCompliant = _ref.specCompliant,
-      specCompliant = _ref$specCompliant === void 0 ? false : _ref$specCompliant;
-
+function arrowFunctionToExpression({
+  allowInsertArrow = true,
+  specCompliant = false
+} = {}) {
   if (!this.isArrowFunctionExpression()) {
     throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
   }
 
-  var thisBinding = hoistFunctionEnvironment(this, specCompliant, allowInsertArrow);
+  const thisBinding = hoistFunctionEnvironment(this, specCompliant, allowInsertArrow);
   this.ensureBlock();
   this.node.type = "FunctionExpression";
 
   if (specCompliant) {
-    var checkBinding = thisBinding ? null : this.parentPath.scope.generateUidIdentifier("arrowCheckId");
+    const checkBinding = thisBinding ? null : this.parentPath.scope.generateUidIdentifier("arrowCheckId");
 
     if (checkBinding) {
       this.parentPath.scope.push({
         id: checkBinding,
-        init: t.objectExpression([])
+        init: t().objectExpression([])
       });
     }
 
-    this.get("body").unshiftContainer("body", t.expressionStatement(t.callExpression(this.hub.file.addHelper("newArrowCheck"), [t.thisExpression(), checkBinding ? t.identifier(checkBinding.name) : t.identifier(thisBinding)])));
-    this.replaceWith(t.callExpression(t.memberExpression((0, _helperFunctionName.default)(this) || this.node, t.identifier("bind")), [checkBinding ? t.identifier(checkBinding.name) : t.thisExpression()]));
+    this.get("body").unshiftContainer("body", t().expressionStatement(t().callExpression(this.hub.file.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()]));
   }
 }
 
-function hoistFunctionEnvironment(fnPath, specCompliant, allowInsertArrow) {
-  if (specCompliant === void 0) {
-    specCompliant = false;
-  }
-
-  if (allowInsertArrow === void 0) {
-    allowInsertArrow = true;
-  }
-
-  var thisEnvFn = fnPath.findParent(function (p) {
+function hoistFunctionEnvironment(fnPath, specCompliant = false, allowInsertArrow = true) {
+  const thisEnvFn = fnPath.findParent(p => {
     return p.isFunction() && !p.isArrowFunctionExpression() || p.isProgram() || p.isClassProperty({
       static: false
     });
   });
-  var inConstructor = thisEnvFn && thisEnvFn.node.kind === "constructor";
+  const inConstructor = thisEnvFn && thisEnvFn.node.kind === "constructor";
 
   if (thisEnvFn.isClassProperty()) {
     throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
   }
 
-  var _getScopeInformation = getScopeInformation(fnPath),
-      thisPaths = _getScopeInformation.thisPaths,
-      argumentsPaths = _getScopeInformation.argumentsPaths,
-      newTargetPaths = _getScopeInformation.newTargetPaths,
-      superProps = _getScopeInformation.superProps,
-      superCalls = _getScopeInformation.superCalls;
+  const {
+    thisPaths,
+    argumentsPaths,
+    newTargetPaths,
+    superProps,
+    superCalls
+  } = getScopeInformation(fnPath);
 
   if (inConstructor && superCalls.length > 0) {
     if (!allowInsertArrow) {
       throw superCalls[0].buildCodeFrameError("Unable to handle nested super() usage in arrow");
     }
 
-    var allSuperCalls = [];
+    const allSuperCalls = [];
     thisEnvFn.traverse({
-      Function: function Function(child) {
+      Function(child) {
         if (child.isArrowFunctionExpression()) return;
         child.skip();
       },
-      ClassProperty: function ClassProperty(child) {
+
+      ClassProperty(child) {
         if (child.node.static) return;
         child.skip();
       },
-      CallExpression: function CallExpression(child) {
+
+      CallExpression(child) {
         if (!child.get("callee").isSuper()) return;
         allSuperCalls.push(child);
       }
+
     });
-    var superBinding = getSuperBinding(thisEnvFn);
-    allSuperCalls.forEach(function (superCall) {
-      return superCall.get("callee").replaceWith(t.identifier(superBinding));
+    const superBinding = getSuperBinding(thisEnvFn);
+    allSuperCalls.forEach(superCall => {
+      const callee = t().identifier(superBinding);
+      callee.loc = superCall.node.callee.loc;
+      superCall.get("callee").replaceWith(callee);
     });
   }
 
-  var thisBinding;
+  let thisBinding;
 
   if (thisPaths.length > 0 || specCompliant) {
     thisBinding = getThisBinding(thisEnvFn, inConstructor);
 
     if (!specCompliant || inConstructor && hasSuperClass(thisEnvFn)) {
-      thisPaths.forEach(function (thisChild) {
-        thisChild.replaceWith(thisChild.isJSX() ? t.jSXIdentifier(thisBinding) : t.identifier(thisBinding));
+      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) {
-    var argumentsBinding = getBinding(thisEnvFn, "arguments", function () {
-      return t.identifier("arguments");
-    });
-    argumentsPaths.forEach(function (argumentsChild) {
-      argumentsChild.replaceWith(t.identifier(argumentsBinding));
+    const argumentsBinding = getBinding(thisEnvFn, "arguments", () => t().identifier("arguments"));
+    argumentsPaths.forEach(argumentsChild => {
+      const argsRef = t().identifier(argumentsBinding);
+      argsRef.loc = argumentsChild.node.loc;
+      argumentsChild.replaceWith(argsRef);
     });
   }
 
   if (newTargetPaths.length > 0) {
-    var newTargetBinding = getBinding(thisEnvFn, "newtarget", function () {
-      return t.metaProperty(t.identifier("new"), t.identifier("target"));
-    });
-    newTargetPaths.forEach(function (argumentsChild) {
-      argumentsChild.replaceWith(t.identifier(newTargetBinding));
+    const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => t().metaProperty(t().identifier("new"), t().identifier("target")));
+    newTargetPaths.forEach(targetChild => {
+      const targetRef = t().identifier(newTargetBinding);
+      targetRef.loc = targetChild.node.loc;
+      targetChild.replaceWith(targetRef);
     });
   }
 
@@ -209,43 +224,39 @@ function hoistFunctionEnvironment(fnPath, specCompliant, allowInsertArrow) {
       throw superProps[0].buildCodeFrameError("Unable to handle nested super.prop usage");
     }
 
-    var flatSuperProps = superProps.reduce(function (acc, superProp) {
-      return acc.concat(standardizeSuperProperty(superProp));
-    }, []);
-    flatSuperProps.forEach(function (superProp) {
-      var key = superProp.node.computed ? "" : superProp.get("property").node.name;
+    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({
         callee: superProp.node
       })) {
-        var _superBinding = getSuperPropCallBinding(thisEnvFn, key);
+        const superBinding = getSuperPropCallBinding(thisEnvFn, key);
 
         if (superProp.node.computed) {
-          var prop = superProp.get("property").node;
-          superProp.replaceWith(t.identifier(_superBinding));
+          const prop = superProp.get("property").node;
+          superProp.replaceWith(t().identifier(superBinding));
           superProp.parentPath.node.arguments.unshift(prop);
         } else {
-          superProp.replaceWith(t.identifier(_superBinding));
+          superProp.replaceWith(t().identifier(superBinding));
         }
       } else {
-        var isAssignment = superProp.parentPath.isAssignmentExpression({
+        const isAssignment = superProp.parentPath.isAssignmentExpression({
           left: superProp.node
         });
-
-        var _superBinding2 = getSuperPropBinding(thisEnvFn, isAssignment, key);
-
-        var args = [];
+        const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
+        const args = [];
 
         if (superProp.node.computed) {
           args.push(superProp.get("property").node);
         }
 
         if (isAssignment) {
-          var value = superProp.parentPath.node.right;
+          const value = superProp.parentPath.node.right;
           args.push(value);
-          superProp.parentPath.replaceWith(t.callExpression(t.identifier(_superBinding2), args));
+          superProp.parentPath.replaceWith(t().callExpression(t().identifier(superBinding), args));
         } else {
-          superProp.replaceWith(t.callExpression(t.identifier(_superBinding2), args));
+          superProp.replaceWith(t().callExpression(t().identifier(superBinding), args));
         }
       }
     });
@@ -256,36 +267,34 @@ function hoistFunctionEnvironment(fnPath, specCompliant, allowInsertArrow) {
 
 function standardizeSuperProperty(superProp) {
   if (superProp.parentPath.isAssignmentExpression() && superProp.parentPath.node.operator !== "=") {
-    var assignmentPath = superProp.parentPath;
-    var op = assignmentPath.node.operator.slice(0, -1);
-    var value = assignmentPath.node.right;
+    const assignmentPath = superProp.parentPath;
+    const op = assignmentPath.node.operator.slice(0, -1);
+    const value = assignmentPath.node.right;
     assignmentPath.node.operator = "=";
 
     if (superProp.node.computed) {
-      var 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 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));
     } 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(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));
     }
 
     return [assignmentPath.get("left"), assignmentPath.get("right").get("left")];
   } else if (superProp.parentPath.isUpdateExpression()) {
-    var updateExpr = superProp.parentPath;
-
-    var _tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
-
-    var computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
-    var 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 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)))];
 
     if (!superProp.parentPath.node.prefix) {
-      parts.push(t.identifier(_tmp.name));
+      parts.push(t().identifier(tmp.name));
     }
 
-    updateExpr.replaceWith(t.sequenceExpression(parts));
-    var left = updateExpr.get("expressions.0.right");
-    var right = updateExpr.get("expressions.1.left");
+    updateExpr.replaceWith(t().sequenceExpression(parts));
+    const left = updateExpr.get("expressions.0.right");
+    const right = updateExpr.get("expressions.1.left");
     return [left, right];
   }
 
@@ -297,83 +306,86 @@ function hasSuperClass(thisEnvFn) {
 }
 
 function getThisBinding(thisEnvFn, inConstructor) {
-  return getBinding(thisEnvFn, "this", function (thisBinding) {
-    if (!inConstructor || !hasSuperClass(thisEnvFn)) return t.thisExpression();
-    var supers = new WeakSet();
+  return getBinding(thisEnvFn, "this", thisBinding => {
+    if (!inConstructor || !hasSuperClass(thisEnvFn)) return t().thisExpression();
+    const supers = new WeakSet();
     thisEnvFn.traverse({
-      Function: function Function(child) {
+      Function(child) {
         if (child.isArrowFunctionExpression()) return;
         child.skip();
       },
-      ClassProperty: function ClassProperty(child) {
+
+      ClassProperty(child) {
         if (child.node.static) return;
         child.skip();
       },
-      CallExpression: function CallExpression(child) {
+
+      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));
+        child.replaceWith(t().assignmentExpression("=", t().identifier(thisBinding), child.node));
       }
+
     });
   });
 }
 
 function getSuperBinding(thisEnvFn) {
-  return getBinding(thisEnvFn, "supercall", function () {
-    var argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
-    return t.arrowFunctionExpression([t.restElement(argsBinding)], t.callExpression(t.super(), [t.spreadElement(t.identifier(argsBinding.name))]));
+  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 || ""), function () {
-    var argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
-    var argsList = [t.restElement(argsBinding)];
-    var fnBody;
+  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))]);
+      fnBody = t().callExpression(t().memberExpression(t().super(), t().identifier(propName)), [t().spreadElement(t().identifier(argsBinding.name))]);
     } else {
-      var method = thisEnvFn.scope.generateUidIdentifier("prop");
+      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))]);
+      fnBody = t().callExpression(t().memberExpression(t().super(), t().identifier(method.name), true), [t().spreadElement(t().identifier(argsBinding.name))]);
     }
 
-    return t.arrowFunctionExpression(argsList, fnBody);
+    return t().arrowFunctionExpression(argsList, fnBody);
   });
 }
 
 function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
-  var op = isAssignment ? "set" : "get";
-  return getBinding(thisEnvFn, "superprop_" + op + ":" + (propName || ""), function () {
-    var argsList = [];
-    var fnBody;
+  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 = t().memberExpression(t().super(), t().identifier(propName));
     } else {
-      var method = thisEnvFn.scope.generateUidIdentifier("prop");
+      const method = thisEnvFn.scope.generateUidIdentifier("prop");
       argsList.unshift(method);
-      fnBody = t.memberExpression(t.super(), t.identifier(method.name), true);
+      fnBody = t().memberExpression(t().super(), t().identifier(method.name), true);
     }
 
     if (isAssignment) {
-      var valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
+      const valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
       argsList.push(valueIdent);
-      fnBody = t.assignmentExpression("=", fnBody, t.identifier(valueIdent.name));
+      fnBody = t().assignmentExpression("=", fnBody, t().identifier(valueIdent.name));
     }
 
-    return t.arrowFunctionExpression(argsList, fnBody);
+    return t().arrowFunctionExpression(argsList, fnBody);
   });
 }
 
 function getBinding(thisEnvFn, key, init) {
-  var cacheKey = "binding:" + key;
-  var data = thisEnvFn.getData(cacheKey);
+  const cacheKey = "binding:" + key;
+  let data = thisEnvFn.getData(cacheKey);
 
   if (!data) {
-    var id = thisEnvFn.scope.generateUidIdentifier(key);
+    const id = thisEnvFn.scope.generateUidIdentifier(key);
     data = id.name;
     thisEnvFn.setData(cacheKey, data);
     thisEnvFn.scope.push({
@@ -386,24 +398,27 @@ function getBinding(thisEnvFn, key, init) {
 }
 
 function getScopeInformation(fnPath) {
-  var thisPaths = [];
-  var argumentsPaths = [];
-  var newTargetPaths = [];
-  var superProps = [];
-  var superCalls = [];
+  const thisPaths = [];
+  const argumentsPaths = [];
+  const newTargetPaths = [];
+  const superProps = [];
+  const superCalls = [];
   fnPath.traverse({
-    ClassProperty: function ClassProperty(child) {
+    ClassProperty(child) {
       if (child.node.static) return;
       child.skip();
     },
-    Function: function Function(child) {
+
+    Function(child) {
       if (child.isArrowFunctionExpression()) return;
       child.skip();
     },
-    ThisExpression: function ThisExpression(child) {
+
+    ThisExpression(child) {
       thisPaths.push(child);
     },
-    JSXIdentifier: function JSXIdentifier(child) {
+
+    JSXIdentifier(child) {
       if (child.node.name !== "this") return;
 
       if (!child.parentPath.isJSXMemberExpression({
@@ -416,17 +431,21 @@ function getScopeInformation(fnPath) {
 
       thisPaths.push(child);
     },
-    CallExpression: function CallExpression(child) {
+
+    CallExpression(child) {
       if (child.get("callee").isSuper()) superCalls.push(child);
     },
-    MemberExpression: function MemberExpression(child) {
+
+    MemberExpression(child) {
       if (child.get("object").isSuper()) superProps.push(child);
     },
-    ReferencedIdentifier: function ReferencedIdentifier(child) {
+
+    ReferencedIdentifier(child) {
       if (child.node.name !== "arguments") return;
       argumentsPaths.push(child);
     },
-    MetaProperty: function MetaProperty(child) {
+
+    MetaProperty(child) {
       if (!child.get("meta").isIdentifier({
         name: "new"
       })) return;
@@ -435,12 +454,13 @@ function getScopeInformation(fnPath) {
       })) return;
       newTargetPaths.push(child);
     }
+
   });
   return {
-    thisPaths: thisPaths,
-    argumentsPaths: argumentsPaths,
-    newTargetPaths: newTargetPaths,
-    superProps: superProps,
-    superCalls: superCalls
+    thisPaths,
+    argumentsPaths,
+    newTargetPaths,
+    superProps,
+    superCalls
   };
 }