oxlint-plugin-effect 0.0.0 → 0.2.0

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

@@ -130,6 +130,16 @@ export const define = <Options = undefined>(
 // Metadata helper
 // ---------------------------------------------------------------------------
 
+/**
+ * Which Effect version a rule applies to.
+ *
+ * Stored on `meta.docs.effectVersion` so preset authors can filter rules
+ * per project. Default `both`, meaning the rule is version-agnostic.
+ *
+ * @since 0.2.0
+ */
+export type EffectVersion = 'v3' | 'v4' | 'both';
+
 /**
  * Build `RuleMeta` with sensible defaults.
  *
@@ -142,6 +152,7 @@ export const meta = (opts: {
 	readonly hasSuggestions?: boolean | undefined;
 	readonly messages?: Record<string, string> | undefined;
 	readonly docs?: RuleDocs | undefined;
+	readonly effectVersion?: EffectVersion | undefined;
 }): RuleMeta => ({
 	type: opts.type,
 	...(opts.fixable !== undefined ? { fixable: opts.fixable } : {}),
@@ -151,6 +162,7 @@ export const meta = (opts: {
 	...(opts.messages !== undefined ? { messages: opts.messages } : {}),
 	docs: {
 		description: opts.description,
+		effectVersion: opts.effectVersion ?? 'both',
 		...opts.docs
 	}
 });
@@ -172,7 +184,7 @@ export const banMember = (
 	opts: {
 		readonly message: string;
 		readonly meta?:
-			| { readonly type?: 'problem' | 'suggestion' }
+			| { readonly type?: 'problem' | 'suggestion'; readonly effectVersion?: EffectVersion }
 			| undefined;
 	}
 ): CreateRule =>
@@ -180,7 +192,8 @@ export const banMember = (
 		name: `ban-${obj}-${P.isString(prop) ? prop : Arr.join(prop, '-')}`,
 		meta: meta({
 			type: opts.meta?.type ?? 'suggestion',
-			description: opts.message
+			description: opts.message,
+			effectVersion: opts.meta?.effectVersion
 		}),
 		create: function* () {
 			const ctx = yield* RuleContext;
@@ -216,7 +229,7 @@ export const banImport = (
 	opts: {
 		readonly message: string;
 		readonly meta?:
-			| { readonly type?: 'problem' | 'suggestion' }
+			| { readonly type?: 'problem' | 'suggestion'; readonly effectVersion?: EffectVersion }
 			| undefined;
 	}
 ): CreateRule =>
@@ -224,7 +237,8 @@ export const banImport = (
 		name: 'ban-import',
 		meta: meta({
 			type: opts.meta?.type ?? 'suggestion',
-			description: opts.message
+			description: opts.message,
+			effectVersion: opts.meta?.effectVersion
 		}),
 		create: function* () {
 			const ctx = yield* RuleContext;
@@ -270,7 +284,7 @@ export const banCallOf = (
 	opts: {
 		readonly message: string;
 		readonly meta?:
-			| { readonly type?: 'problem' | 'suggestion' }
+			| { readonly type?: 'problem' | 'suggestion'; readonly effectVersion?: EffectVersion }
 			| undefined;
 	}
 ): CreateRule => {
@@ -279,7 +293,8 @@ export const banCallOf = (
 		name: `ban-call-${Arr.join(names, '-')}`,
 		meta: meta({
 			type: opts.meta?.type ?? 'suggestion',
-			description: opts.message
+			description: opts.message,
+			effectVersion: opts.meta?.effectVersion
 		}),
 		create: function* () {
 			const ctx = yield* RuleContext;
@@ -327,7 +342,7 @@ export const banNewExpr = (
 	opts: {
 		readonly message: string;
 		readonly meta?:
-			| { readonly type?: 'problem' | 'suggestion' }
+			| { readonly type?: 'problem' | 'suggestion'; readonly effectVersion?: EffectVersion }
 			| undefined;
 	}
 ): CreateRule => {
@@ -336,7 +351,8 @@ export const banNewExpr = (
 		name: `ban-new-${Arr.join(names, '-')}`,
 		meta: meta({
 			type: opts.meta?.type ?? 'suggestion',
-			description: opts.message
+			description: opts.message,
+			effectVersion: opts.meta?.effectVersion
 		}),
 		create: function* () {
 			const ctx = yield* RuleContext;
@@ -372,7 +388,7 @@ export const banStatement = (
 	opts: {
 		readonly message: string;
 		readonly meta?:
-			| { readonly type?: 'problem' | 'suggestion' }
+			| { readonly type?: 'problem' | 'suggestion'; readonly effectVersion?: EffectVersion }
 			| undefined;
 	}
 ): CreateRule =>
@@ -380,7 +396,8 @@ export const banStatement = (
 		name: `ban-${nodeType}`,
 		meta: meta({
 			type: opts.meta?.type ?? 'suggestion',
-			description: opts.message
+			description: opts.message,
+			effectVersion: opts.meta?.effectVersion
 		}),
 		create: function* () {
 			const ctx = yield* RuleContext;
@@ -396,195 +413,136 @@ 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'; readonly effectVersion?: EffectVersion }
+		| 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,
+			effectVersion: config.meta?.effectVersion
 		}),
 		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)
-					: [];
-
-			// 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)
-										})
-									)
-							})
-						)
-					: [];
+			const visitors: Array<EffectVisitor> = [];
 
-			// 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

@@ -8,20 +8,6 @@ import {
   noEffectBind,
   noOptionAs,
   noRuntimeRunFork,
-  noRunInEffect,
-  noGlobalFetch,
-  noGlobalConsole,
-  noGlobalDate,
-  noGlobalRandom,
-  noGlobalTimers,
-  noNewPromise,
-  noNewError,
-  noProcessEnv,
-  noNodeBuiltinImport,
-  noDynamicImport,
-  noThrowStatement,
-  noTryCatch,
-  noJsonParse,
 } from "../src/rules/index.js"
 
 // --- API ban rules ---
@@ -80,173 +66,3 @@ describe("noRuntimeRunFork", () => {
   })
 })
 
-describe("noRunInEffect", () => {
-  test("reports Effect.runSync", () => {
-    const result = Testing.runRule(noRunInEffect, "MemberExpression", Testing.memberExpr("Effect", "runSync"))
-    expect(result.length).toBe(1)
-  })
-
-  test("reports Effect.runPromise", () => {
-    const result = Testing.runRule(noRunInEffect, "MemberExpression", Testing.memberExpr("Effect", "runPromise"))
-    expect(result.length).toBe(1)
-  })
-
-  test("ignores Effect.gen", () => {
-    const result = Testing.runRule(noRunInEffect, "MemberExpression", Testing.memberExpr("Effect", "gen"))
-    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)
-  })
-})