ai-deslop 0.4.5 → 0.4.6

package/README.md

@@ -61,7 +61,8 @@ export default defineConfig({
 | --- | --- | --- |
 | `no-call-only-assertions` | Recommended | Flags tests whose assertions only check mock calls. |
 | `no-module-mocking` | Recommended | Rejects Vitest and Jest module mocks. |
-| `no-poor-substring-tests` | Recommended | Rejects testing that a constant string contains substrings. |
+| `no-poor-substring-tests` | Recommended | Rejects testing that a constant string contains substrings. |
+| `no-repeated-expect-call` | Recommended | Flags adjacent assertions that repeat the same call in test files. Reuse the result instead. No fixer. |
 
 ### Opt-in rules
 

package/dist/index.js

@@ -18,6 +18,7 @@ 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 { noRepeatedExpectCallRule } from "./rules/no-repeated-expect-call.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";
@@ -44,6 +45,7 @@ export const recommendedRules = {
     "deslop/require-safety-comment-for-type-assertion": "error",
     "deslop/no-call-only-assertions": "error",
     "deslop/no-poor-substring-tests": "error",
+    "deslop/no-repeated-expect-call": "error",
     "deslop/no-pass-through-type-alias": "error",
     "typescript/no-deprecated": "error",
     "typescript/no-require-imports": "error",
@@ -82,6 +84,7 @@ const deslopPlugin = eslintCompatPlugin({
         "require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
         "no-call-only-assertions": noCallOnlyAssertionsRule,
         "no-poor-substring-tests": noPoorSubstringTestsRule,
+        "no-repeated-expect-call": noRepeatedExpectCallRule,
         "no-constant-substring-tests": noPoorSubstringTestsRule,
         "no-pass-through-type-alias": noPassThroughTypeAliasRule,
         "no-duplicate-types": noDuplicateTypesRule,

package/dist/rules/no-repeated-expect-call.d.ts

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

package/dist/rules/no-repeated-expect-call.js

@@ -0,0 +1,93 @@
+import { defineRule } from "@oxlint/plugins";
+import { resolveVariable } from "../shared/scope.js";
+const TEST_FILE = /(?:^|[/\\])(?:__tests__|tests?)(?:[/\\]|$)|(?:[._](?:test|spec))\.[cm]?[jt]sx?$/i;
+const TEST_MODULES = new Set(["bun:test", "@jest/globals", "vitest"]);
+const CLOSING_TOKENS = new Set([")", "]", "}"]);
+function isExpect(identifier, sourceCode) {
+    if (identifier.type !== "Identifier")
+        return false;
+    const variable = resolveVariable(sourceCode, identifier);
+    if (variable?.defs.length) {
+        return variable.defs.some((definition) => definition.type === "ImportBinding" &&
+            definition.node.type === "ImportSpecifier" &&
+            definition.node.imported.type === "Identifier" &&
+            definition.node.imported.name === "expect" &&
+            definition.parent?.type === "ImportDeclaration" &&
+            TEST_MODULES.has(definition.parent.source.value));
+    }
+    return identifier.name === "expect";
+}
+function assertionCall(statement, sourceCode) {
+    if (statement.type !== "ExpressionStatement")
+        return null;
+    let expression = statement.expression;
+    if (expression.type === "AwaitExpression")
+        expression = expression.argument;
+    if (expression.type !== "CallExpression" || expression.callee.type !== "MemberExpression")
+        return null;
+    let assertion = expression.callee.object;
+    while (assertion.type === "MemberExpression")
+        assertion = assertion.object;
+    if (assertion.type !== "CallExpression" ||
+        assertion.arguments.length !== 1 ||
+        !isExpect(assertion.callee, sourceCode))
+        return null;
+    let call = assertion.arguments[0];
+    if (call.type === "AwaitExpression")
+        call = call.argument;
+    return call.type === "CallExpression" ? call : null;
+}
+function sameCall(left, right, sourceCode) {
+    if (sourceCode.getText(left) === sourceCode.getText(right))
+        return true;
+    const leftTokens = sourceCode.getTokens(left);
+    const rightTokens = sourceCode.getTokens(right);
+    let leftIndex = 0;
+    let rightIndex = 0;
+    while (leftIndex < leftTokens.length && rightIndex < rightTokens.length) {
+        const leftToken = leftTokens[leftIndex];
+        const rightToken = rightTokens[rightIndex];
+        if (leftToken.value === "," && CLOSING_TOKENS.has(leftTokens[leftIndex + 1]?.value) &&
+            leftTokens[leftIndex - 1]?.value !== "[" && leftTokens[leftIndex - 1]?.value !== ",") {
+            leftIndex++;
+            continue;
+        }
+        if (rightToken.value === "," && CLOSING_TOKENS.has(rightTokens[rightIndex + 1]?.value) &&
+            rightTokens[rightIndex - 1]?.value !== "[" && rightTokens[rightIndex - 1]?.value !== ",") {
+            rightIndex++;
+            continue;
+        }
+        if (leftToken.type !== rightToken.type || leftToken.value !== rightToken.value)
+            return false;
+        leftIndex++;
+        rightIndex++;
+    }
+    return leftIndex === leftTokens.length && rightIndex === rightTokens.length;
+}
+export const noRepeatedExpectCallRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Disallow repeated calls across adjacent assertions; call once and reuse the result." },
+        schema: [],
+        messages: { repeatedCall: "Call once and reuse the result across assertions." },
+    },
+    createOnce(context) {
+        function checkStatements(node) {
+            let previous = null;
+            for (const statement of node.body) {
+                const call = assertionCall(statement, context.sourceCode);
+                if (call && previous && sameCall(previous, call, context.sourceCode)) {
+                    context.report({ node: call, messageId: "repeatedCall" });
+                }
+                previous = call;
+            }
+        }
+        return {
+            before() {
+                return TEST_FILE.test(context.filename);
+            },
+            Program: checkStatements,
+            BlockStatement: checkStatements,
+        };
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-deslop",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.",
   "type": "module",
   "main": "./dist/index.js",
@@ -14,8 +14,8 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "bench": "npm run build && node bench.mjs",
+  "scripts": {
+    "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",