oxlint-plugin-effect 0.13.0 → 0.15.0

package/dist/rules/_anti-slop-type-alias-resolution.js

@@ -0,0 +1,139 @@
+import { childNodesAt, isAstNode } from "./_ast-children.js";
+import { ancestors } from "./_ast-ancestors.js";
+import { lexicalTypeParameterNames } from "./_anti-slop-lexical-type-parameters.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+//#region src/rules/_anti-slop-type-alias-resolution.ts
+const environmentsByProgram = /* @__PURE__ */ new WeakMap();
+function isNode(value) {
+	return isAstNode(value);
+}
+function isTypeScope(node) {
+	return node.type === "Program" || node.type === "BlockStatement" || node.type === "TSModuleBlock" || node.type === "StaticBlock" || node.type === "SwitchStatement";
+}
+function enclosingTypeScope(node) {
+	return Option.getOrElse(Arr.findFirst(ancestors(node), isTypeScope), () => node);
+}
+function declaredTypeBinding(node) {
+	if (node.type === "TSTypeAliasDeclaration") return Option.some({
+		alias: Option.some(node),
+		name: node.id.name
+	});
+	if (node.type === "TSInterfaceDeclaration" || node.type === "TSEnumDeclaration" || node.type === "ClassDeclaration" || node.type === "ClassExpression") return Option.map(Option.fromNullishOr(node.id), (id) => ({
+		alias: Option.none(),
+		name: id.name
+	}));
+	if (node.type === "ImportSpecifier" || node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") return Option.some({
+		alias: Option.none(),
+		name: node.local.name
+	});
+	return Option.none();
+}
+function collectTypeBindings(node, visitorKeys, bindingsByName, aliases) {
+	const declared = declaredTypeBinding(node);
+	if (Option.isSome(declared)) {
+		const { alias, name } = declared.value;
+		const bindings = bindingsByName.get(name) ?? [];
+		bindings.push({
+			alias,
+			name,
+			scope: enclosingTypeScope(node)
+		});
+		bindingsByName.set(name, bindings);
+		if (Option.isSome(alias)) aliases.push(alias.value);
+	}
+	for (const key of visitorKeys[node.type] ?? []) for (const child of childNodesAt(node, key, isNode)) collectTypeBindings(child, visitorKeys, bindingsByName, aliases);
+}
+/** Collect every lexical type alias and competing type binding in a program. */
+function createTypeAliasEnvironment(program, visitorKeys) {
+	const cached = environmentsByProgram.get(program);
+	if (Predicate.isNotUndefined(cached)) return cached;
+	const bindingsByName = /* @__PURE__ */ new Map();
+	const aliases = [];
+	collectTypeBindings(program, visitorKeys, bindingsByName, aliases);
+	const environment = {
+		aliases,
+		bindingsByName,
+		visitorKeys
+	};
+	environmentsByProgram.set(program, environment);
+	return environment;
+}
+function ancestorDistance(ancestor, node) {
+	return Arr.findFirstIndex([node, ...ancestors(node)], (current) => current === ancestor);
+}
+function nearestTypeBindings(name, use, environment) {
+	const candidates = environment.bindingsByName.get(name) ?? [];
+	let nearestDistance = Number.POSITIVE_INFINITY;
+	let nearest = [];
+	for (const candidate of candidates) {
+		const distance = ancestorDistance(candidate.scope, use);
+		if (Option.isNone(distance) || distance.value > nearestDistance) continue;
+		if (distance.value === nearestDistance) {
+			nearest.push(candidate);
+			continue;
+		}
+		nearestDistance = distance.value;
+		nearest = [candidate];
+	}
+	return nearest;
+}
+/** Resolve the nearest visible alias with this name, respecting lexical shadowing. */
+function visibleTypeAlias(name, use, environment) {
+	if (lexicalTypeParameterNames(use, environment.visitorKeys).has(name)) return Option.none();
+	const bindings = nearestTypeBindings(name, use, environment);
+	if (bindings.length !== 1) return Option.none();
+	return Option.flatMap(Arr.head(bindings), (binding) => binding.alias);
+}
+/** Return whether a local declaration shadows a built-in type at this use. */
+function hasVisibleTypeBinding(name, use, environment) {
+	return lexicalTypeParameterNames(use, environment.visitorKeys).has(name) || nearestTypeBindings(name, use, environment).length > 0;
+}
+function typeReferenceName(type) {
+	if (type.typeName.type !== "Identifier") return Option.none();
+	return Option.some(type.typeName.name);
+}
+function aliasSubstitutions(alias, reference, base) {
+	const parameters = alias.typeParameters?.params ?? [];
+	const typeArguments = reference.typeArguments?.params ?? [];
+	const next = new Map(base);
+	for (const [index, parameter] of parameters.entries()) {
+		const explicitArgument = Arr.get(typeArguments, index);
+		const argument = Option.orElse(explicitArgument, () => Option.fromNullishOr(parameter.default));
+		if (Option.isNone(argument)) return Option.none();
+		let argumentSubstitutions = base;
+		if (Option.isNone(explicitArgument)) argumentSubstitutions = next;
+		next.set(parameter.name.name, {
+			type: argument.value,
+			substitutions: new Map(argumentSubstitutions)
+		});
+	}
+	return Option.some(next);
+}
+/** Match a type after resolving visible aliases and substituting their type parameters. */
+function resolvedTypeMatches(type, environment, matcher) {
+	const evaluate = (current, substitutions, resolvingAliases) => {
+		if (current.type === "TSTypeReference") {
+			const name = typeReferenceName(current);
+			if (Option.isSome(name)) {
+				const substitution = substitutions.get(name.value);
+				if (Predicate.isNotUndefined(substitution) && !current.typeArguments?.params.length) return evaluate(substitution.type, substitution.substitutions, resolvingAliases);
+				const expansion = Option.flatMap(Option.filter(visibleTypeAlias(name.value, current, environment), (alias) => !resolvingAliases.has(alias)), (alias) => Option.map(aliasSubstitutions(alias, current, substitutions), (next) => ({
+					alias,
+					next
+				})));
+				if (Option.isSome(expansion)) {
+					const { alias, next } = expansion.value;
+					const nextResolving = new Set(resolvingAliases);
+					nextResolving.add(alias);
+					return evaluate(alias.typeAnnotation, next, nextResolving);
+				}
+			}
+		}
+		return matcher(current, (child) => evaluate(child, substitutions, resolvingAliases));
+	};
+	return evaluate(type, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+}
+//#endregion
+export { createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias };

package/dist/rules/_ast-ancestors.js

@@ -0,0 +1,14 @@
+import * as Option from "effect/Option";
+//#region src/rules/_ast-ancestors.ts
+/** The node's parent, or none at the Program root. */
+const parentOf = (node) => Option.fromNullishOr(node.parent);
+/** The node's ancestors, nearest first, ending at the Program root. */
+function* ancestors(node) {
+	let current = parentOf(node);
+	while (Option.isSome(current)) {
+		yield current.value;
+		current = parentOf(current.value);
+	}
+}
+//#endregion
+export { ancestors, parentOf };

package/dist/rules/_ast-children.js

@@ -0,0 +1,18 @@
+import * as Predicate from "effect/Predicate";
+//#region src/rules/_ast-children.ts
+/**
+* Child-node access by property name, for AST walkers driven by visitor keys
+* or object keys. Reads through the property descriptor, so no walker has to
+* view a node as an open dictionary.
+*/
+/** Whether a value is an AST node: an object whose `type` is a string. */
+const isAstNode = (value) => Predicate.hasProperty(value, "type") && Predicate.isString(value.type);
+/** The nodes held at `node[key]`: the node itself, the nodes of an array, or none. */
+const childNodesAt = (node, key, isNode) => {
+	const value = Object.getOwnPropertyDescriptor(node, key)?.value;
+	if (isNode(value)) return [value];
+	if (Array.isArray(value)) return value.filter(isNode);
+	return [];
+};
+//#endregion
+export { childNodesAt, isAstNode };

package/dist/rules/_call-arguments.js

@@ -0,0 +1,11 @@
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+//#region src/rules/_call-arguments.ts
+const isExpression = (argument) => argument.type !== "SpreadElement";
+/** The call's argument at `index`, or none when it is missing or spread. */
+const expressionArgument = (node, index) => Option.filter(Arr.get(node.arguments, index), isExpression);
+const isStaticProperty = (property, name) => property.type === "Property" && !property.computed && (property.key.type === "Identifier" && property.key.name === name || property.key.type === "Literal" && property.key.value === name);
+/** Every non-computed property of an object literal named `name`, in source order. */
+const staticProperties = (node, name) => node.properties.filter((property) => isStaticProperty(property, name));
+//#endregion
+export { expressionArgument, staticProperties };

package/dist/rules/_effect-context.js

@@ -1,27 +1,32 @@
+import { ancestors } from "./_ast-ancestors.js";
 import { isStaticCall, isStaticMember } from "./_effect-namespaces.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
 //#region src/rules/_effect-context.ts
-const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const isFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+/** `Effect.gen(...)`, `Effect.fn(...)`, or `Effect.fnUntraced(...)` called with the program directly. */
+const directProgramKind = (callee, effectNamespaces) => {
+	if (isStaticMember(callee, effectNamespaces, "gen")) return Option.some("gen");
+	if (isStaticMember(callee, effectNamespaces, "fn")) return Option.some("fn");
+	if (isStaticMember(callee, effectNamespaces, "fnUntraced")) return Option.some("fnUntraced");
+	return Option.none();
+};
+/** `Effect.fn("name")(...)` or `Effect.fnUntraced(options)(...)` called with the program. */
+const curriedProgramKind = (callee, effectNamespaces) => {
+	if (isStaticCall(callee, effectNamespaces, "fn")) return Option.some("fn");
+	if (isStaticCall(callee, effectNamespaces, "fnUntraced")) return Option.some("fnUntraced");
+	return Option.none();
+};
+/** The kind of Effect program a function is the body of, when it is an argument of one. */
 const effectProgramKind = (node, effectNamespaces) => {
 	const parent = node.parent;
-	if (parent?.type !== "CallExpression" || !parent.arguments.includes(node)) return void 0;
-	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "gen")) return "gen";
-	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "fn")) return "fn";
-	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "fnUntraced")) return "fnUntraced";
-	if (parent.callee.type !== "CallExpression") return void 0;
-	if (isStaticCall(parent.callee, effectNamespaces, "fn")) return "fn";
-	if (isStaticCall(parent.callee, effectNamespaces, "fnUntraced")) return "fnUntraced";
-};
-const enclosingEffectProgram = (node, effectNamespaces) => {
-	let current = node.parent;
-	while (current !== void 0 && current !== null) {
-		if (isFunction(current)) {
-			const kind = effectProgramKind(current, effectNamespaces);
-			if (kind === void 0) return void 0;
-			return [current, kind];
-		}
-		current = current.parent;
-	}
+	if (parent?.type !== "CallExpression" || !parent.arguments.includes(node)) return Option.none();
+	const callee = parent.callee;
+	if (callee.type === "Super") return Option.none();
+	return Option.orElse(directProgramKind(callee, effectNamespaces), () => curriedProgramKind(callee, effectNamespaces));
 };
-const isInsideEffectProgram = (node, effectNamespaces) => enclosingEffectProgram(node, effectNamespaces) !== void 0;
+/** The nearest enclosing function, when it is the body of an Effect program. */
+const enclosingEffectProgram = (node, effectNamespaces) => Option.flatMap(Arr.findFirst(ancestors(node), isFunction), (program) => Option.map(effectProgramKind(program, effectNamespaces), (kind) => [program, kind]));
+const isInsideEffectProgram = (node, effectNamespaces) => Option.isSome(enclosingEffectProgram(node, effectNamespaces));
 //#endregion
 export { enclosingEffectProgram, isInsideEffectProgram };

package/dist/rules/_function-metrics.js

@@ -1,5 +1,9 @@
+import { childNodesAt, isAstNode } from "./_ast-children.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 //#region src/rules/_function-metrics.ts
-const isNode = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+const isNode = (value) => isAstNode(value);
 const isFunctionType = (type) => type === "ArrowFunctionExpression" || type === "FunctionDeclaration" || type === "FunctionExpression";
 const isFunctionNode = (node) => isFunctionType(node.type);
 /** Slots that hold the parent link, source positions, or type-level syntax. */
@@ -26,12 +30,7 @@ const transparentTypeWrappers = new Set([
 	"TSInstantiationExpression"
 ]);
 const isTypeOnly = (node) => node.type.startsWith("TS") && !transparentTypeWrappers.has(node.type);
-const slot = (node, key) => {
-	const value = node[key];
-	if (isNode(value)) return [value];
-	if (Array.isArray(value)) return value.filter(isNode);
-	return [];
-};
+const slot = (node, key) => childNodesAt(node, key, isNode);
 /** Runtime child nodes of `node`, in source order of their slots. */
 const children = (node) => {
 	if (transparentTypeWrappers.has(node.type)) return slot(node, "expression");
@@ -44,8 +43,7 @@ const children = (node) => {
 };
 /** The nodes that form the body of a function unit: its parameters and its body. */
 const unitRoots = (fn) => {
-	const node = fn;
-	return [...slot(node, "params"), ...slot(node, "body")];
+	return [...slot(fn, "params"), ...slot(fn, "body")];
 };
 /**
 * Flatten a logical expression tree into its operator sequence, left to right.
@@ -81,7 +79,8 @@ const cognitiveComplexity = (fn) => {
 		for (const child of slot(node, key)) visit(child, nesting);
 	};
 	const visitIf = (node, nesting, isElseIf) => {
-		total += isElseIf ? 1 : 1 + nesting;
+		total += 1;
+		if (!isElseIf) total += nesting;
 		visitSlot(node, "test", nesting);
 		visitSlot(node, "consequent", nesting + 1);
 		for (const alternate of slot(node, "alternate")) if (alternate.type === "IfStatement") visitIf(alternate, nesting, true);
@@ -140,50 +139,61 @@ const halsteadDifficulty = (counts) => {
 };
 const functionOperator = (node) => {
 	if (node.type === "ArrowFunctionExpression") return "=>";
-	return node.generator === true ? "function*" : "function";
+	if (node.generator === true) return "function*";
+	return "function";
 };
 const literalOperand = (node) => {
-	if (typeof node.raw === "string") return node.raw;
-	if (typeof node.bigint === "string") return `${node.bigint}n`;
+	if (Predicate.isString(node.raw)) return node.raw;
+	if (Predicate.isString(node.bigint)) return `${node.bigint}n`;
 	return String(node.value);
 };
+const isNonEmpty = (text) => text.length > 0;
 const templateOperand = (node) => {
 	const value = node.value;
-	if (typeof value !== "object" || value === null) return null;
-	const raw = value.raw;
-	return typeof raw === "string" && raw.length > 0 ? raw : null;
+	if (!Predicate.hasProperty(value, "raw") || !Predicate.isString(value.raw)) return Option.none();
+	return Option.liftPredicate(value.raw, isNonEmpty);
 };
-/** Node types that always stand for the same operator tokens. */
-const fixedOperators = {
-	ForStatement: ["for"],
-	ForInStatement: ["for-in"],
-	WhileStatement: ["while"],
-	DoWhileStatement: ["do-while"],
-	SwitchStatement: ["switch"],
-	ReturnStatement: ["return"],
-	ThrowStatement: ["throw"],
-	CatchClause: ["catch"],
-	BreakStatement: ["break"],
-	ContinueStatement: ["continue"],
-	LabeledStatement: [":"],
-	DebuggerStatement: ["debugger"],
-	WithStatement: ["with"],
-	AssignmentPattern: ["="],
-	NewExpression: ["new"],
-	ArrayExpression: ["[]"],
-	ArrayPattern: ["[]"],
-	ObjectExpression: ["{}"],
-	ObjectPattern: ["{}"],
-	SpreadElement: ["..."],
-	RestElement: ["..."],
-	ConditionalExpression: ["?:"],
-	SequenceExpression: [","],
-	AwaitExpression: ["await"],
-	ImportExpression: ["import()"],
-	TemplateLiteral: ["`"],
-	JSXElement: ["<>"],
-	JSXFragment: ["<>"]
+/** `tokens` when `present`, otherwise none: the operator tokens of an optional clause. */
+const tokensIf = (present, ...tokens) => {
+	if (!present) return [];
+	return tokens;
 };
+/** The `name` of the node held in a slot, or empty when the slot holds none. */
+const slotName = (node, key) => Option.match(Arr.head(slot(node, key)), {
+	onNone: () => "",
+	onSome: (child) => String(child.name)
+});
+/** Node types that always stand for the same operator tokens. */
+const fixedOperators = new Map([
+	["ForStatement", ["for"]],
+	["ForInStatement", ["for-in"]],
+	["WhileStatement", ["while"]],
+	["DoWhileStatement", ["do-while"]],
+	["SwitchStatement", ["switch"]],
+	["ReturnStatement", ["return"]],
+	["ThrowStatement", ["throw"]],
+	["CatchClause", ["catch"]],
+	["BreakStatement", ["break"]],
+	["ContinueStatement", ["continue"]],
+	["LabeledStatement", [":"]],
+	["DebuggerStatement", ["debugger"]],
+	["WithStatement", ["with"]],
+	["AssignmentPattern", ["="]],
+	["NewExpression", ["new"]],
+	["ArrayExpression", ["[]"]],
+	["ArrayPattern", ["[]"]],
+	["ObjectExpression", ["{}"]],
+	["ObjectPattern", ["{}"]],
+	["SpreadElement", ["..."]],
+	["RestElement", ["..."]],
+	["ConditionalExpression", ["?:"]],
+	["SequenceExpression", [","]],
+	["AwaitExpression", ["await"]],
+	["ImportExpression", ["import()"]],
+	["TemplateLiteral", ["`"]],
+	["JSXElement", ["<>"]],
+	["JSXFragment", ["<>"]]
+]);
 /** Node types whose operator token carries the operator itself. */
 const operatorCarriers = new Set([
 	"BinaryExpression",
@@ -195,41 +205,53 @@ const operatorCarriers = new Set([
 /** Statement-level nodes whose operator tokens depend on the node's shape. */
 const statementOperators = (node) => {
 	switch (node.type) {
-		case "IfStatement": return isNode(node.alternate) ? ["if", "else"] : ["if"];
-		case "ForOfStatement": return node.await === true ? ["for-await-of"] : ["for-of"];
-		case "SwitchCase": return isNode(node.test) ? ["case"] : ["default"];
-		case "TryStatement": return isNode(node.finalizer) ? ["try", "finally"] : ["try"];
+		case "IfStatement": return ["if", ...tokensIf(isNode(node.alternate), "else")];
+		case "ForOfStatement":
+			if (node.await === true) return ["for-await-of"];
+			return ["for-of"];
+		case "SwitchCase":
+			if (isNode(node.test)) return ["case"];
+			return ["default"];
+		case "TryStatement": return ["try", ...tokensIf(isNode(node.finalizer), "finally")];
 		case "VariableDeclaration": return [String(node.kind)];
-		case "VariableDeclarator": return isNode(node.init) ? ["="] : [];
+		case "VariableDeclarator": return tokensIf(isNode(node.init), "=");
 		case "ClassDeclaration":
-		case "ClassExpression": return isNode(node.superClass) ? ["class", "extends"] : ["class"];
-		case "PropertyDefinition": return isNode(node.value) ? ["="] : [];
+		case "ClassExpression": return ["class", ...tokensIf(isNode(node.superClass), "extends")];
+		case "PropertyDefinition": return tokensIf(isNode(node.value), "=");
 		default: return [];
 	}
 };
+/** `?.` calls and accesses carry a leading `?`. */
+const optionalMark = (node) => {
+	if (node.optional === true) return "?";
+	return "";
+};
+const memberAccess = (node) => {
+	if (node.computed === true) return "[]";
+	return ".";
+};
 /** Expression-level nodes whose operator tokens depend on the node's shape. */
 const expressionOperators = (node) => {
 	if (operatorCarriers.has(node.type)) return [String(node.operator)];
 	switch (node.type) {
-		case "CallExpression": return node.optional === true ? ["?.()"] : ["()"];
-		case "MemberExpression": {
-			const access = node.computed === true ? "[]" : ".";
-			return node.optional === true ? [`?${access}`] : [access];
-		}
+		case "CallExpression": return [`${optionalMark(node)}()`];
+		case "MemberExpression": return [`${optionalMark(node)}${memberAccess(node)}`];
 		case "Property":
 			if (node.kind === "get" || node.kind === "set") return [String(node.kind)];
-			return node.shorthand === true || node.method === true ? [] : [":"];
-		case "YieldExpression": return node.delegate === true ? ["yield*"] : ["yield"];
-		case "JSXAttribute": return isNode(node.value) ? ["="] : [];
+			return tokensIf(node.shorthand !== true && node.method !== true, ":");
+		case "YieldExpression":
+			if (node.delegate === true) return ["yield*"];
+			return ["yield"];
+		case "JSXAttribute": return tokensIf(isNode(node.value), "=");
 		case "ArrowFunctionExpression":
 		case "FunctionDeclaration":
-		case "FunctionExpression": return node.async === true ? ["async", functionOperator(node)] : [functionOperator(node)];
+		case "FunctionExpression": return [...tokensIf(node.async === true, "async"), functionOperator(node)];
 		default: return [];
 	}
 };
 /** Every operator token a node stands for. */
 const operatorsOf = (node) => [
-	...fixedOperators[node.type] ?? [],
+	...fixedOperators.get(node.type) ?? [],
 	...statementOperators(node),
 	...expressionOperators(node)
 ];
@@ -237,18 +259,15 @@ const operatorsOf = (node) => [
 const operandOf = (node) => {
 	switch (node.type) {
 		case "Identifier":
-		case "JSXIdentifier": return String(node.name);
-		case "PrivateIdentifier": return `#${String(node.name)}`;
-		case "Literal": return literalOperand(node);
+		case "JSXIdentifier": return Option.some(String(node.name));
+		case "PrivateIdentifier": return Option.some(`#${String(node.name)}`);
+		case "Literal": return Option.some(literalOperand(node));
 		case "TemplateElement": return templateOperand(node);
-		case "ThisExpression": return "this";
-		case "Super": return "super";
-		case "MetaProperty": return `${isNode(node.meta) ? String(node.meta.name) : ""}.${isNode(node.property) ? String(node.property.name) : ""}`;
-		case "JSXText": {
-			const text = String(node.value).trim();
-			return text.length > 0 ? text : null;
-		}
-		default: return null;
+		case "ThisExpression": return Option.some("this");
+		case "Super": return Option.some("super");
+		case "MetaProperty": return Option.some(`${slotName(node, "meta")}.${slotName(node, "property")}`);
+		case "JSXText": return Option.liftPredicate(String(node.value).trim(), isNonEmpty);
+		default: return Option.none();
 	}
 };
 /**
@@ -266,7 +285,7 @@ const halstead = (fn) => {
 		if (isTypeOnly(node)) return;
 		for (const operator of operatorsOf(node)) tally(operators, operator);
 		const operand = operandOf(node);
-		if (operand !== null) tally(operands, operand);
+		if (Option.isSome(operand)) tally(operands, operand.value);
 		if (isFunctionType(node.type) || node.type === "MetaProperty") return;
 		for (const child of children(node)) visit(child);
 	};

package/dist/rules/_tagged-control-flow.js

@@ -1,79 +1,57 @@
+import { ancestors } from "./_ast-ancestors.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 //#region src/rules/_tagged-control-flow.ts
 const expressionKey = (node) => {
-	if (node.type === "Identifier") return node.name;
-	if (node.type === "ThisExpression") return "this";
-	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return null;
-	const object = expressionKey(node.object);
-	if (object === null) return null;
-	return `${object}.${node.property.name}`;
+	if (node.type === "Identifier") return Option.some(node.name);
+	if (node.type === "ThisExpression") return Option.some("this");
+	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return Option.none();
+	const property = node.property.name;
+	return Option.map(expressionKey(node.object), (object) => `${object}.${property}`);
 };
 const stringLiteral = (node) => {
-	if (node.type !== "Literal") return null;
-	if (typeof node.value !== "string") return null;
-	return node.value;
+	if (node.type !== "Literal" || !Predicate.isString(node.value)) return Option.none();
+	return Option.some(node.value);
 };
 const taggedSubject = (node) => {
-	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier" || node.property.name !== "_tag") return null;
+	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier" || node.property.name !== "_tag") return Option.none();
 	return expressionKey(node.object);
 };
+/** `subjectSide._tag === "Tag"` read from one orientation of the comparison. */
+const orientedComparison = (subjectSide, tagSide) => Option.all({
+	subject: taggedSubject(subjectSide),
+	tag: stringLiteral(tagSide)
+});
 const tagComparison = (node) => {
-	if (node.type !== "BinaryExpression" || node.operator !== "===") return null;
-	const leftSubject = taggedSubject(node.left);
-	const rightTag = stringLiteral(node.right);
-	if (leftSubject !== null && rightTag !== null) return {
-		subject: leftSubject,
-		tag: rightTag
-	};
-	const rightSubject = taggedSubject(node.right);
-	const leftTag = stringLiteral(node.left);
-	if (rightSubject === null || leftTag === null) return null;
-	return {
-		subject: rightSubject,
-		tag: leftTag
-	};
+	if (node.type !== "BinaryExpression" || node.operator !== "===") return Option.none();
+	const { left, right } = node;
+	return Option.orElse(orientedComparison(left, right), () => orientedComparison(right, left));
 };
 const tagComparisonsInOr = (node) => {
-	if (node.type === "LogicalExpression" && node.operator === "||") {
-		const left = tagComparisonsInOr(node.left);
-		const right = tagComparisonsInOr(node.right);
-		if (left === null || right === null) return null;
-		return [...left, ...right];
-	}
-	const comparison = tagComparison(node);
-	if (comparison === null) return null;
-	return [comparison];
-};
-const hasOneTaggedSubject = (comparisons) => {
-	const first = comparisons[0];
-	if (first === void 0 || comparisons.length < 2) return false;
-	return comparisons.every((comparison) => comparison.subject === first.subject);
+	if (node.type === "LogicalExpression" && node.operator === "||") return Option.zipWith(tagComparisonsInOr(node.left), tagComparisonsInOr(node.right), (left, right) => [...left, ...right]);
+	return Option.map(tagComparison(node), (comparison) => [comparison]);
 };
+const hasOneTaggedSubject = (comparisons) => comparisons.length >= 2 && Option.exists(Arr.head(comparisons), (first) => comparisons.every((comparison) => comparison.subject === first.subject));
 const isEffectCall = (node, operation) => node.callee.type !== "Super" && node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.object.type === "Identifier" && node.callee.object.name === "Effect" && node.callee.property.type === "Identifier" && node.callee.property.name === operation;
-const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
-const effectCallbackLocation = (node, operation) => {
-	let current = node.parent;
-	while (current !== void 0 && current !== null) {
-		if (isFunction(current)) {
-			const call = current.parent;
-			if (call?.type !== "CallExpression" || !isEffectCall(call, operation)) return null;
-			const index = call.arguments.indexOf(current);
-			if (index < 0) return null;
-			return {
-				argumentCount: call.arguments.length,
-				index
-			};
-		}
-		current = current.parent;
-	}
-	return null;
-};
-const isInsideCatchAllHandler = (node) => {
-	const location = effectCallbackLocation(node, "catchAll");
-	if (location === null) return false;
+const isFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+const callbackLocation = (callback, operation) => {
+	const call = callback.parent;
+	if (call?.type !== "CallExpression" || !isEffectCall(call, operation)) return Option.none();
+	const index = call.arguments.indexOf(callback);
+	if (index < 0) return Option.none();
+	return Option.some({
+		argumentCount: call.arguments.length,
+		index
+	});
+};
+/** Where the nearest enclosing function sits among the arguments of an `Effect.<operation>` call. */
+const effectCallbackLocation = (node, operation) => Option.flatMap(Arr.findFirst(ancestors(node), isFunction), (callback) => callbackLocation(callback, operation));
+const isInsideCatchAllHandler = (node) => Option.exists(effectCallbackLocation(node, "catchAll"), (location) => {
 	let handlerIndex = 1;
 	if (location.argumentCount === 1) handlerIndex = 0;
 	return location.index === handlerIndex;
-};
+});
 const taggedSwitchSubject = (node) => taggedSubject(node.discriminant);
 //#endregion
 export { effectCallbackLocation, hasOneTaggedSubject, isEffectCall, isInsideCatchAllHandler, tagComparison, tagComparisonsInOr, taggedSwitchSubject };