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

package/dist/rules/no-transport-types-in-generator.js

@@ -0,0 +1,63 @@
+import { defineRule } from "@oxlint/plugins";
+import { isInsideEffectGeneratorBody } from "../shared/effect-ast.js";
+const defaultTransportTypes = ["Response", "NextResponse"];
+const configuredTransportTypes = (options) => {
+    const [first] = options;
+    if (typeof first !== "object" || first === null || !("transportTypes" in first)) {
+        return new Set(defaultTransportTypes);
+    }
+    const types = first.transportTypes;
+    return new Set(Array.isArray(types) ? types.filter((type) => typeof type === "string") : []);
+};
+// `new Response(…)`, `Response.json(…)` and a plain factory call `toDto(…)` all build one.
+const constructedTypeName = (node) => {
+    const callee = node.callee;
+    if (callee.type === "Identifier")
+        return callee.name;
+    if (node.type === "CallExpression" &&
+        callee.type === "MemberExpression" &&
+        callee.object.type === "Identifier") {
+        return callee.object.name;
+    }
+    return undefined;
+};
+export const noTransportTypesInGeneratorRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Return domain values from Effect generators and convert them to transport types in the second argument of `Effect.fn`.",
+        },
+        messages: {
+            transportInGenerator: "Do not build `{{name}}` inside the generator: return a domain value and convert it with `Effect.map`/`Effect.catchTags` in the pipeable arguments of `Effect.fn`.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    transportTypes: { type: "array", items: { type: "string" }, uniqueItems: true },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let transportTypes = new Set();
+        const check = (node) => {
+            const name = constructedTypeName(node);
+            if (name === undefined ||
+                !transportTypes.has(name) ||
+                !isInsideEffectGeneratorBody(node)) {
+                return;
+            }
+            context.report({ node, messageId: "transportInGenerator", data: { name } });
+        };
+        return {
+            // Options are per file, so they can only be read once a file starts.
+            before() {
+                transportTypes = configuredTransportTypes(context.options);
+            },
+            NewExpression: check,
+            CallExpression: check,
+        };
+    },
+});

package/dist/rules/no-yielded-match.d.ts

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

package/dist/rules/no-yielded-match.js

@@ -0,0 +1,91 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isEffectGenerator, isFunctionNode, memberOf, nearestFunction, } from "../shared/effect-ast.js";
+import { handlersOf, nestedBranches } from "../shared/match-ast.js";
+const guards = { Option: "Option.isNone", Result: "Result.isFailure" };
+const matchedModule = (node) => {
+    if (node?.type !== "CallExpression")
+        return undefined;
+    if (memberOf(node.callee, "Option") === "match")
+        return "Option";
+    if (memberOf(node.callee, "Result") === "match")
+        return "Result";
+    return undefined;
+};
+const isPipe = (callee) => (callee.type === "Identifier" && callee.name === "pipe") ||
+    (callee.type === "MemberExpression" &&
+        !callee.computed &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "pipe");
+// Data-first `Option.match(x, {…})`, or a match as the last step of `x.pipe(…)`/`pipe(x, …)`.
+const yieldedMatch = (node) => {
+    if (node?.type !== "CallExpression")
+        return undefined;
+    if (matchedModule(node) !== undefined && node.arguments.length === 2)
+        return node;
+    if (!isPipe(node.callee))
+        return undefined;
+    const last = node.arguments.at(-1);
+    return matchedModule(last) !== undefined && last?.type === "CallExpression" ? last : undefined;
+};
+const handlerNamed = (match, name) => {
+    for (const argument of match.arguments) {
+        if (argument.type !== "ObjectExpression")
+            continue;
+        for (const property of argument.properties) {
+            if (property.type === "Property" &&
+                !property.computed &&
+                property.key.type === "Identifier" &&
+                property.key.name === name) {
+                return property.value;
+            }
+        }
+    }
+    return undefined;
+};
+// `onSome: Effect.succeed` or `onSome: (x) => Effect.succeed(x)`.
+const resultsIn = (handler, constructor) => {
+    if (memberOf(handler, "Effect") === constructor)
+        return true;
+    return (isFunctionNode(handler) &&
+        handler.body?.type !== "BlockStatement" &&
+        calleeOf(handler.body, "Effect") === constructor);
+};
+// `option-match-to-from-option` (effecttsgo) proposes `Effect.fromOption` for this shape.
+const isFromOptionShape = (match) => matchedModule(match) === "Option" &&
+    resultsIn(handlerNamed(match, "onNone"), "fail") &&
+    resultsIn(handlerNamed(match, "onSome"), "succeed");
+export const noYieldedMatchRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Inside an Effect generator, return early on the empty or failed case instead of yielding an `Option.match`/`Result.match`.",
+        },
+        messages: {
+            yieldedMatch: "This `yield*` of a `{{module}}.match` splits the generator into two branches: return early with `if ({{guard}}(…)) return …` and keep one main path.",
+        },
+    },
+    createOnce(context) {
+        return {
+            YieldExpression(node) {
+                if (!node.delegate)
+                    return;
+                const match = yieldedMatch(node.argument);
+                const module = matchedModule(match);
+                if (match === undefined || module === undefined)
+                    return;
+                const generator = nearestFunction(node);
+                if (generator === undefined || !isEffectGenerator(generator))
+                    return;
+                if (isFromOptionShape(match))
+                    return;
+                if (handlersOf(match).some((handler) => nestedBranches(handler).length > 0))
+                    return;
+                context.report({
+                    node: match,
+                    messageId: "yieldedMatch",
+                    data: { module, guard: guards[module] },
+                });
+            },
+        };
+    },
+});

package/dist/rules/prefer-effect-fn.d.ts

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

package/dist/rules/prefer-effect-fn.js

@@ -0,0 +1,102 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isEffectFnApplication, isFunctionNode, memberOf, } from "../shared/effect-ast.js";
+const isEffectGenChain = (node) => {
+    if (node?.type !== "CallExpression")
+        return false;
+    if (calleeOf(node, "Effect") === "gen")
+        return true;
+    const callee = node.callee;
+    return (callee.type === "MemberExpression" &&
+        !callee.computed &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "pipe" &&
+        isEffectGenChain(callee.object));
+};
+const returnedExpression = (fn) => {
+    if (fn.body?.type !== "BlockStatement")
+        return fn.body;
+    const statements = fn.body.body;
+    const [only] = statements;
+    return statements.length === 1 && only?.type === "ReturnStatement" ? only.argument : undefined;
+};
+// Callbacks such as `it.effect("…", () => Effect.gen(…))` are not named functions: only
+// declarations, variables and object members get a span name worth having.
+const isNamedFunction = (fn) => {
+    const parent = fn.parent;
+    return (fn.type === "FunctionDeclaration" ||
+        (parent?.type === "VariableDeclarator" && parent.init === fn) ||
+        ((parent?.type === "Property" || parent?.type === "PropertyDefinition") &&
+            parent.value === fn));
+};
+const isPipeCall = (node) => node.callee.type === "MemberExpression" &&
+    !node.callee.computed &&
+    node.callee.property.type === "Identifier" &&
+    node.callee.property.name === "pipe";
+// A value keeps its span through `Effect.withSpan`: `Effect.fn` would add only a call-site frame
+// that always points at the same line.
+const hasSpan = (node) => node?.type === "CallExpression" &&
+    isPipeCall(node) &&
+    node.callee.type === "MemberExpression" &&
+    (node.arguments.some((argument) => calleeOf(argument, "Effect") === "withSpan") ||
+        hasSpan(node.callee.object));
+const isUntracedValue = (node) => isEffectGenChain(node) && !hasSpan(node);
+export const preferEffectFnRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Write effectful functions with a named `Effect.fn` instead of returning `Effect.gen`.",
+        },
+        messages: {
+            useEffectFn: 'Use `Effect.fn("name")(function* (...) {...})` instead of a function that returns `Effect.gen`.',
+            missingName: 'Give `Effect.fn` a span name: `Effect.fn("name")(function* (...) {...})`.',
+            useEffectFnForValue: 'Give `{{name}}` a span: declare it as `Effect.fn("{{name}}")(function* () {...})` and call it, or append `.pipe(Effect.withSpan("{{name}}"))`.',
+            pipeOnEffectFn: "Pass combinators as extra arguments of `Effect.fn(...)(body, ...)` instead of calling `.pipe` on it.",
+        },
+    },
+    createOnce(context) {
+        const checkFunction = (fn) => {
+            if (fn.generator || !isNamedFunction(fn))
+                return;
+            if (isEffectGenChain(returnedExpression(fn))) {
+                context.report({ node: fn, messageId: "useEffectFn" });
+            }
+        };
+        return {
+            VariableDeclarator(node) {
+                if (node.id.type === "Identifier" && isUntracedValue(node.init)) {
+                    context.report({
+                        node,
+                        messageId: "useEffectFnForValue",
+                        data: { name: node.id.name },
+                    });
+                }
+            },
+            Property(node) {
+                if (node.key.type === "Identifier" && isUntracedValue(node.value)) {
+                    context.report({
+                        node,
+                        messageId: "useEffectFnForValue",
+                        data: { name: node.key.name },
+                    });
+                }
+            },
+            ArrowFunctionExpression: checkFunction,
+            FunctionExpression: checkFunction,
+            FunctionDeclaration: checkFunction,
+            CallExpression(node) {
+                if (memberOf(node.callee, "Effect") === "fn" && isFunctionNode(node.arguments[0])) {
+                    context.report({ node, messageId: "missingName" });
+                }
+                const callee = node.callee;
+                if (callee.type === "MemberExpression" &&
+                    !callee.computed &&
+                    callee.property.type === "Identifier" &&
+                    callee.property.name === "pipe" &&
+                    isEffectFnApplication(callee.object) &&
+                    isFunctionNode(callee.object.arguments[0])) {
+                    context.report({ node, messageId: "pipeOnEffectFn" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/prefer-effect-vitest.d.ts

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

package/dist/rules/prefer-effect-vitest.js

@@ -0,0 +1,52 @@
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { defineRule } from "@oxlint/plugins";
+import { runnerName } from "../shared/effect-runners.js";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+// Without `@effect/vitest` the remedy is out of reach, so the rule stays silent. Not cached:
+// a long-lived linter would miss a later install, and only test files pay for the lookup.
+const isEffectVitestInstalled = (filename) => {
+    for (let dir = dirname(filename);; dir = dirname(dir)) {
+        if (existsSync(join(dir, "node_modules", "@effect", "vitest", "package.json")))
+            return true;
+        if (dirname(dir) === dir)
+            return false;
+    }
+};
+// Reports references too, not only calls: `const run = Effect.runPromise` escapes nothing.
+export const preferEffectVitestRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Run Effects in tests through `@effect/vitest`. Only test files of projects that install it are checked.",
+        },
+        messages: {
+            runInTest: "`{{name}}` runs an Effect program in a test: let `@effect/vitest` run it, so the test gets the test runtime and its fixtures become Layers.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let checked = false;
+        return {
+            before() {
+                checked =
+                    isTestFile(context) &&
+                        isEffectVitestInstalled(resolve(context.cwd, context.filename));
+            },
+            MemberExpression(node) {
+                if (!checked)
+                    return;
+                const name = runnerName(node);
+                if (name !== undefined)
+                    context.report({ node, messageId: "runInTest", data: { name } });
+            },
+        };
+    },
+});

package/dist/rules/provide-named-layer.d.ts

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

package/dist/rules/provide-named-layer.js

@@ -0,0 +1,55 @@
+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";
+const matchers = new Set(["match", "$match"]);
+// Factories and module members (`planLayer(csv)`, `CsvSheetReader.layer(path)`) are names;
+// only composition written in the argument itself is reported.
+const isInlineComposition = (layer) => {
+    if (layer?.type === "ConditionalExpression" || layer?.type === "LogicalExpression")
+        return true;
+    if (layer?.type !== "CallExpression" || layer.callee.type !== "MemberExpression")
+        return false;
+    const { callee } = layer;
+    if (callee.object.type === "Identifier" && callee.object.name === "Layer")
+        return true;
+    return (!callee.computed &&
+        callee.property.type === "Identifier" &&
+        matchers.has(callee.property.name));
+};
+export const provideNamedLayerRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Provide named layers instead of composing them inside `Effect.provide`. Test files are skipped.",
+        },
+        messages: {
+            inlineLayer: "Name the layer passed to `Effect.provide` (`const appLayer = Layer.mergeAll(...)`) instead of composing it inline.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let inTestFile = false;
+        return {
+            // Tests build per-test fakes inline, which is the idiomatic form there.
+            before() {
+                inTestFile = isTestFile(context);
+            },
+            CallExpression(node) {
+                if (inTestFile || calleeOf(node, "Effect") !== "provide")
+                    return;
+                // Data-first `Effect.provide(effect, layer)` and data-last `Effect.provide(layer)`.
+                const layer = node.arguments.at(-1);
+                if (isInlineComposition(layer)) {
+                    context.report({ node: layer, messageId: "inlineLayer" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/redacted-secret-names.d.ts

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

package/dist/rules/redacted-secret-names.js

@@ -0,0 +1,125 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, memberOf } from "../shared/effect-ast.js";
+import { propertyName } from "../shared/tagged-values.js";
+// A naming heuristic: `_JSON` is here because a service account key travels as inline JSON.
+const secretName = /(KEY|SECRET|TOKEN|PASSWORD|CREDENTIALS?|_JSON)$/;
+// No generic `token`: `nextPageToken` and `tokenType` are not secrets.
+const defaultSecretFields = [
+    "password",
+    "secret",
+    "apiKey",
+    "accessToken",
+    "refreshToken",
+    "idToken",
+];
+const nullableWrappers = new Set(["optional", "optionalKey", "NullOr", "UndefinedOr", "NullishOr"]);
+const chainMethods = new Set(["pipe", "check", "annotate"]);
+const isRedactedSchema = (node) => node?.type === "CallExpression" &&
+    (memberOf(node.callee, "Schema")?.startsWith("Redacted") ?? false);
+const isRedactedConfig = (node) => {
+    const name = calleeOf(node, "Config");
+    return name === "Redacted" || (name === "schema" && isRedactedSchema(node.arguments[0]));
+};
+const isRedactedReference = (node) => (memberOf(node, "Schema") ?? calleeOf(node, "Schema"))?.startsWith("Redacted") ?? false;
+// `Schema.String`, `Schema.NonEmptyString.check(…)`, `Schema.optional(Schema.String)`: a schema
+// that is visibly plain text. A named schema (`AccessToken`) may already be `Redacted`.
+const isPlainSchema = (node) => {
+    if (node?.type === "MemberExpression") {
+        const name = memberOf(node, "Schema");
+        return name !== undefined && !name.startsWith("Redacted");
+    }
+    if (node?.type !== "CallExpression")
+        return false;
+    const wrapper = calleeOf(node, "Schema");
+    if (wrapper !== undefined)
+        return nullableWrappers.has(wrapper) && isPlainSchema(node.arguments[0]);
+    const { callee } = node;
+    if (callee.type !== "MemberExpression" ||
+        callee.computed ||
+        callee.property.type !== "Identifier" ||
+        !chainMethods.has(callee.property.name)) {
+        return false;
+    }
+    return !node.arguments.some(isRedactedReference) && isPlainSchema(callee.object);
+};
+// `Schema.Struct({…})` and `Schema.Class<X>("X")({…})`.
+const fieldsOf = (node) => {
+    const isStruct = calleeOf(node, "Schema") === "Struct";
+    const isClass = calleeOf(node.callee, "Schema") === "Class";
+    const fields = isStruct || isClass ? node.arguments[0] : undefined;
+    return fields?.type === "ObjectExpression" ? fields : undefined;
+};
+// `password` matches `password` and `dbPassword`, not `passwordPolicy`.
+const matchesSecretField = (name, secretFields) => secretFields.some((field) => name === field || name.endsWith(`${field.charAt(0).toUpperCase()}${field.slice(1)}`));
+const configuredSecretFields = (options) => {
+    const [first] = options;
+    if (typeof first !== "object" || first === null || !("secretFields" in first)) {
+        return defaultSecretFields;
+    }
+    const names = first.secretFields;
+    return Array.isArray(names) ? names.filter((name) => typeof name === "string") : [];
+};
+export const redactedSecretNamesRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Read configuration values and declare Schema fields whose name looks like a secret as `Redacted`.",
+        },
+        messages: {
+            notRedacted: "`{{name}}` looks like a secret: read it with `Config.Redacted` or `Config.schema(Schema.Redacted(...), name)`.",
+            fieldNotRedacted: "`{{name}}` looks like a secret: declare it as `Schema.Redacted(...)` so it stays out of logs.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    secretFields: { type: "array", items: { type: "string" }, uniqueItems: true },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let secretFields = defaultSecretFields;
+        const checkConfig = (node) => {
+            if (calleeOf(node, "Config") === undefined || isRedactedConfig(node))
+                return;
+            for (const argument of node.arguments) {
+                if (argument.type === "Literal" &&
+                    typeof argument.value === "string" &&
+                    secretName.test(argument.value)) {
+                    context.report({
+                        node: argument,
+                        messageId: "notRedacted",
+                        data: { name: argument.value },
+                    });
+                }
+            }
+        };
+        const checkSchemaFields = (node) => {
+            for (const property of fieldsOf(node)?.properties ?? []) {
+                if (property.type !== "Property")
+                    continue;
+                const name = propertyName(property);
+                if (name === undefined || !matchesSecretField(name, secretFields))
+                    continue;
+                if (!isPlainSchema(property.value))
+                    continue;
+                context.report({
+                    node: property.key,
+                    messageId: "fieldNotRedacted",
+                    data: { name },
+                });
+            }
+        };
+        return {
+            before() {
+                secretFields = configuredSecretFields(context.options);
+            },
+            CallExpression(node) {
+                checkConfig(node);
+                checkSchemaFields(node);
+            },
+        };
+    },
+});

package/dist/rules/run-only-in-runner.d.ts

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

package/dist/rules/run-only-in-runner.js

@@ -0,0 +1,40 @@
+import { defineRule } from "@oxlint/plugins";
+import { runnerName } from "../shared/effect-runners.js";
+import { isEntryFile } from "../shared/entry-files.js";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+// Reports references too, not only calls: `const run = Effect.runPromise` escapes nothing.
+export const runOnlyInRunnerRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Run Effect programs only at the entry point. Entry and test files are skipped.",
+        },
+        messages: {
+            runOutsideEntry: "`{{name}}` runs an Effect program: only the entry point may do that.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { entryFiles: filePatternsSchema, testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let skipped = false;
+        return {
+            // How tests run their Effects is `prefer-effect-vitest`'s concern.
+            before() {
+                skipped = isEntryFile(context) || isTestFile(context);
+            },
+            MemberExpression(node) {
+                if (skipped)
+                    return;
+                const name = runnerName(node);
+                if (name !== undefined)
+                    context.report({ node, messageId: "runOutsideEntry", data: { name } });
+            },
+        };
+    },
+});

package/dist/rules/service-built-with-of.d.ts

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

package/dist/rules/service-built-with-of.js

@@ -0,0 +1,74 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isFunctionNode } from "../shared/effect-ast.js";
+const layerConstructors = new Set(["succeed", "sync", "effect", "scoped"]);
+// `Layer.succeed(T, impl)` and the curried `Layer.succeed(T)(impl)`.
+const layerApplication = (node) => {
+    const dataFirst = calleeOf(node, "Layer");
+    if (dataFirst !== undefined && node.arguments.length === 2) {
+        return { constructor: dataFirst, tag: node.arguments[0], impl: node.arguments[1] };
+    }
+    const curried = node.callee.type === "CallExpression" ? calleeOf(node.callee, "Layer") : undefined;
+    if (curried !== undefined && node.callee.type === "CallExpression") {
+        return { constructor: curried, tag: node.callee.arguments[0], impl: node.arguments[0] };
+    }
+    return undefined;
+};
+const returnedObjects = (fn) => {
+    if (fn.body?.type === "ObjectExpression")
+        return [fn.body];
+    if (fn.body?.type !== "BlockStatement")
+        return [];
+    return fn.body.body.flatMap((statement) => statement.type === "ReturnStatement" && statement.argument?.type === "ObjectExpression"
+        ? [statement.argument]
+        : []);
+};
+const implementationObjects = (constructor, impl) => {
+    if (constructor === "succeed")
+        return impl?.type === "ObjectExpression" ? [impl] : [];
+    if (constructor === "sync")
+        return isFunctionNode(impl) ? returnedObjects(impl) : [];
+    if (impl?.type !== "CallExpression" || calleeOf(impl, "Effect") !== "gen")
+        return [];
+    return impl.arguments.flatMap((argument) => isFunctionNode(argument) && argument.generator ? returnedObjects(argument) : []);
+};
+export const serviceBuiltWithOfRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Build the service a Layer provides with `Tag.of({…})` instead of a bare object literal.",
+        },
+        hasSuggestions: true,
+        messages: {
+            bareLiteral: "Build the service with `{{tag}}.of({…})`: it names the service the object implements and keeps its type checked if the literal moves out of the Layer.",
+            wrapWithOf: "Wrap the literal in `{{tag}}.of(…)`.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                const application = layerApplication(node);
+                if (application === undefined || !layerConstructors.has(application.constructor)) {
+                    return;
+                }
+                const { tag, impl } = application;
+                if (tag === undefined || tag.type === "SpreadElement")
+                    return;
+                const tagText = context.sourceCode.getText(tag);
+                for (const literal of implementationObjects(application.constructor, impl)) {
+                    context.report({
+                        node: literal,
+                        messageId: "bareLiteral",
+                        data: { tag: tagText },
+                        suggest: [
+                            {
+                                messageId: "wrapWithOf",
+                                data: { tag: tagText },
+                                fix: (fixer) => fixer.replaceText(literal, `${tagText}.of(${context.sourceCode.getText(literal)})`),
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/service-key-matches-name.d.ts

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