ai-deslop 0.4.6 → 0.4.7

package/README.md

@@ -2,7 +2,7 @@
 
 Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.
 
-Rules are vendored from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (generic rules) alongside additional deslop rules, all renamed under the `deslop/*` namespace. The vendored source is MIT licensed; see Credits below.
+Combines vendored anti-slop rules with additional rules under the `deslop/*` namespace. See Credits for attribution.
 
 ## Install
 
@@ -26,71 +26,65 @@ export default defineConfig({
 });
 ```
 
-## Rules
-
-### Type safety and evidence
-
-| Rule | Status | Description |
-| --- | --- | --- |
-| `no-chained-type-assertions` | Recommended | Rejects nested `as` / angle-bracket assertions that fabricate evidence. |
-| `no-conditional-empty-object-spread` | Recommended | Reports object spreads using a conditional `{}` branch to omit fields. |
-| `no-known-value-widening` | Recommended | Rejects known expressions flowing into explicit `unknown`, `object`, or open dictionaries. |
-| `no-object-parameters` | Recommended | Rejects `object` on function inputs. |
-| `no-runtime-typeof` | Recommended | Requires boundary parsing instead of ad hoc `typeof` narrowing. |
-| `no-unknown-parameters` | Recommended | Rejects `unknown` on function inputs. |
-| `no-unknown-returns` | Recommended | Rejects return contracts resolving to `unknown`. |
-| `no-unknown-type-aliases` | Recommended | Rejects aliases whose resolved type is `unknown`. |
-| `no-unsafe-dictionary-type` | Recommended | Rejects dictionary values based on unsafe escape hatches. |
-| `no-widen-then-assert` | Recommended | Rejects widening known evidence before narrowing assertions. |
-| `require-safety-comment-for-type-assertion` | Recommended | Requires an invariant justification for non-const assertions. |
-| `no-pass-through-type-alias` | Recommended | Disallows aliases that only rename another type. |
+## Rules
+
+All rules below are enabled by the recommended config unless listed as opt-in.
+
+### Type safety and evidence
+
+| Rule | Description |
+| --- | --- |
+| `no-chained-type-assertions` | Rejects nested `as` / angle-bracket assertions that fabricate evidence. |
+| `no-conditional-empty-object-spread` | Reports object spreads using a conditional `{}` branch to omit fields. |
+| `no-known-value-widening` | Rejects known expressions flowing into explicit `unknown`, `object`, or open dictionaries. |
+| `no-object-parameters` | Rejects `object` on function inputs. |
+| `no-runtime-typeof` | Requires boundary parsing instead of ad hoc `typeof` narrowing. |
+| `no-unknown-parameters` | Rejects `unknown` on function inputs. |
+| `no-unknown-returns` | Rejects return contracts resolving to `unknown`. |
+| `no-unknown-type-aliases` | Rejects aliases whose resolved type is `unknown`. |
+| `no-unsafe-dictionary-type` | Rejects dictionary values based on unsafe escape hatches. |
+| `no-widen-then-assert` | Rejects widening known evidence before narrowing assertions. |
+| `require-safety-comment-for-type-assertion` | Requires an invariant justification for non-const assertions. |
+| `no-pass-through-type-alias` | Disallows aliases that only rename another type. |
 
 ### Code quality and APIs
 
-| Rule | Status | Description |
-| --- | --- | --- |
-| `no-array-filter-map` | Recommended | Rejects adjacent eager array filter/map passes; allows lazy iterator pipelines. |
-| `no-reduce-accumulator-copy` | Recommended | Rejects non-spread accumulator copies inside reducers. Enable native `oxc/no-accumulating-spread` alongside it. |
-| `no-reflect-apply` | Recommended | Rejects global `Reflect.apply`. |
-| `no-reflect-get` | Recommended | Rejects global `Reflect.get`. |
-| `no-shape-in-symbol-names` | Recommended | Rejects `shape` in locally owned symbol names. |
+| Rule | Description |
+| --- | --- |
+| `no-array-filter-map` | Rejects adjacent eager array filter/map passes; allows lazy iterator pipelines. |
+| `no-reduce-accumulator-copy` | Rejects non-spread accumulator copies inside reducers. Enable native `oxc/no-accumulating-spread` alongside it. |
+| `no-reflect-apply` | Rejects global `Reflect.apply`. |
+| `no-reflect-get` | Rejects global `Reflect.get`. |
+| `no-shape-in-symbol-names` | Rejects `shape` in locally owned symbol names. |
 
 ### Tests
 
-| Rule | Status | Description |
-| --- | --- | --- |
-| `no-call-only-assertions` | Recommended | Flags tests whose assertions only check mock calls. |
-| `no-module-mocking` | Recommended | Rejects Vitest and Jest module mocks. |
-| `no-poor-substring-tests` | Recommended | Rejects testing that a constant string contains substrings. |
-| `no-repeated-expect-call` | Recommended | Flags adjacent assertions that repeat the same call in test files. Reuse the result instead. No fixer. |
+| Rule | Description |
+| --- | --- |
+| `no-call-only-assertions` | Flags tests whose assertions only check mock calls. |
+| `no-module-mocking` | Rejects Vitest and Jest module mocks. |
+| `no-poor-substring-tests` | Rejects testing that a constant string contains substrings. |
+| `no-repeated-expect-call` | Flags adjacent assertions that repeat the same call in test files. Reuse the result instead. No fixer. |
 
 ### Opt-in rules
 
-| Rule | Status | Description |
-| --- | --- | --- |
-| [`no-duplicate-consts`](docs/no-duplicate-consts.md) | Opt-in | Reports all-caps constants with the same static value in different files. |
-| [`no-duplicate-types`](docs/no-duplicate-types.md) | Opt-in | Reports exact duplicate object contracts. No fixer. |
-| [`no-renamed-imports`](docs/no-renamed-imports.md) | Opt-in | Fixes unnecessary named-import aliases when the original name has no module-level conflict. |
-| [`canonical-class-names`](docs/tailwind.md) | Opt-in | Fixes non-canonical Tailwind CSS v4 class spellings. |
+| Rule | Description |
+| --- | --- |
+| [`no-duplicate-consts`](docs/no-duplicate-consts.md) | Reports all-caps constants with the same static value in different files. |
+| [`no-duplicate-types`](docs/no-duplicate-types.md) | Reports exact duplicate object contracts. No fixer. |
+| [`no-renamed-imports`](docs/no-renamed-imports.md) | Fixes unnecessary named-import aliases when the original name has no module-level conflict. |
+| [`no-reexports-outside-entrypoints`](docs/no-reexports-outside-entrypoints.md) | Keeps re-exports in configured entrypoint files. No fixer. |
+| [`canonical-class-names`](docs/tailwind.md) | Fixes non-canonical Tailwind CSS v4 class spellings. |
 
 ### Standard rules enabled by the recommended config
 
-| Standard rule | Status | Description |
-| --- | --- | --- |
-| `typescript/no-deprecated` | Recommended | Disallows using code marked `@deprecated`. Requires type-aware linting. |
-| `typescript/no-require-imports` | Recommended | Disallows CommonJS `require()` imports. |
-| `typescript/no-floating-promises` | Recommended | Disallows floating promises. Requires type-aware linting. |
-| `typescript/no-unnecessary-condition` | Recommended | Disallows always truthy/falsy/nullish conditions. Requires type-aware linting. |
-| `no-unreachable` | Recommended | Disallows unreachable code. |
-
-## Guides
-
-| Guide | Contents |
-| --- | --- |
-| [No duplicate consts](docs/no-duplicate-consts.md) | Configuration and exact static-value comparison behavior. |
-| [No duplicate types](docs/no-duplicate-types.md) | Exact comparison behavior, worker scope, complete TypeScript/JSON examples, and every supported option. |
-| [No renamed imports](docs/no-renamed-imports.md) | When named-import aliases are fixed and how conflicts are handled. |
-| [Tailwind canonical class names](docs/tailwind.md) | Tailwind v4 setup, complete TypeScript/JSON examples, and every supported option. |
+| Standard rule | Description |
+| --- | --- |
+| `typescript/no-deprecated` | Disallows using code marked `@deprecated`. Requires type-aware linting. |
+| `typescript/no-require-imports` | Disallows CommonJS `require()` imports. |
+| `typescript/no-floating-promises` | Disallows floating promises. Requires type-aware linting. |
+| `typescript/no-unnecessary-condition` | Disallows always truthy/falsy/nullish conditions. Requires type-aware linting. |
+| `no-unreachable` | Disallows unreachable code. |
 
 ## Credits
 

package/dist/index.js

@@ -23,6 +23,7 @@ import { noPassThroughTypeAliasRule } from "./rules/no-pass-through-type-alias.j
 import { noDuplicateTypesRule } from "./rules/no-duplicate-types.js";
 import { noDuplicateConstsRule } from "./rules/no-duplicate-consts.js";
 import { noRenamedImportsRule } from "./rules/no-renamed-imports.js";
+import { noReexportsOutsideEntrypointsRule } from "./rules/no-reexports-outside-entrypoints.js";
 import { canonicalClassNames } from "./tailwind/rule.js";
 /** Every `deslop/*` rule, plus selected standard rules, each set to `"error"`. Spread into the `rules` field of an oxlint config. */
 export const recommendedRules = {
@@ -90,6 +91,7 @@ const deslopPlugin = eslintCompatPlugin({
         "no-duplicate-types": noDuplicateTypesRule,
         "no-duplicate-consts": noDuplicateConstsRule,
         "no-renamed-imports": noRenamedImportsRule,
+        "no-reexports-outside-entrypoints": noReexportsOutsideEntrypointsRule,
         // Opt-in: NOT in `recommendedRules`. Requires a `cssPath` option, so users add it manually.
         "canonical-class-names": canonicalClassNames,
     },

package/dist/rules/no-reexports-outside-entrypoints.d.ts

@@ -0,0 +1,2 @@
+/** Keep re-exports in explicitly allowed entrypoint files. */
+export declare const noReexportsOutsideEntrypointsRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-reexports-outside-entrypoints.js

@@ -0,0 +1,51 @@
+import { matchesGlob, relative } from "node:path";
+import { defineRule } from "@oxlint/plugins";
+import { resolveVariable } from "../shared/scope.js";
+/** Keep re-exports in explicitly allowed entrypoint files. */
+export const noReexportsOutsideEntrypointsRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Disallow re-exports outside configured entrypoint files" },
+        messages: {
+            reexport: "Re-export this symbol from a package entrypoint instead of this file.",
+        },
+        schema: [{
+                type: "object",
+                properties: {
+                    entrypoints: { type: "array", items: { type: "string" } },
+                },
+                additionalProperties: false,
+            }],
+    },
+    createOnce(context) {
+        function isImported(node) {
+            return resolveVariable(context.sourceCode, node)?.defs.some((definition) => definition.type === "ImportBinding") ?? false;
+        }
+        return {
+            before() {
+                const options = context.options[0];
+                const filename = relative(context.cwd, context.filename).replaceAll("\\", "/");
+                return !(options?.entrypoints ?? ["**/index.ts"]).some((pattern) => matchesGlob(filename, pattern));
+            },
+            ExportNamedDeclaration(node) {
+                if (node.source !== null) {
+                    context.report({ node, messageId: "reexport" });
+                    return;
+                }
+                for (const specifier of node.specifiers) {
+                    if (specifier.local.type === "Identifier" && isImported(specifier.local)) {
+                        context.report({ node: specifier, messageId: "reexport" });
+                    }
+                }
+            },
+            ExportAllDeclaration(node) {
+                context.report({ node, messageId: "reexport" });
+            },
+            ExportDefaultDeclaration(node) {
+                if (node.declaration.type === "Identifier" && isImported(node.declaration)) {
+                    context.report({ node, messageId: "reexport" });
+                }
+            },
+        };
+    },
+});

package/dist/shared/lexical-bindings.d.ts

@@ -0,0 +1,24 @@
+import type { ESTree, Visitor } from "@oxlint/plugins";
+type Binding = {
+    readonly identifier: Extract<ESTree.Node, {
+        type: "Identifier";
+    }> | null;
+    readonly owner: ESTree.Node;
+};
+/** A conservative index: an absent name is unbound, and a unique root import
+ * cannot be shadowed. Ambiguous names still use the ordinary scope manager. */
+export declare function createLexicalBindingIndex(): {
+    visitor: Visitor;
+    defer(check: () => void): void;
+    getBindings(name: string): readonly Binding[];
+    hasWrites(name: string): boolean;
+    uniqueVisibleBinding(identifier: ESTree.Node & {
+        type: "Identifier";
+        name: string;
+    }): Binding | null;
+    isUnbound(name: string): boolean;
+    hasImport(name: string, accepts: (specifier: ESTree.ImportSpecifier, declaration: ESTree.ImportDeclaration) => boolean): boolean;
+    isUnshadowedImport(name: string, accepts: (specifier: ESTree.ImportSpecifier, declaration: ESTree.ImportDeclaration) => boolean): boolean;
+};
+export type LexicalBindingIndex = ReturnType<typeof createLexicalBindingIndex>;
+export {};

package/dist/shared/lexical-bindings.js

@@ -0,0 +1,252 @@
+const indexes = new WeakMap();
+function bindingScope(binding) {
+    const { owner, identifier } = binding;
+    if (owner.type === "ImportSpecifier" || owner.type === "ImportDefaultSpecifier" || owner.type === "ImportNamespaceSpecifier") {
+        return owner.parent.type === "ImportDeclaration" && owner.parent.parent.type === "Program" ? owner.parent.parent : null;
+    }
+    if (owner.type === "CatchClause")
+        return owner;
+    if (owner.type === "TSFunctionType" || owner.type === "TSConstructorType" || owner.type === "TSCallSignatureDeclaration" || owner.type === "TSConstructSignatureDeclaration" || owner.type === "TSMethodSignature")
+        return owner;
+    if (owner.type === "ArrowFunctionExpression" || owner.type === "FunctionExpression" || owner.type === "TSEmptyBodyFunctionExpression")
+        return owner;
+    if (owner.type === "FunctionDeclaration" || owner.type === "TSDeclareFunction") {
+        if (identifier !== owner.id)
+            return owner;
+    }
+    else if (owner.type !== "VariableDeclarator")
+        return null;
+    const isVar = owner.type === "VariableDeclarator" && owner.parent.type === "VariableDeclaration" && owner.parent.kind === "var";
+    let current = owner.parent;
+    while (current !== null) {
+        if (current.type === "Program" || current.type === "TSModuleBlock" || current.type === "StaticBlock")
+            return current;
+        if (!isVar && (current.type === "BlockStatement" || current.type === "SwitchStatement" || current.type === "ForStatement" || current.type === "ForInStatement" || current.type === "ForOfStatement"))
+            return current;
+        if (isVar && (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression"))
+            return current.body;
+        current = current.parent;
+    }
+    return null;
+}
+/** A conservative index: an absent name is unbound, and a unique root import
+ * cannot be shadowed. Ambiguous names still use the ordinary scope manager. */
+export function createLexicalBindingIndex() {
+    let index;
+    let pending = [];
+    const addPattern = (node, owner) => {
+        if (node === null)
+            return;
+        if (node.type === "Identifier") {
+            const bindings = index.bindings.get(node.name) ?? [];
+            bindings.push({ identifier: node, owner });
+            index.bindings.set(node.name, bindings);
+        }
+        else if (node.type === "ObjectPattern") {
+            for (const property of node.properties)
+                addPattern(property.type === "RestElement" ? property.argument : property.value, owner);
+        }
+        else if (node.type === "ArrayPattern") {
+            for (const element of node.elements)
+                addPattern(element, owner);
+        }
+        else if (node.type === "AssignmentPattern") {
+            addPattern(node.left, owner);
+        }
+        else if (node.type === "RestElement") {
+            addPattern(node.argument, owner);
+        }
+        else if (node.type === "TSParameterProperty") {
+            addPattern(node.parameter, owner);
+        }
+    };
+    const buildBinding = (node) => {
+        switch (node.type) {
+            case "VariableDeclarator":
+                addPattern(node.id, node);
+                break;
+            case "ArrowFunctionExpression":
+            case "FunctionDeclaration":
+            case "FunctionExpression":
+            case "TSDeclareFunction":
+            case "TSEmptyBodyFunctionExpression":
+                addPattern(node.id, node);
+                for (const parameter of node.params)
+                    addPattern(parameter, node);
+                break;
+            case "ClassDeclaration":
+            case "ClassExpression":
+            case "TSTypeAliasDeclaration":
+            case "TSInterfaceDeclaration":
+            case "TSEnumDeclaration":
+            case "TSModuleDeclaration":
+            case "TSImportEqualsDeclaration":
+                addPattern(node.id, node);
+                break;
+            case "TSFunctionType":
+            case "TSConstructorType":
+            case "TSCallSignatureDeclaration":
+            case "TSConstructSignatureDeclaration":
+            case "TSMethodSignature":
+                for (const parameter of node.params)
+                    addPattern(parameter, node);
+                break;
+            case "CatchClause":
+                addPattern(node.param, node);
+                break;
+            case "ImportSpecifier":
+            case "ImportDefaultSpecifier":
+            case "ImportNamespaceSpecifier":
+                addPattern(node.local, node);
+                break;
+            case "TSTypeParameter":
+                addPattern(node.name, node);
+                break;
+            case "TSEnumMember":
+                if (node.id.type === "Identifier")
+                    addPattern(node.id, node);
+                else {
+                    const name = node.id.type === "Literal" ? node.id.value : node.id.expressions.length === 0 ? node.id.quasis[0]?.value.cooked : null;
+                    if (typeof name === "string") {
+                        const bindings = index.bindings.get(name) ?? [];
+                        bindings.push({ identifier: null, owner: node });
+                        index.bindings.set(name, bindings);
+                    }
+                }
+                break;
+            case "TSMappedType":
+                addPattern(node.key, node);
+                break;
+        }
+    };
+    const collect = (node) => {
+        if (index.collected.has(node))
+            return;
+        index.collected.add(node);
+        index.declarations.push(node);
+    };
+    const initialize = () => {
+        if (index.initialized)
+            return;
+        index.initialized = true;
+        for (const declaration of index.declarations)
+            buildBinding(declaration);
+        index.declarations.length = 0;
+    };
+    const write = (node) => {
+        if (node.type === "Identifier")
+            index.writes.add(node.name);
+        else if (node.type === "ObjectPattern") {
+            for (const property of node.properties)
+                write(property.type === "RestElement" ? property.argument : property.value);
+        }
+        else if (node.type === "ArrayPattern") {
+            for (const element of node.elements)
+                if (element !== null)
+                    write(element);
+        }
+        else if (node.type === "AssignmentPattern")
+            write(node.left);
+        else if (node.type === "RestElement")
+            write(node.argument);
+        else if (node.type === "ParenthesizedExpression" || node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression")
+            write(node.expression);
+    };
+    const collectWrite = (node) => {
+        if (index.collectedWrites.has(node))
+            return;
+        index.collectedWrites.add(node);
+        index.writeTargets.push(node);
+    };
+    const visitor = {
+        Program(program) {
+            pending = [];
+            const cached = indexes.get(program);
+            index = cached ?? { bindings: new Map(), collected: new WeakSet(), writes: new Set(), declarations: [], writeTargets: [], collectedWrites: new WeakSet(), initialized: false, writesInitialized: false };
+            if (cached === undefined)
+                indexes.set(program, index);
+        },
+        "Program:exit"() {
+            for (const check of pending)
+                check();
+            pending = [];
+        },
+        AssignmentExpression(node) { collectWrite(node.left); },
+        UpdateExpression(node) { collectWrite(node.argument); },
+        ForInStatement(node) { if (node.left.type !== "VariableDeclaration")
+            collectWrite(node.left); },
+        ForOfStatement(node) { if (node.left.type !== "VariableDeclaration")
+            collectWrite(node.left); },
+    };
+    for (const event of ["VariableDeclarator", "ArrowFunctionExpression", "FunctionDeclaration", "FunctionExpression", "TSDeclareFunction", "TSEmptyBodyFunctionExpression", "TSFunctionType", "TSConstructorType", "TSCallSignatureDeclaration", "TSConstructSignatureDeclaration", "TSMethodSignature", "ClassDeclaration", "ClassExpression", "TSTypeAliasDeclaration", "TSInterfaceDeclaration", "TSEnumDeclaration", "TSEnumMember", "TSModuleDeclaration", "TSImportEqualsDeclaration", "CatchClause", "ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier", "TSTypeParameter", "TSMappedType"])
+        visitor[event] = collect;
+    return {
+        visitor,
+        defer(check) { pending.push(check); },
+        getBindings(name) { initialize(); return index.bindings.get(name) ?? []; },
+        hasWrites(name) {
+            if (!index.writesInitialized) {
+                index.writesInitialized = true;
+                for (const target of index.writeTargets)
+                    write(target);
+                index.writeTargets.length = 0;
+            }
+            return index.writes.has(name);
+        },
+        uniqueVisibleBinding(identifier) {
+            if (identifier.name === "arguments")
+                return null;
+            initialize();
+            const bindings = index.bindings.get(identifier.name);
+            if (bindings === undefined)
+                return null;
+            const scoped = [];
+            for (const binding of bindings) {
+                const scope = bindingScope(binding);
+                if (scope === null)
+                    return null;
+                scoped.push({ binding, scope });
+            }
+            // A function's parameters and body declarations can share one variable.
+            // Leave these merged-definition cases to the full scope manager.
+            for (const { scope } of scoped) {
+                if ((scope.type === "FunctionDeclaration" || scope.type === "FunctionExpression" || scope.type === "ArrowFunctionExpression") && scoped.some(candidate => candidate.scope === scope.body))
+                    return null;
+            }
+            const distances = new Map();
+            let current = identifier;
+            while (current !== null) {
+                const parent = current.parent;
+                if ((parent?.type === "FunctionDeclaration" || parent?.type === "FunctionExpression" || parent?.type === "ArrowFunctionExpression") && current !== parent.body)
+                    return null;
+                distances.set(current, distances.size);
+                current = parent;
+            }
+            let nearest = null;
+            let nearestDistance = Number.POSITIVE_INFINITY;
+            for (const { binding, scope } of scoped) {
+                const distance = distances.get(scope);
+                if (distance === undefined || distance > nearestDistance)
+                    continue;
+                nearest = distance === nearestDistance ? null : binding;
+                nearestDistance = distance;
+            }
+            return nearest;
+        },
+        isUnbound(name) { initialize(); return name !== "arguments" && !index.bindings.has(name); },
+        hasImport(name, accepts) {
+            initialize();
+            return index.bindings.get(name)?.some(({ owner }) => owner.type === "ImportSpecifier" && owner.parent.type === "ImportDeclaration" && accepts(owner, owner.parent)) ?? false;
+        },
+        isUnshadowedImport(name, accepts) {
+            if (name === "arguments")
+                return false;
+            initialize();
+            const bindings = index.bindings.get(name);
+            if (bindings?.length !== 1)
+                return false;
+            const owner = bindings[0]?.owner;
+            return owner?.type === "ImportSpecifier" && owner.parent.type === "ImportDeclaration" && owner.parent.parent.type === "Program" && accepts(owner, owner.parent);
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-deslop",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.",
   "type": "module",
   "main": "./dist/index.js",