oxlint-plugin-effect 0.0.0 → 0.2.0

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

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

@@ -7,8 +7,7 @@
  *
  * Note: Very aggressive — should probably be off by default or in a strict preset only.
  */
-import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 export const noStringSentinelConst = Rule.define({

package/src/rules/no-ternary.ts

@@ -7,9 +7,7 @@
  *
  * Note: Very opinionated — recommended for strict functional presets only.
  */
-import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 
 export const noTernary = Rule.define({
   name: "no-ternary",

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

@@ -1,13 +1,39 @@
 /**
- * Ban `throw` statements.
+ * Ban `throw` statements. Context-aware messaging.
  *
- * Use Effect.fail or tagged errors instead.
+ * 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 { Rule } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, Visitor, RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Ref from "effect/Ref"
 
-export const noThrowStatement = Rule.banStatement("ThrowStatement", {
-  message: "Avoid throw. Use Effect.fail with tagged errors.",
-  meta: { type: "problem" },
+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,14 +1,39 @@
 /**
- * Ban `try/catch` statements.
+ * Ban `try/catch` statements. Context-aware messaging.
  *
- * Model failures in Effect's typed error channel.
+ * 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 { Rule } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, Visitor, RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Ref from "effect/Ref"
 
-export const noTryCatch = Rule.banStatement("TryStatement", {
-  message:
-    "Avoid try/catch. Model failures in Effect's typed error channel using Effect.try or Effect.tryPromise.",
-  meta: { type: "suggestion" },
+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

@@ -3,8 +3,7 @@
  *
  * Source: language-service/unnecessaryArrowBlock
  */
-import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 export const noUnnecessaryArrowBlock = Rule.define({

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

@@ -12,10 +12,8 @@
  * Source: language-service/unnecessaryEffectGen
  */
 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 { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
 
 export const noUnnecessaryEffectGen = Rule.define({
   name: "no-unnecessary-effect-gen",

package/src/rules/no-unnecessary-pipe-chain.ts

@@ -0,0 +1,47 @@
+/**
+ * Ban `x.pipe(f).pipe(g)` — merge into `x.pipe(f, g)`.
+ *
+ * Source: 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 isMethodPipe = (node: ESTree.Node): boolean => {
+  if (node.type !== "CallExpression") return false
+  const callee = (node as unknown as Record<string, unknown>)["callee"]
+  if (callee == null || typeof callee !== "object" || !("type" in callee)) return false
+  if (callee.type !== "MemberExpression") return false
+  const prop = (callee as unknown as Record<string, unknown>)["property"]
+  if (prop == null || typeof prop !== "object" || !("type" in prop)) return false
+  return prop.type === "Identifier" && "name" in prop && prop.name === "pipe"
+}
+
+export const noUnnecessaryPipeChain = Rule.define({
+  name: "no-unnecessary-pipe-chain",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid chaining .pipe().pipe(). Merge into a single .pipe() call.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!isMethodPipe(node)) return Effect.void
+        const callee = (node as unknown as Record<string, unknown>)["callee"] as Record<string, unknown>
+        const obj = callee["object"]
+        if (obj != null && typeof obj === "object" && isMethodPipe(obj as ESTree.Node)) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message:
+                "Unnecessary .pipe() chain. Merge into a single .pipe() call.",
+            }),
+          )
+        }
+        return Effect.void
+      },
+    }
+  },
+})

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

@@ -6,8 +6,7 @@
  * Source: language-service/unnecessaryPipe
  */
 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 { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"