oxlint-plugin-effect 0.14.0 → 0.16.0

package/README.md

@@ -21,7 +21,19 @@ export default {
 };
 ```
 
-If the project uses JSON configuration, copy the exported rule map into `rules`; every recommended rule has `error` severity. The complexity rules carry their limit as an option, `["error", { "max": 21 }]`.
+A JSON configuration extends the generated preset file. It loads the plugin and enables every recommended rule, so new rules arrive with each release:
+
+```jsonc
+{
+  "extends": ["./node_modules/oxlint-plugin-effect/presets/recommended.json"],
+  "rules": {
+    // Local choices override the preset.
+    "effect/noTernary": "off",
+  },
+}
+```
+
+Every recommended rule has `error` severity. The complexity rules carry their limit as an option, `["error", { "max": 21 }]`.
 
 ## Recommended Rules
 
@@ -35,7 +47,8 @@ If the project uses JSON configuration, copy the exported rule map into `rules`;
 | `effect/noNewPromise`                  | Bans new Promise, Promise calls, and Promise static APIs                                  |
 | `effect/noNewError`                    | Allows native Error values only as direct arguments to Effect.die, Cause.die, or Exit.die |
 | `effect/noNullish`                     | Bans null and undefined; permits `Object.create(null)` for prototype-free dictionaries    |
-| `effect/noModuleMocks`                 | Bans Vitest and Jest module mocks and method spies; use Effect service test layers        |
+| `effect/noModuleMocks`                 | Bans Vitest, Jest, and bun:test module mocks, mock functions, and spies; use test layers  |
+| `effect/noTestGlobals`                 | Bans global writes, global stubs, and implicit runner globals in test files               |
 | `effect/noTernary`                     | Bans conditional expressions while allowing ordinary if statements                        |
 | `effect/noManagedRuntimeInEffect`      | Keeps ManagedRuntime construction at non-Effect host boundaries                           |
 | `effect/noModuleLevelMutableState`     | Bans module-level `let` and `var` outside tests; hold shared state in a Layer-owned `Ref` |
@@ -203,7 +216,7 @@ bun run codegen
 bun run add-rule -- no-example --dry-run
 ```
 
-`bun run codegen` owns both the rule export barrel and the recommended preset.
+`bun run codegen` owns the rule export barrel and both forms of the recommended preset: `src/presets/recommended.ts` and `presets/recommended.json`.
 `bun run gate` fails when either generated file is stale.
 
 ## License

package/dist/presets/recommended.d.ts

@@ -46,6 +46,7 @@ declare const recommended: {
   readonly "effect/noShapeInSymbolNames": "error";
   readonly "effect/noSilentCatchAll": "error";
   readonly "effect/noTernary": "error";
+  readonly "effect/noTestGlobals": "error";
   readonly "effect/noTestLifecycleHooks": "error";
   readonly "effect/noThrowStatement": "error";
   readonly "effect/noTryCatch": "error";

package/dist/presets/recommended.js

@@ -40,6 +40,7 @@ const recommended = {
 	"effect/noShapeInSymbolNames": "error",
 	"effect/noSilentCatchAll": "error",
 	"effect/noTernary": "error",
+	"effect/noTestGlobals": "error",
 	"effect/noTestLifecycleHooks": "error",
 	"effect/noThrowStatement": "error",
 	"effect/noTryCatch": "error",

package/dist/rules/_anti-slop-array-method.js

@@ -1,35 +1,40 @@
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 //#region src/rules/_anti-slop-array-method.ts
 /** Unwrap syntax-only wrappers when inspecting array methods and accumulator references. */
 function unwrapArrayExpression(node) {
 	while (node.type === "ParenthesizedExpression" || node.type === "ChainExpression" || node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression") node = node.expression;
 	return node;
 }
+function* scopeChain(scope) {
+	let current = Option.some(scope);
+	while (Option.isSome(current)) {
+		yield current.value;
+		current = Option.fromNullOr(current.value.upper);
+	}
+}
 /** Resolve a local binding by scope, not by identifier spelling. */
 function resolveArrayBinding(sourceCode, node) {
 	node = unwrapArrayExpression(node);
-	if (node.type !== "Identifier") return null;
-	let scope = sourceCode.getScope(node);
-	while (scope !== null) {
-		const variable = scope.set.get(node.name);
-		if (variable !== void 0) return variable;
-		scope = scope.upper;
-	}
-	return null;
+	if (node.type !== "Identifier") return Option.none();
+	const name = node.name;
+	return Arr.findFirst(scopeChain(sourceCode.getScope(node)), (scope) => Option.fromUndefinedOr(scope.set.get(name)));
 }
 /** Read static method names, including computed string literals, without evaluating expressions. */
 function arrayMethodTarget(node) {
 	node = unwrapArrayExpression(node);
-	if (node.type !== "MemberExpression") return null;
+	if (node.type !== "MemberExpression") return Option.none();
 	const property = node.property;
-	if (!node.computed && property.type === "Identifier") return {
+	if (!node.computed && property.type === "Identifier") return Option.some({
 		name: property.name,
 		object: node.object
-	};
-	if (node.computed && property.type === "Literal" && typeof property.value === "string") return {
+	});
+	if (node.computed && property.type === "Literal" && Predicate.isString(property.value)) return Option.some({
 		name: property.value,
 		object: node.object
-	};
-	return null;
+	});
+	return Option.none();
 }
 function isArrayAnnotation(type) {
 	if (type.type === "TSArrayType" || type.type === "TSTupleType") return true;
@@ -41,30 +46,33 @@ function isArrayAnnotation(type) {
 function isKnownArrayExpression(sourceCode, node, visited = /* @__PURE__ */ new Set()) {
 	node = unwrapArrayExpression(node);
 	if (node.type === "ArrayExpression") return true;
-	if (node.type === "CallExpression") {
-		const method = arrayMethodTarget(node.callee);
-		return method !== null && [
-			"map",
-			"filter",
-			"flatMap",
-			"slice",
-			"concat",
-			"toSorted",
-			"toReversed",
-			"toSpliced"
-		].includes(method.name) && isKnownArrayExpression(sourceCode, method.object, visited);
-	}
+	if (node.type === "CallExpression") return Option.exists(arrayMethodTarget(node.callee), (method) => [
+		"map",
+		"filter",
+		"flatMap",
+		"slice",
+		"concat",
+		"toSorted",
+		"toReversed",
+		"toSpliced"
+	].includes(method.name) && isKnownArrayExpression(sourceCode, method.object, visited));
 	if (node.type !== "Identifier") return false;
-	const variable = resolveArrayBinding(sourceCode, node);
-	if (variable === null || visited.has(variable)) return false;
+	return Option.exists(resolveArrayBinding(sourceCode, node), (variable) => isKnownArrayVariable(sourceCode, variable, visited));
+}
+function isKnownArrayVariable(sourceCode, variable, visited) {
+	if (visited.has(variable)) return false;
 	visited.add(variable);
 	if (variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
 	for (const identifier of variable.identifiers) {
 		const annotation = identifier.typeAnnotation?.typeAnnotation;
-		if (annotation !== void 0) return isArrayAnnotation(annotation);
+		if (Predicate.isNotUndefined(annotation)) return isArrayAnnotation(annotation);
 	}
-	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && definition.node.init !== null && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") return isKnownArrayExpression(sourceCode, definition.node.init, visited);
-	return false;
+	return Option.exists(constInitializer(variable), (init) => isKnownArrayExpression(sourceCode, init, visited));
+}
+/** The initializer of the first `const name = init` definition of a variable. */
+function constInitializer(variable) {
+	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && Predicate.isNotNull(definition.node.init) && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") return Option.some(definition.node.init);
+	return Option.none();
 }
 //#endregion
-export { arrayMethodTarget, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression };
+export { arrayMethodTarget, constInitializer, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression };

package/dist/rules/_anti-slop-dictionary-types.js

@@ -1,4 +1,7 @@
 import { createTypeAliasEnvironment, hasVisibleTypeBinding, visibleTypeAlias } 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";
 //#region src/rules/_anti-slop-dictionary-types.ts
 const BUILT_INS = new Set([
 	"Record",
@@ -17,13 +20,16 @@ const TRANSPARENT_WRAPPERS = new Set([
 	"NonNullable"
 ]);
 function declaredStatement(statement) {
-	return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration ?? null : statement;
+	if (statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration") return Option.fromNullishOr(statement.declaration);
+	return Option.some(statement);
+}
+function isInterfaceDeclaration(node) {
+	return node.type === "TSInterfaceDeclaration";
 }
 function createTypeEnvironment(program, visitorKeys) {
 	const interfaces = /* @__PURE__ */ new Map();
-	for (const statement of program.body) {
-		const declaration = declaredStatement(statement);
-		if (declaration?.type !== "TSInterfaceDeclaration") continue;
+	const declared = Arr.getSomes(program.body.map(declaredStatement));
+	for (const declaration of declared.filter(isInterfaceDeclaration)) {
 		const declarations = interfaces.get(declaration.id.name) ?? [];
 		declarations.push(declaration);
 		interfaces.set(declaration.id.name, declarations);
@@ -34,14 +40,18 @@ function createTypeEnvironment(program, visitorKeys) {
 	};
 }
 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 typeArgument(type, index) {
+	return Arr.get(type.typeArguments?.params ?? [], index);
 }
 function isBuiltIn(name, use, environment) {
 	return BUILT_INS.has(name) && !hasVisibleTypeBinding(name, use, environment.typeAliases);
 }
 function isUnappliedReferenceTo(type, name) {
 	const unwrapped = unwrapTransparentType(type);
-	return unwrapped.type === "TSTypeReference" && typeReferenceName(unwrapped) === name && (unwrapped.typeArguments === null || unwrapped.typeArguments === void 0 || unwrapped.typeArguments.params.length === 0);
+	return unwrapped.type === "TSTypeReference" && Option.contains(typeReferenceName(unwrapped), name) && (unwrapped.typeArguments?.params.length ?? 0) === 0;
 }
 function unwrapTransparentType(type) {
 	let current = type;
@@ -52,191 +62,224 @@ function isNeverType(type) {
 	return unwrapTransparentType(type).type === "TSNeverKeyword";
 }
 function isEffectivelyEmptyMember(member) {
-	return member.type === "TSPropertySignature" && member.optional === true && member.typeAnnotation !== null && member.typeAnnotation !== void 0 && isNeverType(member.typeAnnotation.typeAnnotation);
+	return member.type === "TSPropertySignature" && member.optional === true && Predicate.isNotNullish(member.typeAnnotation) && isNeverType(member.typeAnnotation.typeAnnotation);
 }
 function isEffectivelyEmptyTypeLiteral(type) {
 	return type.members.length === 0 || type.members.every(isEffectivelyEmptyMember);
 }
 function isEffectivelyEmptyInterface(declarations) {
 	if (declarations.length !== 1) return false;
-	const [type] = declarations;
-	return type !== void 0 && type.extends.length === 0 && (type.body.body.length === 0 || type.body.body.every(isEffectivelyEmptyMember));
+	return Option.exists(Arr.head(declarations), (type) => type.extends.length === 0 && (type.body.body.length === 0 || type.body.body.every(isEffectivelyEmptyMember)));
 }
 function resolvedSubstitutionArgument(type, base, resolving = /* @__PURE__ */ new Set()) {
 	const unwrapped = unwrapTransparentType(type);
 	if (unwrapped.type !== "TSTypeReference") return type;
-	const name = typeReferenceName(unwrapped);
-	if (name === null || resolving.has(name)) return type;
+	const referenceName = typeReferenceName(unwrapped);
+	if (Option.isNone(referenceName) || resolving.has(referenceName.value)) return type;
+	const name = referenceName.value;
 	const substitution = base.get(name);
-	if (substitution === void 0) return type;
+	if (Predicate.isUndefined(substitution)) return type;
 	const nextResolving = new Set(resolving);
 	nextResolving.add(name);
 	return resolvedSubstitutionArgument(substitution, base, nextResolving);
 }
 function aliasSubstitution(alias, type, base) {
 	const parameters = alias.typeParameters?.params ?? [];
-	const typeArguments = type.typeArguments?.params ?? [];
 	const next = new Map(base);
 	for (const [index, parameter] of parameters.entries()) {
-		const argument = typeArguments[index] ?? parameter.default;
-		if (argument === null || argument === void 0) return null;
-		next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
+		const argument = Option.orElse(typeArgument(type, index), () => Option.fromNullishOr(parameter.default));
+		if (Option.isNone(argument)) return Option.none();
+		next.set(parameter.name.name, resolvedSubstitutionArgument(argument.value, next));
 	}
-	return next;
+	return Option.some(next);
+}
+/**
+* The visible alias named by a reference, expanded with its substitutions, unless it is
+* already resolving. (Local change: upstream repeats this step in each reference resolver.)
+*/
+function aliasExpansion(name, reference, environment, substitutions, resolvingAliases) {
+	const alias = visibleTypeAlias(name, reference, environment.typeAliases);
+	if (Option.isNone(alias) || resolvingAliases.has(name)) return Option.none();
+	return Option.map(aliasSubstitution(alias.value, reference, substitutions), (next) => {
+		const nextResolving = new Set(resolvingAliases);
+		nextResolving.add(name);
+		return {
+			type: alias.value.typeAnnotation,
+			substitutions: next,
+			resolvingAliases: nextResolving
+		};
+	});
 }
 function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
 	const unwrapped = unwrapTransparentType(type);
-	if (unwrapped.type === "TSUnknownKeyword") return "unknown";
-	if (unwrapped.type === "TSAnyKeyword") return "any";
-	if (unwrapped.type === "TSObjectKeyword") return "object";
-	if (unwrapped.type === "TSTypeLiteral" && isEffectivelyEmptyTypeLiteral(unwrapped)) return "empty-object";
-	if (unwrapped.type === "TSUnionType") return unwrapped.types.some((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases) !== null) ? "union" : null;
+	if (unwrapped.type === "TSUnknownKeyword") return Option.some("unknown");
+	if (unwrapped.type === "TSAnyKeyword") return Option.some("any");
+	if (unwrapped.type === "TSObjectKeyword") return Option.some("object");
+	if (unwrapped.type === "TSTypeLiteral" && isEffectivelyEmptyTypeLiteral(unwrapped)) return Option.some("empty-object");
+	if (unwrapped.type === "TSUnionType") {
+		if (unwrapped.types.some((member) => Option.isSome(unsafeDirectValue(member, environment, substitutions, resolvingAliases)))) return Option.some("union");
+		return Option.none();
+	}
 	if (unwrapped.type === "TSIntersectionType") {
 		const unsafeMembers = unwrapped.types.map((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases));
-		if (unsafeMembers.includes("any")) return "any";
-		return unsafeMembers.length > 0 && unsafeMembers.every((member) => member !== null) ? unsafeMembers[0] ?? null : null;
-	}
-	if (unwrapped.type !== "TSTypeReference") return null;
-	const name = typeReferenceName(unwrapped);
-	if (name === null) return null;
-	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
-		const wrapped = unwrapped.typeArguments?.params[0];
-		return wrapped === void 0 ? null : unsafeDirectValue(wrapped, environment, substitutions, resolvingAliases);
+		if (Arr.getSomes(unsafeMembers).includes("any")) return Option.some("any");
+		return Option.flatMap(Option.all(unsafeMembers), Arr.head);
 	}
+	if (unwrapped.type !== "TSTypeReference") return Option.none();
+	return unsafeReferenceValue(unwrapped, environment, substitutions, resolvingAliases);
+}
+function unsafeReferenceValue(unwrapped, environment, substitutions, resolvingAliases) {
+	const referenceName = typeReferenceName(unwrapped);
+	if (Option.isNone(referenceName)) return Option.none();
+	const name = referenceName.value;
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) return Option.flatMap(typeArgument(unwrapped, 0), (wrapped) => unsafeDirectValue(wrapped, environment, substitutions, resolvingAliases));
 	const substitution = substitutions.get(name);
-	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? null : unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
+	if (Predicate.isNotUndefined(substitution)) {
+		if (isUnappliedReferenceTo(substitution, name)) return Option.none();
+		return unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
+	}
 	const interfaceDeclarations = environment.interfaces.get(name);
-	if (interfaceDeclarations !== void 0) return isEffectivelyEmptyInterface(interfaceDeclarations) ? "empty-object" : null;
-	const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
-	if (alias === null || resolvingAliases.has(name)) return null;
-	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
-	if (nextSubstitutions === null) return null;
-	const nextResolving = new Set(resolvingAliases);
-	nextResolving.add(name);
-	return unsafeDirectValue(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+	if (Predicate.isNotUndefined(interfaceDeclarations)) {
+		if (isEffectivelyEmptyInterface(interfaceDeclarations)) return Option.some("empty-object");
+		return Option.none();
+	}
+	return Option.flatMap(aliasExpansion(name, unwrapped, environment, substitutions, resolvingAliases), (expansion) => unsafeDirectValue(expansion.type, environment, expansion.substitutions, expansion.resolvingAliases));
 }
 function dictionaryValueTypes(type, environment, substitutions, resolvingAliases) {
 	const unwrapped = unwrapTransparentType(type);
-	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.flatMap((member) => member.type === "TSIndexSignature" && member.typeAnnotation !== null ? [{
-		type: member.typeAnnotation.typeAnnotation,
-		substitutions
-	}] : []);
-	if (unwrapped.type === "TSMappedType") return unwrapped.typeAnnotation === null ? [] : [{
-		type: unwrapped.typeAnnotation,
-		substitutions
-	}];
-	if (unwrapped.type !== "TSTypeReference") return [];
-	const name = typeReferenceName(unwrapped);
-	if (name === null) return [];
-	const substitution = substitutions.get(name);
-	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? [] : dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
-	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
-		const wrapped = unwrapped.typeArguments?.params[0];
-		return wrapped === void 0 ? [] : dictionaryValueTypes(wrapped, environment, substitutions, resolvingAliases);
-	}
-	if (name === "Record" && isBuiltIn(name, unwrapped, environment)) {
-		const value = unwrapped.typeArguments?.params[1] ?? null;
-		return value === null ? [] : [{
-			type: value,
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.flatMap((member) => {
+		if (member.type !== "TSIndexSignature" || Predicate.isNull(member.typeAnnotation)) return [];
+		return [{
+			type: member.typeAnnotation.typeAnnotation,
+			substitutions
+		}];
+	});
+	if (unwrapped.type === "TSMappedType") {
+		if (Predicate.isNull(unwrapped.typeAnnotation)) return [];
+		return [{
+			type: unwrapped.typeAnnotation,
 			substitutions
 		}];
 	}
-	if ((name === "Pick" || name === "Omit") && isBuiltIn(name, unwrapped, environment)) {
-		const source = unwrapped.typeArguments?.params[0];
-		return source === void 0 ? [] : dictionaryValueTypes(source, environment, substitutions, resolvingAliases);
+	if (unwrapped.type !== "TSTypeReference") return [];
+	return referenceValueTypes(unwrapped, environment, substitutions, resolvingAliases);
+}
+function referenceValueTypes(unwrapped, environment, substitutions, resolvingAliases) {
+	const referenceName = typeReferenceName(unwrapped);
+	if (Option.isNone(referenceName)) return [];
+	const name = referenceName.value;
+	const substitution = substitutions.get(name);
+	if (Predicate.isNotUndefined(substitution)) {
+		if (isUnappliedReferenceTo(substitution, name)) return [];
+		return dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
 	}
-	const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
-	if (alias === null || resolvingAliases.has(name)) return [];
-	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
-	if (nextSubstitutions === null) return [];
-	const nextResolving = new Set(resolvingAliases);
-	nextResolving.add(name);
-	return dictionaryValueTypes(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) return Option.match(typeArgument(unwrapped, 0), {
+		onNone: () => [],
+		onSome: (wrapped) => dictionaryValueTypes(wrapped, environment, substitutions, resolvingAliases)
+	});
+	if (name === "Record" && isBuiltIn(name, unwrapped, environment)) return Option.toArray(Option.map(typeArgument(unwrapped, 1), (value) => ({
+		type: value,
+		substitutions
+	})));
+	if ((name === "Pick" || name === "Omit") && isBuiltIn(name, unwrapped, environment)) return Option.match(typeArgument(unwrapped, 0), {
+		onNone: () => [],
+		onSome: (source) => dictionaryValueTypes(source, environment, substitutions, resolvingAliases)
+	});
+	return Option.match(aliasExpansion(name, unwrapped, environment, substitutions, resolvingAliases), {
+		onNone: () => [],
+		onSome: (expansion) => dictionaryValueTypes(expansion.type, environment, expansion.substitutions, expansion.resolvingAliases)
+	});
 }
+const unsafeDictionary = (unsafeValue) => ({
+	kind: "unsafe-dictionary",
+	unsafeValue
+});
 function classifyUnsafeDictionaryValue(valueType, environment) {
-	const unsafeValue = unsafeDirectValue(valueType, environment, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
-	return unsafeValue === null ? null : {
-		kind: "unsafe-dictionary",
-		unsafeValue
-	};
+	return Option.map(unsafeDirectValue(valueType, environment, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set()), unsafeDictionary);
 }
 function classifyUnsafeDictionary(type, environment) {
-	for (const valueType of dictionaryValueTypes(type, environment, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set())) {
-		const unsafeValue = unsafeDirectValue(valueType.type, environment, valueType.substitutions, /* @__PURE__ */ new Set());
-		if (unsafeValue !== null) return {
-			kind: "unsafe-dictionary",
-			unsafeValue
-		};
-	}
-	return null;
+	return Arr.findFirst(dictionaryValueTypes(type, environment, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set()), (valueType) => Option.map(unsafeDirectValue(valueType.type, environment, valueType.substitutions, /* @__PURE__ */ new Set()), unsafeDictionary));
 }
 function classifyWideningTarget(type, environment) {
 	const unwrapped = unwrapTransparentType(type);
-	if (unwrapped.type === "TSUnknownKeyword") return { kind: "unknown" };
-	if (unwrapped.type === "TSObjectKeyword") return { kind: "object" };
-	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.some((member) => member.type === "TSIndexSignature") ? { kind: "open dictionary" } : unwrapped.members.length > 0 ? { kind: "anonymous object" } : null;
-	if (unwrapped.type === "TSMappedType") return { kind: "open dictionary" };
-	if (unwrapped.type !== "TSTypeReference") return null;
-	const name = typeReferenceName(unwrapped);
-	if (name === null) return null;
-	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
-		const wrapped = unwrapped.typeArguments?.params[0];
-		return wrapped === void 0 ? null : classifyWideningTarget(wrapped, environment);
+	if (unwrapped.type === "TSUnknownKeyword") return Option.some({ kind: "unknown" });
+	if (unwrapped.type === "TSObjectKeyword") return Option.some({ kind: "object" });
+	if (unwrapped.type === "TSTypeLiteral") {
+		if (unwrapped.members.some((member) => member.type === "TSIndexSignature")) return Option.some({ kind: "open dictionary" });
+		if (unwrapped.members.length > 0) return Option.some({ kind: "anonymous object" });
+		return Option.none();
 	}
-	if (name === "Record" && isBuiltIn(name, unwrapped, environment)) return hasBroadRecordKey(unwrapped, environment, /* @__PURE__ */ new Map()) ? { kind: "open dictionary" } : null;
-	const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
-	if (alias === null) return null;
-	if ((alias.typeParameters?.params.length ?? 0) > 0) {
-		const substitutions = aliasSubstitution(alias, unwrapped, /* @__PURE__ */ new Map());
-		return (substitutions === null ? null : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name])))?.kind === "open dictionary" ? { kind: "generic container" } : null;
+	if (unwrapped.type === "TSMappedType") return Option.some({ kind: "open dictionary" });
+	if (unwrapped.type !== "TSTypeReference") return Option.none();
+	const referenceName = typeReferenceName(unwrapped);
+	if (Option.isNone(referenceName)) return Option.none();
+	const name = referenceName.value;
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) return Option.flatMap(typeArgument(unwrapped, 0), (wrapped) => classifyWideningTarget(wrapped, environment));
+	if (name === "Record" && isBuiltIn(name, unwrapped, environment)) {
+		if (hasBroadRecordKey(unwrapped, environment, /* @__PURE__ */ new Map())) return Option.some({ kind: "open dictionary" });
+		return Option.none();
 	}
-	const substitutions = aliasSubstitution(alias, unwrapped, /* @__PURE__ */ new Map());
-	if (substitutions === null) return null;
-	return classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name]));
+	return Option.flatMap(visibleTypeAlias(name, unwrapped, environment.typeAliases), (alias) => classifyWideningAlias(alias, unwrapped, name, environment));
+}
+function classifyWideningAlias(alias, unwrapped, name, environment) {
+	const resolved = Option.flatMap(aliasSubstitution(alias, unwrapped, /* @__PURE__ */ new Map()), (substitutions) => classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name])));
+	if ((alias.typeParameters?.params.length ?? 0) === 0) return resolved;
+	if (Option.exists(resolved, (target) => target.kind === "open dictionary")) return Option.some({ kind: "generic container" });
+	return Option.none();
 }
 function hasBroadRecordKey(type, environment, substitutions) {
-	const key = type.typeArguments?.params[0];
-	return key === void 0 || isBroadMappedKey(key, environment, substitutions);
+	return Option.match(typeArgument(type, 0), {
+		onNone: () => true,
+		onSome: (key) => isBroadMappedKey(key, environment, substitutions)
+	});
 }
 function isBroadMappedKey(type, environment, substitutions, visitedAliases = /* @__PURE__ */ new Set()) {
 	const unwrapped = unwrapTransparentType(type);
 	if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") return true;
 	if (unwrapped.type === "TSUnionType") return unwrapped.types.some((member) => isBroadMappedKey(member, environment, substitutions, visitedAliases));
 	if (unwrapped.type !== "TSTypeReference") return false;
-	const name = typeReferenceName(unwrapped);
-	if (name === null) return false;
+	const referenceName = typeReferenceName(unwrapped);
+	if (Option.isNone(referenceName)) return false;
+	const name = referenceName.value;
 	const substitution = substitutions.get(name);
-	if (substitution !== void 0 && !isUnappliedReferenceTo(substitution, name)) return isBroadMappedKey(substitution, environment, substitutions, visitedAliases);
+	if (Predicate.isNotUndefined(substitution) && !isUnappliedReferenceTo(substitution, name)) return isBroadMappedKey(substitution, environment, substitutions, visitedAliases);
 	if (name === "PropertyKey" && isBuiltIn(name, unwrapped, environment)) return true;
 	const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
-	if (alias === null || (alias.typeParameters?.params.length ?? 0) > 0 || visitedAliases.has(name)) return false;
+	if (Option.isNone(alias) || (alias.value.typeParameters?.params.length ?? 0) > 0 || visitedAliases.has(name)) return false;
 	const nextVisited = new Set(visitedAliases);
 	nextVisited.add(name);
-	return isBroadMappedKey(alias.typeAnnotation, environment, substitutions, nextVisited);
+	return isBroadMappedKey(alias.value.typeAnnotation, environment, substitutions, nextVisited);
 }
 function classifyAliasBroadTarget(type, environment, substitutions, resolvingAliases) {
 	const unwrapped = unwrapTransparentType(type);
-	if (unwrapped.type === "TSUnknownKeyword") return { kind: "unknown" };
-	if (unwrapped.type === "TSObjectKeyword") return { kind: "object" };
-	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.some((member) => member.type === "TSIndexSignature") ? { kind: "open dictionary" } : null;
-	if (unwrapped.type === "TSMappedType") return isBroadMappedKey(unwrapped.constraint, environment, substitutions) ? { kind: "open dictionary" } : null;
-	if (unwrapped.type !== "TSTypeReference") return null;
-	const name = typeReferenceName(unwrapped);
-	if (name === null) return null;
+	if (unwrapped.type === "TSUnknownKeyword") return Option.some({ kind: "unknown" });
+	if (unwrapped.type === "TSObjectKeyword") return Option.some({ kind: "object" });
+	if (unwrapped.type === "TSTypeLiteral") {
+		if (unwrapped.members.some((member) => member.type === "TSIndexSignature")) return Option.some({ kind: "open dictionary" });
+		return Option.none();
+	}
+	if (unwrapped.type === "TSMappedType") {
+		if (isBroadMappedKey(unwrapped.constraint, environment, substitutions)) return Option.some({ kind: "open dictionary" });
+		return Option.none();
+	}
+	if (unwrapped.type !== "TSTypeReference") return Option.none();
+	return classifyReferenceBroadTarget(unwrapped, environment, substitutions, resolvingAliases);
+}
+function classifyReferenceBroadTarget(unwrapped, environment, substitutions, resolvingAliases) {
+	const referenceName = typeReferenceName(unwrapped);
+	if (Option.isNone(referenceName)) return Option.none();
+	const name = referenceName.value;
 	const substitution = substitutions.get(name);
-	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? null : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
-	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
-		const wrapped = unwrapped.typeArguments?.params[0];
-		return wrapped === void 0 ? null : classifyAliasBroadTarget(wrapped, environment, substitutions, resolvingAliases);
+	if (Predicate.isNotUndefined(substitution)) {
+		if (isUnappliedReferenceTo(substitution, name)) return Option.none();
+		return classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
 	}
-	if (name === "Record" && isBuiltIn(name, unwrapped, environment)) return hasBroadRecordKey(unwrapped, environment, substitutions) ? { kind: "open dictionary" } : null;
-	const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
-	if (alias === null || resolvingAliases.has(name)) return null;
-	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
-	if (nextSubstitutions === null) return null;
-	const nextResolving = new Set(resolvingAliases);
-	nextResolving.add(name);
-	return classifyAliasBroadTarget(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) return Option.flatMap(typeArgument(unwrapped, 0), (wrapped) => classifyAliasBroadTarget(wrapped, environment, substitutions, resolvingAliases));
+	if (name === "Record" && isBuiltIn(name, unwrapped, environment)) {
+		if (hasBroadRecordKey(unwrapped, environment, substitutions)) return Option.some({ kind: "open dictionary" });
+		return Option.none();
+	}
+	return Option.flatMap(aliasExpansion(name, unwrapped, environment, substitutions, resolvingAliases), (expansion) => classifyAliasBroadTarget(expansion.type, environment, expansion.substitutions, expansion.resolvingAliases));
 }
 function isKnownEvidenceExpression(expression) {
 	let current = expression;

package/dist/rules/_anti-slop-function-parameters.js

@@ -1,3 +1,4 @@
+import * as Option from "effect/Option";
 //#region src/rules/_anti-slop-function-parameters.ts
 /** Return whether a type is or contains TypeScript's absorbing unknown top type. */
 function containsUnknownType(type) {
@@ -8,20 +9,22 @@ function containsUnknownType(type) {
 /** Return the TypeScript annotation attached to a function parameter or its wrapped binding. */
 function functionParameterTypeAnnotation(parameter) {
 	if (parameter.type === "TSParameterProperty") return functionParameterTypeAnnotation(parameter.parameter);
-	if (parameter.type === "RestElement") return parameter.typeAnnotation ?? functionParameterTypeAnnotation(parameter.argument);
-	if (parameter.type === "AssignmentPattern") return parameter.typeAnnotation ?? functionParameterTypeAnnotation(parameter.left);
-	return parameter.typeAnnotation;
+	if (parameter.type === "RestElement") return Option.orElse(Option.fromNullishOr(parameter.typeAnnotation), () => functionParameterTypeAnnotation(parameter.argument));
+	if (parameter.type === "AssignmentPattern") return Option.orElse(Option.fromNullishOr(parameter.typeAnnotation), () => functionParameterTypeAnnotation(parameter.left));
+	return Option.fromNullishOr(parameter.typeAnnotation);
 }
 /** Return only a function parameter's local binding, excluding its annotation and default value. */
 function functionParameterBindingName(parameter, sourceCode) {
 	if (parameter.type === "TSParameterProperty") return functionParameterBindingName(parameter.parameter, sourceCode);
 	if (parameter.type === "AssignmentPattern") return functionParameterBindingName(parameter.left, sourceCode);
 	if (parameter.type === "RestElement") return functionParameterBindingName(parameter.argument, sourceCode);
-	const annotation = functionParameterTypeAnnotation(parameter);
-	const annotationOffset = annotation === null || annotation === void 0 ? void 0 : annotation.start - parameter.start;
+	const annotationOffset = Option.map(functionParameterTypeAnnotation(parameter), (annotation) => annotation.start - parameter.start);
 	if (parameter.type === "Identifier") return parameter.name;
 	const sourceText = sourceCode.getText(parameter);
-	return annotationOffset === void 0 ? sourceText : sourceText.slice(0, annotationOffset).trimEnd();
+	return Option.match(annotationOffset, {
+		onNone: () => sourceText,
+		onSome: (offset) => sourceText.slice(0, offset).trimEnd()
+	});
 }
 //#endregion
 export { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation };