oxlint-plugin-effect 0.0.0

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

@@ -0,0 +1,51 @@
+/**
+ * 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 } from "../vendor/effect-oxlint/index.js"
+import { 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

@@ -0,0 +1,64 @@
+/**
+ * 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 } from "../vendor/effect-oxlint/index.js"
+import { 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

@@ -0,0 +1,92 @@
+/**
+ * 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 } from "../vendor/effect-oxlint/index.js"
+import { 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

@@ -0,0 +1,68 @@
+/**
+ * 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 } from "../vendor/effect-oxlint/index.js"
+import { 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

@@ -0,0 +1,72 @@
+/**
+ * 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 } from "../vendor/effect-oxlint/index.js"
+import { 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

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

@@ -0,0 +1,55 @@
+/**
+ * Ban `class Foo extends Error`.
+ *
+ * Use Schema.TaggedErrorClass or Data.TaggedError instead.
+ *
+ * Source: language-service/extendsNativeError
+ */
+import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { 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-fetch-in-effect.ts

@@ -0,0 +1,47 @@
+/**
+ * Ban `fetch()` inside Effect.gen/fn context.
+ *
+ * Use HttpClient from 'effect/unstable/http' instead.
+ *
+ * Source: language-service/globalFetchInEffect
+ */
+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 noFetchInEffect = Rule.define({
+  name: "no-fetch-in-effect",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid fetch() inside Effect.gen/fn. Use HttpClient from 'effect/unstable/http'.",
+  }),
+  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 === "fetch") {
+              return ctx.report(
+                Diagnostic.make({
+                  node,
+                  message:
+                    "Avoid fetch() inside Effect context. Use HttpClient from 'effect/unstable/http'.",
+                }),
+              )
+            }
+          }
+          return Effect.void
+        }),
+    })
+  },
+})

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

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