a few more changes

Author: bschlenk

package.json

@@ -35,6 +35,7 @@
     "lint": "eslint --ignore-path .gitignore --ext .js,.ts .",
     "spec": "jest --testPathIgnorePatterns test/e2e-repo.spec.ts /benchmarks-tmp",
     "spec:e2e": "jest test/e2e-repo.spec.ts",
+    "spec:watch": "npm run spec -- --watch",
     "test": "npm run lint && npm run build && npm run spec",
     "tsc": "tsc",
     "version": "npm run build"

src/helpers.ts

@@ -18,6 +18,8 @@ const BABEL_CONFIGS = [
   ".babelrc.cjs",
 ];
 
+export const GLOBALS = ["window", "globalThis"];
+
 /*
 3) Figures out which browsers user is targeting
 
@@ -38,9 +40,7 @@ export interface GuardedScope {
  * scope that the guard applies to and after which index it applies.
  * Should be called with either a bare Identifier or a MemberExpression.
  */
-export function determineGuardedScope(
-  node: (ESTree.Identifier | ESTree.MemberExpression) & Rule.NodeParentExtension
-): GuardedScope | null {
+export function determineGuardedScope(node: Rule.Node): GuardedScope | null {
   const result = getIfStatementAndGuardType(node);
   if (!result) return null;
 
@@ -71,15 +71,12 @@ export function isBlockOrProgram(
 }
 
 function getIfStatementAndGuardType(
-  node: (ESTree.Identifier | ESTree.MemberExpression) & Rule.NodeParentExtension
+  node: Rule.Node
 ): [ESTree.IfStatement & Rule.NodeParentExtension, boolean] | null {
   let positiveGuard = true;
   let expression: Rule.Node = node;
 
-  if (
-    node.parent?.type === "UnaryExpression" &&
-    node.parent.operator === "typeof"
-  ) {
+  if (isUnaryExpression(node.parent, "typeof")) {
     // unused typeof check
     if (node.parent.parent?.type !== "BinaryExpression") return null;
 
@@ -105,16 +102,21 @@ function getIfStatementAndGuardType(
       // typepf foo === "undefined"
       positiveGuard = false;
     }
+  } else if (isBinaryExpression(expression.parent, "in")) {
+    expression = expression.parent;
+  } else if (isBinaryExpression(expression.parent)) {
+    if (
+      expression.parent.right.type === "Identifier" &&
+      expression.parent.right.name === "undefined"
+    ) {
+    }
   }
 
   // !window.fetch
   // !!window.fetch
   // !!!!!!window.fetch
   // !(typeof fetch === "undefined")
-  while (
-    expression.parent?.type === "UnaryExpression" &&
-    expression.parent.operator === "!"
-  ) {
+  while (isUnaryExpression(expression.parent, "!")) {
     expression = expression.parent;
     positiveGuard = !positiveGuard;
   }
@@ -147,20 +149,37 @@ function ifStatementHasEarlyReturn(
   );
 }
 
-export function isInsideTypeofCheck(
-  node: ESTree.Identifier & Rule.NodeParentExtension
-) {
+export function isInsideTypeofCheck(node: Rule.Node) {
   return (
     node.parent.type === "UnaryExpression" && node.parent.operator === "typeof"
   );
 }
 
 function isStringLiteral(
-  node: ESTree.Node
-): node is ESTree.SimpleLiteral & { value: string } {
+  node: Rule.Node
+): node is ESTree.SimpleLiteral & { value: string } & Rule.NodeParentExtension {
   return node.type === "Literal" && typeof node.value === "string";
 }
 
+function isBinaryExpression(
+  node: Rule.Node,
+  operator?: string
+): node is ESTree.BinaryExpression & Rule.NodeParentExtension {
+  return (
+    node.type === "BinaryExpression" &&
+    (!operator || node.operator === operator)
+  );
+}
+
+function isUnaryExpression(
+  node: Rule.Node,
+  operator?: string
+): node is ESTree.UnaryExpression & Rule.NodeParentExtension {
+  return (
+    node.type === "UnaryExpression" && (!operator || node.operator === operator)
+  );
+}
+
 export function reverseTargetMappings<K extends string, V extends string>(
   targetMappings: Record<K, V>
 ): Record<V, K> {
@@ -170,6 +189,90 @@ export function reverseTargetMappings<K extends string, V extends string>(
   return Object.fromEntries(reversedEntries);
 }
 
+export function topmostIdentifierOrMemberExpression(
+  node: Rule.Node
+):
+  | ((ESTree.Identifier | ESTree.MemberExpression) & Rule.NodeParentExtension)
+  | null {
+  switch (node.type) {
+    case "Identifier":
+    case "MemberExpression": {
+      if (node.parent.type !== "MemberExpression") return node;
+
+      let expression = node.parent;
+      while (expression.parent.type === "MemberExpression") {
+        expression = expression.parent;
+      }
+
+      return expression;
+    }
+
+    default:
+      return null;
+  }
+}
+
+interface IdentifierProtoChain {
+  protoChain: string[];
+  expression: Rule.Node;
+}
+
+export function identifierProtoChain(
+  node: ESTree.Identifier & Rule.NodeParentExtension
+): null | IdentifierProtoChain {
+  const result = identifierProtoChainHelper(node);
+  if (!result) return null;
+
+  const { expression, protoChain } = result;
+
+  if (
+    isBinaryExpression(expression, "in") &&
+    isStringLiteral(expression.left)
+  ) {
+    // e.g. `if ("fetch" in window) {}`
+    protoChain.push(expression.left.value);
+  }
+
+  return { expression, protoChain };
+}
+
+/**
+ * Returns an array of property names from the given identifier, without any leading
+ * window or globalThis.
+ */
+function identifierProtoChainHelper(
+  node: ESTree.Identifier & Rule.NodeParentExtension
+): null | IdentifierProtoChain {
+  const expression = topmostIdentifierOrMemberExpression(node);
+  if (!expression) return null;
+
+  const protoChain: string[] = [];
+
+  const protoChainFromMemberExpressionObject = (obj: ESTree.Node) => {
+    if (obj.type === "Identifier") {
+      protoChain.push(obj.name);
+      return true;
+    }
+
+    if (obj.type === "MemberExpression") {
+      if (obj.property.type !== "Identifier") return false;
+      if (!protoChainFromMemberExpressionObject(obj.object)) return false;
+      protoChain.push(obj.property.name);
+      return true;
+    }
+
+    return false;
+  };
+
+  if (!protoChainFromMemberExpressionObject(expression)) return null;
+
+  if (GLOBALS.includes(protoChain[0])) {
+    protoChain.shift();
+  }
+
+  return { expression, protoChain };
+}
+
 /**
  * Determine the settings to run this plugin with, including the browserslist targets and
  * whether to lint all ES APIs.

src/rules/compat.ts

@@ -14,6 +14,8 @@ import {
   determineGuardedScope,
   GuardedScope,
   isBlockOrProgram,
+  identifierProtoChain,
+  GLOBALS,
 } from "../helpers"; // will be deprecated and introduced to this file
 import {
   AstMetadataApiWithTargetsResolver,
@@ -22,6 +24,19 @@ import {
 } from "../types";
 import { nodes } from "../providers";
 
+function getErrorNode(node: Rule.Node): Rule.Node {
+  switch (node.type) {
+    case "MemberExpression": {
+      return node.property;
+    }
+    case "Identifier": {
+      return node;
+    }
+    default:
+      throw new Error("not found");
+  }
+}
+
 function getName(node: Rule.Node): string {
   switch (node.type) {
     case "Identifier": {
@@ -71,12 +86,14 @@ const getRulesForTargets = memoize(
 
     const result: Record<string, AstMetadataApiWithTargetsResolver> = {};
 
-    nodes
-      .filter((node) => (lintAllEsApis ? true : node.kind !== "es"))
-      .forEach((node) => {
-        if (!node.getUnsupportedTargets(targets).length) return;
-        result[node.property || node.object] = node;
-      });
+    for (const node of nodes) {
+      if (
+        (lintAllEsApis || node.kind !== "es") &&
+        node.getUnsupportedTargets(targets).length > 0
+      ) {
+        result[node.protoChainId] = node;
+      }
+    }
 
     return result;
   }
@@ -114,8 +131,12 @@ const ruleModule: Rule.RuleModule = {
       eslintNode: Rule.Node
     ) => {
       if (isPolyfilled(context, node)) return;
+
+      // TODO: name should never include leading "window" or "globalThis"
+      // and location should also not include it, we have to compute location ourselves
+
       errors.push({
-        node: eslintNode,
+        node: getErrorNode(eslintNode),
         message: [
           generateErrorName(node),
           "is not supported in",
@@ -165,49 +186,28 @@ const ruleModule: Rule.RuleModule = {
           }
         }
 
+        // Check if identifier is one we care about
+        const result = identifierProtoChain(node);
+        if (!result) return;
+
         // Check if the identifier name matches any of the ones in our list
-        const name = node.name;
-        const rule = targetedRules[name];
+        const protoChainId = result.protoChain.join(".");
+        const rule = targetedRules[protoChainId];
         if (!rule) return;
 
+        // If this a bare Identifier, not window / globalThis, and not used in a `typeof`
+        // expression, then we can error immediately
         if (
-          node.parent.type !== "MemberExpression" &&
-          !isInsideTypeofCheck(node)
+          result.expression.type === "Identifier" &&
+          !GLOBALS.includes(result.expression.name) &&
+          !isInsideTypeofCheck(result.expression)
         ) {
-          // This will always produce a ReferenceError in unsupported browsers
+          // This will always produce a `ReferenceError` in unsupported browsers
           handleFailingRule(rule, node);
           return;
         }
 
-        let object = "window";
-
-        let expression: Rule.Node = node;
-        if (expression.parent.type === "MemberExpression") {
-          expression = expression.parent;
-          if (expression.object.type === "MemberExpression") {
-            // thing.Promise.all, thing.thing.Promise.all, ignore this
-            if (
-              expression.object.object.type !== "Literal" ||
-              expression.object.object.value !== "window" ||
-              expression.object.property.type !== "Identifier"
-            ) {
-              return;
-            }
-
-            // window.Promise.all, for example
-            object = expression.object.property.name;
-          } else if (expression.object.type === "Identifier") {
-            object = expression.object.name;
-          } else {
-            // unrecognized syntax
-            return;
-          }
-        }
-
-        // This doesn't actually match our rule, like `Thing.all`
-        if (object !== "window" && rule.object !== object) return;
-
-        const scope = determineGuardedScope(expression);
+        const scope = determineGuardedScope(result.expression);
         if (!scope) {
           // this node isn't guarding an if statement, so we can report an error
           handleFailingRule(rule, expression);