@timmo001/oxlint-rules 0.4.0 → 0.6.0

package/dist/generic/index.js

@@ -1,8 +1,86 @@
 // src/generic/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
-// src/generic/rules/prefer-event-parameter-type.ts
+// src/generic/rules/no-explicit-inferable-type-predicate.ts
 import { defineRule } from "@oxlint/plugins";
+function isNamed(node, name) {
+  return node.type === "Identifier" && node.name === name;
+}
+function isNullish(node) {
+  return node.type === "Literal" && node.value === null || isNamed(node, "undefined");
+}
+function isNullishExclusion(node, name) {
+  return node.type === "BinaryExpression" && (node.operator === "!==" || node.operator === "!=") && (isNamed(node.left, name) && isNullish(node.right) || isNullish(node.left) && isNamed(node.right, name));
+}
+function isTypeofCheck(node, name) {
+  if (node.type !== "BinaryExpression" || node.operator !== "===" && node.operator !== "==") {
+    return false;
+  }
+  const isTypeof = (side) => side.type === "UnaryExpression" && side.operator === "typeof" && isNamed(side.argument, name);
+  const isLiteral = (side) => side.type === "Literal";
+  return isTypeof(node.left) && isLiteral(node.right) || isLiteral(node.left) && isTypeof(node.right);
+}
+function isInferableCheck(node, name) {
+  if (node.type === "LogicalExpression") {
+    return node.operator === "&&" && isNullishExclusion(node.left, name) && isNullishExclusion(node.right, name);
+  }
+  return isNullishExclusion(node, name) || isTypeofCheck(node, name) || node.type === "BinaryExpression" && node.operator === "instanceof" && isNamed(node.left, name);
+}
+function returnedExpression(owner) {
+  const body = owner.body;
+  if (!body)
+    return null;
+  if (body.type !== "BlockStatement")
+    return body;
+  const [statement] = body.body;
+  return body.body.length === 1 && statement?.type === "ReturnStatement" ? statement.argument : null;
+}
+function isPublicSignature(owner) {
+  const parent = owner.parent;
+  if (parent.type === "MethodDefinition" || parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration") {
+    return true;
+  }
+  return parent.type === "VariableDeclarator" && parent.parent.parent?.type === "ExportNamedDeclaration";
+}
+var noExplicitInferableTypePredicateRule = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow explicit type predicates on simple null, typeof, or instanceof checks that TypeScript 5.5+ infers."
+    },
+    messages: {
+      removeTypePredicate: "TypeScript infers the type predicate for `{{parameter}}` from this check, while an explicit predicate is never checked against the body. Remove the annotation and rely on the inferred predicate."
+    }
+  },
+  create(context) {
+    const check = (owner) => {
+      const annotation = owner.returnType?.typeAnnotation;
+      if (annotation?.type !== "TSTypePredicate" || annotation.asserts || annotation.parameterName.type !== "Identifier" || isPublicSignature(owner)) {
+        return;
+      }
+      const parameter = annotation.parameterName.name;
+      const expression = returnedExpression(owner);
+      if (!owner.params.some((param) => isNamed(param, parameter)) || !expression || !isInferableCheck(expression, parameter)) {
+        return;
+      }
+      context.report({
+        node: annotation,
+        messageId: "removeTypePredicate",
+        data: { parameter }
+      });
+    };
+    return {
+      ArrowFunctionExpression: check,
+      FunctionDeclaration: check,
+      FunctionExpression: check
+    };
+  }
+});
+
+// src/generic/rules/no-unchecked-query-selector-type.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+
+// src/shared/ast.ts
 function nearestEnclosingFunction(node) {
   let current = node.parent;
   while (current) {
@@ -13,30 +91,204 @@ function nearestEnclosingFunction(node) {
   }
   return null;
 }
-function assertedEventParameter(node) {
-  const expression = node.expression;
-  if (expression.type !== "MemberExpression" || expression.computed || expression.object.type !== "Identifier" || expression.property.type !== "Identifier" || expression.property.name !== "currentTarget" && expression.property.name !== "target") {
+function staticMemberName(node) {
+  if (node.type !== "MemberExpression" || node.computed)
+    return null;
+  return node.property.type === "Identifier" ? node.property.name : null;
+}
+
+// src/shared/json.ts
+function jsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+
+// src/shared/lit.ts
+var renderRoots = new Set(["renderRoot", "shadowRoot"]);
+function litElementBaseClasses(settings) {
+  const configured = jsonObject(settings.lit)?.elementBaseClasses;
+  return new Set([
+    "LitElement",
+    ...Array.isArray(configured) ? configured.map(String) : []
+  ]);
+}
+function isWrapperExpression(node) {
+  return node?.type === "ChainExpression" || node?.type === "ParenthesizedExpression" || node?.type === "TSAsExpression" || node?.type === "TSNonNullExpression" || node?.type === "TSSatisfiesExpression" || node?.type === "TSTypeAssertion";
+}
+function unwrapExpression(node) {
+  let current = node;
+  while (isWrapperExpression(current))
+    current = current.expression;
+  return current;
+}
+function extendsLitBase(node, bases) {
+  if (node.type === "Identifier")
+    return bases.has(node.name);
+  return node.type === "CallExpression" && node.arguments.some((argument) => extendsLitBase(argument, bases));
+}
+function isLitClass(node, bases) {
+  const hasCustomElementDecorator = node.decorators.some((decorator) => decorator.expression.type === "CallExpression" && decorator.expression.callee.type === "Identifier" && decorator.expression.callee.name === "customElement");
+  return hasCustomElementDecorator || node.superClass !== null && extendsLitBase(node.superClass, bases);
+}
+function classOfBody(body) {
+  const owner = body.parent;
+  return owner?.type === "ClassDeclaration" || owner?.type === "ClassExpression" ? owner : null;
+}
+function thisClass(node) {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") {
+      const owner = parent.parent;
+      return (owner?.type === "MethodDefinition" || owner?.type === "TSAbstractMethodDefinition") && !owner.static && owner.value === parent ? classOfBody(owner.parent) : null;
+    }
+    if ((parent.type === "PropertyDefinition" || parent.type === "AccessorProperty") && parent.value === current) {
+      return parent.static ? null : classOfBody(parent.parent);
+    }
+    if (parent.type === "StaticBlock" || parent.type === "ClassBody" || parent.type === "Program") {
+      return null;
+    }
+    current = parent;
+  }
+  return null;
+}
+function isStaticSelector(node) {
+  return node?.type === "Literal" || node?.type === "TemplateLiteral" && node.expressions.length === 0;
+}
+function renderRootQuery(node, bases) {
+  const method = staticMemberName(node.callee);
+  if (method !== "querySelector" && method !== "querySelectorAll" || node.callee.type !== "MemberExpression" || !isStaticSelector(node.arguments[0])) {
+    return null;
+  }
+  const receiver = unwrapExpression(node.callee.object);
+  const root = staticMemberName(receiver);
+  if (!root || !renderRoots.has(root) || receiver.type !== "MemberExpression" || receiver.object.type !== "ThisExpression") {
+    return null;
+  }
+  const owner = thisClass(receiver.object);
+  return owner && isLitClass(owner, bases) ? { method, root } : null;
+}
+function isAssignedMethod(name) {
+  return name === "assignedElements" || name === "assignedNodes";
+}
+function feedsAssignedCall(node) {
+  let current = node;
+  while (isWrapperExpression(current.parent))
+    current = current.parent;
+  const member = current.parent;
+  return member?.type === "MemberExpression" && member.object === current && isAssignedMethod(staticMemberName(member));
+}
+function litQueryDecoratorCall(node, bases) {
+  const method = staticMemberName(node.callee);
+  if (!isAssignedMethod(method)) {
+    return feedsAssignedCall(node) ? null : renderRootQuery(node, bases);
+  }
+  if (node.callee.type !== "MemberExpression")
+    return null;
+  const inner = unwrapExpression(node.callee.object);
+  if (inner.type !== "CallExpression")
     return null;
+  const query = renderRootQuery(inner, bases);
+  return query?.method === "querySelector" ? { method, root: query.root } : null;
+}
+function isLitRenderRootQuery(node, bases) {
+  return renderRootQuery(node, bases) !== null;
+}
+
+// src/generic/rules/no-unchecked-query-selector-type.ts
+var queryMethods = new Set(["closest", "querySelector", "querySelectorAll"]);
+var noUncheckedQuerySelectorTypeRule = defineRule2({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow type arguments on `querySelector`, `querySelectorAll`, and `closest`, which cast the result without checking it."
+    },
+    messages: {
+      checkQueryResult: "`{{method}}<T>` casts the result without checking it. Check it with `instanceof`, use a checked lookup helper, or query a tag name so TypeScript infers the element type."
+    }
+  },
+  create(context) {
+    const bases = litElementBaseClasses(context.settings);
+    return {
+      CallExpression(node) {
+        const method = staticMemberName(node.callee);
+        if (!node.typeArguments || !method || !queryMethods.has(method) || isLitRenderRootQuery(node, bases)) {
+          return;
+        }
+        context.report({
+          node: node.typeArguments,
+          messageId: "checkQueryResult",
+          data: { method }
+        });
+      }
+    };
   }
-  const parameterName = expression.object.name;
-  const property = expression.property.name;
+});
+
+// src/generic/rules/no-untyped-custom-event.ts
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+var noUntypedCustomEventRule = defineRule3({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow `CustomEvent` type references without a detail type, which leave `detail` as `any`."
+    },
+    messages: {
+      typeCustomEventDetail: "`CustomEvent` without a type argument leaves `detail` as `any`. Reuse the project's typed event helper if one fits, or add one, instead of a bare `CustomEvent`."
+    }
+  },
+  create(context) {
+    return {
+      TSTypeReference(node) {
+        if (node.typeName.type !== "Identifier" || node.typeName.name !== "CustomEvent" || node.typeArguments) {
+          return;
+        }
+        context.report({ node, messageId: "typeCustomEventDetail" });
+      }
+    };
+  }
+});
+
+// src/generic/rules/prefer-event-parameter-type.ts
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+function staticMemberPath(node) {
+  const path = [];
+  let current = node.type === "ChainExpression" ? node.expression : node;
+  while (current.type === "MemberExpression") {
+    if (current.computed || current.property.type !== "Identifier") {
+      return null;
+    }
+    path.unshift(current.property.name);
+    current = current.object;
+  }
+  return current.type === "Identifier" && path.length > 0 ? { root: current.name, path } : null;
+}
+function isEventMemberPath(path) {
+  const [first] = path;
+  if (first === "detail")
+    return true;
+  return path.length === 1 && (first === "currentTarget" || first === "target");
+}
+function assertedEventParameter(node) {
+  const member = staticMemberPath(node.expression);
+  if (!member || !isEventMemberPath(member.path))
+    return null;
   const owner = nearestEnclosingFunction(node);
-  if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === parameterName)) {
+  if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === member.root)) {
     return null;
   }
   return {
-    parameter: parameterName,
-    property
+    parameter: member.root,
+    property: member.path.join(".")
   };
 }
-var preferEventParameterTypeRule = defineRule({
+var preferEventParameterTypeRule = defineRule4({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Prefer typing event target properties in the handler parameter instead of asserting them at use sites."
+      description: "Prefer typing event target and detail properties in the handler parameter instead of asserting them at use sites."
     },
     messages: {
-      typeEventParameter: "Type `{{parameter}}.{{property}}` in the function signature instead of asserting it at the use site."
+      typeEventParameter: "Type `{{parameter}}.{{property}}` in the function signature instead of asserting it at the use site. Reuse the project's typed event helper if one fits, or add one."
     }
   },
   create(context) {
@@ -57,9 +309,69 @@ var preferEventParameterTypeRule = defineRule({
   }
 });
 
+// src/generic/rules/prefer-lit-query-decorators.ts
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var messageIds = {
+  assignedElements: "preferQueryAssignedElements",
+  assignedNodes: "preferQueryAssignedNodes",
+  querySelector: "preferQuery",
+  querySelectorAll: "preferQueryAll"
+};
+var preferLitQueryDecoratorsRule = defineRule5({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require Lit query decorators instead of static render-root queries in Lit elements."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          querySelector: { type: "boolean" },
+          querySelectorAll: { type: "boolean" },
+          assignedElements: { type: "boolean" },
+          assignedNodes: { type: "boolean" }
+        },
+        additionalProperties: false
+      }
+    ],
+    defaultOptions: [
+      {
+        querySelector: true,
+        querySelectorAll: true,
+        assignedElements: true,
+        assignedNodes: true
+      }
+    ],
+    messages: {
+      preferQuery: "Use the @query decorator instead of this.{{root}}.querySelector().",
+      preferQueryAll: "Use the @queryAll decorator instead of this.{{root}}.querySelectorAll().",
+      preferQueryAssignedElements: "Use the @queryAssignedElements decorator instead of this.{{root}}.querySelector().assignedElements().",
+      preferQueryAssignedNodes: "Use the @queryAssignedNodes decorator instead of this.{{root}}.querySelector().assignedNodes()."
+    }
+  },
+  create(context) {
+    const bases = litElementBaseClasses(context.settings);
+    const options = jsonObject(context.options[0]);
+    const disabled = new Set(options ? Object.keys(options).filter((method) => options[method] === false) : []);
+    return {
+      CallExpression(node) {
+        const query = litQueryDecoratorCall(node, bases);
+        if (!query || disabled.has(query.method))
+          return;
+        context.report({
+          node,
+          messageId: messageIds[query.method],
+          data: { root: query.root }
+        });
+      }
+    };
+  }
+});
+
 // src/generic/rules/prefer-types-over-assertions.ts
-import { defineRule as defineRule2 } from "@oxlint/plugins";
-var preferTypesOverAssertionsRule = defineRule2({
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var preferTypesOverAssertionsRule = defineRule6({
   meta: {
     type: "problem",
     docs: {
@@ -71,7 +383,7 @@ var preferTypesOverAssertionsRule = defineRule2({
   },
   create(context) {
     const checkAssertion = (node) => {
-      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const") {
+      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const" || assertedEventParameter(node)) {
         return;
       }
       context.report({ node, messageId: "avoidAssertion" });
@@ -87,7 +399,11 @@ var preferTypesOverAssertionsRule = defineRule2({
 var timmoPlugin = eslintCompatPlugin({
   meta: { name: "timmo" },
   rules: {
+    "no-explicit-inferable-type-predicate": noExplicitInferableTypePredicateRule,
+    "no-unchecked-query-selector-type": noUncheckedQuerySelectorTypeRule,
+    "no-untyped-custom-event": noUntypedCustomEventRule,
     "prefer-event-parameter-type": preferEventParameterTypeRule,
+    "prefer-lit-query-decorators": preferLitQueryDecoratorsRule,
     "prefer-types-over-assertions": preferTypesOverAssertionsRule
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timmo001/oxlint-rules",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Shared Oxlint plugins and configs with optional Effect rules.",
   "type": "module",
   "license": "Apache-2.0",
@@ -25,6 +25,8 @@
     "src/generic",
     "!src/generic/**/*.test.ts",
     "!src/effect/**/*.test.ts",
+    "src/shared",
+    "!src/shared/**/*.test.ts",
     "vendor/anti-slop/src",
     "vendor/anti-slop/LICENSE",
     "!vendor/anti-slop/src/**/*.test.ts",
@@ -36,24 +38,25 @@
   ],
   "scripts": {
     "build": "bun run scripts/build.ts",
-    "check": "bun run lint && bun run test && bun run typecheck && bun run format:check && bun run skills:validate",
+    "check": "bun run --parallel --no-exit-on-error lint test typecheck format:check skills:validate",
     "format": "prettier --write \"{src,scripts}/**/*.ts\" \"skills/**/*.{md,mjs}\" \"*.ts\" \"*.md\" \"*.json\"",
     "format:check": "prettier --check \"{src,scripts}/**/*.ts\" \"skills/**/*.{md,mjs}\" \"*.ts\" \"*.md\" \"*.json\"",
-    "lint": "bun run build && oxlint --disable-nested-config .",
-    "skills:validate": "bunx skills-ref validate skills/install-timmo-oxlint-rules && bunx skills-ref validate skills/add-oxlint-rule && bunx skills-ref validate skills/release-oxlint-rules",
+    "lint": "bun run build && bun run lint:oxlint",
+    "lint:oxlint": "oxlint --disable-nested-config .",
+    "skills:validate": "printf '%s\\n' skills/*/ | xargs -P 0 -n 1 skills-ref validate",
     "test": "node --experimental-strip-types scripts/test.ts",
     "test:package": "node --experimental-strip-types scripts/test-package.ts",
     "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@oxlint/plugins": "1.86.0",
-    "oxlint": "1.86.0"
+    "@oxlint/plugins": "1.87.0",
+    "oxlint": "1.87.0"
   },
   "devDependencies": {
-    "@oxlint/plugins": "1.86.0",
+    "@oxlint/plugins": "1.87.0",
     "@types/bun": "^1.3.14",
-    "oxlint": "1.86.0",
-    "oxlint-tsgolint": "7.0.2003",
+    "oxlint": "1.87.0",
+    "oxlint-tsgolint": "7.0.2004",
     "prettier": "^3.9.5",
     "skills-ref": "0.1.5",
     "typescript": "^7.0.0"

package/skills/install-timmo-oxlint-rules/SKILL.md

@@ -32,10 +32,8 @@ description: >-
    instead only when `effect` is a direct dependency or the user explicitly
    requests it.
 4. Keep dependency and config edits visible. Do not delegate them to a script.
-5. For type-aware linting, explicitly pin the latest `oxlint-tsgolint` that
-   satisfies Oxlint's peer requirement and was validated with the rules release.
-   Enable `options.typeAware` in the target config and verify type-aware linting
-   alongside the shared rules.
+5. Explicitly pin the latest `oxlint-tsgolint` that satisfies Oxlint's peer
+   requirement and was validated with the rules release.
 
 ## Copy rules
 
@@ -51,8 +49,23 @@ description: >-
    output as authoritative rather than maintaining plugin or rule inventories
    in this skill.
 
+## Strictness
+
+1. Start with every strictness option in the target config's `options`:
+   `typeAware: true`, `typeCheck: true`, and `maxWarnings: 0`. Keep them in the
+   config rather than as lint script flags, and remove any existing
+   `--type-aware`, `--type-check`, `--deny-warnings`, or `--max-warnings` flags
+   so the config is the single source.
+2. Run the target's lint command. If it passes, keep every option.
+3. If it fails, group the failures by cause and the option that raises them,
+   then ask one structured question: fix the failures, or drop the smallest set
+   of options that makes lint pass (`typeCheck` first, then `maxWarnings`, then
+   `typeAware`). Recommend the reduction that keeps the most strictness, and name
+   any shared cause, such as a missing declaration in an upstream package, that
+   a follow-up could fix for every consumer.
+
 Run the target repository's lint command to verify the configuration loads, plus
 any checks explicitly required by that repository. Run typechecks, tests, or a
 build only when code or dependencies changed in a way those checks cover. Report
 package-manager changes, preserved local configuration, enabled rule groups,
-and checks.
+strictness options kept or dropped, and checks.

package/src/effect/index.ts

@@ -1,11 +1,15 @@
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
+import { noRawGhRule } from "./rules/no-raw-gh.ts";
 import { noTryCatchInEffectGeneratorsRule } from "./rules/no-try-catch-in-effect-generators.ts";
+import { preferPlatformServicesRule } from "./rules/prefer-platform-services.ts";
 
 const timmoEffectPlugin = eslintCompatPlugin({
   meta: { name: "timmo-effect" },
   rules: {
+    "no-raw-gh": noRawGhRule,
     "no-try-catch-in-effect-generators": noTryCatchInEffectGeneratorsRule,
+    "prefer-platform-services": preferPlatformServicesRule,
   },
 });
 

package/src/effect/rules/no-raw-gh.ts

@@ -0,0 +1,126 @@
+import { defineRule } from "@oxlint/plugins";
+
+import { staticMemberName } from "../../shared/ast.ts";
+import { resolveVariable } from "../../shared/scope.ts";
+
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+
+const PACKAGE = "@timmo001/effect-gh";
+
+const rawMethods = new Set(["execute", "json", "stream"]);
+
+/** Whether an identifier is bound by a named import of `name` from effect-gh. */
+function isEffectGhImport(
+  sourceCode: SourceCode,
+  identifier: ESTree.IdentifierReference,
+  name: string,
+): boolean {
+  return (
+    resolveVariable(sourceCode, identifier)?.defs.some((definition) => {
+      if (
+        definition.type !== "ImportBinding" ||
+        definition.parent?.type !== "ImportDeclaration" ||
+        definition.parent.source.value !== PACKAGE ||
+        definition.node.type !== "ImportSpecifier"
+      ) {
+        return false;
+      }
+
+      const imported = definition.node.imported;
+
+      return (
+        (imported.type === "Identifier" ? imported.name : imported.value) ===
+        name
+      );
+    }) ?? false
+  );
+}
+
+/** Whether an expression is `yield* Gh` with Gh from effect-gh. */
+function isYieldGh(sourceCode: SourceCode, node: ESTree.Node | null): boolean {
+  return (
+    node?.type === "YieldExpression" &&
+    node.delegate &&
+    node.argument?.type === "Identifier" &&
+    isEffectGhImport(sourceCode, node.argument, "Gh")
+  );
+}
+
+/** Whether an identifier is a variable initialised with `yield* Gh`. */
+function isGhBinding(
+  sourceCode: SourceCode,
+  identifier: ESTree.IdentifierReference,
+): boolean {
+  return (
+    resolveVariable(sourceCode, identifier)?.defs.some(
+      (definition) =>
+        definition.type === "Variable" &&
+        definition.node.type === "VariableDeclarator" &&
+        isYieldGh(sourceCode, definition.node.init),
+    ) ?? false
+  );
+}
+
+function isGhArgument(node: ESTree.Node | undefined): boolean {
+  if (node?.type === "Literal") return node.value === "gh";
+
+  if (node?.type !== "ArrayExpression") return false;
+  const first = node.elements[0];
+
+  return first?.type === "Literal" && first.value === "gh";
+}
+
+/** Route gh through effect-gh's typed operations instead of raw argv or direct spawns. */
+export const noRawGhRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Use @timmo001/effect-gh typed operations instead of the raw Gh methods, Api.raw, or spawning gh directly.",
+    },
+    messages: {
+      rawGh:
+        "Use a typed effect-gh operation instead of `Gh.{{method}}` with raw argv. Add one to effect-gh if the command has none.",
+      rawApi:
+        "Use `Api.json`, `Api.pages`, `Api.empty`, `Api.text` or `Api.headers` instead of `Api.raw`, so the response is typed.",
+      spawnGh:
+        "Run gh through a typed @timmo001/effect-gh operation instead of spawning it directly.",
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        const method = staticMemberName(callee);
+
+        if (callee.type === "MemberExpression" && method !== null) {
+          const object = callee.object;
+
+          if (
+            rawMethods.has(method) &&
+            (isYieldGh(context.sourceCode, object) ||
+              (object.type === "Identifier" &&
+                isGhBinding(context.sourceCode, object)))
+          ) {
+            context.report({ node, messageId: "rawGh", data: { method } });
+
+            return;
+          }
+
+          if (
+            method === "raw" &&
+            object.type === "Identifier" &&
+            isEffectGhImport(context.sourceCode, object, "Api")
+          ) {
+            context.report({ node, messageId: "rawApi" });
+
+            return;
+          }
+        }
+
+        if (isGhArgument(node.arguments[0]))
+          context.report({ node, messageId: "spawnGh" });
+      },
+    };
+  },
+});