@timmo001/oxlint-rules 0.3.0 → 0.3.2

package/dist/upstream/effect.js

@@ -1,8 +1,149 @@
 // vendor/anti-slop/src/effect/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
-// vendor/anti-slop/src/effect/rules/no-service-constructor-imports.ts
+// vendor/anti-slop/src/effect/rules/no-manual-effect-error-tag.ts
 import { defineRule } from "@oxlint/plugins";
+
+// vendor/anti-slop/src/effect/shared/tagged-values.ts
+var equalityOperators = new Set(["==", "===", "!=", "!=="]);
+var broadEffectCatchMethods = new Set(["catch", "catchAll", "catchIf"]);
+var isStringLiteral = (node) => node?.type === "Literal" && typeof node.value === "string";
+var isTagMember = (node) => node?.type === "MemberExpression" && (!node.computed && node.property.type === "Identifier" && node.property.name === "_tag" || node.computed && isStringLiteral(node.property) && node.property.value === "_tag");
+var tagMemberFromComparison = (node) => {
+  if (!equalityOperators.has(node.operator))
+    return;
+  if (isTagMember(node.left) && isStringLiteral(node.right))
+    return node.left;
+  if (isTagMember(node.right) && isStringLiteral(node.left))
+    return node.right;
+  return;
+};
+var isBroadEffectCatchCall = (node) => node?.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "Effect" && !node.callee.computed && node.callee.property.type === "Identifier" && broadEffectCatchMethods.has(node.callee.property.name);
+var isInsideBroadEffectHandler = (node) => {
+  let current = node.parent;
+  while (current !== null && current !== undefined) {
+    if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") {
+      return isBroadEffectCatchCall(current.parent) && current.parent.arguments.includes(current);
+    }
+    current = current.parent;
+  }
+  return false;
+};
+var isReasonTagMember = (node) => node.object.type === "MemberExpression" && (!node.object.computed && node.object.property.type === "Identifier" && node.object.property.name === "reason" || node.object.computed && isStringLiteral(node.object.property) && node.object.property.value === "reason");
+var propertyName = (property) => {
+  if (!property.computed && property.key.type === "Identifier") {
+    return property.key.name;
+  }
+  if (property.key.type === "Literal" && typeof property.key.value === "string") {
+    return property.key.value;
+  }
+  return;
+};
+var isMatchPatternObject = (node) => {
+  const call = node.parent;
+  if (call?.type !== "CallExpression" || !call.arguments.includes(node)) {
+    return false;
+  }
+  const callee = call.callee;
+  return callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "Match" && !callee.computed && callee.property.type === "Identifier" && (callee.property.name === "when" || callee.property.name === "not");
+};
+
+// vendor/anti-slop/src/effect/rules/no-manual-effect-error-tag.ts
+var noManualEffectErrorTagRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Use Effect tagged error handlers instead of manually branching on `_tag` in a catch handler."
+    },
+    messages: {
+      tag: "Use Effect.catchTag or Effect.catchTags instead of manually discriminating a tagged error in a broad Effect catch handler.",
+      reason: "Use Effect.catchReason or Effect.catchReasons instead of manually discriminating a tagged `reason` in a broad Effect catch handler."
+    }
+  },
+  createOnce(context) {
+    return {
+      BinaryExpression(node) {
+        const tagMember = tagMemberFromComparison(node);
+        if (tagMember === undefined || !isInsideBroadEffectHandler(node)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: isReasonTagMember(tagMember) ? "reason" : "tag"
+        });
+      },
+      SwitchStatement(node) {
+        if (!isTagMember(node.discriminant) || !isInsideBroadEffectHandler(node)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: isReasonTagMember(node.discriminant) ? "reason" : "tag"
+        });
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/effect/rules/no-manual-tag-comparison.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+var noManualTagComparisonRule = defineRule2({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Use Effect Match or Predicate helpers instead of manually branching on `_tag`."
+    },
+    messages: {
+      manualComparison: "Use Match.tag/Match.tags for tagged-value branching, or Predicate.isTagged for a simple reusable predicate.",
+      manualSwitch: "Use Match.value(value).pipe(Match.tag/Match.tags/Match.tagsExhaustive) or the tagged enum `$match` helper instead of switching on `_tag`."
+    }
+  },
+  createOnce(context) {
+    return {
+      BinaryExpression(node) {
+        if (tagMemberFromComparison(node) === undefined || isInsideBroadEffectHandler(node)) {
+          return;
+        }
+        context.report({ node, messageId: "manualComparison" });
+      },
+      SwitchStatement(node) {
+        if (!isTagMember(node.discriminant) || isInsideBroadEffectHandler(node)) {
+          return;
+        }
+        context.report({ node, messageId: "manualSwitch" });
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/effect/rules/no-manual-tagged-construction.ts
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+var noManualTaggedConstructionRule = defineRule3({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Construct tagged values with their existing Effect constructor instead of writing `_tag` manually."
+    },
+    messages: {
+      manualConstruction: "Use the existing Schema tagged `.make`, tagged class/error constructor, or Data.taggedEnum variant constructor instead of writing a literal `_tag` object."
+    }
+  },
+  createOnce(context) {
+    return {
+      ObjectExpression(node) {
+        if (isMatchPatternObject(node))
+          return;
+        const tag = node.properties.find((property) => property.type === "Property" && propertyName(property) === "_tag" && isStringLiteral(property.value));
+        if (tag !== undefined) {
+          context.report({ node: tag, messageId: "manualConstruction" });
+        }
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/effect/rules/no-service-constructor-imports.ts
+import { defineRule as defineRule4 } from "@oxlint/plugins";
 var SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
 var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
 function isProjectLocalImport(source) {
@@ -13,7 +154,7 @@ function getImportedName(specifier) {
     return specifier.imported.name;
   return specifier.imported.value;
 }
-var noServiceConstructorImportsRule = defineRule({
+var noServiceConstructorImportsRule = defineRule4({
   meta: {
     type: "problem",
     docs: {
@@ -46,11 +187,63 @@ var noServiceConstructorImportsRule = defineRule({
   }
 });
 
+// vendor/anti-slop/src/effect/rules/prefer-effect-match.ts
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var equalityOperators2 = new Set(["==", "===", "!=", "!=="]);
+var preferEffectMatchRule = defineRule5({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Use Match from Effect for chained literal ternaries over the same value."
+    },
+    messages: {
+      preferMatch: "Use Match from Effect instead of a chained literal ternary."
+    }
+  },
+  createOnce(context) {
+    const isLiteral = (node) => node.type === "Literal" || node.type === "TemplateLiteral" && node.expressions.length === 0;
+    const comparedValue = (node) => {
+      if (node.type !== "BinaryExpression" || !equalityOperators2.has(node.operator)) {
+        return;
+      }
+      if (isLiteral(node.left))
+        return context.sourceCode.getText(node.right);
+      if (isLiteral(node.right))
+        return context.sourceCode.getText(node.left);
+      return;
+    };
+    return {
+      ConditionalExpression(node) {
+        if (node.parent?.type === "ConditionalExpression")
+          return;
+        const value = comparedValue(node.test);
+        if (value === undefined)
+          return;
+        let alternate = node.alternate;
+        let literalChecks = 1;
+        while (alternate.type === "ConditionalExpression") {
+          if (comparedValue(alternate.test) !== value)
+            return;
+          literalChecks += 1;
+          alternate = alternate.alternate;
+        }
+        if (literalChecks > 1) {
+          context.report({ node, messageId: "preferMatch" });
+        }
+      }
+    };
+  }
+});
+
 // vendor/anti-slop/src/effect/index.ts
 var antiSlopEffectPlugin = eslintCompatPlugin({
   meta: { name: "anti-slop-effect" },
   rules: {
-    "no-service-constructor-imports": noServiceConstructorImportsRule
+    "no-manual-effect-error-tag": noManualEffectErrorTagRule,
+    "no-manual-tag-comparison": noManualTagComparisonRule,
+    "no-manual-tagged-construction": noManualTaggedConstructionRule,
+    "no-service-constructor-imports": noServiceConstructorImportsRule,
+    "prefer-effect-match": preferEffectMatchRule
   }
 });
 var effect_default = antiSlopEffectPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timmo001/oxlint-rules",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Shared Oxlint plugins and configs with optional Effect rules.",
   "type": "module",
   "license": "Apache-2.0",
@@ -45,13 +45,13 @@
     "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@oxlint/plugins": "1.81.0",
-    "oxlint": "1.81.0"
+    "@oxlint/plugins": "1.82.0",
+    "oxlint": "1.82.0"
   },
   "devDependencies": {
-    "@oxlint/plugins": "1.81.0",
+    "@oxlint/plugins": "1.82.0",
     "@types/bun": "^1.3.14",
-    "oxlint": "1.81.0",
+    "oxlint": "1.82.0",
     "prettier": "^3.9.5",
     "skills-ref": "0.1.5",
     "typescript": "^7.0.0"

package/vendor/anti-slop/src/effect/index.ts

@@ -1,12 +1,20 @@
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
+import { noManualEffectErrorTagRule } from "./rules/no-manual-effect-error-tag.ts";
+import { noManualTagComparisonRule } from "./rules/no-manual-tag-comparison.ts";
+import { noManualTaggedConstructionRule } from "./rules/no-manual-tagged-construction.ts";
 import { noServiceConstructorImportsRule } from "./rules/no-service-constructor-imports.ts";
+import { preferEffectMatchRule } from "./rules/prefer-effect-match.ts";
 
 /** Opt-in Oxlint rules for Effect service and Layer architecture. */
 const antiSlopEffectPlugin = eslintCompatPlugin({
 	meta: { name: "anti-slop-effect" },
 	rules: {
+		"no-manual-effect-error-tag": noManualEffectErrorTagRule,
+		"no-manual-tag-comparison": noManualTagComparisonRule,
+		"no-manual-tagged-construction": noManualTaggedConstructionRule,
 		"no-service-constructor-imports": noServiceConstructorImportsRule,
+		"prefer-effect-match": preferEffectMatchRule,
 	},
 });
 

package/vendor/anti-slop/src/effect/rules/no-manual-effect-error-tag.ts

@@ -0,0 +1,52 @@
+import { defineRule } from "@oxlint/plugins";
+
+import {
+	isInsideBroadEffectHandler,
+	isReasonTagMember,
+	isTagMember,
+	tagMemberFromComparison,
+} from "../shared/tagged-values.ts";
+
+export const noManualEffectErrorTagRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Use Effect tagged error handlers instead of manually branching on `_tag` in a catch handler.",
+		},
+		messages: {
+			tag: "Use Effect.catchTag or Effect.catchTags instead of manually discriminating a tagged error in a broad Effect catch handler.",
+			reason:
+				"Use Effect.catchReason or Effect.catchReasons instead of manually discriminating a tagged `reason` in a broad Effect catch handler.",
+		},
+	},
+	createOnce(context) {
+		return {
+			BinaryExpression(node) {
+				const tagMember = tagMemberFromComparison(node);
+				if (
+					tagMember === undefined ||
+					!isInsideBroadEffectHandler(node)
+				) {
+					return;
+				}
+				context.report({
+					node,
+					messageId: isReasonTagMember(tagMember) ? "reason" : "tag",
+				});
+			},
+			SwitchStatement(node) {
+				if (
+					!isTagMember(node.discriminant) ||
+					!isInsideBroadEffectHandler(node)
+				) {
+					return;
+				}
+				context.report({
+					node,
+					messageId: isReasonTagMember(node.discriminant) ? "reason" : "tag",
+				});
+			},
+		};
+	},
+});

package/vendor/anti-slop/src/effect/rules/no-manual-tag-comparison.ts

@@ -0,0 +1,45 @@
+import { defineRule } from "@oxlint/plugins";
+
+import {
+	isInsideBroadEffectHandler,
+	isTagMember,
+	tagMemberFromComparison,
+} from "../shared/tagged-values.ts";
+
+export const noManualTagComparisonRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Use Effect Match or Predicate helpers instead of manually branching on `_tag`.",
+		},
+		messages: {
+			manualComparison:
+				"Use Match.tag/Match.tags for tagged-value branching, or Predicate.isTagged for a simple reusable predicate.",
+			manualSwitch:
+				"Use Match.value(value).pipe(Match.tag/Match.tags/Match.tagsExhaustive) or the tagged enum `$match` helper instead of switching on `_tag`.",
+		},
+	},
+	createOnce(context) {
+		return {
+			BinaryExpression(node) {
+				if (
+					tagMemberFromComparison(node) === undefined ||
+					isInsideBroadEffectHandler(node)
+				) {
+					return;
+				}
+				context.report({ node, messageId: "manualComparison" });
+			},
+			SwitchStatement(node) {
+				if (
+					!isTagMember(node.discriminant) ||
+					isInsideBroadEffectHandler(node)
+				) {
+					return;
+				}
+				context.report({ node, messageId: "manualSwitch" });
+			},
+		};
+	},
+});

package/vendor/anti-slop/src/effect/rules/no-manual-tagged-construction.ts

@@ -0,0 +1,37 @@
+import { defineRule } from "@oxlint/plugins";
+
+import {
+	isMatchPatternObject,
+	isStringLiteral,
+	propertyName,
+} from "../shared/tagged-values.ts";
+
+export const noManualTaggedConstructionRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Construct tagged values with their existing Effect constructor instead of writing `_tag` manually.",
+		},
+		messages: {
+			manualConstruction:
+				"Use the existing Schema tagged `.make`, tagged class/error constructor, or Data.taggedEnum variant constructor instead of writing a literal `_tag` object.",
+		},
+	},
+	createOnce(context) {
+		return {
+			ObjectExpression(node) {
+				if (isMatchPatternObject(node)) return;
+				const tag = node.properties.find(
+					(property) =>
+						property.type === "Property" &&
+						propertyName(property) === "_tag" &&
+						isStringLiteral(property.value),
+				);
+				if (tag !== undefined) {
+					context.report({ node: tag, messageId: "manualConstruction" });
+				}
+			},
+		};
+	},
+});

package/vendor/anti-slop/src/effect/rules/prefer-effect-match.ts

@@ -0,0 +1,54 @@
+import { defineRule, type ESTree } from "@oxlint/plugins";
+
+const equalityOperators = new Set(["==", "===", "!=", "!=="]);
+
+export const preferEffectMatchRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Use Match from Effect for chained literal ternaries over the same value.",
+		},
+		messages: {
+			preferMatch:
+				"Use Match from Effect instead of a chained literal ternary.",
+		},
+	},
+	createOnce(context) {
+		const isLiteral = (node: ESTree.Node): boolean =>
+			node.type === "Literal" ||
+			(node.type === "TemplateLiteral" && node.expressions.length === 0);
+
+		const comparedValue = (node: ESTree.Expression): string | undefined => {
+			if (
+				node.type !== "BinaryExpression" ||
+				!equalityOperators.has(node.operator)
+			) {
+				return undefined;
+			}
+			if (isLiteral(node.left)) return context.sourceCode.getText(node.right);
+			if (isLiteral(node.right)) return context.sourceCode.getText(node.left);
+			return undefined;
+		};
+
+		return {
+			ConditionalExpression(node) {
+				if (node.parent?.type === "ConditionalExpression") return;
+				const value = comparedValue(node.test);
+				if (value === undefined) return;
+
+				let alternate = node.alternate;
+				let literalChecks = 1;
+				while (alternate.type === "ConditionalExpression") {
+					if (comparedValue(alternate.test) !== value) return;
+					literalChecks += 1;
+					alternate = alternate.alternate;
+				}
+
+				if (literalChecks > 1) {
+					context.report({ node, messageId: "preferMatch" });
+				}
+			},
+		};
+	},
+});

package/vendor/anti-slop/src/effect/shared/tagged-values.ts

@@ -0,0 +1,97 @@
+import type { ESTree } from "@oxlint/plugins";
+
+const equalityOperators = new Set(["==", "===", "!=", "!=="]);
+const broadEffectCatchMethods = new Set(["catch", "catchAll", "catchIf"]);
+
+export const isStringLiteral = (
+	node: ESTree.Node | null | undefined,
+): node is ESTree.StringLiteral =>
+	node?.type === "Literal" && typeof node.value === "string";
+
+export const isTagMember = (
+	node: ESTree.Node | null | undefined,
+): node is ESTree.MemberExpression =>
+	node?.type === "MemberExpression" &&
+	((!node.computed &&
+		node.property.type === "Identifier" &&
+		node.property.name === "_tag") ||
+		(node.computed &&
+			isStringLiteral(node.property) &&
+			node.property.value === "_tag"));
+
+export const tagMemberFromComparison = (
+	node: ESTree.BinaryExpression,
+): ESTree.MemberExpression | undefined => {
+	if (!equalityOperators.has(node.operator)) return undefined;
+	if (isTagMember(node.left) && isStringLiteral(node.right)) return node.left;
+	if (isTagMember(node.right) && isStringLiteral(node.left)) return node.right;
+	return undefined;
+};
+
+const isBroadEffectCatchCall = (
+	node: ESTree.Node | null | undefined,
+): node is ESTree.CallExpression =>
+	node?.type === "CallExpression" &&
+	node.callee.type === "MemberExpression" &&
+	node.callee.object.type === "Identifier" &&
+	node.callee.object.name === "Effect" &&
+	!node.callee.computed &&
+	node.callee.property.type === "Identifier" &&
+	broadEffectCatchMethods.has(node.callee.property.name);
+
+export const isInsideBroadEffectHandler = (node: ESTree.Node): boolean => {
+	let current: ESTree.Node | null | undefined = node.parent;
+	while (current !== null && current !== undefined) {
+		if (
+			current.type === "ArrowFunctionExpression" ||
+			current.type === "FunctionExpression"
+		) {
+			return (
+				isBroadEffectCatchCall(current.parent) &&
+				current.parent.arguments.includes(current)
+			);
+		}
+		current = current.parent;
+	}
+	return false;
+};
+
+export const isReasonTagMember = (node: ESTree.MemberExpression): boolean =>
+	node.object.type === "MemberExpression" &&
+	((!node.object.computed &&
+		node.object.property.type === "Identifier" &&
+		node.object.property.name === "reason") ||
+		(node.object.computed &&
+			isStringLiteral(node.object.property) &&
+			node.object.property.value === "reason"));
+
+export const propertyName = (
+	property: ESTree.ObjectProperty,
+): string | undefined => {
+	if (!property.computed && property.key.type === "Identifier") {
+		return property.key.name;
+	}
+	if (
+		property.key.type === "Literal" &&
+		typeof property.key.value === "string"
+	) {
+		return property.key.value;
+	}
+	return undefined;
+};
+
+export const isMatchPatternObject = (node: ESTree.ObjectExpression): boolean => {
+	const call = node.parent;
+	if (call?.type !== "CallExpression" || !call.arguments.includes(node)) {
+		return false;
+	}
+	const callee = call.callee;
+	return (
+		callee.type === "MemberExpression" &&
+		callee.object.type === "Identifier" &&
+		callee.object.name === "Match" &&
+		!callee.computed &&
+		callee.property.type === "Identifier" &&
+		(callee.property.name === "when" || callee.property.name === "not")
+	);
+};

package/vendor/anti-slop/src/index.ts

@@ -1,5 +1,7 @@
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
+import { noArrayFilterMapRule } from "./rules/no-array-filter-map.ts";
+import { noReduceAccumulatorCopyRule } from "./rules/no-reduce-accumulator-copy.ts";
 import { noChainedTypeAssertionsRule } from "./rules/no-chained-type-assertions.ts";
 import { noConditionalEmptyObjectSpreadRule } from "./rules/no-conditional-empty-object-spread.ts";
 import { noKnownValueWideningRule } from "./rules/no-known-value-widening.ts";
@@ -14,12 +16,15 @@ import { noUnknownReturnsRule } from "./rules/no-unknown-returns.ts";
 import { noUnknownTypeAliasesRule } from "./rules/no-unknown-type-aliases.ts";
 import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.ts";
 import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.ts";
+import { requireReadableSpacingRule } from "./rules/require-readable-spacing.ts";
 import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.ts";
 
 /** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
 const antiSlopPlugin = eslintCompatPlugin({
 	meta: { name: "anti-slop" },
 	rules: {
+		"no-array-filter-map": noArrayFilterMapRule,
+		"no-reduce-accumulator-copy": noReduceAccumulatorCopyRule,
 		"no-chained-type-assertions": noChainedTypeAssertionsRule,
 		"no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
 		"no-known-value-widening": noKnownValueWideningRule,
@@ -34,6 +39,7 @@ const antiSlopPlugin = eslintCompatPlugin({
 		"no-unknown-returns": noUnknownReturnsRule,
 		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
 		"no-widen-then-assert": noWidenThenAssertRule,
+		"require-readable-spacing": requireReadableSpacingRule,
 		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
 	},
 });

package/vendor/anti-slop/src/rules/no-array-filter-map.ts

@@ -0,0 +1,28 @@
+import { defineRule } from "@oxlint/plugins";
+
+import { arrayMethodTarget, isKnownArrayExpression, unwrapArrayExpression } from "../shared/array-method.ts";
+
+/** Reject eager array filter/map pipelines; lazy iterator helpers remain allowed. */
+export const noArrayFilterMapRule = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: { description: "Disallow adjacent array filter/map passes in favor of lazy iterator helpers or a single transformation." },
+    messages: {
+      arrayFilterMap: "Avoid consecutive array `{{first}}` and `{{second}}` passes. Prefer `.values().{{first}}(...).{{second}}(...).toArray()` where iterator helpers are supported, or a single `flatMap`/mutating reducer. Preserve callback ordering, indexes, and filtering semantics.",
+    },
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const outer = arrayMethodTarget(node.callee);
+        if (outer === null || (outer.name !== "map" && outer.name !== "filter")) return;
+        const innerCall = unwrapArrayExpression(outer.object);
+        if (innerCall.type !== "CallExpression") return;
+        const inner = arrayMethodTarget(innerCall.callee);
+        if (inner === null || inner.name !== (outer.name === "map" ? "filter" : "map")) return;
+        if (!isKnownArrayExpression(context.sourceCode, inner.object)) return;
+        context.report({ node, messageId: "arrayFilterMap", data: { first: inner.name, second: outer.name } });
+      },
+    };
+  },
+});

package/vendor/anti-slop/src/rules/no-known-value-widening.ts

@@ -13,8 +13,9 @@ import {
 	functionParameterBindingName,
 	functionParameterTypeAnnotation,
 } from "../shared/function-parameters.ts";
+import { resolveVariable } from "../shared/scope.ts";
 
-import type { ESTree, Scope, SourceCode, Variable } from "@oxlint/plugins";
+import type { ESTree, SourceCode, Variable } from "@oxlint/plugins";
 
 type FunctionExpression = ESTree.ArrowFunctionExpression | ESTree.Function;
 
@@ -32,19 +33,6 @@ function unwrapExpression(expression: ESTree.Expression): ESTree.Expression {
 	return current;
 }
 
-function resolveVariable(
-	sourceCode: SourceCode,
-	identifier: ESTree.IdentifierReference,
-): Variable | null {
-	let scope: Scope | null = sourceCode.getScope(identifier);
-	while (scope !== null) {
-		const variable = scope.set.get(identifier.name);
-		if (variable !== undefined) return variable;
-		scope = scope.upper;
-	}
-	return null;
-}
-
 function variableDeclarator(variable: Variable): ESTree.VariableDeclarator | null {
 	if (variable.defs.length !== 1) return null;
 	const [definition] = variable.defs;

package/vendor/anti-slop/src/rules/no-module-mocking.ts

@@ -1,21 +1,10 @@
 import { defineRule } from "@oxlint/plugins";
 
-import type { ESTree, Scope, SourceCode, Variable } from "@oxlint/plugins";
+import { resolveVariable } from "../shared/scope.ts";
 
-const moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
+import type { ESTree, SourceCode } from "@oxlint/plugins";
 
-function resolveVariable(
-  sourceCode: SourceCode,
-  identifier: ESTree.IdentifierReference,
-): Variable | null {
-  let scope: Scope | null = sourceCode.getScope(identifier);
-  while (scope !== null) {
-    const variable = scope.set.get(identifier.name);
-    if (variable !== undefined) return variable;
-    scope = scope.upper;
-  }
-  return null;
-}
+const moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
 
 function importedName(node: ESTree.Node): string | null {
   if (node.type !== "ImportSpecifier") return null;