oxlint-plugin-effect 0.2.0 → 0.2.2

package/src/rules/no-match-void-branch.ts

@@ -1,72 +0,0 @@
-/**
- * Ban `Match.when(true/false, () => Effect.void)` and `Match.orElse(() => Effect.void)`.
- *
- * Remove the no-op branch or restructure.
- *
- * Source: biome-effect-linting-rules/no-match-void-branch
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-const isEffectVoid = (node: unknown): boolean => {
-  if (node == null || typeof node !== "object") return false
-  const n = node as Record<string, unknown>
-  if (n["type"] !== "MemberExpression") return false
-  const obj = n["object"] as Record<string, unknown> | null
-  const prop = n["property"] as Record<string, unknown> | null
-  return (
-    obj != null && obj["type"] === "Identifier" && obj["name"] === "Effect" &&
-    prop != null && prop["type"] === "Identifier" && prop["name"] === "void"
-  )
-}
-
-const isVoidCallback = (node: unknown): boolean => {
-  if (node == null || typeof node !== "object") return false
-  const n = node as Record<string, unknown>
-  if (n["type"] !== "ArrowFunctionExpression" && n["type"] !== "FunctionExpression") return false
-  if (!("body" in n)) return false
-  return isEffectVoid(n["body"])
-}
-
-export const noMatchVoidBranch = Rule.define({
-  name: "no-match-void-branch",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid no-op Match branches returning Effect.void. Remove the branch or restructure.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const ce = node as ESTree.CallExpression
-        const isMatchWhen = AST.isCallOf(ce, "Match", "when")
-        const isMatchOrElse = AST.isCallOf(ce, "Match", "orElse")
-
-        if (!isMatchWhen && !isMatchOrElse) return Effect.void
-
-        if (!("arguments" in node) || !Array.isArray(node.arguments)) return Effect.void
-
-        if (isMatchOrElse && node.arguments.length >= 1 && isVoidCallback(node.arguments[0])) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message: "Match.orElse returning Effect.void is a no-op. Remove the branch or restructure.",
-            }),
-          )
-        }
-
-        if (isMatchWhen && node.arguments.length >= 2 && isVoidCallback(node.arguments[1])) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message: "Match.when branch returning Effect.void is a no-op. Remove the branch or restructure.",
-            }),
-          )
-        }
-
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-multiple-effect-provide.ts

@@ -1,75 +0,0 @@
-/**
- * Ban consecutive `Effect.provide()` calls — merge into one.
- *
- * Detects: `effect.pipe(Effect.provide(A), Effect.provide(B))`
- * Suggests: `effect.pipe(Effect.provide(Layer.mergeAll(A, B)))`
- *
- * This is an AST heuristic — it catches the common patterns without
- * needing the type checker to confirm they're actually Layer values.
- *
- * Source: language-service/multipleEffectProvide
- */
-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 isEffectProvide = (node: ESTree.Node): boolean => {
-  if (node.type !== "CallExpression") return false
-  return Option.isSome(AST.matchCallOf(node as ESTree.CallExpression, "Effect", "provide"))
-}
-
-const countProvides = (args: ReadonlyArray<ESTree.Node>): number => {
-  let count = 0
-  for (const arg of args) {
-    if (isEffectProvide(arg as ESTree.Node)) count++
-  }
-  return count
-}
-
-export const noMultipleEffectProvide = Rule.define({
-  name: "no-multiple-effect-provide",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid consecutive Effect.provide() calls. Merge into Effect.provide(Layer.mergeAll(...)).",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const call = node as ESTree.CallExpression
-        const args = call.arguments
-        if (args.length < 3) return Effect.void
-
-        // Check bare pipe() or .pipe() with multiple Effect.provide args
-        const calleeName = Option.getOrUndefined(AST.calleeName(call))
-        const callee = call.callee
-
-        const isPipe =
-          calleeName === "pipe" ||
-          (callee.type === "MemberExpression" &&
-            "property" in callee &&
-            (callee as unknown as Record<string, unknown>)["computed"] !== true &&
-            (() => {
-              const prop = (callee as unknown as Record<string, unknown>)["property"]
-              return prop != null && typeof prop === "object" && "name" in prop && prop.name === "pipe"
-            })())
-
-        if (!isPipe) return Effect.void
-
-        if (countProvides(args as ReadonlyArray<ESTree.Node>) >= 2) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message:
-                "Multiple Effect.provide() in pipe. Merge into Effect.provide(Layer.mergeAll(...)).",
-            }),
-          )
-        }
-
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-nested-effect-call.ts

@@ -1,57 +0,0 @@
-/**
- * Ban nested Effect.* calls — `Effect.outer(Effect.inner(...))`.
- *
- * Build values first, then one flat pipeline.
- *
- * Sources: biome-effect-linting-rules/no-nested-effect-call, no-effect-call-in-effect-arg, no-call-tower, no-effect-ladder
- */
-import type { ESTree } from "@oxlint/plugins"
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-const isEffectCall = (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"]
-  if (obj == null || typeof obj !== "object") return false
-  const o = obj as Record<string, unknown>
-  return o["type"] === "Identifier" && o["name"] === "Effect"
-}
-
-export const noNestedEffectCall = Rule.define({
-  name: "no-nested-effect-call",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid nesting Effect.* calls. Build values first, then use a flat pipeline.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        if (!isEffectCall(node)) return Effect.void
-
-        const ce = node as ESTree.CallExpression
-        if (!("arguments" in ce) || !Array.isArray(ce.arguments)) return Effect.void
-
-        for (const arg of ce.arguments) {
-          if (isEffectCall(arg)) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message:
-                  "Nested Effect.* call detected. Build values first, then use a flat pipeline.",
-              }),
-            )
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})

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

@@ -1,43 +0,0 @@
-/**
- * Ban nested `Effect.gen` calls.
- *
- * An `Effect.gen` inside another `Effect.gen` should be flattened.
- *
- * Sources: biome-effect-linting-rules/no-nested-effect-gen, language-service/nestedEffectGenYield
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, Visitor, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Ref from "effect/Ref"
-
-export const noNestedEffectGen = Rule.define({
-  name: "no-nested-effect-gen",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid nested Effect.gen. Flatten to a single Effect.gen per method.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const depth = yield* Ref.make(0)
-
-    return Visitor.merge(
-      Visitor.tracked("CallExpression", (node) => AST.isCallOf(node, "Effect", "gen"), depth),
-      {
-        CallExpression: (node) =>
-          Effect.flatMap(Ref.get(depth), (d) => {
-            if (d > 1 && AST.isCallOf(node as ESTree.CallExpression, "Effect", "gen")) {
-              return ctx.report(
-                Diagnostic.make({
-                  node,
-                  message:
-                    "Nested Effect.gen detected. Flatten to a single Effect.gen.",
-                }),
-              )
-            }
-            return Effect.void
-          }),
-      },
-    )
-  },
-})

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

@@ -1,73 +0,0 @@
-/**
- * Ban nested `pipe()` calls — `pipe(pipe(...), ...)` or `.pipe(...).pipe(...)`.
- *
- * Flatten into a single pipeline.
- *
- * Sources: biome-effect-linting-rules/no-pipe-ladder, language-service/unnecessaryPipeChain
- */
-import type { ESTree } from "@oxlint/plugins"
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-const isPipeCall = (node: ESTree.Node): boolean => {
-  if (node.type === "CallExpression" && "callee" in node) {
-    const callee = (node as unknown as Record<string, unknown>)["callee"]
-    if (callee != null && typeof callee === "object" && "type" in callee) {
-      // pipe(...)
-      if (callee.type === "Identifier" && "name" in callee && callee.name === "pipe") {
-        return true
-      }
-      // x.pipe(...)
-      if (
-        callee.type === "MemberExpression" &&
-        "property" in callee &&
-        callee.property != null &&
-        typeof callee.property === "object" &&
-        "type" in callee.property &&
-        callee.property.type === "Identifier" &&
-        "name" in callee.property &&
-        callee.property.name === "pipe"
-      ) {
-        return true
-      }
-    }
-  }
-  return false
-}
-
-export const noNestedPipe = Rule.define({
-  name: "no-nested-pipe",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid nested pipe() calls. Flatten into a single pipeline.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        if (!isPipeCall(node)) return Effect.void
-
-        // Check if any argument is itself a pipe call
-        if ("arguments" in node && Array.isArray(node.arguments)) {
-          for (const arg of node.arguments) {
-            if (
-              arg != null &&
-              typeof arg === "object" &&
-              "type" in arg &&
-              isPipeCall(arg as unknown as ESTree.Node)
-            ) {
-              return ctx.report(
-                Diagnostic.make({
-                  node: arg,
-                  message:
-                    "Nested pipe() detected. Flatten into a single pipeline.",
-                }),
-              )
-            }
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-new-error.ts

@@ -1,53 +0,0 @@
-/**
- * Ban `new Error(...)` and native error constructors. Context-aware messaging.
- *
- * Inside Effect.gen/fn: "Use yield* new MyError() (yieldable TaggedErrorClass)"
- * Outside: "Define class MyError extends Schema.TaggedErrorClass..."
- *
- * Source: language-service/globalErrorInEffectFailure, extendsNativeError
- */
-import type { ESTree } from "@oxlint/plugins"
-import { Diagnostic, Rule, Visitor, 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"
-
-const nativeErrors = new Set([
-  "Error", "TypeError", "RangeError", "ReferenceError", "SyntaxError",
-  "URIError", "EvalError",
-])
-
-export const noNewError = Rule.define({
-  name: "no-new-error",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid native Error constructors. Use Schema.TaggedErrorClass.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(tracker, {
-      NewExpression: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) => {
-          const callee = (node as unknown as Record<string, unknown>)["callee"] as ESTree.Node
-          if (
-            callee.type === "Identifier" &&
-            "name" in callee &&
-            nativeErrors.has(callee.name as string)
-          ) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message: d > 0
-                  ? "Avoid native Error inside Effect.gen/fn. Define: class MyError extends Schema.TaggedErrorClass<MyError>()(\"MyError\", { ... }) {} — then yield* new MyError()."
-                  : "Avoid native Error constructors. Define: class MyError extends Schema.TaggedErrorClass<MyError>()(\"MyError\", { message: Schema.String }) {}",
-              }),
-            )
-          }
-          return Effect.void
-        }),
-    })
-  },
-})

package/src/rules/no-new-promise.ts

@@ -1,50 +0,0 @@
-/**
- * Ban `new Promise()`. Context-aware messaging.
- *
- * Inside Effect.gen/fn: "Use Effect.tryPromise or Effect.async"
- * Outside: "Use Effect.tryPromise or wrap with Effect.fn"
- *
- * Source: language-service/newPromise
- */
-import { Diagnostic, Rule, Visitor, 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 noNewPromise = Rule.define({
-  name: "no-new-promise",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid new Promise(). Use Effect.async or Effect.tryPromise.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(tracker, {
-      NewExpression: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) => {
-          const callee = (node as unknown as Record<string, unknown>)["callee"]
-          if (
-            callee != null &&
-            typeof callee === "object" &&
-            "type" in callee &&
-            callee.type === "Identifier" &&
-            "name" in callee &&
-            callee.name === "Promise"
-          ) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message: d > 0
-                  ? "Avoid new Promise() inside Effect.gen/fn. Use Effect.async for callback APIs, Effect.tryPromise for existing promises, or Effect.promise for infallible promises."
-                  : "Avoid new Promise(). Use Effect.async for callback APIs, Effect.tryPromise for existing promises — wrap this function with Effect.fn.",
-              }),
-            )
-          }
-          return Effect.void
-        }),
-    })
-  },
-})

package/src/rules/no-node-builtin-import.ts

@@ -1,68 +0,0 @@
-/**
- * Ban Node.js builtin imports.
- *
- * Use Effect platform services: FileSystem, Path, HttpClient, Command.
- *
- * Source: language-service/nodeBuiltinImport
- */
-import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-
-const hints: Record<string, string> = {
-  fs: "Use FileSystem from 'effect'",
-  path: "Use Path from 'effect'",
-  http: "Use HttpClient from 'effect/unstable/http'",
-  https: "Use HttpClient from 'effect/unstable/http'",
-  child_process: "Use Command from 'effect'",
-  crypto: "Use a service wrapper",
-  os: "Use PlatformInfo from 'effect'",
-  net: "Use HttpServer from 'effect/unstable/http'",
-  dns: "Use a service wrapper",
-  tls: "Use a service wrapper",
-  dgram: "Use a service wrapper",
-  stream: "Use Stream from 'effect'",
-  zlib: "Use a service wrapper",
-  readline: "Use Terminal from 'effect'",
-  cluster: "Use a service wrapper",
-  worker_threads: "Use a service wrapper",
-}
-
-const nodeBuiltins = new Set(Object.keys(hints))
-
-const resolveModule = (source: string): string | undefined => {
-  const name = source.startsWith("node:") ? source.slice(5) : source
-  const base = name.split("/")[0]
-  return base !== undefined && nodeBuiltins.has(base) ? base : undefined
-}
-
-export const noNodeBuiltinImport = Rule.define({
-  name: "no-node-builtin-import",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid Node.js builtin imports. Use Effect platform services.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      ImportDeclaration: (node) => {
-        const source = Option.getOrUndefined(
-          AST.narrow(node, "ImportDeclaration").pipe(Option.map(AST.importSource)),
-        )
-        if (source === undefined) return Effect.void
-
-        const mod = resolveModule(source)
-        if (mod === undefined) return Effect.void
-
-        const hint = hints[mod] ?? "Use an Effect service wrapper"
-        return ctx.report(
-          Diagnostic.make({
-            node,
-            message: `Avoid importing '${source}'. ${hint}.`,
-          }),
-        )
-      },
-    }
-  },
-})

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

@@ -1,13 +0,0 @@
-/**
- * Ban `Option.as`.
- *
- * Use `Option.map` or `Option.match` with explicit value return.
- *
- * Source: biome-effect-linting-rules/no-option-as
- */
-import { Rule } from "../vendor/effect-oxlint/index.js"
-
-export const noOptionAs = Rule.banMember("Option", "as", {
-  message: "Avoid Option.as. Use Option.map or Option.match instead.",
-  meta: { type: "suggestion" },
-})

package/src/rules/no-option-boolean-normalization.ts

@@ -1,88 +0,0 @@
-/**
- * Ban `Option.match(x, { onSome: (v) => v === true, onNone: () => false })`.
- *
- * Normalize at the schema boundary instead.
- *
- * Source: biome-effect-linting-rules/no-option-boolean-normalization
- */
-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 noOptionBooleanNormalization = Rule.define({
-  name: "no-option-boolean-normalization",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid Option.match for boolean normalization. Normalize at schema boundary.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        if (!AST.isCallOf(node as ESTree.CallExpression, "Option", "match")) return Effect.void
-
-        if (!("arguments" in node) || !Array.isArray(node.arguments) || node.arguments.length < 2)
-          return Effect.void
-
-        const opts = node.arguments[1]
-        if (opts == null || typeof opts !== "object" || !("type" in opts)) return Effect.void
-        if (opts.type !== "ObjectExpression" || !("properties" in opts) || !Array.isArray(opts.properties))
-          return Effect.void
-
-        let hasTripleEqualTrue = false
-        let hasReturnFalse = false
-
-        for (const prop of opts.properties) {
-          if (prop == null || typeof prop !== "object" || !("type" in prop) || prop.type !== "Property")
-            continue
-          const key = (prop as unknown as Record<string, unknown>)["key"] as unknown as Record<string, unknown> | null
-          const value = (prop as unknown as Record<string, unknown>)["value"] as unknown as Record<string, unknown> | null
-
-          if (key == null || value == null) continue
-
-          // onSome: (v) => v === true
-          if (
-            key["type"] === "Identifier" && key["name"] === "onSome" &&
-            value["type"] === "ArrowFunctionExpression" && "body" in value
-          ) {
-            const body = value["body"] as unknown as Record<string, unknown> | null
-            if (
-              body != null &&
-              body["type"] === "BinaryExpression" &&
-              body["operator"] === "===" &&
-              "right" in body
-            ) {
-              const right = body["right"] as unknown as Record<string, unknown> | null
-              if (right != null && right["type"] === "Literal" && right["value"] === true) {
-                hasTripleEqualTrue = true
-              }
-            }
-          }
-
-          // onNone: () => false
-          if (
-            key["type"] === "Identifier" && key["name"] === "onNone" &&
-            value["type"] === "ArrowFunctionExpression" && "body" in value
-          ) {
-            const body = value["body"] as unknown as Record<string, unknown> | null
-            if (body != null && body["type"] === "Literal" && body["value"] === false) {
-              hasReturnFalse = true
-            }
-          }
-        }
-
-        if (hasTripleEqualTrue && hasReturnFalse) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message:
-                "Avoid Option.match for boolean normalization. Normalize at schema boundary instead.",
-            }),
-          )
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-positional-log-error.ts

@@ -1,76 +0,0 @@
-/**
- * Ban positional error/cause arguments in Effect.log* calls.
- *
- * `Effect.logWarning("message", error)` loses error structure.
- * Use `Effect.logWarning("message").pipe(Effect.annotateLogs({ error }))` instead,
- * or pass cause via `Effect.logWarning("message", Cause.fail(error))`.
- *
- * Source: agent session analysis — 57 occurrences across 6 projects
- */
-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 logMethods = new Set([
-  "log",
-  "logDebug",
-  "logInfo",
-  "logWarning",
-  "logError",
-  "logFatal",
-  "logTrace",
-])
-
-export const noPositionalLogError = Rule.define({
-  name: "no-positional-log-error",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid passing errors as positional arguments to Effect.log*. Use Effect.annotateLogs instead.",
-  }),
-  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") return Effect.void
-        if (!logMethods.has(prop)) return Effect.void
-
-        // Effect.log* with more than 1 argument — the second arg is likely
-        // an error/cause being passed positionally
-        const args = call.arguments
-        if (args.length < 2) return Effect.void
-
-        // The first arg should be a string message. If second arg exists,
-        // it's likely an error being passed positionally.
-        const secondArg = args[1]
-        if (secondArg === undefined) return Effect.void
-
-        // Allow Cause.fail/Cause.die as second arg (that's the proper API)
-        if (secondArg.type === "CallExpression") {
-          const secondNames = Option.getOrUndefined(
-            AST.memberNames((secondArg as ESTree.CallExpression).callee as ESTree.MemberExpression),
-          )
-          if (secondNames !== undefined) {
-            const [sObj] = secondNames
-            if (sObj === "Cause") return Effect.void
-          }
-        }
-
-        return ctx.report(
-          Diagnostic.make({
-            node: secondArg,
-            message:
-              `Avoid passing errors as positional args to Effect.${prop}. Use .pipe(Effect.annotateLogs({ error: String(err) })) or pass a Cause.`,
-          }),
-        )
-      },
-    }
-  },
-})