oxlint-plugin-effect 0.2.0 → 0.2.2

package/src/rules/no-redundant-schema-tag-identifier.ts

@@ -1,62 +0,0 @@
-/**
- * Ban redundant `_tag` in `Schema.TaggedStruct("Foo", { _tag: Schema.Literal("Foo") })`.
- *
- * `TaggedStruct` already provides `_tag` automatically.
- *
- * Source: language-service/redundantSchemaTagIdentifier
- */
-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 isTagKey = (key: ESTree.Node): boolean => {
-  if (key.type === "Identifier" && "name" in key && key.name === "_tag") return true
-  if (key.type === "Literal" && "value" in key && key.value === "_tag") return true
-  return false
-}
-
-export const noRedundantSchemaTagIdentifier = Rule.define({
-  name: "no-redundant-schema-tag-identifier",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Redundant _tag in TaggedStruct. TaggedStruct already provides _tag automatically.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const call = node as ESTree.CallExpression
-        if (Option.isNone(AST.matchCallOf(call, "Schema", "TaggedStruct"))) return Effect.void
-
-        // TaggedStruct("tag", { fields })
-        const args = call.arguments
-        if (args.length < 2) return Effect.void
-        const fieldsArg = args[1]
-        if (fieldsArg === undefined) return Effect.void
-        if (fieldsArg.type !== "ObjectExpression") return Effect.void
-
-        const props = (fieldsArg as unknown as Record<string, unknown>)["properties"]
-        if (!Array.isArray(props)) return Effect.void
-
-        for (const prop of props) {
-          const p = prop as ESTree.Node
-          if (p.type !== "Property") continue
-          const key = (p as unknown as Record<string, unknown>)["key"] as ESTree.Node
-          if (isTagKey(key)) {
-            return ctx.report(
-              Diagnostic.make({
-                node: p,
-                message:
-                  "Redundant _tag property. Schema.TaggedStruct already provides _tag automatically.",
-              }),
-            )
-          }
-        }
-
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-return-in-arrow.ts

@@ -1,76 +0,0 @@
-/**
- * Ban explicit `return` in arrow function callbacks (info severity).
- *
- * Use expression-only callbacks + pipeline logic.
- * Excludes Schema.filter callbacks where return is required.
- *
- * Source: biome-effect-linting-rules/no-return-in-arrow
- */
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-export const noReturnInArrow = Rule.define({
-  name: "no-return-in-arrow",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Prefer expression-only arrow callbacks. Avoid explicit return in arrow functions.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      ArrowFunctionExpression: (node) => {
-        if (
-          "body" in node &&
-          node.body != null &&
-          typeof node.body === "object" &&
-          "type" in node.body &&
-          node.body.type === "BlockStatement" &&
-          "body" in node.body &&
-          Array.isArray(node.body.body)
-        ) {
-          for (const stmt of node.body.body) {
-            if (
-              stmt != null &&
-              typeof stmt === "object" &&
-              "type" in stmt &&
-              stmt.type === "ReturnStatement"
-            ) {
-              // Check if parent is a Schema.filter call — skip those
-              if (
-                "parent" in node &&
-                node.parent != null &&
-                typeof node.parent === "object" &&
-                "type" in node.parent &&
-                node.parent.type === "CallExpression" &&
-                "callee" in node.parent
-              ) {
-                const callee = node.parent.callee
-                if (
-                  callee != null &&
-                  typeof callee === "object" &&
-                  "type" in callee &&
-                  callee.type === "MemberExpression" &&
-                  "property" in callee &&
-                  callee.property != null &&
-                  typeof callee.property === "object" &&
-                  "name" in callee.property &&
-                  (callee.property.name === "filter" || callee.property.name === "check")
-                ) {
-                  return Effect.void
-                }
-              }
-
-              return ctx.report(
-                Diagnostic.make({
-                  node: stmt,
-                  message: "Prefer expression-only arrow callbacks over explicit return.",
-                }),
-              )
-            }
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-return-nullish.ts

@@ -1,80 +0,0 @@
-/**
- * Ban `return null`, `return undefined`, `return void 0`. Context-aware messaging.
- *
- * Inside Effect.gen/fn: "Use Option.none() or Effect.void"
- * Outside: "Use Option.none() — convert nullish at system boundaries with Option.fromNullable"
- *
- * Source: biome-effect-linting-rules/no-return-null (extended)
- */
-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 noReturnNullish = Rule.define({
-  name: "no-return-nullish",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid returning null/undefined. Use Option.none() for absence or Effect.void for void effects.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(tracker, {
-      ReturnStatement: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) => {
-          if (
-            node.type !== "ReturnStatement" ||
-            !("argument" in node) ||
-            node.argument === null ||
-            node.argument === undefined
-          ) {
-            return Effect.void
-          }
-
-          const arg = node.argument as unknown as Record<string, unknown>
-
-          // return null
-          if (arg["type"] === "Literal" && arg["value"] === null) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message: d > 0
-                  ? "Avoid returning null inside Effect.gen/fn. Use Option.none() for absence, or yield* Effect.fail(new MyError()) for errors."
-                  : "Avoid returning null. Use Option.none() for absence — convert nullish values at system boundaries with Option.fromNullable().",
-              }),
-            )
-          }
-
-          // return undefined
-          if (arg["type"] === "Identifier" && arg["name"] === "undefined") {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message: d > 0
-                  ? "Avoid returning undefined inside Effect.gen/fn. Use Effect.void for void effects, or Option.none() for absence."
-                  : "Avoid returning undefined. Use Option.none() for absence, or restructure as an Effect returning void.",
-              }),
-            )
-          }
-
-          // return void 0
-          if (arg["type"] === "UnaryExpression" && arg["operator"] === "void") {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message: d > 0
-                  ? "Avoid returning void inside Effect.gen/fn. Use Effect.void for void effects."
-                  : "Avoid returning void expression. Use Option.none() for absence.",
-              }),
-            )
-          }
-
-          return Effect.void
-        }),
-    })
-  },
-})

package/src/rules/no-run-in-effect-gen.ts

@@ -1,66 +0,0 @@
-/**
- * Ban `Effect.run*` and `Runtime.run*` calls inside `Effect.gen`/`Effect.fn`.
- *
- * Running an effect inside a generator drops the ambient context — fibers,
- * services, tracing, and memoized layers. Just `yield*` the child effect;
- * for callback boundaries use `Effect.async`, for fork use `Effect.fork`.
- *
- * Explicitly allowed inside gen: `Effect.runForkWith`, `Effect.runPromiseWith`,
- * `Effect.runSyncWith` (they take services explicitly — legitimate at
- * callback boundaries) and `managedRuntime.runX` on identifier callees
- * (can't be discriminated syntactically).
- *
- * Source: language-service/runEffectInsideEffect, extended for v4.
- */
-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"
-
-import { makeEffectContextTracker } from "./_effect-context.js"
-
-const effectRunMethods = ["runSync", "runPromise", "runFork", "runCallback"]
-const runtimeRunMethods = ["runSync", "runPromise", "runFork", "runCallback"]
-
-export const noRunInEffectGen = Rule.define({
-  name: "no-run-in-effect-gen",
-  meta: Rule.meta({
-    type: "problem",
-    description:
-      "Running effects inside Effect.gen/fn drops the ambient context. Use yield* instead.",
-  }),
-  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) return Effect.void
-          const call = node as ESTree.CallExpression
-
-          if (AST.isCallOf(call, "Effect", effectRunMethods)) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message:
-                  "Avoid Effect.run* inside Effect.gen/fn. `yield*` the child effect, or use Effect.fork for concurrency.",
-              }),
-            )
-          }
-
-          if (AST.isCallOf(call, "Runtime", runtimeRunMethods)) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message:
-                  "Avoid Runtime.run* inside Effect.gen/fn. The ambient context already has your services — `yield*` the child effect.",
-              }),
-            )
-          }
-
-          return Effect.void
-        }),
-    })
-  },
-})

package/src/rules/no-runtime-run-fork.ts

@@ -1,14 +0,0 @@
-/**
- * Ban `Runtime.runFork`.
- *
- * Use `forkScoped`, `Stream`, or runtime-provided layers.
- *
- * Source: biome-effect-linting-rules/no-runtime-runfork
- */
-import { Rule } from "../vendor/effect-oxlint/index.js"
-
-export const noRuntimeRunFork = Rule.banMember("Runtime", "runFork", {
-  message:
-    "Avoid Runtime.runFork. Use forkScoped, Stream, or runtime-provided layers.",
-  meta: { type: "problem", effectVersion: "v3" },
-})

package/src/rules/no-schema-struct-with-tag.ts

@@ -1,64 +0,0 @@
-/**
- * Ban `Schema.Struct({ _tag: Schema.Literal("Foo"), ... })`.
- * Use `Schema.TaggedStruct("Foo", { ... })` instead.
- *
- * Source: language-service/schemaStructWithTag
- */
-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 isTagKey = (key: ESTree.Node): boolean => {
-  if (key.type === "Identifier" && "name" in key && key.name === "_tag") return true
-  if (key.type === "Literal" && "value" in key && key.value === "_tag") return true
-  return false
-}
-
-export const noSchemaStructWithTag = Rule.define({
-  name: "no-schema-struct-with-tag",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      'Use Schema.TaggedStruct("Tag", { ... }) instead of Schema.Struct({ _tag: Schema.Literal("Tag"), ... }).',
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const call = node as ESTree.CallExpression
-        if (Option.isNone(AST.matchCallOf(call, "Schema", "Struct"))) return Effect.void
-
-        const args = call.arguments
-        if (args.length !== 1) return Effect.void
-        const arg = args[0]
-        if (arg === undefined) return Effect.void
-        if (arg.type !== "ObjectExpression") return Effect.void
-
-        const props = (arg as unknown as Record<string, unknown>)["properties"]
-        if (!Array.isArray(props)) return Effect.void
-
-        for (const prop of props) {
-          const p = prop as ESTree.Node
-          if (p.type !== "Property") continue
-          const key = (p as unknown as Record<string, unknown>)["key"] as ESTree.Node
-          if (!isTagKey(key)) continue
-
-          // Check value is Schema.Literal(...)
-          const value = (p as unknown as Record<string, unknown>)["value"] as ESTree.Node
-          if (value.type === "CallExpression" && Option.isSome(AST.matchCallOf(value as ESTree.CallExpression, "Schema", "Literal"))) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message:
-                  'Use Schema.TaggedStruct("Tag", { ... }) instead of Schema.Struct({ _tag: Schema.Literal(...), ... }).',
-              }),
-            )
-          }
-        }
-
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-schema-union-of-literals.ts

@@ -1,48 +0,0 @@
-/**
- * Ban `Schema.Union(Schema.Literal("a"), Schema.Literal("b"))`.
- * Use `Schema.Literal("a", "b")` instead.
- *
- * Source: language-service/schemaUnionOfLiterals
- */
-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 isSchemaLiteral = (node: ESTree.Node): boolean => {
-  if (node.type !== "CallExpression") return false
-  return Option.isSome(AST.matchCallOf(node as ESTree.CallExpression, "Schema", "Literal"))
-}
-
-export const noSchemaUnionOfLiterals = Rule.define({
-  name: "no-schema-union-of-literals",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Use Schema.Literal('a', 'b') instead of Schema.Union(Schema.Literal('a'), Schema.Literal('b')).",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const call = node as ESTree.CallExpression
-        if (Option.isNone(AST.matchCallOf(call, "Schema", "Union"))) return Effect.void
-
-        const args = call.arguments
-        if (args.length < 2) return Effect.void
-
-        // Check if all arguments are Schema.Literal calls
-        const allLiterals = args.every((arg) => isSchemaLiteral(arg as ESTree.Node))
-        if (!allLiterals) return Effect.void
-
-        return ctx.report(
-          Diagnostic.make({
-            node,
-            message:
-              "Use Schema.Literal('a', 'b') instead of Schema.Union(Schema.Literal('a'), Schema.Literal('b')).",
-          }),
-        )
-      },
-    }
-  },
-})

package/src/rules/no-string-sentinel-const.ts

@@ -1,49 +0,0 @@
-/**
- * Ban `const x = "some-string"` string literal const declarations.
- *
- * Use tagged unions, Option, or meaningful domain values.
- *
- * Source: biome-effect-linting-rules/no-string-sentinel-const
- *
- * Note: Very aggressive — should probably be off by default or in a strict preset only.
- */
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-export const noStringSentinelConst = Rule.define({
-  name: "no-string-sentinel-const",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid string literal const declarations. Use tagged unions or domain values.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      VariableDeclarator: (node) => {
-        if (!("init" in node) || node.init == null) return Effect.void
-        const init = node.init as unknown as Record<string, unknown>
-
-        if (init["type"] === "Literal" && typeof init["value"] === "string") {
-          // Check parent is const declaration
-          if (
-            "parent" in node &&
-            node.parent != null &&
-            typeof node.parent === "object" &&
-            "type" in node.parent &&
-            node.parent.type === "VariableDeclaration" &&
-            "kind" in node.parent &&
-            node.parent.kind === "const"
-          ) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message: "Avoid string literal const. Use tagged unions, Option, or domain values.",
-              }),
-            )
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-switch-statement.ts

@@ -1,13 +0,0 @@
-/**
- * Ban `switch` statements.
- *
- * Use `Match.value`, `Option.match`, `Either.match` instead.
- *
- * Source: biome-effect-linting-rules/no-switch-statement
- */
-import { Rule } from "../vendor/effect-oxlint/index.js"
-
-export const noSwitchStatement = Rule.banStatement("SwitchStatement", {
-  message: "Avoid switch statements. Use Match.value, Option.match, or Either.match.",
-  meta: { type: "suggestion" },
-})

package/src/rules/no-ternary.ts

@@ -1,30 +0,0 @@
-/**
- * Ban ternary expressions in Effect codebases.
- *
- * Use `Option.match`, `Either.match`, `Match.value` instead.
- *
- * Source: biome-effect-linting-rules/no-ternary
- *
- * Note: Very opinionated — recommended for strict functional presets only.
- */
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-
-export const noTernary = Rule.define({
-  name: "no-ternary",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid ternary expressions. Use Option.match, Either.match, or Match.value.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      ConditionalExpression: (node) =>
-        ctx.report(
-          Diagnostic.make({
-            node,
-            message: "Avoid ternary expressions. Use Option.match, Either.match, or Match.value.",
-          }),
-        ),
-    }
-  },
-})

package/src/rules/no-throw-statement.ts

@@ -1,39 +0,0 @@
-/**
- * Ban `throw` statements. Context-aware messaging.
- *
- * Inside Effect.gen/fn: "Use yield* Effect.fail() or yield* new MyError()"
- * Outside: "Model errors with Effect.fail() — wrap this function with Effect.fn"
- *
- * Source: effect convention — errors should be in the type system
- */
-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 noThrowStatement = Rule.define({
-  name: "no-throw-statement",
-  meta: Rule.meta({
-    type: "problem",
-    description: "Avoid throw. Use Effect.fail with tagged errors.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(tracker, {
-      ThrowStatement: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) =>
-          ctx.report(
-            Diagnostic.make({
-              node,
-              message: d > 0
-                ? "Avoid throw inside Effect.gen/fn. Use yield* Effect.fail(new MyError()) or yield* new MyError() for yieldable errors."
-                : "Avoid throw. Model errors with Effect — wrap this function with Effect.fn and use Effect.fail with tagged errors.",
-            }),
-          ),
-        ),
-    })
-  },
-})

package/src/rules/no-try-catch.ts

@@ -1,39 +0,0 @@
-/**
- * Ban `try/catch` statements. Context-aware messaging.
- *
- * Inside Effect.gen/fn: "Use Effect.try or Effect.tryPromise"
- * Outside: "Wrap with Effect.fn and use Effect.try for error handling"
- *
- * Source: biome-effect-linting-rules/no-try-catch, language-service/tryCatchInEffectGen
- */
-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 noTryCatch = Rule.define({
-  name: "no-try-catch",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid try/catch. Use Effect.try or Effect.tryPromise.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(tracker, {
-      TryStatement: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) =>
-          ctx.report(
-            Diagnostic.make({
-              node,
-              message: d > 0
-                ? "Avoid try/catch inside Effect.gen/fn. Use Effect.try({ try: () => ..., catch: (e) => new MyError({ cause: e }) })."
-                : "Avoid try/catch. Wrap this function with Effect.fn and use Effect.try or Effect.tryPromise for error handling.",
-            }),
-          ),
-        ),
-    })
-  },
-})

package/src/rules/no-unnecessary-arrow-block.ts

@@ -1,51 +0,0 @@
-/**
- * Ban `() => { return x }` — use `() => x` instead.
- *
- * Source: language-service/unnecessaryArrowBlock
- */
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-export const noUnnecessaryArrowBlock = Rule.define({
-  name: "no-unnecessary-arrow-block",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Unnecessary arrow block body. Use concise arrow `() => expr`.",
-    fixable: "code",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      ArrowFunctionExpression: (node) => {
-        if (
-          "body" in node &&
-          node.body != null &&
-          typeof node.body === "object" &&
-          "type" in node.body &&
-          node.body.type === "BlockStatement" &&
-          "body" in node.body &&
-          Array.isArray(node.body.body) &&
-          node.body.body.length === 1
-        ) {
-          const stmt = node.body.body[0]
-          if (
-            stmt != null &&
-            typeof stmt === "object" &&
-            "type" in stmt &&
-            stmt.type === "ReturnStatement" &&
-            "argument" in stmt &&
-            stmt.argument != null
-          ) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message: "Unnecessary arrow block body. Use `() => expr` instead of `() => { return expr }`.",
-              }),
-            )
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})