refactor(linter/plugins): rename RuleAndContext to RuleDetails (#15480)

Pure refactor. Give this type a better name. It now contains a lot more than just the `Rule` and `Context`.

Author: overlookmotel

apps/oxlint/src-js/plugins/context.ts

@@ -32,7 +32,7 @@ import { SOURCE_CODE } from './source_code.js';
 import { settings, initSettings } from './settings.js';
 
 import type { Fix, FixFn } from './fix.ts';
-import type { RuleAndContext } from './load.ts';
+import type { RuleDetails } from './load.ts';
 import type { SourceCode } from './source_code.ts';
 import type { Location, Ranged } from './types.ts';
 
@@ -256,10 +256,10 @@ export interface Context extends FileContext {
 /**
  * Create `Context` object for a rule.
  * @param fullRuleName - Full rule name, including plugin name e.g. `my-plugin/my-rule`
- * @param ruleAndContext - `RuleAndContext` object
+ * @param ruleDetails - `RuleDetails` object
  * @returns `Context` object
  */
-export function createContext(fullRuleName: string, ruleAndContext: RuleAndContext): Readonly<Context> {
+export function createContext(fullRuleName: string, ruleDetails: RuleDetails): Readonly<Context> {
   // Create `Context` object for rule.
   //
   // All properties are enumerable, to support a pattern which some ESLint plugins use:
@@ -290,31 +290,31 @@ export function createContext(fullRuleName: string, ruleAndContext: RuleAndConte
     // Getter for rule options for this rule on this file
     get options(): Readonly<unknown[]> {
       if (filePath === null) throw new Error('Cannot access `context.options` in `createOnce`');
-      return ruleAndContext.options;
+      return ruleDetails.options;
     },
     /**
      * Report error.
      * @param diagnostic - Diagnostic object
      * @throws {TypeError} If `diagnostic` is invalid
      */
     report(diagnostic: Diagnostic): void {
-      // Delegate to `reportImpl`, passing rule-specific details (`RuleAndContext`)
-      reportImpl(diagnostic, ruleAndContext);
+      // Delegate to `reportImpl`, passing rule-specific details (`RuleDetails`)
+      reportImpl(diagnostic, ruleDetails);
     },
   } as unknown as Context); // It seems TS can't understand `__proto__: FILE_CONTEXT`
 }
 
 /**
  * Report error.
  * @param diagnostic - Diagnostic object
- * @param ruleAndContext - `RuleAndContext` object, containing rule-specific details e.g. `isFixable`
+ * @param ruleDetails - `RuleDetails` object, containing rule-specific details e.g. `isFixable`
  * @throws {TypeError} If `diagnostic` is invalid
  */
-function reportImpl(diagnostic: Diagnostic, ruleAndContext: RuleAndContext): void {
+function reportImpl(diagnostic: Diagnostic, ruleDetails: RuleDetails): void {
   if (filePath === null) throw new Error('Cannot report errors in `createOnce`');
 
   // Get message, resolving message from `messageId` if present
-  let message = getMessage(diagnostic, ruleAndContext);
+  let message = getMessage(diagnostic, ruleDetails);
 
   // Interpolate placeholders {{key}} with data values
   if (hasOwn(diagnostic, 'data')) {
@@ -369,22 +369,22 @@ function reportImpl(diagnostic: Diagnostic, ruleAndContext: RuleAndContext): voi
     message,
     start,
     end,
-    ruleIndex: ruleAndContext.ruleIndex,
-    fixes: getFixes(diagnostic, ruleAndContext),
+    ruleIndex: ruleDetails.ruleIndex,
+    fixes: getFixes(diagnostic, ruleDetails),
   });
 }
 
 /**
  * Get message from diagnostic.
  * @param diagnostic - Diagnostic object
- * @param ruleAndContext - `RuleAndContext` object, containing rule-specific `messages`
+ * @param ruleDetails - `RuleDetails` object, containing rule-specific `messages`
  * @returns Message string
  * @throws {Error|TypeError} If neither `message` nor `messageId` provided, or of wrong type
  */
-function getMessage(diagnostic: Diagnostic, ruleAndContext: RuleAndContext): string {
+function getMessage(diagnostic: Diagnostic, ruleDetails: RuleDetails): string {
   if (hasOwn(diagnostic, 'messageId')) {
     const { messageId } = diagnostic as { messageId: string | null | undefined };
-    if (messageId != null) return resolveMessageFromMessageId(messageId, ruleAndContext);
+    if (messageId != null) return resolveMessageFromMessageId(messageId, ruleDetails);
   }
 
   if (hasOwn(diagnostic, 'message')) {
@@ -399,12 +399,12 @@ function getMessage(diagnostic: Diagnostic, ruleAndContext: RuleAndContext): str
 /**
  * Resolve a message ID to its message string, with optional data interpolation.
  * @param messageId - The message ID to resolve
- * @param ruleAndContext - `RuleAndContext` object, containing rule-specific `messages`
+ * @param ruleDetails - `RuleDetails` object, containing rule-specific `messages`
  * @returns Resolved message string
  * @throws {Error} If `messageId` is not found in `messages`
  */
-function resolveMessageFromMessageId(messageId: string, ruleAndContext: RuleAndContext): string {
-  const { messages } = ruleAndContext;
+function resolveMessageFromMessageId(messageId: string, ruleDetails: RuleDetails): string {
+  const { messages } = ruleDetails;
   if (messages === null) {
     throw new Error(`Cannot use messageId '${messageId}' - rule does not define any messages in \`meta.messages\``);
   }

apps/oxlint/src-js/plugins/fix.ts

@@ -1,7 +1,7 @@
 import { assertIs } from './utils.js';
 
 import type { Diagnostic } from './context.ts';
-import type { RuleAndContext } from './load.ts';
+import type { RuleDetails } from './load.ts';
 import type { Range, Ranged } from './types.ts';
 
 const { prototype: ArrayPrototype, from: ArrayFrom } = Array,
@@ -78,12 +78,12 @@ export type Fixer = typeof FIXER;
  * with getters. As we're not managing to be 100% bulletproof anyway, maybe we don't need to be quite so defensive.
  *
  * @param diagnostic - Diagnostic object
- * @param ruleAndContext - `RuleAndContext` object, containing rule-specific `isFixable` value
+ * @param ruleDetails - `RuleDetails` object, containing rule-specific `isFixable` value
  * @returns Non-empty array of `Fix` objects, or `null` if none
  * @throws {Error} If rule is not marked as fixable but `fix` function returns fixes,
  *   or if `fix` function returns any invalid `Fix` objects
  */
-export function getFixes(diagnostic: Diagnostic, ruleAndContext: RuleAndContext): Fix[] | null {
+export function getFixes(diagnostic: Diagnostic, ruleDetails: RuleDetails): Fix[] | null {
   // ESLint silently ignores non-function `fix` values, so we do the same
   const { fix } = diagnostic;
   if (typeof fix !== 'function') return null;
@@ -138,7 +138,7 @@ export function getFixes(diagnostic: Diagnostic, ruleAndContext: RuleAndContext)
 
   // ESLint does not throw this error if `fix` function returns only falsy values.
   // We've already exited if that is the case, so we're reproducing that behavior.
-  if (ruleAndContext.isFixable === false) {
+  if (ruleDetails.isFixable === false) {
     throw new Error('Fixable rules must set the `meta.fixable` property to "code" or "whitespace".');
   }
 

apps/oxlint/src-js/plugins/lint.ts

@@ -127,20 +127,20 @@ function lintFileImpl(
 
   for (let i = 0, len = ruleIds.length; i < len; i++) {
     const ruleId = ruleIds[i],
-      ruleAndContext = registeredRules[ruleId];
+      ruleDetails = registeredRules[ruleId];
 
     // Set `ruleIndex` for rule. It's used when sending diagnostics back to Rust.
-    ruleAndContext.ruleIndex = i;
+    ruleDetails.ruleIndex = i;
 
-    const { rule, context } = ruleAndContext;
+    const { rule, context } = ruleDetails;
 
-    let { visitor } = ruleAndContext;
+    let { visitor } = ruleDetails;
     if (visitor === null) {
       // Rule defined with `create` method
       visitor = rule.create(context);
     } else {
       // Rule defined with `createOnce` method
-      const { beforeHook, afterHook } = ruleAndContext;
+      const { beforeHook, afterHook } = ruleDetails;
       if (beforeHook !== null) {
         // If `before` hook returns `false`, skip this rule
         const shouldRun = beforeHook();

apps/oxlint/src-js/plugins/load.ts

@@ -35,11 +35,13 @@ export interface CreateOnceRule {
   createOnce: (context: Context) => VisitorWithHooks;
 }
 
-// Linter rule and context object.
-// If `rule` has a `createOnce` method, the visitor it returns is stored in `visitor`.
-export type RuleAndContext = CreateRuleAndContext | CreateOnceRuleAndContext;
+/**
+ * Linter rule, context object, and other details of rule.
+ * If `rule` has a `createOnce` method, the visitor it returns is stored in `visitor` property.
+ */
+export type RuleDetails = CreateRuleDetails | CreateOnceRuleDetails;
 
-interface RuleAndContextBase {
+interface RuleDetailsBase {
   // Static properties of the rule
   readonly context: Readonly<Context>;
   readonly isFixable: boolean;
@@ -49,14 +51,14 @@ interface RuleAndContextBase {
   options: Readonly<unknown[]>;
 }
 
-interface CreateRuleAndContext extends RuleAndContextBase {
+interface CreateRuleDetails extends RuleDetailsBase {
   rule: CreateRule;
   visitor: null;
   beforeHook: null;
   afterHook: null;
 }
 
-interface CreateOnceRuleAndContext extends RuleAndContextBase {
+interface CreateOnceRuleDetails extends RuleDetailsBase {
   rule: CreateOnceRule;
   visitor: Visitor;
   beforeHook: BeforeHook | null;
@@ -68,7 +70,7 @@ const registeredPluginPaths = new Set<string>();
 
 // Rule objects for loaded rules.
 // Indexed by `ruleId`, which is passed to `lintFile`.
-export const registeredRules: RuleAndContext[] = [];
+export const registeredRules: RuleDetails[] = [];
 
 // `before` hook which makes rule never run.
 const neverRunBeforeHook: BeforeHook = () => false;
@@ -162,8 +164,8 @@ async function loadPluginImpl(path: string, packageName?: string): Promise<Plugi
       }
     }
 
-    // Create `RuleAndContext` object for rule.
-    const ruleAndContext: RuleAndContext = {
+    // Create `RuleDetails` object for rule.
+    const ruleDetails: RuleDetails = {
       rule: rule as CreateRule, // Could also be `CreateOnceRule`, but just to satisfy type checker
       context: null, // Filled in below
       isFixable,
@@ -176,8 +178,8 @@ async function loadPluginImpl(path: string, packageName?: string): Promise<Plugi
     };
 
     // Create `Context` object for rule. This will be re-used for every file.
-    const context = createContext(`${pluginName}/${ruleName}`, ruleAndContext);
-    (ruleAndContext as Writable<RuleAndContext>).context = context;
+    const context = createContext(`${pluginName}/${ruleName}`, ruleDetails);
+    (ruleDetails as Writable<RuleDetails>).context = context;
 
     if ('createOnce' in rule) {
       // TODO: Compile visitor object to array here, instead of repeating compilation on each file
@@ -203,12 +205,12 @@ async function loadPluginImpl(path: string, packageName?: string): Promise<Plugi
         afterHook = null;
       }
 
-      (ruleAndContext as CreateOnceRuleAndContext).visitor = visitor;
-      (ruleAndContext as CreateOnceRuleAndContext).beforeHook = beforeHook;
-      (ruleAndContext as CreateOnceRuleAndContext).afterHook = afterHook;
+      (ruleDetails as CreateOnceRuleDetails).visitor = visitor;
+      (ruleDetails as CreateOnceRuleDetails).beforeHook = beforeHook;
+      (ruleDetails as CreateOnceRuleDetails).afterHook = afterHook;
     }
 
-    registeredRules.push(ruleAndContext);
+    registeredRules.push(ruleDetails);
   }
 
   return { name: pluginName, offset, ruleNames };