oxlint-plugin-effect 0.13.0 → 0.15.0

package/dist/rules/prefer-match-tags-exhaustive.js

@@ -2,26 +2,23 @@ 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 { isInsideCatchAllHandler, tagComparison, taggedSwitchSubject } from "./_tagged-control-flow.js";
+import { hasOneTaggedSubject, isInsideCatchAllHandler, tagComparison, taggedSwitchSubject } from "./_tagged-control-flow.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/prefer-match-tags-exhaustive.ts
 const statementReturns = (statement) => {
 	if (statement.type === "ReturnStatement") return true;
 	if (statement.type !== "BlockStatement") return false;
-	const last = statement.body.at(-1);
-	if (last === void 0) return false;
-	return statementReturns(last);
+	return Option.exists(Arr.last(statement.body), statementReturns);
 };
-const caseReturns = (switchCase) => {
-	const last = switchCase.consequent.at(-1);
-	if (last === void 0) return false;
-	return statementReturns(last);
-};
-const isCompleteTransformationShape = (node) => {
-	if (node.cases.length < 2 || taggedSwitchSubject(node) === null) return false;
+const caseReturns = (switchCase) => Option.exists(Arr.last(switchCase.consequent), statementReturns);
+const isCompleteSwitchTransformation = (node) => {
+	if (node.cases.length < 2 || Option.isNone(taggedSwitchSubject(node))) return false;
 	for (const switchCase of node.cases) {
-		if (switchCase.test === null || switchCase.test.type !== "Literal") return false;
-		if (typeof switchCase.test.value !== "string" || !caseReturns(switchCase)) return false;
+		if (switchCase.test?.type !== "Literal") return false;
+		if (!Predicate.isString(switchCase.test.value) || !caseReturns(switchCase)) return false;
 	}
 	return true;
 };
@@ -30,45 +27,36 @@ const isTerminalStatement = (node) => {
 	if (node.parent?.type !== "BlockStatement") return true;
 	return node.parent.body.at(-1) === node;
 };
-const isCompleteIfTransformationShape = (node) => {
-	if (isElseIf(node) || !isTerminalStatement(node)) return false;
+const isPlainIf = (statement) => statement.type === "IfStatement" && Predicate.isNull(statement.alternate);
+/** The tag a branch compares, when the branch always returns. */
+const returningTagComparison = (branch) => Option.filter(tagComparison(branch.test), () => statementReturns(branch.consequent));
+/** Whether at least two returning branches each compare one subject against a distinct tag. */
+const isDistinctTagDispatch = (branches) => Option.exists(Option.all(branches.map(returningTagComparison)), (comparisons) => hasOneTaggedSubject(comparisons) && new Set(comparisons.map((comparison) => comparison.tag)).size === comparisons.length);
+/** The if statement and each `else if` after it; none when the chain ends in a plain else. */
+const elseIfChain = (node) => {
+	const chain = [node];
 	let current = node;
-	let subject;
-	const tags = /* @__PURE__ */ new Set();
-	let branchCount = 0;
-	while (true) {
-		const comparison = tagComparison(current.test);
-		if (comparison === null || !statementReturns(current.consequent)) return false;
-		if (subject !== void 0 && comparison.subject !== subject) return false;
-		if (tags.has(comparison.tag)) return false;
-		subject = comparison.subject;
-		tags.add(comparison.tag);
-		branchCount += 1;
-		if (current.alternate === null) break;
-		if (current.alternate.type !== "IfStatement") return false;
+	while (current.alternate?.type === "IfStatement") {
 		current = current.alternate;
+		chain.push(current);
 	}
-	return branchCount >= 2;
+	if (Predicate.isNotNull(current.alternate)) return Option.none();
+	return Option.some(chain);
+};
+const isCompleteIfTransformation = (node) => {
+	if (isElseIf(node) || !isTerminalStatement(node)) return false;
+	return Option.exists(elseIfChain(node), isDistinctTagDispatch);
 };
-const isCompleteSequentialIfTransformationShape = (node) => {
-	if (node.alternate !== null || node.parent?.type !== "BlockStatement") return false;
+/** Whether `previous` is a returning tag check on the same subject, so `node` does not start a run. */
+const continuesRun = (previous, node) => Option.exists(previous, (statement) => isPlainIf(statement) && statementReturns(statement.consequent) && Option.exists(Option.all([tagComparison(statement.test), tagComparison(node.test)]), ([before, current]) => before.subject === current.subject));
+const isCompleteSequentialIfTransformation = (node) => {
+	if (!isPlainIf(node) || node.parent?.type !== "BlockStatement") return false;
 	const statements = node.parent.body;
 	const index = statements.indexOf(node);
 	if (index < 0) return false;
-	const comparison = tagComparison(node.test);
-	if (comparison === null || !statementReturns(node.consequent)) return false;
-	const previous = statements[index - 1];
-	if (previous?.type === "IfStatement" && previous.alternate === null) {
-		if (tagComparison(previous.test)?.subject === comparison.subject && statementReturns(previous.consequent)) return false;
-	}
-	const tags = new Set([comparison.tag]);
-	for (const statement of statements.slice(index + 1)) {
-		if (statement.type !== "IfStatement" || statement.alternate !== null) return false;
-		const next = tagComparison(statement.test);
-		if (next === null || next.subject !== comparison.subject || tags.has(next.tag) || !statementReturns(statement.consequent)) return false;
-		tags.add(next.tag);
-	}
-	return tags.size >= 2;
+	const run = statements.slice(index);
+	if (!run.every(isPlainIf) || continuesRun(Arr.get(statements, index - 1), node)) return false;
+	return isDistinctTagDispatch(run);
 };
 const preferMatchTagsExhaustive = define({
 	name: "prefer-match-tags-exhaustive",
@@ -80,14 +68,14 @@ const preferMatchTagsExhaustive = define({
 		const context = yield* RuleContext;
 		return {
 			SwitchStatement: (node) => {
-				if (!isCompleteTransformationShape(node) || isInsideCatchAllHandler(node)) return Effect.void;
+				if (!isCompleteSwitchTransformation(node) || isInsideCatchAllHandler(node)) return Effect.void;
 				return context.report(make({
 					node,
 					message: "Use Match.type with Match.tagsExhaustive so a new tagged variant requires a new case."
 				}));
 			},
 			IfStatement: (node) => {
-				if (!isCompleteIfTransformationShape(node) && !isCompleteSequentialIfTransformationShape(node) || isInsideCatchAllHandler(node)) return Effect.void;
+				if (!isCompleteIfTransformation(node) && !isCompleteSequentialIfTransformation(node) || isInsideCatchAllHandler(node)) return Effect.void;
 				return context.report(make({
 					node,
 					message: "Use Match.type with Match.tagsExhaustive so a new tagged variant requires a new branch."

package/dist/rules/prefer-predicate-is-tagged.js

@@ -3,15 +3,14 @@ import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { effectCallbackLocation, hasOneTaggedSubject, tagComparisonsInOr } from "./_tagged-control-flow.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/prefer-predicate-is-tagged.ts
-const isCatchIfPredicate = (node) => {
-	const location = effectCallbackLocation(node, "catchIf");
-	if (location === null) return false;
+const isCatchIfPredicate = (node) => Option.exists(effectCallbackLocation(node, "catchIf"), (location) => {
 	let predicateIndex = 1;
 	if (location.argumentCount === 2) predicateIndex = 0;
 	return location.index === predicateIndex;
-};
+});
 const preferPredicateIsTagged = define({
 	name: "prefer-predicate-is-tagged",
 	meta: meta({
@@ -24,8 +23,7 @@ const preferPredicateIsTagged = define({
 			if (node.operator !== "||") return Effect.void;
 			if (node.parent?.type === "LogicalExpression" && node.parent.operator === "||") return Effect.void;
 			if (isCatchIfPredicate(node)) return Effect.void;
-			const comparisons = tagComparisonsInOr(node);
-			if (comparisons === null || !hasOneTaggedSubject(comparisons)) return Effect.void;
+			if (!Option.exists(tagComparisonsInOr(node), hasOneTaggedSubject)) return Effect.void;
 			return context.report(make({
 				node,
 				message: "Use a named Predicate refinement composed from Predicate.isTagged for multiple tags."

package/dist/rules/prefer-service-of.js

@@ -2,33 +2,44 @@ 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, isStaticCall, 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/prefer-service-of.ts
+const isObjectExpression = (node) => node.type === "ObjectExpression";
+const returnedObjectStatement = (statement) => {
+	if (statement.type !== "ReturnStatement" || statement.argument?.type !== "ObjectExpression") return Option.none();
+	return Option.some(statement.argument);
+};
+/** The object a function argument returns: its expression body or its first returned object. */
 const returnedObject = (node) => {
-	if (node?.type !== "ArrowFunctionExpression" && node?.type !== "FunctionExpression") return;
-	if (node.body === null) return void 0;
-	if (node.body.type === "ObjectExpression") return node.body;
-	if (node.body.type !== "BlockStatement") return void 0;
-	for (const statement of node.body.body) if (statement.type === "ReturnStatement" && statement.argument?.type === "ObjectExpression") return statement.argument;
+	if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") return Option.none();
+	const body = node.body;
+	if (Predicate.isNull(body)) return Option.none();
+	if (body.type === "ObjectExpression") return Option.some(body);
+	if (body.type !== "BlockStatement") return Option.none();
+	return Arr.findFirst(body.body, returnedObjectStatement);
+};
+/** The object an `Effect.succeed(...)` or `Effect.gen(...)` implementation produces. */
+const effectImplementationObject = (implementation, effectNamespaces) => {
+	if (implementation.type !== "CallExpression" || implementation.callee.type === "Super") return Option.none();
+	if (isStaticMember(implementation.callee, effectNamespaces, "succeed")) return Option.filter(Arr.head(implementation.arguments), isObjectExpression);
+	if (isStaticCall(implementation, effectNamespaces, "gen")) return Option.flatMap(Arr.head(implementation.arguments), returnedObject);
+	return Option.none();
+};
+const layerImplementationObject = (callee, implementation, layerNamespaces, effectNamespaces) => {
+	if (isStaticMember(callee, layerNamespaces, "succeed")) return Option.liftPredicate(implementation, isObjectExpression);
+	if (isStaticMember(callee, layerNamespaces, "sync")) return returnedObject(implementation);
+	if (!isStaticMember(callee, layerNamespaces, "effect")) return Option.none();
+	return effectImplementationObject(implementation, effectNamespaces);
 };
 const implementationObject = (node, layerNamespaces, effectNamespaces) => {
-	if (node.callee.type === "Super" || node.arguments.length < 2) return void 0;
-	const implementation = node.arguments[1];
-	if (implementation === void 0 || implementation.type === "SpreadElement") return void 0;
-	if (isStaticMember(node.callee, layerNamespaces, "succeed")) {
-		if (implementation.type === "ObjectExpression") return implementation;
-		return;
-	}
-	if (isStaticMember(node.callee, layerNamespaces, "sync")) return returnedObject(implementation);
-	if (!isStaticMember(node.callee, layerNamespaces, "effect")) return void 0;
-	if (implementation.type !== "CallExpression" || implementation.callee.type === "Super") return;
-	if (isStaticMember(implementation.callee, effectNamespaces, "succeed")) {
-		const value = implementation.arguments[0];
-		if (value?.type === "ObjectExpression") return value;
-		return;
-	}
-	if (isStaticCall(implementation, effectNamespaces, "gen")) return returnedObject(implementation.arguments[0]);
+	const callee = node.callee;
+	if (callee.type === "Super") return Option.none();
+	return Option.flatMap(expressionArgument(node, 1), (implementation) => layerImplementationObject(callee, implementation, layerNamespaces, effectNamespaces));
 };
 const preferServiceOf = define({
 	name: "prefer-service-of",
@@ -52,11 +63,13 @@ const preferServiceOf = define({
 				const service = node.arguments[0];
 				if (service?.type !== "Identifier") return Effect.void;
 				const implementation = implementationObject(node, visibleNamespaces(ctx, node, layerNamespaces), visibleNamespaces(ctx, node, effectNamespaces));
-				if (implementation === void 0) return Effect.void;
-				return ctx.report(make({
-					node: implementation,
-					message: `Wrap this implementation with ${service.name}.of(...) so it stays checked against the service interface.`
-				}));
+				return Option.match(implementation, {
+					onNone: () => Effect.void,
+					onSome: (object) => ctx.report(make({
+						node: object,
+						message: `Wrap this implementation with ${service.name}.of(...) so it stays checked against the service interface.`
+					}))
+				});
 			}
 		};
 	}

package/dist/rules/require-named-effect-fn.js

@@ -3,9 +3,11 @@ 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 Effect from "effect/Effect";
 //#region src/rules/require-named-effect-fn.ts
-const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const isFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
 const requireNamedEffectFn = define({
 	name: "require-named-effect-fn",
 	meta: meta({
@@ -24,7 +26,7 @@ const requireNamedEffectFn = define({
 			CallExpression: (node) => {
 				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
 				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
-				if (!isStaticMember(node.callee, namespaces, "fn") || !isFunction(node.arguments[0])) return Effect.void;
+				if (!isStaticMember(node.callee, namespaces, "fn") || !Option.exists(Arr.head(node.arguments), isFunction)) return Effect.void;
 				return ctx.report(make({
 					node,
 					message: "Name this operation with Effect.fn(\"Domain.operation\") for stable tracing and diagnostics."

package/dist/rules/require-suppression-reason.d.ts

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

package/dist/rules/require-suppression-reason.js

@@ -0,0 +1,92 @@
+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 Effect from "effect/Effect";
+//#region src/rules/require-suppression-reason.ts
+/**
+* A directive at the start of a comment line, after any JSDoc `*` gutter.
+* The rules and reason run to the next directive or the end of the comment.
+*/
+const directivePattern = /(?:^|\n)[\t *]*(?<name>(?:oxlint|eslint)-disable(?:-next-line|-line)?|@effect-diagnostics(?:-next-line)?|@ts-(?:expect-error|ignore|nocheck))(?=$|[\s:])/gu;
+/** ESLint-style reason separator: `--` with whitespace on both sides. */
+const reasonSeparator = /\s--\s/u;
+const kindOf = (name) => {
+	if (name.startsWith("@ts-")) return "typescript";
+	if (name.startsWith("@effect-diagnostics")) return "effect-diagnostics";
+	return "lint";
+};
+const parseDirectives = (value) => {
+	const matches = [...value.matchAll(directivePattern)];
+	return matches.map((match, index) => {
+		const name = match.groups?.["name"] ?? "";
+		const start = match.index + match[0].length;
+		const end = matches[index + 1]?.index ?? value.length;
+		const padded = ` ${value.slice(start, end).replaceAll(/\n[\t *]*/gu, " ").trim()} `;
+		const separator = padded.search(reasonSeparator);
+		let targetText = padded;
+		let reason = "";
+		if (separator !== -1) {
+			targetText = padded.slice(0, separator);
+			reason = padded.slice(separator + 4);
+		}
+		return {
+			kind: kindOf(name),
+			name,
+			targets: targetText.split(/[\s,]+/u).filter((target) => target.length > 0),
+			reason: reason.trim()
+		};
+	});
+};
+const checkDirective = (directive) => {
+	const findings = [];
+	if (directive.kind !== "typescript" && directive.targets.length === 0) {
+		let example = "ruleName:off";
+		if (directive.kind === "lint") example = "rule-name";
+		findings.push({
+			messageId: "missingTarget",
+			data: {
+				directive: directive.name,
+				example
+			}
+		});
+	}
+	if (directive.kind === "effect-diagnostics") for (const target of directive.targets) {
+		if (!target.startsWith("effect/")) continue;
+		findings.push({
+			messageId: "effectPrefix",
+			data: {
+				target,
+				bare: target.slice(7)
+			}
+		});
+	}
+	if (directive.reason.length === 0) findings.push({
+		messageId: "missingReason",
+		data: { directive: directive.name }
+	});
+	return findings;
+};
+const requireSuppressionReason = define({
+	name: "require-suppression-reason",
+	meta: meta({
+		type: "problem",
+		description: "Require oxlint, ESLint, Effect diagnostics, and TypeScript suppressions to name what they disable and give a reason after ` -- `.",
+		messages: {
+			missingTarget: "`{{directive}}` must name what it disables, for example `{{directive}} {{example}} -- reason`. A blanket suppression hides every future finding on the code it covers.",
+			missingReason: "`{{directive}}` needs a reason after ` -- ` that says why the check does not apply here, so a reader can tell when the suppression can be removed.",
+			effectPrefix: "`@effect-diagnostics` ignores `{{target}}`: @effect/tsgo does not accept the `effect/` prefix. Write the bare rule name, `{{bare}}`."
+		}
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const checkComment = (comment) => Effect.forEach(parseDirectives(comment.value).flatMap(checkDirective), (finding) => ctx.report(fromId({
+			node: comment,
+			messageId: finding.messageId,
+			data: finding.data
+		})), { discard: true });
+		return { Program: () => Effect.forEach(ctx.sourceCode.getAllComments().filter((comment) => comment.type !== "Shebang"), checkComment, { discard: true }) };
+	}
+});
+//#endregion
+export { requireSuppressionReason };

package/dist/vendor/effect-oxlint/Diagnostic.js

@@ -112,4 +112,4 @@ const extractFixes = (result) => {
 */
 const composeFixes = (...fixes) => (fixer) => Arr.flatMap(fixes, (fn) => Array.from(extractFixes(fn(fixer))));
 //#endregion
-export { Diagnostic_exports, fromId, make, replaceText, withFix };
+export { Diagnostic_exports, fromId, make };

package/dist/vendor/effect-oxlint/Scope.js

@@ -107,4 +107,4 @@ const throughReferences = (scope) => scope.through;
 */
 const isStrict = (scope) => scope.isStrict;
 //#endregion
-export { Scope_exports, findVariableUp };
+export { Scope_exports, findVariableUp, getReferences, throughReferences, variables };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effect",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "oxlint plugin with Effect-specific lint rules",
   "license": "MIT",
   "repository": {
@@ -45,11 +45,12 @@
     "lint": "concurrently -n ox,effect -c yellow,blue \"oxlint\" \"bun run lint:effect\"",
     "lint:ox": "oxlint",
     "lint:effect": "effect-language-service diagnostics --project tsconfig.json --lspconfig \"$(cat .effect-lsp.json)\"",
+    "lint:self": "oxlint -c oxlint.self.config.ts src scripts tests",
     "lint:fix": "oxlint --fix",
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
     "test": "bun run build && bun test",
-    "gate": "concurrently -n type,style,generated,test -c blue,yellow,magenta,green \"bun run typecheck\" \"bun run lint\" \"bun run codegen:check\" \"bun run test\"",
+    "gate": "bun run build && concurrently -n type,style,self,generated,test -c blue,yellow,cyan,magenta,green \"bun run typecheck\" \"bun run lint\" \"bun run lint:self\" \"bun run codegen:check\" \"bun test\"",
     "codegen": "bun run scripts/codegen.ts",
     "codegen:check": "bun run scripts/codegen.ts --check",
     "add-rule": "bun run scripts/add-rule.ts",