oxlint-plugin-effect 0.14.0 → 0.15.0

package/dist/rules/no-widen-then-assert.js

@@ -2,6 +2,9 @@ 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 * as Arr from "effect/Array";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-widen-then-assert.ts
 /**
@@ -15,6 +18,7 @@ const functionBoundaryTypes = new Set([
 	"TSDeclareFunction",
 	"TSEmptyBodyFunctionExpression"
 ]);
+const sameBoundary = Option.makeEquivalence((left, right) => left === right);
 function unwrapExpressionParentheses(expression) {
 	let current = expression;
 	while (current.type === "ParenthesizedExpression") current = current.expression;
@@ -26,7 +30,20 @@ function unwrapTypeParentheses(type) {
 	return current;
 }
 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 isReferenceNamed(type, name) {
+	return Option.contains(typeReferenceName(type), name);
+}
+/** The two type arguments of a reference such as `Record<K, V>`, when it has exactly two. */
+function typeArgumentPair(reference) {
+	const parameters = reference.typeArguments?.params ?? [];
+	if (parameters.length !== 2) return Option.none();
+	return Option.all([Arr.get(parameters, 0), Arr.get(parameters, 1)]);
+}
+function firstTypeArgument(reference) {
+	return Arr.head(reference.typeArguments?.params ?? []);
 }
 function isUnknownOrAnyType(type) {
 	const unwrapped = unwrapTypeParentheses(type);
@@ -36,42 +53,45 @@ function isBroadRecordKeyType(type) {
 	const unwrapped = unwrapTypeParentheses(type);
 	if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") return true;
 	if (unwrapped.type === "TSUnionType") return unwrapped.types.every(isBroadRecordKeyType);
-	return unwrapped.type === "TSTypeReference" && typeReferenceName(unwrapped) === "PropertyKey";
+	return unwrapped.type === "TSTypeReference" && isReferenceNamed(unwrapped, "PropertyKey");
+}
+function isBroadRecordReference(reference) {
+	if (isReferenceNamed(reference, "Readonly")) return Option.exists(firstTypeArgument(reference), isBroadRecordType);
+	if (!isReferenceNamed(reference, "Record")) return false;
+	return Option.exists(typeArgumentPair(reference), ([key, value]) => isBroadRecordKeyType(key) && isUnknownOrAnyType(value));
+}
+function isBroadIndexSignature(member) {
+	return member.parameters.length === 1 && Option.exists(Arr.head(member.parameters), (parameter) => isBroadRecordKeyType(parameter.typeAnnotation.typeAnnotation)) && isUnknownOrAnyType(member.typeAnnotation.typeAnnotation);
 }
 function isBroadRecordType(type) {
 	const unwrapped = unwrapTypeParentheses(type);
-	if (unwrapped.type === "TSTypeReference") {
-		if (typeReferenceName(unwrapped) === "Readonly") {
-			const [inner] = unwrapped.typeArguments?.params ?? [];
-			return inner !== void 0 && isBroadRecordType(inner);
-		}
-		if (typeReferenceName(unwrapped) !== "Record") return false;
-		const parameters = unwrapped.typeArguments?.params ?? [];
-		return parameters.length === 2 && parameters[0] !== void 0 && parameters[1] !== void 0 && isBroadRecordKeyType(parameters[0]) && isUnknownOrAnyType(parameters[1]);
-	}
+	if (unwrapped.type === "TSTypeReference") return isBroadRecordReference(unwrapped);
 	if (unwrapped.type !== "TSTypeLiteral" || unwrapped.members.length !== 1) return false;
-	const [member] = unwrapped.members;
-	const [parameter] = member?.type === "TSIndexSignature" ? member.parameters : [];
-	return member?.type === "TSIndexSignature" && member.parameters.length === 1 && parameter !== void 0 && isBroadRecordKeyType(parameter.typeAnnotation.typeAnnotation) && isUnknownOrAnyType(member.typeAnnotation.typeAnnotation);
+	return Option.exists(Arr.head(unwrapped.members), (member) => member.type === "TSIndexSignature" && isBroadIndexSignature(member));
 }
 function broadTypeKind(type) {
 	const unwrapped = unwrapTypeParentheses(type);
-	if (unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword") return "top";
-	if (unwrapped.type === "TSObjectKeyword") return "object";
-	return isBroadRecordType(unwrapped) ? "record" : null;
+	if (unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword") return Option.some("top");
+	if (unwrapped.type === "TSObjectKeyword") return Option.some("object");
+	if (isBroadRecordType(unwrapped)) return Option.some("record");
+	return Option.none();
+}
+function isBroadType(type) {
+	return Option.isSome(broadTypeKind(type));
 }
 function assertedExpression(node) {
 	return unwrapExpressionParentheses(node.expression);
 }
 function assertionFromExpression(expression) {
 	const unwrapped = unwrapExpressionParentheses(expression);
-	return unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion" ? unwrapped : null;
+	if (unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion") return Option.some(unwrapped);
+	return Option.none();
 }
 function normalizedTypeText(sourceText, type) {
 	return sourceText.slice(type.start, type.end).replaceAll(/\s+/gu, "");
 }
 function typesHaveSameSyntax(sourceText, left, right) {
-	return left !== null && normalizedTypeText(sourceText, unwrapTypeParentheses(left)) === normalizedTypeText(sourceText, unwrapTypeParentheses(right));
+	return Option.exists(left, (type) => normalizedTypeText(sourceText, unwrapTypeParentheses(type)) === normalizedTypeText(sourceText, unwrapTypeParentheses(right)));
 }
 function isDefinitelyObjectType(type) {
 	const unwrapped = unwrapTypeParentheses(type);
@@ -92,74 +112,79 @@ function isDefinitelyNarrowerRecordType(type) {
 	const unwrapped = unwrapTypeParentheses(type);
 	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.some((member) => member.type !== "TSIndexSignature");
 	if (unwrapped.type !== "TSTypeReference") return false;
-	if (typeReferenceName(unwrapped) === "Readonly") {
-		const [inner] = unwrapped.typeArguments?.params ?? [];
-		return inner !== void 0 && isDefinitelyNarrowerRecordType(inner);
-	}
-	if (typeReferenceName(unwrapped) !== "Record") return false;
-	const parameters = unwrapped.typeArguments?.params ?? [];
-	return parameters.length === 2 && parameters[1] !== void 0 && !isUnknownOrAnyType(parameters[1]);
+	if (isReferenceNamed(unwrapped, "Readonly")) return Option.exists(firstTypeArgument(unwrapped), isDefinitelyNarrowerRecordType);
+	if (!isReferenceNamed(unwrapped, "Record")) return false;
+	return Option.exists(typeArgumentPair(unwrapped), ([, value]) => !isUnknownOrAnyType(value));
 }
 function functionBoundary(node) {
-	let current = node.parent;
-	while (current !== null && current.type !== "Program") {
-		if (functionBoundaryTypes.has(current.type)) return current;
-		current = current.parent;
-	}
-	return null;
+	return Arr.findFirst(ancestors(node), (ancestor) => functionBoundaryTypes.has(ancestor.type));
 }
 function resolvedVariableForIdentifier(scopes, identifier) {
-	for (const scope of scopes) {
-		const reference = scope.references.find((candidate) => candidate.identifier.start === identifier.start && candidate.identifier.end === identifier.end);
-		if (reference !== void 0) return reference.resolved;
-	}
-	return null;
+	const reference = Arr.findFirst(scopes, (scope) => Arr.findFirst(scope.references, (candidate) => candidate.identifier.start === identifier.start && candidate.identifier.end === identifier.end));
+	return Option.flatMap(reference, (found) => Option.fromNullishOr(found.resolved));
 }
 function variableDeclarator(variable) {
-	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator") return definition.node;
-	return null;
+	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator") return Option.some(definition.node);
+	return Option.none();
+}
+function isConstDeclarator(declarator) {
+	return declarator.parent.type === "VariableDeclaration" && declarator.parent.kind === "const";
+}
+function isReassigned(variable) {
+	return variable.references.some((reference) => reference.isWrite() && !reference.init);
 }
 function knownValueEvidence(expression, scopes, boundary, visitedVariables) {
 	const unwrapped = unwrapExpressionParentheses(expression);
 	if (unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion") {
-		if (broadTypeKind(unwrapped.typeAnnotation) !== null) return null;
-		return { type: unwrapped.typeAnnotation };
+		if (isBroadType(unwrapped.typeAnnotation)) return Option.none();
+		return Option.some({ type: Option.some(unwrapped.typeAnnotation) });
 	}
-	if (unwrapped.type === "Literal" || unwrapped.type === "TemplateLiteral") return { type: null };
-	if (unwrapped.type === "ArrayExpression" || unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "ClassExpression" || unwrapped.type === "FunctionExpression" || unwrapped.type === "NewExpression" || unwrapped.type === "ObjectExpression") return { type: null };
-	if (unwrapped.type !== "Identifier") return null;
-	const variable = resolvedVariableForIdentifier(scopes, unwrapped);
-	if (variable === null || visitedVariables.has(variable)) return null;
-	const annotatedIdentifier = variable.identifiers.find((identifier) => identifier.typeAnnotation !== null && identifier.typeAnnotation !== void 0);
-	const annotation = annotatedIdentifier?.typeAnnotation?.typeAnnotation;
-	if (annotation !== void 0 && annotatedIdentifier !== void 0) {
-		if (functionBoundary(annotatedIdentifier) !== boundary || broadTypeKind(annotation) !== null) return null;
-		return { type: annotation };
-	}
-	const declarator = variableDeclarator(variable);
-	if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init) || functionBoundary(declarator) !== boundary) return null;
-	return knownValueEvidence(declarator.init, scopes, boundary, new Set([...visitedVariables, variable]));
+	if (unwrapped.type === "Literal" || unwrapped.type === "TemplateLiteral") return Option.some({ type: Option.none() });
+	if (unwrapped.type === "ArrayExpression" || unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "ClassExpression" || unwrapped.type === "FunctionExpression" || unwrapped.type === "NewExpression" || unwrapped.type === "ObjectExpression") return Option.some({ type: Option.none() });
+	if (unwrapped.type === "Identifier") return identifierValueEvidence(unwrapped, scopes, boundary, visitedVariables);
+	return Option.none();
+}
+function identifierValueEvidence(expression, scopes, boundary, visitedVariables) {
+	return resolvedVariableForIdentifier(scopes, expression).pipe(Option.filter((variable) => !visitedVariables.has(variable)), Option.flatMap((variable) => Option.match(annotatedIdentifier(variable), {
+		onSome: ([identifier, annotation]) => annotatedValueEvidence(identifier, annotation, boundary),
+		onNone: () => declaredValueEvidence(variable, scopes, boundary, visitedVariables)
+	})));
+}
+/** The first declaration identifier of a variable that carries a type annotation. */
+function annotatedIdentifier(variable) {
+	return Arr.findFirst(variable.identifiers, (identifier) => Option.map(Option.fromNullishOr(identifier.typeAnnotation), (annotation) => [identifier, annotation.typeAnnotation]));
+}
+function annotatedValueEvidence(identifier, annotation, boundary) {
+	if (!sameBoundary(functionBoundary(identifier), boundary) || isBroadType(annotation)) return Option.none();
+	return Option.some({ type: Option.some(annotation) });
+}
+function declaredValueEvidence(variable, scopes, boundary, visitedVariables) {
+	return variableDeclarator(variable).pipe(Option.filter((declarator) => isConstDeclarator(declarator) && !isReassigned(variable) && sameBoundary(functionBoundary(declarator), boundary)), Option.flatMap((declarator) => Option.fromNullishOr(declarator.init)), Option.flatMap((init) => knownValueEvidence(init, scopes, boundary, new Set([...visitedVariables, variable]))));
 }
 function widenedBinding(variable, scopes) {
-	const declarator = variableDeclarator(variable);
-	if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.id.type !== "Identifier" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
-	const identifier = variable.identifiers.find((candidate) => candidate.start === declarator.id.start && candidate.end === declarator.id.end);
+	return variableDeclarator(variable).pipe(Option.filter((declarator) => isConstDeclarator(declarator) && declarator.id.type === "Identifier" && !isReassigned(variable)), Option.flatMap((declarator) => Option.flatMap(Option.fromNullishOr(declarator.init), (init) => widenedDeclarator(variable, declarator, init, scopes))));
+}
+function widenedDeclarator(variable, declarator, init, scopes) {
+	const identifier = Arr.findFirst(variable.identifiers, (candidate) => candidate.start === declarator.id.start && candidate.end === declarator.id.end);
 	const boundary = functionBoundary(declarator);
-	const declaredType = identifier?.typeAnnotation?.typeAnnotation;
-	const initializerAssertion = assertionFromExpression(declarator.init);
-	const initializerBroadKind = initializerAssertion === null ? null : broadTypeKind(initializerAssertion.typeAnnotation);
-	const broadKind = (declaredType === void 0 ? null : broadTypeKind(declaredType)) ?? initializerBroadKind;
-	if (broadKind === null) return null;
-	const evidence = knownValueEvidence(initializerAssertion !== null && initializerBroadKind !== null ? assertedExpression(initializerAssertion) : declarator.init, scopes, boundary, new Set([variable]));
-	return evidence === null ? null : {
-		broadKind,
+	const declaredType = identifier.pipe(Option.flatMap((found) => Option.fromNullishOr(found.typeAnnotation)), Option.map((annotation) => annotation.typeAnnotation));
+	const initializerAssertion = assertionFromExpression(init);
+	const initializerBroadKind = Option.flatMap(initializerAssertion, (assertion) => broadTypeKind(assertion.typeAnnotation));
+	const declaredBroadKind = Option.flatMap(declaredType, broadTypeKind);
+	const broadKind = Option.orElse(declaredBroadKind, () => initializerBroadKind);
+	const originalExpression = Option.match(Option.zipLeft(initializerAssertion, initializerBroadKind), {
+		onNone: () => init,
+		onSome: assertedExpression
+	});
+	return Option.flatMap(broadKind, (kind) => Option.map(knownValueEvidence(originalExpression, scopes, boundary, new Set([variable])), (evidence) => ({
+		broadKind: kind,
 		evidence,
 		declaredAt: declarator.end,
 		boundary
-	};
+	})));
 }
 function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
-	if (broadTypeKind(assertedType) !== null) return false;
+	if (isBroadType(assertedType)) return false;
 	if (broadKind === "top") return true;
 	if (typesHaveSameSyntax(sourceText, evidence.type, assertedType)) return true;
 	if (broadKind === "object") return isDefinitelyObjectType(assertedType);
@@ -179,10 +204,8 @@ const noWidenThenAssert = define({
 		const checkAssertion = (node) => {
 			const expression = assertedExpression(node);
 			if (expression.type !== "Identifier") return Effect.void;
-			const variable = resolvedVariableForIdentifier(scopes, expression);
-			if (variable === null) return Effect.void;
-			const widened = widenedBinding(variable, scopes);
-			if (widened === null || node.start <= widened.declaredAt || functionBoundary(node) !== widened.boundary || !assertionIsNarrower(context.sourceCode.text, widened.broadKind, widened.evidence, node.typeAnnotation)) return Effect.void;
+			const widened = Option.flatMap(resolvedVariableForIdentifier(scopes, expression), (variable) => widenedBinding(variable, scopes));
+			if (!Option.exists(widened, (binding) => node.start > binding.declaredAt && sameBoundary(functionBoundary(node), binding.boundary) && assertionIsNarrower(context.sourceCode.text, binding.broadKind, binding.evidence, node.typeAnnotation))) return Effect.void;
 			return context.report(fromId({
 				node,
 				messageId: "widenThenAssert",

package/dist/rules/prefer-catch-tag.js

@@ -3,51 +3,43 @@ import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { isEffectCall, tagComparisonsInOr, taggedSwitchSubject } from "./_tagged-control-flow.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/prefer-catch-tag.ts
-const returnedExpression = (fn) => {
-	if (fn.body === null) return null;
-	if (fn.body.type !== "BlockStatement") return fn.body;
-	if (fn.body.body.length !== 1) return null;
-	const statement = fn.body.body[0];
-	if (statement?.type !== "ReturnStatement" || statement.argument === null) return null;
-	return statement.argument;
-};
-const hasManualTagPredicate = (argument) => {
-	if (argument?.type !== "ArrowFunctionExpression" && argument?.type !== "FunctionExpression") return false;
-	const parameter = argument.params[0];
-	if (parameter?.type !== "Identifier") return false;
-	const expression = returnedExpression(argument);
-	if (expression === null) return false;
-	const comparisons = tagComparisonsInOr(expression);
-	if (comparisons === null || comparisons.length === 0) return false;
-	return comparisons.every((comparison) => comparison.subject === parameter.name);
-};
-const isFunction = (argument) => argument?.type === "ArrowFunctionExpression" || argument?.type === "FunctionExpression";
-const hasTagCondition = (node, parameter) => {
-	const comparisons = tagComparisonsInOr(node.test);
-	if (comparisons === null || comparisons.length === 0) return false;
-	return comparisons.every((comparison) => comparison.subject === parameter);
-};
+const isFunction = (argument) => argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression";
+const isIdentifier = (parameter) => parameter.type === "Identifier";
+/** The name of a callback's first parameter when it is a plain identifier. */
+const identifierParameter = (fn) => Arr.head(fn.params).pipe(Option.filter(isIdentifier), Option.map((parameter) => parameter.name));
+/** The expression a callback returns when its body is that expression or a lone `return`. */
+const returnedExpression = (fn) => Option.flatMap(Option.fromNullishOr(fn.body), (body) => {
+	if (body.type !== "BlockStatement") return Option.some(body);
+	const [statement] = body.body;
+	if (body.body.length !== 1 || statement?.type !== "ReturnStatement") return Option.none();
+	return Option.fromNullishOr(statement.argument);
+});
+/** Whether `expression` is one or more `parameter._tag === "Tag"` checks joined by `||`. */
+const isTagCheckOn = (expression, parameter) => Option.exists(tagComparisonsInOr(expression), (comparisons) => comparisons.every((comparison) => comparison.subject === parameter));
+const hasManualTagPredicate = (argument) => isFunction(argument) && Option.exists(Option.all([identifierParameter(argument), returnedExpression(argument)]), ([parameter, expression]) => isTagCheckOn(expression, parameter));
 const hasTagSwitch = (node, parameter) => {
-	if (taggedSwitchSubject(node) !== parameter) return false;
-	return node.cases.some((switchCase) => switchCase.test?.type === "Literal" && typeof switchCase.test.value === "string");
+	if (!Option.contains(taggedSwitchSubject(node), parameter)) return false;
+	return node.cases.some((switchCase) => switchCase.test?.type === "Literal" && Predicate.isString(switchCase.test.value));
 };
 const hasManualTagDispatch = (argument) => {
 	if (!isFunction(argument) || argument.body?.type !== "BlockStatement") return false;
-	const parameter = argument.params[0];
-	if (parameter?.type !== "Identifier") return false;
-	return argument.body.body.some((statement) => {
-		if (statement.type === "IfStatement") return hasTagCondition(statement, parameter.name);
-		if (statement.type === "SwitchStatement") return hasTagSwitch(statement, parameter.name);
+	const statements = argument.body.body;
+	return Option.exists(identifierParameter(argument), (parameter) => statements.some((statement) => {
+		if (statement.type === "IfStatement") return isTagCheckOn(statement.test, parameter);
+		if (statement.type === "SwitchStatement") return hasTagSwitch(statement, parameter);
 		return false;
-	});
+	}));
 };
 const catchAllHandler = (node) => {
-	if (!isEffectCall(node, "catchAll")) return void 0;
+	if (!isEffectCall(node, "catchAll")) return Option.none();
 	let handlerIndex = 1;
 	if (node.arguments.length === 1) handlerIndex = 0;
-	return node.arguments[handlerIndex];
+	return Arr.get(node.arguments, handlerIndex);
 };
 const preferCatchTag = define({
 	name: "prefer-catch-tag",
@@ -61,9 +53,9 @@ const preferCatchTag = define({
 			if (isEffectCall(node, "catchIf")) {
 				let predicateIndex = 1;
 				if (node.arguments.length === 2) predicateIndex = 0;
-				const predicate = node.arguments[predicateIndex];
-				if (!hasManualTagPredicate(predicate)) return Effect.void;
-			} else if (!hasManualTagDispatch(catchAllHandler(node))) return Effect.void;
+				const predicate = Arr.get(node.arguments, predicateIndex);
+				if (!Option.exists(predicate, hasManualTagPredicate)) return Effect.void;
+			} else if (!Option.exists(catchAllHandler(node), hasManualTagDispatch)) return Effect.void;
 			return context.report(make({
 				node,
 				message: "Use Effect.catchTag for one tagged failure or Effect.catchTags for multiple tagged failures."

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

@@ -2,26 +2,23 @@ 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 { isInsideCatchAllHandler, tagComparison, taggedSwitchSubject } from "./_tagged-control-flow.js";
+import { hasOneTaggedSubject, isInsideCatchAllHandler, tagComparison, taggedSwitchSubject } from "./_tagged-control-flow.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/prefer-match-tags-exhaustive.ts
 const statementReturns = (statement) => {
 	if (statement.type === "ReturnStatement") return true;
 	if (statement.type !== "BlockStatement") return false;
-	const last = statement.body.at(-1);
-	if (last === void 0) return false;
-	return statementReturns(last);
+	return Option.exists(Arr.last(statement.body), statementReturns);
 };
-const caseReturns = (switchCase) => {
-	const last = switchCase.consequent.at(-1);
-	if (last === void 0) return false;
-	return statementReturns(last);
-};
-const isCompleteTransformationShape = (node) => {
-	if (node.cases.length < 2 || taggedSwitchSubject(node) === null) return false;
+const caseReturns = (switchCase) => Option.exists(Arr.last(switchCase.consequent), statementReturns);
+const isCompleteSwitchTransformation = (node) => {
+	if (node.cases.length < 2 || Option.isNone(taggedSwitchSubject(node))) return false;
 	for (const switchCase of node.cases) {
-		if (switchCase.test === null || switchCase.test.type !== "Literal") return false;
-		if (typeof switchCase.test.value !== "string" || !caseReturns(switchCase)) return false;
+		if (switchCase.test?.type !== "Literal") return false;
+		if (!Predicate.isString(switchCase.test.value) || !caseReturns(switchCase)) return false;
 	}
 	return true;
 };
@@ -30,45 +27,36 @@ const isTerminalStatement = (node) => {
 	if (node.parent?.type !== "BlockStatement") return true;
 	return node.parent.body.at(-1) === node;
 };
-const isCompleteIfTransformationShape = (node) => {
-	if (isElseIf(node) || !isTerminalStatement(node)) return false;
+const isPlainIf = (statement) => statement.type === "IfStatement" && Predicate.isNull(statement.alternate);
+/** The tag a branch compares, when the branch always returns. */
+const returningTagComparison = (branch) => Option.filter(tagComparison(branch.test), () => statementReturns(branch.consequent));
+/** Whether at least two returning branches each compare one subject against a distinct tag. */
+const isDistinctTagDispatch = (branches) => Option.exists(Option.all(branches.map(returningTagComparison)), (comparisons) => hasOneTaggedSubject(comparisons) && new Set(comparisons.map((comparison) => comparison.tag)).size === comparisons.length);
+/** The if statement and each `else if` after it; none when the chain ends in a plain else. */
+const elseIfChain = (node) => {
+	const chain = [node];
 	let current = node;
-	let subject;
-	const tags = /* @__PURE__ */ new Set();
-	let branchCount = 0;
-	while (true) {
-		const comparison = tagComparison(current.test);
-		if (comparison === null || !statementReturns(current.consequent)) return false;
-		if (subject !== void 0 && comparison.subject !== subject) return false;
-		if (tags.has(comparison.tag)) return false;
-		subject = comparison.subject;
-		tags.add(comparison.tag);
-		branchCount += 1;
-		if (current.alternate === null) break;
-		if (current.alternate.type !== "IfStatement") return false;
+	while (current.alternate?.type === "IfStatement") {
 		current = current.alternate;
+		chain.push(current);
 	}
-	return branchCount >= 2;
+	if (Predicate.isNotNull(current.alternate)) return Option.none();
+	return Option.some(chain);
+};
+const isCompleteIfTransformation = (node) => {
+	if (isElseIf(node) || !isTerminalStatement(node)) return false;
+	return Option.exists(elseIfChain(node), isDistinctTagDispatch);
 };
-const isCompleteSequentialIfTransformationShape = (node) => {
-	if (node.alternate !== null || node.parent?.type !== "BlockStatement") return false;
+/** Whether `previous` is a returning tag check on the same subject, so `node` does not start a run. */
+const continuesRun = (previous, node) => Option.exists(previous, (statement) => isPlainIf(statement) && statementReturns(statement.consequent) && Option.exists(Option.all([tagComparison(statement.test), tagComparison(node.test)]), ([before, current]) => before.subject === current.subject));
+const isCompleteSequentialIfTransformation = (node) => {
+	if (!isPlainIf(node) || node.parent?.type !== "BlockStatement") return false;
 	const statements = node.parent.body;
 	const index = statements.indexOf(node);
 	if (index < 0) return false;
-	const comparison = tagComparison(node.test);
-	if (comparison === null || !statementReturns(node.consequent)) return false;
-	const previous = statements[index - 1];
-	if (previous?.type === "IfStatement" && previous.alternate === null) {
-		if (tagComparison(previous.test)?.subject === comparison.subject && statementReturns(previous.consequent)) return false;
-	}
-	const tags = new Set([comparison.tag]);
-	for (const statement of statements.slice(index + 1)) {
-		if (statement.type !== "IfStatement" || statement.alternate !== null) return false;
-		const next = tagComparison(statement.test);
-		if (next === null || next.subject !== comparison.subject || tags.has(next.tag) || !statementReturns(statement.consequent)) return false;
-		tags.add(next.tag);
-	}
-	return tags.size >= 2;
+	const run = statements.slice(index);
+	if (!run.every(isPlainIf) || continuesRun(Arr.get(statements, index - 1), node)) return false;
+	return isDistinctTagDispatch(run);
 };
 const preferMatchTagsExhaustive = define({
 	name: "prefer-match-tags-exhaustive",
@@ -80,14 +68,14 @@ const preferMatchTagsExhaustive = define({
 		const context = yield* RuleContext;
 		return {
 			SwitchStatement: (node) => {
-				if (!isCompleteTransformationShape(node) || isInsideCatchAllHandler(node)) return Effect.void;
+				if (!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 (!isCompleteIfTransformationShape(node) && !isCompleteSequentialIfTransformationShape(node) || isInsideCatchAllHandler(node)) return Effect.void;
+				if (!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

@@ -3,15 +3,14 @@ import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { effectCallbackLocation, hasOneTaggedSubject, tagComparisonsInOr } from "./_tagged-control-flow.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/prefer-predicate-is-tagged.ts
-const isCatchIfPredicate = (node) => {
-	const location = effectCallbackLocation(node, "catchIf");
-	if (location === null) return false;
+const isCatchIfPredicate = (node) => Option.exists(effectCallbackLocation(node, "catchIf"), (location) => {
 	let predicateIndex = 1;
 	if (location.argumentCount === 2) predicateIndex = 0;
 	return location.index === predicateIndex;
-};
+});
 const preferPredicateIsTagged = define({
 	name: "prefer-predicate-is-tagged",
 	meta: meta({
@@ -24,8 +23,7 @@ const preferPredicateIsTagged = define({
 			if (node.operator !== "||") return Effect.void;
 			if (node.parent?.type === "LogicalExpression" && node.parent.operator === "||") return Effect.void;
 			if (isCatchIfPredicate(node)) return Effect.void;
-			const comparisons = tagComparisonsInOr(node);
-			if (comparisons === null || !hasOneTaggedSubject(comparisons)) 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."

package/dist/rules/prefer-service-of.js

@@ -2,33 +2,44 @@ 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 } 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 Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/prefer-service-of.ts
+const isObjectExpression = (node) => node.type === "ObjectExpression";
+const returnedObjectStatement = (statement) => {
+	if (statement.type !== "ReturnStatement" || statement.argument?.type !== "ObjectExpression") return Option.none();
+	return Option.some(statement.argument);
+};
+/** The object a function argument returns: its expression body or its first returned object. */
 const returnedObject = (node) => {
-	if (node?.type !== "ArrowFunctionExpression" && node?.type !== "FunctionExpression") return;
-	if (node.body === null) return void 0;
-	if (node.body.type === "ObjectExpression") return node.body;
-	if (node.body.type !== "BlockStatement") return void 0;
-	for (const statement of node.body.body) if (statement.type === "ReturnStatement" && statement.argument?.type === "ObjectExpression") return statement.argument;
+	if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") return Option.none();
+	const body = node.body;
+	if (Predicate.isNull(body)) return Option.none();
+	if (body.type === "ObjectExpression") return Option.some(body);
+	if (body.type !== "BlockStatement") return Option.none();
+	return Arr.findFirst(body.body, returnedObjectStatement);
+};
+/** The object an `Effect.succeed(...)` or `Effect.gen(...)` implementation produces. */
+const effectImplementationObject = (implementation, effectNamespaces) => {
+	if (implementation.type !== "CallExpression" || implementation.callee.type === "Super") return Option.none();
+	if (isStaticMember(implementation.callee, effectNamespaces, "succeed")) return Option.filter(Arr.head(implementation.arguments), isObjectExpression);
+	if (isStaticCall(implementation, effectNamespaces, "gen")) return Option.flatMap(Arr.head(implementation.arguments), returnedObject);
+	return Option.none();
+};
+const layerImplementationObject = (callee, implementation, layerNamespaces, effectNamespaces) => {
+	if (isStaticMember(callee, layerNamespaces, "succeed")) return Option.liftPredicate(implementation, isObjectExpression);
+	if (isStaticMember(callee, layerNamespaces, "sync")) return returnedObject(implementation);
+	if (!isStaticMember(callee, layerNamespaces, "effect")) return Option.none();
+	return effectImplementationObject(implementation, effectNamespaces);
 };
 const implementationObject = (node, layerNamespaces, effectNamespaces) => {
-	if (node.callee.type === "Super" || node.arguments.length < 2) return void 0;
-	const implementation = node.arguments[1];
-	if (implementation === void 0 || implementation.type === "SpreadElement") return void 0;
-	if (isStaticMember(node.callee, layerNamespaces, "succeed")) {
-		if (implementation.type === "ObjectExpression") return implementation;
-		return;
-	}
-	if (isStaticMember(node.callee, layerNamespaces, "sync")) return returnedObject(implementation);
-	if (!isStaticMember(node.callee, layerNamespaces, "effect")) return void 0;
-	if (implementation.type !== "CallExpression" || implementation.callee.type === "Super") return;
-	if (isStaticMember(implementation.callee, effectNamespaces, "succeed")) {
-		const value = implementation.arguments[0];
-		if (value?.type === "ObjectExpression") return value;
-		return;
-	}
-	if (isStaticCall(implementation, effectNamespaces, "gen")) return returnedObject(implementation.arguments[0]);
+	const callee = node.callee;
+	if (callee.type === "Super") return Option.none();
+	return Option.flatMap(expressionArgument(node, 1), (implementation) => layerImplementationObject(callee, implementation, layerNamespaces, effectNamespaces));
 };
 const preferServiceOf = define({
 	name: "prefer-service-of",
@@ -52,11 +63,13 @@ const preferServiceOf = define({
 				const service = node.arguments[0];
 				if (service?.type !== "Identifier") return Effect.void;
 				const implementation = implementationObject(node, visibleNamespaces(ctx, node, layerNamespaces), visibleNamespaces(ctx, node, effectNamespaces));
-				if (implementation === void 0) return Effect.void;
-				return ctx.report(make({
-					node: implementation,
-					message: `Wrap this implementation with ${service.name}.of(...) so it stays checked against the service interface.`
-				}));
+				return Option.match(implementation, {
+					onNone: () => Effect.void,
+					onSome: (object) => ctx.report(make({
+						node: object,
+						message: `Wrap this implementation with ${service.name}.of(...) so it stays checked against the service interface.`
+					}))
+				});
 			}
 		};
 	}

package/dist/rules/require-named-effect-fn.js

@@ -3,9 +3,11 @@ import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.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/require-named-effect-fn.ts
-const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const isFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
 const requireNamedEffectFn = define({
 	name: "require-named-effect-fn",
 	meta: meta({
@@ -24,7 +26,7 @@ const requireNamedEffectFn = define({
 			CallExpression: (node) => {
 				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
 				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
-				if (!isStaticMember(node.callee, namespaces, "fn") || !isFunction(node.arguments[0])) return Effect.void;
+				if (!isStaticMember(node.callee, namespaces, "fn") || !Option.exists(Arr.head(node.arguments), isFunction)) return Effect.void;
 				return ctx.report(make({
 					node,
 					message: "Name this operation with Effect.fn(\"Domain.operation\") for stable tracing and diagnostics."