oxlint-plugin-effect 0.16.0 → 0.17.0

package/README.md

@@ -67,8 +67,8 @@ Every recommended rule has `error` severity. The complexity rules carry their li
 | `effect/noEffectBind`                  | Bans Effect.bind                                                                          |
 | `effect/preferCatchTag`                | Replaces manual `_tag` predicates and `catchAll` dispatch with tagged recovery            |
 | `effect/preferEffectFn`                | Requires `Effect.fn` for a generator operation that adds a span                           |
-| `effect/preferMatchTagsExhaustive`     | Requires exhaustive `Match` for return-only `_tag` switches and if chains                 |
-| `effect/preferPredicateIsTagged`       | Replaces combined `_tag` comparisons with a named `Predicate` refinement                  |
+| `effect/preferMatchTagsExhaustive`     | Requires exhaustive `Match` for return-only `_tag` switches and if chains in Effect files |
+| `effect/preferPredicateIsTagged`       | Replaces combined `_tag` comparisons with a named `Predicate` refinement in Effect files  |
 | `effect/preferServiceOf`               | Checks inline Layer implementations through `Service.of`                                  |
 | `effect/requireNamedEffectFn`          | Requires stable names for `Effect.fn` operations                                          |
 | `effect/requireSuppressionReason`      | Requires lint, Effect, and TS suppressions to name their target and give a `--` reason    |

package/dist/rules/_const-bindings.js

@@ -0,0 +1,35 @@
+import { findVariableUp } from "../vendor/effect-oxlint/Scope.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Option from "effect/Option";
+//#region src/rules/_const-bindings.ts
+/** Strips type-only wrappers such as `as const`, `satisfies`, and `!`. */
+const unwrapTypeSyntax = (node) => {
+	let current = node;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression") current = current.expression;
+	return current;
+};
+/** The initializer of a single, never reassigned const binding. */
+const constInitializer = (ctx, node) => Option.flatMap(findVariableUp(ctx.sourceCode.getScope(node), node.name), (variable) => {
+	const definition = variable.defs[0];
+	if (variable.defs.length !== 1 || definition?.node.type !== "VariableDeclarator") return Option.none();
+	const declarator = definition.node;
+	if (declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const") return Option.none();
+	return Option.fromNullishOr(declarator.init);
+});
+/**
+* A value held in a const is checked like the inline value, through type-only wrappers.
+* Unresolved identifiers, such as parameters, stay as they are. `seen` stops a self-referential chain.
+*/
+const constResolver = (ctx) => {
+	const resolveWith = (seen) => (expression) => {
+		const node = unwrapTypeSyntax(expression);
+		if (node.type !== "Identifier" || seen.has(node)) return node;
+		return Option.match(constInitializer(ctx, node), {
+			onNone: () => node,
+			onSome: (init) => resolveWith(new Set([...seen, node]))(init)
+		});
+	};
+	return resolveWith(/* @__PURE__ */ new Set());
+};
+//#endregion
+export { constResolver };

package/dist/rules/_effect-namespaces.js

@@ -21,5 +21,10 @@ const visibleNamespaces = (ctx, node, namespaces) => new Set([...namespaces].fil
 })));
 const isStaticMember = (node, namespaces, property) => node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && namespaces.has(node.object.name) && node.property.type === "Identifier" && node.property.name === property;
 const isStaticCall = (node, namespaces, property) => node.type === "CallExpression" && node.callee.type !== "Super" && isStaticMember(node.callee, namespaces, property);
+/** Whether an import loads the effect package, one of its subpaths, or an @effect package. */
+const isEffectPackageImport = (node) => {
+	const source = node.source.value;
+	return source === "effect" || source.startsWith("effect/") || source.startsWith("@effect/");
+};
 //#endregion
-export { importedNamespaces, isStaticCall, isStaticMember, visibleNamespaces };
+export { importedNamespaces, isEffectPackageImport, isStaticCall, isStaticMember, visibleNamespaces };

package/dist/rules/no-unbounded-concurrency.js

@@ -4,14 +4,19 @@ import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { expressionArgument, staticProperties } from "./_call-arguments.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { constResolver } from "./_const-bindings.js";
 import * as Arr from "effect/Array";
 import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unbounded-concurrency.ts
-/** The first `concurrency: "unbounded"` value in an options object literal. */
-const unboundedConcurrency = (node) => {
-	if (node.type !== "ObjectExpression") return Option.none();
-	return Option.map(Arr.findFirst(staticProperties(node, "concurrency"), (property) => property.value.type === "Literal" && property.value.value === "unbounded"), (property) => property.value);
+/** Whether an options object, inline or held in a const, sets `concurrency: "unbounded"`. */
+const isUnboundedConcurrency = (argument, resolve) => {
+	const options = resolve(argument);
+	if (options.type !== "ObjectExpression") return false;
+	return staticProperties(options, "concurrency").some((property) => {
+		const value = resolve(property.value);
+		return value.type === "Literal" && value.value === "unbounded";
+	});
 };
 const fixedCollection = (node) => node.type === "ArrayExpression" || node.type === "ObjectExpression";
 /** Where `Effect.all` and `Effect.forEach` take their options. */
@@ -29,6 +34,7 @@ const noUnboundedConcurrency = define({
 	create: function* () {
 		const ctx = yield* RuleContext;
 		const effectNamespaces = new Set(["Effect"]);
+		const resolve = constResolver(ctx);
 		return {
 			ImportDeclaration: (node) => {
 				if (node.type !== "ImportDeclaration") return Effect.void;
@@ -39,14 +45,11 @@ const noUnboundedConcurrency = define({
 				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
 				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
 				if (Option.exists(Arr.head(node.arguments), fixedCollection)) return Effect.void;
-				const unbounded = Option.flatMap(optionsIndex(node.callee, namespaces), (index) => Option.flatMap(expressionArgument(node, index), unboundedConcurrency));
-				return Option.match(unbounded, {
-					onNone: () => Effect.void,
-					onSome: (value) => ctx.report(make({
-						node: value,
-						message: "Bound concurrency for a collection that can grow. Use a finite concurrency value."
-					}))
-				});
+				if (!Option.exists(optionsIndex(node.callee, namespaces), (index) => Option.exists(expressionArgument(node, index), (options) => isUnboundedConcurrency(options, resolve)))) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Bound concurrency for a collection that can grow. Use a finite concurrency value."
+				}));
 			}
 		};
 	}

package/dist/rules/no-unbounded-retry.js

@@ -4,6 +4,7 @@ import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { expressionArgument, staticProperties } from "./_call-arguments.js";
 import { importedNamespaces, isStaticCall, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { constResolver } from "./_const-bindings.js";
 import * as Arr from "effect/Array";
 import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
@@ -18,21 +19,25 @@ const staticPropertyName = (node) => {
 	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return Option.none();
 	return Option.some(node.property.name);
 };
-const isBoundedOperation = (node, scheduleNamespaces) => {
+const isBoundedOperation = (argument, scheduleNamespaces, resolve) => {
+	if (argument.type === "SpreadElement") return false;
+	const node = resolve(argument);
 	if (node.type !== "CallExpression" || node.callee.type === "Super") return false;
 	const callee = node.callee;
 	if (Option.exists(staticPropertyName(callee), (property) => boundedCombinators.has(property) && isStaticMember(callee, scheduleNamespaces, property))) return true;
 	if (!isStaticMember(callee, scheduleNamespaces, "both")) return false;
-	return Option.exists(expressionArgument(node, 0), (bound) => isStaticCall(bound, scheduleNamespaces, "recurs"));
+	return Option.exists(expressionArgument(node, 0), (bound) => isStaticCall(resolve(bound), scheduleNamespaces, "recurs"));
 };
-const unboundedSchedule = (node, scheduleNamespaces) => {
-	if (node.type === "MemberExpression" && isStaticMember(node, scheduleNamespaces, "forever")) return Option.some(node);
-	if (node.type !== "CallExpression" || node.callee.type === "Super") return Option.none();
+const isUnboundedSchedule = (expression, scheduleNamespaces, resolve) => {
+	const node = resolve(expression);
+	if (node.type === "MemberExpression" && isStaticMember(node, scheduleNamespaces, "forever")) return true;
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return false;
 	const callee = node.callee;
 	const property = staticPropertyName(callee);
-	if (Option.exists(property, (name) => unboundedConstructors.has(name) && isStaticMember(callee, scheduleNamespaces, name))) return Option.some(node);
-	if (!Option.contains(property, "pipe") || callee.type !== "MemberExpression") return Option.none();
-	return Option.filter(unboundedSchedule(callee.object, scheduleNamespaces), () => !node.arguments.some((operation) => isBoundedOperation(operation, scheduleNamespaces)));
+	if (Option.exists(property, (name) => unboundedConstructors.has(name) && isStaticMember(callee, scheduleNamespaces, name))) return true;
+	if (!Option.contains(property, "pipe") || callee.type !== "MemberExpression") return false;
+	if (callee.object.type === "Super") return false;
+	return isUnboundedSchedule(callee.object, scheduleNamespaces, resolve) && !node.arguments.some((operation) => isBoundedOperation(operation, scheduleNamespaces, resolve));
 };
 /** Arguments a data-last retry call takes; one more means the data-first form. */
 const retryArity = (callee, effectNamespaces, streamNamespaces, httpClientNamespaces) => {
@@ -48,16 +53,17 @@ const policyArgument = (node, arity) => {
 	return Arr.get(node.arguments, policyIndex);
 };
 /** The schedule a policy argument retries on, unless it sets `times`. */
-const policySchedule = (policy) => {
-	if (policy.type === "SpreadElement") return Option.none();
+const policySchedule = (argument, resolve) => {
+	if (argument.type === "SpreadElement") return Option.none();
+	const policy = resolve(argument);
 	if (policy.type !== "ObjectExpression") return Option.some(policy);
 	if (Arr.isReadonlyArrayNonEmpty(staticProperties(policy, "times"))) return Option.none();
 	return Option.map(Arr.head(staticProperties(policy, "schedule")), (property) => property.value);
 };
-const retryPolicy = (node, effectNamespaces, streamNamespaces, httpClientNamespaces) => {
+const retryPolicy = (node, effectNamespaces, streamNamespaces, httpClientNamespaces, resolve) => {
 	if (node.callee.type === "Super") return Option.none();
 	const arity = retryArity(node.callee, effectNamespaces, streamNamespaces, httpClientNamespaces);
-	return Option.flatMap(Option.flatMap(arity, (count) => policyArgument(node, count)), policySchedule);
+	return Option.flatMap(Option.flatMap(arity, (count) => policyArgument(node, count)), (policy) => policySchedule(policy, resolve));
 };
 const noUnboundedRetry = define({
 	name: "no-unbounded-retry",
@@ -71,6 +77,7 @@ const noUnboundedRetry = define({
 		const httpClientNamespaces = new Set(["HttpClient"]);
 		const scheduleNamespaces = new Set(["Schedule"]);
 		const streamNamespaces = new Set(["Stream"]);
+		const resolve = constResolver(ctx);
 		return {
 			ImportDeclaration: (node) => {
 				if (node.type !== "ImportDeclaration") return Effect.void;
@@ -82,15 +89,13 @@ const noUnboundedRetry = define({
 			},
 			CallExpression: (node) => {
 				if (node.type !== "CallExpression") return Effect.void;
-				const policy = retryPolicy(node, visibleNamespaces(ctx, node, effectNamespaces), visibleNamespaces(ctx, node, streamNamespaces), visibleNamespaces(ctx, node, httpClientNamespaces));
-				const unbounded = Option.flatMap(policy, (schedule) => unboundedSchedule(schedule, visibleNamespaces(ctx, node, scheduleNamespaces)));
-				return Option.match(unbounded, {
-					onNone: () => Effect.void,
-					onSome: (schedule) => ctx.report(make({
-						node: schedule,
-						message: "Bound retry attempts or elapsed time. Add times or compose the schedule with Schedule.recurs or Schedule.take."
-					}))
-				});
+				const policy = retryPolicy(node, visibleNamespaces(ctx, node, effectNamespaces), visibleNamespaces(ctx, node, streamNamespaces), visibleNamespaces(ctx, node, httpClientNamespaces), resolve);
+				const scheduleNamespacesInScope = visibleNamespaces(ctx, node, scheduleNamespaces);
+				if (!Option.exists(policy, (schedule) => isUnboundedSchedule(schedule, scheduleNamespacesInScope, resolve))) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Bound retry attempts or elapsed time. Add times or compose the schedule with Schedule.recurs or Schedule.take."
+				}));
 			}
 		};
 	}

package/dist/rules/prefer-match-tags-exhaustive.js

@@ -2,6 +2,7 @@ import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import { isEffectPackageImport } from "./_effect-namespaces.js";
 import { hasOneTaggedSubject, isInsideCatchAllHandler, tagComparison, taggedSwitchSubject } from "./_tagged-control-flow.js";
 import * as Arr from "effect/Array";
 import * as Option from "effect/Option";
@@ -66,16 +67,21 @@ const preferMatchTagsExhaustive = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
+		const effectImports = /* @__PURE__ */ new Set();
 		return {
+			ImportDeclaration: (node) => {
+				if (isEffectPackageImport(node)) effectImports.add(node.source.value);
+				return Effect.void;
+			},
 			SwitchStatement: (node) => {
-				if (!isCompleteSwitchTransformation(node) || isInsideCatchAllHandler(node)) return Effect.void;
+				if (effectImports.size === 0 || !isCompleteSwitchTransformation(node) || isInsideCatchAllHandler(node)) return Effect.void;
 				return context.report(make({
 					node,
 					message: "Use Match.type with Match.tagsExhaustive so a new tagged variant requires a new case."
 				}));
 			},
 			IfStatement: (node) => {
-				if (!isCompleteIfTransformation(node) && !isCompleteSequentialIfTransformation(node) || isInsideCatchAllHandler(node)) return Effect.void;
+				if (effectImports.size === 0 || !isCompleteIfTransformation(node) && !isCompleteSequentialIfTransformation(node) || isInsideCatchAllHandler(node)) return Effect.void;
 				return context.report(make({
 					node,
 					message: "Use Match.type with Match.tagsExhaustive so a new tagged variant requires a new branch."

package/dist/rules/prefer-predicate-is-tagged.js

@@ -2,6 +2,7 @@ import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import { isEffectPackageImport } from "./_effect-namespaces.js";
 import { effectCallbackLocation, hasOneTaggedSubject, tagComparisonsInOr } from "./_tagged-control-flow.js";
 import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
@@ -19,16 +20,23 @@ const preferPredicateIsTagged = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		return { LogicalExpression: (node) => {
-			if (node.operator !== "||") return Effect.void;
-			if (node.parent?.type === "LogicalExpression" && node.parent.operator === "||") return Effect.void;
-			if (isCatchIfPredicate(node)) return Effect.void;
-			if (!Option.exists(tagComparisonsInOr(node), hasOneTaggedSubject)) return Effect.void;
-			return context.report(make({
-				node,
-				message: "Use a named Predicate refinement composed from Predicate.isTagged for multiple tags."
-			}));
-		} };
+		const effectImports = /* @__PURE__ */ new Set();
+		return {
+			ImportDeclaration: (node) => {
+				if (isEffectPackageImport(node)) effectImports.add(node.source.value);
+				return Effect.void;
+			},
+			LogicalExpression: (node) => {
+				if (effectImports.size === 0 || node.operator !== "||") return Effect.void;
+				if (node.parent?.type === "LogicalExpression" && node.parent.operator === "||") return Effect.void;
+				if (isCatchIfPredicate(node)) return Effect.void;
+				if (!Option.exists(tagComparisonsInOr(node), hasOneTaggedSubject)) return Effect.void;
+				return context.report(make({
+					node,
+					message: "Use a named Predicate refinement composed from Predicate.isTagged for multiple tags."
+				}));
+			}
+		};
 	}
 });
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effect",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "oxlint plugin with Effect-specific lint rules",
   "license": "MIT",
   "repository": {
@@ -51,8 +51,8 @@
     "lint:fix": "oxlint --fix",
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
-    "test": "bun run build && bun test",
-    "gate": "bun run build && concurrently -n type,style,self,generated,test -c blue,yellow,cyan,magenta,green \"bun run typecheck\" \"bun run lint\" \"bun run lint:self\" \"bun run codegen:check\" \"bun test\"",
+    "test": "bun run build && bun test --timeout=30000",
+    "gate": "bun run build && concurrently -n type,style,self,generated,test -c blue,yellow,cyan,magenta,green \"bun run typecheck\" \"bun run lint\" \"bun run lint:self\" \"bun run codegen:check\" \"bun test --timeout=30000\"",
     "codegen": "bun run scripts/codegen.ts",
     "codegen:check": "bun run scripts/codegen.ts --check",
     "add-rule": "bun run scripts/add-rule.ts",