ai-deslop 0.5.2 → 0.6.0

package/dist/index.js

@@ -58,6 +58,7 @@ export const recommendedRules = {
     "typescript/await-thenable": "error",
     "typescript/no-unnecessary-condition": "error",
     "typescript/switch-exhaustiveness-check": "error",
+    "typescript/no-inferrable-types": "error",
     "no-unreachable": "error",
     "deslop/no-restricted-syntax": [
         "error",

package/dist/rules/max-boolean-conditions.js

@@ -1,4 +1,18 @@
 import { defineRule } from "@oxlint/plugins";
+function countRawTerms(node) {
+    const pending = [node];
+    let count = 0;
+    while (pending.length > 0) {
+        const term = pending.pop();
+        if (term.type === "LogicalExpression" && term.operator !== "??") {
+            pending.push(term.left, term.right);
+        }
+        else {
+            count++;
+        }
+    }
+    return count;
+}
 /** Limit top-level Boolean terms in control-flow conditions. */
 export const maxBooleanConditionsRule = defineRule({
     meta: {
@@ -21,6 +35,10 @@ export const maxBooleanConditionsRule = defineRule({
         function checkCondition(node) {
             if (node.test === null)
                 return;
+            // Grouping can only merge terms, so skip token reads when the ungrouped count fits.
+            const max = options.maxConditions ?? 3;
+            if (countRawTerms(node.test) <= max)
+                return;
             const pending = [node.test];
             let count = 0;
             while (pending.length > 0) {
@@ -35,7 +53,6 @@ export const maxBooleanConditionsRule = defineRule({
                     count++;
                 }
             }
-            const max = options.maxConditions ?? 3;
             if (count <= max)
                 return;
             if (options.message !== undefined) {

package/dist/rules/no-call-only-assertions.js

@@ -1,7 +1,13 @@
 import { defineRule } from "@oxlint/plugins";
 // Tests whose every assertion is a "was it called" mock check verify orchestration, not behavior.
 // `toHaveBeenCalledWith` is allowed because it asserts on real data.
-const CALL_ONLY_MATCHERS = new Set(["toHaveBeenCalled", "toHaveBeenCalledTimes", "toHaveBeenCalledOnce"]);
+const CALL_ONLY_MATCHERS = new Set([
+    "toHaveBeenCalled",
+    "toHaveBeenCalledTimes",
+    "toHaveBeenCalledOnce",
+    "toBeCalled",
+    "toBeCalledTimes",
+]);
 const TEST_NAMES = new Set(["it", "test"]);
 const MODIFIERS = new Set(["not", "resolves", "rejects"]);
 function rootIdentifierName(node) {
@@ -42,6 +48,14 @@ function matcherName(node) {
     const isExpectCall = object.type === "CallExpression" && rootIdentifierName(object.callee) === "expect";
     return isExpectCall ? node.callee.property.name : undefined;
 }
+// `assert(...)`, `assert.equal(...)`, `assert.strict.equal(...)`: real assertions.
+function isAssertCall(node) {
+    let callee = node.callee;
+    while (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier") {
+        callee = callee.object;
+    }
+    return callee.type === "Identifier" && callee.name === "assert";
+}
 /** Tests must assert on behavior, not only that a mock was called. */
 export const noCallOnlyAssertionsRule = defineRule({
     meta: {
@@ -57,6 +71,9 @@ export const noCallOnlyAssertionsRule = defineRule({
         return {
             before() {
                 tests = [];
+                // Every call-only matcher name contains "Called". `\u` covers escaped identifiers.
+                const text = context.sourceCode.text;
+                return text.includes("Called") || text.includes("\\u");
             },
             CallExpression(node) {
                 if (isTestCall(node)) {
@@ -66,6 +83,10 @@ export const noCallOnlyAssertionsRule = defineRule({
                 const test = tests.at(-1);
                 if (!test)
                     return;
+                if (isAssertCall(node)) {
+                    test.total += 1;
+                    return;
+                }
                 const matcher = matcherName(node);
                 if (!matcher)
                     return;

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

@@ -38,12 +38,13 @@ export const noDuplicateConstsRule = defineRule({
     },
     createOnce(context) {
         const seen = new Map();
+        const seenKeysByFile = 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);
+                for (const key of seenKeysByFile.get(context.filename) ?? [])
+                    seen.delete(key);
+                seenKeysByFile.delete(context.filename);
             },
             VariableDeclaration(node) {
                 if (node.kind !== "const")
@@ -57,6 +58,11 @@ export const noDuplicateConstsRule = defineRule({
                     const key = `${declaration.id.name}:${value}`, first = seen.get(key);
                     if (first === undefined) {
                         seen.set(key, { filename: context.filename, name: declaration.id.name });
+                        const keys = seenKeysByFile.get(context.filename);
+                        if (keys === undefined)
+                            seenKeysByFile.set(context.filename, [key]);
+                        else
+                            keys.push(key);
                     }
                     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

@@ -16,7 +16,7 @@ export const noDuplicateTypesRule = defineRule({
         schema: [{ type: "object", properties: { message: { type: "string" }, minProperties: { type: "integer", minimum: 0 }, schemas: { type: "object", properties: { libraries: { type: "array", items: { enum: ["zod", "valibot", "arktype"] } }, matchTypes: { type: "boolean" } }, additionalProperties: false }, drizzle: { type: "object", properties: { models: { type: "array", items: { enum: ["select", "insert"] } }, matchTypes: { type: "boolean" } }, additionalProperties: false } }, additionalProperties: false }],
     },
     createOnce(context) {
-        const seen = new Map();
+        const seen = new Map(), seenKeysByFile = new Map();
         const zodNamespaces = new Set(), valibotNamespaces = new Set(), arkTypeFunctions = new Set();
         const valibotFunctions = new Map(), drizzleTables = new Set(), drizzleSchemaFactories = new Set(), drizzleSchemaObjects = new Set();
         const drizzleBuilders = new Map(), drizzleModels = new Map();
@@ -29,10 +29,16 @@ export const noDuplicateTypesRule = defineRule({
             const isolates = kind === "schema" ? options.schemas?.matchTypes === false : kind.startsWith("drizzle-") && options.drizzle?.matchTypes === false;
             const key = isolates ? `${kind}:${fingerprint}` : fingerprint, first = seen.get(key);
             if (first === undefined) {
-                seen.set(key, { node, name, filename: context.filename });
+                seen.set(key, { start: node.start, name, filename: context.filename });
+                const keys = seenKeysByFile.get(context.filename);
+                if (keys === undefined)
+                    seenKeysByFile.set(context.filename, [key]);
+                else
+                    keys.push(key);
                 return;
             }
-            if (first.node !== node)
+            // The same declarator can produce one fingerprint for several Drizzle models.
+            if (first.filename !== context.filename || first.start !== node.start)
                 context.report({ node, messageId: "duplicate", data: { message: options.message ?? "This type is structurally identical to an existing declaration.", firstName: first.name, firstFile: first.filename } });
         };
         const inspectType = (node) => {
@@ -42,7 +48,10 @@ export const noDuplicateTypesRule = defineRule({
                 report(node, node.id.name, fingerprint, "type");
         };
         const inspectSchema = (node) => {
-            if (node.id.type !== "Identifier" || node.init === null)
+            // Every schema form is a call, and needs a library binding imported earlier in the file.
+            if (node.id.type !== "Identifier" || node.init?.type !== "CallExpression")
+                return;
+            if (zodNamespaces.size === 0 && valibotNamespaces.size === 0 && valibotFunctions.size === 0 && !hasArkTypeImport)
                 return;
             const zod = memberCall(node.init);
             const valibot = factoryCall(node.init, valibotNamespaces, valibotFunctions);
@@ -55,7 +64,7 @@ export const noDuplicateTypesRule = defineRule({
                 report(node, node.id.name, schema.fingerprint, "schema");
         };
         const inspectDrizzle = (node) => {
-            if (options.drizzle === undefined || node.id.type !== "Identifier" || node.init === null)
+            if (options.drizzle === undefined || node.id.type !== "Identifier" || node.init?.type !== "CallExpression" || drizzleTables.size === 0 && drizzleSchemaObjects.size === 0)
                 return;
             const models = new Map();
             for (const model of options.drizzle.models ?? ["select", "insert"]) {
@@ -69,18 +78,19 @@ export const noDuplicateTypesRule = defineRule({
                 drizzleModels.set(node.id.name, models);
         };
         const trackImport = (node) => {
-            if (node.source.value === "zod")
+            // Only track bindings for enabled detectors; the inspectors read nothing else.
+            if (node.source.value === "zod" && enabled("zod"))
                 for (const specifier of node.specifiers)
                     if (specifier.type === "ImportNamespaceSpecifier" || specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "z")
                         zodNamespaces.add(specifier.local.name);
-            if (node.source.value === "valibot")
+            if (node.source.value === "valibot" && enabled("valibot"))
                 for (const specifier of node.specifiers) {
                     if (specifier.type === "ImportNamespaceSpecifier")
                         valibotNamespaces.add(specifier.local.name);
                     if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier")
                         valibotFunctions.set(specifier.local.name, specifier.imported.name);
                 }
-            if (node.source.value === "arktype") {
+            if (node.source.value === "arktype" && enabled("arktype")) {
                 hasArkTypeImport = true;
                 for (const specifier of node.specifiers) {
                     const imported = specifier.type === "ImportSpecifier" ? specifier.imported : null;
@@ -88,6 +98,8 @@ export const noDuplicateTypesRule = defineRule({
                         arkTypeFunctions.add(specifier.local.name);
                 }
             }
+            if (options.drizzle === undefined)
+                return;
             const source = /^drizzle-orm\/(pg|mysql|sqlite)-core$/.exec(String(node.source.value));
             if (source === null)
                 return;
@@ -107,9 +119,9 @@ 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);
+                for (const key of seenKeysByFile.get(context.filename) ?? [])
+                    seen.delete(key);
+                seenKeysByFile.delete(context.filename);
                 options = context.options[0] ?? {};
                 zodNamespaces.clear();
                 valibotNamespaces.clear();
@@ -124,7 +136,8 @@ export const noDuplicateTypesRule = defineRule({
                 hasArkTypeImport = false;
             },
             ImportDeclaration: trackImport,
-            TSTypeAliasDeclaration(node) { inspectType(node); drizzleAliases.push(node); },
+            TSTypeAliasDeclaration(node) { inspectType(node); if (options.drizzle !== undefined)
+                drizzleAliases.push(node); },
             TSInterfaceDeclaration: inspectType,
             VariableDeclarator(node) {
                 inspectSchema(node);

package/dist/rules/no-pass-through-schema.js

@@ -67,7 +67,9 @@ export const noPassThroughSchemaRule = defineRule({
     createOnce(context) {
         let options;
         const candidates = [];
-        const exported = new Set();
+        // Export identifiers are resolved to variables only when an alias needs the check.
+        const exportedNames = [];
+        let exported = null;
         function variableFor(node) {
             let scope = context.sourceCode.getScope(node);
             while (true) {
@@ -150,15 +152,25 @@ export const noPassThroughSchemaRule = defineRule({
             return null;
         }
         function markExport(node) {
-            const variable = variableFor(node);
-            if (variable !== null)
-                exported.add(variable);
+            exportedNames.push(node);
+        }
+        function exportedVariables() {
+            if (exported === null) {
+                exported = new Set();
+                for (const node of exportedNames) {
+                    const variable = variableFor(node);
+                    if (variable !== null)
+                        exported.add(variable);
+                }
+            }
+            return exported;
         }
         return {
             before() {
                 options = context.options[0] ?? {};
                 candidates.length = 0;
-                exported.clear();
+                exportedNames.length = 0;
+                exported = null;
             },
             VariableDeclarator(node) {
                 if (node.parent.type === "VariableDeclaration" && node.parent.kind === "const" && node.id.type === "Identifier" && node.init?.type === "Identifier")
@@ -190,7 +202,7 @@ export const noPassThroughSchemaRule = defineRule({
                     if (target !== "schema" && target !== "zod-schema" && target !== "ark-schema")
                         continue;
                     const variable = variableFor(node.id);
-                    if (options.allowExportedAliases && variable !== null && exported.has(variable))
+                    if (options.allowExportedAliases && variable !== null && exportedVariables().has(variable))
                         continue;
                     context.report({ node, messageId: "passThroughSchema", data: { schemaName: node.init.name } });
                 }

package/dist/rules/no-pass-through-type-alias.js

@@ -5,16 +5,28 @@ function isForwardedTypeParameter(typeArgument, typeParameter) {
         typeArgument.typeName.name === typeParameter.name.name &&
         !typeArgument.typeArguments);
 }
+function typeNameText(node) {
+    if (node.type === "Identifier")
+        return node.name;
+    if (node.type !== "TSQualifiedName")
+        return null;
+    const left = typeNameText(node.left);
+    return left === null ? null : `${left}.${node.right.name}`;
+}
 function passThroughTargetName(node) {
     const annotation = node.typeAnnotation;
-    if (annotation.type !== "TSTypeReference" || annotation.typeName.type !== "Identifier") {
+    if (annotation.type !== "TSTypeReference") {
+        return null;
+    }
+    const typeName = typeNameText(annotation.typeName);
+    if (typeName === null) {
         return null;
     }
     const typeParameters = node.typeParameters?.params ?? [];
     const typeArguments = annotation.typeArguments?.params ?? [];
     const isPassThrough = typeParameters.length === typeArguments.length &&
         typeParameters.every((typeParameter, index) => isForwardedTypeParameter(typeArguments[index], typeParameter));
-    return isPassThrough ? annotation.typeName.name : null;
+    return isPassThrough ? typeName : null;
 }
 /** Disallow type aliases that only rename another type. */
 export const noPassThroughTypeAliasRule = defineRule({

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

@@ -42,7 +42,40 @@ const ASSERT_MATCHERS = new Set([
     "match",
     "notMatch",
 ]);
+// Bounded, insertion-ordered cache. Entries are validated by mtime and size so that
+// long-lived processes (editor/LSP) see on-disk changes.
+const FILE_CONTENT_CACHE_LIMIT = 256;
 const fileContentCache = new Map();
+// TS ESM style: a `.js` specifier may refer to a `.ts` source file, etc.
+const SOURCE_EXTENSIONS_FOR_SPECIFIER = {
+    ".js": [".ts", ".tsx"],
+    ".jsx": [".tsx"],
+    ".mjs": [".mts"],
+    ".cjs": [".cts"],
+};
+function readCachedFile(filePath) {
+    const stats = fs.statSync(filePath, { throwIfNoEntry: false });
+    if (!stats?.isFile()) {
+        fileContentCache.delete(filePath);
+        return undefined;
+    }
+    const cached = fileContentCache.get(filePath);
+    if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+        return cached.content;
+    }
+    const content = fs.readFileSync(filePath, "utf8");
+    fileContentCache.delete(filePath);
+    if (fileContentCache.size >= FILE_CONTENT_CACHE_LIMIT) {
+        const oldest = fileContentCache.keys().next().value;
+        if (oldest !== undefined)
+            fileContentCache.delete(oldest);
+    }
+    fileContentCache.set(filePath, { mtimeMs: stats.mtimeMs, size: stats.size, content });
+    return content;
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function isTestFile(filename) {
     if (!filename)
         return false;
@@ -98,36 +131,37 @@ function isImportedConstantString(variable, currentFilename) {
     if (typeof source !== "string" || !source.startsWith(".")) {
         return false;
     }
+    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)
+        return false;
     const dir = path.dirname(currentFilename);
+    const specifierExtension = path.extname(source);
+    const stem = source.slice(0, source.length - specifierExtension.length);
     const candidates = [
         path.resolve(dir, source),
+        ...(SOURCE_EXTENSIONS_FOR_SPECIFIER[specifierExtension] ?? []).map((extension) => path.resolve(dir, `${stem}${extension}`)),
         path.resolve(dir, `${source}.ts`),
         path.resolve(dir, `${source}.tsx`),
+        path.resolve(dir, `${source}.mts`),
+        path.resolve(dir, `${source}.cts`),
         path.resolve(dir, `${source}.js`),
+        path.resolve(dir, `${source}.jsx`),
         path.resolve(dir, `${source}.mjs`),
         path.resolve(dir, source, "index.ts"),
         path.resolve(dir, source, "index.js"),
     ];
+    const pattern = new RegExp(`export\\s+const\\s+${escapeRegExp(importedName)}\\s*=\\s*(["'\`])`);
     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)
+            const content = readCachedFile(candidate);
+            if (content === undefined)
                 continue;
-            const pattern = new RegExp(`export\\s+const\\s+${importedName}\\s*=\\s*(["'\`])`);
             if (pattern.test(content)) {
                 return true;
             }
@@ -249,14 +283,15 @@ export const noPoorSubstringTestsRule = defineRule({
         schema: [],
     },
     createOnce(context) {
-        let shouldCheck = false;
         return {
-            Program() {
-                shouldCheck = isTestFile(context.filename);
+            before() {
+                if (!isTestFile(context.filename))
+                    return false;
+                // Every pattern needs an `expect` or `assert` callee. `\u` covers escaped identifiers.
+                const text = context.sourceCode.text;
+                return text.includes("expect") || text.includes("assert") || text.includes("\\u");
             },
             CallExpression(node) {
-                if (!shouldCheck)
-                    return;
                 // Pattern 1: expect(subject).toContain(sub), expect(subject).toMatch(regex), etc.
                 if (node.callee.type === "MemberExpression" &&
                     !node.callee.computed &&

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

@@ -1,6 +1,7 @@
 import { matchesGlob, relative } from "node:path";
 import { defineRule } from "@oxlint/plugins";
 import { resolveVariable } from "../vendor/anti-slop/shared/scope.js";
+const defaultEntrypoints = ["**/index.ts", "**/index.tsx", "**/index.mts", "**/index.cts", "**/index.js", "**/index.jsx", "**/index.mjs"];
 /** Keep re-exports in explicitly allowed entrypoint files. */
 export const noReexportsOutsideEntrypointsRule = defineRule({
     meta: {
@@ -21,28 +22,38 @@ export const noReexportsOutsideEntrypointsRule = defineRule({
         function isImported(node) {
             return resolveVariable(context.sourceCode, node)?.defs.some((definition) => definition.type === "ImportBinding") ?? false;
         }
-        return {
-            before() {
+        // Most files have no re-exports, so match the entrypoint globs only on the first one.
+        let entrypoint;
+        function isEntrypoint() {
+            if (entrypoint === undefined) {
                 const options = context.options[0];
                 const filename = relative(context.cwd, context.filename).replaceAll("\\", "/");
-                return !(options?.entrypoints ?? ["**/index.ts"]).some((pattern) => matchesGlob(filename, pattern));
+                entrypoint = (options?.entrypoints ?? defaultEntrypoints).some((pattern) => matchesGlob(filename, pattern));
+            }
+            return entrypoint;
+        }
+        return {
+            before() {
+                entrypoint = undefined;
             },
             ExportNamedDeclaration(node) {
                 if (node.source !== null) {
-                    context.report({ node, messageId: "reexport" });
+                    if (!isEntrypoint())
+                        context.report({ node, messageId: "reexport" });
                     return;
                 }
                 for (const specifier of node.specifiers) {
-                    if (specifier.local.type === "Identifier" && isImported(specifier.local)) {
+                    if (specifier.local.type === "Identifier" && isImported(specifier.local) && !isEntrypoint()) {
                         context.report({ node: specifier, messageId: "reexport" });
                     }
                 }
             },
             ExportAllDeclaration(node) {
-                context.report({ node, messageId: "reexport" });
+                if (!isEntrypoint())
+                    context.report({ node, messageId: "reexport" });
             },
             ExportDefaultDeclaration(node) {
-                if (node.declaration.type === "Identifier" && isImported(node.declaration)) {
+                if (node.declaration.type === "Identifier" && isImported(node.declaration) && !isEntrypoint()) {
                     context.report({ node, messageId: "reexport" });
                 }
             },

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

@@ -11,6 +11,78 @@ function moduleScopeFor(scope) {
 function importedName(node) {
     return node.imported.type === "Identifier" ? node.imported.name : null;
 }
+const reservedBindingNames = new Set([
+    "arguments",
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "eval",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "interface",
+    "let",
+    "new",
+    "null",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+]);
+function isShadowedAt(reference, name, moduleScope) {
+    let current = reference.from;
+    while (current !== null && current !== moduleScope) {
+        if (current.set.has(name))
+            return true;
+        current = current.upper;
+    }
+    return false;
+}
+function isIntrinsicJsxTag(identifier, name) {
+    const parent = identifier.parent;
+    return (parent.type === "JSXOpeningElement" || parent.type === "JSXClosingElement") && /^[a-z]/.test(name);
+}
+function referenceReplacement(identifier, localName, name) {
+    const parent = identifier.parent;
+    if (parent.type === "Property" && parent.shorthand && parent.value === identifier)
+        return `${localName}: ${name}`;
+    if (parent.type === "ExportSpecifier" && parent.local === identifier && parent.exported.range[0] === identifier.range[0]) {
+        return `${name} as ${localName}`;
+    }
+    return name;
+}
 /** Disallow named import aliases when the imported name is available in module scope. */
 export const noRenamedImportsRule = defineRule({
     meta: {
@@ -39,11 +111,16 @@ export const noRenamedImportsRule = defineRule({
                     messageId: "unnecessaryAlias",
                     data: { importedName: name, localName: node.local.name },
                     fix(fixer) {
+                        const localName = node.local.name;
+                        const references = variable.references.filter((reference) => reference.resolved === variable);
+                        if (reservedBindingNames.has(name) ||
+                            moduleScope.through.some((reference) => reference.identifier.name === name) ||
+                            references.some((reference) => isShadowedAt(reference, name, moduleScope) || isIntrinsicJsxTag(reference.identifier, name))) {
+                            return null;
+                        }
                         return [
-                            fixer.replaceText(node, name),
-                            ...variable.references
-                                .filter((reference) => reference.resolved === variable)
-                                .map((reference) => fixer.replaceText(reference.identifier, name)),
+                            fixer.replaceTextRange([node.imported.range[0], node.range[1]], name),
+                            ...references.map((reference) => fixer.replaceText(reference.identifier, referenceReplacement(reference.identifier, localName, name))),
                         ];
                     },
                 });

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

@@ -2,6 +2,7 @@ import { defineRule } from "@oxlint/plugins";
 import { classifyUnsafeDictionaryValue, classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression, } from "../shared/dictionary-types.js";
 import { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation, } from "../shared/function-parameters.js";
 import { resolveVariable } from "../shared/scope.js";
+const TYPE_PREDICATE_KEYWORD = /\b(?:asserts|is)\b/;
 function unwrapExpression(expression) {
     let current = expression;
     while (current.type === "ParenthesizedExpression" ||
@@ -196,6 +197,7 @@ export const noKnownValueWideningRule = defineRule({
     },
     createOnce(context) {
         let environment = null;
+        let hasTypePredicateKeyword = null;
         const reportFlow = (expression, destination, subject) => {
             if (destination === null)
                 return;
@@ -214,7 +216,8 @@ export const noKnownValueWideningRule = defineRule({
         const targetFromAnnotation = (annotation) => environment === null ? null : annotationTarget(annotation, environment);
         return {
             Program(node) {
-                environment = createTypeEnvironment(node, context.sourceCode.visitorKeys);
+                hasTypePredicateKeyword = null;
+                environment = createTypeEnvironment(node, context.sourceCode.visitorKeys, context.sourceCode.text);
             },
             VariableDeclarator(node) {
                 if (node.init === null || node.id.type !== "Identifier")
@@ -245,6 +248,10 @@ export const noKnownValueWideningRule = defineRule({
             CallExpression(node) {
                 if (environment === null)
                     return;
+                // A report needs a local type predicate (`x is T` or `asserts x`) in this file.
+                hasTypePredicateKeyword ??= TYPE_PREDICATE_KEYWORD.test(context.sourceCode.text);
+                if (!hasTypePredicateKeyword)
+                    return;
                 const owner = localFunctionForCall(context.sourceCode, node.callee);
                 if (owner === null)
                     return;

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

@@ -29,8 +29,6 @@ function isTestFrameworkObject(sourceCode, expression) {
 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" &&
@@ -42,7 +40,10 @@ function moduleMockCall(sourceCode, callee) {
         : property.type === "Identifier"
             ? property.name
             : null;
-    return method !== null && moduleMockMethods.has(method);
+    // Compare the cheap method name before resolving the object through scope analysis.
+    return (method !== null &&
+        moduleMockMethods.has(method) &&
+        isTestFrameworkObject(sourceCode, callee.object));
 }
 /** Ban test framework module mocking in favor of real dependency seams. */
 export const noModuleMockingRule = defineRule({

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

@@ -39,7 +39,7 @@ export const noObjectParametersRule = defineRule({
         };
         return {
             Program(node) {
-                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys, context.sourceCode.text);
             },
             ArrowFunctionExpression: checkParameters,
             FunctionDeclaration: checkParameters,

package/dist/vendor/anti-slop/rules/no-reduce-accumulator-copy.js

@@ -1,5 +1,6 @@
 import { defineRule } from "@oxlint/plugins";
 import { arrayMethodTarget, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression, } from "../shared/array-method.js";
+const ARRAY_COPY_METHODS = ["concat", "slice", "toSpliced", "toSorted", "toReversed", "with"];
 function enclosingReducer(node) {
     let parent = node.parent;
     while (parent !== null) {
@@ -68,6 +69,10 @@ export const noReduceAccumulatorCopyRule = defineRule({
                 const method = arrayMethodTarget(node.callee);
                 if (method === null)
                     return;
+                // Only these methods can copy an accumulator; skip the parent walk for every other call.
+                if (method.name !== "assign" && method.name !== "from" &&
+                    !ARRAY_COPY_METHODS.includes(method.name))
+                    return;
                 const reducer = enclosingReducer(node);
                 if (reducer === null)
                     return;
@@ -85,7 +90,7 @@ export const noReduceAccumulatorCopyRule = defineRule({
                     const source = node.arguments[0];
                     copiesAccumulator = source !== undefined && isAccumulator(source);
                 }
-                else if (["concat", "slice", "toSpliced", "toSorted", "toReversed", "with"].includes(method.name)) {
+                else if (ARRAY_COPY_METHODS.includes(method.name)) {
                     const initialValue = reducer.initialValue;
                     const arrayAccumulator = initialValue !== undefined &&
                         isKnownArrayExpression(context.sourceCode, initialValue);

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

@@ -13,6 +13,8 @@ export const noReflectApplyRule = defineRule({
     },
     createOnce(context) {
         return {
+            // Every report calls through the `Reflect` identifier.
+            before: () => context.sourceCode.text.includes("Reflect"),
             CallExpression(node) {
                 if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
                     return;

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

@@ -13,6 +13,8 @@ export const noReflectGetRule = defineRule({
     },
     createOnce(context) {
         return {
+            // Every report calls through the `Reflect` identifier.
+            before: () => context.sourceCode.text.includes("Reflect"),
             CallExpression(node) {
                 if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
                     return;

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

@@ -47,6 +47,8 @@ export const noRuntimeTypeofRule = defineRule({
     },
     createOnce(context) {
         return {
+            // Every report is a `typeof` operator, so a file without the keyword cannot report.
+            before: () => context.sourceCode.text.includes("typeof"),
             UnaryExpression(node) {
                 const option = context.options?.[0];
                 const allowInTypeGuards = typeof option === "object" &&

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

@@ -1,5 +1,6 @@
 import { defineRule } from "@oxlint/plugins";
 const FORBIDDEN_SYMBOL_NAME = "shape";
+const FORBIDDEN_SYMBOL_TEXT = /shape/i;
 function containsForbiddenSymbolName(name) {
     return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
 }
@@ -32,6 +33,8 @@ export const noForbiddenTermInSymbolNamesRule = defineRule({
             });
         };
         return {
+            // Every symbol name is source text, so a file without the term cannot report.
+            before: () => FORBIDDEN_SYMBOL_TEXT.test(context.sourceCode.text),
             Identifier: reportForbiddenSymbolName,
             PrivateIdentifier: reportForbiddenSymbolName,
             JSXIdentifier: reportForbiddenSymbolName,

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

@@ -41,7 +41,7 @@ export const noUnknownReturnsRule = defineRule({
         };
         return {
             Program(node) {
-                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys, context.sourceCode.text);
             },
             ArrowFunctionExpression: checkReturnType,
             FunctionDeclaration: checkReturnType,

package/dist/vendor/anti-slop/rules/no-unknown-type-aliases.js

@@ -24,7 +24,7 @@ export const noUnknownTypeAliasesRule = defineRule({
             });
         return {
             Program(node) {
-                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys, context.sourceCode.text);
             },
             TSTypeAliasDeclaration(node) {
                 if (!resolvesToUnknown(node.typeAnnotation))

package/dist/vendor/anti-slop/rules/no-unsafe-dictionary-type.js

@@ -115,7 +115,7 @@ export const noUnsafeDictionaryTypeRule = defineRule({
         };
         return {
             Program(node) {
-                environment = createTypeEnvironment(node, context.sourceCode.visitorKeys);
+                environment = createTypeEnvironment(node, context.sourceCode.visitorKeys, context.sourceCode.text);
             },
             TSTypeReference: reportIfUnsafe,
             TSTypeLiteral: reportIfUnsafe,

package/dist/vendor/anti-slop/rules/no-widen-then-assert.js

@@ -238,11 +238,13 @@ export const noWidenThenAssertRule = defineRule({
         },
     },
     createOnce(context) {
-        let scopes = [];
+        let fileScopes = null;
         const checkAssertion = (node) => {
             const expression = assertedExpression(node);
             if (expression.type !== "Identifier")
                 return;
+            // Scope analysis is costly; read it only once a candidate assertion exists.
+            const scopes = (fileScopes ??= context.sourceCode.scopeManager.scopes);
             const variable = resolvedVariableForIdentifier(scopes, expression);
             if (variable === null)
                 return;
@@ -261,7 +263,7 @@ export const noWidenThenAssertRule = defineRule({
         };
         return {
             Program() {
-                scopes = context.sourceCode.scopeManager.scopes;
+                fileScopes = null;
             },
             TSAsExpression: checkAssertion,
             TSTypeAssertion: checkAssertion,

package/dist/vendor/anti-slop/shared/dictionary-types.d.ts

@@ -12,7 +12,7 @@ export type TypeEnvironment = {
     readonly interfaces: ReadonlyMap<string, readonly ESTree.TSInterfaceDeclaration[]>;
     readonly typeAliases: LexicalTypeAliasEnvironment;
 };
-export declare function createTypeEnvironment(program: ESTree.Program, visitorKeys: Readonly<Record<string, readonly string[]>>): TypeEnvironment;
+export declare function createTypeEnvironment(program: ESTree.Program, visitorKeys: Readonly<Record<string, readonly string[]>>, sourceText: string): TypeEnvironment;
 export declare function classifyUnsafeDictionaryValue(valueType: ESTree.TSType, environment: TypeEnvironment): UnsafeDictionary | null;
 export declare function classifyUnsafeDictionary(type: ESTree.TSType, environment: TypeEnvironment): UnsafeDictionary | null;
 export declare function classifyWideningTarget(type: ESTree.TSType, environment: TypeEnvironment): WideningTarget | null;

package/dist/vendor/anti-slop/shared/dictionary-types.js

@@ -16,7 +16,7 @@ function declaredStatement(statement) {
         ? (statement.declaration ?? null)
         : statement;
 }
-export function createTypeEnvironment(program, visitorKeys) {
+export function createTypeEnvironment(program, visitorKeys, sourceText) {
     const interfaces = new Map();
     for (const statement of program.body) {
         const declaration = declaredStatement(statement);
@@ -28,7 +28,7 @@ export function createTypeEnvironment(program, visitorKeys) {
     }
     return {
         interfaces,
-        typeAliases: createTypeAliasEnvironment(program, visitorKeys),
+        typeAliases: createTypeAliasEnvironment(program, visitorKeys, sourceText),
     };
 }
 function typeReferenceName(type) {

package/dist/vendor/anti-slop/shared/type-alias-resolution.d.ts

@@ -12,8 +12,8 @@ export type TypeAliasEnvironment = {
     readonly visitorKeys: VisitorKeys;
 };
 export type ResolvedTypeMatcher = (type: ESTree.TSType, matches: (child: ESTree.TSType) => boolean) => boolean;
-/** Collect every lexical type alias and competing type binding in a program. */
-export declare function createTypeAliasEnvironment(program: ESTree.Program, visitorKeys: VisitorKeys): TypeAliasEnvironment;
+/** Collect every lexical type alias and competing type binding in a program, on first use. */
+export declare function createTypeAliasEnvironment(program: ESTree.Program, visitorKeys: VisitorKeys, sourceText: string): TypeAliasEnvironment;
 /** Resolve the nearest visible alias with this name, respecting lexical shadowing. */
 export declare function visibleTypeAlias(name: string, use: ESTree.Node, environment: TypeAliasEnvironment): ESTree.TSTypeAliasDeclaration | null;
 /** Return whether a local declaration shadows a built-in type at this use. */

package/dist/vendor/anti-slop/shared/type-alias-resolution.js

@@ -37,41 +37,84 @@ function declaredTypeBinding(node) {
     }
     return null;
 }
-function collectTypeBindings(node, visitorKeys, bindingsByName, aliases) {
+/**
+ * Every node that declares a type binding contains one of these keywords in its own source
+ * range. Import specifiers are the exception; they are reached through their ImportDeclaration.
+ */
+const BINDING_KEYWORD = /\b(?:class|enum|import|interface|type)\b/g;
+function bindingKeywordOffsets(sourceText) {
+    const offsets = [];
+    for (const match of sourceText.matchAll(BINDING_KEYWORD))
+        offsets.push(match.index);
+    return offsets;
+}
+/** Return whether a sorted offset list has an entry in `[start, end)`. */
+function hasOffsetInRange(offsets, start, end) {
+    let low = 0;
+    let high = offsets.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if ((offsets[middle] ?? 0) < start)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low < offsets.length && (offsets[low] ?? end) < end;
+}
+function collectTypeBindings(node, visitorKeys, offsets, visitAll, collection) {
     const declared = declaredTypeBinding(node);
     if (declared !== null) {
-        const bindings = bindingsByName.get(declared.name) ?? [];
+        const bindings = collection.bindingsByName.get(declared.name) ?? [];
         bindings.push({ ...declared, scope: enclosingTypeScope(node) });
-        bindingsByName.set(declared.name, bindings);
+        collection.bindingsByName.set(declared.name, bindings);
         if (declared.alias !== null)
-            aliases.push(declared.alias);
+            collection.aliases.push(declared.alias);
     }
+    const visitChildren = visitAll || node.type === "ImportDeclaration";
     // SAFETY: Oxlint's visitor keys identify only ESTree child-node properties.
     const fields = node;
     for (const key of visitorKeys[node.type] ?? []) {
         const value = fields[key];
         if (isNode(value)) {
-            collectTypeBindings(value, visitorKeys, bindingsByName, aliases);
+            if (visitChildren || hasOffsetInRange(offsets, value.start, value.end)) {
+                collectTypeBindings(value, visitorKeys, offsets, visitChildren, collection);
+            }
             continue;
         }
         if (!Array.isArray(value))
             continue;
         for (const child of value) {
-            if (isNode(child)) {
-                collectTypeBindings(child, visitorKeys, bindingsByName, aliases);
+            if (isNode(child) &&
+                (visitChildren || hasOffsetInRange(offsets, child.start, child.end))) {
+                collectTypeBindings(child, visitorKeys, offsets, visitChildren, collection);
             }
         }
     }
 }
-/** Collect every lexical type alias and competing type binding in a program. */
-export function createTypeAliasEnvironment(program, visitorKeys) {
+function collectProgramTypeBindings(program, visitorKeys, sourceText) {
+    const collection = { aliases: [], bindingsByName: new Map() };
+    const offsets = bindingKeywordOffsets(sourceText);
+    if (offsets.length > 0) {
+        collectTypeBindings(program, visitorKeys, offsets, false, collection);
+    }
+    return collection;
+}
+/** Collect every lexical type alias and competing type binding in a program, on first use. */
+export function createTypeAliasEnvironment(program, visitorKeys, sourceText) {
     const cached = environmentsByProgram.get(program);
     if (cached !== undefined)
         return cached;
-    const bindingsByName = new Map();
-    const aliases = [];
-    collectTypeBindings(program, visitorKeys, bindingsByName, aliases);
-    const environment = { aliases, bindingsByName, visitorKeys };
+    let collection = null;
+    const collected = () => (collection ??= collectProgramTypeBindings(program, visitorKeys, sourceText));
+    const environment = {
+        get aliases() {
+            return collected().aliases;
+        },
+        get bindingsByName() {
+            return collected().bindingsByName;
+        },
+        visitorKeys,
+    };
     environmentsByProgram.set(program, environment);
     return environment;
 }

package/package.json

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