oxlint-plugin-effect 0.0.0 → 0.1.0

package/src/rules/no-throw-statement.ts

@@ -1,13 +1,39 @@
 /**
- * Ban `throw` statements.
+ * Ban `throw` statements. Context-aware messaging.
  *
- * Use Effect.fail or tagged errors instead.
+ * Inside Effect.gen/fn: "Use yield* Effect.fail() or yield* new MyError()"
+ * Outside: "Model errors with Effect.fail() — wrap this function with Effect.fn"
  *
  * Source: effect convention — errors should be in the type system
  */
-import { Rule } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, Visitor, RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Ref from "effect/Ref"
 
-export const noThrowStatement = Rule.banStatement("ThrowStatement", {
-  message: "Avoid throw. Use Effect.fail with tagged errors.",
-  meta: { type: "problem" },
+import { makeEffectContextTracker } from "./_effect-context.js"
+
+export const noThrowStatement = Rule.define({
+  name: "no-throw-statement",
+  meta: Rule.meta({
+    type: "problem",
+    description: "Avoid throw. Use Effect.fail with tagged errors.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const [depth, tracker] = yield* makeEffectContextTracker
+
+    return Visitor.merge(tracker, {
+      ThrowStatement: (node) =>
+        Effect.flatMap(Ref.get(depth), (d) =>
+          ctx.report(
+            Diagnostic.make({
+              node,
+              message: d > 0
+                ? "Avoid throw inside Effect.gen/fn. Use yield* Effect.fail(new MyError()) or yield* new MyError() for yieldable errors."
+                : "Avoid throw. Model errors with Effect — wrap this function with Effect.fn and use Effect.fail with tagged errors.",
+            }),
+          ),
+        ),
+    })
+  },
 })

package/src/rules/no-try-catch.ts

@@ -1,14 +1,39 @@
 /**
- * Ban `try/catch` statements.
+ * Ban `try/catch` statements. Context-aware messaging.
  *
- * Model failures in Effect's typed error channel.
+ * Inside Effect.gen/fn: "Use Effect.try or Effect.tryPromise"
+ * Outside: "Wrap with Effect.fn and use Effect.try for error handling"
  *
  * Source: biome-effect-linting-rules/no-try-catch, language-service/tryCatchInEffectGen
  */
-import { Rule } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, Visitor, RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Ref from "effect/Ref"
 
-export const noTryCatch = Rule.banStatement("TryStatement", {
-  message:
-    "Avoid try/catch. Model failures in Effect's typed error channel using Effect.try or Effect.tryPromise.",
-  meta: { type: "suggestion" },
+import { makeEffectContextTracker } from "./_effect-context.js"
+
+export const noTryCatch = Rule.define({
+  name: "no-try-catch",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid try/catch. Use Effect.try or Effect.tryPromise.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const [depth, tracker] = yield* makeEffectContextTracker
+
+    return Visitor.merge(tracker, {
+      TryStatement: (node) =>
+        Effect.flatMap(Ref.get(depth), (d) =>
+          ctx.report(
+            Diagnostic.make({
+              node,
+              message: d > 0
+                ? "Avoid try/catch inside Effect.gen/fn. Use Effect.try({ try: () => ..., catch: (e) => new MyError({ cause: e }) })."
+                : "Avoid try/catch. Wrap this function with Effect.fn and use Effect.try or Effect.tryPromise for error handling.",
+            }),
+          ),
+        ),
+    })
+  },
 })

package/src/rules/no-unnecessary-arrow-block.ts

@@ -3,8 +3,7 @@
  *
  * Source: language-service/unnecessaryArrowBlock
  */
-import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 export const noUnnecessaryArrowBlock = Rule.define({

package/src/rules/no-unnecessary-effect-gen.ts

@@ -12,10 +12,8 @@
  * Source: language-service/unnecessaryEffectGen
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
 
 export const noUnnecessaryEffectGen = Rule.define({
   name: "no-unnecessary-effect-gen",

package/src/rules/no-unnecessary-pipe-chain.ts

@@ -0,0 +1,47 @@
+/**
+ * Ban `x.pipe(f).pipe(g)` — merge into `x.pipe(f, g)`.
+ *
+ * Source: language-service/unnecessaryPipeChain
+ */
+import type { ESTree } from "@oxlint/plugins"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+const isMethodPipe = (node: ESTree.Node): boolean => {
+  if (node.type !== "CallExpression") return false
+  const callee = (node as unknown as Record<string, unknown>)["callee"]
+  if (callee == null || typeof callee !== "object" || !("type" in callee)) return false
+  if (callee.type !== "MemberExpression") return false
+  const prop = (callee as unknown as Record<string, unknown>)["property"]
+  if (prop == null || typeof prop !== "object" || !("type" in prop)) return false
+  return prop.type === "Identifier" && "name" in prop && prop.name === "pipe"
+}
+
+export const noUnnecessaryPipeChain = Rule.define({
+  name: "no-unnecessary-pipe-chain",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid chaining .pipe().pipe(). Merge into a single .pipe() call.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!isMethodPipe(node)) return Effect.void
+        const callee = (node as unknown as Record<string, unknown>)["callee"] as Record<string, unknown>
+        const obj = callee["object"]
+        if (obj != null && typeof obj === "object" && isMethodPipe(obj as ESTree.Node)) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message:
+                "Unnecessary .pipe() chain. Merge into a single .pipe() call.",
+            }),
+          )
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-unnecessary-pipe.ts

@@ -6,8 +6,7 @@
  * Source: language-service/unnecessaryPipe
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 

package/src/vendor/effect-oxlint/Rule.ts

@@ -396,195 +396,133 @@ export const banStatement = (
 // ---------------------------------------------------------------------------
 
 /**
- * Specification for `banMultiple`: which patterns to ban under one rule.
+ * A single ban specification. Each spec carries its own message so
+ * diagnostics are specific to the exact pattern matched.
  *
- * @since 0.2.0
+ * @since 0.3.0
  */
-export interface BanMultipleSpec {
-	/** Bare identifier calls to ban (e.g. `'fetch'` or `['useState', 'useEffect']`). */
-	readonly calls?: string | ReadonlyArray<string> | undefined;
-	/** `new` expressions to ban (e.g. `'Date'` or `['Error', 'TypeError']`). */
-	readonly newExprs?: string | ReadonlyArray<string> | undefined;
-	/** Member expressions to ban: `[object, property | properties]` tuples. */
-	readonly members?:
-		| ReadonlyArray<
-				readonly [obj: string, prop: string | ReadonlyArray<string>]
-		  >
-		| undefined;
-	/** Import sources to ban (string or predicate). */
-	readonly imports?:
-		| ReadonlyArray<string | ((source: string) => boolean)>
-		| undefined;
-	/** Statement node types to ban (e.g. `'ThrowStatement'`). */
-	readonly statements?: ReadonlyArray<string> | undefined;
-}
+export type BanSpec =
+	| { readonly type: 'member'; readonly object: string; readonly property: string | ReadonlyArray<string>; readonly message: string }
+	| { readonly type: 'call'; readonly name: string | ReadonlyArray<string>; readonly message: string }
+	| { readonly type: 'new'; readonly name: string | ReadonlyArray<string>; readonly message: string }
+	| { readonly type: 'import'; readonly source: string | ((source: string) => boolean); readonly message: string }
+	| { readonly type: 'statement'; readonly nodeType: string; readonly message: string };
 
 /**
- * Create a rule that bans multiple patterns with a shared message.
- *
- * Combines call bans, `new` expression bans, member bans, import bans,
- * and statement bans into a single rule with merged visitors.
+ * Create a rule that bans multiple patterns, each with its own message.
  *
  * @example
  * ```ts
- * // Ban 5 loop statement types
- * Rule.banMultiple(
- *   {
- *     statements: [
- *       'ForStatement', 'ForInStatement', 'ForOfStatement',
- *       'WhileStatement', 'DoWhileStatement'
- *     ]
- *   },
- *   { message: 'Use Arr.map / Effect.forEach instead' }
- * )
- *
- * // Combine import + member bans
- * Rule.banMultiple(
- *   {
- *     imports: ['node:fs'],
- *     members: [['fs', ['readFileSync', 'writeFileSync']]]
- *   },
- *   { message: 'Use Effect FileSystem service' }
- * )
- *
- * // Combine new expression + member bans
- * Rule.banMultiple(
- *   {
- *     newExprs: 'Date',
- *     members: [['Date', 'now']]
- *   },
- *   { message: 'Use Clock service' }
- * )
+ * Rule.banMultiple({
+ *   name: "no-global-date",
+ *   meta: { type: "suggestion" },
+ *   specs: [
+ *     { type: "new", name: "Date", message: "Avoid new Date(). Use Clock service." },
+ *     { type: "member", object: "Date", property: "now", message: "Avoid Date.now(). Use Clock service." },
+ *   ],
+ * })
  * ```
  *
- * @since 0.2.0
+ * @since 0.3.0
  */
-export const banMultiple = (
-	spec: BanMultipleSpec,
-	opts: {
-		readonly name?: string | undefined;
-		readonly message: string;
-		readonly meta?:
-			| { readonly type?: 'problem' | 'suggestion' }
-			| undefined;
-	}
-): CreateRule =>
-	define({
-		name: opts.name ?? 'ban-multiple',
+export const banMultiple = (config: {
+	readonly name: string;
+	readonly meta?: { readonly type?: 'problem' | 'suggestion' } | undefined;
+	readonly specs: ReadonlyArray<BanSpec>;
+}): CreateRule => {
+	const description = config.specs.map((s) => s.message).join(' ');
+	return define({
+		name: config.name,
 		meta: meta({
-			type: opts.meta?.type ?? 'suggestion',
-			description: opts.message
+			type: config.meta?.type ?? 'suggestion',
+			description
 		}),
 		create: function* () {
 			const ctx = yield* RuleContext;
-			const report = (node: ESTree.Node) =>
-				ctx.report(makeDiagnostic({ node, message: opts.message }));
-
-			// Statement bans
-			const stmtVisitors: ReadonlyArray<EffectVisitor> =
-				spec.statements !== undefined
-					? Arr.map(
-							spec.statements,
-							(nodeType): EffectVisitor => ({
-								[nodeType]: report
-							})
-						)
-					: [];
 
-			// Call bans
-			const callVisitors: ReadonlyArray<EffectVisitor> =
-				spec.calls !== undefined
-					? ((names: ReadonlyArray<string>) => [
-							{
-								CallExpression: (node: ESTree.Node) =>
-									pipe(
-										AST.narrow(node, 'CallExpression'),
-										Option.flatMap(AST.calleeName),
-										Option.filter((n) =>
-											Arr.contains(names, n)
-										),
-										Option.match({
-											onNone: () => Effect.void,
-											onSome: () => report(node)
-										})
-									)
-							} satisfies EffectVisitor
-						])(P.isString(spec.calls) ? [spec.calls] : spec.calls)
-					: [];
+			const visitors: Array<EffectVisitor> = [];
 
-			// NewExpression bans
-			const newExprVisitors: ReadonlyArray<EffectVisitor> =
-				spec.newExprs !== undefined
-					? ((names: ReadonlyArray<string>) => [
-							{
-								NewExpression: (node: ESTree.Node) =>
-									pipe(
-										AST.narrow(node, 'NewExpression'),
-										Option.flatMap((n) =>
-											newExprCalleeName(n.callee)
-										),
-										Option.filter((n) =>
-											Arr.contains(names, n)
-										),
-										Option.match({
-											onNone: () => Effect.void,
-											onSome: () => report(node)
-										})
-									)
-							} satisfies EffectVisitor
-						])(
-							P.isString(spec.newExprs)
-								? [spec.newExprs]
-								: spec.newExprs
-						)
-					: [];
-
-			// Member bans
-			const memberVisitors: ReadonlyArray<EffectVisitor> =
-				spec.members !== undefined
-					? Arr.map(
-							spec.members,
-							([obj, prop]): EffectVisitor => ({
-								MemberExpression: (node: ESTree.Node) =>
-									pipe(
-										AST.narrow(node, 'MemberExpression'),
-										Option.flatMap(
-											AST.matchMember(obj, prop)
-										),
-										Option.match({
-											onNone: () => Effect.void,
-											onSome: (matched) => report(matched)
-										})
-									)
-							})
-						)
-					: [];
-
-			// Import bans
-			const importVisitors: ReadonlyArray<EffectVisitor> =
-				spec.imports !== undefined
-					? Arr.map(
-							spec.imports,
-							(source): EffectVisitor => ({
-								ImportDeclaration: (node: ESTree.Node) =>
-									pipe(
-										AST.narrow(node, 'ImportDeclaration'),
-										Option.flatMap(AST.matchImport(source)),
-										Option.match({
-											onNone: () => Effect.void,
-											onSome: (matched) => report(matched)
-										})
-									)
-							})
-						)
-					: [];
+			for (const spec of config.specs) {
+				switch (spec.type) {
+					case 'member': {
+						const report = (node: ESTree.Node) =>
+							ctx.report(makeDiagnostic({ node, message: spec.message }));
+						visitors.push({
+							MemberExpression: (node: ESTree.Node) =>
+								pipe(
+									AST.narrow(node, 'MemberExpression'),
+									Option.flatMap(AST.matchMember(spec.object, spec.property)),
+									Option.match({
+										onNone: () => Effect.void,
+										onSome: (matched) => report(matched)
+									})
+								)
+						});
+						break;
+					}
+					case 'call': {
+						const names = P.isString(spec.name) ? [spec.name] : spec.name;
+						const report = (node: ESTree.Node) =>
+							ctx.report(makeDiagnostic({ node, message: spec.message }));
+						visitors.push({
+							CallExpression: (node: ESTree.Node) =>
+								pipe(
+									AST.narrow(node, 'CallExpression'),
+									Option.flatMap(AST.calleeName),
+									Option.filter((n) => Arr.contains(names, n)),
+									Option.match({
+										onNone: () => Effect.void,
+										onSome: () => report(node)
+									})
+								)
+						});
+						break;
+					}
+					case 'new': {
+						const names = P.isString(spec.name) ? [spec.name] : spec.name;
+						const report = (node: ESTree.Node) =>
+							ctx.report(makeDiagnostic({ node, message: spec.message }));
+						visitors.push({
+							NewExpression: (node: ESTree.Node) =>
+								pipe(
+									AST.narrow(node, 'NewExpression'),
+									Option.flatMap((n) => newExprCalleeName(n.callee)),
+									Option.filter((n) => Arr.contains(names, n)),
+									Option.match({
+										onNone: () => Effect.void,
+										onSome: () => report(node)
+									})
+								)
+						});
+						break;
+					}
+					case 'import': {
+						const report = (node: ESTree.Node) =>
+							ctx.report(makeDiagnostic({ node, message: spec.message }));
+						visitors.push({
+							ImportDeclaration: (node: ESTree.Node) =>
+								pipe(
+									AST.narrow(node, 'ImportDeclaration'),
+									Option.flatMap(AST.matchImport(spec.source)),
+									Option.match({
+										onNone: () => Effect.void,
+										onSome: (matched) => report(matched)
+									})
+								)
+						});
+						break;
+					}
+					case 'statement': {
+						visitors.push({
+							[spec.nodeType]: (node: ESTree.Node) =>
+								ctx.report(makeDiagnostic({ node, message: spec.message }))
+						});
+						break;
+					}
+				}
+			}
 
-			return mergeVisitors(
-				...stmtVisitors,
-				...callVisitors,
-				...newExprVisitors,
-				...memberVisitors,
-				...importVisitors
-			);
+			return mergeVisitors(...visitors);
 		}
 	});
+};

package/tests/ban-rules.test.ts

@@ -9,19 +9,6 @@ import {
   noOptionAs,
   noRuntimeRunFork,
   noRunInEffect,
-  noGlobalFetch,
-  noGlobalConsole,
-  noGlobalDate,
-  noGlobalRandom,
-  noGlobalTimers,
-  noNewPromise,
-  noNewError,
-  noProcessEnv,
-  noNodeBuiltinImport,
-  noDynamicImport,
-  noThrowStatement,
-  noTryCatch,
-  noJsonParse,
 } from "../src/rules/index.js"
 
 // --- API ban rules ---
@@ -96,157 +83,3 @@ describe("noRunInEffect", () => {
     Testing.expectNoDiagnostics(result)
   })
 })
-
-// --- Global ban rules ---
-
-describe("noGlobalFetch", () => {
-  test("reports fetch()", () => {
-    const result = Testing.runRule(noGlobalFetch, "CallExpression", Testing.callExpr("fetch"))
-    expect(result.length).toBe(1)
-  })
-
-  test("ignores other calls", () => {
-    const result = Testing.runRule(noGlobalFetch, "CallExpression", Testing.callExpr("getData"))
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noGlobalConsole", () => {
-  test("reports console.log", () => {
-    const result = Testing.runRule(noGlobalConsole, "MemberExpression", Testing.memberExpr("console", "log"))
-    expect(result.length).toBe(1)
-  })
-
-  test("reports console.error", () => {
-    const result = Testing.runRule(noGlobalConsole, "MemberExpression", Testing.memberExpr("console", "error"))
-    expect(result.length).toBe(1)
-  })
-
-  test("ignores logger.log", () => {
-    const result = Testing.runRule(noGlobalConsole, "MemberExpression", Testing.memberExpr("logger", "log"))
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noGlobalDate", () => {
-  test("reports Date.now", () => {
-    const result = Testing.runRule(noGlobalDate, "MemberExpression", Testing.memberExpr("Date", "now"))
-    expect(result.length).toBe(1)
-  })
-
-  test("reports new Date()", () => {
-    const result = Testing.runRule(noGlobalDate, "NewExpression", Testing.newExpr("Date"))
-    expect(result.length).toBe(1)
-  })
-})
-
-describe("noGlobalRandom", () => {
-  test("reports Math.random", () => {
-    const result = Testing.runRule(noGlobalRandom, "MemberExpression", Testing.memberExpr("Math", "random"))
-    expect(result.length).toBe(1)
-  })
-})
-
-describe("noGlobalTimers", () => {
-  test("reports setTimeout", () => {
-    const result = Testing.runRule(noGlobalTimers, "CallExpression", Testing.callExpr("setTimeout"))
-    expect(result.length).toBe(1)
-  })
-
-  test("reports setInterval", () => {
-    const result = Testing.runRule(noGlobalTimers, "CallExpression", Testing.callExpr("setInterval"))
-    expect(result.length).toBe(1)
-  })
-})
-
-describe("noNewPromise", () => {
-  test("reports new Promise()", () => {
-    const result = Testing.runRule(noNewPromise, "NewExpression", Testing.newExpr("Promise"))
-    expect(result.length).toBe(1)
-  })
-})
-
-describe("noNewError", () => {
-  test("reports new Error()", () => {
-    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("Error"))
-    expect(result.length).toBe(1)
-  })
-
-  test("reports new TypeError()", () => {
-    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("TypeError"))
-    expect(result.length).toBe(1)
-  })
-
-  test("ignores new MyError()", () => {
-    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("MyError"))
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noProcessEnv", () => {
-  test("reports process.env", () => {
-    const result = Testing.runRule(noProcessEnv, "MemberExpression", Testing.memberExpr("process", "env"))
-    expect(result.length).toBe(1)
-  })
-})
-
-// --- Import ban rules ---
-
-describe("noNodeBuiltinImport", () => {
-  test("reports import from 'fs'", () => {
-    const result = Testing.runRule(noNodeBuiltinImport, "ImportDeclaration", Testing.importDecl("fs"))
-    expect(result.length).toBe(1)
-  })
-
-  test("reports import from 'node:fs'", () => {
-    const result = Testing.runRule(noNodeBuiltinImport, "ImportDeclaration", Testing.importDecl("node:fs"))
-    expect(result.length).toBe(1)
-  })
-
-  test("reports import from 'child_process'", () => {
-    const result = Testing.runRule(noNodeBuiltinImport, "ImportDeclaration", Testing.importDecl("child_process"))
-    expect(result.length).toBe(1)
-  })
-
-  test("ignores import from 'effect'", () => {
-    const result = Testing.runRule(noNodeBuiltinImport, "ImportDeclaration", Testing.importDecl("effect"))
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-// --- Statement ban rules ---
-
-describe("noThrowStatement", () => {
-  test("reports throw", () => {
-    const result = Testing.runRule(noThrowStatement, "ThrowStatement", Testing.throwStmt())
-    expect(result.length).toBe(1)
-  })
-})
-
-describe("noTryCatch", () => {
-  test("reports try/catch", () => {
-    const result = Testing.runRule(noTryCatch, "TryStatement", Testing.tryStmt())
-    expect(result.length).toBe(1)
-  })
-})
-
-describe("noDynamicImport", () => {
-  test("reports dynamic import()", () => {
-    const result = Testing.runRule(noDynamicImport, "ImportExpression", { type: "ImportExpression" } as never)
-    expect(result.length).toBe(1)
-  })
-})
-
-// --- JSON ---
-
-describe("noJsonParse", () => {
-  test("reports JSON.parse", () => {
-    const result = Testing.runRule(noJsonParse, "MemberExpression", Testing.memberExpr("JSON", "parse"))
-    expect(result.length).toBe(1)
-  })
-
-  test("reports JSON.stringify", () => {
-    const result = Testing.runRule(noJsonParse, "MemberExpression", Testing.memberExpr("JSON", "stringify"))
-    expect(result.length).toBe(1)
-  })
-})