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

package/dist/rules/service-key-matches-name.js

@@ -0,0 +1,69 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf } from "../shared/effect-ast.js";
+// `class X extends Context.Service<X, Shape>()(key)`: the outer call carries the key.
+const contextServiceKey = (superClass) => superClass?.type === "CallExpression" && calleeOf(superClass.callee, "Context") === "Service"
+    ? superClass.arguments[0]
+    : undefined;
+const literalKey = (node) => {
+    if (node?.type === "Literal" && typeof node.value === "string")
+        return node.value;
+    if (node?.type === "TemplateLiteral" && node.expressions.length === 0) {
+        return node.quasis[0]?.value.cooked ?? undefined;
+    }
+    return undefined;
+};
+const className = (node) => {
+    if (node.id !== null)
+        return node.id.name;
+    const declarator = node.parent;
+    return declarator?.type === "VariableDeclarator" && declarator.id.type === "Identifier"
+        ? declarator.id.name
+        : undefined;
+};
+// A path prefix (`"app/db/Database"`) is the key `AGENTS.md` recommends: only the last segment
+// has to be the name.
+const keyFor = (key, name) => {
+    const slash = key.lastIndexOf("/");
+    return slash === -1 ? name : `${key.slice(0, slash + 1)}${name}`;
+};
+export const serviceKeyMatchesNameRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Key a `Context.Service` class with its own name, alone or after a path prefix.",
+        },
+        hasSuggestions: true,
+        messages: {
+            keyMismatch: 'The key `"{{key}}"` does not end with the class name `{{name}}`: the key is the service\'s identity in errors and traces.',
+            useKey: 'Use `"{{expected}}"`.',
+        },
+    },
+    createOnce(context) {
+        const checkClass = (node) => {
+            const keyNode = contextServiceKey(node.superClass);
+            const key = literalKey(keyNode);
+            const name = className(node);
+            if (keyNode === undefined || key === undefined || name === undefined)
+                return;
+            if (key === name || key.endsWith(`/${name}`))
+                return;
+            const expected = keyFor(key, name);
+            context.report({
+                node: keyNode,
+                messageId: "keyMismatch",
+                data: { key, name },
+                suggest: [
+                    {
+                        messageId: "useKey",
+                        data: { expected },
+                        fix: (fixer) => fixer.replaceText(keyNode, JSON.stringify(expected)),
+                    },
+                ],
+            });
+        };
+        return {
+            ClassDeclaration: checkClass,
+            ClassExpression: checkClass,
+        };
+    },
+});

package/dist/rules/service-port-shape-only.d.ts

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

package/dist/rules/service-port-shape-only.js

@@ -0,0 +1,65 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, memberOf } from "../shared/effect-ast.js";
+const legacyServices = [
+    ["Effect", "Service"],
+    ["Context", "Tag"],
+    ["Context", "GenericTag"],
+];
+const implementationStatics = new Set(["layer", "Default"]);
+// `class X extends Context.Service<X, Shape>()(id, options?)`: the outer call carries the id.
+const contextServiceIdCall = (superClass) => superClass?.type === "CallExpression" && calleeOf(superClass.callee, "Context") === "Service"
+    ? superClass
+    : undefined;
+const staticMemberName = (member) => (member.type === "PropertyDefinition" || member.type === "MethodDefinition") &&
+    member.static &&
+    member.key.type === "Identifier"
+    ? member.key.name
+    : undefined;
+export const servicePortShapeOnlyRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Keep a `Context.Service` port a pure contract, with implementations in separate Layers.",
+        },
+        messages: {
+            makeOption: "Declare the port as shape only: move the implementation into a Layer in its own adapter file.",
+            staticImplementation: "Do not attach `static {{name}}` to the port: provide the implementation as a Layer in its own adapter file.",
+            legacyService: "Use `class X extends Context.Service<X, Shape>()(id) {}` instead of `{{name}}`.",
+        },
+    },
+    createOnce(context) {
+        const checkClass = (node) => {
+            const idCall = contextServiceIdCall(node.superClass);
+            if (idCall === undefined)
+                return;
+            const options = idCall.arguments[1];
+            if (options !== undefined)
+                context.report({ node: options, messageId: "makeOption" });
+            for (const member of node.body.body) {
+                const name = staticMemberName(member);
+                if (name !== undefined && implementationStatics.has(name)) {
+                    context.report({
+                        node: member,
+                        messageId: "staticImplementation",
+                        data: { name },
+                    });
+                }
+            }
+        };
+        return {
+            ClassDeclaration: checkClass,
+            ClassExpression: checkClass,
+            MemberExpression(node) {
+                for (const [object, property] of legacyServices) {
+                    if (memberOf(node, object) === property) {
+                        context.report({
+                            node,
+                            messageId: "legacyService",
+                            data: { name: `${object}.${property}` },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/single-style-per-function.d.ts

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

package/dist/rules/single-style-per-function.js

@@ -0,0 +1,145 @@
+import { defineRule } from "@oxlint/plugins";
+import { isEffectGenerator, isServerComponent, memberOf, } from "../shared/effect-ast.js";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+const isThenCall = (node) => node.callee.type === "MemberExpression" &&
+    !node.callee.computed &&
+    node.callee.property.type === "Identifier" &&
+    node.callee.property.name === "then";
+const testRunners = new Set(["test", "it"]);
+const testHooks = new Set(["beforeAll", "afterAll", "beforeEach", "afterEach"]);
+// `test(…)`, `test.only(…)`, `test.each(table)(…)`: the callee chain roots at the runner or hook.
+const testRoleOf = (fn) => {
+    const call = fn.parent;
+    if (call?.type !== "CallExpression" || !call.arguments.some((arg) => arg === fn))
+        return undefined;
+    let callee = call.callee;
+    while (callee.type === "MemberExpression" || callee.type === "CallExpression") {
+        callee = callee.type === "MemberExpression" ? callee.object : callee.callee;
+    }
+    if (callee.type !== "Identifier")
+        return undefined;
+    if (testRunners.has(callee.name))
+        return "test";
+    if (testHooks.has(callee.name))
+        return "hook";
+    return undefined;
+};
+// Awaiting promise-based fixtures and then one Effect program reads as Arrange/Act/Assert;
+// a second Effect step is where promise and Effect sequencing start to interleave.
+const interleavesEffectSteps = (frame) => {
+    const effectSteps = frame.promiseSteps.filter((step) => step.involvesEffect);
+    return (effectSteps.length > 1 || effectSteps.some((step) => step.node.type !== "AwaitExpression"));
+};
+const reportFor = {
+    test: "asyncEffectTest",
+    hook: "asyncEffectHook",
+    helper: "asyncEffectHelper",
+};
+export const singleStylePerFunctionRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Keep each function entirely Effect or entirely async/await.",
+        },
+        messages: {
+            asyncEffect: "This function builds Effects: drop `async` and lift promises with `Effect.tryPromise({ try, catch })`.",
+            promiseStep: "Do not mix promises with Effect in the same function: lift the promise with `Effect.tryPromise({ try, catch })`.",
+            asyncEffectTest: "This test chains promises around Effect: await a single program and assert on its result, or make its body one Effect with `it.effect` from `@effect/vitest`.",
+            asyncEffectHook: "This hook chains promises around Effect: await a single program, lifting the promises into it with `Effect.tryPromise({ try, catch })`, or build the fixture as a Layer with `layer` from `@effect/vitest`.",
+            asyncEffectHelper: "This test helper chains promises around Effect: await a single program, lifting the promises into it with `Effect.tryPromise({ try, catch })`.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        const frames = [];
+        const current = () => frames.at(-1);
+        const openSteps = [];
+        let inTestFile = false;
+        // In a test file a helper such as `probe` or `captureLines` is a promise/Effect boundary
+        // like the test that calls it, so it gets the same allowance.
+        const roleOf = (fn) => testRoleOf(fn) ?? (inTestFile && !isEffectGenerator(fn) ? "helper" : undefined);
+        const enter = (fn) => {
+            frames.push({
+                fn,
+                effectful: isEffectGenerator(fn),
+                rendersJsx: false,
+                promiseSteps: [],
+            });
+        };
+        const openStep = (node) => {
+            const step = { node, involvesEffect: false };
+            current()?.promiseSteps.push(step);
+            openSteps.push(step);
+        };
+        const exit = () => {
+            const frame = frames.pop();
+            if (frame === undefined)
+                return;
+            // One report per test or hook: the remedy is its shape, not each promise in it.
+            const role = roleOf(frame.fn);
+            if (role !== undefined) {
+                if (interleavesEffectSteps(frame))
+                    context.report({ node: frame.fn, messageId: reportFor[role] });
+                return;
+            }
+            if (!frame.effectful || isServerComponent(frame.fn, frame.rendersJsx))
+                return;
+            if (frame.fn.async)
+                context.report({ node: frame.fn, messageId: "asyncEffect" });
+            for (const step of frame.promiseSteps)
+                context.report({ node: step.node, messageId: "promiseStep" });
+        };
+        const markJsx = () => {
+            const frame = current();
+            if (frame !== undefined)
+                frame.rendersJsx = true;
+        };
+        return {
+            before() {
+                inTestFile = isTestFile(context);
+            },
+            ArrowFunctionExpression: enter,
+            FunctionExpression: enter,
+            FunctionDeclaration: enter,
+            "ArrowFunctionExpression:exit": exit,
+            "FunctionExpression:exit": exit,
+            "FunctionDeclaration:exit": exit,
+            MemberExpression(node) {
+                const name = memberOf(node, "Effect");
+                if (name === undefined)
+                    return;
+                // A step involves Effect wherever it appears in it, nested callbacks included.
+                for (const step of openSteps)
+                    step.involvesEffect = true;
+                const frame = current();
+                if (frame === undefined)
+                    return;
+                // `Effect.run*` is how an async boundary legitimately hands off to Effect (P27);
+                // where it may appear is run-only-in-runner's business.
+                if (!name.startsWith("run"))
+                    frame.effectful = true;
+            },
+            JSXElement: markJsx,
+            JSXFragment: markJsx,
+            AwaitExpression: openStep,
+            "AwaitExpression:exit"() {
+                openSteps.pop();
+            },
+            CallExpression(node) {
+                if (isThenCall(node))
+                    openStep(node);
+            },
+            "CallExpression:exit"(node) {
+                if (isThenCall(node))
+                    openSteps.pop();
+            },
+        };
+    },
+});

package/dist/rules/try-object-form.d.ts

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

package/dist/rules/try-object-form.js

@@ -0,0 +1,26 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf } from "../shared/effect-ast.js";
+const tryConstructors = new Set(["try", "tryPromise"]);
+export const tryObjectFormRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Use the object form of `Effect.try` and `Effect.tryPromise`, mapping failures to tagged errors.",
+        },
+        messages: {
+            objectForm: "Use `Effect.{{name}}({ try, catch })`: the thunk form types the failure as `Cause.UnknownError`.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                const name = calleeOf(node, "Effect");
+                if (name === undefined || !tryConstructors.has(name))
+                    return;
+                if (node.arguments[0]?.type !== "ObjectExpression") {
+                    context.report({ node, messageId: "objectForm", data: { name } });
+                }
+            },
+        };
+    },
+});

package/dist/rules/untraced-recursion.d.ts

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

package/dist/rules/untraced-recursion.js

@@ -0,0 +1,48 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isFunctionNode } from "../shared/effect-ast.js";
+// `Effect.fn("name")(body)` and `Effect.fn(body)`; `Effect.fnUntraced` is what the rule asks for.
+const tracedBody = (node) => {
+    if (node?.type !== "CallExpression")
+        return undefined;
+    const isTraced = calleeOf(node, "Effect") === "fn" || calleeOf(node.callee, "Effect") === "fn";
+    const [body] = node.arguments;
+    return isTraced && isFunctionNode(body) ? body : undefined;
+};
+const isInside = (node, ancestor) => {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current === ancestor)
+            return true;
+    }
+    return false;
+};
+// Every recursive call of a traced function opens a span nested in the previous one and
+// captures a stack frame: the trace grows with the depth instead of naming one unit of work.
+export const untracedRecursionRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Write recursive effectful functions with `Effect.fnUntraced`, so each level does not open a nested span.",
+        },
+        messages: {
+            recursiveTraced: "`{{name}}` calls itself: use `Effect.fnUntraced` and trace the entry point that starts the recursion.",
+        },
+    },
+    createOnce(context) {
+        return {
+            VariableDeclarator(node) {
+                const body = tracedBody(node.init);
+                if (node.id.type !== "Identifier" || body === undefined)
+                    return;
+                const [variable] = context.sourceCode.getDeclaredVariables(node);
+                const recursive = variable?.references.some((reference) => isInside(reference.identifier, body));
+                if (recursive === true) {
+                    context.report({
+                        node: node.id,
+                        messageId: "recursiveTraced",
+                        data: { name: node.id.name },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/shared/effect-ast.d.ts

@@ -0,0 +1,10 @@
+import type { ESTree } from "@oxlint/plugins";
+export type FunctionNode = ESTree.Function | ESTree.ArrowFunctionExpression;
+export declare const isFunctionNode: (node: ESTree.Node | null | undefined) => node is FunctionNode;
+export declare const memberOf: (node: ESTree.Node | null | undefined, object: string) => string | undefined;
+export declare const calleeOf: (node: ESTree.Node | null | undefined, object: string) => string | undefined;
+export declare const isEffectFnApplication: (node: ESTree.Node | null | undefined) => node is ESTree.CallExpression;
+export declare const isEffectGenerator: (fn: FunctionNode) => boolean;
+export declare const isInsideEffectGeneratorBody: (node: ESTree.Node) => boolean;
+export declare const nearestFunction: (node: ESTree.Node) => FunctionNode | undefined;
+export declare const isServerComponent: (fn: FunctionNode, rendersJsx: boolean) => boolean;

package/dist/shared/effect-ast.js

@@ -0,0 +1,63 @@
+export const isFunctionNode = (node) => node?.type === "ArrowFunctionExpression" ||
+    node?.type === "FunctionExpression" ||
+    node?.type === "FunctionDeclaration";
+// Like the anti-slop rules, names are matched literally: `import { Effect as E }` escapes.
+export const memberOf = (node, object) => {
+    if (node?.type !== "MemberExpression" ||
+        node.computed ||
+        node.object.type !== "Identifier" ||
+        node.object.name !== object ||
+        node.property.type !== "Identifier") {
+        return undefined;
+    }
+    return node.property.name;
+};
+export const calleeOf = (node, object) => node?.type === "CallExpression" ? memberOf(node.callee, object) : undefined;
+// Both `Effect.fn("name")(body, ...pipeables)` and the unnamed `Effect.fn(body, ...pipeables)`.
+export const isEffectFnApplication = (node) => {
+    if (node?.type !== "CallExpression")
+        return false;
+    const factory = memberOf(node.callee, "Effect");
+    return factory === "fn" || factory === "fnUntraced" || calleeOf(node.callee, "Effect") === "fn";
+};
+export const isEffectGenerator = (fn) => {
+    const call = fn.parent;
+    if (!fn.generator || call?.type !== "CallExpression")
+        return false;
+    if (calleeOf(call, "Effect") === "gen")
+        return call.arguments.some((arg) => arg === fn);
+    return isEffectFnApplication(call) && call.arguments[0] === fn;
+};
+const isEffectCombinatorCallback = (fn) => fn.parent?.type === "CallExpression" &&
+    memberOf(fn.parent.callee, "Effect") !== undefined &&
+    fn.parent.arguments.some((arg) => arg === fn);
+// Callbacks handed to an `Effect.*` combinator inside the generator still belong to its success
+// path; the pipeable arguments of an `Effect.fn` nested in it are the handler slot, so they do
+// not, and neither does a function the generator only defines (an HTTP handler, a service method).
+export const isInsideEffectGeneratorBody = (node) => {
+    let child = node;
+    for (let current = node.parent; current; current = current.parent) {
+        if (isEffectFnApplication(current) &&
+            current.arguments.findIndex((arg) => arg === child) > 0) {
+            return false;
+        }
+        if (isFunctionNode(current)) {
+            if (current.generator)
+                return isEffectGenerator(current);
+            if (!isEffectCombinatorCallback(current))
+                return false;
+        }
+        child = current;
+    }
+    return false;
+};
+export const nearestFunction = (node) => {
+    for (let current = node.parent; current; current = current.parent) {
+        if (isFunctionNode(current))
+            return current;
+    }
+    return undefined;
+};
+// An async function that renders JSX is a React Server Component: it hands its outcome to React,
+// and how failures become UI is the application's call, not a rule's.
+export const isServerComponent = (fn, rendersJsx) => fn.async && rendersJsx;

package/dist/shared/effect-runners.d.ts

@@ -0,0 +1,2 @@
+import type { ESTree } from "@oxlint/plugins";
+export declare const runnerName: (node: ESTree.MemberExpression) => string | undefined;

package/dist/shared/effect-runners.js

@@ -0,0 +1,14 @@
+import { memberOf } from "./effect-ast.js";
+const runtimeEntries = [
+    ["NodeRuntime", "runMain"],
+    ["BunRuntime", "runMain"],
+    ["ManagedRuntime", "make"],
+];
+// The qualified name of the runner `node` refers to, when it runs an Effect program.
+export const runnerName = (node) => {
+    const effectMember = memberOf(node, "Effect");
+    if (effectMember?.startsWith("run"))
+        return `Effect.${effectMember}`;
+    const entry = runtimeEntries.find(([object, property]) => memberOf(node, object) === property);
+    return entry === undefined ? undefined : `${entry[0]}.${entry[1]}`;
+};

package/dist/shared/entry-files.d.ts

@@ -0,0 +1,6 @@
+export declare const defaultEntryFiles: readonly ["**/main.ts", "**/cli.ts", "**/bin/**"];
+export declare const isEntryFile: (context: {
+    readonly filename: string;
+    readonly cwd: string;
+    readonly options: ReadonlyArray<unknown>;
+}) => boolean;

package/dist/shared/entry-files.js

@@ -0,0 +1,5 @@
+import { makeFileMatcher } from "./file-globs.js";
+// `index.ts` is not matched on purpose: it is usually a barrel, and exempting it would let
+// adapters reach the rest of the application through the re-exports.
+export const defaultEntryFiles = ["**/main.ts", "**/cli.ts", "**/bin/**"];
+export const isEntryFile = makeFileMatcher("entryFiles", defaultEntryFiles);

package/dist/shared/file-globs.d.ts

@@ -0,0 +1,14 @@
+export declare const filePatternsSchema: {
+    type: string;
+    items: {
+        type: string;
+    };
+    uniqueItems: boolean;
+};
+type FileContext = {
+    readonly filename: string;
+    readonly cwd: string;
+    readonly options: ReadonlyArray<unknown>;
+};
+export declare const makeFileMatcher: (key: string, defaults: ReadonlyArray<string>) => (context: FileContext) => boolean;
+export {};

package/dist/shared/file-globs.js

@@ -0,0 +1,17 @@
+import { matchesGlob, relative, sep } from "node:path";
+export const filePatternsSchema = { type: "array", items: { type: "string" }, uniqueItems: true };
+const configuredPatterns = (options, key, defaults) => {
+    const [first] = options;
+    if (typeof first !== "object" || first === null)
+        return defaults;
+    const entry = Object.entries(first).find(([name]) => name === key);
+    if (entry === undefined)
+        return defaults;
+    const patterns = entry[1];
+    return Array.isArray(patterns) ? patterns.filter((pattern) => typeof pattern === "string") : [];
+};
+// Globs match the path relative to the working directory, with `/` on every platform.
+export const makeFileMatcher = (key, defaults) => (context) => {
+    const path = relative(context.cwd, context.filename).split(sep).join("/");
+    return configuredPatterns(context.options, key, defaults).some((pattern) => matchesGlob(path, pattern));
+};

package/dist/shared/match-ast.d.ts

@@ -0,0 +1,5 @@
+import type { ESTree } from "@oxlint/plugins";
+export declare const isMatchCall: (node: ESTree.Node | null | undefined) => node is ESTree.CallExpression;
+export declare const isMatchChain: (node: ESTree.Node | null | undefined) => boolean;
+export declare const handlersOf: (match: ESTree.CallExpression) => ESTree.Expression[];
+export declare const nestedBranches: (handler: ESTree.Node) => ReadonlyArray<ESTree.Node>;

package/dist/shared/match-ast.js

@@ -0,0 +1,52 @@
+import { calleeOf, isFunctionNode, memberOf } from "./effect-ast.js";
+const modulesWithMatch = ["Option", "Result", "Exit", "Either"];
+export const isMatchCall = (node) => {
+    if (node?.type !== "CallExpression")
+        return false;
+    const { callee } = node;
+    if (modulesWithMatch.some((module) => memberOf(callee, module) === "match"))
+        return true;
+    if (memberOf(callee, "Match") === "valueTags")
+        return true;
+    return (callee.type === "MemberExpression" &&
+        !callee.computed &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "$match");
+};
+const isMatchStart = (node) => {
+    const start = calleeOf(node, "Match");
+    return start === "value" || start === "type";
+};
+// `Match.value(x).pipe(...)`, the data-last `Match.type().pipe(...)`, and both through the
+// function form `pipe(Match.value(x), ...)`. Their handlers are arguments of `Match.when`
+// and friends, not object properties, so `handlersOf` sees none.
+export const isMatchChain = (node) => {
+    if (node?.type !== "CallExpression")
+        return false;
+    const { callee } = node;
+    if (callee.type === "Identifier")
+        return callee.name === "pipe" && isMatchStart(node.arguments[0]);
+    return (callee.type === "MemberExpression" &&
+        !callee.computed &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "pipe" &&
+        isMatchStart(callee.object));
+};
+export const handlersOf = (match) => match.arguments.flatMap((argument) => argument.type === "ObjectExpression"
+    ? argument.properties.flatMap((property) => property.type === "Property" ? [property.value] : [])
+    : []);
+const returnedExpressions = (fn) => {
+    if (fn.body?.type !== "BlockStatement")
+        return fn.body ? [fn.body] : [];
+    return fn.body.body.flatMap((statement) => statement.type === "ReturnStatement" && statement.argument ? [statement.argument] : []);
+};
+// What `no-nested-match` reports in a handler: itself a match, or a returned match or ternary.
+export const nestedBranches = (handler) => {
+    if (isMatchCall(handler) || isMatchChain(handler))
+        return [handler];
+    if (!isFunctionNode(handler))
+        return [];
+    return returnedExpressions(handler).filter((expression) => isMatchCall(expression) ||
+        isMatchChain(expression) ||
+        expression.type === "ConditionalExpression");
+};

package/dist/shared/tagged-values.d.ts

@@ -0,0 +1,17 @@
+import type { ESTree } from "@oxlint/plugins";
+export declare const isEqualityComparison: (node: ESTree.Node) => node is ESTree.BinaryExpression;
+export declare const isStringLiteral: (node: ESTree.Node | null | undefined) => node is ESTree.StringLiteral;
+export declare const isTagMember: (node: ESTree.Node | null | undefined) => node is ESTree.MemberExpression;
+export declare const isReasonTagMember: (node: ESTree.MemberExpression) => boolean;
+export declare const tagMemberFromComparison: (node: ESTree.BinaryExpression) => ESTree.MemberExpression | undefined;
+export declare const isInsideBroadEffectHandler: (node: ESTree.Node) => boolean;
+export declare const propertyName: (property: ESTree.ObjectProperty) => string | undefined;
+export declare const discriminantsSchema: {
+    readonly type: "array";
+    readonly items: {
+        readonly type: "string";
+    };
+    readonly uniqueItems: true;
+};
+export declare const configuredDiscriminants: (options: ReadonlyArray<unknown>) => Set<string>;
+export declare const discriminantOf: (node: ESTree.Node | null | undefined, discriminants: ReadonlySet<string>) => string | undefined;

package/dist/shared/tagged-values.js

@@ -0,0 +1,67 @@
+import { calleeOf } from "./effect-ast.js";
+const equalityOperators = new Set(["==", "===", "!=", "!=="]);
+const broadEffectCatchMethods = new Set(["catch", "catchAll", "catchIf"]);
+export const isEqualityComparison = (node) => node.type === "BinaryExpression" && equalityOperators.has(node.operator);
+export const isStringLiteral = (node) => node?.type === "Literal" && typeof node.value === "string";
+const isPropertyNamed = (node, name) => node.computed
+    ? isStringLiteral(node.property) && node.property.value === name
+    : node.property.type === "Identifier" && node.property.name === name;
+export const isTagMember = (node) => node?.type === "MemberExpression" && isPropertyNamed(node, "_tag");
+export const isReasonTagMember = (node) => node.object.type === "MemberExpression" && isPropertyNamed(node.object, "reason");
+export const tagMemberFromComparison = (node) => {
+    if (!isEqualityComparison(node))
+        return undefined;
+    if (isTagMember(node.left) && isStringLiteral(node.right))
+        return node.left;
+    if (isTagMember(node.right) && isStringLiteral(node.left))
+        return node.right;
+    return undefined;
+};
+// Only the nearest function counts: a `_tag` check in a callback nested inside the handler
+// is not the handler discriminating its error.
+export const isInsideBroadEffectHandler = (node) => {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") {
+            const call = current.parent;
+            return (call?.type === "CallExpression" &&
+                broadEffectCatchMethods.has(calleeOf(call, "Effect") ?? "") &&
+                call.arguments.some((argument) => argument === current));
+        }
+    }
+    return false;
+};
+export const propertyName = (property) => {
+    if (!property.computed && property.key.type === "Identifier")
+        return property.key.name;
+    if (isStringLiteral(property.key))
+        return property.key.value;
+    return undefined;
+};
+// The fields that discriminate a closed union: `_tag` for Effect's tagged values, plus whatever
+// the codebase uses (`type`, `kind`). Shared by the rules on comparison and construction.
+const defaultDiscriminants = ["_tag"];
+export const discriminantsSchema = {
+    type: "array",
+    items: { type: "string" },
+    uniqueItems: true,
+};
+export const configuredDiscriminants = (options) => {
+    const [first] = options;
+    if (typeof first !== "object" || first === null || !("discriminants" in first)) {
+        return new Set(defaultDiscriminants);
+    }
+    const names = first.discriminants;
+    return new Set(Array.isArray(names) ? names.filter((name) => typeof name === "string") : []);
+};
+export const discriminantOf = (node, discriminants) => {
+    if (node?.type !== "MemberExpression")
+        return undefined;
+    const name = node.computed
+        ? isStringLiteral(node.property)
+            ? node.property.value
+            : undefined
+        : node.property.type === "Identifier"
+            ? node.property.name
+            : undefined;
+    return name !== undefined && discriminants.has(name) ? name : undefined;
+};