oxlint-plugin-effect 0.0.0

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

@@ -0,0 +1,18 @@
+/**
+ * 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" },
+  },
+)

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

@@ -0,0 +1,14 @@
+/**
+ * Ban `Runtime.runFork`.
+ *
+ * Use `forkScoped`, `Stream`, or runtime-provided layers.
+ *
+ * Source: biome-effect-linting-rules/no-runtime-runfork
+ */
+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" },
+})

package/src/rules/no-string-sentinel-const.ts

@@ -0,0 +1,50 @@
+/**
+ * Ban `const x = "some-string"` string literal const declarations.
+ *
+ * Use tagged unions, Option, or meaningful domain values.
+ *
+ * Source: biome-effect-linting-rules/no-string-sentinel-const
+ *
+ * Note: Very aggressive — should probably be off by default or in a strict preset only.
+ */
+import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+export const noStringSentinelConst = Rule.define({
+  name: "no-string-sentinel-const",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid string literal const declarations. Use tagged unions or domain values.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      VariableDeclarator: (node) => {
+        if (!("init" in node) || node.init == null) return Effect.void
+        const init = node.init as unknown as Record<string, unknown>
+
+        if (init["type"] === "Literal" && typeof init["value"] === "string") {
+          // Check parent is const declaration
+          if (
+            "parent" in node &&
+            node.parent != null &&
+            typeof node.parent === "object" &&
+            "type" in node.parent &&
+            node.parent.type === "VariableDeclaration" &&
+            "kind" in node.parent &&
+            node.parent.kind === "const"
+          ) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message: "Avoid string literal const. Use tagged unions, Option, or domain values.",
+              }),
+            )
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})

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

@@ -0,0 +1,13 @@
+/**
+ * Ban `switch` statements.
+ *
+ * Use `Match.value`, `Option.match`, `Either.match` instead.
+ *
+ * Source: biome-effect-linting-rules/no-switch-statement
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noSwitchStatement = Rule.banStatement("SwitchStatement", {
+  message: "Avoid switch statements. Use Match.value, Option.match, or Either.match.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-ternary.ts

@@ -0,0 +1,32 @@
+/**
+ * Ban ternary expressions in Effect codebases.
+ *
+ * Use `Option.match`, `Either.match`, `Match.value` instead.
+ *
+ * Source: biome-effect-linting-rules/no-ternary
+ *
+ * Note: Very opinionated — recommended for strict functional presets only.
+ */
+import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+export const noTernary = Rule.define({
+  name: "no-ternary",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid ternary expressions. Use Option.match, Either.match, or Match.value.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      ConditionalExpression: (node) =>
+        ctx.report(
+          Diagnostic.make({
+            node,
+            message: "Avoid ternary expressions. Use Option.match, Either.match, or Match.value.",
+          }),
+        ),
+    }
+  },
+})

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

@@ -0,0 +1,42 @@
+/**
+ * Ban `throw` statements inside Effect.gen/fn generators.
+ *
+ * Use Effect.fail with tagged errors instead.
+ *
+ * Source: effect convention — errors should be in the type system
+ */
+import { Diagnostic, Rule, Visitor } from "../vendor/effect-oxlint/index.js"
+import { 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"
+
+export const noThrowInEffectGen = Rule.define({
+  name: "no-throw-in-effect-gen",
+  meta: Rule.meta({
+    type: "problem",
+    description:
+      "Avoid throw inside Effect.gen/fn. 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) => {
+          if (d > 0) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message:
+                  "Avoid throw inside Effect.gen/fn. Use Effect.fail with tagged errors.",
+              }),
+            )
+          }
+          return Effect.void
+        }),
+    })
+  },
+})

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

@@ -0,0 +1,13 @@
+/**
+ * Ban `throw` statements.
+ *
+ * Use Effect.fail or tagged errors instead.
+ *
+ * Source: effect convention — errors should be in the type system
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noThrowStatement = Rule.banStatement("ThrowStatement", {
+  message: "Avoid throw. Use Effect.fail with tagged errors.",
+  meta: { type: "problem" },
+})

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

@@ -0,0 +1,47 @@
+/**
+ * Ban `setTimeout`/`setInterval` inside Effect.gen/fn context.
+ *
+ * Use Effect.sleep or Schedule instead.
+ *
+ * Source: language-service/globalTimersInEffect
+ */
+import type { ESTree } from "@oxlint/plugins"
+import { AST, Diagnostic, Rule, Visitor } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Ref from "effect/Ref"
+
+import { makeEffectContextTracker } from "./_effect-context.js"
+
+const timerNames = ["setTimeout", "setInterval"]
+
+export const noTimersInEffect = Rule.define({
+  name: "no-timers-in-effect",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid setTimeout/setInterval inside Effect.gen/fn. Use Effect.sleep or Schedule.",
+  }),
+  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) {
+            const name = Option.getOrUndefined(AST.calleeName(node as ESTree.CallExpression))
+            if (name !== undefined && timerNames.includes(name)) {
+              return ctx.report(
+                Diagnostic.make({
+                  node,
+                  message: "Avoid setTimeout/setInterval inside Effect context. Use Effect.sleep or Schedule.",
+                }),
+              )
+            }
+          }
+          return Effect.void
+        }),
+    })
+  },
+})

package/src/rules/no-try-catch-in-effect-gen.ts

@@ -0,0 +1,42 @@
+/**
+ * Ban `try/catch` inside Effect.gen/fn generators.
+ *
+ * Use Effect.try, Effect.tryPromise, or Effect.catch* instead.
+ *
+ * Source: language-service/tryCatchInEffectGen
+ */
+import { Diagnostic, Rule, Visitor } from "../vendor/effect-oxlint/index.js"
+import { 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"
+
+export const noTryCatchInEffectGen = Rule.define({
+  name: "no-try-catch-in-effect-gen",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid try/catch inside Effect.gen/fn. 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) => {
+          if (d > 0) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message:
+                  "Avoid try/catch inside Effect.gen/fn. Use Effect.try, Effect.tryPromise, or Effect.catch*.",
+              }),
+            )
+          }
+          return Effect.void
+        }),
+    })
+  },
+})

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

@@ -0,0 +1,14 @@
+/**
+ * Ban `try/catch` statements.
+ *
+ * Model failures in Effect's typed error channel.
+ *
+ * Source: biome-effect-linting-rules/no-try-catch, language-service/tryCatchInEffectGen
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+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" },
+})

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

@@ -0,0 +1,52 @@
+/**
+ * Ban `() => { return x }` — use `() => x` instead.
+ *
+ * Source: language-service/unnecessaryArrowBlock
+ */
+import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+export const noUnnecessaryArrowBlock = Rule.define({
+  name: "no-unnecessary-arrow-block",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Unnecessary arrow block body. Use concise arrow `() => expr`.",
+    fixable: "code",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      ArrowFunctionExpression: (node) => {
+        if (
+          "body" in node &&
+          node.body != null &&
+          typeof node.body === "object" &&
+          "type" in node.body &&
+          node.body.type === "BlockStatement" &&
+          "body" in node.body &&
+          Array.isArray(node.body.body) &&
+          node.body.body.length === 1
+        ) {
+          const stmt = node.body.body[0]
+          if (
+            stmt != null &&
+            typeof stmt === "object" &&
+            "type" in stmt &&
+            stmt.type === "ReturnStatement" &&
+            "argument" in stmt &&
+            stmt.argument != null
+          ) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message: "Unnecessary arrow block body. Use `() => expr` instead of `() => { return expr }`.",
+              }),
+            )
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})

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

@@ -0,0 +1,85 @@
+/**
+ * Detect unnecessary `Effect.gen` wrappers with a single `yield*` + return.
+ *
+ * ```ts
+ * // BAD
+ * Effect.gen(function* () { return yield* someEffect })
+ *
+ * // GOOD
+ * someEffect
+ * ```
+ *
+ * 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 * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+
+export const noUnnecessaryEffectGen = Rule.define({
+  name: "no-unnecessary-effect-gen",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Unnecessary Effect.gen — single yield can be replaced with the yielded effect directly.",
+    fixable: "code",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!AST.isCallOf(node as ESTree.CallExpression, "Effect", "gen")) return Effect.void
+
+        // Check for single-arg: Effect.gen(function*() { ... })
+        if (!("arguments" in node) || !Array.isArray(node.arguments) || node.arguments.length !== 1)
+          return Effect.void
+
+        const arg = node.arguments[0]
+        if (arg == null || typeof arg !== "object" || !("type" in arg)) return Effect.void
+
+        // Must be a generator function expression
+        if (arg.type !== "FunctionExpression" || !("generator" in arg) || !arg.generator)
+          return Effect.void
+
+        // Must have exactly one statement in the body
+        if (
+          !("body" in arg) ||
+          arg.body == null ||
+          typeof arg.body !== "object" ||
+          !("type" in arg.body) ||
+          arg.body.type !== "BlockStatement" ||
+          !("body" in arg.body) ||
+          !Array.isArray(arg.body.body) ||
+          arg.body.body.length !== 1
+        )
+          return Effect.void
+
+        const stmt = arg.body.body[0]
+        if (stmt == null || typeof stmt !== "object" || !("type" in stmt)) return Effect.void
+
+        // Must be `return yield* expr`
+        if (
+          stmt.type === "ReturnStatement" &&
+          "argument" in stmt &&
+          stmt.argument != null &&
+          typeof stmt.argument === "object" &&
+          "type" in stmt.argument &&
+          stmt.argument.type === "YieldExpression" &&
+          "delegate" in stmt.argument &&
+          stmt.argument.delegate === true
+        ) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message:
+                "Unnecessary Effect.gen — single yield*. Replace with the yielded effect directly.",
+            }),
+          )
+        }
+
+        return Effect.void
+      },
+    }
+  },
+})

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

@@ -0,0 +1,46 @@
+/**
+ * Ban `pipe(x)` with zero pipe arguments.
+ *
+ * Just use `x` directly.
+ *
+ * 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 * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+
+export const noUnnecessaryPipe = Rule.define({
+  name: "no-unnecessary-pipe",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Unnecessary pipe() with single argument. Use the value directly.",
+    fixable: "code",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        // Match pipe(x) — bare pipe call with exactly one arg
+        const name = Option.getOrUndefined(AST.calleeName(node as ESTree.CallExpression))
+        if (name !== "pipe") return Effect.void
+
+        if (
+          "arguments" in node &&
+          Array.isArray(node.arguments) &&
+          node.arguments.length === 1
+        ) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message:
+                "Unnecessary pipe() with single argument. Use the value directly.",
+            }),
+          )
+        }
+        return Effect.void
+      },
+    }
+  },
+})