oxlint-plugin-effect 0.13.0 → 0.15.0

package/README.md

@@ -34,10 +34,14 @@ If the project uses JSON configuration, copy the exported rule map into `rules`;
 | `effect/noThrowStatement`              | Bans every throw statement                                                                |
 | `effect/noNewPromise`                  | Bans new Promise, Promise calls, and Promise static APIs                                  |
 | `effect/noNewError`                    | Allows native Error values only as direct arguments to Effect.die, Cause.die, or Exit.die |
-| `effect/noNullish`                     | Bans null and undefined; permits `Object.create(null)` for prototype-free dictionaries   |
-| `effect/noModuleMocks`                 | Bans Vitest and Jest module mocks and method spies; use Effect service test layers        |
+| `effect/noNullish`                     | Bans null and undefined; permits `Object.create(null)` for prototype-free dictionaries    |
+| `effect/noModuleMocks`                 | Bans Vitest, Jest, and bun:test module mocks, mock functions, and spies; use test layers  |
+| `effect/noTestGlobals`                 | Bans global writes, global stubs, and implicit runner globals in test files               |
 | `effect/noTernary`                     | Bans conditional expressions while allowing ordinary if statements                        |
 | `effect/noManagedRuntimeInEffect`      | Keeps ManagedRuntime construction at non-Effect host boundaries                           |
+| `effect/noModuleLevelMutableState`     | Bans module-level `let` and `var` outside tests; hold shared state in a Layer-owned `Ref` |
+| `effect/noEagerAcquire`                | Bans `acquireRelease` acquires that build or capture the resource before acquire runs     |
+| `effect/noEffectRunInTests`            | Bans `Effect.run*` and `ManagedRuntime.make` in tests; use `it.effect` or `it.layer`      |
 | `effect/noInlineProvide`               | Keeps dependency provisioning at explicit composition boundaries                          |
 | `effect/noNestedEffectGen`             | Flattens directly yielded nested generators                                               |
 | `effect/noPerCallCacheConstruction`    | Constructs shared caches once in their owning layer                                       |
@@ -55,26 +59,34 @@ If the project uses JSON configuration, copy the exported rule map into `rules`;
 | `effect/preferPredicateIsTagged`       | Replaces combined `_tag` comparisons with a named `Predicate` refinement                  |
 | `effect/preferServiceOf`               | Checks inline Layer implementations through `Service.of`                                  |
 | `effect/requireNamedEffectFn`          | Requires stable names for `Effect.fn` operations                                          |
+| `effect/requireSuppressionReason`      | Requires lint, Effect, and TS suppressions to name their target and give a `--` reason    |
 | `effect/noGlobals`                     | Bans ambient capabilities with direct Effect replacements; allows `process.std*.isTTY`    |
 | `effect/noNodeBuiltinImport`           | Bans fully replaced Node modules and replaced operations from partial modules             |
 
+`effect/requireSuppressionReason` also rejects `@effect-diagnostics effect/name:off`: @effect/tsgo ignores the `effect/` prefix, so write the bare rule name. A blanket directive that covers its own line, such as a bare `// oxlint-disable-line` or a file-leading `/* eslint-disable */`, suppresses this rule's report too; oxlint applies the directive before the rule can report it.
+
 ## Anti-Slop Rules
 
 The recommended preset also includes these rules from
 [`dmmulroy/anti-slop`](https://github.com/dmmulroy/anti-slop):
 
-| Rule                                    | Contract                                                           |
-| --------------------------------------- | ------------------------------------------------------------------ |
-| `effect/noChainedTypeAssertions`        | Bans nested type assertions that invent type evidence              |
-| `effect/noConditionalEmptyObjectSpread` | Bans conditional spreads that use an empty object to omit fields   |
-| `effect/noKnownValueWidening`           | Bans broad target types that discard known value evidence          |
-| `effect/noObjectParameters`             | Bans the broad `object` type on function inputs                    |
-| `effect/noRuntimeTypeof`                | Requires boundary parsing instead of runtime `typeof` narrowing    |
-| `effect/noShapeInSymbolNames`           | Bans `shape` in symbol names                                       |
-| `effect/noUnknownParameters`            | Bans `unknown` inputs except an input named `cause`                |
-| `effect/noUnknownTypeAliases`           | Bans aliases that only hide `unknown`                              |
-| `effect/noUnsafeDictionaryType`         | Bans dictionaries with unsafe broad value types                    |
-| `effect/noWidenThenAssert`              | Bans local flows that widen known values and then assert them back |
+| Rule                                    | Contract                                                                         |
+| --------------------------------------- | -------------------------------------------------------------------------------- |
+| `effect/noArrayFilterMap`               | Bans adjacent array `filter`/`map` passes over a known array                     |
+| `effect/noChainedTypeAssertions`        | Bans nested type assertions that invent type evidence                            |
+| `effect/noConditionalEmptyObjectSpread` | Bans conditional spreads that use an empty object to omit fields                 |
+| `effect/noKnownValueWidening`           | Bans broad target types that discard known value evidence                        |
+| `effect/noObjectParameters`             | Bans the broad `object` type on function inputs                                  |
+| `effect/noReduceAccumulatorCopy`        | Bans copying a reducer accumulator on every iteration                            |
+| `effect/noReflectApply`                 | Bans `Reflect.apply`; call typed functions directly                              |
+| `effect/noReflectGet`                   | Bans `Reflect.get`; use typed property access                                    |
+| `effect/noRuntimeTypeof`                | Requires boundary parsing instead of `typeof` narrowing; allows existence probes |
+| `effect/noShapeInSymbolNames`           | Bans `shape` in symbol names                                                     |
+| `effect/noUnknownParameters`            | Bans `unknown` inputs except `cause`, type guards, and rejection reasons         |
+| `effect/noUnknownReturns`               | Bans return contracts of `unknown` or `Promise<unknown>`                         |
+| `effect/noUnknownTypeAliases`           | Bans aliases that only hide `unknown`                                            |
+| `effect/noUnsafeDictionaryType`         | Bans dictionaries with unsafe broad value types                                  |
+| `effect/noWidenThenAssert`              | Bans local flows that widen known values and then assert them back               |
 
 See `THIRD_PARTY_NOTICES.md` for the source revision and license.
 

package/THIRD_PARTY_NOTICES.md

@@ -1,8 +1,10 @@
 # Third-Party Notices
 
 The anti-slop rules include code derived from
-[`dmmulroy/anti-slop`](https://github.com/dmmulroy/anti-slop) at commit
-`b5d2288db1f00469a1d5f2e3b0e265e5a5676fd0`.
+[`dmmulroy/anti-slop`](https://github.com/dmmulroy/anti-slop), synced to commit
+`c44ef22ca116d0ba62a3ff663a0bd13a3f3fa40b`. The rejection-handler exemption in
+`noUnknownParameters` comes from the vendored copy in
+[`joelhooks/rat-stack`](https://github.com/joelhooks/rat-stack).
 
 MIT License
 

package/dist/presets/recommended.d.ts

@@ -14,17 +14,21 @@ declare const recommended: {
   readonly "effect/maxHalsteadDifficulty": readonly ["error", {
     readonly max: 79;
   }];
+  readonly "effect/noArrayFilterMap": "error";
   readonly "effect/noAs": "error";
   readonly "effect/noAsyncFunction": "error";
   readonly "effect/noChainedTypeAssertions": "error";
   readonly "effect/noConditionalEmptyObjectSpread": "error";
   readonly "effect/noDynamicImports": "error";
+  readonly "effect/noEagerAcquire": "error";
   readonly "effect/noEffectBind": "error";
   readonly "effect/noEffectDo": "error";
+  readonly "effect/noEffectRunInTests": "error";
   readonly "effect/noGlobals": "error";
   readonly "effect/noInlineProvide": "error";
   readonly "effect/noKnownValueWidening": "error";
   readonly "effect/noManagedRuntimeInEffect": "error";
+  readonly "effect/noModuleLevelMutableState": "error";
   readonly "effect/noModuleMocks": "error";
   readonly "effect/noNestedEffectGen": "error";
   readonly "effect/noNewError": "error";
@@ -33,18 +37,23 @@ declare const recommended: {
   readonly "effect/noNullish": "error";
   readonly "effect/noObjectParameters": "error";
   readonly "effect/noPerCallCacheConstruction": "error";
+  readonly "effect/noReduceAccumulatorCopy": "error";
+  readonly "effect/noReflectApply": "error";
+  readonly "effect/noReflectGet": "error";
   readonly "effect/noRunCollectOnUnboundedStream": "error";
   readonly "effect/noRuntimeTypeof": "error";
   readonly "effect/noSequentialEffectAll": "error";
   readonly "effect/noShapeInSymbolNames": "error";
   readonly "effect/noSilentCatchAll": "error";
   readonly "effect/noTernary": "error";
+  readonly "effect/noTestGlobals": "error";
   readonly "effect/noTestLifecycleHooks": "error";
   readonly "effect/noThrowStatement": "error";
   readonly "effect/noTryCatch": "error";
   readonly "effect/noUnboundedConcurrency": "error";
   readonly "effect/noUnboundedRetry": "error";
   readonly "effect/noUnknownParameters": "error";
+  readonly "effect/noUnknownReturns": "error";
   readonly "effect/noUnknownTypeAliases": "error";
   readonly "effect/noUnsafeDictionaryType": "error";
   readonly "effect/noWidenThenAssert": "error";
@@ -54,6 +63,7 @@ declare const recommended: {
   readonly "effect/preferPredicateIsTagged": "error";
   readonly "effect/preferServiceOf": "error";
   readonly "effect/requireNamedEffectFn": "error";
+  readonly "effect/requireSuppressionReason": "error";
 };
 //#endregion
 export { recommended };

package/dist/presets/recommended.js

@@ -8,17 +8,21 @@ const recommended = {
 	complexity: ["error", { max: 21 }],
 	"effect/maxCognitiveComplexity": ["error", { max: 21 }],
 	"effect/maxHalsteadDifficulty": ["error", { max: 79 }],
+	"effect/noArrayFilterMap": "error",
 	"effect/noAs": "error",
 	"effect/noAsyncFunction": "error",
 	"effect/noChainedTypeAssertions": "error",
 	"effect/noConditionalEmptyObjectSpread": "error",
 	"effect/noDynamicImports": "error",
+	"effect/noEagerAcquire": "error",
 	"effect/noEffectBind": "error",
 	"effect/noEffectDo": "error",
+	"effect/noEffectRunInTests": "error",
 	"effect/noGlobals": "error",
 	"effect/noInlineProvide": "error",
 	"effect/noKnownValueWidening": "error",
 	"effect/noManagedRuntimeInEffect": "error",
+	"effect/noModuleLevelMutableState": "error",
 	"effect/noModuleMocks": "error",
 	"effect/noNestedEffectGen": "error",
 	"effect/noNewError": "error",
@@ -27,18 +31,23 @@ const recommended = {
 	"effect/noNullish": "error",
 	"effect/noObjectParameters": "error",
 	"effect/noPerCallCacheConstruction": "error",
+	"effect/noReduceAccumulatorCopy": "error",
+	"effect/noReflectApply": "error",
+	"effect/noReflectGet": "error",
 	"effect/noRunCollectOnUnboundedStream": "error",
 	"effect/noRuntimeTypeof": "error",
 	"effect/noSequentialEffectAll": "error",
 	"effect/noShapeInSymbolNames": "error",
 	"effect/noSilentCatchAll": "error",
 	"effect/noTernary": "error",
+	"effect/noTestGlobals": "error",
 	"effect/noTestLifecycleHooks": "error",
 	"effect/noThrowStatement": "error",
 	"effect/noTryCatch": "error",
 	"effect/noUnboundedConcurrency": "error",
 	"effect/noUnboundedRetry": "error",
 	"effect/noUnknownParameters": "error",
+	"effect/noUnknownReturns": "error",
 	"effect/noUnknownTypeAliases": "error",
 	"effect/noUnsafeDictionaryType": "error",
 	"effect/noWidenThenAssert": "error",
@@ -47,7 +56,8 @@ const recommended = {
 	"effect/preferMatchTagsExhaustive": "error",
 	"effect/preferPredicateIsTagged": "error",
 	"effect/preferServiceOf": "error",
-	"effect/requireNamedEffectFn": "error"
+	"effect/requireNamedEffectFn": "error",
+	"effect/requireSuppressionReason": "error"
 };
 //#endregion
 export { recommended };

package/dist/rules/_anti-slop-array-method.js

@@ -0,0 +1,78 @@
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+//#region src/rules/_anti-slop-array-method.ts
+/** Unwrap syntax-only wrappers when inspecting array methods and accumulator references. */
+function unwrapArrayExpression(node) {
+	while (node.type === "ParenthesizedExpression" || node.type === "ChainExpression" || node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression") node = node.expression;
+	return node;
+}
+function* scopeChain(scope) {
+	let current = Option.some(scope);
+	while (Option.isSome(current)) {
+		yield current.value;
+		current = Option.fromNullOr(current.value.upper);
+	}
+}
+/** Resolve a local binding by scope, not by identifier spelling. */
+function resolveArrayBinding(sourceCode, node) {
+	node = unwrapArrayExpression(node);
+	if (node.type !== "Identifier") return Option.none();
+	const name = node.name;
+	return Arr.findFirst(scopeChain(sourceCode.getScope(node)), (scope) => Option.fromUndefinedOr(scope.set.get(name)));
+}
+/** Read static method names, including computed string literals, without evaluating expressions. */
+function arrayMethodTarget(node) {
+	node = unwrapArrayExpression(node);
+	if (node.type !== "MemberExpression") return Option.none();
+	const property = node.property;
+	if (!node.computed && property.type === "Identifier") return Option.some({
+		name: property.name,
+		object: node.object
+	});
+	if (node.computed && property.type === "Literal" && Predicate.isString(property.value)) return Option.some({
+		name: property.value,
+		object: node.object
+	});
+	return Option.none();
+}
+function isArrayAnnotation(type) {
+	if (type.type === "TSArrayType" || type.type === "TSTupleType") return true;
+	if (type.type === "TSParenthesizedType") return isArrayAnnotation(type.typeAnnotation);
+	if (type.type === "TSTypeOperator" && type.operator === "readonly") return isArrayAnnotation(type.typeAnnotation);
+	return type.type === "TSTypeReference" && type.typeName.type === "Identifier" && (type.typeName.name === "Array" || type.typeName.name === "ReadonlyArray");
+}
+/** Recognize local array evidence; unknown receivers and iterator pipelines are deliberately excluded. */
+function isKnownArrayExpression(sourceCode, node, visited = /* @__PURE__ */ new Set()) {
+	node = unwrapArrayExpression(node);
+	if (node.type === "ArrayExpression") return true;
+	if (node.type === "CallExpression") return Option.exists(arrayMethodTarget(node.callee), (method) => [
+		"map",
+		"filter",
+		"flatMap",
+		"slice",
+		"concat",
+		"toSorted",
+		"toReversed",
+		"toSpliced"
+	].includes(method.name) && isKnownArrayExpression(sourceCode, method.object, visited));
+	if (node.type !== "Identifier") return false;
+	return Option.exists(resolveArrayBinding(sourceCode, node), (variable) => isKnownArrayVariable(sourceCode, variable, visited));
+}
+function isKnownArrayVariable(sourceCode, variable, visited) {
+	if (visited.has(variable)) return false;
+	visited.add(variable);
+	if (variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
+	for (const identifier of variable.identifiers) {
+		const annotation = identifier.typeAnnotation?.typeAnnotation;
+		if (Predicate.isNotUndefined(annotation)) return isArrayAnnotation(annotation);
+	}
+	return Option.exists(constInitializer(variable), (init) => isKnownArrayExpression(sourceCode, init, visited));
+}
+/** The initializer of the first `const name = init` definition of a variable. */
+function constInitializer(variable) {
+	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && Predicate.isNotNull(definition.node.init) && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") return Option.some(definition.node.init);
+	return Option.none();
+}
+//#endregion
+export { arrayMethodTarget, constInitializer, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression };