@qq99/eslint-plugin-solid 0.18.0-no-reactive-read-in-effect-callback.0

package/src/rules/no-reactive-read-in-effect-callback.ts

@@ -0,0 +1,570 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+import { TSESTree as T, ESLintUtils } from "@typescript-eslint/utils";
+import { findVariable } from "../compat";
+import { createReactiveImportResolver } from "../utils/reactive-imports";
+import {
+  Value,
+  object,
+  scalar,
+  setter,
+  container,
+  asStore,
+  propertyValue,
+  propertyName,
+  mergeValues,
+  awaitedValue,
+  promiseValue,
+  hasKind,
+  callResult,
+  propertiesOf,
+  iteratorValue,
+  iterationValue,
+  iterationReturn,
+  computationValue,
+} from "../utils/reactive-values";
+import {
+  FunctionNode,
+  getSolidSourceRegex,
+  ignoreTransparentWrappers,
+  isFunctionNode,
+  isPropsByName,
+  isSolidV2,
+} from "../utils";
+
+type MessageIds = "untrackedRead";
+type Options = [{ reactiveObjectFactories?: string[] }];
+type Variable = TSESLint.Scope.Variable;
+type Bindings = Map<Variable, Value>;
+
+/**
+ * Track the shape of values crossing the compute/apply boundary. Plain
+ * containers can retain proxies or accessors in individual fields; copying a
+ * container is not necessarily a snapshot. Imported return values are traced
+ * through bounded local source analysis, not a full project type check.
+ */
+export default ESLintUtils.RuleCreator.withoutDocs<Options, MessageIds>({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow reading reactive values in the untracked apply callback of a Solid 2 split effect.",
+      url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-reactive-read-in-effect-callback.md",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          reactiveObjectFactories: {
+            type: "array",
+            items: { type: "string" },
+            uniqueItems: true,
+            description: "Local names of additional functions that return reactive objects.",
+            default: [],
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      untrackedRead:
+        "Reactive value '{{name}}' is read in an untracked effect callback. Read it in the compute function and pass a plain snapshot to the callback.",
+    },
+  },
+  defaultOptions: [{ reactiveObjectFactories: [] }],
+  create(context, [options]) {
+    if (!isSolidV2(context)) return {};
+
+    const sourceCode = context.sourceCode;
+    const solidSource = getSolidSourceRegex(context);
+    const { value: importedValue, type: typeOf } = createReactiveImportResolver(
+      context.physicalFilename,
+      solidSource,
+      sourceCode.text
+    );
+    const factories = new Set(options.reactiveObjectFactories);
+    const reported = new Set<number>();
+    const parameterReads = new WeakMap<Bindings, T.Node[]>();
+
+    const unwrap = (node: T.Node): T.Node =>
+      node.type === "ChainExpression" ? unwrap(node.expression) : ignoreTransparentWrappers(node);
+
+    // Resolve only stable local aliases, with a guard for circular definitions.
+    const resolve = (node: T.Node | undefined, seen = new Set<T.Node>()): T.Node | undefined => {
+      if (!node) return undefined;
+      node = unwrap(node);
+      if (seen.has(node)) return undefined;
+      seen.add(node);
+      if (node.type === "Identifier") {
+        const variable = findVariable(context, node);
+        const def = variable?.defs[0];
+        if (def?.type === "FunctionName") return def.node;
+        if (
+          def?.type === "Variable" &&
+          def.node.id.type === "Identifier" &&
+          !variable?.references.some((ref) => ref.isWrite() && !ref.init)
+        ) {
+          return resolve(def.node.init ?? undefined, seen);
+        }
+      }
+      if (node.type === "MemberExpression") {
+        const base = resolve(node.object, seen);
+        const key = propertyName(node.property, node.computed);
+        if (base?.type === "ObjectExpression" && key !== null) {
+          const property = base.properties.find(
+            (p) => p.type === "Property" && propertyName(p.key, p.computed) === key
+          );
+          if (property?.type === "Property") return resolve(property.value, seen);
+        }
+      }
+      return node;
+    };
+
+    const resolveFunction = (node: T.Node | undefined): FunctionNode | null => {
+      const resolved = resolve(node);
+      return isFunctionNode(resolved) ? resolved : null;
+    };
+
+    // Resolve the binding, not just its spelling: aliases, namespaces and
+    // shadowed imports must all have the same behavior.
+    const importedBinding = (node: T.Node): { source: string; name: string } | null => {
+      node = resolve(node) ?? node;
+      const id =
+        node.type === "Identifier"
+          ? node
+          : node.type === "MemberExpression" && node.object.type === "Identifier"
+          ? node.object
+          : null;
+      if (!id) return null;
+      const def = findVariable(context, id)?.defs[0];
+      if (
+        def?.type !== "ImportBinding" ||
+        def.parent.type !== "ImportDeclaration" ||
+        def.parent.importKind === "type"
+      )
+        return null;
+      if (node.type === "Identifier" && def.node.type === "ImportSpecifier") {
+        if (def.node.importKind === "type") return null;
+        const name =
+          def.node.imported.type === "Identifier"
+            ? def.node.imported.name
+            : def.node.imported.value;
+        return { source: def.parent.source.value, name };
+      }
+      if (node.type === "Identifier" && def.node.type === "ImportDefaultSpecifier") {
+        return { source: def.parent.source.value, name: "default" };
+      }
+      if (node.type === "MemberExpression" && def.node.type === "ImportNamespaceSpecifier") {
+        const name = propertyName(node.property, node.computed);
+        return name === null ? null : { source: def.parent.source.value, name };
+      }
+      return null;
+    };
+
+    const solidImport = (node: T.Node): string | null => {
+      const binding = importedBinding(node);
+      return binding && solidSource.test(binding.source) ? binding.name : null;
+    };
+
+    const isCallbackPropCall = (node: T.MemberExpression, env: Bindings): boolean => {
+      // Conventional event callbacks are imperative, not dependencies. Limit
+      // this to direct calls on props with a known void callback signature;
+      // ordinary data props, accessor props, and store methods still warn.
+      const name = propertyName(node.property, node.computed);
+      if (
+        !name ||
+        !/^on[A-Z]/.test(name) ||
+        node.parent.type !== "CallExpression" ||
+        node.parent.callee !== node
+      )
+        return false;
+      const base = resolve(node.object);
+      if (base?.type !== "Identifier" || !isPropsByName(base.name)) return false;
+      const variable = findVariable(context, base);
+      return (
+        variable?.defs[0]?.type === "Parameter" &&
+        !env.has(variable) &&
+        typeOf(node.range) === "callback"
+      );
+    };
+
+    const report = (node: T.Node): void => {
+      if (reported.has(node.range[0])) return;
+      reported.add(node.range[0]);
+      context.report({
+        node,
+        messageId: "untrackedRead",
+        data: { name: sourceCode.getText(node) },
+      });
+    };
+
+    // Parser visitor keys exclude parent links and include TS/JSX nodes.
+    // Nested functions are visited only for known calls. Async helpers called
+    // by apply remain untracked on both sides of their suspension points.
+    const walk = (node: T.Node, visit: (node: T.Node) => void): void => {
+      if (isFunctionNode(node)) return;
+      visit(node);
+      for (const key of sourceCode.visitorKeys[node.type] ?? []) {
+        const child = (node as unknown as Record<string, unknown>)[key];
+        if (Array.isArray(child)) {
+          for (const item of child) if (item?.type) walk(item as T.Node, visit);
+        } else if (child && typeof child === "object" && "type" in child) {
+          walk(child as T.Node, visit);
+        }
+      }
+    };
+
+    const returns = (fn: FunctionNode): T.Node[] => {
+      if (fn.body.type !== "BlockStatement") return [fn.body];
+      const result: T.Node[] = [];
+      walk(fn.body, (node) => {
+        if (node.type === "ReturnStatement" && node.argument) result.push(node.argument);
+      });
+      return result;
+    };
+
+    const bind = (
+      pattern: T.Node,
+      value: Value,
+      env: Bindings,
+      check = false,
+      seen = new Set<T.Node>()
+    ): void => {
+      if (seen.has(pattern)) return;
+      const next = new Set(seen).add(pattern);
+      if (pattern.type === "Identifier") {
+        const variable = findVariable(context, pattern);
+        if (variable) env.set(variable, value);
+      } else if (pattern.type === "AssignmentPattern") {
+        if (check && !value) parameterReads.get(env)?.push(pattern.right);
+        bind(pattern.left, value ?? infer(pattern.right, env, next), env, check, next);
+      } else if (pattern.type === "ObjectPattern") {
+        for (const property of pattern.properties) {
+          if (check && hasKind(value, "object")) report(property);
+          if (property.type === "RestElement") {
+            bind(
+              property.argument,
+              { kind: "plain", properties: new Map(propertiesOf(value)) },
+              env,
+              false,
+              next
+            );
+          } else {
+            if (check && property.computed) parameterReads.get(env)?.push(property.key);
+            bind(
+              property.value,
+              propertyValue(value, propertyName(property.key, property.computed)),
+              env,
+              check,
+              next
+            );
+          }
+        }
+      } else if (pattern.type === "ArrayPattern") {
+        if (check && hasKind(value, "object")) report(pattern);
+        pattern.elements.forEach((element, index) => {
+          if (element) bind(element, propertyValue(value, String(index)), env, check, next);
+        });
+      } else if (pattern.type === "RestElement") {
+        bind(pattern.argument, value, env, check, next);
+      }
+    };
+
+    const callBindings = (
+      fn: FunctionNode,
+      args: Value[],
+      env: Bindings,
+      check = false,
+      seen = new Set<T.Node>()
+    ): Bindings => {
+      const local = new Map(env);
+      if (check) parameterReads.set(local, []);
+      fn.params.forEach((param, index) => {
+        const value =
+          param.type === "RestElement"
+            ? container(args.slice(index).map((arg, i) => [String(i), arg]))
+            : args[index] ?? null;
+        bind(param, value, local, check, seen);
+      });
+      return local;
+    };
+
+    const resultOf = (fn: FunctionNode, env: Bindings, seen: Set<T.Node>): Value => {
+      if (seen.has(fn)) return null;
+      const next = new Set(seen).add(fn);
+      const result = returns(fn).reduce<Value>(
+        (value, node) => mergeValues(value, infer(node, env, next)),
+        null
+      );
+      if (fn.generator) {
+        let yielded: Value = null;
+        walk(fn.body, (node) => {
+          if (node.type !== "YieldExpression" || !node.argument) return;
+          const value = infer(node.argument, env, next);
+          yielded = mergeValues(yielded, node.delegate ? iterationValue(value) : value);
+        });
+        return iteratorValue(fn.async, yielded, result);
+      }
+      return fn.async ? promiseValue(result) : result;
+    };
+
+    const computeValue = (
+      node: T.Node | undefined,
+      env: Bindings,
+      seen = new Set<T.Node>()
+    ): Value => {
+      if (!node) return null;
+      const fn = resolveFunction(node);
+      if (fn) return computationValue(resultOf(fn, env, seen));
+      const binding = importedBinding(node);
+      return computationValue(
+        binding
+          ? importedValue(binding.source, binding.name, [])
+          : callResult(infer(node, env, seen))
+      );
+    };
+
+    const infer = (input: T.Node | undefined, env: Bindings, seen = new Set<T.Node>()): Value => {
+      if (!input) return null;
+      const node = unwrap(input);
+      if (seen.has(node)) return null;
+      const next = new Set(seen).add(node);
+      if (node.type === "AwaitExpression") return awaitedValue(infer(node.argument, env, next));
+      if (node.type === "YieldExpression") {
+        if (!node.delegate) return null;
+        const result = iterationReturn(infer(node.argument ?? undefined, env, next));
+        let parent: T.Node | undefined = node.parent;
+        while (parent && !isFunctionNode(parent)) parent = parent.parent;
+        return parent && isFunctionNode(parent) && parent.async ? awaitedValue(result) : result;
+      }
+      if (node.type === "Identifier") {
+        const variable = findVariable(context, node);
+        if (!variable) return null;
+        if (env.has(variable)) return env.get(variable)!;
+        const def = variable.defs[0];
+        if (def?.type === "ImportBinding") {
+          const binding = importedBinding(node);
+          return binding ? importedValue(binding.source, binding.name) : null;
+        }
+        if (def?.type === "Parameter") return isPropsByName(node.name) ? object : null;
+        if (def?.type !== "Variable" || !def.node.init || seen.has(def.node)) return null;
+        if (variable.references.some((ref) => ref.isWrite() && !ref.init)) return null;
+        next.add(def.node);
+        const value = infer(def.node.init, env, next);
+        const bindings = new Map<Variable, Value>();
+        bind(def.node.id, value, bindings, false, next);
+        return bindings.get(variable) ?? null;
+      }
+      if (node.type === "MemberExpression") {
+        const value = propertyValue(
+          infer(node.object, env, next),
+          propertyName(node.property, node.computed)
+        );
+        // Reading a scalar field is still reactive, but its copied result is
+        // not a proxy. Refine only the value, never suppress the original read.
+        return (value === null || value.kind === "object") && typeOf(node.range) === "scalar"
+          ? scalar
+          : value;
+      }
+      if (
+        node.type === "Literal" ||
+        node.type === "TemplateLiteral" ||
+        node.type === "BinaryExpression" ||
+        node.type === "UnaryExpression"
+      )
+        return scalar;
+      if (node.type === "ObjectExpression") {
+        const properties = new Map<string, Value>();
+        for (const property of node.properties) {
+          if (property.type === "SpreadElement") {
+            const value = infer(property.argument, env, next);
+            for (const [key, entry] of propertiesOf(value)) properties.set(key, entry);
+          } else {
+            const key = propertyName(property.key, property.computed);
+            if (key !== null) properties.set(key, infer(property.value, env, next));
+          }
+        }
+        return { kind: "plain", properties };
+      }
+      if (node.type === "ArrayExpression") {
+        return container(
+          node.elements.map((element, i) => [String(i), infer(element ?? undefined, env, next)])
+        );
+      }
+      if (node.type === "ConditionalExpression") {
+        return mergeValues(infer(node.consequent, env, next), infer(node.alternate, env, next));
+      }
+      if (node.type === "LogicalExpression") {
+        return mergeValues(infer(node.left, env, next), infer(node.right, env, next));
+      }
+      if (node.type === "CallExpression") {
+        // Only the unshadowed built-in Promise.resolve has these semantics.
+        if (
+          node.callee.type === "MemberExpression" &&
+          node.callee.object.type === "Identifier" &&
+          node.callee.object.name === "Promise" &&
+          propertyName(node.callee.property, node.callee.computed) === "resolve"
+        ) {
+          const variable = findVariable(context, node.callee.object);
+          if (!variable?.defs.length && !variable?.references.some((ref) => ref.isWrite()))
+            return promiseValue(infer(node.arguments[0], env, next));
+        }
+        const primitive = solidImport(node.callee);
+        const first = node.arguments[0];
+        const fn = resolveFunction(first);
+        if (
+          primitive === "createSignal" ||
+          primitive === "createOptimistic" ||
+          primitive === "createMemo"
+        ) {
+          // Solid unwraps async computations, but a signal initialized with a
+          // Promise as data still holds that Promise.
+          const result = computeValue(first, env, next) ?? infer(first, env, next);
+          const accessor: Value = { kind: "accessor", result };
+          return primitive === "createMemo"
+            ? accessor
+            : container([
+                ["0", accessor],
+                ["1", setter],
+              ]);
+        }
+        if (
+          primitive === "createStore" ||
+          primitive === "createOptimisticStore" ||
+          primitive === "createProjection"
+        ) {
+          const initial = fn ? node.arguments[1] : first;
+          const value = asStore(infer(initial, env, next)) ?? object;
+          return primitive === "createProjection"
+            ? value
+            : container([
+                ["0", value],
+                ["1", setter],
+              ]);
+        }
+        if (primitive === "omit") return infer(first, env, next);
+        if (primitive === "merge") {
+          return node.arguments.reduce<Value>(
+            (value, arg) => mergeValues(value, infer(arg, env, next)),
+            null
+          );
+        }
+        if (node.callee.type === "Identifier" && factories.has(node.callee.name)) return object;
+        const binding = importedBinding(node.callee);
+        if (binding) {
+          return importedValue(
+            binding.source,
+            binding.name,
+            node.arguments.map((arg) => infer(arg, env, next))
+          );
+        }
+        const callee = infer(node.callee, env, next);
+        if (hasKind(callee, "accessor")) return callResult(callee);
+        const called = resolveFunction(node.callee);
+        if (called && !next.has(called)) {
+          return resultOf(
+            called,
+            callBindings(
+              called,
+              node.arguments.map((arg) => infer(arg, env, next)),
+              env,
+              false,
+              new Set(next).add(called)
+            ),
+            next
+          );
+        }
+      }
+      return null;
+    };
+
+    const analyze = (fn: FunctionNode, env: Bindings, active = new Set<FunctionNode>()): void => {
+      if (active.has(fn) || fn.generator) return;
+      const next = new Set(active).add(fn);
+      // Default parameter expressions also execute in the apply phase.
+      const visit = (node: T.Node): void => {
+        if (node.type === "VariableDeclarator" && node.init) {
+          bind(node.id, infer(node.init, env), env, true);
+        } else if (node.type === "AssignmentExpression") {
+          bind(node.left, infer(node.right, env), env, true);
+        } else if (node.type === "SpreadElement" && hasKind(infer(node.argument, env), "object")) {
+          report(node);
+        } else if (node.type === "MemberExpression" && hasKind(infer(node.object, env), "object")) {
+          const parent = node.parent;
+          if (
+            !isCallbackPropCall(node, env) &&
+            !(
+              parent?.type === "AssignmentExpression" &&
+              parent.left === node &&
+              parent.operator === "="
+            )
+          ) {
+            report(node);
+          }
+        }
+        if (node.type !== "CallExpression") return;
+        const callee = infer(node.callee, env);
+        if (hasKind(callee, "accessor")) report(node);
+        const called = resolveFunction(node.callee);
+        if (called) {
+          analyze(
+            called,
+            callBindings(
+              called,
+              node.arguments.map((arg) => infer(arg, env)),
+              env,
+              true
+            ),
+            next
+          );
+        } else if (hasKind(callee, "setter")) {
+          const updater = resolveFunction(node.arguments[0]);
+          // The setter's previous value/draft is safe; captured values are not.
+          if (updater) analyze(updater, callBindings(updater, [], env, true), next);
+        } else if (
+          node.callee.type === "MemberExpression" &&
+          ["forEach", "map", "filter", "some", "every", "find", "findIndex", "flatMap"].includes(
+            propertyName(node.callee.property, node.callee.computed) ?? ""
+          )
+        ) {
+          const callback = resolveFunction(node.arguments[0]);
+          if (callback) {
+            const item = propertyValue(infer(node.callee.object, env), "0");
+            analyze(callback, callBindings(callback, [item], env, true), next);
+          }
+        }
+      };
+      for (const expression of parameterReads.get(env) ?? []) walk(expression, visit);
+      walk(fn.body, visit);
+    };
+
+    const effects: T.CallExpression[] = [];
+    return {
+      CallExpression(node) {
+        effects.push(node);
+      },
+      "Program:exit"() {
+        for (const node of effects) {
+          if (
+            !["createEffect", "createRenderEffect"].includes(solidImport(node.callee) ?? "") ||
+            node.arguments.length < 2
+          )
+            continue;
+          let apply = resolveFunction(node.arguments[1]);
+          if (!apply) {
+            const bundle = resolve(node.arguments[1]);
+            if (bundle?.type === "ObjectExpression") {
+              const effect = bundle.properties.find(
+                (p) => p.type === "Property" && propertyName(p.key, p.computed) === "effect"
+              );
+              if (effect?.type === "Property") apply = resolveFunction(effect.value);
+            }
+          }
+          if (!apply) continue;
+          const env: Bindings = new Map();
+          const value = computeValue(node.arguments[0], env);
+          analyze(apply, callBindings(apply, [value, value], env, true));
+        }
+      },
+    };
+  },
+});

package/src/rules/no-restated-default-options.ts

@@ -0,0 +1,96 @@
+/**
+ * FIXME: remove this comments and import when below issue is fixed.
+ * This import is necessary for type generation due to a bug in the TypeScript compiler.
+ * See: https://github.com/microsoft/TypeScript/issues/42873
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import type { TSESLint } from "@typescript-eslint/utils";
+
+import { TSESTree as T, ESLintUtils, ASTUtils } from "@typescript-eslint/utils";
+import { getSolidSourceRegex, trackImports } from "../utils";
+import { getScope } from "../compat";
+
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+
+type MessageIds = "restatedDefault";
+type Options = [];
+
+// Defaults verified against the Solid 2.0 RC source (client/flow.ts):
+// <For> is keyed by default; <Show> and <Match> are non-keyed by default.
+const JSX_PROP_DEFAULTS: Record<string, Record<string, boolean>> = {
+  For: { keyed: true },
+  Show: { keyed: false },
+  Match: { keyed: false },
+};
+
+/*
+ * Explicitly passing a prop's default value is noise that AI-generated code
+ * produces constantly. Same category as typescript-eslint's
+ * no-unnecessary-type-arguments: opt-in, stylistic, autofixable.
+ */
+export default createRule<Options, MessageIds>({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow restating a prop or option value that is already the default.",
+      url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-restated-default-options.md",
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      restatedDefault:
+        "Passing `{{prop}}={{{value}}}` restates the default for `<{{component}}>`; omit it.",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const { matchImport, handleImportDeclaration } = trackImports(getSolidSourceRegex(context));
+    return {
+      ImportDeclaration: handleImportDeclaration,
+      JSXAttribute(node) {
+        if (node.name.type !== "JSXIdentifier") return;
+        const element = node.parent as T.JSXOpeningElement;
+        if (element.name.type !== "JSXIdentifier") return;
+
+        // Resolve through the import map so aliased Solid imports match and a
+        // same-named component from another library (or a local declaration)
+        // never does. An *unbound* <For>/<Show>/<Match> is still Solid's: the
+        // compiler auto-imports the control-flow built-ins.
+        let componentName = matchImport(Object.keys(JSX_PROP_DEFAULTS), element.name.name);
+        if (
+          !componentName &&
+          element.name.name in JSX_PROP_DEFAULTS &&
+          ASTUtils.findVariable(getScope(context, element), element.name.name) == null
+        ) {
+          componentName = element.name.name;
+        }
+        if (!componentName) return;
+        const defaults = JSX_PROP_DEFAULTS[componentName];
+        const prop = node.name.name;
+        if (!(prop in defaults)) return;
+        const defaultValue = defaults[prop];
+
+        let stated: boolean | null = null;
+        if (node.value == null) {
+          // bare prop, e.g. `<Show keyed>` means true
+          stated = true;
+        } else if (
+          node.value.type === "JSXExpressionContainer" &&
+          node.value.expression.type === "Literal" &&
+          typeof node.value.expression.value === "boolean"
+        ) {
+          stated = node.value.expression.value;
+        }
+
+        if (stated === defaultValue) {
+          context.report({
+            node,
+            messageId: "restatedDefault",
+            data: { prop, value: String(stated), component: element.name.name },
+            fix: (fixer) => fixer.remove(node),
+          });
+        }
+      },
+    };
+  },
+});