oxlint-plugin-effect 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # oxlint-plugin-effect
 
+## 0.2.0
+
+### Minor Changes
+
+- [`5ecb6fd`](https://github.com/cevr/effect-oxlint/commit/5ecb6fd543d6183d34f037c407f0a9cc0defc5e6) Thanks [@cevr](https://github.com/cevr)! - Support v3/v4 dual-version codebases and add rule-version metadata.
+
+  **`tsgolint-effect` (Go type-aware linter):**
+
+  - `IsEffectPackageSymbol` now matches paths across all mainstream package managers (npm/yarn-classic `node_modules/effect`, pnpm `.pnpm/effect@`, bun isolated `.bun/effect@`, yarn berry `.yarn/cache/effect-npm-`) and the `effect-v3` alias used by dual-version projects. Previously, v3 code imported as `effect-v3` silently bypassed every type-aware rule.
+  - `IsEffectType`, `IsLayerType`, `IsStreamType`, `IsScopeType` now check the `~effect/*` brand property on types first, falling back to the symbol-name + path heuristic. More robust across package managers and future-proof against package-name changes.
+  - Added `Rule.EffectVersion` field (`"v3" | "v4" | "both"`, default `"both"`) for version-specific rules.
+
+  **`oxlint-plugin-effect` (JS AST linter):**
+
+  - Added `meta.docs.effectVersion` on rules (`"v3" | "v4" | "both"`, default `"both"`). Preset authors can filter rules per project version.
+  - Tagged the following rules as `"v3"` (they detect v3-only APIs): `noCatchAllToMapError`, `noEffectGenAdapter`, `noRuntimeRunFork`.
+  - **Renamed `noRunInEffect` → `noRunInEffectGen`.** The old rule fired globally (outside Effect context too — a bug). The new rule is context-aware via `makeEffectContextTracker` and only fires inside `Effect.gen`/`Effect.fn`. Expanded coverage to `Runtime.run{Sync,Promise,Fork,Callback}`. Explicitly permits `Effect.run*With` (v4 explicit-services variants) and `<identifier>.run*` (ManagedRuntime-shaped calls) — both are legitimate at callback boundaries. Preset users must update `"effect/noRunInEffect"` references to `"effect/noRunInEffectGen"`.
+
 ## 0.1.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effect",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "oxlint plugin with Effect-specific lint rules",
   "license": "MIT",

package/src/presets/core.ts

@@ -8,7 +8,7 @@ export const core = {
   "effect/noEffectNever": "error",
   "effect/noEffectAs": "error",
   "effect/noEffectBind": "error",
-  "effect/noRunInEffect": "error",
+  "effect/noRunInEffectGen": "error",
 
   // AST pattern rules
   "effect/noNestedPipe": "error",

package/src/presets/full.ts

@@ -13,7 +13,7 @@ export const full = {
   "effect/noEffectBind": "error",
   "effect/noOptionAs": "error",
   "effect/noRuntimeRunFork": "error",
-  "effect/noRunInEffect": "error",
+  "effect/noRunInEffectGen": "error",
 
   // Global bans (everywhere, not just Effect context)
   "effect/noAsyncFunction": "warn",

package/src/presets/strict.ts

@@ -11,7 +11,7 @@ export const strict = {
   "effect/noEffectBind": "error",
   "effect/noOptionAs": "error",
   "effect/noRuntimeRunFork": "error",
-  "effect/noRunInEffect": "error",
+  "effect/noRunInEffectGen": "error",
 
   // Style / functional
   "effect/noReturnNull": "error",

package/src/rules/index.ts

@@ -11,7 +11,6 @@ export { noEffectBind } from "./no-effect-bind.js"
 export { noEffectDo } from "./no-effect-do.js"
 export { noEffectNever } from "./no-effect-never.js"
 export { noOptionAs } from "./no-option-as.js"
-export { noRunInEffect } from "./no-run-in-effect.js"
 export { noRuntimeRunFork } from "./no-runtime-run-fork.js"
 
 // --- Statement bans ---
@@ -68,5 +67,6 @@ export { noInlineProvide } from "./no-inline-provide.js"
 export { noNewError } from "./no-new-error.js"
 export { noNewPromise } from "./no-new-promise.js"
 export { noReturnNullish } from "./no-return-nullish.js"
+export { noRunInEffectGen } from "./no-run-in-effect-gen.js"
 export { noThrowStatement } from "./no-throw-statement.js"
 export { noTryCatch } from "./no-try-catch.js"

package/src/rules/no-catch-all-to-map-error.ts

@@ -49,6 +49,7 @@ export const noCatchAllToMapError = Rule.define({
     type: "suggestion",
     description:
       "Use Effect.mapError instead of Effect.catchAll(e => Effect.fail(f(e))).",
+    effectVersion: "v3",
   }),
   create: function* () {
     const ctx = yield* RuleContext

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

@@ -14,6 +14,7 @@ export const noEffectGenAdapter = Rule.define({
   meta: Rule.meta({
     type: "suggestion",
     description: "Deprecated adapter parameter in Effect.gen. Use `yield*` directly.",
+    effectVersion: "v3",
   }),
   create: function* () {
     const ctx = yield* RuleContext

package/src/rules/no-run-in-effect-gen.ts

@@ -0,0 +1,66 @@
+/**
+ * Ban `Effect.run*` and `Runtime.run*` calls inside `Effect.gen`/`Effect.fn`.
+ *
+ * Running an effect inside a generator drops the ambient context — fibers,
+ * services, tracing, and memoized layers. Just `yield*` the child effect;
+ * for callback boundaries use `Effect.async`, for fork use `Effect.fork`.
+ *
+ * Explicitly allowed inside gen: `Effect.runForkWith`, `Effect.runPromiseWith`,
+ * `Effect.runSyncWith` (they take services explicitly — legitimate at
+ * callback boundaries) and `managedRuntime.runX` on identifier callees
+ * (can't be discriminated syntactically).
+ *
+ * Source: language-service/runEffectInsideEffect, extended for v4.
+ */
+import type { ESTree } from "@oxlint/plugins"
+import { AST, Diagnostic, Rule, Visitor, RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Ref from "effect/Ref"
+
+import { makeEffectContextTracker } from "./_effect-context.js"
+
+const effectRunMethods = ["runSync", "runPromise", "runFork", "runCallback"]
+const runtimeRunMethods = ["runSync", "runPromise", "runFork", "runCallback"]
+
+export const noRunInEffectGen = Rule.define({
+  name: "no-run-in-effect-gen",
+  meta: Rule.meta({
+    type: "problem",
+    description:
+      "Running effects inside Effect.gen/fn drops the ambient context. Use yield* instead.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const [depth, tracker] = yield* makeEffectContextTracker
+
+    return Visitor.merge(tracker, {
+      CallExpression: (node) =>
+        Effect.flatMap(Ref.get(depth), (d) => {
+          if (d <= 0) return Effect.void
+          const call = node as ESTree.CallExpression
+
+          if (AST.isCallOf(call, "Effect", effectRunMethods)) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message:
+                  "Avoid Effect.run* inside Effect.gen/fn. `yield*` the child effect, or use Effect.fork for concurrency.",
+              }),
+            )
+          }
+
+          if (AST.isCallOf(call, "Runtime", runtimeRunMethods)) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message:
+                  "Avoid Runtime.run* inside Effect.gen/fn. The ambient context already has your services — `yield*` the child effect.",
+              }),
+            )
+          }
+
+          return Effect.void
+        }),
+    })
+  },
+})

package/src/rules/no-runtime-run-fork.ts

@@ -10,5 +10,5 @@ import { Rule } from "../vendor/effect-oxlint/index.js"
 export const noRuntimeRunFork = Rule.banMember("Runtime", "runFork", {
   message:
     "Avoid Runtime.runFork. Use forkScoped, Stream, or runtime-provided layers.",
-  meta: { type: "problem" },
+  meta: { type: "problem", effectVersion: "v3" },
 })

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;
@@ -427,7 +444,9 @@ export type BanSpec =
  */
 export const banMultiple = (config: {
 	readonly name: string;
-	readonly meta?: { readonly type?: 'problem' | 'suggestion' } | undefined;
+	readonly meta?:
+		| { readonly type?: 'problem' | 'suggestion'; readonly effectVersion?: EffectVersion }
+		| undefined;
 	readonly specs: ReadonlyArray<BanSpec>;
 }): CreateRule => {
 	const description = config.specs.map((s) => s.message).join(' ');
@@ -435,7 +454,8 @@ export const banMultiple = (config: {
 		name: config.name,
 		meta: meta({
 			type: config.meta?.type ?? 'suggestion',
-			description
+			description,
+			effectVersion: config.meta?.effectVersion
 		}),
 		create: function* () {
 			const ctx = yield* RuleContext;

package/tests/ban-rules.test.ts

@@ -8,7 +8,6 @@ import {
   noEffectBind,
   noOptionAs,
   noRuntimeRunFork,
-  noRunInEffect,
 } from "../src/rules/index.js"
 
 // --- API ban rules ---
@@ -67,19 +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)
-  })
-})

package/tests/context-rules.test.ts

@@ -7,6 +7,7 @@ import {
   noNewPromise,
   noNewError,
   noReturnNullish,
+  noRunInEffectGen,
 } from "../src/rules/index.js"
 
 // Helper: simulate entering and exiting Effect.gen context
@@ -196,3 +197,67 @@ describe("noGlobals", () => {
     Testing.expectNoDiagnostics(result)
   })
 })
+
+describe("noRunInEffectGen", () => {
+  test("reports Effect.runPromise inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
+      ["CallExpression", effectGenNode],
+      ["CallExpression", Testing.callOfMember("Effect", "runPromise", [Testing.id("x")])],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("reports Effect.runFork inside Effect.fn", () => {
+    const effectFnNode = Testing.callOfMember("Effect", "fn", [])
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
+      ["CallExpression", effectFnNode],
+      ["CallExpression", Testing.callOfMember("Effect", "runFork", [Testing.id("x")])],
+      ["CallExpression:exit", effectFnNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("reports Runtime.runFork inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
+      ["CallExpression", effectGenNode],
+      ["CallExpression", Testing.callOfMember("Runtime", "runFork", [Testing.id("x")])],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores Effect.runForkWith inside Effect.gen (legit v4 callback boundary)", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
+      ["CallExpression", effectGenNode],
+      ["CallExpression", Testing.callOfMember("Effect", "runForkWith", [Testing.id("services")])],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+
+  test("ignores managedRuntime.runFork on identifier callee", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
+      ["CallExpression", effectGenNode],
+      ["CallExpression", Testing.callOfMember("managedRuntime", "runFork", [Testing.id("x")])],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+
+  test("ignores Effect.runPromise outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
+      ["CallExpression", Testing.callOfMember("Effect", "runPromise", [Testing.id("x")])],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+
+  test("ignores yield* child effect inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
+      ["CallExpression", effectGenNode],
+      ["CallExpression", Testing.callOfMember("Effect", "succeed", [Testing.id("x")])],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})

package/src/rules/no-run-in-effect.ts

@@ -1,18 +0,0 @@
-/**
- * Ban `Effect.runSync`, `Effect.runPromise`, `Effect.runFork`, `Effect.runCallback`.
- *
- * Inside Effect context, use Runtime or Effect.services pattern.
- *
- * Source: language-service/runEffectInsideEffect
- */
-import { Rule } from "../vendor/effect-oxlint/index.js"
-
-export const noRunInEffect = Rule.banMember(
-  "Effect",
-  ["runSync", "runPromise", "runFork", "runCallback"],
-  {
-    message:
-      "Avoid Effect.run* calls. Use Effect.services (v4) or Runtime pattern instead.",
-    meta: { type: "problem" },
-  },
-)