eslint-plugin-no-mistakes 0.92.0 → 0.93.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.92.0",
+  "version": "0.93.0",
   "description": "ESLint and Oxlint rules that keep code static enough for no-mistakes analyzers and coding agents",
   "license": "MIT",
   "repository": {

package/src/rules/forbidden-member-chains-destructure.js

@@ -2,12 +2,6 @@
 
 const { matches, expressionInfo } = require("./forbidden-member-chains-match");
 
-const PARAM_PARENTS = new Set([
-  "FunctionDeclaration",
-  "FunctionExpression",
-  "ArrowFunctionExpression",
-]);
-
 function patternKey(prop) {
   const key = prop.key;
   if (key.type === "Identifier") return key.name;
@@ -24,8 +18,19 @@ function objectPattern(node) {
 }
 
 function destructureVisitors({ compiled, context, suppressed, info }) {
+  // The outer pattern and a default can reach the same property and chain.
+  // `const { panel: { open } = other.panel } = other` reports that pair once.
+  const reported = new WeakMap();
+
   function report(node, chain) {
     if (suppressed(node)) return;
+    let seen = reported.get(node);
+    if (seen?.has(chain)) return;
+    if (!seen) {
+      seen = new Set();
+      reported.set(node, seen);
+    }
+    seen.add(chain);
     context.report({ node, messageId: "forbiddenChain", data: { message: chain.message } });
   }
 
@@ -63,8 +68,11 @@ function destructureVisitors({ compiled, context, suppressed, info }) {
       const pattern = objectPattern(node.left);
       if (pattern) check(pattern, node.right);
     },
+    // A default is a receiver at any depth, not only on a function parameter.
+    // The parser only allows one in a parameter, property, or array element.
+    // `const { x: { open } = other.panel } = {}` reports `*.panel.open`.
+    // An array element is too: `const [{ open } = other.panel] = []`.
     AssignmentPattern(node) {
-      if (!PARAM_PARENTS.has(node.parent?.type)) return;
       const pattern = objectPattern(node.left);
       if (pattern) check(pattern, node.right);
     },

package/src/rules/forbidden-member-chains-schema.js

@@ -17,29 +17,19 @@ function nonStar() {
   return text(128, "^(?!\\*$)[\\s\\S]+$");
 }
 
-function pathString(pattern) {
-  return text(256, pattern);
-}
-
-function segments(maxItems) {
-  return { type: "array", minItems: 1, maxItems, items: nonStar() };
-}
-
-function starThen(minItems, maxItems) {
-  return {
-    type: "array",
-    minItems,
-    maxItems,
-    items: [{ enum: ["*"] }],
-    additionalItems: nonStar(),
-  };
-}
-
-function pathSchema(pattern, starMin, plainMax, starMax) {
-  return {
-    anyOf: [pathString(pattern), segments(plainMax), starThen(starMin, starMax)],
-  };
-}
+// Segment rules run in assertPath so a bad path names the segment. A JSON Schema
+// anyOf only says the value matched none of the alternatives.
+const pathValue = {
+  anyOf: [
+    { type: "string", minLength: 1, maxLength: 256 },
+    {
+      type: "array",
+      minItems: 1,
+      maxItems: 32,
+      items: { type: "string", minLength: 1, maxLength: 128 },
+    },
+  ],
+};
 
 function chain(properties, required) {
   return {
@@ -60,20 +50,17 @@ const schema = [
         maxItems: 64,
         items: {
           anyOf: [
-            chain({ path: pathSchema(OPEN_PATH, 2, MAX_SEGMENTS, MAX_SEGMENTS) }, [
-              "path",
-              "message",
-            ]),
+            chain({ path: pathValue }, ["path", "message"]),
             chain(
               {
-                path: pathSchema(OPEN_PATH, 2, MAX_SEGMENTS, MAX_SEGMENTS),
+                path: pathValue,
                 receiver: { type: "string", enum: ["*"] },
               },
               ["path", "message", "receiver"],
             ),
             chain(
               {
-                path: pathSchema(NAMED_PATH, 1, MAX_SEGMENTS - 1, MAX_SEGMENTS),
+                path: pathValue,
                 receiver: nonStar(),
               },
               ["path", "message", "receiver"],
@@ -85,7 +72,48 @@ const schema = [
   },
 ];
 
+function shownPath(path) {
+  return Array.isArray(path) ? path.join(".") : String(path);
+}
+
+function assertPath(path, named) {
+  const parts = Array.isArray(path) ? path : String(path).split(".");
+  const shown = shownPath(path);
+  const empty = parts.findIndex((part) => part === "");
+  if (empty !== -1) throw new Error(`empty segment at index ${empty} in '${shown}'`);
+  const star = parts.findIndex((part, index) => part === "*" && index !== 0);
+  if (star !== -1) {
+    throw new Error(`'*' segment at index ${star} in '${shown}'; '*' is only a leading segment`);
+  }
+  if (typeof path === "string") {
+    const pattern = new RegExp(named ? NAMED_PATH : OPEN_PATH);
+    if (pattern.test(path)) return;
+    const limit = named && parts[0] !== "*" ? MAX_SEGMENTS - 1 : MAX_SEGMENTS;
+    if (parts.length > limit) {
+      throw new Error(`path '${shown}' has ${parts.length} segments; the maximum is ${limit}`);
+    }
+    throw new Error(`malformed path '${shown}'`);
+  }
+  const leadingStar = parts[0] === "*";
+  const limit = leadingStar ? MAX_SEGMENTS : named ? MAX_SEGMENTS - 1 : MAX_SEGMENTS;
+  const min = leadingStar ? (named ? 1 : 2) : 1;
+  if (parts.length < min) {
+    throw new Error(`path '${shown}' has ${parts.length} segments; at least ${min} are required`);
+  }
+  if (parts.length > limit) {
+    throw new Error(`path '${shown}' has ${parts.length} segments; the maximum is ${limit}`);
+  }
+}
+
+function assertChains(entries) {
+  if (!Array.isArray(entries)) return;
+  for (const entry of entries) {
+    assertPath(entry.path, typeof entry.receiver === "string" && entry.receiver !== "*");
+  }
+}
+
 function compile(entry) {
+  assertPath(entry.path, typeof entry.receiver === "string" && entry.receiver !== "*");
   const parts = Array.isArray(entry.path) ? entry.path.slice() : entry.path.split(".");
   let wildcard = false;
   let body = parts;
@@ -101,4 +129,4 @@ function compile(entry) {
   return { wildcard, parts: body, message: entry.message };
 }
 
-module.exports = { schema, compile };
+module.exports = { schema, compile, assertChains };

package/src/rules/forbidden-member-chains.js

@@ -1,7 +1,7 @@
 "use strict";
 
 const { ruleSuppression } = require("../rule-suppression");
-const { schema, compile } = require("./forbidden-member-chains-schema");
+const { schema, compile, assertChains } = require("./forbidden-member-chains-schema");
 const {
   matches,
   computeChain,
@@ -20,6 +20,7 @@ module.exports = {
   create(context) {
     const compiled = [];
     const entries = context.options[0]?.chains;
+    assertChains(entries);
     if (Array.isArray(entries)) {
       for (const entry of entries) compiled.push(compile(entry));
     }