@doubleloop-io/oxlint-plugin-effect 0.0.0-stage → 0.1.0-rc.0

package/dist/rules/no-asymmetric-match-handlers.js

@@ -0,0 +1,74 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isEffectFnApplication, isFunctionNode } from "../shared/effect-ast.js";
+import { handlersOf, isMatchCall } from "../shared/match-ast.js";
+const isDelegation = (node) => node?.type === "Identifier" ||
+    node?.type === "MemberExpression" ||
+    node?.type === "CallExpression" ||
+    node?.type === "NewExpression";
+const isEffectBody = (node) => node.type === "CallExpression" &&
+    (isEffectFnApplication(node) || calleeOf(node, "Effect") === "gen") &&
+    node.arguments.some(isFunctionNode);
+const shapeOfResult = (node) => {
+    if (!node)
+        return "value";
+    if (isEffectBody(node))
+        return "inline";
+    return isDelegation(node) ? "delegating" : "value";
+};
+// Literals, templates, arrays and ternaries produce a value rather than implement a step,
+// so they sit on either side of an asymmetry without breaking it.
+const shapeOf = (handler) => {
+    if (!isFunctionNode(handler))
+        return shapeOfResult(handler);
+    if (!handler.body)
+        return "value";
+    if (handler.generator)
+        return "inline";
+    if (handler.body.type !== "BlockStatement")
+        return shapeOfResult(handler.body);
+    const [only, ...rest] = handler.body.body;
+    if (!only)
+        return "value";
+    if (rest.length > 0 || only.type !== "ReturnStatement")
+        return "inline";
+    return shapeOfResult(only.argument);
+};
+const effectFnName = (handler) => {
+    if (handler.type !== "CallExpression" || handler.callee.type !== "CallExpression")
+        return;
+    const [name] = handler.callee.arguments;
+    return name?.type === "Literal" && typeof name.value === "string" ? name.value : undefined;
+};
+export const noAsymmetricMatchHandlersRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Keep the handlers of a match at one level of abstraction: when one delegates to a named function, extract the inline ones too.",
+        },
+        messages: {
+            inlineHandler: "This handler is implemented inline while another branch of the same match delegates to a named function. Extract it into a named function{{hint}} and call it from the handler.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (!isMatchCall(node))
+                    return;
+                const handlers = handlersOf(node);
+                const shapes = handlers.map(shapeOf);
+                if (!shapes.includes("delegating"))
+                    return;
+                handlers.forEach((handler, index) => {
+                    if (shapes[index] !== "inline")
+                        return;
+                    const name = effectFnName(handler);
+                    context.report({
+                        node: handler,
+                        messageId: "inlineHandler",
+                        data: { hint: name ? ` (\`${name}\`)` : "" },
+                    });
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-bare-error-in-effect.d.ts

@@ -0,0 +1 @@
+export declare const noBareErrorInEffectRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-bare-error-in-effect.js

@@ -0,0 +1,34 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isEffectGenerator, nearestFunction } from "../shared/effect-ast.js";
+// Only the two forms the effecttsgo preset misses: `Effect.fail(new Error(…))` and
+// `extends Error` are already reported by global-error-in-effect-failure and extends-native-error.
+export const noBareErrorInEffectRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Fail Effects with tagged errors, never with a `throw` or a primitive value.",
+        },
+        messages: {
+            throwInGenerator: "A `throw` inside an Effect generator becomes a defect: `return yield* new TaggedError(...)` instead.",
+            primitiveFailure: "Fail with a tagged error (`Data.TaggedError` or `Schema.TaggedError`), not a primitive value.",
+        },
+    },
+    createOnce(context) {
+        return {
+            ThrowStatement(node) {
+                const fn = nearestFunction(node);
+                if (fn !== undefined && isEffectGenerator(fn)) {
+                    context.report({ node, messageId: "throwInGenerator" });
+                }
+            },
+            CallExpression(node) {
+                if (calleeOf(node, "Effect") !== "fail")
+                    return;
+                const [failure] = node.arguments;
+                if (failure?.type === "Literal" || failure?.type === "TemplateLiteral") {
+                    context.report({ node: failure, messageId: "primitiveFailure" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-effect-promise.d.ts

@@ -0,0 +1 @@
+export declare const noEffectPromiseRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-effect-promise.js

@@ -0,0 +1,57 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf } from "../shared/effect-ast.js";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+// Argument index of the release step, where a promise that cannot reject is the normal case.
+const releaseSlots = new Map([
+    ["acquireRelease", 1],
+    ["acquireUseRelease", 2],
+    ["addFinalizer", 0],
+]);
+const isInsideRelease = (node) => {
+    let child = node;
+    for (let current = node.parent; current; current = current.parent) {
+        const slot = releaseSlots.get(calleeOf(current, "Effect") ?? "");
+        if (current.type === "CallExpression" &&
+            slot !== undefined &&
+            current.arguments[slot] === child) {
+            return true;
+        }
+        child = current;
+    }
+    return false;
+};
+export const noEffectPromiseRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Prefer `Effect.tryPromise` over `Effect.promise` outside resource release. Test files are skipped.",
+        },
+        messages: {
+            rejectionAsDefect: "`Effect.promise` turns a rejection into a defect: use `Effect.tryPromise({ try, catch })` unless the promise cannot reject.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let inTestFile = false;
+        return {
+            // A rejection during test setup is a broken test, and a defect fails it with the cause.
+            before() {
+                inTestFile = isTestFile(context);
+            },
+            CallExpression(node) {
+                if (inTestFile)
+                    return;
+                if (calleeOf(node, "Effect") === "promise" && !isInsideRelease(node)) {
+                    context.report({ node, messageId: "rejectionAsDefect" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-effect-return-type.d.ts

@@ -0,0 +1 @@
+export declare const noEffectReturnTypeRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-effect-return-type.js

@@ -0,0 +1,130 @@
+import { defineRule } from "@oxlint/plugins";
+import { nearestFunction } from "../shared/effect-ast.js";
+// `Effect.Effect`, `Stream.Stream`, `Layer.Layer`: the types that carry error and requirement
+// channels collected from everything they call.
+const channelModules = new Set(["Effect", "Stream", "Layer"]);
+const isChannelType = (node) => node.typeName.type === "TSQualifiedName" &&
+    node.typeName.left.type === "Identifier" &&
+    channelModules.has(node.typeName.left.name) &&
+    node.typeName.right.name === node.typeName.left.name;
+const isInside = (node, ancestor) => {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current === ancestor)
+            return true;
+    }
+    return false;
+};
+const branchesOf = (expression) => expression.type === "ConditionalExpression"
+    ? [...branchesOf(expression.consequent), ...branchesOf(expression.alternate)]
+    : [expression];
+// Without type information, branches built differently (`Effect.succeed` and `Effect.fail`)
+// stand in for an inferred union of effects that the annotation folds into one type.
+const returnsDifferentShapes = (branches, sourceCode) => {
+    const shapeOf = (branch) => branch.type === "CallExpression" || branch.type === "NewExpression"
+        ? `${branch.type} ${sourceCode.getText(branch.callee)}`
+        : branch.type;
+    return new Set(branches.map(shapeOf)).size > 1;
+};
+// TypeScript cannot infer the return type of a function that calls itself: it falls back to
+// `any` and asks for the annotation.
+const isRecursive = (node, sourceCode) => {
+    const declaration = node.type === "FunctionDeclaration" ? node : node.parent;
+    const name = declaration?.type === "FunctionDeclaration"
+        ? declaration.id?.name
+        : declaration?.type === "VariableDeclarator" && declaration.id.type === "Identifier"
+            ? declaration.id.name
+            : undefined;
+    if (declaration === null || name === undefined)
+        return false;
+    // The declared variables of a function declaration include its parameters.
+    return sourceCode
+        .getDeclaredVariables(declaration)
+        .some((variable) => variable.name === name &&
+        variable.references.some((reference) => isInside(reference.identifier, node)));
+};
+// Only the declaration itself: methods of an exported object and functions it returns are not
+// part of the module's signature.
+const isExportedDeclaration = (node) => {
+    const declarator = node.parent;
+    const declaration = declarator?.type === "VariableDeclarator" && declarator.init === node
+        ? declarator.parent
+        : node;
+    const parent = declaration?.parent?.type;
+    return parent === "ExportNamedDeclaration" || parent === "ExportDefaultDeclaration";
+};
+const checksExported = (options) => {
+    const [first] = options;
+    return typeof first === "object" && first !== null && "checkExported" in first
+        ? first.checkExported === true
+        : false;
+};
+export const noEffectReturnTypeRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Let inference type a function returning an Effect: its error and requirement channels change with every callee. Exported declarations are skipped: their annotation is a contract.",
+        },
+        hasSuggestions: true,
+        messages: {
+            effectReturnType: "Remove the return type annotation: error and requirement channels follow the callees, so inference keeps them up to date.",
+            removeReturnType: "Remove the return type annotation.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { checkExported: { type: "boolean" } },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let checkExported = false;
+        const annotated = new Set();
+        const returned = new Map();
+        const collect = (node) => {
+            const fn = nearestFunction(node);
+            if (fn === undefined || node.argument === null)
+                return;
+            returned.set(fn, [...(returned.get(fn) ?? []), node.argument]);
+        };
+        const check = (node) => {
+            const statements = returned.get(node) ?? [];
+            returned.delete(node);
+            if (!annotated.delete(node) || !node.returnType)
+                return;
+            const expressions = node.body?.type === "BlockStatement" ? statements : node.body ? [node.body] : [];
+            if (returnsDifferentShapes(expressions.flatMap(branchesOf), context.sourceCode))
+                return;
+            if (isRecursive(node, context.sourceCode))
+                return;
+            if (!checkExported && isExportedDeclaration(node))
+                return;
+            const { returnType } = node;
+            context.report({
+                node: returnType,
+                messageId: "effectReturnType",
+                suggest: [
+                    {
+                        messageId: "removeReturnType",
+                        fix: (fixer) => fixer.remove(returnType),
+                    },
+                ],
+            });
+        };
+        return {
+            before() {
+                checkExported = checksExported(context.options);
+            },
+            TSTypeReference(node) {
+                const fn = nearestFunction(node);
+                if (fn?.returnType && isChannelType(node) && isInside(node, fn.returnType)) {
+                    annotated.add(fn);
+                }
+            },
+            ReturnStatement: collect,
+            "ArrowFunctionExpression:exit": check,
+            "FunctionDeclaration:exit": check,
+            "FunctionExpression:exit": check,
+        };
+    },
+});

package/dist/rules/no-inline-schema-codec.d.ts

@@ -0,0 +1 @@
+export declare const noInlineSchemaCodecRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-inline-schema-codec.js

@@ -0,0 +1,46 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, nearestFunction } from "../shared/effect-ast.js";
+// Only the codec factories: `Schema.decode`, `decodeTo`, `encodeKeys`, … build schemas.
+const codecFactory = /^(decode|encode)(Unknown)?(Effect|Exit|Option|Promise|Result|Sync)$/;
+const layerConstructors = new Set(["effect", "scoped"]);
+const isLayerConstructor = (node) => {
+    const name = calleeOf(node, "Layer");
+    return name !== undefined && layerConstructors.has(name);
+};
+// `Layer.effect(T, Effect.gen(…))` and the curried `Layer.effect(T)(Effect.gen(…))`: the
+// generator runs once, when the Layer is built.
+const isLayerConstructionGenerator = (fn) => {
+    const gen = fn.parent;
+    if (!fn.generator || gen?.type !== "CallExpression" || calleeOf(gen, "Effect") !== "gen") {
+        return false;
+    }
+    const layer = gen.parent;
+    if (layer?.type !== "CallExpression" || !layer.arguments.some((arg) => arg === gen)) {
+        return false;
+    }
+    return isLayerConstructor(layer) || isLayerConstructor(layer.callee);
+};
+export const noInlineSchemaCodecRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Extract `Schema.decode*`/`Schema.encode*` codecs into module-level constants instead of applying them inline.",
+        },
+        messages: {
+            inlineCodec: "`Schema.{{factory}}(…)` is built and applied inline: extract it into a named module-level constant.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                const factory = calleeOf(node.callee, "Schema");
+                if (factory === undefined || !codecFactory.test(factory))
+                    return;
+                const fn = nearestFunction(node);
+                if (fn === undefined || isLayerConstructionGenerator(fn))
+                    return;
+                context.report({ node: node.callee, messageId: "inlineCodec", data: { factory } });
+            },
+        };
+    },
+});

package/dist/rules/no-inline-yield-star.d.ts

@@ -0,0 +1 @@
+export declare const noInlineYieldStarRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-inline-yield-star.js

@@ -0,0 +1,230 @@
+import { defineRule } from "@oxlint/plugins";
+import { nearestFunction } from "../shared/effect-ast.js";
+const contains = (outer, inner) => outer[0] <= inner[0] && inner[1] <= outer[1];
+const isStandalone = (node) => {
+    const { parent } = node;
+    if (!parent)
+        return false;
+    if (parent.type === "ConditionalExpression" && parent.test !== node)
+        return isStandalone(parent);
+    if (parent.type === "LogicalExpression" && parent.right === node)
+        return isStandalone(parent);
+    if (parent.type === "VariableDeclarator")
+        return true;
+    if (parent.type === "AssignmentExpression")
+        return parent.parent.type === "ExpressionStatement";
+    return parent.type.endsWith("Statement");
+};
+const isInStatementList = (node) => {
+    const { parent } = node;
+    switch (parent?.type) {
+        case "BlockStatement":
+        case "Program":
+        case "StaticBlock":
+            return true;
+        case "SwitchCase":
+            return parent.test !== node;
+        default:
+            return false;
+    }
+};
+const statementOf = (node) => {
+    let current = node;
+    while (current.parent && !isInStatementList(current))
+        current = current.parent;
+    return current;
+};
+const logicalAssignments = new Set(["&&=", "||=", "??="]);
+// The extracted `const` runs before its statement, once and unconditionally: any position that
+// short-circuits, repeats or belongs to a nested statement would change when the effect runs.
+const runsOnceBeforeStatement = (child, parent, statement) => {
+    switch (parent.type) {
+        case "LogicalExpression":
+            return parent.left === child;
+        case "ConditionalExpression":
+            return parent.test === child;
+        case "AssignmentExpression":
+            return parent.left === child || !logicalAssignments.has(parent.operator);
+        case "ChainExpression":
+        case "ClassBody":
+        case "WhileStatement":
+        case "DoWhileStatement":
+            return false;
+        case "ForStatement":
+            return parent === statement && parent.init === child;
+        case "ForInStatement":
+        case "ForOfStatement":
+            return parent === statement && parent.right === child;
+        default:
+            return parent === statement || !parent.type.endsWith("Statement");
+    }
+};
+const canHoist = (node, statement) => {
+    let child = node;
+    while (child !== statement) {
+        const parent = child.parent;
+        if (!parent || !runsOnceBeforeStatement(child, parent, statement))
+            return false;
+        child = parent;
+    }
+    return true;
+};
+// Anything evaluated before a hoisted `yield*` must be hoisted with it, or the order of effects flips.
+const reordersEffects = (hoisted, effectful) => hoisted.some((target) => effectful.some((node) => node.range[1] <= target.range[0] &&
+    !hoisted.some((moved) => contains(moved.range, node.range) && moved.range[1] <= target.range[0])));
+const verbPrefix = /^(?:get|read|fetch|load|find|parse|decode|make|create|build|compute|resolve|from|to)(?=[A-Z])/;
+const reservedWords = new Set("arguments await break case catch class const continue debugger default delete do else enum eval export extends false finally for function if implements import in instanceof interface let new null package private protected public return static super switch this throw true try typeof undefined var void while with yield".split(" "));
+const trailingName = (node) => {
+    switch (node.type) {
+        case "Identifier":
+            return node.name;
+        case "MemberExpression":
+            return !node.computed && node.property.type === "Identifier"
+                ? node.property.name
+                : undefined;
+        case "CallExpression":
+        case "NewExpression":
+            return trailingName(node.callee);
+        default:
+            return undefined;
+    }
+};
+// `yield* readSheet()` becomes `sheet`, `yield* reader.rows` becomes `rows`.
+const baseName = (node) => {
+    const name = node.argument ? trailingName(node.argument)?.replace(verbPrefix, "") : undefined;
+    if (name === undefined || name === "")
+        return "value";
+    const variable = name.charAt(0).toLowerCase() + name.slice(1);
+    return reservedWords.has(variable) ? "value" : variable;
+};
+const namesInUse = (scope) => {
+    const names = new Set();
+    const collect = (inner) => {
+        for (const variable of inner.variables)
+            names.add(variable.name);
+        for (const reference of inner.references)
+            names.add(reference.identifier.name);
+        inner.childScopes.forEach(collect);
+    };
+    collect(scope);
+    for (let outer = scope.upper; outer; outer = outer.upper) {
+        for (const name of outer.set.keys())
+            names.add(name);
+    }
+    return names;
+};
+// The parentheses of a call with a single argument belong to the call, not to the `yield*`.
+const replacedRange = (node, sourceCode) => {
+    const { parent } = node;
+    const callParens = (parent.type === "CallExpression" || parent.type === "NewExpression") &&
+        parent.arguments.length === 1
+        ? 1
+        : 0;
+    const wrappers = [];
+    let before = sourceCode.getTokenBefore(node);
+    let after = sourceCode.getTokenAfter(node);
+    while (before?.value === "(" && after?.value === ")") {
+        wrappers.push([before.range[0], after.range[1]]);
+        before = sourceCode.getTokenBefore(before);
+        after = sourceCode.getTokenAfter(after);
+    }
+    return wrappers[wrappers.length - 1 - callParens] ?? node.range;
+};
+const extraction = (statement, hoisted, sourceCode) => {
+    const taken = namesInUse(sourceCode.getScope(statement).variableScope);
+    const replacements = hoisted.map((node) => {
+        let name = baseName(node);
+        for (let suffix = 2; taken.has(name); suffix++)
+            name = `${baseName(node)}${suffix}`;
+        taken.add(name);
+        return { node, name, range: replacedRange(node, sourceCode) };
+    });
+    const { text } = sourceCode;
+    const rewrite = (range, self) => {
+        const inside = replacements.filter((replacement) => replacement.node !== self && contains(range, replacement.range));
+        const outermost = inside
+            .filter((replacement) => inside.every((other) => other === replacement || !contains(other.range, replacement.range)))
+            .toSorted((left, right) => left.range[0] - right.range[0]);
+        let result = "";
+        let cursor = range[0];
+        for (const replacement of outermost) {
+            result += text.slice(cursor, replacement.range[0]) + replacement.name;
+            cursor = replacement.range[1];
+        }
+        return result + text.slice(cursor, range[1]);
+    };
+    const lineStart = text.lastIndexOf("\n", statement.range[0] - 1) + 1;
+    const indentation = text.slice(lineStart, statement.range[0]);
+    const startsLine = indentation.trim() === "";
+    const declarations = replacements.map(({ node, name }) => `const ${name} = ${rewrite(node.range, node)}`);
+    const remainder = rewrite(statement.range);
+    const guarded = startsLine && /^[[(`+\-/]/.test(remainder) ? `;${remainder}` : remainder;
+    return [...declarations, guarded].join(startsLine ? `\n${indentation}` : "; ");
+};
+export const noInlineYieldStarRule = defineRule({
+    meta: {
+        type: "suggestion",
+        fixable: "code",
+        docs: {
+            description: "Bind the result of a `yield*` to a `const` instead of using it inside a larger expression.",
+        },
+        messages: {
+            inlineYieldStar: "This `yield*` runs inside a larger expression. Bind its result first (`const rows = yield* reader.rows`), so each statement runs one effect in reading order.",
+        },
+    },
+    createOnce(context) {
+        let inline = [];
+        let effectful = [];
+        const collect = (node) => {
+            effectful.push(node);
+        };
+        return {
+            before() {
+                inline = [];
+                effectful = [];
+            },
+            YieldExpression(node) {
+                effectful.push(node);
+                if (node.delegate && !isStandalone(node))
+                    inline.push(node);
+            },
+            AwaitExpression: collect,
+            AssignmentExpression: collect,
+            CallExpression: collect,
+            NewExpression: collect,
+            TaggedTemplateExpression: collect,
+            UpdateExpression: collect,
+            VariableDeclarator: collect,
+            "Program:exit"() {
+                const byStatement = new Map();
+                for (const node of inline) {
+                    const statement = statementOf(node);
+                    byStatement.set(statement, [...(byStatement.get(statement) ?? []), node]);
+                }
+                for (const [statement, yields] of byStatement) {
+                    const owner = nearestFunction(statement);
+                    const hoisted = yields
+                        .filter((node) => canHoist(node, statement))
+                        .toSorted((left, right) => left.range[1] - right.range[1] || right.range[0] - left.range[0]);
+                    const evaluatedInStatement = effectful.filter((node) => contains(statement.range, node.range) &&
+                        nearestFunction(node) === owner);
+                    const fixable = statement.type !== "Program" &&
+                        hoisted.length > 0 &&
+                        !reordersEffects(hoisted, evaluatedInStatement);
+                    const replacement = fixable
+                        ? extraction(statement, hoisted, context.sourceCode)
+                        : undefined;
+                    for (const node of yields) {
+                        context.report({
+                            node,
+                            messageId: "inlineYieldStar",
+                            ...(replacement !== undefined && hoisted.includes(node)
+                                ? { fix: (fixer) => fixer.replaceText(statement, replacement) }
+                                : {}),
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-manual-discriminant-comparison.d.ts

@@ -0,0 +1,2 @@
+export declare const remedyFor: (discriminant: string) => string;
+export declare const noManualDiscriminantComparisonRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-manual-discriminant-comparison.js

@@ -0,0 +1,58 @@
+import { defineRule } from "@oxlint/plugins";
+import { configuredDiscriminants, discriminantOf, discriminantsSchema, isEqualityComparison, isInsideBroadEffectHandler, isStringLiteral, } from "../shared/tagged-values.js";
+export const remedyFor = (discriminant) => discriminant === "_tag"
+    ? "`Match.tagsExhaustive`, the tagged enum `$match` or an exhaustive ts-pattern match; for a single check, `Predicate.isTagged`"
+    : `\`Match.discriminatorsExhaustive("${discriminant}")\` or an exhaustive ts-pattern match`;
+export const noManualDiscriminantComparisonRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Branch on a union's discriminant with an exhaustive match, not with comparisons or `switch`.",
+        },
+        messages: {
+            manualComparison: "Comparing `{{discriminant}}` with a literal still compiles when a variant is added: use {{remedy}}.",
+            manualSwitch: "A `switch` on `{{discriminant}}` still compiles when a variant is added: use {{remedy}}.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { discriminants: discriminantsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let discriminants = new Set();
+        const report = (node, discriminant, messageId) => {
+            // Inside `Effect.catch` handlers, `_tag` belongs to `anti-slop-no-manual-effect-error-tag`.
+            if (discriminant === "_tag" && isInsideBroadEffectHandler(node))
+                return;
+            context.report({
+                node,
+                messageId,
+                data: { discriminant, remedy: remedyFor(discriminant) },
+            });
+        };
+        return {
+            before() {
+                discriminants = configuredDiscriminants(context.options);
+            },
+            BinaryExpression(node) {
+                if (!isEqualityComparison(node))
+                    return;
+                const discriminant = isStringLiteral(node.right)
+                    ? discriminantOf(node.left, discriminants)
+                    : isStringLiteral(node.left)
+                        ? discriminantOf(node.right, discriminants)
+                        : undefined;
+                if (discriminant !== undefined)
+                    report(node, discriminant, "manualComparison");
+            },
+            SwitchStatement(node) {
+                const discriminant = discriminantOf(node.discriminant, discriminants);
+                if (discriminant !== undefined)
+                    report(node, discriminant, "manualSwitch");
+            },
+        };
+    },
+});

package/dist/rules/no-manual-discriminant-construction.d.ts

@@ -0,0 +1,2 @@
+export declare const remedyFor: (discriminant: string) => "the Schema's `.make` or the class constructor" | "the Schema's tagged `.make`, the tagged class or error constructor, or the `Data.taggedEnum` variant constructor";
+export declare const noManualDiscriminantConstructionRule: import("@oxlint/plugins").Rule;