@timmo001/oxlint-rules 0.4.0 → 0.6.0

package/src/shared/ast.ts

@@ -0,0 +1,31 @@
+import type { ESTree } from "@oxlint/plugins";
+
+export type FunctionNode = ESTree.Function | ESTree.ArrowFunctionExpression;
+
+export type TypeAssertion = ESTree.TSAsExpression | ESTree.TSTypeAssertion;
+
+export function nearestEnclosingFunction(
+  node: ESTree.Node,
+): FunctionNode | null {
+  let current: ESTree.Node | null = node.parent;
+
+  while (current) {
+    if (
+      current.type === "FunctionDeclaration" ||
+      current.type === "FunctionExpression" ||
+      current.type === "ArrowFunctionExpression"
+    ) {
+      return current;
+    }
+
+    current = current.parent;
+  }
+
+  return null;
+}
+
+export function staticMemberName(node: ESTree.Node): string | null {
+  if (node.type !== "MemberExpression" || node.computed) return null;
+
+  return node.property.type === "Identifier" ? node.property.name : null;
+}

package/src/shared/effect.ts

@@ -0,0 +1,72 @@
+import { staticMemberName } from "./ast.ts";
+import { resolveVariable } from "./scope.ts";
+
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+
+export function isEffectImport(
+  sourceCode: SourceCode,
+  identifier: ESTree.IdentifierReference,
+  namespace: boolean,
+): boolean {
+  const variable = resolveVariable(sourceCode, identifier);
+
+  return (
+    variable?.defs.some((definition) => {
+      if (
+        definition.type !== "ImportBinding" ||
+        definition.parent?.type !== "ImportDeclaration" ||
+        definition.parent.source.value !== "effect"
+      ) {
+        return false;
+      }
+
+      if (namespace) return definition.node.type === "ImportNamespaceSpecifier";
+
+      if (definition.node.type !== "ImportSpecifier") return false;
+      const imported = definition.node.imported;
+
+      return (
+        (imported.type === "Identifier" ? imported.name : imported.value) ===
+        "Effect"
+      );
+    }) ?? false
+  );
+}
+
+export function isEffectMethod(
+  sourceCode: SourceCode,
+  node: ESTree.Expression,
+  method: "fn" | "gen",
+): boolean {
+  if (staticMemberName(node) !== method || node.type !== "MemberExpression") {
+    return false;
+  }
+
+  const object = node.object;
+
+  if (object.type === "Identifier") {
+    return isEffectImport(sourceCode, object, false);
+  }
+
+  if (
+    staticMemberName(object) !== "Effect" ||
+    object.type !== "MemberExpression" ||
+    object.object.type !== "Identifier"
+  ) {
+    return false;
+  }
+
+  return isEffectImport(sourceCode, object.object, true);
+}
+
+/** Whether a module imports Effect or one of its platform packages. */
+export function importsEffect(program: ESTree.Program): boolean {
+  return program.body.some(
+    (statement) =>
+      statement.type === "ImportDeclaration" &&
+      statement.importKind !== "type" &&
+      (statement.source.value === "effect" ||
+        statement.source.value.startsWith("effect/") ||
+        statement.source.value.startsWith("@effect/")),
+  );
+}

package/src/shared/json.ts

@@ -0,0 +1,11 @@
+import type { Settings } from "@oxlint/plugins";
+
+/** Narrow a rule option or setting, which Oxlint passes as untyped JSON. */
+export function jsonObject(
+  value: Settings[string] | undefined,
+): Readonly<Settings> | null {
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- Oxlint settings and options are the JSON input boundary.
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value
+    : null;
+}

package/src/shared/lit.ts

@@ -0,0 +1,219 @@
+import { staticMemberName } from "./ast.ts";
+import { jsonObject } from "./json.ts";
+
+import type { ESTree, Settings } from "@oxlint/plugins";
+
+type AssignedMethod = "assignedElements" | "assignedNodes";
+
+type QueryMethod = "querySelector" | "querySelectorAll";
+
+export type LitQueryMethod = AssignedMethod | QueryMethod;
+
+type WrapperExpression =
+  | ESTree.ChainExpression
+  | ESTree.ParenthesizedExpression
+  | ESTree.TSAsExpression
+  | ESTree.TSNonNullExpression
+  | ESTree.TSSatisfiesExpression
+  | ESTree.TSTypeAssertion;
+
+const renderRoots = new Set(["renderRoot", "shadowRoot"]);
+
+/** Read `settings.lit.elementBaseClasses`, as eslint-plugin-lit does. */
+export function litElementBaseClasses(
+  settings: Readonly<Settings>,
+): ReadonlySet<string> {
+  const configured = jsonObject(settings.lit)?.elementBaseClasses;
+
+  return new Set([
+    "LitElement",
+    ...(Array.isArray(configured) ? configured.map(String) : []),
+  ]);
+}
+
+function isWrapperExpression(
+  node: ESTree.Node | null,
+): node is WrapperExpression {
+  return (
+    node?.type === "ChainExpression" ||
+    node?.type === "ParenthesizedExpression" ||
+    node?.type === "TSAsExpression" ||
+    node?.type === "TSNonNullExpression" ||
+    node?.type === "TSSatisfiesExpression" ||
+    node?.type === "TSTypeAssertion"
+  );
+}
+
+function unwrapExpression(node: ESTree.Node): ESTree.Node {
+  let current = node;
+
+  while (isWrapperExpression(current)) current = current.expression;
+
+  return current;
+}
+
+function extendsLitBase(
+  node: ESTree.Node,
+  bases: ReadonlySet<string>,
+): boolean {
+  if (node.type === "Identifier") return bases.has(node.name);
+
+  return (
+    node.type === "CallExpression" &&
+    node.arguments.some((argument) => extendsLitBase(argument, bases))
+  );
+}
+
+function isLitClass(node: ESTree.Class, bases: ReadonlySet<string>): boolean {
+  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: ESTree.Node): ESTree.Class | null {
+  const owner = body.parent;
+
+  return owner?.type === "ClassDeclaration" || owner?.type === "ClassExpression"
+    ? owner
+    : null;
+}
+
+/** The class whose instance `this` refers to at `node`, if any. */
+function thisClass(node: ESTree.Node): ESTree.Class | null {
+  let current = node;
+
+  while (current.parent) {
+    const parent: ESTree.Node = 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: ESTree.Node | undefined): boolean {
+  return (
+    node?.type === "Literal" ||
+    (node?.type === "TemplateLiteral" && node.expressions.length === 0)
+  );
+}
+
+function renderRootQuery(
+  node: ESTree.CallExpression,
+  bases: ReadonlySet<string>,
+): { readonly method: QueryMethod; readonly root: string } | null {
+  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: string | null): name is AssignedMethod {
+  return name === "assignedElements" || name === "assignedNodes";
+}
+
+function feedsAssignedCall(node: ESTree.CallExpression): boolean {
+  let current: ESTree.Node = node;
+
+  while (isWrapperExpression(current.parent)) current = current.parent;
+
+  const member = current.parent;
+
+  return (
+    member?.type === "MemberExpression" &&
+    member.object === current &&
+    isAssignedMethod(staticMemberName(member))
+  );
+}
+
+/**
+ * Match a static render-root query in a Lit class that a query decorator can
+ * replace, following eslint-plugin-lit's `prefer-query-decorators`.
+ */
+export function litQueryDecoratorCall(
+  node: ESTree.CallExpression,
+  bases: ReadonlySet<string>,
+): { readonly method: LitQueryMethod; readonly root: string } | null {
+  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;
+}
+
+/** Whether a call is a static render-root query in a Lit class. */
+export function isLitRenderRootQuery(
+  node: ESTree.CallExpression,
+  bases: ReadonlySet<string>,
+): boolean {
+  return renderRootQuery(node, bases) !== null;
+}

package/src/shared/scope.ts

@@ -0,0 +1 @@
+export { resolveVariable } from "../../vendor/anti-slop/src/shared/scope.ts";