oxclippy 0.1.0

package/src/rules/never-loop.ts

@@ -0,0 +1,49 @@
+// clippy::never_loop — loop that always exits on the first iteration
+// Detects: for/while where every path through the body ends with break/return/throw.
+
+import type { Context, Node } from "../types";
+import { unwrapBlock } from "../types";
+
+function alwaysExits(node: Node): boolean {
+  if (!node) return false;
+
+  switch (node.type) {
+    case "ReturnStatement":
+    case "ThrowStatement":
+    case "BreakStatement":
+      return true;
+    case "BlockStatement":
+      return node.body.length > 0 && alwaysExits(node.body[node.body.length - 1]!);
+    case "IfStatement":
+      return !!node.alternate && alwaysExits(node.consequent) && alwaysExits(node.alternate);
+    case "ExpressionStatement":
+      return false;
+    default:
+      return false;
+  }
+}
+
+function checkLoop(node: Node, context: Context) {
+  const body = node.body;
+  if (!body) return;
+
+  if (alwaysExits(body)) {
+    context.report({
+      message:
+        "Never loop: this loop always exits on the first iteration. Consider replacing with a conditional. (clippy::never_loop)",
+      node,
+    });
+  }
+}
+
+export default {
+  create(context: Context) {
+    return {
+      ForStatement: (node: Node) => checkLoop(node, context),
+      ForOfStatement: (node: Node) => checkLoop(node, context),
+      ForInStatement: (node: Node) => checkLoop(node, context),
+      WhileStatement: (node: Node) => checkLoop(node, context),
+      DoWhileStatement: (node: Node) => checkLoop(node, context),
+    };
+  },
+};

package/src/rules/object-keys-values.ts

@@ -0,0 +1,67 @@
+// clippy principle: "don't reinvent the standard library"
+// Detects: Object.keys(obj).map(k => obj[k]) → Object.values(obj)
+// Detects: Object.keys(obj).forEach(k => use(obj[k])) when only value is used → Object.values(obj)
+// Analogous to Clippy's for_kv_map (iterating kv pairs when only one is needed).
+
+import type { Context, Node } from "../types";
+import { isCallOf, isIdentifier } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      CallExpression(node: Node) {
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression") return;
+
+        const methodName = callee.property;
+        if (methodName?.type !== "Identifier") return;
+        if (methodName.name !== "map" && methodName.name !== "forEach") return;
+
+        // Check: Object.keys(obj).map/forEach(...)
+        const receiver = callee.object;
+        if (!isCallOf(receiver, "Object", "keys")) return;
+        if (!receiver.arguments || receiver.arguments.length !== 1) return;
+
+        const objArg = receiver.arguments[0]!;
+        if (objArg.type !== "Identifier") return;
+        const objName = objArg.name;
+
+        // Check callback: k => expr using obj[k]
+        const args = node.arguments;
+        if (!args || args.length !== 1) return;
+        const callback = args[0]!;
+
+        if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")
+          return;
+        if (callback.params.length !== 1) return;
+        const param = callback.params[0]!;
+        if (param.type !== "Identifier") return;
+        const keyName = param.name;
+
+        // Check if callback body contains obj[key] — if so, suggest Object.values or Object.entries
+        const bodyStr = context.sourceCode.text.slice(callback.body.start, callback.body.end);
+
+        // Simple heuristic: if the callback references obj[key], suggest Object.values/entries
+        const indexPattern = `${objName}[${keyName}]`;
+        if (bodyStr.includes(indexPattern)) {
+          // Check if key is ALSO used independently (not just as obj[key])
+          // Simple heuristic: count occurrences of keyName outside obj[keyName]
+          const stripped = bodyStr.replace(new RegExp(`${objName}\\[${keyName}\\]`, "g"), "");
+          const keyStillUsed = new RegExp(`\\b${keyName}\\b`).test(stripped);
+
+          if (keyStillUsed) {
+            context.report({
+              message: `Object keys+values: \`Object.keys(${objName}).${methodName.name}(${keyName} => ... ${objName}[${keyName}] ...)\` can use \`Object.entries(${objName})\` for clearer access to both key and value. (clippy: for_kv_map)`,
+              node,
+            });
+          } else {
+            context.report({
+              message: `Object keys→values: \`Object.keys(${objName}).${methodName.name}(${keyName} => ... ${objName}[${keyName}] ...)\` can be simplified to \`Object.values(${objName}).${methodName.name}(...)\`. (clippy: for_kv_map)`,
+              node,
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/prefer-structured-clone.ts

@@ -0,0 +1,30 @@
+// clippy principle: "don't reinvent the standard library"
+// Detects: JSON.parse(JSON.stringify(x)) → structuredClone(x)
+// structuredClone handles more types (Date, RegExp, Map, Set, ArrayBuffer, etc.)
+// and avoids the gotchas of JSON round-tripping (undefined → missing, functions → missing).
+
+import type { Context, Node } from "../types";
+import { isIdentifier, isCallOf } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      CallExpression(node: Node) {
+        // JSON.parse(JSON.stringify(x))
+        if (!isCallOf(node, "JSON", "parse")) return;
+
+        const args = node.arguments;
+        if (!args || args.length !== 1) return;
+
+        const inner = args[0]!;
+        if (isCallOf(inner, "JSON", "stringify") && inner.arguments?.length === 1) {
+          context.report({
+            message:
+              "Prefer structuredClone: `JSON.parse(JSON.stringify(x))` can be replaced with `structuredClone(x)`, which handles more types and is more correct. (clippy: don't reinvent stdlib)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/promise-new-resolve.ts

@@ -0,0 +1,59 @@
+// clippy principle: "avoid error-prone constructors"
+// Detects: new Promise((resolve) => resolve(x)) → Promise.resolve(x)
+// Detects: new Promise((_, reject) => reject(x)) → Promise.reject(x)
+// The Promise constructor is needed for async operations, not for wrapping sync values.
+
+import type { Context, Node } from "../types";
+import { isIdentifier } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      NewExpression(node: Node) {
+        if (!isIdentifier(node.callee, "Promise")) return;
+        if (!node.arguments || node.arguments.length !== 1) return;
+
+        const callback = node.arguments[0]!;
+        if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")
+          return;
+        if (callback.params.length < 1) return;
+
+        const resolveParam = callback.params[0]!;
+        const rejectParam = callback.params[1];
+
+        let bodyExpr: Node | null = null;
+        if (callback.body.type === "BlockStatement" && callback.body.body.length === 1) {
+          const stmt = callback.body.body[0]!;
+          if (stmt.type === "ExpressionStatement") bodyExpr = stmt.expression;
+        } else if (callback.body.type !== "BlockStatement") {
+          bodyExpr = callback.body;
+        }
+
+        if (!bodyExpr || bodyExpr.type !== "CallExpression") return;
+        if (bodyExpr.arguments.length > 1) return;
+
+        const calledFn = bodyExpr.callee;
+        if (calledFn.type !== "Identifier") return;
+
+        // new Promise((resolve) => resolve(x)) → Promise.resolve(x)
+        if (resolveParam.type === "Identifier" && calledFn.name === resolveParam.name) {
+          context.report({
+            message:
+              "Promise constructor wrapping sync value: `new Promise(resolve => resolve(x))` can be simplified to `Promise.resolve(x)`. (clippy: avoid error-prone constructors)",
+            node,
+          });
+          return;
+        }
+
+        // new Promise((_, reject) => reject(x)) → Promise.reject(x)
+        if (rejectParam?.type === "Identifier" && calledFn.name === rejectParam.name) {
+          context.report({
+            message:
+              "Promise constructor wrapping sync rejection: `new Promise((_, reject) => reject(x))` can be simplified to `Promise.reject(x)`. (clippy: avoid error-prone constructors)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/redundant-closure-call.ts

@@ -0,0 +1,61 @@
+// clippy::redundant_closure_call — immediately invoked function expression wrapping a simple expression
+// Detects: (() => expr)() → expr
+// Detects: (function() { return expr; })() → expr
+// Only flags single-expression/return IIFEs, not those with side effects or multiple statements.
+
+import type { Context, Node } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      CallExpression(node: Node) {
+        const { callee } = node;
+        if (node.arguments.length !== 0) return;
+
+        // Unwrap parenthesized expression — the callee may be in parens
+        let fn = callee;
+        // In ESTree, parens don't produce a wrapper node, so callee is the function directly
+
+        if (fn.type === "ArrowFunctionExpression" && fn.params.length === 0) {
+          // (() => expr)()
+          if (fn.body.type !== "BlockStatement") {
+            context.report({
+              message:
+                "Redundant closure call: this IIFE wraps a single expression. Use the expression directly. (clippy::redundant_closure_call)",
+              node,
+            });
+            return;
+          }
+          // (() => { return expr; })()
+          if (fn.body.body.length === 1) {
+            const stmt = fn.body.body[0]!;
+            if (stmt.type === "ReturnStatement" && stmt.argument) {
+              context.report({
+                message:
+                  "Redundant closure call: this IIFE wraps a single return. Use the expression directly. (clippy::redundant_closure_call)",
+                node,
+              });
+            }
+          }
+          return;
+        }
+
+        if (
+          fn.type === "FunctionExpression" &&
+          fn.params.length === 0 &&
+          fn.body.type === "BlockStatement" &&
+          fn.body.body.length === 1
+        ) {
+          const stmt = fn.body.body[0]!;
+          if (stmt.type === "ReturnStatement" && stmt.argument) {
+            context.report({
+              message:
+                "Redundant closure call: this IIFE wraps a single return. Use the expression directly. (clippy::redundant_closure_call)",
+              node,
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/redundant-closure.ts

@@ -0,0 +1,81 @@
+// clippy::redundant_closure — wrapper closures around known single-arg functions
+// Detects: .map(x => String(x)) → .map(String)
+// Detects: .filter(x => Boolean(x)) → .filter(Boolean)
+//
+// SAFETY: Only flags known-safe builtins that ignore extra arguments from .map(val, idx, arr).
+// Does NOT flag arbitrary functions (e.g. parseInt takes a radix arg, so .map(parseInt) breaks).
+
+import type { Context, Node } from "../types";
+import { isIdentifier } from "../types";
+
+// Builtins that only use their first argument, safe to pass directly to .map/.filter/etc.
+const SAFE_SINGLE_ARG = new Set([
+  "String",
+  "Number",
+  "Boolean",
+  "BigInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI",
+]);
+
+export default {
+  create(context: Context) {
+    return {
+      CallExpression(node: Node) {
+        // Look for .method(x => fn(x)) or .method(function(x) { return fn(x); })
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression") return;
+
+        const args = node.arguments;
+        if (!args || args.length !== 1) return;
+
+        const callback = args[0]!;
+        let paramName: string | null = null;
+        let bodyExpr: Node | null = null;
+
+        if (callback.type === "ArrowFunctionExpression" && callback.params.length === 1) {
+          const param = callback.params[0]!;
+          if (param.type !== "Identifier") return;
+          paramName = param.name;
+
+          if (callback.body.type === "BlockStatement" && callback.body.body.length === 1) {
+            const stmt = callback.body.body[0]!;
+            if (stmt.type === "ReturnStatement") bodyExpr = stmt.argument;
+          } else if (callback.body.type !== "BlockStatement") {
+            bodyExpr = callback.body;
+          }
+        } else if (callback.type === "FunctionExpression" && callback.params.length === 1) {
+          const param = callback.params[0]!;
+          if (param.type !== "Identifier") return;
+          paramName = param.name;
+
+          if (callback.body.type === "BlockStatement" && callback.body.body.length === 1) {
+            const stmt = callback.body.body[0]!;
+            if (stmt.type === "ReturnStatement") bodyExpr = stmt.argument;
+          }
+        }
+
+        if (!paramName || !bodyExpr) return;
+        if (bodyExpr.type !== "CallExpression") return;
+        if (bodyExpr.arguments.length !== 1) return;
+
+        const innerArg = bodyExpr.arguments[0]!;
+        if (!isIdentifier(innerArg, paramName)) return;
+
+        // Check if the called function is a safe single-arg builtin
+        const fnCallee = bodyExpr.callee;
+        if (isIdentifier(fnCallee) && SAFE_SINGLE_ARG.has(fnCallee.name)) {
+          context.report({
+            message: `Redundant closure: \`x => ${fnCallee.name}(x)\` can be simplified to \`${fnCallee.name}\`. (clippy::redundant_closure)`,
+            node: callback,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/search-is-some.ts

@@ -0,0 +1,45 @@
+// clippy::search_is_some — .find() compared to undefined/null when .some() suffices
+// Detects: arr.find(fn) !== undefined → arr.some(fn)
+// Detects: arr.find(fn) != null → arr.some(fn)
+
+import type { Context, Node } from "../types";
+import { isMethodCall } from "../types";
+
+function isNullish(node: Node): boolean {
+  if (node.type === "Identifier" && node.name === "undefined") return true;
+  if (node.type === "Literal" && node.value === null) return true;
+  return false;
+}
+
+function isFindCall(node: Node): boolean {
+  return isMethodCall(node, "find");
+}
+
+function matchesFindNullish(left: Node, right: Node): boolean {
+  return (isFindCall(left) && isNullish(right)) || (isNullish(left) && isFindCall(right));
+}
+
+export default {
+  create(context: Context) {
+    return {
+      BinaryExpression(node: Node) {
+        const { operator, left, right } = node;
+        if (!matchesFindNullish(left, right)) return;
+
+        if (operator === "!==" || operator === "!=") {
+          context.report({
+            message:
+              "Search is some: `.find(fn) !== undefined` can be simplified to `.some(fn)` when you don't need the found value. (clippy::search_is_some)",
+            node,
+          });
+        } else if (operator === "===" || operator === "==") {
+          context.report({
+            message:
+              "Search is some: `.find(fn) === undefined` can be simplified to `!.some(fn)` when you don't need the found value. (clippy::search_is_some)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/similar-names.ts

@@ -0,0 +1,155 @@
+// clippy::similar_names — variables with confusingly similar names
+// Detects: names differing by one character (item/items, data/date, form/from)
+// Minimum length: 3 characters. Excludes common pairs like i/j/k, x/y/z.
+
+import type { Context, Node } from "../types";
+
+const ALLOWED_PAIRS = new Set([
+  "i,j",
+  "j,k",
+  "i,k",
+  "x,y",
+  "y,z",
+  "x,z",
+  "a,b",
+  "b,c",
+  "a,c",
+  "n,m",
+  "r,s",
+]);
+
+/** Returns true if names are confusingly similar (edit distance 1 or single transposition) */
+function areSimilar(a: string, b: string): boolean {
+  if (Math.abs(a.length - b.length) > 1) return false;
+  if (a.length === b.length) {
+    let diffs = 0;
+    let firstDiff = -1;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        if (diffs === 0) firstDiff = i;
+        diffs++;
+        if (diffs > 2) return false;
+      }
+    }
+    if (diffs <= 1) return diffs === 1;
+    // Check for transposition: ab→ba
+    if (diffs === 2 && a[firstDiff] === b[firstDiff + 1] && a[firstDiff + 1] === b[firstDiff])
+      return true;
+    return false;
+  }
+  // Length differs by 1 — check for single insertion/deletion
+  const [shorter, longer] = a.length < b.length ? [a, b] : [b, a];
+  let diffs = 0;
+  let si = 0;
+  for (let li = 0; li < longer.length; li++) {
+    if (shorter[si] === longer[li]) {
+      si++;
+    } else {
+      diffs++;
+      if (diffs > 1) return false;
+    }
+  }
+  return true;
+}
+
+function collectNames(node: Node, names: Map<string, Node>) {
+  if (!node || typeof node !== "object" || !node.type) return;
+
+  if (node.type === "VariableDeclarator" && node.id?.type === "Identifier") {
+    names.set(node.id.name, node.id);
+  }
+  if (node.type === "FunctionDeclaration" && node.id?.type === "Identifier") {
+    names.set(node.id.name, node.id);
+  }
+
+  // Collect parameters
+  if (node.params) {
+    for (const p of node.params) {
+      if (p.type === "Identifier") names.set(p.name, p);
+      if (p.type === "AssignmentPattern" && p.left?.type === "Identifier")
+        names.set(p.left.name, p.left);
+    }
+  }
+
+  // Don't recurse into nested functions (separate scope)
+  if (
+    node.type === "FunctionDeclaration" ||
+    node.type === "FunctionExpression" ||
+    node.type === "ArrowFunctionExpression"
+  )
+    return;
+
+  for (const key of Object.keys(node)) {
+    if (
+      key === "type" ||
+      key === "loc" ||
+      key === "range" ||
+      key === "parent" ||
+      key === "start" ||
+      key === "end"
+    )
+      continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      for (const child of val) {
+        if (child && typeof child === "object" && child.type) collectNames(child, names);
+      }
+    } else if (val && typeof val === "object" && val.type) {
+      collectNames(val, names);
+    }
+  }
+}
+
+export default {
+  create(context: Context) {
+    function checkScope(node: Node) {
+      const names = new Map<string, Node>();
+
+      // Collect params
+      if (node.params) {
+        for (const p of node.params) {
+          if (p.type === "Identifier") names.set(p.name, p);
+          if (p.type === "AssignmentPattern" && p.left?.type === "Identifier")
+            names.set(p.left.name, p.left);
+        }
+      }
+
+      // Collect from body
+      if (node.body?.type === "BlockStatement") {
+        for (const stmt of node.body.body) {
+          collectNames(stmt, names);
+        }
+      }
+
+      const nameList = [...names.entries()];
+      const reported = new Set<string>();
+
+      for (let i = 0; i < nameList.length; i++) {
+        for (let j = i + 1; j < nameList.length; j++) {
+          const [nameA] = nameList[i]!;
+          const [nameB, nodeB] = nameList[j]!;
+
+          if (nameA.length < 3 || nameB.length < 3) continue;
+
+          const pair = [nameA, nameB].sort().join(",");
+          if (ALLOWED_PAIRS.has(pair)) continue;
+          if (reported.has(pair)) continue;
+
+          if (areSimilar(nameA.toLowerCase(), nameB.toLowerCase())) {
+            reported.add(pair);
+            context.report({
+              message: `Similar names: \`${nameA}\` and \`${nameB}\` differ by only one character, which is easy to confuse. (clippy::similar_names)`,
+              node: nodeB,
+            });
+          }
+        }
+      }
+    }
+
+    return {
+      FunctionDeclaration: checkScope,
+      FunctionExpression: checkScope,
+      ArrowFunctionExpression: checkScope,
+    };
+  },
+};

package/src/rules/single-case-switch.ts

@@ -0,0 +1,27 @@
+// clippy::single_match — switch statement with only one non-default case
+// Detects: switch(x) { case 'a': ...; break; } → if (x === 'a') { ... }
+
+import type { Context, Node } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      SwitchStatement(node: Node) {
+        const cases: Node[] = node.cases;
+        if (!cases) return;
+
+        const nonDefaultCases = cases.filter((c: Node) => c.test !== null);
+        const defaultCase = cases.find((c: Node) => c.test === null);
+
+        if (nonDefaultCases.length !== 1) return;
+
+        // If single case + optional default, suggest if/else
+        const suggestion = defaultCase ? "if/else" : "if";
+        context.report({
+          message: `Single-case switch: this switch has only one case. Use an \`${suggestion}\` statement instead. (clippy::single_match)`,
+          node,
+        });
+      },
+    };
+  },
+};

package/src/rules/single-element-loop.ts

@@ -0,0 +1,21 @@
+// clippy::single_element_loop — looping over a single-element array literal
+// Detects: for (const x of [value]) { ... } → just use value directly
+
+import type { Context, Node } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      ForOfStatement(node: Node) {
+        const right = node.right;
+        if (right?.type === "ArrayExpression" && right.elements?.length === 1) {
+          context.report({
+            message:
+              "Single element loop: this loop iterates over a single-element array. Use the value directly. (clippy::single_element_loop)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};