@crescware/eslint-plugin-crescware-iteration-var-names 0.0.2 → 0.0.3

package/dist/index.d.ts

@@ -15,7 +15,7 @@ declare const plugin: {
         name: string;
     };
     rules: {
-        "array-callback-arg-names": Rule;
+        "iteration-var-names": Rule;
     };
 };
 export default plugin;

package/dist/index.js

@@ -13,6 +13,7 @@ const TARGET_METHODS = new Set([
     "reduceRight",
     "sort",
 ]);
+const FOR_ALLOWED_INNER = new Set(["k", "v", "i"]);
 const expectedNamesFor = (kind) => {
     switch (kind) {
         case "reduce-sync":
@@ -71,19 +72,195 @@ const isIdentifier = (node) => {
         node.type === "Identifier" &&
         typeof node.name === "string");
 };
+const collectPatternIdentifiers = (node) => {
+    if (node === null) {
+        return [];
+    }
+    switch (node.type) {
+        case "Identifier":
+            if (typeof node.name !== "string") {
+                return [];
+            }
+            return [node];
+        case "ArrayPattern":
+            return (node.elements ?? []).flatMap((el) => collectPatternIdentifiers(el));
+        case "ObjectPattern":
+            return (node.properties ?? []).flatMap((v) => {
+                if (v.type === "Property") {
+                    return collectPatternIdentifiers(v.value);
+                }
+                if (v.type === "RestElement") {
+                    return collectPatternIdentifiers(v.argument);
+                }
+                return [];
+            });
+        case "RestElement":
+            return collectPatternIdentifiers(node.argument ?? null);
+        case "AssignmentPattern":
+            return collectPatternIdentifiers(node.left ?? null);
+        default:
+            return [];
+    }
+};
+const collectForLoopVarIdentifiers = (node) => {
+    if (node.type === "ForStatement") {
+        const init = node.init;
+        if (init === null || init === undefined) {
+            return [];
+        }
+        if (init.type !== "VariableDeclaration") {
+            return [];
+        }
+        const decl = init;
+        return decl.declarations.flatMap((v) => collectPatternIdentifiers(v.id));
+    }
+    const left = node.left;
+    if (left.type === "VariableDeclaration") {
+        const decl = left;
+        return decl.declarations.flatMap((v) => collectPatternIdentifiers(v.id));
+    }
+    return [];
+};
+const forKindOf = (node) => {
+    if (node.type === "ForOfStatement") {
+        return "for-of";
+    }
+    if (node.type === "ForInStatement") {
+        return "for-in";
+    }
+    return "for";
+};
+const DISCARD_NAME = "_";
+const hasIdentifierUseIn = (root, name) => {
+    if (root === null || root === undefined) {
+        return false;
+    }
+    if (typeof root !== "object") {
+        return false;
+    }
+    if (Array.isArray(root)) {
+        for (const item of root) {
+            if (hasIdentifierUseIn(item, name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    const node = root;
+    const type = node.type;
+    if (type === "Identifier" && node.name === name) {
+        return true;
+    }
+    if (type === "VariableDeclarator") {
+        return hasIdentifierUseIn(node.init, name);
+    }
+    if (type === "FunctionDeclaration" ||
+        type === "FunctionExpression" ||
+        type === "ArrowFunctionExpression") {
+        return hasIdentifierUseIn(node.body, name);
+    }
+    if (type === "MemberExpression") {
+        if (hasIdentifierUseIn(node.object, name)) {
+            return true;
+        }
+        if (node.computed === true) {
+            return hasIdentifierUseIn(node.property, name);
+        }
+        return false;
+    }
+    if (type === "Property") {
+        if (node.computed === true && hasIdentifierUseIn(node.key, name)) {
+            return true;
+        }
+        return hasIdentifierUseIn(node.value, name);
+    }
+    if (type === "ForStatement") {
+        const init = node.init;
+        if (init !== null &&
+            init !== undefined &&
+            init.type !== "VariableDeclaration") {
+            if (hasIdentifierUseIn(init, name)) {
+                return true;
+            }
+        }
+        if (hasIdentifierUseIn(node.test, name)) {
+            return true;
+        }
+        if (hasIdentifierUseIn(node.update, name)) {
+            return true;
+        }
+        return hasIdentifierUseIn(node.body, name);
+    }
+    if (type === "ForOfStatement" || type === "ForInStatement") {
+        const left = node.left;
+        if (left !== null &&
+            left !== undefined &&
+            left.type !== "VariableDeclaration") {
+            if (hasIdentifierUseIn(left, name)) {
+                return true;
+            }
+        }
+        if (hasIdentifierUseIn(node.right, name)) {
+            return true;
+        }
+        return hasIdentifierUseIn(node.body, name);
+    }
+    if (type === "CatchClause") {
+        return hasIdentifierUseIn(node.body, name);
+    }
+    if (type === "ImportSpecifier" ||
+        type === "ImportDefaultSpecifier" ||
+        type === "ImportNamespaceSpecifier" ||
+        type === "LabeledStatement" ||
+        type === "BreakStatement" ||
+        type === "ContinueStatement") {
+        return hasIdentifierUseIn(node.body, name);
+    }
+    if (type === "ClassDeclaration" || type === "ClassExpression") {
+        if (hasIdentifierUseIn(node.superClass, name)) {
+            return true;
+        }
+        return hasIdentifierUseIn(node.body, name);
+    }
+    const indexed = node;
+    for (const key of Object.keys(indexed)) {
+        if (key === "loc" ||
+            key === "range" ||
+            key === "parent" ||
+            key === "type") {
+            continue;
+        }
+        if (hasIdentifierUseIn(indexed[key], name)) {
+            return true;
+        }
+    }
+    return false;
+};
+const outerDescriptorOf = (frame) => {
+    if (frame.kind === "array-callback") {
+        return `Array.prototype.${frame.methodName} callback`;
+    }
+    return `${frame.kind} loop`;
+};
 const rule = {
     meta: {
         type: "suggestion",
         docs: {
-            description: "Enforce naming convention for Array.prototype callback arguments (v/i/arr, acc, prev, a/b).",
+            description: "Ban thoughtless single-character variable names in iteration contexts (Array.prototype callbacks, for / for-of / for-in).",
         },
         schema: [],
     },
     create(context) {
-        const callbackStack = [];
+        const frameStack = [];
         const callbackToFrame = new WeakMap();
-        const reportInner = (param, methodName, kind, paramIndex) => {
-            const expected = expectedNamesFor(kind)[paramIndex];
+        const forNodeToFrame = new WeakMap();
+        const isReduceFirstPosition = (frame, paramIndex) => {
+            return (paramIndex === 0 &&
+                (frame.methodKind === "reduce-sync" ||
+                    frame.methodKind === "reduce-async"));
+        };
+        const reportInnerArrayCallback = (param, frame, paramIndex, body) => {
+            const expected = expectedNamesFor(frame.methodKind)[paramIndex];
             if (expected === undefined) {
                 return;
             }
@@ -93,20 +270,60 @@ const rule = {
             if (param.name === expected) {
                 return;
             }
+            if (param.name === DISCARD_NAME &&
+                !isReduceFirstPosition(frame, paramIndex)) {
+                if (!hasIdentifierUseIn(body, DISCARD_NAME)) {
+                    return;
+                }
+                context.report({
+                    message: `Discard parameter '_' is referenced inside the body; rename it to a meaningful name.`,
+                    node: param,
+                });
+                return;
+            }
             context.report({
-                message: `Array.prototype.${methodName} expects '${expected}' for argument ${paramIndex + 1} (got: '${param.name}').`,
+                message: `Array.prototype.${frame.methodName} expects '${expected}' for argument ${paramIndex + 1} (got: '${param.name}').`,
                 node: param,
             });
         };
-        const reportOuter = (param, methodName) => {
+        const reportInnerFor = (param, frame, body) => {
             if (param.name.length >= 2) {
                 return;
             }
+            if (FOR_ALLOWED_INNER.has(param.name)) {
+                return;
+            }
+            if (param.name === DISCARD_NAME) {
+                if (!hasIdentifierUseIn(body, DISCARD_NAME)) {
+                    return;
+                }
+                context.report({
+                    message: `Discard parameter '_' is referenced inside the body; rename it to a meaningful name.`,
+                    node: param,
+                });
+                return;
+            }
             context.report({
-                message: `Avoid the single-character name '${param.name}' on an outer Array.prototype.${methodName} callback; use a meaningful name with 2 or more characters.`,
+                message: `${frame.kind} loop variable '${param.name}' is not allowed; use 'k', 'v', 'i' or a meaningful name with 2 or more characters.`,
                 node: param,
             });
         };
+        const reportOuter = (param, frame) => {
+            if (param.name.length >= 2) {
+                return;
+            }
+            const descriptor = outerDescriptorOf(frame);
+            context.report({
+                message: `Avoid the single-character name '${param.name}' on an outer ${descriptor}; use a meaningful name with 2 or more characters.`,
+                node: param,
+            });
+        };
+        const markParentHasNested = () => {
+            const top = frameStack[frameStack.length - 1];
+            if (top !== undefined) {
+                top.hasNested = true;
+            }
+        };
         const onCallEnter = (node) => {
             const methodName = getTargetMethodName(node);
             if (methodName === null) {
@@ -116,46 +333,78 @@ const rule = {
             if (callback === null) {
                 return;
             }
-            const kind = methodKindOf(methodName, callback.async === true);
-            if (kind === null) {
+            const methodKind = methodKindOf(methodName, callback.async === true);
+            if (methodKind === null) {
                 return;
             }
-            const frame = { kind, methodName, hasNested: false };
+            const frame = {
+                kind: "array-callback",
+                methodKind,
+                methodName,
+                hasNested: false,
+            };
             callbackToFrame.set(callback, frame);
-            const top = callbackStack[callbackStack.length - 1];
-            if (top !== undefined) {
-                top.hasNested = true;
-            }
+            markParentHasNested();
         };
         const onFunctionEnter = (node) => {
             const frame = callbackToFrame.get(node);
             if (frame === undefined) {
                 return;
             }
-            callbackStack.push(frame);
+            frameStack.push(frame);
         };
         const onFunctionExit = (node) => {
             const frame = callbackToFrame.get(node);
             if (frame === undefined) {
                 return;
             }
-            const popped = callbackStack.pop();
+            const popped = frameStack.pop();
             if (popped !== frame) {
                 return;
             }
-            const expected = expectedNamesFor(frame.kind);
+            const expected = expectedNamesFor(frame.methodKind);
             const params = node.params;
             const limit = Math.min(params.length, expected.length);
+            const body = node.body;
             for (let i = 0; i < limit; i++) {
                 const param = params[i];
                 if (!isIdentifier(param)) {
                     continue;
                 }
                 if (frame.hasNested) {
-                    reportOuter(param, frame.methodName);
+                    reportOuter(param, frame);
+                }
+                else {
+                    reportInnerArrayCallback(param, frame, i, body);
+                }
+            }
+        };
+        const onForEnter = (node) => {
+            const frame = {
+                kind: forKindOf(node),
+                hasNested: false,
+            };
+            markParentHasNested();
+            frameStack.push(frame);
+            forNodeToFrame.set(node, frame);
+        };
+        const onForExit = (node) => {
+            const frame = forNodeToFrame.get(node);
+            if (frame === undefined) {
+                return;
+            }
+            const popped = frameStack.pop();
+            if (popped !== frame) {
+                return;
+            }
+            const params = collectForLoopVarIdentifiers(node);
+            const body = node.body;
+            for (const param of params) {
+                if (frame.hasNested) {
+                    reportOuter(param, frame);
                 }
                 else {
-                    reportInner(param, frame.methodName, frame.kind, i);
+                    reportInnerFor(param, frame, body);
                 }
             }
         };
@@ -165,13 +414,19 @@ const rule = {
             "ArrowFunctionExpression:exit": onFunctionExit,
             FunctionExpression: onFunctionEnter,
             "FunctionExpression:exit": onFunctionExit,
+            ForStatement: onForEnter,
+            "ForStatement:exit": onForExit,
+            ForOfStatement: onForEnter,
+            "ForOfStatement:exit": onForExit,
+            ForInStatement: onForEnter,
+            "ForInStatement:exit": onForExit,
         };
     },
 };
 const plugin = {
     meta: { name: "crescware-iteration-var-names" },
     rules: {
-        "array-callback-arg-names": rule,
+        "iteration-var-names": rule,
     },
 };
 export default plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crescware/eslint-plugin-crescware-iteration-var-names",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "files": [
     "dist"
   ],