oxlint-plugin-effect 0.14.0 → 0.15.0

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

@@ -2,18 +2,24 @@ 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 { expressionArgument, staticProperties } from "./_call-arguments.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.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 void 0;
-	for (const property of node.properties) {
-		if (property.type !== "Property" || property.computed) continue;
-		if (!(property.key.type === "Identifier" && property.key.name === "concurrency" || property.key.type === "Literal" && property.key.value === "concurrency")) continue;
-		if (property.value.type === "Literal" && property.value.value === "unbounded") return property.value;
-	}
+	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);
+};
+const fixedCollection = (node) => node.type === "ArrayExpression" || node.type === "ObjectExpression";
+/** Where `Effect.all` and `Effect.forEach` take their options. */
+const optionsIndex = (callee, effectNamespaces) => {
+	if (isStaticMember(callee, effectNamespaces, "forEach")) return Option.some(2);
+	if (isStaticMember(callee, effectNamespaces, "all")) return Option.some(1);
+	return Option.none();
 };
-const fixedCollection = (node) => node?.type === "ArrayExpression" || node?.type === "ObjectExpression";
 const noUnboundedConcurrency = define({
 	name: "no-unbounded-concurrency",
 	meta: meta({
@@ -32,16 +38,15 @@ const noUnboundedConcurrency = define({
 			CallExpression: (node) => {
 				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
 				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
-				let optionsIndex;
-				if (isStaticMember(node.callee, namespaces, "all")) optionsIndex = 1;
-				if (isStaticMember(node.callee, namespaces, "forEach")) optionsIndex = 2;
-				if (optionsIndex === void 0 || fixedCollection(node.arguments[0])) return Effect.void;
-				const unbounded = unboundedConcurrency(node.arguments[optionsIndex]);
-				if (unbounded === void 0) return Effect.void;
-				return ctx.report(make({
-					node: unbounded,
-					message: "Bound concurrency for a collection that can grow. Use a finite concurrency value."
-				}));
+				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."
+					}))
+				});
 			}
 		};
 	}

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

@@ -2,7 +2,10 @@ 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 { expressionArgument, staticProperties } from "./_call-arguments.js";
 import { importedNamespaces, isStaticCall, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unbounded-retry.ts
 const unboundedConstructors = new Set([
@@ -12,68 +15,49 @@ const unboundedConstructors = new Set([
 ]);
 const boundedCombinators = new Set(["take"]);
 const staticPropertyName = (node) => {
-	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return;
-	return node.property.name;
-};
-const hasOwnProperty = (node, name) => {
-	for (const property of node.properties) {
-		if (property.type !== "Property" || property.computed) continue;
-		if (property.key.type === "Identifier" && property.key.name === name) return true;
-		if (property.key.type === "Literal" && property.key.value === name) return true;
-	}
-	return false;
-};
-const propertyValue = (node, name) => {
-	for (const property of node.properties) {
-		if (property.type !== "Property" || property.computed) continue;
-		if (property.key.type === "Identifier" && property.key.name === name || property.key.type === "Literal" && property.key.value === name) return property.value;
-	}
+	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return Option.none();
+	return Option.some(node.property.name);
 };
 const isBoundedOperation = (node, scheduleNamespaces) => {
 	if (node.type !== "CallExpression" || node.callee.type === "Super") return false;
-	const property = staticPropertyName(node.callee);
-	if (property === void 0) return false;
-	if (boundedCombinators.has(property) && isStaticMember(node.callee, scheduleNamespaces, property)) return true;
-	if (!isStaticMember(node.callee, scheduleNamespaces, "both")) return false;
-	const bound = node.arguments[0];
-	return bound !== void 0 && bound.type !== "SpreadElement" && isStaticCall(bound, scheduleNamespaces, "recurs");
+	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"));
 };
 const unboundedSchedule = (node, scheduleNamespaces) => {
-	if (node.type === "MemberExpression" && isStaticMember(node, scheduleNamespaces, "forever")) return node;
-	if (node.type !== "CallExpression" || node.callee.type === "Super") return void 0;
-	const property = staticPropertyName(node.callee);
-	if (property !== void 0 && unboundedConstructors.has(property) && isStaticMember(node.callee, scheduleNamespaces, property)) return node;
-	if (property !== "pipe" || node.callee.type !== "MemberExpression") return void 0;
-	const root = unboundedSchedule(node.callee.object, scheduleNamespaces);
-	if (root === void 0) return void 0;
-	for (const operation of node.arguments) if (isBoundedOperation(operation, scheduleNamespaces)) return void 0;
-	return root;
+	if (node.type === "MemberExpression" && isStaticMember(node, scheduleNamespaces, "forever")) return Option.some(node);
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return Option.none();
+	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)));
+};
+/** Arguments a data-last retry call takes; one more means the data-first form. */
+const retryArity = (callee, effectNamespaces, streamNamespaces, httpClientNamespaces) => {
+	if (isStaticMember(callee, effectNamespaces, "retryOrElse")) return Option.some(2);
+	if (isStaticMember(callee, effectNamespaces, "retry") || isStaticMember(callee, streamNamespaces, "retry") || isStaticMember(callee, httpClientNamespaces, "retryTransient")) return Option.some(1);
+	return Option.none();
+};
+/** The policy argument: first in the data-last form, second in the data-first form. */
+const policyArgument = (node, arity) => {
+	if (node.arguments.length < arity) return Option.none();
+	let policyIndex = 1;
+	if (node.arguments.length === arity) policyIndex = 0;
+	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();
+	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) => {
-	if (node.callee.type === "Super") return void 0;
-	let policyIndex;
-	if (isStaticMember(node.callee, effectNamespaces, "retry")) {
-		if (node.arguments.length === 1) policyIndex = 0;
-		if (node.arguments.length >= 2) policyIndex = 1;
-	}
-	if (isStaticMember(node.callee, effectNamespaces, "retryOrElse")) {
-		if (node.arguments.length === 2) policyIndex = 0;
-		if (node.arguments.length >= 3) policyIndex = 1;
-	}
-	if (isStaticMember(node.callee, streamNamespaces, "retry")) {
-		if (node.arguments.length === 1) policyIndex = 0;
-		if (node.arguments.length >= 2) policyIndex = 1;
-	}
-	if (isStaticMember(node.callee, httpClientNamespaces, "retryTransient")) {
-		if (node.arguments.length === 1) policyIndex = 0;
-		if (node.arguments.length >= 2) policyIndex = 1;
-	}
-	if (policyIndex === void 0) return void 0;
-	const policy = node.arguments[policyIndex];
-	if (policy?.type === "SpreadElement") return void 0;
-	if (policy?.type !== "ObjectExpression") return policy;
-	if (hasOwnProperty(policy, "times")) return void 0;
-	return propertyValue(policy, "schedule");
+	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);
 };
 const noUnboundedRetry = define({
 	name: "no-unbounded-retry",
@@ -99,13 +83,14 @@ 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));
-				if (policy === void 0) return Effect.void;
-				const unbounded = unboundedSchedule(policy, visibleNamespaces(ctx, node, scheduleNamespaces));
-				if (unbounded === void 0) return Effect.void;
-				return ctx.report(make({
-					node: unbounded,
-					message: "Bound retry attempts or elapsed time. Add times or compose the schedule with Schedule.recurs or Schedule.take."
-				}));
+				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."
+					}))
+				});
 			}
 		};
 	}

package/dist/rules/no-unknown-parameters.js

@@ -3,6 +3,7 @@ import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation } from "./_anti-slop-function-parameters.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unknown-parameters.ts
 function isTypePredicateSubject(owner, parameterName) {
@@ -34,12 +35,13 @@ const noUnknownParameters = define({
 		const context = yield* RuleContext;
 		const checkParameters = (node) => Effect.forEach(node.params, (parameter) => {
 			const annotation = functionParameterTypeAnnotation(parameter);
-			if (annotation === null || annotation === void 0) return Effect.void;
-			if (!containsUnknownType(annotation.typeAnnotation)) return Effect.void;
+			if (Option.isNone(annotation)) return Effect.void;
+			const type = annotation.value.typeAnnotation;
+			if (!containsUnknownType(type)) return Effect.void;
 			const name = functionParameterBindingName(parameter, context.sourceCode);
 			if (name === "cause" || isTypePredicateSubject(node, name) || parameter === node.params[0] && isRejectionHandler(node)) return Effect.void;
 			return context.report(fromId({
-				node: annotation.typeAnnotation,
+				node: type,
 				messageId: "unknownParameter",
 				data: { parameter: name }
 			}));

package/dist/rules/no-unknown-returns.js

@@ -2,7 +2,11 @@ import { fromId } 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 { ancestors } from "./_ast-ancestors.js";
 import { createTypeAliasEnvironment, resolvedTypeMatches } from "./_anti-slop-type-alias-resolution.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unknown-returns.ts
 /**
@@ -13,12 +17,10 @@ import * as Effect from "effect/Effect";
 */
 function isInsideTypePattern(node) {
 	let child = node;
-	let parent = node.parent;
-	while (parent !== null && parent.type !== "Program") {
+	for (const parent of ancestors(node)) {
 		if (parent.type === "TSConditionalType" && parent.extendsType === child) return true;
 		if (parent.type === "TSTypeParameter" && parent.constraint === child) return true;
 		child = parent;
-		parent = parent.parent;
 	}
 	return false;
 }
@@ -32,18 +34,17 @@ const noUnknownReturns = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		let environment = null;
-		const resolvesToUnknown = (type) => environment !== null && resolvedTypeMatches(type, environment, (resolved, matches) => {
+		let environment = Option.none();
+		const resolvesToUnknown = (type) => Option.exists(environment, (present) => resolvedTypeMatches(type, present, (resolved, matches) => {
 			if (resolved.type === "TSUnknownKeyword") return true;
 			if (resolved.type === "TSParenthesizedType") return matches(resolved.typeAnnotation);
 			if (resolved.type === "TSUnionType") return resolved.types.some(matches);
 			if (resolved.type !== "TSTypeReference" || resolved.typeName.type !== "Identifier" || resolved.typeName.name !== "Promise" && resolved.typeName.name !== "PromiseLike") return false;
-			const value = resolved.typeArguments?.params[0];
-			return value !== void 0 && matches(value);
-		});
+			return Option.exists(Arr.head(resolved.typeArguments?.params ?? []), matches);
+		}));
 		const checkReturnType = (node) => {
 			const annotation = node.returnType;
-			if (annotation === null || annotation === void 0) return Effect.void;
+			if (Predicate.isNullish(annotation)) return Effect.void;
 			if (!resolvesToUnknown(annotation.typeAnnotation)) return Effect.void;
 			if (isInsideTypePattern(node)) return Effect.void;
 			return context.report(fromId({
@@ -53,7 +54,7 @@ const noUnknownReturns = define({
 		};
 		return {
 			Program: (node) => {
-				environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+				environment = Option.some(createTypeAliasEnvironment(node, context.sourceCode.visitorKeys));
 				return Effect.void;
 			},
 			ArrowFunctionExpression: checkReturnType,

package/dist/rules/no-unknown-type-aliases.js

@@ -3,6 +3,7 @@ import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { createTypeAliasEnvironment, resolvedTypeMatches } from "./_anti-slop-type-alias-resolution.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unknown-type-aliases.ts
 /** Ban named aliases that merely conceal TypeScript's unknown top type. */
@@ -15,22 +16,25 @@ const noUnknownTypeAliases = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		let environment = null;
-		const resolvesToUnknown = (type) => environment !== null && resolvedTypeMatches(type, environment, (resolved, matches) => {
+		let environment = Option.none();
+		const resolvesToUnknown = (type) => Option.exists(environment, (present) => resolvedTypeMatches(type, present, (resolved, matches) => {
 			if (resolved.type === "TSUnknownKeyword") return true;
 			if (resolved.type === "TSParenthesizedType") return matches(resolved.typeAnnotation);
 			return resolved.type === "TSUnionType" && resolved.types.some(matches);
-		});
+		}));
 		return {
 			Program: (node) => {
-				environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+				environment = Option.some(createTypeAliasEnvironment(node, context.sourceCode.visitorKeys));
 				return Effect.void;
 			},
-			TSTypeAliasDeclaration: (node) => resolvesToUnknown(node.typeAnnotation) ? context.report(fromId({
-				node: node.id,
-				messageId: "unknownAlias",
-				data: { alias: node.id.name }
-			})) : Effect.void
+			TSTypeAliasDeclaration: (node) => {
+				if (!resolvesToUnknown(node.typeAnnotation)) return Effect.void;
+				return context.report(fromId({
+					node: node.id,
+					messageId: "unknownAlias",
+					data: { alias: node.id.name }
+				}));
+			}
 		};
 	}
 });

package/dist/rules/no-unsafe-dictionary-type.js

@@ -2,8 +2,12 @@ import { fromId } 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 { ancestors } from "./_ast-ancestors.js";
 import { visibleTypeAlias } from "./_anti-slop-type-alias-resolution.js";
 import { classifyUnsafeDictionary, classifyUnsafeDictionaryValue, createTypeEnvironment } from "./_anti-slop-dictionary-types.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unsafe-dictionary-type.ts
 const typeNodeKinds = new Set([
@@ -49,41 +53,30 @@ function isTypeNode(node) {
 	return typeNodeKinds.has(node.type);
 }
 function typeReferenceName(type) {
-	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+	if (type.typeName.type !== "Identifier") return Option.none();
+	return Option.some(type.typeName.name);
 }
 function isInsideTypeAliasDeclaration(node) {
-	let current = node.parent;
-	while (current !== null && current.type !== "Program") {
-		if (current.type === "TSTypeAliasDeclaration") return true;
-		current = current.parent;
-	}
-	return false;
+	return Option.isSome(Arr.findFirst(ancestors(node), (ancestor) => ancestor.type === "TSTypeAliasDeclaration"));
 }
 function isPlainAliasConsumerUse(node, environment) {
 	if (node.type !== "TSTypeReference" || node.typeArguments?.params.length) return false;
-	const name = typeReferenceName(node);
-	return name !== null && visibleTypeAlias(name, node, environment.typeAliases) !== null && !isInsideTypeAliasDeclaration(node);
+	return Option.exists(typeReferenceName(node), (name) => Option.isSome(visibleTypeAlias(name, node, environment.typeAliases))) && !isInsideTypeAliasDeclaration(node);
 }
 function isInsideTypeParameterConstraint(node) {
 	let child = node;
-	let parent = child.parent;
-	while (parent !== null && parent.type !== "Program") {
+	for (const parent of ancestors(node)) {
 		if (parent.type === "TSTypeParameter" && parent.constraint === child) return true;
 		child = parent;
-		parent = child.parent;
 	}
 	return false;
 }
 function shouldReportType(node, environment) {
 	if (isInsideTypeParameterConstraint(node)) return false;
 	if (isPlainAliasConsumerUse(node, environment)) return false;
-	if (classifyUnsafeDictionary(node, environment) === null) return false;
-	let current = node.parent;
-	while (current !== null && current.type !== "Program") {
-		if (isTypeNode(current) && classifyUnsafeDictionary(current, environment) !== null) return false;
-		current = current.parent;
-	}
-	return true;
+	if (Option.isNone(classifyUnsafeDictionary(node, environment))) return false;
+	const unsafeAncestor = Arr.findFirst(ancestors(node), (ancestor) => isTypeNode(ancestor) && Option.isSome(classifyUnsafeDictionary(ancestor, environment)));
+	return Option.isNone(unsafeAncestor);
 }
 /** Disallow object-dictionary contracts whose direct value type is an unsafe escape hatch. */
 const noUnsafeDictionaryType = define({
@@ -95,29 +88,31 @@ const noUnsafeDictionaryType = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		let environment = null;
+		let environment = Option.none();
 		const report = (node, value) => context.report(fromId({
 			node,
 			messageId: "unsafeDictionary",
 			data: { value }
 		}));
+		const reportUnsafe = (node, unsafe) => Option.match(unsafe, {
+			onNone: () => Effect.void,
+			onSome: (found) => report(node, found.unsafeValue)
+		});
 		const reportIfUnsafe = (node) => {
-			if (environment === null || !shouldReportType(node, environment)) return Effect.void;
-			const unsafe = classifyUnsafeDictionary(node, environment);
-			return unsafe === null ? Effect.void : report(node, unsafe.unsafeValue);
+			if (Option.isNone(environment) || !shouldReportType(node, environment.value)) return Effect.void;
+			return reportUnsafe(node, classifyUnsafeDictionary(node, environment.value));
 		};
 		return {
 			Program: (node) => {
-				environment = createTypeEnvironment(node, context.sourceCode.visitorKeys);
+				environment = Option.some(createTypeEnvironment(node, context.sourceCode.visitorKeys));
 				return Effect.void;
 			},
 			TSTypeReference: reportIfUnsafe,
 			TSTypeLiteral: reportIfUnsafe,
 			TSMappedType: reportIfUnsafe,
 			TSIndexSignature: (node) => {
-				if (environment === null || node.typeAnnotation === null || node.parent?.type === "TSTypeLiteral") return Effect.void;
-				const unsafe = classifyUnsafeDictionaryValue(node.typeAnnotation.typeAnnotation, environment);
-				return unsafe === null ? Effect.void : report(node, unsafe.unsafeValue);
+				if (Option.isNone(environment) || Predicate.isNull(node.typeAnnotation) || node.parent?.type === "TSTypeLiteral") return Effect.void;
+				return reportUnsafe(node, classifyUnsafeDictionaryValue(node.typeAnnotation.typeAnnotation, environment.value));
 			}
 		};
 	}