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

package/src/rules/no-single-arg-create-effect.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 { ESLintUtils } from "@typescript-eslint/utils";
+import { getSolidSourceRegex, trackImports } from "../utils";
+
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+
+type MessageIds = "singleArgEffect" | "singleArgRenderEffect";
+type Options = [];
+
+/*
+ * Solid 2.0 splits effects into a tracked compute function and an untracked
+ * effect function: `createEffect(compute, effect)`. The single-argument 1.x
+ * form types as `never` via a deprecated overload — which produces no compile
+ * error on a bare statement call — and only throws at runtime in dev mode.
+ * This rule is the build-time hard stop.
+ */
+export default createRule<Options, MessageIds>({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Require the two-argument `createEffect(compute, effect)` form used by Solid 2.0.",
+      url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-single-arg-create-effect.md",
+    },
+    schema: [],
+    messages: {
+      singleArgEffect:
+        "In Solid 2.0, createEffect takes separate compute and effect functions: `createEffect(() => signal(), (value) => doWork(value))`. For a derived value use `createMemo`; for a one-shot side effect, just call the function directly.",
+      singleArgRenderEffect:
+        "In Solid 2.0, createRenderEffect takes separate compute and effect functions: `createRenderEffect(() => signal(), (value) => doWork(value))`.",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const { matchImport, handleImportDeclaration } = trackImports(getSolidSourceRegex(context));
+
+    return {
+      ImportDeclaration: handleImportDeclaration,
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier" || node.arguments.length !== 1) return;
+        if (matchImport("createEffect", node.callee.name)) {
+          context.report({ node, messageId: "singleArgEffect" });
+        } else if (matchImport("createRenderEffect", node.callee.name)) {
+          context.report({ node, messageId: "singleArgRenderEffect" });
+        }
+      },
+    };
+  },
+});

package/src/rules/no-store-mutation-outside-setter.ts

@@ -0,0 +1,137 @@
+/**
+ * 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 } from "@typescript-eslint/utils";
+import { findVariable } from "../compat";
+import { getSolidSourceRegex, trackImports } from "../utils";
+
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+
+// Array methods that mutate their receiver in place.
+const MUTATING_METHODS = new Set([
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin",
+]);
+
+type MessageIds = "mutateStore" | "mutateProjection";
+type Options = [];
+
+/*
+ * Store setters receive a mutable draft in Solid 2.0 (`produce` semantics by
+ * default), which makes mutating the read proxy directly — `store.count++`,
+ * `store.items.push(x)` — look plausible. It isn't: the proxy's write traps
+ * silently ignore writes outside a draft scope, with no error or dev warning
+ * of any kind — the mutation just vanishes. That silence is exactly why this
+ * rule matters: lint is currently the only guardrail. Draft mutations inside
+ * the setter are written through the draft parameter, a different variable,
+ * so they never resolve to the store and are naturally exempt.
+ */
+export default createRule<Options, MessageIds>({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow mutating a store's read proxy; store state changes only through the setter's mutable draft.",
+      url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-store-mutation-outside-setter.md",
+    },
+    schema: [],
+    messages: {
+      mutateStore:
+        "'{{name}}' is a store's read proxy, which is read-only; this mutation is silently ignored — no error, no update, the write just vanishes. Mutate the draft inside the setter instead: `{{setter}}(draft => { ... })`.",
+      mutateProjection:
+        "'{{name}}' is a projection, a read-only derived store. Derive this value inside the projection function instead of mutating the result.",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const { matchImport, handleImportDeclaration } = trackImports(getSolidSourceRegex(context));
+
+    type Target = { kind: "store"; setter: string | null } | { kind: "projection" };
+
+    /** Resolves an identifier to the store or projection it names, if any. */
+    const resolveTarget = (id: T.Identifier): Target | null => {
+      const def = findVariable(context, id)?.defs[0];
+      if (!def || def.type !== "Variable" || !def.node.init) return null;
+      const { id: declId, init } = def.node;
+      if (init.type !== "CallExpression" || init.callee.type !== "Identifier") return null;
+
+      // const [store, setStore] = createStore(...)
+      if (
+        declId.type === "ArrayPattern" &&
+        declId.elements[0]?.type === "Identifier" &&
+        declId.elements[0].name === id.name &&
+        matchImport("createStore", init.callee.name)
+      ) {
+        const setter = declId.elements[1]?.type === "Identifier" ? declId.elements[1].name : null;
+        return { kind: "store", setter };
+      }
+      // const projected = createProjection(...)
+      if (declId.type === "Identifier" && matchImport("createProjection", init.callee.name)) {
+        return { kind: "projection" };
+      }
+      return null;
+    };
+
+    /** Walks a member chain (`store.a.b`) down to its base identifier. */
+    const baseIdentifier = (node: T.Node): T.Identifier | null => {
+      let current: T.Node = node;
+      while (current.type === "MemberExpression") current = current.object;
+      return current.type === "Identifier" ? current : null;
+    };
+
+    const checkMutation = (member: T.MemberExpression, reportNode: T.Node) => {
+      const base = baseIdentifier(member);
+      const target = base && resolveTarget(base);
+      if (!target) return;
+      if (target.kind === "projection") {
+        context.report({
+          node: reportNode,
+          messageId: "mutateProjection",
+          data: { name: base.name },
+        });
+      } else {
+        context.report({
+          node: reportNode,
+          messageId: "mutateStore",
+          data: { name: base.name, setter: target.setter ?? "setStore" },
+        });
+      }
+    };
+
+    return {
+      ImportDeclaration: handleImportDeclaration,
+      AssignmentExpression(node) {
+        if (node.left.type === "MemberExpression") checkMutation(node.left, node);
+      },
+      UpdateExpression(node) {
+        if (node.argument.type === "MemberExpression") checkMutation(node.argument, node);
+      },
+      UnaryExpression(node) {
+        if (node.operator === "delete" && node.argument.type === "MemberExpression") {
+          checkMutation(node.argument, node);
+        }
+      },
+      CallExpression(node) {
+        if (
+          node.callee.type === "MemberExpression" &&
+          node.callee.property.type === "Identifier" &&
+          MUTATING_METHODS.has(node.callee.property.name)
+        ) {
+          checkMutation(node.callee, node);
+        }
+      },
+    };
+  },
+});

package/src/rules/no-unknown-namespaces.ts

@@ -0,0 +1,140 @@
+/**
+ * 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 { ESLintUtils, TSESTree as T } from "@typescript-eslint/utils";
+import { isDOMElementName, isSolidV2 } from "../utils";
+
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+
+const knownNamespaces = ["on", "oncapture", "use", "prop", "attr", "bool"];
+const styleNamespaces = ["style", "class"];
+const otherNamespaces = ["xmlns", "xlink"];
+
+// In Solid 2.0, namespaces are no longer reserved: any colon-name passes
+// through as a literal attribute, and `prop:` is the only special prefix left.
+// The formerly-public 1.x prefixes now silently render literal attributes, so
+// in v2 mode they're flagged as near-certain migration bugs with per-prefix
+// guidance.
+const v2MigrationGuidance: Record<string, string> = {
+  on: "For an event handler, use the camelCase form instead: `onClick`",
+  oncapture:
+    "There is no capture-phase prefix in Solid 2.0; add a capture listener with `addEventListener` in a `ref` if needed",
+  use: "Directives were removed in Solid 2.0; call the function in `ref` instead: `ref={(el) => myDirective(el)}`",
+  attr: "Use the plain attribute name; attributes are the default in Solid 2.0",
+  bool: "Use the plain attribute with a boolean or conditional value",
+};
+
+type MessageIds = "unknown" | "style" | "component" | "component-suggest" | "v2Namespace";
+type Options = [{ allowedNamespaces: Array<string> }?];
+
+export default createRule<Options, MessageIds>({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Enforce using only Solid-specific namespaced attribute names (i.e. `'on:'` in `<div on:click={...} />`).",
+      url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-unknown-namespaces.md",
+    },
+    hasSuggestions: true,
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowedNamespaces: {
+            description: "an array of additional namespace names to allow",
+            type: "array",
+            items: {
+              type: "string",
+            },
+            default: [],
+            minItems: 1,
+            uniqueItems: true,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      unknown: `'{{namespace}}:' is not one of Solid's special prefixes for JSX attributes (${knownNamespaces
+        .map((n) => `'${n}:'`)
+        .join(", ")}).`,
+      style:
+        "Using the '{{namespace}}:' special prefix is potentially confusing, prefer the '{{namespace}}' prop instead.",
+      component: "Namespaced props have no effect on components.",
+      "component-suggest": "Replace {{namespace}}:{{name}} with {{name}}.",
+      v2Namespace:
+        "'{{namespace}}:' is not a special prefix in Solid 2.0; this renders a literal '{{namespace}}:{{name}}' attribute. {{guidance}}.",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const explicitlyAllowedNamespaces = context.options?.[0]?.allowedNamespaces;
+    const v2 = isSolidV2(context);
+    return {
+      "JSXAttribute > JSXNamespacedName": (node: T.JSXNamespacedName) => {
+        const openingElement = node.parent!.parent as T.JSXOpeningElement;
+        if (
+          openingElement.name.type === "JSXIdentifier" &&
+          !isDOMElementName(openingElement.name.name)
+        ) {
+          // no namespaces on Solid component elements
+          context.report({
+            node,
+            messageId: "component",
+            suggest: [
+              {
+                messageId: "component-suggest",
+                data: { namespace: node.namespace.name, name: node.name.name },
+                fix: (fixer) => fixer.replaceText(node, node.name.name),
+              },
+            ],
+          });
+          return;
+        }
+
+        const namespace = node.namespace?.name;
+
+        if (v2) {
+          // In 2.0 any colon-name is a legal literal attribute; only flag the
+          // formerly-special 1.x prefixes, which are near-certain migration bugs.
+          const guidance = v2MigrationGuidance[namespace];
+          if (guidance && !explicitlyAllowedNamespaces?.includes(namespace)) {
+            context.report({
+              node,
+              messageId: "v2Namespace",
+              data: { namespace, name: node.name.name, guidance },
+            });
+          }
+          return;
+        }
+
+        if (
+          !(
+            knownNamespaces.includes(namespace) ||
+            otherNamespaces.includes(namespace) ||
+            explicitlyAllowedNamespaces?.includes(namespace)
+          )
+        ) {
+          if (styleNamespaces.includes(namespace)) {
+            context.report({
+              node,
+              messageId: "style",
+              data: { namespace },
+            });
+          } else {
+            context.report({
+              node,
+              messageId: "unknown",
+              data: { namespace },
+            });
+          }
+        }
+      },
+    };
+  },
+});

package/src/rules/no-unused-signal.ts

@@ -0,0 +1,119 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+
+import { TSESTree as T, ESLintUtils } from "@typescript-eslint/utils";
+import { findVariable, getSourceCode } from "../compat";
+import { findParent, getSolidSourceRegex, trackImports } from "../utils";
+
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+
+type MessageIds = "neverWritten" | "neverRead" | "replaceWithAccessor";
+type Options = [];
+
+/*
+ * A destructured signal tuple is the only handle on the signal, so scope
+ * analysis is conclusive: if the setter is never referenced the value can
+ * never change, and if the accessor is never referenced the state can never
+ * be observed. Unused-variable rules miss both halves because the *other*
+ * half keeps the declaration "used". Exported declarations are skipped —
+ * references in other modules are invisible here.
+ */
+export default createRule<Options, MessageIds>({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Disallow signals that are never written (use a plain value) or never read (dead state).",
+      url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-unused-signal.md",
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      neverWritten:
+        "This {{kind}} is never written, so its value can never change. Use a plain value, or `createMemo` if it should derive from reactive state.",
+      neverRead:
+        "This {{kind}} is never read, so setting it has no effect. Remove the {{kind}}, or read the value where the state should be used.",
+      replaceWithAccessor: "Replace with a constant accessor.",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const { matchImport, handleImportDeclaration } = trackImports(getSolidSourceRegex(context));
+
+    /** Does this pattern element's variable have any reference besides its initialization? */
+    const isUsed = (element: T.Identifier): boolean => {
+      const variable = findVariable(context, element);
+      // Unresolvable variables can't be proven unused; assume they're fine.
+      if (!variable) return true;
+      return variable.references.some((ref) => !ref.init);
+    };
+
+    return {
+      ImportDeclaration: handleImportDeclaration,
+      VariableDeclarator(node) {
+        if (
+          node.init?.type !== "CallExpression" ||
+          node.init.callee.type !== "Identifier" ||
+          node.id.type !== "ArrayPattern" ||
+          node.id.elements.length > 2
+        ) {
+          return;
+        }
+        const primitive = matchImport(
+          ["createSignal", "createStore", "createOptimistic"],
+          node.init.callee.name
+        );
+        if (!primitive) return;
+        const kind =
+          primitive === "createSignal"
+            ? "signal"
+            : primitive === "createStore"
+            ? "store"
+            : "optimistic value";
+        // Only plain `[accessor, setter]` shapes (with possible holes) are conclusive.
+        const [accessor = null, setter = null] = node.id.elements;
+        if (
+          (accessor && accessor.type !== "Identifier") ||
+          (setter && setter.type !== "Identifier")
+        ) {
+          return;
+        }
+        // Exported signals can be read or written by other modules.
+        if (findParent(node, (n) => n.type === "ExportNamedDeclaration")) return;
+
+        if (!accessor || !isUsed(accessor)) {
+          context.report({ node: accessor ?? node.id, messageId: "neverRead", data: { kind } });
+          return;
+        }
+        if (!setter || !isUsed(setter)) {
+          const init = node.init;
+          const initialValue = init.arguments[0];
+          // Only suggest the rewrite for signals whose initial value is a
+          // simple literal; richer expressions may want createMemo or
+          // evaluate-once semantics, and store/optimistic results aren't
+          // accessor-shaped.
+          const suggest =
+            primitive === "createSignal" && (!initialValue || initialValue.type === "Literal")
+              ? [
+                  {
+                    messageId: "replaceWithAccessor" as const,
+                    fix: (fixer: TSESLint.RuleFixer) =>
+                      fixer.replaceText(
+                        node,
+                        `${accessor.name} = () => ${
+                          initialValue ? getSourceCode(context).getText(initialValue) : "undefined"
+                        }`
+                      ),
+                  },
+                ]
+              : undefined;
+          context.report({
+            node: setter ?? node.id,
+            messageId: "neverWritten",
+            data: { kind },
+            suggest,
+          });
+        }
+      },
+    };
+  },
+});

package/src/rules/no-write-in-pure-computation.ts

@@ -0,0 +1,231 @@
+/**
+ * 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 } from "@typescript-eslint/utils";
+import { findVariable } from "../compat";
+import {
+  FunctionNode,
+  findParent,
+  getFunctionName,
+  isFunctionNode,
+  getSolidSourceRegex,
+  trackImports,
+} from "../utils";
+
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+
+type MessageIds = "writeInMemo" | "writeInCompute" | "writeInComponent";
+type Options = [];
+
+/*
+ * `createMemo` callbacks, the compute half of `createEffect(compute,
+ * effect)`, and component bodies are pure owned scopes in Solid 2.0:
+ * writing other reactive state from inside them creates update cycles and
+ * throws in dev mode (REACTIVE_WRITE_IN_OWNED_SCOPE). Only setter calls
+ * whose nearest enclosing function IS the pure scope are flagged — a setter
+ * inside a nested function (an event handler, an `onSettled` or
+ * `createTrackedEffect` callback, the effect half) runs later, in an
+ * imperative scope, and is fine.
+ */
+export default createRule<Options, MessageIds>({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow writing signals or stores inside `createMemo`, the compute half of `createEffect`, or a component body, which are pure owned scopes.",
+      url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-write-in-pure-computation.md",
+    },
+    schema: [],
+    messages: {
+      writeInMemo:
+        "Calling the setter '{{name}}' inside createMemo makes the computation impure and creates an update cycle. Derive the value instead of storing it, or move the write to an effect.",
+      writeInCompute:
+        "Calling the setter '{{name}}' in the compute half of {{api}} — the compute function is tracked and must be pure. Move the write into the effect half (the second argument).",
+      writeInComponent:
+        "Calling the setter '{{name}}' during component setup — the body runs once as a pure owned scope, and Solid 2.0 throws on setup writes in dev. Initialize the state with the right value instead, or move the write into an effect half or event handler.",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const { matchImport, handleImportDeclaration } = trackImports(getSolidSourceRegex(context));
+
+    /** Pure computation functions seen so far, mapped to how to report writes in them. */
+    const computations = new Map<T.Node, { messageId: MessageIds; api: string }>();
+
+    /**
+     * Does this signal opt into owned-scope writes? Core skips its dev guard
+     * for signals created with `ownedWrite: true`, and its error message
+     * steers users to that option — so the lint must honor it too. The check
+     * only says "no" when it can *prove* the opt-in is absent: a missing
+     * options argument, or an object literal (followed through one level of
+     * const indirection) that is fully readable and lacks `ownedWrite`.
+     * Everything else — spreads, casts, unresolvable or reassigned
+     * variables — is assumed to opt in, so the rule can only under-report,
+     * never contradict core.
+     */
+    const allowsOwnedWrite = (init: T.CallExpression): boolean => {
+      let options: T.Node | undefined = init.arguments[1];
+      if (!options) return false;
+      if (options.type === "Identifier") {
+        const variable = findVariable(context, options);
+        const def = variable?.defs[0];
+        if (
+          variable?.defs.length !== 1 ||
+          def?.type !== "Variable" ||
+          def.node.parent?.kind !== "const" ||
+          !def.node.init ||
+          // A const holding an object can still be given properties later
+          // (`opts.ownedWrite = true`); any reference that mutates the object
+          // or escapes it (passed elsewhere, aliased) makes the literal read
+          // inconclusive. Only references that ARE the options argument of a
+          // signal creation keep it conclusive.
+          variable.references.some(
+            (ref) =>
+              ref.identifier !== def.node.id &&
+              !(
+                ref.identifier.parent?.type === "CallExpression" &&
+                ref.identifier.parent.arguments[1] === ref.identifier
+              )
+          )
+        ) {
+          return true;
+        }
+        options = def.node.init;
+      }
+      if (options.type !== "ObjectExpression") return true;
+      return options.properties.some(
+        (property) =>
+          property.type === "SpreadElement" ||
+          ((property.key.type === "Identifier"
+            ? property.key.name === "ownedWrite"
+            : property.key.type === "Literal" && property.key.value === "ownedWrite") &&
+            !(property.value.type === "Literal" && property.value.value === false))
+      );
+    };
+
+    /** Is `id` the setter half of a signal/store/optimistic tuple? */
+    const isSetter = (id: T.Identifier): boolean => {
+      const def = findVariable(context, id)?.defs[0];
+      if (!def || def.type !== "Variable" || !def.node.init) return false;
+      const { id: declId, init } = def.node;
+      if (
+        declId.type !== "ArrayPattern" ||
+        declId.elements[1]?.type !== "Identifier" ||
+        declId.elements[1].name !== id.name ||
+        init.type !== "CallExpression" ||
+        init.callee.type !== "Identifier"
+      ) {
+        return false;
+      }
+      const primitive = matchImport(
+        ["createSignal", "createStore", "createOptimistic"],
+        init.callee.name
+      );
+      if (!primitive) return false;
+      // `ownedWrite` is a SignalOptions flag; store setters have no such
+      // exemption in core, so only signal-shaped primitives honor it.
+      if (primitive !== "createStore" && allowsOwnedWrite(init)) return false;
+      return true;
+    };
+
+    /**
+     * Setter calls whose nearest enclosing function might be a component.
+     * Whether it IS one (contains JSX, component-shaped) is only known at the
+     * function's :exit, so reports are deferred until then.
+     */
+    const pendingComponentWrites = new Map<FunctionNode, T.CallExpression[]>();
+    const functionStack: Array<{ hasJSX: boolean }> = [];
+
+    /**
+     * Matches the component detection in no-destructure/components-return-once:
+     * containing JSX isn't enough on its own, because data callbacks
+     * (`items.map((item) => <li />)`) and lowercase-named helpers also return
+     * JSX. Component-shaped means: not lowercase-named, not a "render prop",
+     * and not a plain call argument (unless the callee is PascalCase, like a
+     * HOC).
+     */
+    const isComponent = (node: FunctionNode) =>
+      !getFunctionName(node)?.match(/^[a-z]/) &&
+      node.parent?.type !== "JSXExpressionContainer" &&
+      !(
+        node.parent?.type === "CallExpression" &&
+        node.parent.arguments.includes(node as T.CallExpressionArgument) &&
+        !(node.parent.callee as T.Identifier).name?.match(/^[A-Z]/)
+      );
+
+    return {
+      ImportDeclaration: handleImportDeclaration,
+      ":function"() {
+        functionStack.push({ hasJSX: false });
+      },
+      JSXElement() {
+        if (functionStack.length) functionStack[functionStack.length - 1].hasJSX = true;
+      },
+      JSXFragment() {
+        if (functionStack.length) functionStack[functionStack.length - 1].hasJSX = true;
+      },
+      ":function:exit"(node: T.Node) {
+        const { hasJSX } = functionStack.pop() ?? { hasJSX: false };
+        if (!isFunctionNode(node)) return;
+        const pending = pendingComponentWrites.get(node);
+        if (!pending) return;
+        pendingComponentWrites.delete(node);
+        // A function that is itself a registered computation is reported
+        // through the computation path, never as a component.
+        if (!hasJSX || computations.has(node) || !isComponent(node)) return;
+        for (const call of pending) {
+          context.report({
+            node: call,
+            messageId: "writeInComponent",
+            data: { name: (call.callee as T.Identifier).name },
+          });
+        }
+      },
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier") return;
+
+        // Register pure computation callbacks. Ancestors are visited before
+        // descendants, so these are known before their setter calls are seen.
+        if (matchImport("createMemo", node.callee.name)) {
+          const fn = node.arguments[0];
+          if (isFunctionNode(fn)) {
+            computations.set(fn, { messageId: "writeInMemo", api: "createMemo" });
+          }
+          return;
+        }
+        const effectName = matchImport(["createEffect", "createRenderEffect"], node.callee.name);
+        if (effectName && node.arguments.length >= 2) {
+          const fn = node.arguments[0];
+          if (isFunctionNode(fn)) {
+            computations.set(fn, { messageId: "writeInCompute", api: effectName });
+          }
+          return;
+        }
+
+        const enclosing = findParent(node, isFunctionNode);
+        if (!enclosing || !isFunctionNode(enclosing)) return;
+        const computation = computations.get(enclosing);
+        if (!computation && !isSetter(node.callee)) return;
+        if (computation) {
+          if (isSetter(node.callee)) {
+            context.report({
+              node,
+              messageId: computation.messageId,
+              data: { name: node.callee.name, api: computation.api },
+            });
+          }
+          return;
+        }
+        // Possibly a setup-scope write; decided at the function's :exit.
+        const pending = pendingComponentWrites.get(enclosing);
+        if (pending) pending.push(node);
+        else pendingComponentWrites.set(enclosing, [node]);
+      },
+    };
+  },
+});