oxclippy 0.1.0

package/src/rules/manual-some.ts

@@ -0,0 +1,46 @@
+// clippy::manual_find (boolean variant) — for loop implementing .some()
+// Detects: for (const x of arr) { if (cond(x)) return true; } return false;
+
+import type { Context, Node } from "../types";
+import { getFunctionBody, isLiteral, unwrapBlock } from "../types";
+
+function checkBody(body: Node[], context: Context) {
+  for (let i = 0; i < body.length; i++) {
+    const stmt = body[i]!;
+    if (stmt.type !== "ForOfStatement") continue;
+
+    const inner = unwrapBlock(stmt.body);
+    if (!inner || inner.type !== "IfStatement" || inner.alternate) continue;
+
+    const consequent = unwrapBlock(inner.consequent);
+    if (
+      !consequent ||
+      consequent.type !== "ReturnStatement" ||
+      !isLiteral(consequent.argument, true)
+    )
+      continue;
+
+    const next: Node | undefined = body[i + 1];
+    if (next && next.type === "ReturnStatement" && isLiteral(next.argument, false)) {
+      context.report({
+        message: "Manual some: this loop can be replaced with `.some()`. (clippy::manual_find)",
+        node: stmt,
+      });
+    }
+  }
+}
+
+export default {
+  create(context: Context) {
+    function checkFunction(node: Node) {
+      const body = getFunctionBody(node);
+      if (body) checkBody(body, context);
+    }
+
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction,
+    };
+  },
+};

package/src/rules/manual-strip.ts

@@ -0,0 +1,96 @@
+// clippy::manual_strip — manual prefix/suffix stripping
+// Detects: if (s.startsWith(prefix)) { s.slice(prefix.length, ...) }
+// Detects: if (s.endsWith(suffix)) { s.slice(0, -suffix.length) }
+// Suggests: extract the strip logic or use a helper
+
+import type { Context, Node } from "../types";
+import { isMethodCall } from "../types";
+
+function getStringMethodTarget(
+  testExpr: Node,
+  methodName: string,
+): { str: string; arg: string } | null {
+  if (!isMethodCall(testExpr, methodName)) return null;
+
+  const callee = testExpr.callee;
+  if (callee.object?.type !== "Identifier") return null;
+  if (!testExpr.arguments || testExpr.arguments.length !== 1) return null;
+
+  const arg = testExpr.arguments[0];
+  if (arg.type !== "Identifier" && arg.type !== "Literal") return null;
+
+  return {
+    str: callee.object.name,
+    arg: arg.type === "Identifier" ? arg.name : JSON.stringify(arg.value),
+  };
+}
+
+function bodyContainsSlice(node: Node, strName: string): boolean {
+  // Walk the AST to find .slice() calls on the same variable
+  if (!node || typeof node !== "object") return false;
+
+  // Check if this node is a call to strName.slice(...)
+  if (
+    node.type === "CallExpression" &&
+    node.callee?.type === "MemberExpression" &&
+    node.callee.object?.type === "Identifier" &&
+    node.callee.object.name === strName &&
+    node.callee.property?.type === "Identifier" &&
+    node.callee.property.name === "slice"
+  ) {
+    return true;
+  }
+
+  // Recurse into children
+  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 && bodyContainsSlice(child, strName))
+          return true;
+      }
+    } else if (val && typeof val === "object" && val.type && bodyContainsSlice(val, strName)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export default {
+  create(context: Context) {
+    return {
+      IfStatement(node: Node) {
+        const test = node.test;
+        if (!test) return;
+
+        // Check for str.startsWith(prefix)
+        const startsInfo = getStringMethodTarget(test, "startsWith");
+        if (startsInfo && bodyContainsSlice(node.consequent, startsInfo.str)) {
+          context.report({
+            message: `Manual strip: checking \`startsWith()\` then slicing is a manual prefix strip. Consider extracting a \`stripPrefix\` helper. (clippy::manual_strip)`,
+            node,
+          });
+          return;
+        }
+
+        // Check for str.endsWith(suffix)
+        const endsInfo = getStringMethodTarget(test, "endsWith");
+        if (endsInfo && bodyContainsSlice(node.consequent, endsInfo.str)) {
+          context.report({
+            message: `Manual strip: checking \`endsWith()\` then slicing is a manual suffix strip. Consider extracting a \`stripSuffix\` helper. (clippy::manual_strip)`,
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/manual-swap.ts

@@ -0,0 +1,73 @@
+// clippy::manual_swap — three-statement swap pattern
+// Detects: const tmp = a; a = b; b = tmp; → [a, b] = [b, a]
+
+import type { Context, Node } from "../types";
+
+function exprName(node: Node): string | null {
+  if (node.type === "Identifier") return node.name;
+  if (
+    node.type === "MemberExpression" &&
+    !node.computed &&
+    node.object?.type === "Identifier" &&
+    node.property?.type === "Identifier"
+  ) {
+    return `${node.object.name}.${node.property.name}`;
+  }
+  return null;
+}
+
+function checkBody(body: Node[], context: Context) {
+  for (let i = 0; i < body.length - 2; i++) {
+    const s1 = body[i]!;
+    const s2 = body[i + 1]!;
+    const s3 = body[i + 2]!;
+
+    // s1: const tmp = a;
+    if (s1.type !== "VariableDeclaration" || s1.declarations.length !== 1) continue;
+    const decl = s1.declarations[0]!;
+    if (decl.id?.type !== "Identifier" || !decl.init) continue;
+    const tmpName = decl.id.name;
+    const aName = exprName(decl.init);
+    if (!aName) continue;
+
+    // s2: a = b;
+    if (
+      s2.type !== "ExpressionStatement" ||
+      s2.expression?.type !== "AssignmentExpression" ||
+      s2.expression.operator !== "="
+    )
+      continue;
+    const assignLeft = exprName(s2.expression.left);
+    const bName = exprName(s2.expression.right);
+    if (assignLeft !== aName || !bName) continue;
+
+    // s3: b = tmp;
+    if (
+      s3.type !== "ExpressionStatement" ||
+      s3.expression?.type !== "AssignmentExpression" ||
+      s3.expression.operator !== "="
+    )
+      continue;
+    const assign2Left = exprName(s3.expression.left);
+    const assign2Right = exprName(s3.expression.right);
+    if (assign2Left !== bName || assign2Right !== tmpName) continue;
+
+    context.report({
+      message: `Manual swap: use destructuring \`[${aName}, ${bName}] = [${bName}, ${aName}]\` instead of a temp variable. (clippy::manual_swap)`,
+      node: s1,
+    });
+  }
+}
+
+export default {
+  create(context: Context) {
+    return {
+      BlockStatement(node: Node) {
+        if (node.body) checkBody(node.body, context);
+      },
+      Program(node: Node) {
+        if (node.body) checkBody(node.body, context);
+      },
+    };
+  },
+};

package/src/rules/map-identity.ts

@@ -0,0 +1,67 @@
+// clippy::map_identity — .map() with an identity function
+// Detects: arr.map(x => x) — a no-op; remove or use .slice() to copy
+
+import type { Context, Node } from "../types";
+import { isMethodCall } from "../types";
+
+function isIdentityClosure(node: Node): boolean {
+  // (x) => x
+  if (node.type === "ArrowFunctionExpression" && node.params.length === 1) {
+    const param = node.params[0]!;
+    const body = node.body;
+    if (param.type === "Identifier" && body.type === "Identifier" && body.name === param.name) {
+      return true;
+    }
+    // (x) => { return x; }
+    if (body.type === "BlockStatement" && body.body.length === 1) {
+      const stmt = body.body[0]!;
+      if (
+        stmt.type === "ReturnStatement" &&
+        stmt.argument?.type === "Identifier" &&
+        stmt.argument.name === param.name
+      ) {
+        return true;
+      }
+    }
+  }
+  // function(x) { return x; }
+  if (node.type === "FunctionExpression" && node.params.length === 1) {
+    const param = node.params[0]!;
+    if (
+      param.type === "Identifier" &&
+      node.body.type === "BlockStatement" &&
+      node.body.body.length === 1
+    ) {
+      const stmt = node.body.body[0]!;
+      if (
+        stmt.type === "ReturnStatement" &&
+        stmt.argument?.type === "Identifier" &&
+        stmt.argument.name === param.name
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+export default {
+  create(context: Context) {
+    return {
+      CallExpression(node: Node) {
+        if (!isMethodCall(node, "map")) return;
+
+        const args = node.arguments;
+        if (!args || args.length !== 1) return;
+
+        if (isIdentityClosure(args[0]!)) {
+          context.report({
+            message:
+              "Map identity: `.map(x => x)` is a no-op. Remove it, or use `.slice()` / `[...arr]` to copy. (clippy::map_identity)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/map-void-return.ts

@@ -0,0 +1,23 @@
+// clippy::map_unit_fn — using .map() for side effects instead of .forEach()
+// Detects: arr.map(fn) where the result is unused (ExpressionStatement)
+// In Rust, this is .map(f) where f returns ()
+
+import type { Context, Node } from "../types";
+import { isMethodCall } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      ExpressionStatement(node: Node) {
+        const expr = node.expression;
+        if (!isMethodCall(expr, "map")) return;
+
+        context.report({
+          message:
+            "Map void return: `.map()` result is unused. Use `.forEach()` for side effects. (clippy::map_unit_fn)",
+          node,
+        });
+      },
+    };
+  },
+};

package/src/rules/match-same-arms.ts

@@ -0,0 +1,46 @@
+// clippy::match_same_arms — switch cases with identical bodies
+// Detects: switch where two or more cases have the same code.
+
+import type { Context, Node } from "../types";
+
+function caseBodySource(caseNode: Node, sourceText: string): string {
+  const stmts: Node[] = caseNode.consequent;
+  if (!stmts || stmts.length === 0) return "";
+  // Exclude break statements from comparison
+  const meaningful = stmts.filter((s: Node) => s.type !== "BreakStatement");
+  if (meaningful.length === 0) return "";
+  const first = meaningful[0]!;
+  const last = meaningful[meaningful.length - 1]!;
+  if (first.start == null || last.end == null) return "";
+  return sourceText.slice(first.start, last.end);
+}
+
+export default {
+  create(context: Context) {
+    return {
+      SwitchStatement(node: Node) {
+        const cases: Node[] = node.cases;
+        if (!cases || cases.length < 2) return;
+
+        const seen = new Map<string, Node>();
+
+        for (const c of cases) {
+          if (c.test === null) continue; // skip default
+          const body = caseBodySource(c, context.sourceCode.text);
+          if (!body) continue;
+
+          const existing = seen.get(body);
+          if (existing) {
+            context.report({
+              message:
+                "Match same arms: multiple switch cases have identical bodies. Consider combining them. (clippy::match_same_arms)",
+              node: c,
+            });
+          } else {
+            seen.set(body, c);
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/needless-bool.ts

@@ -0,0 +1,67 @@
+// clippy::needless_bool — if/else returning boolean literals
+// Detects: if (c) { return true } else { return false } → return c
+// Detects: if (c) { x = true } else { x = false } → x = c
+// NOT covered by eslint/no-unneeded-ternary (which only catches ternaries)
+
+import type { Context, Node } from "../types";
+import { isBoolLiteral, unwrapBlock } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      IfStatement(node: Node) {
+        if (!node.alternate) return;
+
+        const consequent = unwrapBlock(node.consequent);
+        const alternate = unwrapBlock(node.alternate);
+        if (!consequent || !alternate) return;
+
+        // Case 1: if (c) return true; else return false;
+        if (consequent.type === "ReturnStatement" && alternate.type === "ReturnStatement") {
+          const cArg = consequent.argument;
+          const aArg = alternate.argument;
+          if (isBoolLiteral(cArg) && isBoolLiteral(aArg) && cArg.value !== aArg.value) {
+            const suggestion = cArg.value ? "return <condition>" : "return !<condition>";
+            context.report({
+              message: `Needless bool: this if/else returns opposing booleans. Simplify to \`${suggestion}\`. (clippy::needless_bool)`,
+              node,
+            });
+          }
+          return;
+        }
+
+        // Case 2: if (c) { x = true } else { x = false }
+        if (
+          consequent.type === "ExpressionStatement" &&
+          alternate.type === "ExpressionStatement" &&
+          consequent.expression.type === "AssignmentExpression" &&
+          alternate.expression.type === "AssignmentExpression" &&
+          consequent.expression.operator === "=" &&
+          alternate.expression.operator === "="
+        ) {
+          const cExpr = consequent.expression;
+          const aExpr = alternate.expression;
+
+          // Check both assign to the same variable
+          if (
+            cExpr.left.type === "Identifier" &&
+            aExpr.left.type === "Identifier" &&
+            cExpr.left.name === aExpr.left.name &&
+            isBoolLiteral(cExpr.right) &&
+            isBoolLiteral(aExpr.right) &&
+            cExpr.right.value !== aExpr.right.value
+          ) {
+            const varName = cExpr.left.name;
+            const suggestion = cExpr.right.value
+              ? `${varName} = <condition>`
+              : `${varName} = !<condition>`;
+            context.report({
+              message: `Needless bool: this if/else assigns opposing booleans. Simplify to \`${suggestion}\`. (clippy::needless_bool)`,
+              node,
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/needless-continue.ts

@@ -0,0 +1,47 @@
+// clippy::needless_continue — unnecessary continue at the end of a loop body
+// Detects: for (...) { ...; continue; } — the continue is a no-op
+// Detects: for (...) { if (cond) { stuff } else { continue; } } — else continue is redundant
+
+import type { Context, Node } from "../types";
+
+function checkLoopBody(body: Node, context: Context) {
+  if (body.type !== "BlockStatement" || body.body.length === 0) return;
+
+  const stmts: Node[] = body.body;
+  const last = stmts[stmts.length - 1]!;
+
+  // Direct: last statement is bare continue
+  if (last.type === "ContinueStatement" && !last.label) {
+    context.report({
+      message:
+        "Needless continue: `continue` at the end of a loop body has no effect. (clippy::needless_continue)",
+      node: last,
+    });
+    return;
+  }
+
+  // Else-continue: if (...) { ... } else { continue; }
+  if (last.type === "IfStatement" && last.alternate) {
+    const alt = last.alternate;
+    const altBody = alt.type === "BlockStatement" ? alt.body : [alt];
+    if (altBody.length === 1 && altBody[0]!.type === "ContinueStatement" && !altBody[0]!.label) {
+      context.report({
+        message:
+          "Needless continue: `else { continue; }` at the end of a loop is redundant. Remove the else branch. (clippy::needless_continue)",
+        node: altBody[0]!,
+      });
+    }
+  }
+}
+
+export default {
+  create(context: Context) {
+    return {
+      ForStatement: (node: Node) => checkLoopBody(node.body, context),
+      ForOfStatement: (node: Node) => checkLoopBody(node.body, context),
+      ForInStatement: (node: Node) => checkLoopBody(node.body, context),
+      WhileStatement: (node: Node) => checkLoopBody(node.body, context),
+      DoWhileStatement: (node: Node) => checkLoopBody(node.body, context),
+    };
+  },
+};

package/src/rules/needless-late-init.ts

@@ -0,0 +1,44 @@
+// clippy::needless_late_init — variable declared without init then immediately assigned
+// Detects: let x; x = expr; → const x = expr;
+// Also: let x; if (c) { x = a; } else { x = b; } → const x = c ? a : b;
+
+import type { Context, Node } from "../types";
+
+function checkBody(body: Node[], context: Context) {
+  for (let i = 0; i < body.length - 1; i++) {
+    const decl = body[i]!;
+    const next = body[i + 1]!;
+
+    if (decl.type !== "VariableDeclaration" || decl.declarations.length !== 1) continue;
+    const d = decl.declarations[0]!;
+    if (d.id?.type !== "Identifier" || d.init !== null) continue;
+    const varName = d.id.name;
+
+    // Case 1: let x; x = expr;
+    if (
+      next.type === "ExpressionStatement" &&
+      next.expression?.type === "AssignmentExpression" &&
+      next.expression.operator === "=" &&
+      next.expression.left?.type === "Identifier" &&
+      next.expression.left.name === varName
+    ) {
+      context.report({
+        message: `Needless late init: \`${varName}\` is declared then immediately assigned. Initialize on declaration with \`const\`. (clippy::needless_late_init)`,
+        node: decl,
+      });
+    }
+  }
+}
+
+export default {
+  create(context: Context) {
+    return {
+      BlockStatement(node: Node) {
+        if (node.body) checkBody(node.body, context);
+      },
+      Program(node: Node) {
+        if (node.body) checkBody(node.body, context);
+      },
+    };
+  },
+};

package/src/rules/needless-range-loop.ts

@@ -0,0 +1,127 @@
+// clippy::needless_range_loop — index-based loop where for-of suffices
+// Detects: for (let i = 0; i < arr.length; i++) { ...arr[i]... }
+// when `i` is only used for indexing into `arr`, not for other purposes.
+
+import type { Context, Node } from "../types";
+
+function isZeroInit(init: Node): string | null {
+  if (init.type !== "VariableDeclaration" || init.declarations.length !== 1) return null;
+  const decl = init.declarations[0]!;
+  if (decl.id?.type !== "Identifier") return null;
+  if (decl.init?.type !== "Literal" || decl.init.value !== 0) return null;
+  return decl.id.name;
+}
+
+function isLengthTest(test: Node, indexVar: string): string | null {
+  if (test.type !== "BinaryExpression" || test.operator !== "<") return null;
+  if (test.left?.type !== "Identifier" || test.left.name !== indexVar) return null;
+  // arr.length
+  if (
+    test.right?.type === "MemberExpression" &&
+    test.right.object?.type === "Identifier" &&
+    test.right.property?.type === "Identifier" &&
+    test.right.property.name === "length"
+  ) {
+    return test.right.object.name;
+  }
+  return null;
+}
+
+function isIncrement(update: Node, indexVar: string): boolean {
+  // i++ or i += 1
+  if (
+    update.type === "UpdateExpression" &&
+    update.operator === "++" &&
+    update.argument?.type === "Identifier" &&
+    update.argument.name === indexVar
+  )
+    return true;
+  if (
+    update.type === "AssignmentExpression" &&
+    update.operator === "+=" &&
+    update.left?.type === "Identifier" &&
+    update.left.name === indexVar &&
+    update.right?.type === "Literal" &&
+    update.right.value === 1
+  )
+    return true;
+  return false;
+}
+
+/** Check if `indexVar` is used in the body ONLY as arr[indexVar] and nowhere else */
+function onlyUsedAsIndex(body: Node, indexVar: string, arrName: string): boolean {
+  let onlyIndexAccess = true;
+
+  function walk(n: Node) {
+    if (!n || typeof n !== "object" || !n.type) return;
+    if (!onlyIndexAccess) return;
+
+    if (n.type === "Identifier" && n.name === indexVar) {
+      // This identifier reference to indexVar — check if parent is arr[i]
+      // We can't check parent easily, so we take a different approach
+      onlyIndexAccess = false;
+      return;
+    }
+
+    if (
+      n.type === "MemberExpression" &&
+      n.computed &&
+      n.object?.type === "Identifier" &&
+      n.object.name === arrName &&
+      n.property?.type === "Identifier" &&
+      n.property.name === indexVar
+    ) {
+      // This is arr[i] — skip recursing into property to avoid the false hit
+      walk(n.object);
+      return;
+    }
+
+    for (const key of Object.keys(n)) {
+      if (
+        key === "type" ||
+        key === "loc" ||
+        key === "range" ||
+        key === "parent" ||
+        key === "start" ||
+        key === "end"
+      )
+        continue;
+      const val = n[key];
+      if (Array.isArray(val)) {
+        for (const child of val) {
+          if (child && typeof child === "object" && child.type) walk(child);
+        }
+      } else if (val && typeof val === "object" && val.type) {
+        walk(val);
+      }
+    }
+  }
+
+  walk(body);
+  return onlyIndexAccess;
+}
+
+export default {
+  create(context: Context) {
+    return {
+      ForStatement(node: Node) {
+        if (!node.init || !node.test || !node.update) return;
+
+        const indexVar = isZeroInit(node.init);
+        if (!indexVar) return;
+
+        const arrName = isLengthTest(node.test, indexVar);
+        if (!arrName) return;
+
+        if (!isIncrement(node.update, indexVar)) return;
+
+        if (onlyUsedAsIndex(node.body, indexVar, arrName)) {
+          context.report({
+            message: `Needless range loop: \`${indexVar}\` is only used to index \`${arrName}\`. Use \`for (const item of ${arrName})\` instead. (clippy::needless_range_loop)`,
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/neg-multiply.ts

@@ -0,0 +1,36 @@
+// clippy::neg_multiply — multiplication by -1 instead of negation
+// Detects: x * -1 → -x, -1 * x → -x
+
+import type { Context, Node } from "../types";
+
+function isNegOne(node: Node): boolean {
+  if (
+    node.type === "UnaryExpression" &&
+    node.operator === "-" &&
+    node.argument.type === "Literal" &&
+    node.argument.value === 1
+  ) {
+    return true;
+  }
+  // Also handle literal -1 (some parsers represent it as Literal with value -1)
+  if (node.type === "Literal" && node.value === -1) return true;
+  return false;
+}
+
+export default {
+  create(context: Context) {
+    return {
+      BinaryExpression(node: Node) {
+        if (node.operator !== "*") return;
+
+        if (isNegOne(node.left) || isNegOne(node.right)) {
+          context.report({
+            message:
+              "Neg multiply: multiplying by -1 is less readable than negation. Use `-x` instead of `x * -1`. (clippy::neg_multiply)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};