ai-deslop 0.4.3 → 0.4.5

package/README.md

@@ -1,75 +1,100 @@
-# ai-deslop
-
-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.
-
-## Install
-
-```bash
-npm install --save-dev ai-deslop
-# @oxlint/plugins comes along as a runtime dependency — keep it in sync with your oxlint version
-```
-
-Ships compiled JavaScript — works with any oxlint JS-plugin runtime (Bun, Deno, or Node.js).
-
-## Usage
-
-```ts
-import { defineConfig } from "oxlint";
-import { configs as deslopConfigs } from "ai-deslop";
-
-export default defineConfig({
-  jsPlugins: ["ai-deslop"],
-  options: deslopConfigs.recommended.options,
-  rules: deslopConfigs.recommended.rules
-});
-```
-
-The recommended config enables type-aware linting for `typescript/no-deprecated` and `typescript/no-floating-promises`. Install `oxlint-tsgolint` when using it.
-
-## Rules
-
-| 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-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-module-mocking` | Recommended | Rejects Vitest and Jest module mocks. |
-| `no-object-parameters` | Recommended | Rejects `object` on function inputs. |
-| `no-reflect-apply` | Recommended | Rejects global `Reflect.apply`. |
-| `no-reflect-get` | Recommended | Rejects global `Reflect.get`. |
-| `no-runtime-typeof` | Recommended | Requires boundary parsing instead of ad hoc `typeof` narrowing. |
-| `no-shape-in-symbol-names` | Recommended | Rejects `shape` in locally owned symbol names. |
-| `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-call-only-assertions` | Recommended | Flags tests whose assertions only check mock calls. |
-| `no-pass-through-type-alias` | Recommended | Disallows aliases that only rename another type. |
+# ai-deslop
+
+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.
+
+## Install
+
+```bash
+npm install --save-dev ai-deslop
+# @oxlint/plugins comes along as a runtime dependency — keep it in sync with your oxlint version
+```
+
+Ships compiled JavaScript — works with any oxlint JS-plugin runtime (Bun, Deno, or Node.js).
+
+## Usage
+
+```ts
+import { defineConfig } from "oxlint";
+import { configs as deslopConfigs } from "ai-deslop";
+
+export default defineConfig({
+  jsPlugins: ["ai-deslop"],
+  options: deslopConfigs.recommended.options,
+  rules: deslopConfigs.recommended.rules
+});
+```
+
+## 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. |
+
+### 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. |
+
+### 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. |
+
+### 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. |
-
-| Standard rule | Status | Description |
-| --- | --- | --- |
-| `typescript/no-deprecated` | Recommended | Disallows using code marked `@deprecated`. Requires type-aware linting. |
-| `typescript/no-floating-promises` | Recommended | Disallows floating promises. Requires type-aware linting. |
-
-## Guides
-
-| Guide | Contents |
-| --- | --- |
+
+### 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. |
-| [Tailwind canonical class names](docs/tailwind.md) | Tailwind v4 setup, complete TypeScript/JSON examples, and every supported option. |
-
-## Credits
-
-- Generic rules vendored verbatim from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (MIT, © Dillon Mulroy), including `src/shared/*`.
-
-## License
-
-MIT
+| [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. |
+
+## Credits
+
+- Generic rules vendored verbatim from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (MIT, © Dillon Mulroy), including `src/shared/*`.
+
+## License
+
+MIT

package/dist/index.js

@@ -17,8 +17,11 @@ import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.js
 import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.js";
 import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.js";
 import { noCallOnlyAssertionsRule } from "./rules/no-call-only-assertions.js";
+import { noPoorSubstringTestsRule } from "./rules/no-poor-substring-tests.js";
 import { noPassThroughTypeAliasRule } from "./rules/no-pass-through-type-alias.js";
 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 { 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 = {
@@ -40,9 +43,13 @@ export const recommendedRules = {
     "deslop/no-widen-then-assert": "error",
     "deslop/require-safety-comment-for-type-assertion": "error",
     "deslop/no-call-only-assertions": "error",
+    "deslop/no-poor-substring-tests": "error",
     "deslop/no-pass-through-type-alias": "error",
     "typescript/no-deprecated": "error",
+    "typescript/no-require-imports": "error",
     "typescript/no-floating-promises": "error",
+    "typescript/no-unnecessary-condition": "error",
+    "no-unreachable": "error",
 };
 /** ESLint flat-config style configs. `recommended` enables every recommended `deslop/*` rule as `"error"` (excluding opt-in rules), plus standard `typescript/*` rules. The `typescript/*` rules require type-aware linting (`options.typeAware`), so `recommended` sets it. */
 export const configs = {
@@ -74,8 +81,12 @@ const deslopPlugin = eslintCompatPlugin({
         "no-widen-then-assert": noWidenThenAssertRule,
         "require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
         "no-call-only-assertions": noCallOnlyAssertionsRule,
+        "no-poor-substring-tests": noPoorSubstringTestsRule,
+        "no-constant-substring-tests": noPoorSubstringTestsRule,
         "no-pass-through-type-alias": noPassThroughTypeAliasRule,
         "no-duplicate-types": noDuplicateTypesRule,
+        "no-duplicate-consts": noDuplicateConstsRule,
+        "no-renamed-imports": noRenamedImportsRule,
         // Opt-in: NOT in `recommendedRules`. Requires a `cssPath` option, so users add it manually.
         "canonical-class-names": canonicalClassNames,
     },

package/dist/rules/no-duplicate-consts.d.ts

@@ -0,0 +1,2 @@
+/** Report static all-caps constants duplicated by name and value in another file. */
+export declare const noDuplicateConstsRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-duplicate-consts.js

@@ -0,0 +1,68 @@
+import { defineRule } from "@oxlint/plugins";
+function staticValue(node) {
+    if (node.type === "Literal") {
+        return JSON.stringify(["literal", typeof node.value, String(node.value)]);
+    }
+    if (node.type === "TemplateLiteral") {
+        return node.expressions.length === 0 ? JSON.stringify(["literal", "string", node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? ""]) : null;
+    }
+    if (node.type === "UnaryExpression" && (node.operator === "+" || node.operator === "-") && node.argument.type === "Literal" && typeof node.argument.value === "number") {
+        return JSON.stringify(["literal", "number", `${node.operator}${node.argument.value}`]);
+    }
+    if (node.type === "ArrayExpression") {
+        const values = node.elements.map((element) => element === null || element.type === "SpreadElement" ? null : staticValue(element));
+        return values.some((value) => value === null) ? null : JSON.stringify(["array", values]);
+    }
+    if (node.type === "ObjectExpression") {
+        const properties = [];
+        for (const property of node.properties) {
+            if (property.type !== "Property" || property.computed || property.method || property.kind !== "init" || property.key.type !== "Identifier" && property.key.type !== "Literal")
+                return null;
+            const value = staticValue(property.value);
+            if (value === null)
+                return null;
+            const key = property.key.type === "Identifier" ? property.key.name : String(property.key.value);
+            properties.push([key, value]);
+        }
+        return JSON.stringify(["object", properties]);
+    }
+    return null;
+}
+/** Report static all-caps constants duplicated by name and value in another file. */
+export const noDuplicateConstsRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Report all-caps constants duplicated by name and static value across files" },
+        messages: { duplicate: "{{name}} duplicates the constant in {{firstFile}}." },
+        schema: [],
+    },
+    createOnce(context) {
+        const seen = new Map();
+        return {
+            Program() {
+                // LSPs can re-lint a file in the same worker; discard stale entries first.
+                for (const [key, constant] of seen)
+                    if (constant.filename === context.filename)
+                        seen.delete(key);
+            },
+            VariableDeclaration(node) {
+                if (node.kind !== "const")
+                    return;
+                for (const declaration of node.declarations) {
+                    if (declaration.id.type !== "Identifier" || !/^[A-Z][A-Z0-9_]*$/.test(declaration.id.name) || declaration.init === null)
+                        continue;
+                    const value = staticValue(declaration.init);
+                    if (value === null)
+                        continue;
+                    const key = `${declaration.id.name}:${value}`, first = seen.get(key);
+                    if (first === undefined) {
+                        seen.set(key, { filename: context.filename, name: declaration.id.name });
+                    }
+                    else if (first.filename !== context.filename) {
+                        context.report({ node: declaration, messageId: "duplicate", data: { name: declaration.id.name, firstFile: first.filename } });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-duplicate-types.js

@@ -106,6 +106,10 @@ export const noDuplicateTypesRule = defineRule({
         };
         return {
             Program() {
+                // LSPs can re-lint a file in the same createOnce worker; discard its stale declarations first.
+                for (const [key, type] of seen)
+                    if (type.filename === context.filename)
+                        seen.delete(key);
                 options = context.options[0] ?? {};
                 zodNamespaces.clear();
                 valibotNamespaces.clear();

package/dist/rules/no-poor-substring-tests.d.ts

@@ -0,0 +1,2 @@
+/** Disallow testing that a constant string contains substrings. */
+export declare const noPoorSubstringTestsRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-poor-substring-tests.js

@@ -0,0 +1,320 @@
+import fs from "node:fs";
+import path from "node:path";
+import { defineRule } from "@oxlint/plugins";
+import { resolveVariable } from "../shared/scope.js";
+const SUBSTRING_MATCHERS = new Set([
+    "toContain",
+    "toInclude",
+    "toMatch",
+    "include",
+    "contain",
+    "string",
+    "match",
+]);
+const CHAIN_MODIFIERS = new Set([
+    "not",
+    "resolves",
+    "rejects",
+    "to",
+    "be",
+    "have",
+    "that",
+    "which",
+    "and",
+    "is",
+    "deep",
+    "nested",
+    "own",
+]);
+const SUBSTRING_METHODS = new Set([
+    "includes",
+    "startsWith",
+    "endsWith",
+    "indexOf",
+    "search",
+    "match",
+]);
+const ASSERT_MATCHERS = new Set([
+    "include",
+    "includes",
+    "notInclude",
+    "notIncludes",
+    "match",
+    "notMatch",
+]);
+const fileContentCache = new Map();
+function isTestFile(filename) {
+    if (!filename)
+        return false;
+    return /(?:^|[/\\])(?:__tests__|tests?)(?:[/\\]|$)|(?:[._](?:test|spec))\.[cm]?[jt]sx?$/i.test(filename);
+}
+function rootIdentifierName(node) {
+    let current = node;
+    while (true) {
+        if (current.type === "Identifier")
+            return current.name;
+        if (current.type === "MemberExpression") {
+            current = current.object;
+        }
+        else if (current.type === "CallExpression" || current.type === "TaggedTemplateExpression") {
+            current = current.type === "CallExpression" ? current.callee : current.tag;
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+function unwrapExpression(expression) {
+    let current = expression;
+    while (true) {
+        if (current.type === "ParenthesizedExpression" ||
+            current.type === "TSAsExpression" ||
+            current.type === "TSTypeAssertion" ||
+            current.type === "TSNonNullExpression" ||
+            current.type === "TSSatisfiesExpression") {
+            current = current.expression;
+        }
+        else {
+            break;
+        }
+    }
+    return current;
+}
+function isStableConstVariable(variable, declarator) {
+    if (declarator.parent.type !== "VariableDeclaration")
+        return false;
+    if (declarator.parent.kind === "const")
+        return true;
+    return variable.references.every((ref) => ref.init || !ref.isWrite());
+}
+function isImportedConstantString(variable, currentFilename) {
+    if (!currentFilename || !path.isAbsolute(currentFilename))
+        return false;
+    const definition = variable.defs[0];
+    if (definition?.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") {
+        return false;
+    }
+    const source = definition.parent.source.value;
+    if (typeof source !== "string" || !source.startsWith(".")) {
+        return false;
+    }
+    const dir = path.dirname(currentFilename);
+    const candidates = [
+        path.resolve(dir, source),
+        path.resolve(dir, `${source}.ts`),
+        path.resolve(dir, `${source}.tsx`),
+        path.resolve(dir, `${source}.js`),
+        path.resolve(dir, `${source}.mjs`),
+        path.resolve(dir, source, "index.ts"),
+        path.resolve(dir, source, "index.js"),
+    ];
+    for (const candidate of candidates) {
+        try {
+            let content = fileContentCache.get(candidate);
+            if (content === undefined) {
+                if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile()) {
+                    continue;
+                }
+                content = fs.readFileSync(candidate, "utf8");
+                fileContentCache.set(candidate, content);
+            }
+            const importedName = definition.node.type === "ImportSpecifier"
+                ? definition.node.imported.type === "Identifier"
+                    ? definition.node.imported.name
+                    : definition.node.imported.value
+                : definition.node.type === "ImportDefaultSpecifier"
+                    ? "default"
+                    : null;
+            if (!importedName)
+                continue;
+            const pattern = new RegExp(`export\\s+const\\s+${importedName}\\s*=\\s*(["'\`])`);
+            if (pattern.test(content)) {
+                return true;
+            }
+        }
+        catch {
+            // ignore file read errors
+        }
+    }
+    return false;
+}
+function isConstantString(expression, sourceCode, currentFilename, visited = new Set()) {
+    const current = unwrapExpression(expression);
+    if (current.type === "Literal" && typeof current.value === "string") {
+        return true;
+    }
+    if (current.type === "TemplateLiteral") {
+        if (current.expressions.length === 0) {
+            return true;
+        }
+        return current.expressions.every((expr) => isConstantString(expr, sourceCode, currentFilename, visited));
+    }
+    if (current.type === "BinaryExpression" && current.operator === "+") {
+        return (isConstantString(current.left, sourceCode, currentFilename, visited) &&
+            isConstantString(current.right, sourceCode, currentFilename, visited));
+    }
+    if (current.type === "CallExpression" &&
+        current.callee.type === "Identifier" &&
+        current.callee.name === "String" &&
+        current.arguments.length === 1 &&
+        current.arguments[0]?.type !== "SpreadElement") {
+        return isConstantString(current.arguments[0], sourceCode, currentFilename, visited);
+    }
+    if (current.type === "Identifier") {
+        const variable = resolveVariable(sourceCode, current);
+        if (variable === null || visited.has(variable)) {
+            return false;
+        }
+        if (variable.defs.length === 1) {
+            const [def] = variable.defs;
+            if (def?.type === "Variable" &&
+                def.node.type === "VariableDeclarator" &&
+                def.node.init !== null) {
+                if (isStableConstVariable(variable, def.node)) {
+                    visited.add(variable);
+                    return isConstantString(def.node.init, sourceCode, currentFilename, visited);
+                }
+            }
+            if (def?.type === "ImportBinding") {
+                return isImportedConstantString(variable, currentFilename);
+            }
+        }
+    }
+    return false;
+}
+function extractExpectSubject(callee) {
+    let object = callee.object;
+    while (object.type === "MemberExpression" &&
+        !object.computed &&
+        object.property.type === "Identifier" &&
+        CHAIN_MODIFIERS.has(object.property.name)) {
+        object = object.object;
+    }
+    if (object.type === "CallExpression" &&
+        rootIdentifierName(object.callee) === "expect" &&
+        object.arguments.length > 0 &&
+        object.arguments[0]?.type !== "SpreadElement") {
+        return object.arguments[0];
+    }
+    return null;
+}
+function extractSubstringCallSubject(node) {
+    const unwrapped = unwrapExpression(node);
+    if (unwrapped.type === "CallExpression" &&
+        unwrapped.callee.type === "MemberExpression" &&
+        !unwrapped.callee.computed &&
+        unwrapped.callee.property.type === "Identifier") {
+        const method = unwrapped.callee.property.name;
+        if (SUBSTRING_METHODS.has(method)) {
+            return unwrapped.callee.object;
+        }
+        if (method === "test" && unwrapped.arguments.length > 0 && unwrapped.arguments[0]?.type !== "SpreadElement") {
+            return unwrapped.arguments[0];
+        }
+    }
+    if (unwrapped.type === "BinaryExpression") {
+        if (unwrapped.left.type !== "PrivateIdentifier") {
+            const leftSubject = extractSubstringCallSubject(unwrapped.left);
+            if (leftSubject)
+                return leftSubject;
+        }
+        const rightSubject = extractSubstringCallSubject(unwrapped.right);
+        if (rightSubject)
+            return rightSubject;
+    }
+    return null;
+}
+function isExpectStringContaining(node) {
+    const unwrapped = unwrapExpression(node);
+    if (unwrapped.type === "CallExpression" &&
+        unwrapped.callee.type === "MemberExpression" &&
+        !unwrapped.callee.computed &&
+        unwrapped.callee.property.type === "Identifier" &&
+        unwrapped.callee.property.name === "stringContaining" &&
+        rootIdentifierName(unwrapped.callee.object) === "expect") {
+        return true;
+    }
+    return false;
+}
+/** Disallow testing that a constant string contains substrings. */
+export const noPoorSubstringTestsRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Disallow testing that a constant string contains substrings; tests must assert on dynamic behavior or verify full contracts.",
+        },
+        messages: {
+            poorSubstringTest: "Testing that a constant string contains a substring provides little signal. Assert against dynamic behavior, or verify the complete contract with an exact match or snapshot instead.",
+        },
+        schema: [],
+    },
+    createOnce(context) {
+        let shouldCheck = false;
+        return {
+            Program() {
+                shouldCheck = isTestFile(context.filename);
+            },
+            CallExpression(node) {
+                if (!shouldCheck)
+                    return;
+                // Pattern 1: expect(subject).toContain(sub), expect(subject).toMatch(regex), etc.
+                if (node.callee.type === "MemberExpression" &&
+                    !node.callee.computed &&
+                    node.callee.property.type === "Identifier") {
+                    const propertyName = node.callee.property.name;
+                    if (SUBSTRING_MATCHERS.has(propertyName)) {
+                        const subject = extractExpectSubject(node.callee);
+                        if (subject && isConstantString(subject, context.sourceCode, context.filename)) {
+                            context.report({ node, messageId: "poorSubstringTest" });
+                            return;
+                        }
+                    }
+                    // Pattern 1b: expect(subject).toEqual(expect.stringContaining(sub))
+                    if (node.arguments.length > 0 &&
+                        node.arguments[0] !== undefined &&
+                        node.arguments[0].type !== "SpreadElement" &&
+                        isExpectStringContaining(node.arguments[0])) {
+                        const subject = extractExpectSubject(node.callee);
+                        if (subject && isConstantString(subject, context.sourceCode, context.filename)) {
+                            context.report({ node, messageId: "poorSubstringTest" });
+                            return;
+                        }
+                    }
+                }
+                // Pattern 2: expect(subject.includes("sub")), expect(subject.startsWith("sub")), expect(/regex/.test(subject)), etc.
+                if (rootIdentifierName(node.callee) === "expect" && node.arguments.length > 0) {
+                    const firstArg = node.arguments[0];
+                    if (firstArg && firstArg.type !== "SpreadElement") {
+                        const subject = extractSubstringCallSubject(firstArg);
+                        if (subject && isConstantString(subject, context.sourceCode, context.filename)) {
+                            context.report({ node, messageId: "poorSubstringTest" });
+                            return;
+                        }
+                    }
+                }
+                // Pattern 3: assert(subject.includes("sub")), assert.ok(subject.includes("sub")), assert.isTrue(subject.includes("sub"))
+                if (rootIdentifierName(node.callee) === "assert" &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0] !== undefined &&
+                    node.arguments[0].type !== "SpreadElement") {
+                    const firstArg = node.arguments[0];
+                    // 3a: assert.include(subject, "sub"), assert.match(subject, /regex/)
+                    if (node.callee.type === "MemberExpression" &&
+                        !node.callee.computed &&
+                        node.callee.property.type === "Identifier" &&
+                        ASSERT_MATCHERS.has(node.callee.property.name)) {
+                        if (isConstantString(firstArg, context.sourceCode, context.filename)) {
+                            context.report({ node, messageId: "poorSubstringTest" });
+                            return;
+                        }
+                    }
+                    // 3b: assert(subject.includes("sub")), assert.ok(subject.includes("sub"))
+                    const subject = extractSubstringCallSubject(firstArg);
+                    if (subject && isConstantString(subject, context.sourceCode, context.filename)) {
+                        context.report({ node, messageId: "poorSubstringTest" });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-renamed-imports.d.ts

@@ -0,0 +1,2 @@
+/** Disallow named import aliases when the imported name is available in module scope. */
+export declare const noRenamedImportsRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-renamed-imports.js

@@ -0,0 +1,53 @@
+import { defineRule } from "@oxlint/plugins";
+function moduleScopeFor(scope) {
+    let current = scope;
+    while (current !== null) {
+        if (current.type === "module")
+            return current;
+        current = current.upper;
+    }
+    return null;
+}
+function importedName(node) {
+    return node.imported.type === "Identifier" ? node.imported.name : null;
+}
+/** Disallow named import aliases when the imported name is available in module scope. */
+export const noRenamedImportsRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Disallow unnecessary aliases for named imports" },
+        fixable: "code",
+        messages: {
+            unnecessaryAlias: "Use {{importedName}} directly instead of renaming this import to {{localName}}.",
+        },
+        schema: [],
+    },
+    createOnce(context) {
+        return {
+            ImportSpecifier(node) {
+                const name = importedName(node);
+                if (name === null || name === node.local.name)
+                    return;
+                const moduleScope = moduleScopeFor(context.sourceCode.getScope(node));
+                if (moduleScope === null || moduleScope.set.has(name))
+                    return;
+                const variable = moduleScope.set.get(node.local.name);
+                if (variable === undefined)
+                    return;
+                context.report({
+                    node,
+                    messageId: "unnecessaryAlias",
+                    data: { importedName: name, localName: node.local.name },
+                    fix(fixer) {
+                        return [
+                            fixer.replaceText(node, name),
+                            ...variable.references
+                                .filter((reference) => reference.resolved === variable)
+                                .map((reference) => fixer.replaceText(reference.identifier, name)),
+                        ];
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/tailwind/design-system.d.ts

@@ -1,3 +1,4 @@
 export declare function resolveCssPath(cssPath: string | undefined, cwd?: string): string;
 export declare function ensureDesignSystem(cssFile: string): string;
+export declare function getDesignSystemVersion(key: string): number | undefined;
 export declare function canonicalizeTokens(key: string, tokens: Array<string>, rem: number): Map<string, string>;

package/dist/tailwind/design-system.js

@@ -8,6 +8,7 @@ import { createSyncFn } from "synckit";
 const workerPath = fileURLToPath(new URL("./worker.js", import.meta.url));
 let syncCall = null;
 const loadedSystems = new Map();
+const canonicalResults = new Map();
 function getSyncCall() {
     if (syncCall === null) {
         syncCall = createSyncFn(workerPath);
@@ -26,16 +27,31 @@ export function ensureDesignSystem(cssFile) {
     const cssContent = fs.readFileSync(cssFile, "utf8");
     getSyncCall()({ type: "load", key: cssFile, cssContent, base: path.dirname(cssFile) });
     loadedSystems.set(cssFile, stat.mtimeMs);
+    canonicalResults.delete(cssFile);
     return cssFile;
 }
+export function getDesignSystemVersion(key) {
+    return loadedSystems.get(key);
+}
 export function canonicalizeTokens(key, tokens, rem) {
     if (tokens.length === 0)
         return new Map();
-    const canonical = getSyncCall()({ type: "canonicalize", key, candidates: tokens, rem });
-    if (!Array.isArray(canonical))
-        throw new Error("Tailwind canonicalization returned an invalid result");
+    let byRem = canonicalResults.get(key);
+    if (!byRem)
+        canonicalResults.set(key, byRem = new Map());
+    let cached = byRem.get(rem);
+    if (!cached)
+        byRem.set(rem, cached = new Map());
+    const missing = [...new Set(tokens.filter(token => !cached.has(token)))];
+    if (missing.length > 0) {
+        const canonical = getSyncCall()({ type: "canonicalize", key, candidates: missing, rem });
+        if (!Array.isArray(canonical))
+            throw new Error("Tailwind canonicalization returned an invalid result");
+        for (let i = 0; i < missing.length; i++)
+            cached.set(missing[i], canonical[i] ?? missing[i]);
+    }
     const result = new Map();
-    for (let i = 0; i < tokens.length; i++)
-        result.set(tokens[i], canonical[i] ?? tokens[i]);
+    for (const token of tokens)
+        result.set(token, cached.get(token));
     return result;
 }

package/dist/tailwind/optimize-system.d.ts

@@ -0,0 +1,4 @@
+import type { __unstable__loadDesignSystem } from "@tailwindcss/node";
+type DesignSystem = Awaited<ReturnType<typeof __unstable__loadDesignSystem>>;
+export declare function optimizeDesignSystem(system: DesignSystem): DesignSystem;
+export {};

package/dist/tailwind/optimize-system.js

@@ -0,0 +1,127 @@
+function propertyKey(system, candidates, raw = false) {
+    const properties = new Set();
+    function visit(node) {
+        if (node.kind === "at-rule" && node.name === "@property")
+            return;
+        if (node.kind === "declaration" && node.value !== undefined && !node.property.startsWith("--tw-"))
+            properties.add(node.property);
+        if ("nodes" in node)
+            for (const child of node.nodes)
+                visit(child);
+    }
+    for (const candidate of candidates) {
+        if (!raw || candidate.kind === "arbitrary") {
+            for (const { node } of system.compileAstNodes({ ...candidate, variants: [], important: false }))
+                visit(node);
+            continue;
+        }
+        // Property discovery needs utility declarations, not selector generation,
+        // importance propagation, or Tailwind's expensive declaration sort order.
+        const utilities = system.utilities.get(candidate.root) ?? [];
+        const isFallback = (utility) => (utility.options?.types?.length ?? 0) > 1 && utility.options.types.includes("any");
+        for (const fallback of [false, true]) {
+            let accepted = false;
+            for (const utility of utilities) {
+                if (utility.kind !== candidate.kind || isFallback(utility) !== fallback)
+                    continue;
+                const nodes = utility.compileFn(candidate);
+                if (nodes === null && utility.options?.types?.length) {
+                    accepted = true;
+                    break;
+                }
+                if (nodes === null || nodes === undefined)
+                    continue;
+                accepted = true;
+                for (const node of nodes)
+                    visit(node);
+            }
+            if (accepted)
+                break;
+        }
+    }
+    return [...properties].sort().join("\0");
+}
+// Canonicalization only compares equivalent declaration sets. Partition its
+// eager class index without changing the compiler, theme, or candidate parser.
+export function optimizeDesignSystem(system) {
+    const parseVariant = system.parseVariant.bind(system);
+    const getVariantOrder = system.getVariantOrder.bind(system);
+    const seenVariants = new Set();
+    let variantVersion = 0;
+    let orderVersion = -1;
+    let order;
+    system.parseVariant = raw => {
+        const variant = parseVariant(raw);
+        if (variant !== null && !seenVariants.has(variant)) {
+            seenVariants.add(variant);
+            variantVersion++;
+        }
+        return variant;
+    };
+    system.getVariantOrder = () => {
+        if (orderVersion !== variantVersion) {
+            order = getVariantOrder();
+            for (const variant of order.keys())
+                seenVariants.add(variant);
+            orderVersion = variantVersion;
+        }
+        return order;
+    };
+    let groups;
+    const scopedSystems = new Map();
+    function getGroups() {
+        if (groups)
+            return groups;
+        const built = new Map();
+        for (const entry of system.getClassList()) {
+            // Match Tailwind's index: quarter-step numeric modifiers use its
+            // on-demand fallback rather than the enumerated class signatures.
+            const modifiers = entry[1].modifiers.filter((modifier) => {
+                const number = Number(modifier);
+                return !(number >= 0 && number % 0.25 === 0 && String(number) === modifier);
+            });
+            const spellings = [entry[0], ...modifiers.map((modifier) => `${entry[0]}/${modifier}`)];
+            for (const spelling of spellings) {
+                let key;
+                const token = system.theme.prefix ? `${system.theme.prefix}:${spelling}` : spelling;
+                try {
+                    key = propertyKey(system, system.parseCandidate(token), true);
+                }
+                catch {
+                    continue;
+                }
+                let group = built.get(key);
+                if (!group)
+                    built.set(key, group = new Set());
+                group.add(entry);
+            }
+        }
+        return groups = built;
+    }
+    return {
+        ...system,
+        canonicalizeCandidates(tokens, options) {
+            return tokens.map(token => {
+                const candidates = system.parseCandidate(token);
+                if (candidates.every(candidate => candidate.kind === "static"))
+                    return system.canonicalizeCandidates([token], options)[0] ?? token;
+                const keys = new Set([propertyKey(system, candidates)]);
+                const withoutModifiers = candidates.map(candidate => candidate.kind === "static" ? candidate : { ...candidate, modifier: null });
+                keys.add(propertyKey(system, withoutModifiers));
+                const scopeKey = [...keys].sort().join("\x01");
+                let scoped = scopedSystems.get(scopeKey);
+                if (!scoped) {
+                    const entries = new Set();
+                    const index = getGroups();
+                    for (const key of keys)
+                        for (const entry of index.get(key) ?? [])
+                            entries.add(entry);
+                    const list = [...entries];
+                    scoped = { ...system, storage: {}, getClassList: () => list };
+                    scopedSystems.set(scopeKey, scoped);
+                }
+                return scoped.canonicalizeCandidates([token], options)[0] ?? token;
+            });
+        },
+    };
+}

package/dist/tailwind/rule.js

@@ -1,11 +1,12 @@
 import { defineRule } from "@oxlint/plugins";
 import { rewriteClassValue, summarizeChanges, uniqueTokens } from "./candidates.js";
-import { canonicalizeTokens, ensureDesignSystem, resolveCssPath } from "./design-system.js";
+import { canonicalizeTokens, ensureDesignSystem, getDesignSystemVersion, resolveCssPath } from "./design-system.js";
 export const PLUGIN_NAME = "deslop";
 export const RULE_ID = "canonical-class-names";
 const DEFAULT_ATTRIBUTES = ["class", "className"];
 const DEFAULT_CALLEE_FUNCTIONS = ["cn", "clsx", "cva", "twMerge", "tw", "classNames", "cx"];
 const DEFAULT_ROOT_FONT_SIZE = 16;
+const MAX_CACHED_VALUES = 10_000;
 const OPTIONS_SCHEMA = {
     type: "object",
     properties: {
@@ -34,7 +35,11 @@ export const canonicalClassNames = defineRule({
         let rem = DEFAULT_ROOT_FONT_SIZE;
         let cssFile = "";
         let designKey = null;
+        const checkedValues = new Map();
+        let checkedVersion;
         function initFile() {
+            const previousRem = rem;
+            const previousCssFile = cssFile;
             const options = (context.options?.[0] ?? {});
             attributes = new Set(options.attributes ?? DEFAULT_ATTRIBUTES);
             callees = new Set(options.calleeFunctions ?? DEFAULT_CALLEE_FUNCTIONS);
@@ -46,11 +51,18 @@ export const canonicalClassNames = defineRule({
                 cssFile = options.cssPath ?? "";
             }
             designKey = null;
+            if (previousRem !== rem || previousCssFile !== cssFile)
+                checkedValues.clear();
         }
         function getDesignKey() {
             if (designKey === null) {
                 try {
                     designKey = ensureDesignSystem(cssFile);
+                    const version = getDesignSystemVersion(designKey);
+                    if (checkedVersion !== version) {
+                        checkedValues.clear();
+                        checkedVersion = version;
+                    }
                 }
                 catch {
                     designKey = false;
@@ -59,22 +71,29 @@ export const canonicalClassNames = defineRule({
             return designKey === false ? null : designKey;
         }
         function checkStringNode(node, value) {
-            const tokens = uniqueTokens(value);
-            if (tokens.length === 0)
+            if (!/\S/.test(value))
                 return;
             const key = getDesignKey();
             if (key === null) {
                 context.report({ node, messageId: "cssNotFound", data: { path: cssFile } });
                 return;
             }
-            let canonicalOf;
-            try {
-                canonicalOf = canonicalizeTokens(key, tokens, rem);
-            }
-            catch {
-                return;
+            let rewritten = checkedValues.get(value);
+            if (!rewritten) {
+                const tokens = uniqueTokens(value);
+                let canonicalOf;
+                try {
+                    canonicalOf = canonicalizeTokens(key, tokens, rem);
+                }
+                catch {
+                    return;
+                }
+                rewritten = rewriteClassValue(value, canonicalOf);
+                if (checkedValues.size >= MAX_CACHED_VALUES)
+                    checkedValues.clear();
+                checkedValues.set(value, rewritten);
             }
-            const { fixed, changes } = rewriteClassValue(value, canonicalOf);
+            const { fixed, changes } = rewritten;
             if (changes.length === 0)
                 return;
             const summary = summarizeChanges(changes);

package/dist/tailwind/worker.js

@@ -1,13 +1,15 @@
 import { __unstable__loadDesignSystem } from "@tailwindcss/node";
 import { runAsWorker } from "synckit";
+import { optimizeDesignSystem } from "./optimize-system.js";
 const designSystems = new Map();
 runAsWorker(async (job) => {
     if (job.type === "load") {
-        designSystems.set(job.key, await __unstable__loadDesignSystem(job.cssContent, { base: job.base }));
+        designSystems.set(job.key, optimizeDesignSystem(await __unstable__loadDesignSystem(job.cssContent, { base: job.base })));
         return { ok: true };
     }
     const designSystem = designSystems.get(job.key);
     if (!designSystem)
         throw new Error(`Tailwind design system not loaded for "${job.key}"`);
-    return designSystem.canonicalizeCandidates(job.candidates, { rem: job.rem });
+    // Tailwind deduplicates canonical spellings, so a batch result is not positional.
+    return job.candidates.map(candidate => designSystem.canonicalizeCandidates([candidate], { rem: job.rem })[0] ?? candidate);
 });

package/package.json

@@ -1,64 +1,65 @@
-{
-  "name": "ai-deslop",
-  "version": "0.4.3",
-  "description": "Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
+{
+  "name": "ai-deslop",
+  "version": "0.4.5",
+  "description": "Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "prepublishOnly": "npm run build",
-    "check": "npm run build && oxlint src && tsc --noEmit",
-    "lint": "oxlint src",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@oxlint/plugins": "1.82.0",
-    "@tailwindcss/node": "^4.3.3",
-    "synckit": "^0.11.13"
-  },
-  "peerDependencies": {
-    "tailwindcss": "^4.0.0"
-  },
-  "peerDependenciesMeta": {
-    "tailwindcss": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@types/node": "26.2.0",
-    "oxlint": "1.82.0",
-    "typescript": "7.0.2",
-    "vitest": "^5.0.1"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/maharshi365/deslop.git"
-  },
-  "homepage": "https://github.com/maharshi365/deslop#readme",
-  "bugs": {
-    "url": "https://github.com/maharshi365/deslop/issues"
-  },
-  "keywords": [
-    "oxlint",
-    "oxlint-plugin",
-    "eslint",
-    "ai-slop",
-    "code-quality",
-    "typescript"
-  ],
-  "publishConfig": {
-    "access": "public"
-  }
-}
+    "bench": "npm run build && node bench.mjs",
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
+    "check": "npm run build && oxlint src && tsc --noEmit",
+    "lint": "oxlint src",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@oxlint/plugins": "1.82.0",
+    "@tailwindcss/node": "^4.3.3",
+    "synckit": "^0.11.13"
+  },
+  "peerDependencies": {
+    "tailwindcss": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "tailwindcss": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "26.2.0",
+    "oxlint": "1.82.0",
+    "typescript": "7.0.2",
+    "vitest": "^5.0.1"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maharshi365/deslop.git"
+  },
+  "homepage": "https://github.com/maharshi365/deslop#readme",
+  "bugs": {
+    "url": "https://github.com/maharshi365/deslop/issues"
+  },
+  "keywords": [
+    "oxlint",
+    "oxlint-plugin",
+    "eslint",
+    "ai-slop",
+    "code-quality",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}