oxlint-plugin-effect 0.0.0

package/src/rules/no-arrow-ladder.ts

@@ -0,0 +1,71 @@
+/**
+ * Ban nested IIFE chains — `((x) => ((y) => ...)(arg2))(arg1)`.
+ *
+ * Use named const bindings + flat pipeline.
+ *
+ * Source: biome-effect-linting-rules/no-arrow-ladder
+ */
+import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+const isIife = (node: unknown): boolean => {
+  if (node == null || typeof node !== "object") return false
+  const n = node as unknown as Record<string, unknown>
+  if (n["type"] !== "CallExpression") return false
+  const callee = n["callee"]
+  if (callee == null || typeof callee !== "object") return false
+  const c = callee as unknown as Record<string, unknown>
+  return c["type"] === "ArrowFunctionExpression" || c["type"] === "FunctionExpression"
+}
+
+const containsIife = (node: unknown): boolean => {
+  if (node == null || typeof node !== "object") return false
+  const n = node as unknown as Record<string, unknown>
+  if (isIife(n)) return true
+  if ("body" in n) {
+    if (Array.isArray(n["body"])) {
+      for (const child of n["body"]) {
+        if (containsIife(child)) return true
+      }
+    } else if (containsIife(n["body"])) return true
+  }
+  if ("argument" in n && containsIife(n["argument"])) return true
+  if ("arguments" in n && Array.isArray(n["arguments"])) {
+    for (const arg of n["arguments"]) {
+      if (containsIife(arg)) return true
+    }
+  }
+  if ("expression" in n && containsIife(n["expression"])) return true
+  return false
+}
+
+export const noArrowLadder = Rule.define({
+  name: "no-arrow-ladder",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid nested IIFE chains. Use named const bindings + flat pipeline.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!isIife(node)) return Effect.void
+
+        // Check if the body of the IIFE itself contains another IIFE
+        const callee = (node as unknown as Record<string, unknown>)["callee"]
+        if (callee == null || typeof callee !== "object") return Effect.void
+        const c = callee as unknown as Record<string, unknown>
+        if ("body" in c && containsIife(c["body"])) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message: "Nested IIFE chain detected. Use named const bindings + flat pipeline.",
+            }),
+          )
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-async-function.ts

@@ -0,0 +1,48 @@
+/**
+ * Ban `async` functions.
+ *
+ * Use Effect.promise, Effect.tryPromise, or Effect.gen instead.
+ *
+ * Source: language-service/asyncFunction
+ *
+ * Note: This is an effectNative rule — off by default.
+ * Only enable in codebases fully committed to Effect.
+ */
+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 noAsyncFunction = Rule.define({
+  name: "no-async-function",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid async functions. Use Effect.promise or Effect.tryPromise.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const report = (node: Parameters<typeof Diagnostic.make>[0]["node"]) =>
+      ctx.report(
+        Diagnostic.make({
+          node,
+          message:
+            "Avoid async functions. Use Effect.promise, Effect.tryPromise, or Effect.gen.",
+        }),
+      )
+
+    return {
+      FunctionDeclaration: (node) => {
+        if ("async" in node && node.async === true) return report(node)
+        return Effect.void
+      },
+      FunctionExpression: (node) => {
+        if ("async" in node && node.async === true) return report(node)
+        return Effect.void
+      },
+      ArrowFunctionExpression: (node) => {
+        if ("async" in node && node.async === true) return report(node)
+        return Effect.void
+      },
+    }
+  },
+})

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

@@ -0,0 +1,46 @@
+/**
+ * Ban `console.*` calls inside Effect.gen/fn context.
+ *
+ * Use Effect Logger service instead.
+ *
+ * Source: language-service/globalConsoleInEffect
+ */
+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 consoleMethods = ["log", "warn", "error", "info", "debug", "trace"]
+
+export const noConsoleInEffect = Rule.define({
+  name: "no-console-in-effect",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid console.* inside Effect.gen/fn. Use Effect Logger service.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const [depth, tracker] = yield* makeEffectContextTracker
+
+    return Visitor.merge(tracker, {
+      MemberExpression: (node) =>
+        Effect.flatMap(Ref.get(depth), (d) => {
+          if (d > 0 && Option.isSome(AST.matchMember(node as ESTree.MemberExpression, "console", consoleMethods))) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message:
+                  "Avoid console.* inside Effect context. Use Effect Logger service.",
+              }),
+            )
+          }
+          return Effect.void
+        }),
+    })
+  },
+})

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

@@ -0,0 +1,61 @@
+/**
+ * Ban `Date.now()` and `new Date()` inside Effect.gen/fn context.
+ *
+ * Use Clock service instead.
+ *
+ * Source: language-service/globalDateInEffect
+ */
+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"
+
+export const noDateInEffect = Rule.define({
+  name: "no-date-in-effect",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid Date.now() and new Date() inside Effect.gen/fn. Use Clock service.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const [depth, tracker] = yield* makeEffectContextTracker
+
+    return Visitor.merge(
+      tracker,
+      {
+        MemberExpression: (node) =>
+          Effect.flatMap(Ref.get(depth), (d) => {
+            if (d > 0 && Option.isSome(AST.matchMember(node as ESTree.MemberExpression, "Date", "now"))) {
+              return ctx.report(
+                Diagnostic.make({ node, message: "Avoid Date.now() inside Effect context. Use Clock service." }),
+              )
+            }
+            return Effect.void
+          }),
+        NewExpression: (node) =>
+          Effect.flatMap(Ref.get(depth), (d) => {
+            if (
+              d > 0 &&
+              "callee" in node &&
+              node.callee != null &&
+              typeof node.callee === "object" &&
+              "type" in node.callee &&
+              node.callee.type === "Identifier" &&
+              "name" in node.callee &&
+              node.callee.name === "Date"
+            ) {
+              return ctx.report(
+                Diagnostic.make({ node, message: "Avoid new Date() inside Effect context. Use Clock service." }),
+              )
+            }
+            return Effect.void
+          }),
+      },
+    )
+  },
+})

package/src/rules/no-dynamic-import.ts

@@ -0,0 +1,13 @@
+/**
+ * Ban dynamic `import()` expressions.
+ *
+ * Use static module imports.
+ *
+ * Source: biome-effect-linting-rules/prevent-dynamic-imports
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noDynamicImport = Rule.banStatement("ImportExpression", {
+  message: "Avoid dynamic import(). Use static module imports.",
+  meta: { type: "problem" },
+})

package/src/rules/no-effect-as.ts

@@ -0,0 +1,14 @@
+/**
+ * Ban `Effect.as`.
+ *
+ * Use `Effect.map` for value mapping or `Effect.asVoid` after explicit steps.
+ *
+ * Source: biome-effect-linting-rules/no-effect-as
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noEffectAs = Rule.banMember("Effect", "as", {
+  message:
+    "Avoid Effect.as. Use Effect.map for value mapping or Effect.asVoid.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-effect-async.ts

@@ -0,0 +1,14 @@
+/**
+ * Ban `Effect.async`.
+ *
+ * Use `Stream` or structured Effect lifecycles (acquire/use/release).
+ *
+ * Source: biome-effect-linting-rules/no-effect-async
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noEffectAsync = Rule.banMember("Effect", "async", {
+  message:
+    "Avoid Effect.async. Use Stream or structured Effect lifecycles.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-effect-bind.ts

@@ -0,0 +1,13 @@
+/**
+ * Ban `Effect.bind`.
+ *
+ * Use flat pipe or direct top-level `Effect.gen` with yields.
+ *
+ * Source: biome-effect-linting-rules/no-effect-bind
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noEffectBind = Rule.banMember("Effect", "bind", {
+  message: "Avoid Effect.bind. Use flat pipe or Effect.gen with yields.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-effect-do.ts

@@ -0,0 +1,14 @@
+/**
+ * Ban `Effect.Do` — the builder/do-notation entry point.
+ *
+ * Use flat pipe-based flow or `Effect.gen` instead.
+ *
+ * Sources: biome-effect-linting-rules/no-effect-do, language-service/effectDoNotation
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noEffectDo = Rule.banMember("Effect", "Do", {
+  message:
+    "Avoid Effect.Do builder notation. Use flat pipe-based flow or Effect.gen.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-effect-fn-generator.ts

@@ -0,0 +1,59 @@
+/**
+ * Ban `Effect.fn(function* () { ... })` called with a generator argument.
+ *
+ * Effect.fn should wrap a plain function or arrow that builds a pipeline,
+ * not a generator (use Effect.gen for generators).
+ *
+ * Source: biome-effect-linting-rules/no-effect-fn-generator
+ *
+ * Note: This rule may be too aggressive. In Effect v4, `Effect.fn("name")(function*() {...})`
+ * is actually the idiomatic pattern. This rule targets `Effect.fn(function*() {...})` without
+ * a name span, which is the discouraged pattern from the biome rules.
+ */
+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"
+
+export const noEffectFnGenerator = Rule.define({
+  name: "no-effect-fn-generator",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Effect.fn should not directly wrap a generator. Use Effect.fn('name')(function*() {...}) with a span name.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!AST.isCallOf(node as ESTree.CallExpression, "Effect", "fn")) return Effect.void
+
+        // Effect.fn(function*() {...}) — single arg that's a generator
+        if (
+          "arguments" in node &&
+          Array.isArray(node.arguments) &&
+          node.arguments.length === 1
+        ) {
+          const arg = node.arguments[0]
+          if (
+            arg != null &&
+            typeof arg === "object" &&
+            "type" in arg &&
+            arg.type === "FunctionExpression" &&
+            "generator" in arg &&
+            arg.generator === true
+          ) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message:
+                  "Use Effect.fn('spanName')(function*() {...}) — provide a trace span name.",
+              }),
+            )
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})

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

@@ -0,0 +1,51 @@
+/**
+ * Ban deprecated adapter parameter in `Effect.gen(function*(adapter) {...})`.
+ *
+ * The adapter parameter is deprecated — just use `yield*` directly.
+ *
+ * Source: language-service/effectGenUsesAdapter
+ */
+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"
+
+export const noEffectGenAdapter = Rule.define({
+  name: "no-effect-gen-adapter",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Deprecated adapter parameter in Effect.gen. Use `yield*` directly.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!AST.isCallOf(node as ESTree.CallExpression, "Effect", "gen")) return Effect.void
+
+        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 &&
+          arg.type === "FunctionExpression" &&
+          "generator" in arg &&
+          arg.generator === true &&
+          "params" in arg &&
+          Array.isArray(arg.params) &&
+          arg.params.length > 0
+        ) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message: "Deprecated adapter parameter in Effect.gen. Remove the parameter and use `yield*` directly.",
+            }),
+          )
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-effect-map-void.ts

@@ -0,0 +1,81 @@
+/**
+ * Ban `Effect.map(() => undefined)` / `Effect.map(() => void 0)` / `Effect.map(() => {})`.
+ *
+ * Use `Effect.asVoid` instead.
+ *
+ * Source: language-service/effectMapVoid
+ */
+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"
+
+const isVoidCallback = (arg: unknown): boolean => {
+  if (arg == null || typeof arg !== "object" || !("type" in arg)) return false
+
+  // Arrow function: () => undefined, () => void 0, () => {}
+  if (arg.type === "ArrowFunctionExpression" && "body" in arg) {
+    const body = arg.body
+    if (body == null || typeof body !== "object" || !("type" in body)) return false
+
+    // () => undefined
+    if (body.type === "Identifier" && "name" in body && body.name === "undefined") return true
+
+    // () => void 0
+    if (
+      body.type === "UnaryExpression" &&
+      "operator" in body &&
+      body.operator === "void"
+    )
+      return true
+
+    // () => {}  (empty block)
+    if (
+      body.type === "BlockStatement" &&
+      "body" in body &&
+      Array.isArray(body.body) &&
+      body.body.length === 0
+    )
+      return true
+  }
+
+  return false
+}
+
+export const noEffectMapVoid = Rule.define({
+  name: "no-effect-map-void",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid Effect.map(() => undefined). Use Effect.asVoid instead.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!AST.isCallOf(node as ESTree.CallExpression, "Effect", "map")) return Effect.void
+
+        if (
+          "arguments" in node &&
+          Array.isArray(node.arguments) &&
+          node.arguments.length >= 1
+        ) {
+          // Effect.map(effect, fn) or as pipe arg Effect.map(fn)
+          const fn =
+            node.arguments.length === 2
+              ? node.arguments[1]
+              : node.arguments[0]
+          if (isVoidCallback(fn)) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message: "Use Effect.asVoid instead of Effect.map(() => undefined).",
+              }),
+            )
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-effect-never.ts

@@ -0,0 +1,14 @@
+/**
+ * Ban `Effect.never`.
+ *
+ * Use `Stream` or explicit acquire/release lifecycles instead.
+ *
+ * Source: biome-effect-linting-rules/no-effect-never
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noEffectNever = Rule.banMember("Effect", "never", {
+  message:
+    "Avoid Effect.never. Use Stream or explicit acquire/release lifecycles.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-effect-orElse-ladder.ts

@@ -0,0 +1,80 @@
+/**
+ * Ban `Effect.orElse` wrapping chains with sequencing combinators.
+ *
+ * Move error handling to a single terminal decision after the pipeline.
+ *
+ * Source: biome-effect-linting-rules/no-effect-orElse-ladder
+ */
+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"
+
+const sequencingCombinators = ["flatMap", "zipRight", "as", "tap", "andThen"]
+
+const containsSequencing = (node: unknown): boolean => {
+  if (node == null || typeof node !== "object") return false
+  const n = node as Record<string, unknown>
+  if (n["type"] === "CallExpression" && "callee" in n) {
+    const callee = n["callee"] as Record<string, unknown> | null
+    if (
+      callee != null &&
+      callee["type"] === "MemberExpression" &&
+      "object" in callee &&
+      "property" in callee
+    ) {
+      const obj = callee["object"] as Record<string, unknown> | null
+      const prop = callee["property"] as Record<string, unknown> | null
+      if (
+        obj != null &&
+        obj["type"] === "Identifier" &&
+        obj["name"] === "Effect" &&
+        prop != null &&
+        prop["type"] === "Identifier" &&
+        typeof prop["name"] === "string" &&
+        sequencingCombinators.includes(prop["name"])
+      ) {
+        return true
+      }
+    }
+    if ("arguments" in n && Array.isArray(n["arguments"])) {
+      for (const arg of n["arguments"]) {
+        if (containsSequencing(arg)) return true
+      }
+    }
+  }
+  if ("body" in n) return containsSequencing(n["body"])
+  return false
+}
+
+export const noEffectOrElseLadder = Rule.define({
+  name: "no-effect-orElse-ladder",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid Effect.orElse wrapping sequencing chains. Handle errors at a single terminal decision.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!AST.isCallOf(node as ESTree.CallExpression, "Effect", "orElse")) return Effect.void
+
+        if ("arguments" in node && Array.isArray(node.arguments)) {
+          for (const arg of node.arguments) {
+            if (containsSequencing(arg)) {
+              return ctx.report(
+                Diagnostic.make({
+                  node,
+                  message:
+                    "Effect.orElse wrapping sequencing chain. Move error handling to a terminal decision after the pipeline.",
+                }),
+              )
+            }
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-effect-succeed-string.ts

@@ -0,0 +1,53 @@
+/**
+ * Ban `Effect.succeed("...")` with string literal arguments.
+ *
+ * Return domain values (Option/Either/tagged unions) instead.
+ *
+ * Source: biome-effect-linting-rules/no-string-sentinel-return
+ */
+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"
+
+export const noEffectSucceedString = Rule.define({
+  name: "no-effect-succeed-string",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid Effect.succeed with string literals. Return domain values (tagged unions, Option, Either).",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!AST.isCallOf(node as ESTree.CallExpression, "Effect", "succeed")) return Effect.void
+
+        if (
+          "arguments" in node &&
+          Array.isArray(node.arguments) &&
+          node.arguments.length === 1
+        ) {
+          const arg = node.arguments[0]
+          if (
+            arg != null &&
+            typeof arg === "object" &&
+            "type" in arg &&
+            arg.type === "Literal" &&
+            "value" in arg &&
+            typeof arg.value === "string"
+          ) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message:
+                  "Avoid Effect.succeed with string literals. Use tagged unions, Option, or Either.",
+              }),
+            )
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})