oxlint-plugin-effect 0.7.0 → 0.8.0

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

@@ -0,0 +1,199 @@
+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/no-widen-then-assert.ts
+/**
+* Ported from dmmulroy/anti-slop at
+* b5d2288db1f00469a1d5f2e3b0e265e5a5676fd0.
+*/
+const functionBoundaryTypes = new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression"
+]);
+function unwrapExpressionParentheses(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function unwrapTypeParentheses(type) {
+	let current = type;
+	while (current.type === "TSParenthesizedType") current = current.typeAnnotation;
+	return current;
+}
+function typeReferenceName(type) {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isUnknownOrAnyType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	return unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword";
+}
+function isBroadRecordKeyType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") return true;
+	if (unwrapped.type === "TSUnionType") return unwrapped.types.every(isBroadRecordKeyType);
+	return unwrapped.type === "TSTypeReference" && typeReferenceName(unwrapped) === "PropertyKey";
+}
+function isBroadRecordType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSTypeReference") {
+		if (typeReferenceName(unwrapped) === "Readonly") {
+			const [inner] = unwrapped.typeArguments?.params ?? [];
+			return inner !== void 0 && isBroadRecordType(inner);
+		}
+		if (typeReferenceName(unwrapped) !== "Record") return false;
+		const parameters = unwrapped.typeArguments?.params ?? [];
+		return parameters.length === 2 && parameters[0] !== void 0 && parameters[1] !== void 0 && isBroadRecordKeyType(parameters[0]) && isUnknownOrAnyType(parameters[1]);
+	}
+	if (unwrapped.type !== "TSTypeLiteral" || unwrapped.members.length !== 1) return false;
+	const [member] = unwrapped.members;
+	const [parameter] = member?.type === "TSIndexSignature" ? member.parameters : [];
+	return member?.type === "TSIndexSignature" && member.parameters.length === 1 && parameter !== void 0 && isBroadRecordKeyType(parameter.typeAnnotation.typeAnnotation) && isUnknownOrAnyType(member.typeAnnotation.typeAnnotation);
+}
+function broadTypeKind(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword") return "top";
+	if (unwrapped.type === "TSObjectKeyword") return "object";
+	return isBroadRecordType(unwrapped) ? "record" : null;
+}
+function assertedExpression(node) {
+	return unwrapExpressionParentheses(node.expression);
+}
+function assertionFromExpression(expression) {
+	const unwrapped = unwrapExpressionParentheses(expression);
+	return unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion" ? unwrapped : null;
+}
+function normalizedTypeText(sourceText, type) {
+	return sourceText.slice(type.start, type.end).replaceAll(/\s+/gu, "");
+}
+function typesHaveSameSyntax(sourceText, left, right) {
+	return left !== null && normalizedTypeText(sourceText, unwrapTypeParentheses(left)) === normalizedTypeText(sourceText, unwrapTypeParentheses(right));
+}
+function isDefinitelyObjectType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	switch (unwrapped.type) {
+		case "TSArrayType":
+		case "TSConstructorType":
+		case "TSFunctionType":
+		case "TSMappedType":
+		case "TSObjectKeyword":
+		case "TSTupleType": return true;
+		case "TSTypeLiteral": return unwrapped.members.length > 0;
+		case "TSIntersectionType": return unwrapped.types.every(isDefinitelyObjectType);
+		case "TSTypeOperator": return unwrapped.operator === "readonly" && isDefinitelyObjectType(unwrapped.typeAnnotation);
+		default: return false;
+	}
+}
+function isDefinitelyNarrowerRecordType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.some((member) => member.type !== "TSIndexSignature");
+	if (unwrapped.type !== "TSTypeReference") return false;
+	if (typeReferenceName(unwrapped) === "Readonly") {
+		const [inner] = unwrapped.typeArguments?.params ?? [];
+		return inner !== void 0 && isDefinitelyNarrowerRecordType(inner);
+	}
+	if (typeReferenceName(unwrapped) !== "Record") return false;
+	const parameters = unwrapped.typeArguments?.params ?? [];
+	return parameters.length === 2 && parameters[1] !== void 0 && !isUnknownOrAnyType(parameters[1]);
+}
+function functionBoundary(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (functionBoundaryTypes.has(current.type)) return current;
+		current = current.parent;
+	}
+	return null;
+}
+function resolvedVariableForIdentifier(scopes, identifier) {
+	for (const scope of scopes) {
+		const reference = scope.references.find((candidate) => candidate.identifier.start === identifier.start && candidate.identifier.end === identifier.end);
+		if (reference !== void 0) return reference.resolved;
+	}
+	return null;
+}
+function variableDeclarator(variable) {
+	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator") return definition.node;
+	return null;
+}
+function knownValueEvidence(expression, scopes, boundary, visitedVariables) {
+	const unwrapped = unwrapExpressionParentheses(expression);
+	if (unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion") {
+		if (broadTypeKind(unwrapped.typeAnnotation) !== null) return null;
+		return { type: unwrapped.typeAnnotation };
+	}
+	if (unwrapped.type === "Literal" || unwrapped.type === "TemplateLiteral") return { type: null };
+	if (unwrapped.type === "ArrayExpression" || unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "ClassExpression" || unwrapped.type === "FunctionExpression" || unwrapped.type === "NewExpression" || unwrapped.type === "ObjectExpression") return { type: null };
+	if (unwrapped.type !== "Identifier") return null;
+	const variable = resolvedVariableForIdentifier(scopes, unwrapped);
+	if (variable === null || visitedVariables.has(variable)) return null;
+	const annotatedIdentifier = variable.identifiers.find((identifier) => identifier.typeAnnotation !== null && identifier.typeAnnotation !== void 0);
+	const annotation = annotatedIdentifier?.typeAnnotation?.typeAnnotation;
+	if (annotation !== void 0 && annotatedIdentifier !== void 0) {
+		if (functionBoundary(annotatedIdentifier) !== boundary || broadTypeKind(annotation) !== null) return null;
+		return { type: annotation };
+	}
+	const declarator = variableDeclarator(variable);
+	if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init) || functionBoundary(declarator) !== boundary) return null;
+	return knownValueEvidence(declarator.init, scopes, boundary, new Set([...visitedVariables, variable]));
+}
+function widenedBinding(variable, scopes) {
+	const declarator = variableDeclarator(variable);
+	if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.id.type !== "Identifier" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
+	const identifier = variable.identifiers.find((candidate) => candidate.start === declarator.id.start && candidate.end === declarator.id.end);
+	const boundary = functionBoundary(declarator);
+	const declaredType = identifier?.typeAnnotation?.typeAnnotation;
+	const initializerAssertion = assertionFromExpression(declarator.init);
+	const initializerBroadKind = initializerAssertion === null ? null : broadTypeKind(initializerAssertion.typeAnnotation);
+	const broadKind = (declaredType === void 0 ? null : broadTypeKind(declaredType)) ?? initializerBroadKind;
+	if (broadKind === null) return null;
+	const evidence = knownValueEvidence(initializerAssertion !== null && initializerBroadKind !== null ? assertedExpression(initializerAssertion) : declarator.init, scopes, boundary, new Set([variable]));
+	return evidence === null ? null : {
+		broadKind,
+		evidence,
+		declaredAt: declarator.end,
+		boundary
+	};
+}
+function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
+	if (broadTypeKind(assertedType) !== null) return false;
+	if (broadKind === "top") return true;
+	if (typesHaveSameSyntax(sourceText, evidence.type, assertedType)) return true;
+	if (broadKind === "object") return isDefinitelyObjectType(assertedType);
+	return isDefinitelyNarrowerRecordType(assertedType);
+}
+/** Detect immutable local bindings that erase a known type and are later asserted back to a narrower type. */
+const noWidenThenAssert = define({
+	name: "no-widen-then-assert",
+	meta: meta({
+		type: "problem",
+		description: "Disallow local const flows that explicitly widen a known value before asserting the widened binding to a narrower type.",
+		messages: { widenThenAssert: "Binding \"{{name}}\" erases established type evidence by widening the value, then reconstructs that evidence with a type assertion. Preserve the precise type end-to-end; if the input is genuinely unknown, parse it once at the boundary instead." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		const scopes = context.sourceCode.scopeManager.scopes;
+		const checkAssertion = (node) => {
+			const expression = assertedExpression(node);
+			if (expression.type !== "Identifier") return Effect.void;
+			const variable = resolvedVariableForIdentifier(scopes, expression);
+			if (variable === null) return Effect.void;
+			const widened = widenedBinding(variable, scopes);
+			if (widened === null || node.start <= widened.declaredAt || functionBoundary(node) !== widened.boundary || !assertionIsNarrower(context.sourceCode.text, widened.broadKind, widened.evidence, node.typeAnnotation)) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "widenThenAssert",
+				data: { name: expression.name }
+			}));
+		};
+		return {
+			TSAsExpression: checkAssertion,
+			TSTypeAssertion: checkAssertion
+		};
+	}
+});
+//#endregion
+export { noWidenThenAssert };

package/dist/rules/prefer-effect-fn.d.ts

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

package/dist/rules/prefer-effect-fn.js

@@ -0,0 +1,31 @@
+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 * as Effect from "effect/Effect";
+//#region src/rules/prefer-effect-fn.ts
+const isStaticMember = (node, object, property) => node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === object && node.property.type === "Identifier" && node.property.name === property;
+const isEffectGenCall = (node) => node.type === "CallExpression" && node.callee.type !== "Super" && isStaticMember(node.callee, "Effect", "gen");
+const isEffectWithSpanCall = (node) => node.type === "CallExpression" && node.callee.type !== "Super" && isStaticMember(node.callee, "Effect", "withSpan");
+const spansEffectGenDirectly = (node) => node.callee.type !== "Super" && node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" && node.callee.property.name === "withSpan" && isEffectGenCall(node.callee.object);
+const pipesOnlyWithSpanFromEffectGen = (node) => node.callee.type !== "Super" && node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" && node.callee.property.name === "pipe" && isEffectGenCall(node.callee.object) && node.arguments.length === 1 && node.arguments[0] !== void 0 && isEffectWithSpanCall(node.arguments[0]);
+const preferEffectFn = define({
+	name: "prefer-effect-fn",
+	meta: meta({
+		type: "suggestion",
+		description: "Use Effect.fn for a named generator operation."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (node.type !== "CallExpression") return Effect.void;
+			if (!spansEffectGenDirectly(node) && !pipesOnlyWithSpanFromEffectGen(node)) return Effect.void;
+			return ctx.report(make({
+				node,
+				message: "Avoid a span on Effect.gen. Define the named operation with Effect.fn."
+			}));
+		} };
+	}
+});
+//#endregion
+export { preferEffectFn };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effect",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "oxlint plugin with Effect-specific lint rules",
   "license": "MIT",
   "repository": {
@@ -8,7 +8,8 @@
     "url": "https://github.com/cevr/effect-oxlint"
   },
   "files": [
-    "dist"
+    "dist",
+    "THIRD_PARTY_NOTICES.md"
   ],
   "type": "module",
   "exports": {