oxlint-plugin-effect 0.2.0 → 0.2.2

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

@@ -1,70 +0,0 @@
-/**
- * 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, 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

@@ -1,47 +0,0 @@
-/**
- * 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, 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-catch-all-to-map-error.ts

@@ -1,90 +0,0 @@
-/**
- * Ban `Effect.catchAll(e => Effect.fail(f(e)))` — use `Effect.mapError(f)`.
- *
- * Source: language-service/catchAllToMapError
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-
-const catchNames = new Set(["catchAll", "catchAllCause"])
-
-/**
- * Check if a node is `Effect.fail(...)` or `Effect.failCause(...)`.
- */
-const isEffectFailCall = (node: ESTree.Node): boolean => {
-  if (node.type !== "CallExpression") return false
-  const call = node as ESTree.CallExpression
-  return (
-    Option.isSome(AST.matchCallOf(call, "Effect", "fail")) ||
-    Option.isSome(AST.matchCallOf(call, "Effect", "failCause"))
-  )
-}
-
-/**
- * Check if a function body is a single `Effect.fail(...)` expression.
- * Handles: `(e) => Effect.fail(f(e))` and `(e) => { return Effect.fail(f(e)) }`
- */
-const bodyIsEffectFail = (fn: ESTree.Node): boolean => {
-  const body = (fn as unknown as Record<string, unknown>)["body"]
-  if (body == null || typeof body !== "object") return false
-  const bodyNode = body as ESTree.Node
-  // Arrow with expression body: (e) => Effect.fail(f(e))
-  if (bodyNode.type !== "BlockStatement") {
-    return isEffectFailCall(bodyNode)
-  }
-  // Block body with single return: (e) => { return Effect.fail(f(e)) }
-  const stmts = (bodyNode as unknown as Record<string, unknown>)["body"]
-  if (!Array.isArray(stmts) || stmts.length !== 1) return false
-  const stmt = stmts[0] as ESTree.Node
-  if (stmt.type !== "ReturnStatement") return false
-  const arg = (stmt as unknown as Record<string, unknown>)["argument"]
-  return arg != null && typeof arg === "object" && isEffectFailCall(arg as ESTree.Node)
-}
-
-export const noCatchAllToMapError = Rule.define({
-  name: "no-catch-all-to-map-error",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Use Effect.mapError instead of Effect.catchAll(e => Effect.fail(f(e))).",
-    effectVersion: "v3",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const call = node as ESTree.CallExpression
-        const names = Option.getOrUndefined(AST.memberNames(call.callee as ESTree.MemberExpression))
-        if (names === undefined) return Effect.void
-        const [obj, prop] = names
-        if (obj !== "Effect" && obj !== "_") return Effect.void
-        if (!catchNames.has(prop)) return Effect.void
-
-        // The callback is the last argument
-        const args = call.arguments
-        if (args.length === 0) return Effect.void
-        const callback = args[args.length - 1]
-        if (callback === undefined) return Effect.void
-        if (
-          callback.type !== "ArrowFunctionExpression" &&
-          callback.type !== "FunctionExpression"
-        ) {
-          return Effect.void
-        }
-
-        if (bodyIsEffectFail(callback as ESTree.Node)) {
-          const replacement = prop === "catchAllCause" ? "mapErrorCause" : "mapError"
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message: `Use Effect.${replacement} instead of Effect.${prop}(e => Effect.fail(...)).`,
-            }),
-          )
-        }
-        return Effect.void
-      },
-    }
-  },
-})

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

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,58 +0,0 @@
-/**
- * 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, 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

@@ -1,51 +0,0 @@
-/**
- * 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, 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.",
-    effectVersion: "v3",
-  }),
-  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-flatten.ts

@@ -1,82 +0,0 @@
-/**
- * Ban `.map(f).flatMap(g)` — use `.flatMap(x => g(f(x)))` or refactor.
- *
- * Detects `.pipe(Effect.map(f), Effect.flatMap(g))` chains where
- * the map + flatMap can be fused.
- *
- * Source: language-service/effectMapFlatten
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-
-const isEffectMap = (node: ESTree.Node): boolean => {
-  if (node.type !== "CallExpression") return false
-  return Option.isSome(AST.matchCallOf(node as ESTree.CallExpression, "Effect", "map"))
-}
-
-const isEffectFlatMap = (node: ESTree.Node): boolean => {
-  if (node.type !== "CallExpression") return false
-  return Option.isSome(AST.matchCallOf(node as ESTree.CallExpression, "Effect", "flatMap"))
-}
-
-const hasMapFlatMapSequence = (args: ReadonlyArray<ESTree.Node>): boolean => {
-  for (let i = 0; i < args.length - 1; i++) {
-    const a = args[i]; const b = args[i + 1]; if (a && b && isEffectMap(a) && isEffectFlatMap(b)) return true
-  }
-  return false
-}
-
-export const noEffectMapFlatten = Rule.define({
-  name: "no-effect-map-flatten",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid Effect.map followed by Effect.flatMap in pipe. Fuse into a single Effect.flatMap.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const call = node as ESTree.CallExpression
-        const args = call.arguments
-
-        // Bare pipe(value, Effect.map(f), Effect.flatMap(g))
-        const calleeName = Option.getOrUndefined(AST.calleeName(call))
-        if (calleeName === "pipe" && hasMapFlatMapSequence(args as ReadonlyArray<ESTree.Node>)) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message:
-                "Effect.map followed by Effect.flatMap can be fused into a single Effect.flatMap.",
-            }),
-          )
-        }
-
-        // .pipe(Effect.map(f), Effect.flatMap(g))
-        const calleeNode = call.callee
-        if (calleeNode.type === "MemberExpression") {
-          const prop = (calleeNode as unknown as Record<string, unknown>)["property"]
-          if (
-            prop != null &&
-            typeof prop === "object" &&
-            "name" in prop &&
-            prop.name === "pipe" &&
-            hasMapFlatMapSequence(args as ReadonlyArray<ESTree.Node>)
-          ) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message:
-                  "Effect.map followed by Effect.flatMap can be fused into a single Effect.flatMap.",
-              }),
-            )
-          }
-        }
-
-        return Effect.void
-      },
-    }
-  },
-})

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

@@ -1,80 +0,0 @@
-/**
- * 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, 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

@@ -1,14 +0,0 @@
-/**
- * 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

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