@goodbones/oxlint 0.1.0-beta.6 → 0.1.0-beta.8

package/src/imports-rule.ts

@@ -5,20 +5,15 @@ import {
   rulesSelecting,
   type SelectedRule,
 } from "@goodbones/core";
+import type { ReadEdge } from "@goodbones/typescript";
 import * as Result from "effect/Result";
 
 import {
-  type CallNode,
-  type ImportEqualsNode,
-  importEqualsSpecifierOf,
-  type ImportExpressionNode,
-  importExpressionSpecifierOf,
+  at,
+  factsOfProgram,
   type OxlintRule,
-  type ReportableNode,
-  requireSpecifierOf,
+  type Program,
   type RuleContext,
-  type SourceNode,
-  specifierOf,
   toRepoRelative,
 } from "./oxlint-api.js";
 
@@ -44,32 +39,29 @@ export const makeImportsRule = (policy: LoadedPolicy): OxlintRule => ({
     let importer = "";
     let selected: ReadonlyArray<SelectedRule> = [];
 
-    const check = (node: ReportableNode, specifier: string | null): void => {
-      if (specifier === null) return;
-
+    const check = (edge: ReadEdge): void => {
+      const { specifier } = edge;
       const outcome = evaluateSelectedEdge(selected, policy.resolver, { importer, specifier });
 
       if (Result.isFailure(outcome)) {
         if (policy.config.resolve.unresolved === "off") return;
         if (policy.ignoreUnresolved.some((pattern) => pattern.test(specifier))) return;
-        context.report({ node, message: unresolvedMessage(specifier, outcome.failure.detail) });
+        context.report({
+          node: at(edge.node),
+          message: unresolvedMessage(specifier, outcome.failure.detail),
+        });
         return;
       }
 
       for (const violation of outcome.success) {
         if (policy.baseline.isBaselined(violation)) continue;
-        context.report({ node, message: formatMessage(violation) });
+        context.report({ node: at(edge.node), message: formatMessage(violation) });
       }
     };
 
-    const checkSource = (node: SourceNode): void => {
-      check(node, specifierOf(node));
-    };
-
-    // Every form that names a module is an edge. The CLI adapter reads the same
-    // five out of TypeScript's tree, and the parity suite holds the two to it: a
-    // `require` the plugin skipped would be a rule that enforces nothing under
-    // `oxlint` while failing under `architecture check`.
+    // Every form that names a module is an edge, and the pack's reader is
+    // what says which forms those are — the same reader the CLI reads a file
+    // through, so a form one host sees the other sees too.
     return {
       before() {
         importer = toRepoRelative(policy.repoRoot, context.filename);
@@ -77,19 +69,8 @@ export const makeImportsRule = (policy: LoadedPolicy): OxlintRule => ({
         selected = rulesSelecting(policy.importRules, importer);
         return selected.length > 0;
       },
-      ImportDeclaration: checkSource,
-      ExportNamedDeclaration: checkSource,
-      ExportAllDeclaration: checkSource,
-      // `import("m")` with a literal argument. A computed one is not a fact a
-      // static policy can speak about, in either adapter.
-      ImportExpression(node: ImportExpressionNode) {
-        check(node, importExpressionSpecifierOf(node));
-      },
-      CallExpression(node: CallNode) {
-        check(node, requireSpecifierOf(node));
-      },
-      TSImportEqualsDeclaration(node: ImportEqualsNode) {
-        check(node, importEqualsSpecifierOf(node));
+      Program(node: Program) {
+        for (const edge of factsOfProgram(importer, node).edges) check(edge);
       },
     };
   },

package/src/members-rule.ts

@@ -1,6 +1,5 @@
 import {
   type CompiledMemberRule,
-  type DeclarationKind,
   evaluateMemberSite,
   formatMessage,
   type LoadedPolicy,
@@ -8,112 +7,14 @@ import {
 } from "@goodbones/core";
 
 import {
+  at,
+  factsOfProgram,
   type OxlintRule,
-  type ReportableNode,
+  type Program,
   type RuleContext,
   toRepoRelative,
 } from "./oxlint-api.js";
 
-type NamedNode = ReportableNode & {
-  readonly type: string;
-  readonly name?: unknown;
-  readonly value?: unknown;
-};
-
-type MemberNode = ReportableNode & {
-  readonly type: string;
-  readonly key?: (NamedNode & { readonly type?: string }) | null;
-  readonly computed?: boolean;
-  // A class method's kind: `method`, `get`, `set` or `constructor`.
-  readonly kind?: string;
-};
-
-// A type, as far as this rule reads it: a literal with members, or an
-// intersection / union / parenthesised type wrapping others.
-type TypeNode = ReportableNode & {
-  readonly type: string;
-  readonly members?: ReadonlyArray<MemberNode>;
-  readonly types?: ReadonlyArray<TypeNode>;
-  readonly typeAnnotation?: TypeNode | null;
-};
-
-type TypeAliasNode = ReportableNode & {
-  readonly id?: NamedNode | null;
-  readonly typeAnnotation?: TypeNode | null;
-};
-
-// Every visitor takes the whole `Node` union, so `body` is typed to admit a
-// function body as readily as an interface's, and narrowed below.
-type InterfaceNode = ReportableNode & {
-  readonly id?: NamedNode | null;
-  readonly body?: { readonly type?: string; readonly body?: unknown } | null;
-};
-
-type ClassNode = InterfaceNode;
-
-const isMemberList = (value: unknown): value is ReadonlyArray<MemberNode> => Array.isArray(value);
-
-type CallNode = ReportableNode & {
-  readonly callee?:
-    | (ReportableNode & {
-        readonly type: string;
-        readonly name?: unknown;
-        readonly computed?: boolean;
-        readonly property?: (NamedNode & { readonly type: string }) | null;
-      })
-    | null;
-};
-
-// The member shapes that carry a name a vocabulary rule can speak about: a
-// property or method signature in a type, a property, method or accessor in a
-// class. Mirrors the CLI's `isNamedMember`.
-const DECLARED_MEMBER_TYPES = new Set([
-  "TSPropertySignature",
-  "TSMethodSignature",
-  "PropertyDefinition",
-  "MethodDefinition",
-  "TSAbstractPropertyDefinition",
-  "TSAbstractMethodDefinition",
-]);
-
-// The type literals written in a type, through intersections, unions and
-// parentheses. A reference is not followed: its members are declared where it
-// is, and reported there under its own name. Mirrors the CLI's `literalsOf`.
-const literalsOf = (node: TypeNode | null | undefined): ReadonlyArray<TypeNode> => {
-  if (node === null || node === undefined) return [];
-  switch (node.type) {
-    case "TSTypeLiteral":
-      return [node];
-    case "TSIntersectionType":
-    case "TSUnionType":
-      return (node.types ?? []).flatMap(literalsOf);
-    case "TSParenthesizedType":
-      return literalsOf(node.typeAnnotation);
-    default:
-      return [];
-  }
-};
-
-const nameOf = (node: NamedNode | null | undefined): string | null => {
-  if (node === null || node === undefined) return null;
-  if (typeof node.name === "string") return node.name;
-  return typeof node.value === "string" ? node.value : null;
-};
-
-// The name a call is made by: `f()` and `x.f()` are both `f`. `x[f]()` and
-// `x["f"]()` are not — a computed property is not a name a vocabulary rule can
-// speak about — and neither is a private `x.#f()`. The CLI reads the same
-// three cases out of TypeScript's tree; the parity suite keeps them agreeing.
-const calleeName = (node: CallNode): string | null => {
-  const callee = node.callee;
-  if (callee === null || callee === undefined) return null;
-  if (callee.type === "Identifier" && typeof callee.name === "string") return callee.name;
-  if (callee.type !== "MemberExpression" || callee.computed === true) return null;
-  const property = callee.property;
-  if (property?.type !== "Identifier") return null;
-  return nameOf(property);
-};
-
 export const makeMembersRule = (policy: LoadedPolicy): OxlintRule => ({
   meta: {
     type: "problem" as const,
@@ -128,42 +29,8 @@ export const makeMembersRule = (policy: LoadedPolicy): OxlintRule => ({
     let file = "";
     let selected: ReadonlyArray<CompiledMemberRule> = [];
 
-    const report = (
-      node: ReportableNode,
-      name: string,
-      declaration?: { readonly name: string; readonly declares: DeclarationKind },
-    ): void => {
-      const violations = evaluateMemberSite(selected, {
-        file,
-        subject: declaration === undefined ? "calls" : "members",
-        name,
-        ...(declaration === undefined
-          ? {}
-          : { in: declaration.name, declares: declaration.declares }),
-      });
-      for (const violation of violations) {
-        if (policy.baseline.isBaselined(violation)) continue;
-        context.report({ node, message: formatMessage(violation) });
-      }
-    };
-
-    // The members written in a declaration, under that declaration's name and
-    // kind. A computed key is not a name a vocabulary rule can speak about;
-    // neither is a private `#name`, an index, call or construct signature, or
-    // a constructor.
-    const declared = (
-      declaration: string,
-      declares: DeclarationKind,
-      members: ReadonlyArray<MemberNode>,
-    ): void => {
-      for (const member of members) {
-        if (member.computed === true || !DECLARED_MEMBER_TYPES.has(member.type)) continue;
-        if (member.key?.type === "PrivateIdentifier" || member.kind === "constructor") continue;
-        const name = nameOf(member.key);
-        if (name !== null) report(member.key ?? member, name, { name: declaration, declares });
-      }
-    };
-
+    // A declared member is reported at its key, a call at the call — the nodes
+    // the pack's reader hands back with each site.
     return {
       before() {
         file = toRepoRelative(policy.repoRoot, context.filename);
@@ -171,35 +38,14 @@ export const makeMembersRule = (policy: LoadedPolicy): OxlintRule => ({
         selected = memberRulesSelecting(policy.memberRules, file);
         return selected.length > 0;
       },
-
-      TSTypeAliasDeclaration(node: TypeAliasNode) {
-        const declaration = nameOf(node.id);
-        if (declaration === null) return;
-        for (const literal of literalsOf(node.typeAnnotation)) {
-          declared(declaration, "type", literal.members ?? []);
+      Program(node: Program) {
+        for (const site of factsOfProgram(file, node).memberSites) {
+          for (const violation of evaluateMemberSite(selected, site)) {
+            if (policy.baseline.isBaselined(violation)) continue;
+            context.report({ node: at(site.node), message: formatMessage(violation) });
+          }
         }
       },
-
-      TSInterfaceDeclaration(node: InterfaceNode) {
-        const declaration = nameOf(node.id);
-        const members = node.body?.body;
-        if (declaration === null || !isMemberList(members)) return;
-        declared(declaration, "interface", members);
-      },
-
-      // A named class only, as the CLI reads it: an anonymous default class has
-      // no name for `in`, and a class expression is a value.
-      ClassDeclaration(node: ClassNode) {
-        const declaration = nameOf(node.id);
-        const members = node.body?.body;
-        if (declaration === null || !isMemberList(members)) return;
-        declared(declaration, "class", members);
-      },
-
-      CallExpression(node: CallNode) {
-        const name = calleeName(node);
-        if (name !== null) report(node, name);
-      },
     };
   },
 });

package/src/oxlint-api.ts

@@ -1,5 +1,11 @@
 import * as path from "node:path";
 
+import {
+  type ProgramBody,
+  type ReadFacts,
+  readProgram,
+  type SyntaxNode,
+} from "@goodbones/typescript";
 import type { RuleTester } from "oxlint/plugins-dev";
 
 // oxlint publishes no plugin types, so the exact `Context`, node and fixer shapes
@@ -12,55 +18,33 @@ type Diagnostic = Parameters<RuleContext["report"]>[0];
 export type ReportableNode = Extract<Diagnostic, { node: unknown }>["node"];
 export type Fixer = Parameters<NonNullable<Diagnostic["fix"]>>[0];
 
-export type SourceNode = ReportableNode & {
-  readonly source?: { readonly value?: unknown } | null;
-};
+// The root of the tree oxlint hands a rule, and the one the pack's reader
+// walks.
+export type Program = RuleContext["sourceCode"]["ast"];
 
 export const toRepoRelative = (repoRoot: string, filename: string): string =>
   path.relative(repoRoot, filename).replaceAll(path.sep, "/");
 
-export const specifierOf = (node: SourceNode): string | null => {
-  const value = node.source?.value;
-  return typeof value === "string" ? value : null;
-};
-
-// The three forms that name a module without an `import … from`. Each is an
-// edge for the import rule and a whole-module binding for the export rule, so
-// both read them through these.
-
-// `require("m")` — a CallExpression whose callee is the bare identifier.
-export type CallNode = ReportableNode & {
-  readonly callee?: { readonly type: string; readonly name?: unknown } | null;
-  readonly arguments?: ReadonlyArray<{ readonly type: string; readonly value?: unknown }> | null;
-};
-
-// `import("m")` — `source` is any expression; only a string literal is an edge.
-export type ImportExpressionNode = ReportableNode & {
-  readonly source?: { readonly type?: string; readonly value?: unknown } | null;
-};
-
-// `import x = require("m")` — the module is under `moduleReference`, not `source`.
-export type ImportEqualsNode = ReportableNode & {
-  readonly moduleReference?: {
-    readonly type: string;
-    readonly expression?: { readonly value?: unknown } | null;
-  } | null;
-};
-
-export const requireSpecifierOf = (node: CallNode): string | null => {
-  if (node.callee?.type !== "Identifier" || node.callee.name !== "require") return null;
-  const [first] = node.arguments ?? [];
-  return first?.type === "Literal" && typeof first.value === "string" ? first.value : null;
-};
-
-export const importExpressionSpecifierOf = (node: ImportExpressionNode): string | null => {
-  const source = node.source;
-  return source?.type === "Literal" && typeof source.value === "string" ? source.value : null;
-};
-
-export const importEqualsSpecifierOf = (node: ImportEqualsNode): string | null => {
-  const reference = node.moduleReference;
-  if (reference?.type !== "TSExternalModuleReference") return null;
-  const value = reference.expression?.value;
-  return typeof value === "string" ? value : null;
+// A diagnostic is placed by the node's range, which every node of oxlint's
+// tree carries; a node from another parse carries `start` and `end`.
+export const at = (node: SyntaxNode): ReportableNode => ({
+  range: node.range ?? [node.start, node.end],
+});
+
+// The facts of one file, read once and shared by every rule that runs on it:
+// oxlint deserialises a file's tree once and hands the same `Program` to each
+// rule, so the tree is the key.
+const read = new WeakMap<Program, ReadFacts>();
+
+export const factsOfProgram = (file: string, program: Program): ReadFacts => {
+  const found = read.get(program);
+  if (found !== undefined) return found;
+  // oxlint's node types are `@oxc-project/types`' with `parent` required on
+  // every node — the same tree, generated from the same source. Each node
+  // type assigns on its own; the compiler gives up relating the two
+  // ~190-member recursive unions as wholes, so the boundary is asserted once,
+  // here. The parity suite is what proves the trees are one.
+  const facts = readProgram(file, program as ProgramBody);
+  read.set(program, facts);
+  return facts;
 };

package/src/plugin.ts

@@ -1,3 +1,4 @@
+import { makeCampaignsRule } from "./campaigns-rule.js";
 import { loadPolicyFromFile } from "./config-loader.js";
 import { makeExportsRule } from "./exports-rule.js";
 import { makeImportsRule } from "./imports-rule.js";
@@ -28,12 +29,14 @@ export const rules: {
   readonly members: OxlintRule;
   readonly structure: OxlintRule;
   readonly surface: OxlintRule;
+  readonly campaigns: OxlintRule;
 } = {
   imports: makeImportsRule(policy),
   exports: makeExportsRule(policy),
   members: makeMembersRule(policy),
   structure: makeStructureRule(policy),
   surface: makeSurfaceRule(policy),
+  campaigns: makeCampaignsRule(policy),
 };
 
 const plugin: { readonly meta: { readonly name: string }; readonly rules: typeof rules } = {

package/src/surface-rule.ts

@@ -1,193 +1,21 @@
 import {
   type CompiledSurfaceRule,
-  type DeclarationKind,
   evaluateSurface,
-  type ExportSite,
   formatMessage,
   type LoadedPolicy,
   surfaceRulesSelecting,
 } from "@goodbones/core";
+import type { ReadExportSite } from "@goodbones/typescript";
 
 import {
+  at,
+  factsOfProgram,
   type OxlintRule,
-  type ReportableNode,
+  type Program,
   type RuleContext,
   toRepoRelative,
 } from "./oxlint-api.js";
 
-type NamedNode = ReportableNode & {
-  readonly type?: string;
-  readonly name?: unknown;
-  readonly value?: unknown;
-};
-
-// A top-level statement, as far as this rule reads one. Every field is
-// optional because the visitor takes the whole `Node` union; each is checked
-// before use.
-type StatementNode = ReportableNode & {
-  readonly type: string;
-  readonly id?: NamedNode | null;
-  readonly declaration?: StatementNode | null;
-  readonly declarations?: ReadonlyArray<{ readonly id?: PatternNode | null }> | null;
-  readonly specifiers?: ReadonlyArray<SpecifierNode> | null;
-  readonly source?: { readonly value?: unknown } | null;
-  readonly exported?: NamedNode | null;
-};
-
-type PatternNode = ReportableNode & {
-  readonly type: string;
-  readonly name?: unknown;
-  readonly properties?: ReadonlyArray<{
-    readonly value?: PatternNode | null;
-    readonly argument?: PatternNode | null;
-  }> | null;
-  readonly elements?: ReadonlyArray<PatternNode | null> | null;
-  readonly left?: PatternNode | null;
-  readonly argument?: PatternNode | null;
-};
-
-type SpecifierNode = ReportableNode & {
-  readonly exported?: NamedNode | null;
-  readonly local?: NamedNode | null;
-};
-
-type ProgramNode = ReportableNode & { readonly body?: unknown };
-
-const isStatementList = (value: unknown): value is ReadonlyArray<StatementNode> =>
-  Array.isArray(value);
-
-const nameOf = (node: NamedNode | null | undefined): string | null => {
-  if (node === null || node === undefined) return null;
-  if (typeof node.name === "string") return node.name;
-  return typeof node.value === "string" ? node.value : null;
-};
-
-// The identifiers a binding pattern introduces.
-const patternNames = (pattern: PatternNode | null | undefined): ReadonlyArray<string> => {
-  if (pattern === null || pattern === undefined) return [];
-  switch (pattern.type) {
-    case "Identifier":
-      return typeof pattern.name === "string" ? [pattern.name] : [];
-    case "ObjectPattern":
-      return (pattern.properties ?? []).flatMap((property) =>
-        patternNames(property.value ?? property.argument),
-      );
-    case "ArrayPattern":
-      return (pattern.elements ?? []).flatMap(patternNames);
-    case "AssignmentPattern":
-      return patternNames(pattern.left);
-    case "RestElement":
-      return patternNames(pattern.argument);
-    default:
-      return [];
-  }
-};
-
-// The names a declaration statement introduces, with what it declares them as.
-const declaredNamesOf = (
-  statement: StatementNode,
-): ReadonlyArray<readonly [string, DeclarationKind]> => {
-  const named = (declares: DeclarationKind): ReadonlyArray<readonly [string, DeclarationKind]> => {
-    const name = nameOf(statement.id);
-    return name === null ? [] : [[name, declares]];
-  };
-  switch (statement.type) {
-    case "FunctionDeclaration":
-      return named("function");
-    case "ClassDeclaration":
-      return named("class");
-    case "VariableDeclaration":
-      return (statement.declarations ?? []).flatMap((declaration) =>
-        patternNames(declaration.id).map((name) => [name, "variable"] as const),
-      );
-    case "TSTypeAliasDeclaration":
-      return named("type");
-    case "TSInterfaceDeclaration":
-      return named("interface");
-    case "TSEnumDeclaration":
-      return named("enum");
-    case "TSModuleDeclaration":
-      return named("other");
-    default:
-      return [];
-  }
-};
-
-type Found = { readonly site: ExportSite; readonly node: ReportableNode };
-
-// A file's surface, read off the program body rather than by visiting export
-// nodes: an `export` inside a namespace body is that namespace's, not the
-// module's, and reading the top level directly is what says so without a
-// parent pointer. Mirrors the CLI's `exportSitesOf`.
-const surfaceOf = (file: string, body: ReadonlyArray<StatementNode>): ReadonlyArray<Found> => {
-  const locals = new Map<string, DeclarationKind>();
-  for (const statement of body) {
-    const declaration =
-      statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration"
-        ? statement.declaration
-        : statement;
-    if (declaration === null || declaration === undefined) continue;
-    for (const [name, declares] of declaredNamesOf(declaration)) locals.set(name, declares);
-  }
-
-  const found: Array<Found> = [];
-  const site = (
-    node: ReportableNode,
-    name: string,
-    kind: ExportSite["kind"],
-    declares: DeclarationKind,
-    reexport: boolean,
-  ): void => {
-    found.push({ node, site: { file, name, kind, declares, reexport } });
-  };
-
-  for (const statement of body) {
-    switch (statement.type) {
-      case "ExportNamedDeclaration": {
-        const declaration = statement.declaration;
-        if (declaration !== null && declaration !== undefined) {
-          for (const [name, declares] of declaredNamesOf(declaration)) {
-            site(declaration, name, "named", declares, false);
-          }
-          break;
-        }
-        const reexport = typeof statement.source?.value === "string";
-        for (const specifier of statement.specifiers ?? []) {
-          const name = nameOf(specifier.exported);
-          if (name === null) continue;
-          const local = nameOf(specifier.local) ?? name;
-          const declares = reexport ? "other" : (locals.get(local) ?? "other");
-          site(specifier, name, name === "default" ? "default" : "named", declares, reexport);
-        }
-        break;
-      }
-      case "ExportDefaultDeclaration": {
-        const declaration = statement.declaration;
-        const declares: DeclarationKind =
-          declaration === null || declaration === undefined
-            ? "expression"
-            : declaration.type === "FunctionDeclaration"
-              ? "function"
-              : declaration.type === "ClassDeclaration"
-                ? "class"
-                : declaration.type === "TSInterfaceDeclaration"
-                  ? "interface"
-                  : declaration.type === "Identifier"
-                    ? (locals.get(nameOf(declaration) ?? "") ?? "expression")
-                    : "expression";
-        site(statement, "default", "default", declares, false);
-        break;
-      }
-      case "ExportAllDeclaration":
-        site(statement, nameOf(statement.exported) ?? "*", "namespace", "other", true);
-        break;
-      default:
-        break;
-    }
-  }
-  return found;
-};
-
 export const makeSurfaceRule = (policy: LoadedPolicy): OxlintRule => ({
   meta: {
     type: "problem" as const,
@@ -210,26 +38,24 @@ export const makeSurfaceRule = (policy: LoadedPolicy): OxlintRule => ({
         return selected.length > 0;
       },
 
-      Program(node: ProgramNode) {
-        if (!isStatementList(node.body)) return;
-        const found = surfaceOf(file, node.body);
-        const violations = evaluateSurface(
-          selected,
-          file,
-          found.map((one) => one.site),
-        );
+      Program(node: Program) {
+        const sites = factsOfProgram(file, node).exportSites;
+        const violations = evaluateSurface(selected, file, sites);
 
         // A per-site violation lands on the site's own node; a `count` one, on
         // the program — it is about the file.
-        const used = new Set<Found>();
+        const used = new Set<ReadExportSite>();
         for (const violation of violations) {
           if (policy.baseline.isBaselined(violation)) continue;
-          const at =
+          const site =
             violation.subject === null
               ? undefined
-              : found.find((one) => one.site.name === violation.subject && !used.has(one));
-          if (at !== undefined) used.add(at);
-          context.report({ node: at?.node ?? node, message: formatMessage(violation) });
+              : sites.find((one) => one.name === violation.subject && !used.has(one));
+          if (site !== undefined) used.add(site);
+          context.report({
+            node: site === undefined ? node : at(site.node),
+            message: formatMessage(violation),
+          });
         }
       },
     };