refactor: less abstraction

Author: Rel1cx

packages/plugins/eslint-plugin-react-x/src/rules/no-access-state-in-setstate.ts

@@ -1,10 +1,11 @@
 import * as AST from "@eslint-react/ast";
 import { isClassComponent, isThisSetState } from "@eslint-react/core";
-import { _ } from "@eslint-react/eff";
+import { _, constFalse, constTrue } from "@eslint-react/eff";
 import type { RuleFeature } from "@eslint-react/shared";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import type { TSESTree } from "@typescript-eslint/utils";
 import type { CamelCase } from "string-ts";
+import { match } from "ts-pattern";
 
 import { createRule } from "../utils";
 
@@ -16,6 +17,21 @@ export const RULE_FEATURES = [
 
 export type MessageID = CamelCase<typeof RULE_NAME>;
 
+function isKeyLiteral(
+  node:
+    | TSESTree.MemberExpression
+    | TSESTree.MethodDefinition
+    | TSESTree.Property
+    | TSESTree.PropertyDefinition,
+  key: TSESTree.Node,
+) {
+  return match(key)
+    .with({ type: T.Literal }, constTrue)
+    .with({ type: T.TemplateLiteral, expressions: [] }, constTrue)
+    .with({ type: T.Identifier }, () => !node.computed)
+    .otherwise(constFalse);
+}
+
 function getName(node: TSESTree.Expression | TSESTree.PrivateIdentifier): string | _ {
   if (AST.isTsOnlyExpression(node)) {
     return getName(node.expression);
@@ -142,7 +158,7 @@ export default createRule<[], MessageID>({
           .properties
           .some((prop) =>
             prop.type === T.Property
-            && AST.isKeyLiteralLike(prop, prop.key)
+            && isKeyLiteral(prop, prop.key)
             && getName(prop.key) === "state"
           );
         if (!hasState) {

packages/plugins/eslint-plugin-react-x/src/rules/no-unused-class-component-members.ts

@@ -1,10 +1,11 @@
 import * as AST from "@eslint-react/ast";
 import { isClassComponent } from "@eslint-react/core";
-import { _ } from "@eslint-react/eff";
+import { _, constFalse, constTrue } from "@eslint-react/eff";
 import type { RuleFeature } from "@eslint-react/shared";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import type { TSESTree } from "@typescript-eslint/utils";
 import type { CamelCase } from "string-ts";
+import { match } from "ts-pattern";
 
 import { createRule } from "../utils";
 
@@ -38,6 +39,21 @@ const LIFECYCLE_METHODS = new Set([
   "UNSAFE_componentWillUpdate",
 ]);
 
+function isKeyLiteral(
+  node:
+    | TSESTree.MemberExpression
+    | TSESTree.MethodDefinition
+    | TSESTree.Property
+    | TSESTree.PropertyDefinition,
+  key: TSESTree.Node,
+) {
+  return match(key)
+    .with({ type: T.Literal }, constTrue)
+    .with({ type: T.TemplateLiteral, expressions: [] }, constTrue)
+    .with({ type: T.Identifier }, () => !node.computed)
+    .otherwise(constFalse);
+}
+
 // Return the name of an identifier or the string value of a literal. Useful
 // anywhere that a literal may be used as a key (e.g., member expressions,
 // method definitions, ObjectExpression property keys).
@@ -123,7 +139,7 @@ export default createRule<[], MessageID>({
       if (node.static) {
         return;
       }
-      if (AST.isKeyLiteralLike(node, node.key)) {
+      if (isKeyLiteral(node, node.key)) {
         propertyDefs.get(currentClass)?.add(node.key);
       }
     }
@@ -145,7 +161,7 @@ export default createRule<[], MessageID>({
         if (!isClassComponent(currentClass) || currentMethod.static) {
           return;
         }
-        if (!AST.isThisExpression(node.object) || !AST.isKeyLiteralLike(node, node.property)) {
+        if (!AST.isThisExpression(node.object) || !isKeyLiteral(node, node.property)) {
           return;
         }
         if (node.parent.type === T.AssignmentExpression && node.parent.left === node) {
@@ -175,7 +191,7 @@ export default createRule<[], MessageID>({
         // detect `{ foo, bar: baz } = this`
         if (node.init != null && AST.isThisExpression(node.init) && node.id.type === T.ObjectPattern) {
           for (const prop of node.id.properties) {
-            if (prop.type === T.Property && AST.isKeyLiteralLike(prop, prop.key)) {
+            if (prop.type === T.Property && isKeyLiteral(prop, prop.key)) {
               const keyName = getName(prop.key);
               if (keyName != null) {
                 propertyUsages.get(currentClass)?.add(keyName);

packages/plugins/eslint-plugin-react-x/src/rules/no-unused-state.ts

@@ -1,11 +1,11 @@
 import * as AST from "@eslint-react/ast";
 import { isClassComponent, isGetDerivedStateFromProps } from "@eslint-react/core";
-import { _ } from "@eslint-react/eff";
+import { _, constFalse, constTrue } from "@eslint-react/eff";
 import type { RuleFeature } from "@eslint-react/shared";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import type { TSESTree } from "@typescript-eslint/utils";
 import type { CamelCase } from "string-ts";
-import { isMatching, P } from "ts-pattern";
+import { isMatching, match, P } from "ts-pattern";
 
 import { createRule } from "../utils";
 
@@ -17,6 +17,21 @@ export const RULE_FEATURES = [
 
 export type MessageID = CamelCase<typeof RULE_NAME>;
 
+function isKeyLiteral(
+  node:
+    | TSESTree.MemberExpression
+    | TSESTree.MethodDefinition
+    | TSESTree.Property
+    | TSESTree.PropertyDefinition,
+  key: TSESTree.Node,
+) {
+  return match(key)
+    .with({ type: T.Literal }, constTrue)
+    .with({ type: T.TemplateLiteral, expressions: [] }, constTrue)
+    .with({ type: T.Identifier }, () => !node.computed)
+    .otherwise(constFalse);
+}
+
 function getName(node: TSESTree.Expression | TSESTree.PrivateIdentifier): string | _ {
   if (AST.isTsOnlyExpression(node)) {
     return getName(node.expression);
@@ -179,7 +194,7 @@ export default createRule<[], MessageID>({
           return;
         }
         const hasState = node.id.properties.some((prop) => {
-          if (prop.type === T.Property && AST.isKeyLiteralLike(prop, prop.key)) {
+          if (prop.type === T.Property && isKeyLiteral(prop, prop.key)) {
             return getName(prop.key) === "state";
           }
           return false;

packages/plugins/eslint-plugin-react-x/src/rules/no-use-context.ts

@@ -1,12 +1,13 @@
 import { isReactHookCall, isReactHookCallWithNameAlias } from "@eslint-react/core";
-import type { RuleFeature } from "@eslint-react/shared";
+import type { RuleContext, RuleFeature } from "@eslint-react/shared";
 import { getSettingsFromContext } from "@eslint-react/shared";
+import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import { compare } from "compare-versions";
 import type { CamelCase } from "string-ts";
 import { isMatching } from "ts-pattern";
 
-import { createRule, getAssociatedTokens } from "../utils";
+import { createRule } from "../utils";
 
 export const RULE_NAME = "no-use-context";
 
@@ -102,3 +103,24 @@ export default createRule<[], MessageID>({
   },
   defaultOptions: [],
 });
+
+function getAssociatedTokens(context: RuleContext, node: TSESTree.Node) {
+  {
+    const tokenBefore = context.sourceCode.getTokenBefore(node);
+    const tokenAfter = context.sourceCode.getTokenAfter(node);
+    const tokens = [];
+
+    // If this is not the only entry, then the line above this one
+    // will become the last line, and should not have a trailing comma.
+    if (tokenAfter?.value !== "," && tokenBefore?.value === ",") {
+      tokens.push(tokenBefore);
+    }
+
+    // If this is not the last entry, then we need to remove the comma from this line.
+    if (tokenAfter?.value === ",") {
+      tokens.push(tokenAfter);
+    }
+
+    return tokens;
+  }
+}

packages/plugins/eslint-plugin-react-x/src/utils/get-associated-tokens.ts

@@ -1,2 +1 @@
 export * from "./create-rule";
-export * from "./get-associated-tokens";

packages/plugins/eslint-plugin-react-x/src/utils/index.ts

@@ -8,14 +8,13 @@ export * from "./get-nested-expressions";
 export * from "./get-nested-identifiers";
 export * from "./get-nested-return-statements";
 export * from "./get-top-level-identifier";
-export * from "./is";
 export * from "./is-empty-function";
-export * from "./is-key-literal";
 export * from "./is-kind-of-literal";
 export * from "./is-map-call";
 export * from "./is-multi-line";
 export * from "./is-node-equal";
 export * from "./is-this-expression";
+export * from "./is";
 export * from "./to-readable-node-name";
 export * from "./to-readable-node-type";
-export type * from "./types";
+export * from "./types";