Cleanup isReferenced a bit (#7669)

* Cleanup isReferenced a bit

* Optimize isReferenced inside Functions

* Group return falses

packages/babel-types/src/validators/isReferenced.js

@@ -4,53 +4,26 @@
  */
 export default function isReferenced(node: Object, parent: Object): boolean {
   switch (parent.type) {
-    // yes: object::NODE
-    // yes: NODE::callee
-    case "BindExpression":
-      return parent.object === node || parent.callee === node;
-
     // yes: PARENT[NODE]
     // yes: NODE.child
     // no: parent.NODE
     case "MemberExpression":
     case "JSXMemberExpression":
     case "OptionalMemberExpression":
-      if (parent.property === node && parent.computed) {
+      if (parent.property === node) {
-        return true;
+        return !!parent.computed;
-      } else if (parent.object === node) {
-        return true;
-      } else {
-        return false;
-      }
-
-    // no: new.NODE
-    // no: NODE.target
-    case "MetaProperty":
-      return false;
-
-    // yes: { [NODE]: "" }
-    // yes: { NODE }
-    // no: { NODE: "" }
-    case "ObjectProperty":
-      if (parent.key === node) {
-        return parent.computed;
       }
+      return parent.object === node;
 
     // no: let NODE = init;
     // yes: let id = NODE;
     case "VariableDeclarator":
-      return parent.id !== node;
+      return parent.init === node;
 
-    // no: function NODE() {}
+    // yes: () => NODE
-    // no: function foo(NODE) {}
+    // no: (NODE) => {}
     case "ArrowFunctionExpression":
-    case "FunctionDeclaration":
+      return parent.body === node;
-    case "FunctionExpression":
-      for (const param of (parent.params: Array<any>)) {
-        if (param === node) return false;
-      }
-
-      return parent.id !== node;
 
     // no: export { foo as NODE };
     // yes: export { NODE as foo };
@@ -58,62 +31,32 @@ export default function isReferenced(node: Object, parent: Object): boolean {
     case "ExportSpecifier":
       if (parent.source) {
         return false;
-      } else {
-        return parent.local === node;
       }
+      return parent.local === node;
 
-    // no: export NODE from "foo";
+    // yes: { [NODE]: "" }
-    // no: export * as NODE from "foo";
+    // no: { NODE: "" }
-    case "ExportNamespaceSpecifier":
+    // depends: { NODE }
-    case "ExportDefaultSpecifier":
+    case "ObjectProperty":
-      return false;
-
-    // no: <div NODE="foo" />
-    case "JSXAttribute":
-      return parent.name !== node;
-
     // no: class { NODE = value; }
     // yes: class { [NODE] = value; }
     // yes: class { key = NODE; }
     case "ClassProperty":
     case "ClassPrivateProperty":
-      if (parent.key === node) {
+    // no: class { NODE() {} }
-        return !!parent.computed;
-      } else {
-        return parent.value === node;
-      }
-
-    // no: import NODE from "foo";
-    // no: import * as NODE from "foo";
-    // no: import { NODE as foo } from "foo";
-    // no: import { foo as NODE } from "foo";
-    // no: import NODE from "bar";
-    case "ImportDefaultSpecifier":
-    case "ImportNamespaceSpecifier":
-    case "ImportSpecifier":
-      return false;
-
-    // no: class NODE {}
-    case "ClassDeclaration":
-    case "ClassExpression":
-      return parent.id !== node;
-
     // yes: class { [NODE]() {} }
     case "ClassMethod":
     case "ObjectMethod":
-      return parent.key === node && parent.computed;
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+      return parent.value === node;
 
-    // no: NODE: for (;;) {}
+    // no: class NODE {}
-    case "LabeledStatement":
+    // yes: class Foo extends NODE {}
-      return false;
+    case "ClassDeclaration":
-
+    case "ClassExpression":
-    // no: try {} catch (NODE) {}
+      return parent.superClass === node;
-    case "CatchClause":
-      return parent.param !== node;
-
-    // no: function foo(...NODE) {}
-    case "RestElement":
-      return false;
 
     // yes: left = NODE;
     // no: NODE = right;
@@ -125,11 +68,54 @@ export default function isReferenced(node: Object, parent: Object): boolean {
     case "AssignmentPattern":
       return parent.right === node;
 
+    // no: NODE: for (;;) {}
+    case "LabeledStatement":
+      return false;
+
+    // no: try {} catch (NODE) {}
+    case "CatchClause":
+      return false;
+
+    // no: function foo(...NODE) {}
+    case "RestElement":
+      return false;
+
+    // no: function NODE() {}
+    // no: function foo(NODE) {}
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+      return false;
+
+    // no: export NODE from "foo";
+    // no: export * as NODE from "foo";
+    case "ExportNamespaceSpecifier":
+    case "ExportDefaultSpecifier":
+      return false;
+
+    // no: import NODE from "foo";
+    // no: import * as NODE from "foo";
+    // no: import { NODE as foo } from "foo";
+    // no: import { foo as NODE } from "foo";
+    // no: import NODE from "bar";
+    case "ImportDefaultSpecifier":
+    case "ImportNamespaceSpecifier":
+    case "ImportSpecifier":
+      return false;
+
+    // no: <div NODE="foo" />
+    case "JSXAttribute":
+      return false;
+
     // no: [NODE] = [];
     // no: ({ NODE }) = [];
     case "ObjectPattern":
     case "ArrayPattern":
       return false;
+
+    // no: new.NODE
+    // no: NODE.target
+    case "MetaProperty":
+      return false;
   }
 
   return true;