oxlint-plugin-effect 0.13.0 → 0.15.0

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

@@ -2,13 +2,10 @@ 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 { 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
-function referencedAliasName(type) {
-	if (type.type === "TSParenthesizedType") return referencedAliasName(type.typeAnnotation);
-	if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier") return null;
-	return type.typeArguments === null || type.typeArguments === void 0 || type.typeArguments.params.length === 0 ? type.typeName.name : null;
-}
 /** Ban named aliases that merely conceal TypeScript's unknown top type. */
 const noUnknownTypeAliases = define({
 	name: "no-unknown-type-aliases",
@@ -19,29 +16,26 @@ const noUnknownTypeAliases = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		const aliases = /* @__PURE__ */ new Map();
-		const resolvesToUnknown = (type, visited = /* @__PURE__ */ new Set()) => {
-			if (type.type === "TSUnknownKeyword") return true;
-			if (type.type === "TSParenthesizedType") return resolvesToUnknown(type.typeAnnotation, visited);
-			const name = referencedAliasName(type);
-			if (name === null || visited.has(name)) return false;
-			const alias = aliases.get(name);
-			if (alias === void 0 || alias.typeParameters !== null && alias.typeParameters !== void 0) return false;
-			const nextVisited = new Set(visited);
-			nextVisited.add(name);
-			return resolvesToUnknown(alias.typeAnnotation, nextVisited);
-		};
-		return { Program: (node) => {
-			for (const statement of node.body) {
-				const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
-				if (declaration?.type === "TSTypeAliasDeclaration") aliases.set(declaration.id.name, declaration);
+		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 = Option.some(createTypeAliasEnvironment(node, context.sourceCode.visitorKeys));
+				return 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 }
+				}));
 			}
-			return Effect.forEach(aliases.values(), (alias) => resolvesToUnknown(alias.typeAnnotation, new Set([alias.id.name])) ? context.report(fromId({
-				node: alias.id,
-				messageId: "unknownAlias",
-				data: { alias: alias.id.name }
-			})) : Effect.void, { discard: true });
-		} };
+		};
 	}
 });
 //#endregion

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

@@ -2,37 +2,81 @@ 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([
+	"JSDocNonNullableType",
+	"JSDocNullableType",
+	"JSDocUnknownType",
+	"TSAnyKeyword",
+	"TSArrayType",
+	"TSBigIntKeyword",
+	"TSBooleanKeyword",
+	"TSConditionalType",
+	"TSConstructorType",
+	"TSFunctionType",
+	"TSImportType",
+	"TSIndexedAccessType",
+	"TSInferType",
+	"TSIntersectionType",
+	"TSIntrinsicKeyword",
+	"TSLiteralType",
+	"TSMappedType",
+	"TSNamedTupleMember",
+	"TSNeverKeyword",
+	"TSNullKeyword",
+	"TSNumberKeyword",
+	"TSObjectKeyword",
+	"TSParenthesizedType",
+	"TSStringKeyword",
+	"TSSymbolKeyword",
+	"TSTemplateLiteralType",
+	"TSThisType",
+	"TSTupleType",
+	"TSTypeLiteral",
+	"TSTypeOperator",
+	"TSTypePredicate",
+	"TSTypeQuery",
+	"TSTypeReference",
+	"TSUndefinedKeyword",
+	"TSUnionType",
+	"TSUnknownKeyword",
+	"TSVoidKeyword"
+]);
 function isTypeNode(node) {
-	return node.type.startsWith("TS") && node.type !== "TSTypeAnnotation";
+	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 && environment.aliases.has(name) && !isInsideTypeAliasDeclaration(node);
+	return Option.exists(typeReferenceName(node), (name) => Option.isSome(visibleTypeAlias(name, node, environment.typeAliases))) && !isInsideTypeAliasDeclaration(node);
+}
+function isInsideTypeParameterConstraint(node) {
+	let child = node;
+	for (const parent of ancestors(node)) {
+		if (parent.type === "TSTypeParameter" && parent.constraint === child) return true;
+		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({
@@ -44,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);
+				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));
 			}
 		};
 	}

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

@@ -2,11 +2,14 @@ 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
 /**
 * Ported from dmmulroy/anti-slop at
-* b5d2288db1f00469a1d5f2e3b0e265e5a5676fd0.
+* c44ef22ca116d0ba62a3ff663a0bd13a3f3fa40b.
 */
 const functionBoundaryTypes = new Set([
 	"ArrowFunctionExpression",
@@ -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."