more reliable t.isReferenced - fixes #610

lib/6to5/types/index.js

@@ -234,45 +234,59 @@ t.prependToMemberExpression = function (member, append) {
  */
 
 t.isReferenced = function (node, parent) {
-  // we're a property key and we aren't computed so we aren't referenced
-  if (t.isProperty(parent) && parent.key === node && !parent.computed) return false;
-
-  if (t.isFunction(parent)) {
-    // we're a function param
-    if (_.contains(parent.params, node)) return false;
-
-    for (var i = 0; i < parent.params.length; i++) {
-      var param = parent.params[i];
-      if (param === node) {
-        return false;
-      } else if (t.isRestElement(param) && param.argument === node) {
-        return false;
-      }
-    }
+  if (t.isProperty(parent)) {
+    return parent.key === node && parent.computed;
   }
 
-  if (t.isMethodDefinition(parent) && parent.key === node && !parent.computed) {
+  if (t.isFunction(parent)) {
+    for (var i = 0; i < parent.params.length; i++) {
+      var param = parent.params[i];
+      if (t.isRestElement(param)) param = param.argument;
+      if (param === node) return false;
+    }
+
+    return parent.id !== node;
+  }
+
+  if (t.isClass(parent)) {
+    return parent.id !== node;
+  }
+
+  if (t.isMethodDefinition(parent)) {
+    return parent.key === node && parent.computed;
+  }
+
+  if (t.isImportSpecifier(parent)) {
     return false;
   }
 
-  // we're a catch clause param
-  if (t.isCatchClause(parent) && parent.param === node) return false;
+  if (t.isImportBatchSpecifier(parent)) {
+    return false;
+  }
 
-  // we're a variable declarator id so we aren't referenced
-  if (t.isVariableDeclarator(parent) && parent.id === node) return false;
+  if (t.isLabeledStatement(parent)) {
+    return false;
+  }
 
-  var isMemberExpression = t.isMemberExpression(parent);
+  if (t.isCatchClause(parent)) {
+    return parent.param !== node
+  }
 
-  // we're in a member expression and we're the computed property so we're referenced
-  var isComputedProperty = isMemberExpression && parent.property === node && parent.computed;
+  if (t.isVariableDeclarator(parent)) {
+    return parent.id !== node;
+  }
 
-  // we're in a member expression and we're the object so we're referenced
-  var isObject = isMemberExpression && parent.object === node;
+  if (t.isMemberExpression(parent)) {
+    if (parent.property === node && parent.computed) { // PARENT[NODE]
+      return true;
+    } else if (parent.object === node) { // NODE.child
+      return true;
+    } else {
+      return false;
+    }
+  }
 
-  // we are referenced
-  if (!isMemberExpression || isComputedProperty || isObject) return true;
-
-  return false;
+  return true;
 };
 
 /**