oxlint-plugin-effect 0.13.0 → 0.14.0

package/dist/rules/no-unknown-type-aliases.js

@@ -2,13 +2,9 @@ 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 { createTypeAliasEnvironment, resolvedTypeMatches } from "./_anti-slop-type-alias-resolution.js";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unknown-type-aliases.ts
-function referencedAliasName(type) {
-	if (type.type === "TSParenthesizedType") return referencedAliasName(type.typeAnnotation);
-	if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier") return null;
-	return type.typeArguments === null || type.typeArguments === void 0 || type.typeArguments.params.length === 0 ? type.typeName.name : null;
-}
 /** Ban named aliases that merely conceal TypeScript's unknown top type. */
 const noUnknownTypeAliases = define({
 	name: "no-unknown-type-aliases",
@@ -19,29 +15,23 @@ const noUnknownTypeAliases = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		const aliases = /* @__PURE__ */ new Map();
-		const resolvesToUnknown = (type, visited = /* @__PURE__ */ new Set()) => {
-			if (type.type === "TSUnknownKeyword") return true;
-			if (type.type === "TSParenthesizedType") return resolvesToUnknown(type.typeAnnotation, visited);
-			const name = referencedAliasName(type);
-			if (name === null || visited.has(name)) return false;
-			const alias = aliases.get(name);
-			if (alias === void 0 || alias.typeParameters !== null && alias.typeParameters !== void 0) return false;
-			const nextVisited = new Set(visited);
-			nextVisited.add(name);
-			return resolvesToUnknown(alias.typeAnnotation, nextVisited);
-		};
-		return { Program: (node) => {
-			for (const statement of node.body) {
-				const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
-				if (declaration?.type === "TSTypeAliasDeclaration") aliases.set(declaration.id.name, declaration);
-			}
-			return Effect.forEach(aliases.values(), (alias) => resolvesToUnknown(alias.typeAnnotation, new Set([alias.id.name])) ? context.report(fromId({
-				node: alias.id,
+		let environment = null;
+		const resolvesToUnknown = (type) => environment !== null && resolvedTypeMatches(type, environment, (resolved, matches) => {
+			if (resolved.type === "TSUnknownKeyword") return true;
+			if (resolved.type === "TSParenthesizedType") return matches(resolved.typeAnnotation);
+			return resolved.type === "TSUnionType" && resolved.types.some(matches);
+		});
+		return {
+			Program: (node) => {
+				environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+				return Effect.void;
+			},
+			TSTypeAliasDeclaration: (node) => resolvesToUnknown(node.typeAnnotation) ? context.report(fromId({
+				node: node.id,
 				messageId: "unknownAlias",
-				data: { alias: alias.id.name }
-			})) : Effect.void, { discard: true });
-		} };
+				data: { alias: node.id.name }
+			})) : Effect.void
+		};
 	}
 });
 //#endregion

package/dist/rules/no-unsafe-dictionary-type.js

@@ -2,11 +2,51 @@ 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 { visibleTypeAlias } from "./_anti-slop-type-alias-resolution.js";
 import { classifyUnsafeDictionary, classifyUnsafeDictionaryValue, createTypeEnvironment } from "./_anti-slop-dictionary-types.js";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unsafe-dictionary-type.ts
+const typeNodeKinds = new Set([
+	"JSDocNonNullableType",
+	"JSDocNullableType",
+	"JSDocUnknownType",
+	"TSAnyKeyword",
+	"TSArrayType",
+	"TSBigIntKeyword",
+	"TSBooleanKeyword",
+	"TSConditionalType",
+	"TSConstructorType",
+	"TSFunctionType",
+	"TSImportType",
+	"TSIndexedAccessType",
+	"TSInferType",
+	"TSIntersectionType",
+	"TSIntrinsicKeyword",
+	"TSLiteralType",
+	"TSMappedType",
+	"TSNamedTupleMember",
+	"TSNeverKeyword",
+	"TSNullKeyword",
+	"TSNumberKeyword",
+	"TSObjectKeyword",
+	"TSParenthesizedType",
+	"TSStringKeyword",
+	"TSSymbolKeyword",
+	"TSTemplateLiteralType",
+	"TSThisType",
+	"TSTupleType",
+	"TSTypeLiteral",
+	"TSTypeOperator",
+	"TSTypePredicate",
+	"TSTypeQuery",
+	"TSTypeReference",
+	"TSUndefinedKeyword",
+	"TSUnionType",
+	"TSUnknownKeyword",
+	"TSVoidKeyword"
+]);
 function isTypeNode(node) {
-	return node.type.startsWith("TS") && node.type !== "TSTypeAnnotation";
+	return typeNodeKinds.has(node.type);
 }
 function typeReferenceName(type) {
 	return type.typeName.type === "Identifier" ? type.typeName.name : null;
@@ -22,9 +62,20 @@ function isInsideTypeAliasDeclaration(node) {
 function isPlainAliasConsumerUse(node, environment) {
 	if (node.type !== "TSTypeReference" || node.typeArguments?.params.length) return false;
 	const name = typeReferenceName(node);
-	return name !== null && environment.aliases.has(name) && !isInsideTypeAliasDeclaration(node);
+	return name !== null && visibleTypeAlias(name, node, environment.typeAliases) !== null && !isInsideTypeAliasDeclaration(node);
+}
+function isInsideTypeParameterConstraint(node) {
+	let child = node;
+	let parent = child.parent;
+	while (parent !== null && parent.type !== "Program") {
+		if (parent.type === "TSTypeParameter" && parent.constraint === child) return true;
+		child = parent;
+		parent = child.parent;
+	}
+	return false;
 }
 function shouldReportType(node, environment) {
+	if (isInsideTypeParameterConstraint(node)) return false;
 	if (isPlainAliasConsumerUse(node, environment)) return false;
 	if (classifyUnsafeDictionary(node, environment) === null) return false;
 	let current = node.parent;
@@ -57,7 +108,7 @@ const noUnsafeDictionaryType = define({
 		};
 		return {
 			Program: (node) => {
-				environment = createTypeEnvironment(node);
+				environment = createTypeEnvironment(node, context.sourceCode.visitorKeys);
 				return Effect.void;
 			},
 			TSTypeReference: reportIfUnsafe,

package/dist/rules/no-widen-then-assert.js

@@ -6,7 +6,7 @@ import * as Effect from "effect/Effect";
 //#region src/rules/no-widen-then-assert.ts
 /**
 * Ported from dmmulroy/anti-slop at
-* b5d2288db1f00469a1d5f2e3b0e265e5a5676fd0.
+* c44ef22ca116d0ba62a3ff663a0bd13a3f3fa40b.
 */
 const functionBoundaryTypes = new Set([
 	"ArrowFunctionExpression",

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,87 @@
+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);
+		const targetText = separator === -1 ? padded : padded.slice(0, separator);
+		const reason = separator === -1 ? "" : 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) {
+		const example = directive.kind === "lint" ? "rule-name" : "ruleName:off";
+		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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effect",
-  "version": "0.13.0",
+  "version": "0.14.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",