oxlint-plugin-effect 0.13.0 → 0.15.0

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

@@ -1,3 +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",
@@ -16,54 +20,38 @@ 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 createTypeEnvironment(program) {
-	const aliases = /* @__PURE__ */ new Map();
+function isInterfaceDeclaration(node) {
+	return node.type === "TSInterfaceDeclaration";
+}
+function createTypeEnvironment(program, visitorKeys) {
 	const interfaces = /* @__PURE__ */ new Map();
-	const shadowedBuiltIns = /* @__PURE__ */ new Set();
-	for (const statement of program.body) {
-		const declaration = declaredStatement(statement);
-		if (declaration?.type === "ImportDeclaration") {
-			for (const specifier of declaration.specifiers) if (BUILT_INS.has(specifier.local.name)) shadowedBuiltIns.add(specifier.local.name);
-			continue;
-		}
-		if (declaration?.type === "TSTypeAliasDeclaration") {
-			if (aliases.get(declaration.id.name) === void 0) aliases.set(declaration.id.name, declaration);
-			else shadowedBuiltIns.add(declaration.id.name);
-			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
-			continue;
-		}
-		if (declaration?.type === "TSInterfaceDeclaration") {
-			const declarations = interfaces.get(declaration.id.name) ?? [];
-			declarations.push(declaration);
-			interfaces.set(declaration.id.name, declarations);
-			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
-			continue;
-		}
-		if (declaration?.type === "TSEnumDeclaration") {
-			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
-			continue;
-		}
-		if ((declaration?.type === "ClassDeclaration" || declaration?.type === "FunctionDeclaration") && declaration.id !== null) {
-			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
-		}
+	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);
 	}
 	return {
-		aliases,
 		interfaces,
-		shadowedBuiltIns
+		typeAliases: createTypeAliasEnvironment(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, environment) {
-	return BUILT_INS.has(name) && !environment.shadowedBuiltIns.has(name);
+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;
@@ -74,164 +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) {
+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) 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);
-	return substitution === void 0 ? type : resolvedSubstitutionArgument(substitution, base);
+	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, 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 = environment.aliases.get(name);
-	if (alias === void 0 || 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, environment)) {
-		const wrapped = unwrapped.typeArguments?.params[0];
-		return wrapped === void 0 ? [] : dictionaryValueTypes(wrapped, environment, substitutions, resolvingAliases);
-	}
-	if (name === "Record" && isBuiltIn(name, 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, 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 = environment.aliases.get(name);
-	if (alias === void 0 || 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;
-}
-function resolvesToDictionary(type, environment, substitutions, resolvingAliases) {
-	return dictionaryValueTypes(type, environment, substitutions, resolvingAliases).length > 0;
+	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, 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, environment)) return { kind: "open dictionary" };
-	const alias = environment.aliases.get(name);
-	if (alias === void 0) return null;
-	if ((alias.typeParameters?.params.length ?? 0) > 0) {
-		const substitutions = aliasSubstitution(alias, unwrapped, /* @__PURE__ */ new Map());
-		return substitutions !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions, new Set([name])) ? { 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) {
+	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 referenceName = typeReferenceName(unwrapped);
+	if (Option.isNone(referenceName)) return false;
+	const name = referenceName.value;
+	const substitution = substitutions.get(name);
+	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 (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.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 !== "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 classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
-	const alias = environment.aliases.get(name);
-	if (alias === void 0 || 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 (Predicate.isNotUndefined(substitution)) {
+		if (isUnappliedReferenceTo(substitution, name)) return Option.none();
+		return classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
+	}
+	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

@@ -0,0 +1,30 @@
+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) {
+	if (type.type === "TSUnknownKeyword") return true;
+	if (type.type === "TSParenthesizedType") return containsUnknownType(type.typeAnnotation);
+	return type.type === "TSUnionType" && type.types.some(containsUnknownType);
+}
+/** 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 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 annotationOffset = Option.map(functionParameterTypeAnnotation(parameter), (annotation) => annotation.start - parameter.start);
+	if (parameter.type === "Identifier") return parameter.name;
+	const sourceText = sourceCode.getText(parameter);
+	return Option.match(annotationOffset, {
+		onNone: () => sourceText,
+		onSome: (offset) => sourceText.slice(0, offset).trimEnd()
+	});
+}
+//#endregion
+export { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation };

package/dist/rules/_anti-slop-lexical-type-parameters.js

@@ -0,0 +1,25 @@
+import { childNodesAt, isAstNode } from "./_ast-children.js";
+import { ancestors } from "./_ast-ancestors.js";
+//#region src/rules/_anti-slop-lexical-type-parameters.ts
+function isNode(value) {
+	return isAstNode(value);
+}
+function collectInferTypeParameterNames(node, visitorKeys, names) {
+	if (node.type === "TSInferType") names.add(node.typeParameter.name.name);
+	for (const key of visitorKeys[node.type] ?? []) for (const child of childNodesAt(node, key, isNode)) collectInferTypeParameterNames(child, visitorKeys, names);
+}
+/** Collect type binders that are in scope at a node and can shadow module aliases. */
+function lexicalTypeParameterNames(node, visitorKeys) {
+	const names = /* @__PURE__ */ new Set();
+	let descendant = node;
+	for (const current of [node, ...ancestors(node)]) {
+		if (current.type === "Program") break;
+		if ("typeParameters" in current) for (const parameter of current.typeParameters?.params ?? []) names.add(parameter.name.name);
+		if (current.type === "TSMappedType" && (descendant === current.nameType || descendant === current.typeAnnotation)) names.add(current.key.name);
+		if (current.type === "TSConditionalType" && descendant === current.trueType) collectInferTypeParameterNames(current.extendsType, visitorKeys, names);
+		descendant = current;
+	}
+	return names;
+}
+//#endregion
+export { lexicalTypeParameterNames };

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

@@ -0,0 +1,25 @@
+import { resolveVariable } from "./_anti-slop-scope.js";
+import * as Option from "effect/Option";
+//#region src/rules/_anti-slop-reflect-method.ts
+/**
+* Ported from dmmulroy/anti-slop at
+* c44ef22ca116d0ba62a3ff663a0bd13a3f3fa40b.
+*/
+function isGlobalReflect(sourceCode, expression) {
+	if (expression.type !== "Identifier" || expression.name !== "Reflect") return false;
+	if (sourceCode.isGlobalReference(expression)) return true;
+	return Option.match(resolveVariable(sourceCode, expression), {
+		onNone: () => true,
+		onSome: (variable) => variable.defs.length === 0
+	});
+}
+/** Reports whether a call target names one method on the global Reflect object. */
+function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
+	if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) return false;
+	if (!isGlobalReflect(sourceCode, callee.object)) return false;
+	const property = callee.property;
+	if (callee.computed) return property.type === "Literal" && property.value === methodName;
+	return property.type === "Identifier" && property.name === methodName;
+}
+//#endregion
+export { isGlobalReflectMethodCall };

package/dist/rules/_anti-slop-scope.js

@@ -0,0 +1,15 @@
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+//#region src/rules/_anti-slop-scope.ts
+/** Resolve an identifier to its binding by walking lexical scopes upward. */
+function resolveVariable(sourceCode, identifier) {
+	let scope = Option.some(sourceCode.getScope(identifier));
+	while (Option.isSome(scope)) {
+		const variable = scope.value.set.get(identifier.name);
+		if (Predicate.isNotUndefined(variable)) return Option.some(variable);
+		scope = Option.fromNullishOr(scope.value.upper);
+	}
+	return Option.none();
+}
+//#endregion
+export { resolveVariable };