oxlint-plugin-effect 0.14.0 → 0.16.0

package/dist/rules/no-reduce-accumulator-copy.js

@@ -2,7 +2,10 @@ import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
-import { arrayMethodTarget, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression } from "./_anti-slop-array-method.js";
+import { arrayMethodTarget, constInitializer, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression } from "./_anti-slop-array-method.js";
+import { ancestors } from "./_ast-ancestors.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-reduce-accumulator-copy.ts
 const arrayCopyMethods = new Set([
@@ -13,45 +16,64 @@ const arrayCopyMethods = new Set([
 	"toReversed",
 	"with"
 ]);
-function enclosingReducer(node) {
-	let parent = node.parent;
-	while (parent !== null) {
-		if (parent.type === "FunctionDeclaration") return null;
-		if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") {
-			const callback = parent;
-			let owner = callback.parent;
-			while (owner !== null && unwrapArrayExpression(owner) === callback) owner = owner.parent;
-			if (owner?.type !== "CallExpression") return null;
-			const method = arrayMethodTarget(owner.callee);
-			const firstArgument = owner.arguments[0];
-			if (method === null || method.name !== "reduce" && method.name !== "reduceRight" || owner.arguments.length > 2 || firstArgument === void 0 || unwrapArrayExpression(firstArgument) !== callback) return null;
-			const firstParameter = callback.params[0];
-			const accumulator = firstParameter?.type === "AssignmentPattern" ? firstParameter.left : firstParameter;
-			if (accumulator?.type !== "Identifier") return null;
-			return {
+const isCallback = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+const parameterBinding = (parameter) => {
+	if (parameter.type === "AssignmentPattern") return parameter.left;
+	return parameter;
+};
+const isReduceCall = (owner, callback) => Option.exists(arrayMethodTarget(owner.callee), (method) => method.name === "reduce" || method.name === "reduceRight") && owner.arguments.length <= 2 && Option.exists(Arr.head(owner.arguments), (firstArgument) => unwrapArrayExpression(firstArgument) === callback);
+function reducerForCallback(callback) {
+	const owner = Arr.findFirst(ancestors(callback), (node) => unwrapArrayExpression(node) !== callback);
+	return Option.flatMap(owner, (call) => {
+		if (call.type !== "CallExpression" || !isReduceCall(call, callback)) return Option.none();
+		return Option.flatMap(Arr.head(callback.params), (firstParameter) => {
+			const accumulator = parameterBinding(firstParameter);
+			if (accumulator.type !== "Identifier") return Option.none();
+			return Option.some({
 				callback,
 				accumulator,
-				initialValue: owner.arguments[1]
-			};
-		}
-		parent = parent.parent;
-	}
-	return null;
+				initialValue: Arr.get(call.arguments, 1)
+			});
+		});
+	});
+}
+function enclosingReducer(node) {
+	const boundary = Arr.findFirst(ancestors(node), (parent) => parent.type === "FunctionDeclaration" || isCallback(parent));
+	return Option.flatMap(boundary, (parent) => {
+		if (!isCallback(parent)) return Option.none();
+		return reducerForCallback(parent);
+	});
 }
 function referencesAccumulator(sourceCode, node, accumulator, visited = /* @__PURE__ */ new Set()) {
-	const variable = resolveArrayBinding(sourceCode, node);
-	if (variable === null || visited.has(variable)) return false;
-	if (variable === accumulator) return true;
-	visited.add(variable);
-	if (variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
-	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 referencesAccumulator(sourceCode, definition.node.init, accumulator, visited);
-	return false;
+	return Option.exists(resolveArrayBinding(sourceCode, node), (variable) => {
+		if (visited.has(variable)) return false;
+		if (variable === accumulator) return true;
+		visited.add(variable);
+		if (variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
+		return Option.exists(constInitializer(variable), (init) => referencesAccumulator(sourceCode, init, accumulator, visited));
+	});
 }
 function isGlobalCopyOwner(sourceCode, node, name) {
 	const owner = unwrapArrayExpression(node);
 	if (owner.type !== "Identifier" || owner.name !== name) return false;
-	const variable = resolveArrayBinding(sourceCode, owner);
-	return variable === null || variable.defs.length === 0;
+	return Option.match(resolveArrayBinding(sourceCode, owner), {
+		onNone: () => true,
+		onSome: (variable) => variable.defs.length === 0
+	});
+}
+function accumulatorCopyCandidate(sourceCode, node) {
+	const lookups = Option.all({
+		method: arrayMethodTarget(node.callee),
+		reducer: enclosingReducer(node)
+	});
+	return Option.flatMap(lookups, ({ method, reducer }) => {
+		const accumulator = Arr.findFirst(sourceCode.getDeclaredVariables(reducer.callback), (variable) => variable.identifiers.some((identifier) => identifier.start === reducer.accumulator.start));
+		return Option.map(accumulator, (variable) => ({
+			method,
+			reducer,
+			accumulator: variable
+		}));
+	});
 }
 /** Reject non-spread copies of reducer accumulators; pair with oxc/no-accumulating-spread. */
 const noReduceAccumulatorCopy = define({
@@ -64,30 +86,20 @@ const noReduceAccumulatorCopy = define({
 	create: function* () {
 		const context = yield* RuleContext;
 		const { sourceCode } = context;
-		const copiesAccumulator = (node) => {
-			const method = arrayMethodTarget(node.callee);
-			if (method === null) return false;
-			const reducer = enclosingReducer(node);
-			if (reducer === null) return false;
-			const accumulator = sourceCode.getDeclaredVariables(reducer.callback).find((variable) => variable.identifiers.some((identifier) => identifier.start === reducer.accumulator.start));
-			if (accumulator === void 0) return false;
+		const copiesAccumulator = (node, { method, reducer, accumulator }) => {
 			const isAccumulator = (expression) => referencesAccumulator(sourceCode, expression, accumulator);
-			if (method.name === "assign" && isGlobalCopyOwner(sourceCode, method.object, "Object")) {
-				const target = node.arguments[0];
-				return target !== void 0 && unwrapArrayExpression(target).type === "ObjectExpression" && node.arguments.slice(1).some(isAccumulator);
-			}
-			if (method.name === "from" && isGlobalCopyOwner(sourceCode, method.object, "Array")) {
-				const source = node.arguments[0];
-				return source !== void 0 && isAccumulator(source);
-			}
+			if (method.name === "assign" && isGlobalCopyOwner(sourceCode, method.object, "Object")) return Option.exists(Arr.head(node.arguments), (target) => unwrapArrayExpression(target).type === "ObjectExpression") && node.arguments.slice(1).some(isAccumulator);
+			if (method.name === "from" && isGlobalCopyOwner(sourceCode, method.object, "Array")) return Option.exists(Arr.head(node.arguments), isAccumulator);
 			if (!arrayCopyMethods.has(method.name)) return false;
-			const initialValue = reducer.initialValue;
-			return initialValue !== void 0 && isKnownArrayExpression(sourceCode, initialValue) && isAccumulator(method.object);
+			return Option.exists(reducer.initialValue, (initialValue) => isKnownArrayExpression(sourceCode, initialValue)) && isAccumulator(method.object);
 		};
-		return { CallExpression: (node) => copiesAccumulator(node) ? context.report(fromId({
-			node,
-			messageId: "accumulatorCopy"
-		})) : Effect.void };
+		return { CallExpression: (node) => {
+			if (!Option.exists(accumulatorCopyCandidate(sourceCode, node), (candidate) => copiesAccumulator(node, candidate))) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "accumulatorCopy"
+			}));
+		} };
 	}
 });
 //#endregion

package/dist/rules/no-reflect-apply.js

@@ -15,10 +15,13 @@ const noReflectApply = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		return { CallExpression: (node) => node.callee.type !== "Super" && isGlobalReflectMethodCall(context.sourceCode, node.callee, "apply") ? context.report(fromId({
-			node,
-			messageId: "reflectApply"
-		})) : Effect.void };
+		return { CallExpression: (node) => {
+			if (node.callee.type === "Super" || !isGlobalReflectMethodCall(context.sourceCode, node.callee, "apply")) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "reflectApply"
+			}));
+		} };
 	}
 });
 //#endregion

package/dist/rules/no-reflect-get.js

@@ -15,10 +15,13 @@ const noReflectGet = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		return { CallExpression: (node) => node.callee.type !== "Super" && isGlobalReflectMethodCall(context.sourceCode, node.callee, "get") ? context.report(fromId({
-			node,
-			messageId: "reflectGet"
-		})) : Effect.void };
+		return { CallExpression: (node) => {
+			if (node.callee.type === "Super" || !isGlobalReflectMethodCall(context.sourceCode, node.callee, "get")) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "reflectGet"
+			}));
+		} };
 	}
 });
 //#endregion

package/dist/rules/no-run-collect-on-unbounded-stream.js

@@ -2,7 +2,9 @@ import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import { expressionArgument } from "./_call-arguments.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-run-collect-on-unbounded-stream.ts
 const unboundedSources = new Set([
@@ -23,29 +25,25 @@ const terminatingOperations = new Set([
 ]);
 const staticOperation = (node, streamNamespaces, operations) => {
 	if (node.type === "SpreadElement") return false;
-	const candidate = node.type === "CallExpression" && node.callee.type !== "Super" ? node.callee : node;
+	let candidate = node;
+	if (node.type === "CallExpression" && node.callee.type !== "Super") candidate = node.callee;
 	for (const operation of operations) if (isStaticMember(candidate, streamNamespaces, operation)) return true;
 	return false;
 };
+const isPipeMember = (node) => node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier" && node.property.name === "pipe";
+const pipesTerminatingOperation = (node, streamNamespaces) => node.arguments.some((operation) => staticOperation(operation, streamNamespaces, terminatingOperations));
 const unboundedRoot = (node, streamNamespaces) => {
-	if (node.type !== "CallExpression" || node.callee.type === "Super") return void 0;
-	for (const source of unboundedSources) if (isStaticMember(node.callee, streamNamespaces, source)) return node;
-	if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "pipe") return;
-	const root = unboundedRoot(node.callee.object, streamNamespaces);
-	if (root === void 0) return void 0;
-	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, terminatingOperations)) return void 0;
-	return root;
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return Option.none();
+	for (const source of unboundedSources) if (isStaticMember(node.callee, streamNamespaces, source)) return Option.some(node);
+	if (!isPipeMember(node.callee)) return Option.none();
+	return Option.filter(unboundedRoot(node.callee.object, streamNamespaces), () => !pipesTerminatingOperation(node, streamNamespaces));
 };
 const collectedSource = (node, streamNamespaces) => {
-	if (node.callee.type === "Super") return void 0;
-	if (isStaticMember(node.callee, streamNamespaces, "runCollect")) {
-		const source = node.arguments[0];
-		if (source !== void 0 && source.type !== "SpreadElement") return source;
-		return;
-	}
-	if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "pipe") return;
-	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, terminatingOperations)) return void 0;
-	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, collectOperations)) return node.callee.object;
+	if (node.callee.type === "Super") return Option.none();
+	if (isStaticMember(node.callee, streamNamespaces, "runCollect")) return expressionArgument(node, 0);
+	if (!isPipeMember(node.callee) || pipesTerminatingOperation(node, streamNamespaces)) return Option.none();
+	if (!node.arguments.some((operation) => staticOperation(operation, streamNamespaces, collectOperations))) return Option.none();
+	return Option.some(node.callee.object);
 };
 const noRunCollectOnUnboundedStream = define({
 	name: "no-run-collect-on-unbounded-stream",
@@ -65,14 +63,14 @@ const noRunCollectOnUnboundedStream = define({
 			CallExpression: (node) => {
 				if (node.type !== "CallExpression") return Effect.void;
 				const namespaces = visibleNamespaces(ctx, node, streamNamespaces);
-				const source = collectedSource(node, namespaces);
-				if (source === void 0) return Effect.void;
-				const root = unboundedRoot(source, namespaces);
-				if (root === void 0) return Effect.void;
-				return ctx.report(make({
-					node: root,
-					message: "Do not collect a clearly unbounded Stream. Add a terminating operation or consume it with runForEach or runDrain."
-				}));
+				const root = Option.flatMap(collectedSource(node, namespaces), (source) => unboundedRoot(source, namespaces));
+				return Option.match(root, {
+					onNone: () => Effect.void,
+					onSome: (stream) => ctx.report(make({
+						node: stream,
+						message: "Do not collect a clearly unbounded Stream. Add a terminating operation or consume it with runForEach or runDrain."
+					}))
+				});
 			}
 		};
 	}

package/dist/rules/no-runtime-typeof.js

@@ -14,7 +14,8 @@ function isExistenceProbe(node) {
 		"==",
 		"!="
 	].includes(parent.operator)) return false;
-	const other = parent.left === node ? parent.right : parent.left;
+	let other = parent.left;
+	if (parent.left === node) other = parent.right;
 	return other.type === "Literal" && other.value === "undefined";
 }
 /** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
@@ -27,10 +28,13 @@ const noRuntimeTypeof = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		return { UnaryExpression: (node) => node.operator === "typeof" && !isExistenceProbe(node) ? context.report(fromId({
-			node,
-			messageId: "runtimeTypeof"
-		})) : Effect.void };
+		return { UnaryExpression: (node) => {
+			if (node.operator !== "typeof" || isExistenceProbe(node)) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "runtimeTypeof"
+			}));
+		} };
 	}
 });
 //#endregion

package/dist/rules/no-sequential-effect-all.js

@@ -2,19 +2,26 @@ import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import { expressionArgument, staticProperties } from "./_call-arguments.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-sequential-effect-all.ts
+const primitiveLiteral = (node) => {
+	if (node.type !== "Literal") return Option.none();
+	const value = node.value;
+	if (Predicate.isNull(value) || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return Option.some(node);
+	return Option.none();
+};
+/** The first primitive literal given for `name` in an options object literal. */
 const propertyLiteral = (node, name) => {
-	if (node?.type !== "ObjectExpression") return void 0;
-	for (const property of node.properties) {
-		if (property.type !== "Property" || property.computed) continue;
-		if ((property.key.type === "Identifier" && property.key.name === name || property.key.type === "Literal" && property.key.value === name) && property.value.type === "Literal") {
-			const value = property.value.value;
-			if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
-		}
-	}
+	if (node.type !== "ObjectExpression") return Option.none();
+	return Arr.findFirst(staticProperties(node, name), (property) => primitiveLiteral(property.value));
 };
+/** Whether the options set `name` to the literal `expected`. */
+const hasLiteralOption = (options, name, expected) => Option.exists(Option.flatMap(options, (node) => propertyLiteral(node, name)), (literal) => literal.value === expected);
 const pipedToAsVoid = (node, effectNamespaces) => {
 	const member = node.parent;
 	if (member?.type !== "MemberExpression" || member.object !== node || member.computed || member.property.type !== "Identifier" || member.property.name !== "pipe") return false;
@@ -46,9 +53,9 @@ const noSequentialEffectAll = define({
 				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
 				if (!isStaticMember(node.callee, namespaces, "all")) return Effect.void;
 				if (node.arguments[0]?.type !== "ArrayExpression") return Effect.void;
-				const options = node.arguments[1];
-				if (propertyLiteral(options, "concurrency") !== 1) return Effect.void;
-				if (!(propertyLiteral(options, "discard") === true || pipedToAsVoid(node, namespaces))) return Effect.void;
+				const options = expressionArgument(node, 1);
+				if (!hasLiteralOption(options, "concurrency", 1)) return Effect.void;
+				if (!(hasLiteralOption(options, "discard", true) || pipedToAsVoid(node, namespaces))) return Effect.void;
 				return ctx.report(make({
 					node,
 					message: "Use Effect.andThen or one flat generator for sequential steps. Reserve Effect.all for value aggregation or real concurrency."

package/dist/rules/no-shape-in-symbol-names.js

@@ -2,6 +2,7 @@ import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-shape-in-symbol-names.ts
 const forbiddenSymbolName = "shape";
@@ -11,7 +12,7 @@ function containsForbiddenSymbolName(name) {
 /** Return whether an identifier names a statically accessed member owned by another value. */
 function isBorrowedMemberName(node) {
 	const parent = node.parent;
-	if (parent === null || parent.type !== "MemberExpression") return false;
+	if (Predicate.isNull(parent) || parent.type !== "MemberExpression") return false;
 	return parent.property === node && !parent.computed;
 }
 /** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
@@ -24,11 +25,14 @@ const noShapeInSymbolNames = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		const reportForbiddenSymbolName = (node) => containsForbiddenSymbolName(node.name) && !isBorrowedMemberName(node) ? context.report(fromId({
-			node,
-			messageId: "forbiddenSymbolName",
-			data: { name: node.name }
-		})) : Effect.void;
+		const reportForbiddenSymbolName = (node) => {
+			if (!containsForbiddenSymbolName(node.name) || isBorrowedMemberName(node)) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "forbiddenSymbolName",
+				data: { name: node.name }
+			}));
+		};
 		return {
 			Identifier: reportForbiddenSymbolName,
 			PrivateIdentifier: reportForbiddenSymbolName,

package/dist/rules/no-silent-catch-all.js

@@ -3,20 +3,24 @@ import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-silent-catch-all.ts
-const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const isFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
 const isEffectVoid = (node, effectNamespaces) => isStaticMember(node, effectNamespaces, "void");
 const silentlyReturnsVoid = (node, effectNamespaces) => {
-	if (node.params.length !== 0 || node.body === null) return false;
-	if (node.body.type !== "BlockStatement") return isEffectVoid(node.body, effectNamespaces);
-	if (node.body.body.length !== 1) return false;
-	const statement = node.body.body[0];
-	return statement?.type === "ReturnStatement" && statement.argument !== null && isEffectVoid(statement.argument, effectNamespaces);
+	const body = node.body;
+	if (node.params.length !== 0 || Predicate.isNull(body)) return false;
+	if (body.type !== "BlockStatement") return isEffectVoid(body, effectNamespaces);
+	if (body.body.length !== 1) return false;
+	return Option.exists(Arr.head(body.body), (statement) => statement.type === "ReturnStatement" && Predicate.isNotNull(statement.argument) && isEffectVoid(statement.argument, effectNamespaces));
 };
+/** The handler of a data-last (one argument) or data-first catch call. */
 const handlerArgument = (node) => {
-	if (node.arguments.length === 1) return node.arguments[0];
-	return node.arguments[1];
+	if (node.arguments.length === 1) return Arr.get(node.arguments, 0);
+	return Arr.get(node.arguments, 1);
 };
 const noSilentCatchAll = define({
 	name: "no-silent-catch-all",
@@ -37,12 +41,14 @@ const noSilentCatchAll = define({
 				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
 				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
 				if (!(isStaticMember(node.callee, namespaces, "catchAll") || isStaticMember(node.callee, namespaces, "catchAllCause"))) return Effect.void;
-				const handler = handlerArgument(node);
-				if (!isFunction(handler) || !silentlyReturnsVoid(handler, namespaces)) return Effect.void;
-				return ctx.report(make({
-					node: handler,
-					message: "Do not erase every failure with Effect.void. Recover a typed failure truthfully or record the unexpected failure before recovery."
-				}));
+				const silentHandler = Option.filter(Option.filter(handlerArgument(node), isFunction), (handler) => silentlyReturnsVoid(handler, namespaces));
+				return Option.match(silentHandler, {
+					onNone: () => Effect.void,
+					onSome: (handler) => ctx.report(make({
+						node: handler,
+						message: "Do not erase every failure with Effect.void. Recover a typed failure truthfully or record the unexpected failure before recovery."
+					}))
+				});
 			}
 		};
 	}

package/dist/rules/no-test-globals.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-test-globals.d.ts
+declare const noTestGlobals: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noTestGlobals };

package/dist/rules/no-test-globals.js

@@ -0,0 +1,147 @@
+import { memberNames, narrow } from "../vendor/effect-oxlint/AST.js";
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import { findVariableUp, getReferences, throughReferences, variables } from "../vendor/effect-oxlint/Scope.js";
+import "../vendor/effect-oxlint/index.js";
+import { isTestFile, skipFile } from "./_test-files.js";
+import { collectTestBindings, resolveTestBinding } from "./_test-apis.js";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-test-globals.ts
+const globalRoots = new Set([
+	"global",
+	"globalThis",
+	"self",
+	"window"
+]);
+const mutatingCalls = new Map([["Object", new Set([
+	"assign",
+	"defineProperties",
+	"defineProperty"
+])], ["Reflect", new Set([
+	"defineProperty",
+	"deleteProperty",
+	"set"
+])]]);
+const stubbingMethods = new Set([
+	"replaceProperty",
+	"stubEnv",
+	"stubGlobal",
+	"unstubAllEnvs",
+	"unstubAllGlobals"
+]);
+const runnerGlobals = new Set([
+	"afterAll",
+	"afterEach",
+	"beforeAll",
+	"beforeEach",
+	"describe",
+	"expect",
+	"fdescribe",
+	"fit",
+	"it",
+	"jest",
+	"mock",
+	"spyOn",
+	"test",
+	"vi",
+	"xdescribe",
+	"xit",
+	"xtest"
+]);
+const capabilityHint = "Provide the capability through an Effect service or runtime input.";
+const innermostMember = (node) => {
+	if (node.object.type === "MemberExpression") return innermostMember(node.object);
+	return node;
+};
+const isStaticProperty = (node, name) => !node.computed && node.property.type === "Identifier" && node.property.name === name;
+/**
+* References to runner names that no import or declaration provides: unresolved
+* references, plus references to globals the linter configuration declares.
+*/
+const runnerGlobalReferences = (globalScope) => {
+	const ambient = variables(globalScope).filter((variable) => variable.defs.length === 0).flatMap((variable) => getReferences(variable));
+	return [...new Map([...throughReferences(globalScope), ...ambient].map((reference) => [reference.identifier, reference])).values()].filter((reference) => runnerGlobals.has(reference.identifier.name));
+};
+const noTestGlobals = define({
+	name: "no-test-globals",
+	meta: meta({
+		type: "problem",
+		description: "Keep tests off shared global state and implicit test globals."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		if (!isTestFile(ctx.filename)) return skipFile;
+		const bindings = /* @__PURE__ */ new Map();
+		const isUnshadowedGlobal = (node, name) => Option.match(findVariableUp(ctx.sourceCode.getScope(node), name), {
+			onNone: () => true,
+			onSome: (variable) => variable.defs.length === 0
+		});
+		const isGlobalRoot = (node) => node.type === "Identifier" && globalRoots.has(node.name) && isUnshadowedGlobal(node, node.name);
+		/** A global object, a member chain rooted at one, or a chain rooted at `process.env`. */
+		const isGlobalState = (node) => {
+			if (node.type !== "MemberExpression") return isGlobalRoot(node);
+			const innermost = innermostMember(node);
+			if (isGlobalRoot(innermost.object)) return true;
+			return innermost.object.type === "Identifier" && innermost.object.name === "process" && isStaticProperty(innermost, "env") && isUnshadowedGlobal(innermost, "process");
+		};
+		const reportWrite = (target) => {
+			if (target.type !== "MemberExpression" || !isGlobalState(target)) return Effect.void;
+			return ctx.report(make({
+				node: target,
+				message: `Avoid writing ${ctx.sourceCode.getText(target)} in tests. ${capabilityHint}`
+			}));
+		};
+		const mutatedGlobal = (call) => {
+			if (call.callee.type !== "MemberExpression") return Option.none();
+			const target = Option.filter(Option.fromUndefinedOr(call.arguments[0]), (argument) => argument.type !== "SpreadElement" && isGlobalState(argument));
+			if (Option.isNone(target)) return Option.none();
+			return Option.map(Option.filter(memberNames(call.callee), ([object, method]) => Option.exists(Option.fromUndefinedOr(mutatingCalls.get(object)), (methods) => methods.has(method)) && isUnshadowedGlobal(call, object)), ([object, method]) => `${object}.${method}() on ${ctx.sourceCode.getText(target.value)}`);
+		};
+		const stubbingCall = (call) => {
+			if (call.callee.type !== "MemberExpression") return Option.none();
+			const scope = ctx.sourceCode.getScope(call);
+			return Option.flatMap(Option.filter(memberNames(call.callee), ([, method]) => stubbingMethods.has(method)), ([object, method]) => Option.map(Option.filter(resolveTestBinding(scope, object, bindings), (binding) => binding === "jest" || binding === "vi"), (binding) => `${binding}.${method}()`));
+		};
+		const reportCall = (call) => Option.match(Option.orElse(mutatedGlobal(call), () => stubbingCall(call)), {
+			onNone: () => Effect.void,
+			onSome: (used) => ctx.report(make({
+				node: call,
+				message: `Avoid ${used} in tests. ${capabilityHint}`
+			}))
+		});
+		const reportRunnerGlobal = (reference) => ctx.report(make({
+			node: reference.identifier,
+			message: `Import ${reference.identifier.name} from your test library instead of using the runner global.`
+		}));
+		return {
+			ImportDeclaration: (node) => {
+				collectTestBindings(node, bindings);
+				return Effect.void;
+			},
+			AssignmentExpression: (node) => Option.match(narrow(node, "AssignmentExpression"), {
+				onNone: () => Effect.void,
+				onSome: (assignment) => reportWrite(assignment.left)
+			}),
+			UpdateExpression: (node) => Option.match(narrow(node, "UpdateExpression"), {
+				onNone: () => Effect.void,
+				onSome: (update) => reportWrite(update.argument)
+			}),
+			UnaryExpression: (node) => Option.match(Option.filter(narrow(node, "UnaryExpression"), (unary) => unary.operator === "delete"), {
+				onNone: () => Effect.void,
+				onSome: (unary) => reportWrite(unary.argument)
+			}),
+			CallExpression: (node) => Option.match(narrow(node, "CallExpression"), {
+				onNone: () => Effect.void,
+				onSome: reportCall
+			}),
+			"Program:exit": () => Option.match(Option.fromNullishOr(ctx.sourceCode.scopeManager.globalScope), {
+				onNone: () => Effect.void,
+				onSome: (globalScope) => Effect.forEach(runnerGlobalReferences(globalScope), reportRunnerGlobal, { discard: true })
+			})
+		};
+	}
+});
+//#endregion
+export { noTestGlobals };

package/dist/rules/no-test-lifecycle-hooks.js

@@ -6,6 +6,7 @@ import "../vendor/effect-oxlint/index.js";
 import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-test-lifecycle-hooks.ts
+/** Ban test lifecycle hooks in favor of Effect scopes and scoped test variants. */
 const lifecycleHooks = new Set([
 	"afterAll",
 	"afterEach",
@@ -23,8 +24,9 @@ const noTestLifecycleHooks = define({
 		return { CallExpression: (node) => Option.match(narrow(node, "CallExpression"), {
 			onNone: () => Effect.void,
 			onSome: (call) => {
-				const name = Option.getOrUndefined(calleeName(call));
-				if (name === void 0 || !lifecycleHooks.has(name)) return Effect.void;
+				const hook = Option.filter(calleeName(call), (name) => lifecycleHooks.has(name));
+				if (Option.isNone(hook)) return Effect.void;
+				const name = hook.value;
 				return ctx.report(make({
 					node: call,
 					message: `Avoid ${name}(). Use effect-bun-test scoped tests and Effect.acquireRelease for fixture lifecycles.`