oxlint-plugin-effect 0.2.0 → 0.2.2

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

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

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

@@ -1,50 +0,0 @@
-/**
- * Ban `Effect.succeed(someVariable)` where the argument is a plain identifier.
- *
- * Suggests selecting a plain value (Option/Match), then running one Effect pipeline.
- *
- * Source: biome-effect-linting-rules/no-effect-succeed-variable
- */
-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 noEffectSucceedVariable = Rule.define({
-  name: "no-effect-succeed-variable",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid Effect.succeed with a plain variable. Select value with Option/Match, then run one Effect pipeline.",
-  }),
-  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 === "Identifier"
-          ) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message:
-                  "Avoid Effect.succeed(variable). Select value with Option/Match, then run one Effect pipeline.",
-              }),
-            )
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})

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

@@ -1,63 +0,0 @@
-/**
- * Ban `Effect.succeed(undefined)` and `Effect.succeed(void 0)`.
- *
- * Use `Effect.void` instead.
- *
- * Source: language-service/effectSucceedWithVoid
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-const isUndefinedLike = (node: unknown): boolean => {
-  if (node == null || typeof node !== "object" || !("type" in node)) return false
-  // undefined identifier
-  if (node.type === "Identifier" && "name" in node && node.name === "undefined") return true
-  // void 0
-  if (
-    node.type === "UnaryExpression" &&
-    "operator" in node &&
-    node.operator === "void" &&
-    "argument" in node &&
-    node.argument != null &&
-    typeof node.argument === "object" &&
-    "type" in node.argument &&
-    node.argument.type === "Literal" &&
-    "value" in node.argument &&
-    node.argument.value === 0
-  )
-    return true
-  return false
-}
-
-export const noEffectSucceedVoid = Rule.define({
-  name: "no-effect-succeed-void",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid Effect.succeed(undefined). Use Effect.void instead.",
-  }),
-  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 &&
-          isUndefinedLike(node.arguments[0])
-        ) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message: "Use Effect.void instead of Effect.succeed(undefined).",
-            }),
-          )
-        }
-        return Effect.void
-      },
-    }
-  },
-})

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

@@ -1,91 +0,0 @@
-/**
- * Ban `console.*` inside `Effect.sync(...)`.
- *
- * Use Effect.log* instead.
- *
- * Source: biome-effect-linting-rules/no-effect-sync-console
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-const consoleMethods = new Set(["log", "warn", "error", "info", "debug", "trace"])
-
-const containsConsoleCall = (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 &&
-    n["callee"] != null &&
-    typeof n["callee"] === "object"
-  ) {
-    const callee = n["callee"] as Record<string, unknown>
-    if (
-      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"] === "console" &&
-        prop != null && prop["type"] === "Identifier" && typeof prop["name"] === "string" &&
-        consoleMethods.has(prop["name"])
-      ) {
-        return true
-      }
-    }
-  }
-  // Recurse into body/arguments
-  if ("body" in n) {
-    if (Array.isArray(n["body"])) {
-      for (const child of n["body"]) {
-        if (containsConsoleCall(child)) return true
-      }
-    } else if (containsConsoleCall(n["body"])) return true
-  }
-  if ("argument" in n && containsConsoleCall(n["argument"])) return true
-  if ("arguments" in n && Array.isArray(n["arguments"])) {
-    for (const arg of n["arguments"]) {
-      if (containsConsoleCall(arg)) return true
-    }
-  }
-  if ("expression" in n && containsConsoleCall(n["expression"])) return true
-  if ("expressions" in n && Array.isArray(n["expressions"])) {
-    for (const expr of n["expressions"]) {
-      if (containsConsoleCall(expr)) return true
-    }
-  }
-  return false
-}
-
-export const noEffectSyncConsole = Rule.define({
-  name: "no-effect-sync-console",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid console.* inside Effect.sync. Use Effect.log* instead.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        if (!AST.isCallOf(node as ESTree.CallExpression, "Effect", "sync")) return Effect.void
-
-        if ("arguments" in node && Array.isArray(node.arguments)) {
-          for (const arg of node.arguments) {
-            if (containsConsoleCall(arg)) {
-              return ctx.report(
-                Diagnostic.make({
-                  node,
-                  message: "Avoid console.* inside Effect.sync. Use Effect.log, Effect.logWarning, etc.",
-                }),
-              )
-            }
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-effect-sync-wrapper.ts

@@ -1,67 +0,0 @@
-/**
- * Warn on `Effect.sync(() => someCall(...))` wrapping a plain function call.
- *
- * Consider whether the wrapped call truly needs to be in Effect.sync.
- *
- * Source: biome-effect-linting-rules/warn-effect-sync-wrapper
- */
-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 noEffectSyncWrapper = Rule.define({
-  name: "no-effect-sync-wrapper",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Effect.sync wrapping a plain call. Consider if Effect.sync is necessary.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        if (!AST.isCallOf(node as ESTree.CallExpression, "Effect", "sync")) 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)) return Effect.void
-
-        // () => someCall(...)
-        if (arg.type === "ArrowFunctionExpression" && "body" in arg) {
-          const body = arg.body
-          if (
-            body != null &&
-            typeof body === "object" &&
-            "type" in body &&
-            body.type === "CallExpression"
-          ) {
-            // Exclude console.* (handled by no-effect-sync-console)
-            const callee = (body as unknown as Record<string, unknown>)["callee"]
-            if (
-              callee != null &&
-              typeof callee === "object" &&
-              "type" in callee &&
-              callee.type === "MemberExpression" &&
-              "object" in callee &&
-              callee.object != null &&
-              typeof callee.object === "object" &&
-              "name" in callee.object &&
-              callee.object.name === "console"
-            ) {
-              return Effect.void
-            }
-
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message: "Effect.sync wrapping a plain function call. Consider if Effect.sync is necessary.",
-              }),
-            )
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-effect-type-alias.ts

@@ -1,71 +0,0 @@
-/**
- * Ban `type X = Effect.Effect<...>` type aliases.
- *
- * Keep Effect types on service methods or inline at call site.
- *
- * Source: biome-effect-linting-rules/no-effect-type-alias
- */
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-const containsEffectType = (node: unknown): boolean => {
-  if (node == null || typeof node !== "object") return false
-  const n = node as Record<string, unknown>
-  // TSTypeReference with Effect.Effect
-  if (
-    n["type"] === "TSTypeReference" &&
-    "typeName" in n &&
-    n["typeName"] != null &&
-    typeof n["typeName"] === "object"
-  ) {
-    const typeName = n["typeName"] as Record<string, unknown>
-    if (
-      typeName["type"] === "TSQualifiedName" &&
-      "left" in typeName && "right" in typeName
-    ) {
-      const left = typeName["left"] as Record<string, unknown> | null
-      const right = typeName["right"] as Record<string, unknown> | null
-      if (
-        left != null && left["type"] === "Identifier" && left["name"] === "Effect" &&
-        right != null && right["type"] === "Identifier" && right["name"] === "Effect"
-      ) {
-        return true
-      }
-    }
-  }
-  // Recurse into typeAnnotation, typeParameters
-  if ("typeAnnotation" in n && containsEffectType(n["typeAnnotation"])) return true
-  if ("typeParameters" in n && n["typeParameters"] != null && typeof n["typeParameters"] === "object") {
-    const tp = n["typeParameters"] as Record<string, unknown>
-    if ("params" in tp && Array.isArray(tp["params"])) {
-      for (const p of tp["params"]) {
-        if (containsEffectType(p)) return true
-      }
-    }
-  }
-  return false
-}
-
-export const noEffectTypeAlias = Rule.define({
-  name: "no-effect-type-alias",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid Effect type aliases. Keep Effect types on service methods or inline.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      TSTypeAliasDeclaration: (node) => {
-        if ("typeAnnotation" in node && containsEffectType(node.typeAnnotation)) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message: "Avoid type alias wrapping Effect.Effect. Let Effect types flow from service methods.",
-            }),
-          )
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-effect-wrapper-alias.ts

@@ -1,95 +0,0 @@
-/**
- * Ban wrapper functions that just alias an Effect.fn or pipe(Effect.fn(...)).
- *
- * Inline the pipeline at the call site or define a real domain function.
- *
- * Source: biome-effect-linting-rules/no-effect-wrapper-alias
- */
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-const isEffectFnCall = (node: unknown): boolean => {
-  if (node == null || typeof node !== "object") return false
-  const n = node 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 Record<string, unknown>
-  if (c["type"] !== "MemberExpression") return false
-  const obj = c["object"] as Record<string, unknown> | null
-  const prop = c["property"] as Record<string, unknown> | null
-  return (
-    obj != null && obj["type"] === "Identifier" && obj["name"] === "Effect" &&
-    prop != null && prop["type"] === "Identifier" && prop["name"] === "fn"
-  )
-}
-
-const isPipeWrappingEffectFn = (node: unknown): boolean => {
-  if (node == null || typeof node !== "object") return false
-  const n = node 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 Record<string, unknown>
-  if (!(c["type"] === "Identifier" && c["name"] === "pipe")) return false
-  const args = n["arguments"]
-  if (!Array.isArray(args) || args.length === 0) return false
-  return isEffectFnCall(args[0])
-}
-
-export const noEffectWrapperAlias = Rule.define({
-  name: "no-effect-wrapper-alias",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid wrapper functions aliasing Effect.fn. Inline or define a real domain function.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      VariableDeclarator: (node) => {
-        if (!("init" in node) || node.init == null) return Effect.void
-        const init = node.init
-
-        // const x = Effect.fn(...)
-        if (isEffectFnCall(init)) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message: "Avoid aliasing Effect.fn. Inline the pipeline or define a real domain function.",
-            }),
-          )
-        }
-
-        // const x = pipe(Effect.fn(...), ...)
-        if (isPipeWrappingEffectFn(init)) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message: "Avoid wrapping Effect.fn in pipe. Inline the pipeline or define a real domain function.",
-            }),
-          )
-        }
-
-        // const x = () => Effect.fn(...)  or  const x = () => pipe(Effect.fn(...))
-        if (
-          typeof init === "object" &&
-          "type" in init &&
-          (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") &&
-          "body" in init
-        ) {
-          const body = init.body
-          if (isEffectFnCall(body) || isPipeWrappingEffectFn(body)) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message: "Avoid wrapper function aliasing Effect.fn. Inline or define a real domain function.",
-              }),
-            )
-          }
-        }
-
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-extends-native-error.ts

@@ -1,54 +0,0 @@
-/**
- * Ban `class Foo extends Error`.
- *
- * Use Schema.TaggedErrorClass or Data.TaggedError instead.
- *
- * Source: language-service/extendsNativeError
- */
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-const nativeErrors = new Set([
-  "Error",
-  "TypeError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "URIError",
-  "EvalError",
-])
-
-export const noExtendsNativeError = Rule.define({
-  name: "no-extends-native-error",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid extending native Error. Use Schema.TaggedErrorClass or Data.TaggedError.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      ClassDeclaration: (node) => {
-        if (
-          "superClass" in node &&
-          node.superClass != null &&
-          typeof node.superClass === "object" &&
-          "type" in node.superClass &&
-          node.superClass.type === "Identifier" &&
-          "name" in node.superClass &&
-          typeof node.superClass.name === "string" &&
-          nativeErrors.has(node.superClass.name)
-        ) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message:
-                "Avoid extending native Error. Use Schema.TaggedErrorClass or Data.TaggedError.",
-            }),
-          )
-        }
-        return Effect.void
-      },
-    }
-  },
-})

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

@@ -1,77 +0,0 @@
-/**
- * Ban nested `Effect.flatMap` calls (flatMap ladder).
- *
- * Build context once with `Effect.all`/`Effect.map` and run a single flatMap.
- *
- * Source: biome-effect-linting-rules/no-flatmap-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 isEffectFlatMap = (node: ESTree.CallExpression): boolean =>
-  AST.isCallOf(node, "Effect", "flatMap")
-
-const containsEffectFlatMap = (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 && "arguments" in n) {
-    if (isEffectFlatMap(node as ESTree.CallExpression)) return true
-  }
-  if ("arguments" in n && Array.isArray(n["arguments"])) {
-    for (const arg of n["arguments"]) {
-      if (containsEffectFlatMap(arg)) return true
-    }
-  }
-  if ("body" in n) return containsEffectFlatMap(n["body"])
-  return false
-}
-
-export const noFlatmapLadder = Rule.define({
-  name: "no-flatmap-ladder",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid nested Effect.flatMap (flatMap ladder). Build context once with Effect.all and run a single flatMap.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const ce = node as ESTree.CallExpression
-        if (!isEffectFlatMap(ce)) return Effect.void
-        if (!("arguments" in ce) || !Array.isArray(ce.arguments)) return Effect.void
-
-        // Check if any argument's subtree contains another Effect.flatMap
-        for (const arg of ce.arguments) {
-          if (arg != null && typeof arg === "object" && "type" in arg) {
-            if (arg.type === "CallExpression" && isEffectFlatMap(arg as ESTree.CallExpression)) {
-              return ctx.report(
-                Diagnostic.make({
-                  node,
-                  message:
-                    "Nested Effect.flatMap detected. Build context with Effect.all, then single flatMap.",
-                }),
-              )
-            }
-            // Check inside arrow/function body
-            if (
-              (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") &&
-              "body" in arg &&
-              containsEffectFlatMap(arg.body)
-            ) {
-              return ctx.report(
-                Diagnostic.make({
-                  node,
-                  message:
-                    "Nested Effect.flatMap detected. Build context with Effect.all, then single flatMap.",
-                }),
-              )
-            }
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-fromnullable-coalesce.ts

@@ -1,62 +0,0 @@
-/**
- * Ban `Option.fromNullable(x ?? null)` / `Option.fromNullable(x ?? undefined)`.
- *
- * The nullish coalescing is redundant — pass the source directly.
- *
- * Source: biome-effect-linting-rules/no-fromnullable-nullish-coalesce
- */
-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 noFromNullableCoalesce = Rule.define({
-  name: "no-fromnullable-coalesce",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Redundant nullish coalescing in Option.fromNullable. Pass the value directly.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        // Match Option.fromNullable(...) or Option.fromNullishOr(...)
-        const ce = node as ESTree.CallExpression
-        const isFromNullable =
-          AST.isCallOf(ce, "Option", "fromNullable") ||
-          AST.isCallOf(ce, "Option", "fromNullishOr")
-        if (!isFromNullable) 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 === "LogicalExpression" &&
-            "operator" in arg &&
-            arg.operator === "??"
-          ) {
-            // Check RHS is null or undefined
-            if ("right" in arg && arg.right != null && typeof arg.right === "object" && "type" in arg.right) {
-              const rhs = arg.right
-              const isNullish =
-                (rhs.type === "Literal" && "value" in rhs && rhs.value === null) ||
-                (rhs.type === "Identifier" && "name" in rhs && rhs.name === "undefined")
-              if (isNullish) {
-                return ctx.report(
-                  Diagnostic.make({
-                    node,
-                    message:
-                      "Redundant ?? null/undefined in Option.fromNullable. Pass the value directly.",
-                  }),
-                )
-              }
-            }
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})