@commonplaces/oxlint-plugin 0.0.0-stage → 0.1.1

package/dist/anti-slop/rules/no-known-value-widening.js

@@ -0,0 +1,171 @@
+import { Array, Option } from "effect";
+import { variableInScope } from "../../syntax.js";
+import { defineRule } from "@oxlint/plugins";
+import { classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression, } from "../shared/dictionary-types.js";
+function unwrapExpression(expression) {
+    const current = expression;
+    if (current.type === "ParenthesizedExpression" ||
+        current.type === "TSAsExpression" ||
+        current.type === "TSSatisfiesExpression" ||
+        current.type === "TSTypeAssertion" ||
+        current.type === "TSNonNullExpression") {
+        return unwrapExpression(current.expression);
+    }
+    return current;
+}
+function resolveVariable(sourceCode, identifier) {
+    return Option.getOrNull(variableInScope(sourceCode.getScope(identifier), identifier.name));
+}
+function variableDeclarator(variable) {
+    if (variable.defs.length !== 1)
+        return null;
+    const [definition] = variable.defs;
+    return definition?.type === "Variable" && definition.node.type === "VariableDeclarator"
+        ? definition.node
+        : null;
+}
+function isStableConstVariable(variable, declarator) {
+    return (declarator.parent.type === "VariableDeclaration" &&
+        declarator.parent.kind === "const" &&
+        Array.every(variable.references, (reference) => reference.init || !reference.isWrite()));
+}
+function hasKnownEvidence(sourceCode, expression, visitedVariables = []) {
+    if (isKnownEvidenceExpression(expression))
+        return true;
+    const unwrapped = unwrapExpression(expression);
+    if (unwrapped.type !== "Identifier")
+        return false;
+    const variable = resolveVariable(sourceCode, unwrapped);
+    if (variable === null || Array.some(visitedVariables, (previous) => previous === variable))
+        return false;
+    const declarator = variableDeclarator(variable);
+    if (declarator === null ||
+        declarator.init === null ||
+        !isStableConstVariable(variable, declarator)) {
+        return false;
+    }
+    return hasKnownEvidence(sourceCode, declarator.init, [...visitedVariables, variable]);
+}
+function annotationTarget(annotation, environment) {
+    return annotation === null || annotation === undefined
+        ? null
+        : classifyWideningTarget(annotation.typeAnnotation, environment);
+}
+function enclosingFunction(node) {
+    const current = node.parent;
+    if (current === null || current.type === "Program")
+        return null;
+    return current.type === "ArrowFunctionExpression" ||
+        current.type === "FunctionDeclaration" ||
+        current.type === "FunctionExpression"
+        ? current
+        : enclosingFunction(current);
+}
+function sourceKeyName(sourceCode, key) {
+    if (key.type === "Identifier" || key.type === "PrivateIdentifier")
+        return key.name;
+    if (key.type === "Literal")
+        return String(key.value);
+    return sourceCode.getText(key);
+}
+function functionName(sourceCode, owner) {
+    if (owner === null)
+        return "anonymous function";
+    if (owner.id !== null)
+        return owner.id.name;
+    const parent = owner.parent;
+    if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier")
+        return parent.id.name;
+    if (parent.type === "MethodDefinition")
+        return sourceKeyName(sourceCode, parent.key);
+    return "anonymous function";
+}
+function isEmptyObjectExpression(expression) {
+    const unwrapped = unwrapExpression(expression);
+    return unwrapped.type === "ObjectExpression" && unwrapped.properties.length === 0;
+}
+function isDictionaryAccumulatorTarget(destination) {
+    return destination.kind === "open dictionary" || destination.kind === "generic container";
+}
+function hasParentAssertion(node) {
+    return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
+}
+/** Detect sound syntactic cases where a known value is explicitly widened and loses evidence. */
+export const noKnownValueWideningRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence.",
+        },
+        messages: {
+            widening: "The explicit {{target}} type on {{subject}} discards known type evidence. Keep inference, validate with `satisfies`, or use a named owner contract.",
+        },
+    },
+    create(context) {
+        const environment = createTypeEnvironment(context.sourceCode.ast);
+        const reportFlow = (expression, destination, subject) => {
+            if (destination === null)
+                return;
+            if (isDictionaryAccumulatorTarget(destination) && isEmptyObjectExpression(expression)) {
+                return;
+            }
+            if (!hasKnownEvidence(context.sourceCode, expression))
+                return;
+            context.report({
+                node: expression,
+                messageId: "widening",
+                data: { subject, target: destination.kind },
+            });
+        };
+        const targetFromAnnotation = (annotation) => annotationTarget(annotation, environment);
+        return {
+            VariableDeclarator(node) {
+                if (node.init === null || node.id.type !== "Identifier")
+                    return;
+                reportFlow(node.init, targetFromAnnotation(node.id.typeAnnotation), `binding \`${node.id.name}\``);
+            },
+            PropertyDefinition(node) {
+                if (node.value === null)
+                    return;
+                reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+            },
+            AccessorProperty(node) {
+                if (node.value === null)
+                    return;
+                reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+            },
+            AssignmentExpression(node) {
+                if (node.operator !== "=" || node.left.type !== "Identifier")
+                    return;
+                const variable = resolveVariable(context.sourceCode, node.left);
+                if (variable === null)
+                    return;
+                const declarator = variableDeclarator(variable);
+                if (declarator === null || declarator.id.type !== "Identifier")
+                    return;
+                reportFlow(node.right, targetFromAnnotation(declarator.id.typeAnnotation), `binding \`${declarator.id.name}\``);
+            },
+            ReturnStatement(node) {
+                if (node.argument === null)
+                    return;
+                const owner = enclosingFunction(node);
+                reportFlow(node.argument, targetFromAnnotation(owner?.returnType), `return value of \`${functionName(context.sourceCode, owner)}\``);
+            },
+            ArrowFunctionExpression(node) {
+                if (node.body.type === "BlockStatement")
+                    return;
+                reportFlow(node.body, targetFromAnnotation(node.returnType), `return value of \`${functionName(context.sourceCode, node)}\``);
+            },
+            TSAsExpression(node) {
+                if (hasParentAssertion(node))
+                    return;
+                reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
+            },
+            TSTypeAssertion(node) {
+                if (hasParentAssertion(node))
+                    return;
+                reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
+            },
+        };
+    },
+});

package/dist/anti-slop/rules/no-module-mocking.d.ts

@@ -0,0 +1,2 @@
+/** Ban test framework module mocking in favor of real dependency seams. */
+export declare const noModuleMockingRule: import("@oxlint/plugins").Rule;

package/dist/anti-slop/rules/no-module-mocking.js

@@ -0,0 +1,73 @@
+import { Array, Option } from "effect";
+import { variableInScope } from "../../syntax.js";
+import { defineRule } from "@oxlint/plugins";
+const moduleMockMethods = ["doMock", "mock", "unstable_mockModule"];
+function resolveVariable(sourceCode, identifier) {
+    return Option.getOrNull(variableInScope(sourceCode.getScope(identifier), identifier.name));
+}
+function importedName(node) {
+    if (node.type !== "ImportSpecifier")
+        return null;
+    return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
+}
+function isTestFrameworkObject(sourceCode, expression) {
+    if (expression.type !== "Identifier")
+        return false;
+    if ((expression.name === "vi" || expression.name === "jest") &&
+        sourceCode.isGlobalReference(expression)) {
+        return true;
+    }
+    const variable = resolveVariable(sourceCode, expression);
+    if (variable === null || variable.defs.length === 0) {
+        return expression.name === "vi" || expression.name === "jest";
+    }
+    return Array.some(variable.defs, (definition) => {
+        if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") {
+            return false;
+        }
+        const source = definition.parent.source.value;
+        const name = importedName(definition.node);
+        return ((source === "vitest" && name === "vi") || (source === "@jest/globals" && name === "jest"));
+    });
+}
+function moduleMockCall(sourceCode, callee) {
+    if (!("property" in callee) || !("object" in callee) || !("computed" in callee))
+        return false;
+    if (!isTestFrameworkObject(sourceCode, callee.object))
+        return false;
+    const property = callee.property;
+    const method = callee.computed
+        ? property.type === "Literal" &&
+            (property.value === "doMock" ||
+                property.value === "mock" ||
+                property.value === "unstable_mockModule")
+            ? property.value
+            : null
+        : property.type === "Identifier"
+            ? property.name
+            : null;
+    return method !== null && Array.contains(moduleMockMethods, method);
+}
+/** Ban test framework module mocking in favor of real dependency seams. */
+export const noModuleMockingRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow Vitest and Jest module mocking; tests must replace dependencies through real interfaces.",
+        },
+        messages: {
+            moduleMock: "Replace module mocking with dependency injection through a real interface, service layer, or faithful test implementation.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
+                    return;
+                if (moduleMockCall(context.sourceCode, node.callee)) {
+                    context.report({ node, messageId: "moduleMock" });
+                }
+            },
+        };
+    },
+});

package/dist/anti-slop/rules/no-object-parameters.d.ts

@@ -0,0 +1,2 @@
+/** Ban the broad object type on function inputs, including local aliases to object. */
+export declare const noObjectParametersRule: import("@oxlint/plugins").Rule;

package/dist/anti-slop/rules/no-object-parameters.js

@@ -0,0 +1,86 @@
+import { Array, HashMap, Option } from "effect";
+import { createTypeEnvironment } from "../shared/dictionary-types.js";
+import { defineRule } from "@oxlint/plugins";
+import { lexicalTypeParameterNames } from "../shared/lexical-type-parameters.js";
+function parameterAnnotation(parameter) {
+    if (parameter.type === "TSParameterProperty") {
+        return parameterAnnotation(parameter.parameter);
+    }
+    if (parameter.type === "RestElement") {
+        return parameter.typeAnnotation ?? parameterAnnotation(parameter.argument);
+    }
+    if (parameter.type === "AssignmentPattern") {
+        return parameter.typeAnnotation ?? parameter.left.typeAnnotation;
+    }
+    return parameter.typeAnnotation;
+}
+function parameterName(parameter, sourceCode) {
+    return parameter.type === "Identifier"
+        ? parameter.name
+        : sourceCode.getText(parameter).replace(/\s*:\s*object\s*$/u, "");
+}
+/** Ban the broad object type on function inputs, including local aliases to object. */
+export const noObjectParametersRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow object function parameters; inputs must use an owner-provided type and be parsed at their boundary.",
+        },
+        messages: {
+            objectParameter: "Parameter `{{parameter}}` uses the broad `object` type. Accept a named owner type; parse external input at its boundary before calling this function.",
+        },
+    },
+    create(context) {
+        const aliases = createTypeEnvironment(context.sourceCode.ast).aliases;
+        const resolvesToObject = (type, shadowedAliases, visited = []) => {
+            if (type.type === "TSObjectKeyword")
+                return true;
+            if (type.type === "TSParenthesizedType")
+                return resolvesToObject(type.typeAnnotation, shadowedAliases, visited);
+            if (type.type === "TSUnionType") {
+                return Array.some(type.types, (member) => resolvesToObject(member, shadowedAliases, visited));
+            }
+            if (type.type !== "TSTypeReference" ||
+                type.typeName.type !== "Identifier" ||
+                (type.typeArguments !== null &&
+                    type.typeArguments !== undefined &&
+                    type.typeArguments.params.length > 0) ||
+                Array.contains(visited, type.typeName.name) ||
+                Array.contains(shadowedAliases, type.typeName.name)) {
+                return false;
+            }
+            const alias = Option.getOrUndefined(HashMap.get(aliases, type.typeName.name));
+            if (alias === undefined || alias.typeParameters != null)
+                return false;
+            const nextVisited = [...visited, type.typeName.name];
+            return resolvesToObject(alias.typeAnnotation, shadowedAliases, nextVisited);
+        };
+        const checkParameters = (node) => {
+            const shadowedAliases = lexicalTypeParameterNames(node, context);
+            Array.forEach(node.params, (parameter) => {
+                const annotation = parameterAnnotation(parameter);
+                if (annotation === null || annotation === undefined)
+                    return;
+                if (!resolvesToObject(annotation.typeAnnotation, shadowedAliases))
+                    return;
+                context.report({
+                    node: annotation.typeAnnotation,
+                    messageId: "objectParameter",
+                    data: { parameter: parameterName(parameter, context.sourceCode) },
+                });
+            });
+        };
+        return {
+            ArrowFunctionExpression: checkParameters,
+            FunctionDeclaration: checkParameters,
+            FunctionExpression: checkParameters,
+            TSCallSignatureDeclaration: checkParameters,
+            TSConstructSignatureDeclaration: checkParameters,
+            TSConstructorType: checkParameters,
+            TSDeclareFunction: checkParameters,
+            TSEmptyBodyFunctionExpression: checkParameters,
+            TSFunctionType: checkParameters,
+            TSMethodSignature: checkParameters,
+        };
+    },
+});

package/dist/anti-slop/rules/no-reflect-apply.d.ts

@@ -0,0 +1,2 @@
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+export declare const noReflectApplyRule: import("@oxlint/plugins").Rule;

package/dist/anti-slop/rules/no-reflect-apply.js

@@ -0,0 +1,25 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobalReflectMethodCall } from "../shared/reflect-method.js";
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+export const noReflectApplyRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow Reflect.apply; call typed functions directly or model dynamic dispatch behind an interface.",
+        },
+        messages: {
+            reflectApply: "Replace `Reflect.apply` with a typed function call. Model dynamic dispatch behind a named interface.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
+                    return;
+                if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "apply")) {
+                    context.report({ node, messageId: "reflectApply" });
+                }
+            },
+        };
+    },
+});

package/dist/anti-slop/rules/no-reflect-get.d.ts

@@ -0,0 +1,2 @@
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+export declare const noReflectGetRule: import("@oxlint/plugins").Rule;

package/dist/anti-slop/rules/no-reflect-get.js

@@ -0,0 +1,25 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobalReflectMethodCall } from "../shared/reflect-method.js";
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+export const noReflectGetRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow Reflect.get; use typed property access or parse dynamic input into a domain type.",
+        },
+        messages: {
+            reflectGet: "Replace `Reflect.get` with typed property access. Parse dynamic input into a named domain type before reading it.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
+                    return;
+                if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "get")) {
+                    context.report({ node, messageId: "reflectGet" });
+                }
+            },
+        };
+    },
+});

package/dist/anti-slop/rules/no-runtime-typeof.d.ts

@@ -0,0 +1,2 @@
+/** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
+export declare const noRuntimeTypeofRule: import("@oxlint/plugins").Rule;

package/dist/anti-slop/rules/no-runtime-typeof.js

@@ -0,0 +1,47 @@
+import { Array, Option, Schema } from "effect";
+import { defineRule } from "@oxlint/plugins";
+function isRuntimeFunction(node) {
+    return (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionDeclaration" ||
+        node.type === "FunctionExpression");
+}
+function isInsideTypeGuard(node) {
+    const current = node.parent;
+    if (current === null || current.type === "Program")
+        return false;
+    return isRuntimeFunction(current)
+        ? current.returnType?.typeAnnotation.type === "TSTypePredicate"
+        : isInsideTypeGuard(current);
+}
+/** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
+export const noRuntimeTypeofRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow runtime typeof checks; external values must be decoded into meaningful types at their I/O boundary.",
+        },
+        messages: {
+            runtimeTypeof: "A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowInTypeGuards: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        defaultOptions: [{ allowInTypeGuards: false }],
+    },
+    createOnce(context) {
+        return {
+            UnaryExpression(node) {
+                const allowInTypeGuards = Schema.is(Schema.Struct({ allowInTypeGuards: Schema.Literal(true) }))(Option.getOrUndefined(Array.head(context.options)));
+                if (node.operator === "typeof" && (!allowInTypeGuards || !isInsideTypeGuard(node))) {
+                    context.report({ node, messageId: "runtimeTypeof" });
+                }
+            },
+        };
+    },
+});

package/dist/anti-slop/rules/no-shape-in-symbol-names.d.ts

@@ -0,0 +1,2 @@
+/** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
+export declare const noForbiddenTermInSymbolNamesRule: import("@oxlint/plugins").Rule;

package/dist/anti-slop/rules/no-shape-in-symbol-names.js

@@ -0,0 +1,33 @@
+import { defineRule } from "@oxlint/plugins";
+const FORBIDDEN_SYMBOL_NAME = "shape";
+function containsForbiddenSymbolName(name) {
+    return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
+}
+/** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
+export const noForbiddenTermInSymbolNamesRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: 'Disallow the case-insensitive substring "shape" in JavaScript, TypeScript, private, and JSX symbol names.',
+        },
+        messages: {
+            forbiddenSymbolName: 'Rename symbol "{{name}}" for its domain role; "shape" describes structure rather than ownership.',
+        },
+    },
+    createOnce(context) {
+        const reportForbiddenSymbolName = (node) => {
+            if (!containsForbiddenSymbolName(node.name))
+                return;
+            context.report({
+                node,
+                messageId: "forbiddenSymbolName",
+                data: { name: node.name },
+            });
+        };
+        return {
+            Identifier: reportForbiddenSymbolName,
+            PrivateIdentifier: reportForbiddenSymbolName,
+            JSXIdentifier: reportForbiddenSymbolName,
+        };
+    },
+});

package/dist/anti-slop/rules/no-unknown-parameters.d.ts

@@ -0,0 +1,2 @@
+/** Disallow unknown inputs except explicitly named error-cause enrichment. */
+export declare const noUnknownParametersRule: import("@oxlint/plugins").Rule;

package/dist/anti-slop/rules/no-unknown-parameters.js

@@ -0,0 +1,69 @@
+import { Array } from "effect";
+import { defineRule } from "@oxlint/plugins";
+function parameterAnnotation(parameter) {
+    if (parameter.type === "TSParameterProperty") {
+        return parameterAnnotation(parameter.parameter);
+    }
+    if (parameter.type === "RestElement") {
+        return parameter.typeAnnotation ?? parameterAnnotation(parameter.argument);
+    }
+    if (parameter.type === "AssignmentPattern") {
+        return parameter.typeAnnotation ?? parameter.left.typeAnnotation;
+    }
+    return parameter.typeAnnotation;
+}
+function parameterName(parameter, sourceText) {
+    if (parameter.type === "TSParameterProperty") {
+        return parameterName(parameter.parameter, sourceText);
+    }
+    if (parameter.type === "AssignmentPattern") {
+        return parameterName(parameter.left, sourceText);
+    }
+    if (parameter.type === "RestElement") {
+        return parameterName(parameter.argument, sourceText);
+    }
+    return parameter.type === "Identifier"
+        ? parameter.name
+        : sourceText.replace(/\s*:\s*unknown\s*$/u, "");
+}
+/** Disallow unknown inputs except explicitly named error-cause enrichment. */
+export const noUnknownParametersRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow explicitly unknown function parameters except `cause`; decode unknown input at its I/O boundary instead.",
+        },
+        messages: {
+            unknownParameter: "Parameter `{{parameter}}` leaves input unparsed. Accept a named domain type; run the expected schema or parser at the I/O boundary before calling this function.",
+        },
+    },
+    createOnce(context) {
+        const checkParameters = (node) => {
+            Array.forEach(node.params, (parameter) => {
+                const annotation = parameterAnnotation(parameter);
+                if (annotation?.typeAnnotation.type !== "TSUnknownKeyword")
+                    return;
+                const name = parameterName(parameter, context.sourceCode.getText(parameter));
+                if (name === "cause")
+                    return;
+                context.report({
+                    node: annotation.typeAnnotation,
+                    messageId: "unknownParameter",
+                    data: { parameter: name },
+                });
+            });
+        };
+        return {
+            ArrowFunctionExpression: checkParameters,
+            FunctionDeclaration: checkParameters,
+            FunctionExpression: checkParameters,
+            TSCallSignatureDeclaration: checkParameters,
+            TSConstructSignatureDeclaration: checkParameters,
+            TSConstructorType: checkParameters,
+            TSDeclareFunction: checkParameters,
+            TSEmptyBodyFunctionExpression: checkParameters,
+            TSFunctionType: checkParameters,
+            TSMethodSignature: checkParameters,
+        };
+    },
+});

package/dist/anti-slop/rules/no-unknown-returns.d.ts

@@ -0,0 +1,2 @@
+/** Ban function contracts that return unknown instead of a parsed domain type. */
+export declare const noUnknownReturnsRule: import("@oxlint/plugins").Rule;

package/dist/anti-slop/rules/no-unknown-returns.js

@@ -0,0 +1,77 @@
+import { Array, HashMap, Option } from "effect";
+import { createTypeEnvironment } from "../shared/dictionary-types.js";
+import { defineRule } from "@oxlint/plugins";
+import { lexicalTypeParameterNames } from "../shared/lexical-type-parameters.js";
+function referencedAliasName(type) {
+    if (type.type === "TSParenthesizedType")
+        return referencedAliasName(type.typeAnnotation);
+    if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier")
+        return null;
+    return type.typeArguments === null ||
+        type.typeArguments === undefined ||
+        type.typeArguments.params.length === 0
+        ? type.typeName.name
+        : null;
+}
+/** Ban function contracts that return unknown instead of a parsed domain type. */
+export const noUnknownReturnsRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow functions whose explicit return contract is unknown or Promise<unknown>.",
+        },
+        messages: {
+            unknownReturn: "This function exposes `unknown` to its caller. Parse the value at its boundary and return a named domain type.",
+        },
+    },
+    create(context) {
+        const aliases = createTypeEnvironment(context.sourceCode.ast).aliases;
+        const resolvesToUnknown = (type, shadowedAliases, visited = []) => {
+            if (type.type === "TSUnknownKeyword")
+                return true;
+            if (type.type === "TSParenthesizedType") {
+                return resolvesToUnknown(type.typeAnnotation, shadowedAliases, visited);
+            }
+            if (type.type === "TSUnionType") {
+                return Array.some(type.types, (member) => resolvesToUnknown(member, shadowedAliases, visited));
+            }
+            if (type.type === "TSTypeReference" &&
+                type.typeName.type === "Identifier" &&
+                (type.typeName.name === "Promise" || type.typeName.name === "PromiseLike")) {
+                const value = Option.getOrUndefined(Array.head(type.typeArguments?.params ?? []));
+                return value !== undefined && resolvesToUnknown(value, shadowedAliases, visited);
+            }
+            const name = referencedAliasName(type);
+            if (name === null || Array.contains(visited, name) || Array.contains(shadowedAliases, name))
+                return false;
+            const alias = Option.getOrUndefined(HashMap.get(aliases, name));
+            if (alias === undefined ||
+                (alias.typeParameters !== null && alias.typeParameters !== undefined)) {
+                return false;
+            }
+            const nextVisited = [...visited, name];
+            return resolvesToUnknown(alias.typeAnnotation, shadowedAliases, nextVisited);
+        };
+        const checkReturnType = (node) => {
+            const annotation = node.returnType;
+            if (annotation === null || annotation === undefined)
+                return;
+            if (!resolvesToUnknown(annotation.typeAnnotation, lexicalTypeParameterNames(node, context))) {
+                return;
+            }
+            context.report({ node: annotation.typeAnnotation, messageId: "unknownReturn" });
+        };
+        return {
+            ArrowFunctionExpression: checkReturnType,
+            FunctionDeclaration: checkReturnType,
+            FunctionExpression: checkReturnType,
+            TSCallSignatureDeclaration: checkReturnType,
+            TSConstructSignatureDeclaration: checkReturnType,
+            TSConstructorType: checkReturnType,
+            TSDeclareFunction: checkReturnType,
+            TSEmptyBodyFunctionExpression: checkReturnType,
+            TSFunctionType: checkReturnType,
+            TSMethodSignature: checkReturnType,
+        };
+    },
+});

package/dist/anti-slop/rules/no-unknown-type-aliases.d.ts

@@ -0,0 +1,2 @@
+/** Ban named aliases that merely conceal TypeScript's unknown top type. */
+export declare const noUnknownTypeAliasesRule: import("@oxlint/plugins").Rule;