oxclippy 0.1.0

package/src/rules/struct-field-names.ts

@@ -0,0 +1,108 @@
+// clippy::struct_field_names — interface/type with redundantly prefixed or suffixed fields
+// Detects: interface User { userName, userEmail, userAge } — "user" prefix is redundant
+
+import type { Context, Node } from "../types";
+
+function getFieldNames(node: Node): string[] {
+  const body = node.body?.body ?? node.body?.members ?? node.members;
+  if (!Array.isArray(body)) return [];
+  return body
+    .map((m: Node) => {
+      if (m.type === "TSPropertySignature" || m.type === "PropertyDefinition") {
+        return m.key?.type === "Identifier" ? m.key.name : null;
+      }
+      return null;
+    })
+    .filter((n: string | null): n is string => n !== null);
+}
+
+function commonPrefix(names: string[]): string {
+  if (names.length < 2) return "";
+  let prefix = names[0]!;
+  for (let i = 1; i < names.length; i++) {
+    const name = names[i]!;
+    let j = 0;
+    while (
+      j < prefix.length &&
+      j < name.length &&
+      prefix[j]!.toLowerCase() === name[j]!.toLowerCase()
+    )
+      j++;
+    prefix = prefix.slice(0, j);
+  }
+  if (!prefix) return "";
+  // Check that prefix ends at a word boundary in the original names
+  // For camelCase: the next char after prefix in any name should be uppercase or absent
+  // For snake_case: prefix should end with _
+  if (prefix.endsWith("_")) return prefix;
+  // Check camelCase boundary: char at prefix.length in first name that's longer should be uppercase
+  for (const name of names) {
+    if (name.length > prefix.length) {
+      const nextChar = name[prefix.length]!;
+      if (nextChar >= "A" && nextChar <= "Z") return prefix;
+      // Not a word boundary
+      return "";
+    }
+  }
+  return prefix;
+}
+
+function commonSuffix(names: string[]): string {
+  if (names.length < 2) return "";
+  // Find raw common suffix
+  let suffix = names[0]!;
+  for (let i = 1; i < names.length; i++) {
+    const name = names[i]!;
+    let j = 0;
+    while (
+      j < suffix.length &&
+      j < name.length &&
+      suffix[suffix.length - 1 - j] === name[name.length - 1 - j]
+    )
+      j++;
+    suffix = suffix.slice(suffix.length - j);
+  }
+  if (!suffix) return "";
+  // Check word boundary: suffix should start with uppercase (camelCase) or _
+  if (suffix[0]! >= "A" && suffix[0]! <= "Z") return suffix;
+  if (suffix.startsWith("_")) return suffix;
+  return "";
+}
+
+export default {
+  create(context: Context) {
+    function check(node: Node, typeName: string | undefined) {
+      if (!typeName) return;
+      const names = getFieldNames(node);
+      if (names.length < 2) return;
+
+      const prefix = commonPrefix(names);
+      if (prefix.length >= 3) {
+        context.report({
+          message: `Struct field names: all fields of \`${typeName}\` share the prefix \`${prefix}\`. Remove it — the type name provides context. (clippy::struct_field_names)`,
+          node,
+        });
+        return;
+      }
+
+      const suffix = commonSuffix(names);
+      if (suffix.length >= 3) {
+        context.report({
+          message: `Struct field names: all fields of \`${typeName}\` share the suffix \`${suffix}\`. Consider removing it. (clippy::struct_field_names)`,
+          node,
+        });
+      }
+    }
+
+    return {
+      TSInterfaceDeclaration(node: Node) {
+        check(node, node.id?.name);
+      },
+      TSTypeAliasDeclaration(node: Node) {
+        if (node.typeAnnotation?.type === "TSTypeLiteral") {
+          check(node.typeAnnotation, node.id?.name);
+        }
+      },
+    };
+  },
+};

package/src/rules/too-many-arguments.ts

@@ -0,0 +1,37 @@
+// clippy::too_many_arguments — functions with too many parameters
+// Default threshold: 5 (Clippy uses 7, but JS convention favors options objects earlier)
+
+import type { Context, Node } from "../types";
+
+const THRESHOLD = 5;
+
+function checkParams(node: Node, context: Context) {
+  const params: Node[] = node.params;
+  if (!params || params.length <= THRESHOLD) return;
+
+  const name =
+    node.id?.name ??
+    (node.parent?.type === "VariableDeclarator" ? node.parent.id?.name : null) ??
+    "<anonymous>";
+
+  context.report({
+    message: `Too many arguments: \`${name}\` has ${params.length} parameters (max ${THRESHOLD}). Consider using an options object. (clippy::too_many_arguments)`,
+    node,
+  });
+}
+
+export default {
+  create(context: Context) {
+    return {
+      FunctionDeclaration(node: Node) {
+        checkParams(node, context);
+      },
+      FunctionExpression(node: Node) {
+        checkParams(node, context);
+      },
+      ArrowFunctionExpression(node: Node) {
+        checkParams(node, context);
+      },
+    };
+  },
+};

package/src/rules/too-many-lines.ts

@@ -0,0 +1,45 @@
+// clippy::too_many_lines — functions exceeding a line count threshold
+// Default threshold: 100 lines (matches Clippy default)
+
+import type { Context, Node } from "../types";
+
+const THRESHOLD = 100;
+
+function countLines(node: Node, sourceText: string): number {
+  if (node.loc) return node.loc.end.line - node.loc.start.line + 1;
+  if (node.start != null && node.end != null) {
+    return sourceText.substring(node.start, node.end).split("\n").length;
+  }
+  return 0;
+}
+
+function checkLines(node: Node, context: Context) {
+  const lines = countLines(node, context.sourceCode.text);
+  if (lines <= THRESHOLD) return;
+
+  const name =
+    node.id?.name ??
+    (node.parent?.type === "VariableDeclarator" ? node.parent.id?.name : null) ??
+    "<anonymous>";
+
+  context.report({
+    message: `Too many lines: \`${name}\` is ${lines} lines long (max ${THRESHOLD}). Consider breaking it into smaller functions. (clippy::too_many_lines)`,
+    node,
+  });
+}
+
+export default {
+  create(context: Context) {
+    return {
+      FunctionDeclaration(node: Node) {
+        checkLines(node, context);
+      },
+      FunctionExpression(node: Node) {
+        checkLines(node, context);
+      },
+      ArrowFunctionExpression(node: Node) {
+        checkLines(node, context);
+      },
+    };
+  },
+};

package/src/rules/unnecessary-fold.ts

@@ -0,0 +1,65 @@
+// clippy::unnecessary_fold — .reduce() that could be .some() or .every()
+// Detects: arr.reduce((acc, x) => acc || cond(x), false) → arr.some(cond)
+// Detects: arr.reduce((acc, x) => acc && cond(x), true) → arr.every(cond)
+
+import type { Context, Node } from "../types";
+import { isLiteral, isMethodCall } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      CallExpression(node: Node) {
+        if (!isMethodCall(node, "reduce")) return;
+        const args = node.arguments;
+        if (!args || args.length !== 2) return;
+
+        const callback = args[0]!;
+        const initial = args[1]!;
+
+        // Callback must be (acc, x) => acc OP expr
+        if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")
+          return;
+        if (callback.params.length !== 2) return;
+        const accParam = callback.params[0]!;
+        if (accParam.type !== "Identifier") return;
+        const accName = accParam.name;
+
+        // Get the body expression
+        let bodyExpr: Node | null = null;
+        if (callback.body.type === "BlockStatement") {
+          if (
+            callback.body.body.length === 1 &&
+            callback.body.body[0]!.type === "ReturnStatement"
+          ) {
+            bodyExpr = callback.body.body[0]!.argument;
+          }
+        } else {
+          bodyExpr = callback.body;
+        }
+        if (!bodyExpr || bodyExpr.type !== "LogicalExpression") return;
+
+        // acc || expr with initial false → .some()
+        if (bodyExpr.operator === "||" && isLiteral(initial, false)) {
+          if (bodyExpr.left.type === "Identifier" && bodyExpr.left.name === accName) {
+            context.report({
+              message:
+                "Unnecessary fold: this `.reduce()` with `||` and initial `false` can be replaced with `.some()`. (clippy::unnecessary_fold)",
+              node,
+            });
+          }
+        }
+
+        // acc && expr with initial true → .every()
+        if (bodyExpr.operator === "&&" && isLiteral(initial, true)) {
+          if (bodyExpr.left.type === "Identifier" && bodyExpr.left.name === accName) {
+            context.report({
+              message:
+                "Unnecessary fold: this `.reduce()` with `&&` and initial `true` can be replaced with `.every()`. (clippy::unnecessary_fold)",
+              node,
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/unnecessary-reduce-collect.ts

@@ -0,0 +1,109 @@
+// clippy principle: "prefer combinators" — .reduce() that builds an array is really .map() or .filter()
+//
+// Detects: arr.reduce((acc, x) => { acc.push(f(x)); return acc; }, []) → arr.map(f)
+// Detects: arr.reduce((acc, x) => { if (c(x)) acc.push(x); return acc; }, []) → arr.filter(c)
+// Detects: arr.reduce((acc, x) => { acc.push(...f(x)); return acc; }, []) → arr.flatMap(f)
+
+import type { Context, Node } from "../types";
+import { isMethodCall } from "../types";
+
+function isEmptyArray(node: Node): boolean {
+  return node.type === "ArrayExpression" && (!node.elements || node.elements.length === 0);
+}
+
+export default {
+  create(context: Context) {
+    return {
+      CallExpression(node: Node) {
+        if (!isMethodCall(node, "reduce")) return;
+        const args = node.arguments;
+        if (!args || args.length !== 2) return;
+
+        const callback = args[0]!;
+        const init = args[1]!;
+
+        if (!isEmptyArray(init)) return;
+        if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")
+          return;
+        if (callback.params.length !== 2) return;
+
+        const accParam = callback.params[0]!;
+        if (accParam.type !== "Identifier") return;
+        const accName = accParam.name;
+
+        // Get the body statements
+        let bodyStmts: Node[] | null = null;
+        if (callback.body.type === "BlockStatement") {
+          bodyStmts = callback.body.body;
+        }
+        if (!bodyStmts) return;
+
+        // Pattern: { acc.push(...); return acc; }
+        if (bodyStmts.length === 2) {
+          const pushStmt = bodyStmts[0]!;
+          const returnStmt = bodyStmts[1]!;
+
+          if (returnStmt.type !== "ReturnStatement") return;
+          if (returnStmt.argument?.type !== "Identifier" || returnStmt.argument.name !== accName)
+            return;
+
+          // Check for acc.push(expr)
+          if (
+            pushStmt.type === "ExpressionStatement" &&
+            pushStmt.expression?.type === "CallExpression" &&
+            pushStmt.expression.callee?.type === "MemberExpression" &&
+            pushStmt.expression.callee.object?.type === "Identifier" &&
+            pushStmt.expression.callee.object.name === accName &&
+            pushStmt.expression.callee.property?.type === "Identifier" &&
+            pushStmt.expression.callee.property.name === "push" &&
+            pushStmt.expression.arguments?.length === 1
+          ) {
+            context.report({
+              message:
+                "Unnecessary reduce: this `.reduce()` builds an array with `.push()`. Use `.map()` instead. (clippy: prefer combinators)",
+              node,
+            });
+            return;
+          }
+        }
+
+        // Pattern: { if (cond) acc.push(x); return acc; }
+        if (bodyStmts.length === 2) {
+          const ifStmt = bodyStmts[0]!;
+          const returnStmt = bodyStmts[1]!;
+
+          if (returnStmt.type !== "ReturnStatement") return;
+          if (returnStmt.argument?.type !== "Identifier" || returnStmt.argument.name !== accName)
+            return;
+
+          if (ifStmt.type === "IfStatement" && !ifStmt.alternate) {
+            const consequent = ifStmt.consequent;
+            let pushExpr: Node | null = null;
+
+            if (consequent.type === "BlockStatement" && consequent.body.length === 1) {
+              pushExpr = consequent.body[0]!;
+            } else if (consequent.type === "ExpressionStatement") {
+              pushExpr = consequent;
+            }
+
+            if (
+              pushExpr?.type === "ExpressionStatement" &&
+              pushExpr.expression?.type === "CallExpression" &&
+              pushExpr.expression.callee?.type === "MemberExpression" &&
+              pushExpr.expression.callee.object?.type === "Identifier" &&
+              pushExpr.expression.callee.object.name === accName &&
+              pushExpr.expression.callee.property?.type === "Identifier" &&
+              pushExpr.expression.callee.property.name === "push"
+            ) {
+              context.report({
+                message:
+                  "Unnecessary reduce: this `.reduce()` conditionally pushes items. Use `.filter()` instead. (clippy: prefer combinators)",
+                node,
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/unreadable-literal.ts

@@ -0,0 +1,59 @@
+// clippy::unreadable_literal — large numeric literals without digit separators
+// Detects: 1000000 → 1_000_000, 0xFF00FF → 0xFF_00_FF
+// Threshold: integers >= 10_000, floats >= 100_000
+
+import type { Context, Node } from "../types";
+
+const INT_THRESHOLD = 10_000;
+
+export default {
+  create(context: Context) {
+    return {
+      Literal(node: Node) {
+        if (typeof node.value !== "number") return;
+        if (!Number.isFinite(node.value)) return;
+
+        const raw: string | undefined = node.raw;
+        if (!raw) return;
+
+        // Skip if already has underscores
+        if (raw.includes("_")) return;
+
+        // Skip hex/octal/binary (different grouping rules)
+        if (
+          raw.startsWith("0x") ||
+          raw.startsWith("0o") ||
+          raw.startsWith("0b") ||
+          raw.startsWith("0X") ||
+          raw.startsWith("0O") ||
+          raw.startsWith("0B")
+        )
+          return;
+
+        // Skip floats with decimal points (e.g. 3.14)
+        if (raw.includes(".")) return;
+
+        // Skip scientific notation
+        if (raw.includes("e") || raw.includes("E")) return;
+
+        const absVal = Math.abs(node.value);
+        if (absVal >= INT_THRESHOLD && Number.isInteger(absVal)) {
+          context.report({
+            message: `Unreadable literal: \`${raw}\` is hard to read. Use numeric separators: \`${formatWithSeparators(raw)}\`. (clippy::unreadable_literal)`,
+            node,
+          });
+        }
+      },
+    };
+  },
+};
+
+function formatWithSeparators(raw: string): string {
+  const negative = raw.startsWith("-");
+  const digits = negative ? raw.slice(1) : raw;
+  const parts: string[] = [];
+  for (let i = digits.length; i > 0; i -= 3) {
+    parts.unshift(digits.slice(Math.max(0, i - 3), i));
+  }
+  return (negative ? "-" : "") + parts.join("_");
+}

package/src/rules/used-underscore-binding.ts

@@ -0,0 +1,41 @@
+// clippy::used_underscore_binding — variables prefixed with _ that are actually used
+// Convention: _ prefix means "intentionally unused." Using such variables is confusing.
+
+import type { Context, Node } from "../types";
+
+export default {
+  create(context: Context) {
+    const declared = new Map<string, Node>();
+    const used = new Set<string>();
+
+    return {
+      VariableDeclarator(node: Node) {
+        if (
+          node.id?.type === "Identifier" &&
+          node.id.name.startsWith("_") &&
+          node.id.name !== "_"
+        ) {
+          declared.set(node.id.name, node.id);
+        }
+      },
+      Identifier(node: Node) {
+        if (node.name?.startsWith("_") && node.name !== "_") {
+          // Only count as "used" if it's not the declaration site
+          if (node.parent?.type !== "VariableDeclarator" || node.parent.id !== node) {
+            used.add(node.name);
+          }
+        }
+      },
+      "Program:exit"() {
+        for (const [name, declNode] of declared) {
+          if (used.has(name)) {
+            context.report({
+              message: `Used underscore binding: \`${name}\` starts with \`_\` (conventionally unused) but is actually used. Remove the underscore prefix. (clippy::used_underscore_binding)`,
+              node: declNode,
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/useless-conversion.ts

@@ -0,0 +1,115 @@
+// clippy::useless_conversion — redundant type conversions
+// Detects: String("hello"), Number(42), Boolean(true), Array.from([...])
+// Also: "str".toString(), (42).valueOf()
+
+import type { Context, Node } from "../types";
+import { isIdentifier, isCallOf } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      CallExpression(node: Node) {
+        const { callee } = node;
+        const args = node.arguments;
+        if (!args || args.length !== 1) return;
+        const arg = args[0];
+
+        // String("literal string")
+        if (
+          isIdentifier(callee, "String") &&
+          arg.type === "Literal" &&
+          typeof arg.value === "string"
+        ) {
+          context.report({
+            message:
+              "Useless conversion: `String()` called on a string literal. (clippy::useless_conversion)",
+            node,
+          });
+          return;
+        }
+
+        // Number(42)
+        if (
+          isIdentifier(callee, "Number") &&
+          arg.type === "Literal" &&
+          typeof arg.value === "number"
+        ) {
+          context.report({
+            message:
+              "Useless conversion: `Number()` called on a number literal. (clippy::useless_conversion)",
+            node,
+          });
+          return;
+        }
+
+        // Boolean(true/false)
+        if (
+          isIdentifier(callee, "Boolean") &&
+          arg.type === "Literal" &&
+          typeof arg.value === "boolean"
+        ) {
+          context.report({
+            message:
+              "Useless conversion: `Boolean()` called on a boolean literal. (clippy::useless_conversion)",
+            node,
+          });
+          return;
+        }
+
+        // Array.from([...])
+        if (isCallOf(node, "Array", "from") && arg.type === "ArrayExpression") {
+          context.report({
+            message:
+              "Useless conversion: `Array.from()` called on an array literal. Use the array directly. (clippy::useless_conversion)",
+            node,
+          });
+          return;
+        }
+
+        // "str".toString()
+        if (
+          callee.type === "MemberExpression" &&
+          isIdentifier(callee.property, "toString") &&
+          callee.object.type === "Literal" &&
+          typeof callee.object.value === "string" &&
+          args.length === 0
+        ) {
+          // This branch handles 0-arg toString, but our check above requires 1 arg.
+          // We'll handle it in a separate visitor.
+        }
+      },
+
+      // Handle 0-arg method calls like "str".toString(), (42).valueOf()
+      "CallExpression:exit"(node: Node) {
+        const { callee } = node;
+        const args = node.arguments;
+        if (!args || args.length !== 0) return;
+        if (callee.type !== "MemberExpression") return;
+
+        const obj = callee.object;
+        const method = callee.property;
+        if (method.type !== "Identifier") return;
+
+        // "str".toString()
+        if (obj.type === "Literal" && typeof obj.value === "string" && method.name === "toString") {
+          context.report({
+            message:
+              "Useless conversion: `.toString()` called on a string literal. (clippy::useless_conversion)",
+            node,
+          });
+          return;
+        }
+
+        // (42).toString() is NOT useless — it converts number to string
+        // But (42).valueOf() IS useless
+        if (obj.type === "Literal" && typeof obj.value === "number" && method.name === "valueOf") {
+          context.report({
+            message:
+              "Useless conversion: `.valueOf()` called on a number literal. (clippy::useless_conversion)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/xor-used-as-pow.ts

@@ -0,0 +1,34 @@
+// clippy::suspicious_xor_used_as_pow — XOR operator mistaken for exponentiation
+// Detects: 2 ^ 8 (likely meant 2 ** 8 = 256, but ^ is XOR = 10)
+// Only flags when both sides are integer literals and the result looks like
+// the user intended exponentiation.
+
+import type { Context, Node } from "../types";
+
+function isIntLiteral(node: Node): boolean {
+  return node.type === "Literal" && typeof node.value === "number" && Number.isInteger(node.value);
+}
+
+export default {
+  create(context: Context) {
+    return {
+      BinaryExpression(node: Node) {
+        if (node.operator !== "^") return;
+
+        // Only flag when both sides are integer literals (strong signal of mistake)
+        if (!isIntLiteral(node.left) || !isIntLiteral(node.right)) return;
+
+        const base = node.left.value as number;
+        const exp = node.right.value as number;
+
+        // Common exponentiation patterns: 2^N, 10^N, small^small
+        if (base >= 2 && exp >= 2) {
+          context.report({
+            message: `XOR used as pow: \`${base} ^ ${exp}\` is bitwise XOR (= ${base ^ exp}), not exponentiation. Use \`${base} ** ${exp}\` (= ${base ** exp}) or \`Math.pow(${base}, ${exp})\` instead. (clippy::suspicious_xor_used_as_pow)`,
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/zero-divided-by-zero.ts

@@ -0,0 +1,24 @@
+// clippy::zero_divided_by_zero — 0 / 0 produces NaN; use NaN directly
+// Also catches 0.0 / 0.0
+
+import type { Context, Node } from "../types";
+
+function isZero(node: Node): boolean {
+  return node.type === "Literal" && (node.value === 0 || node.value === 0.0);
+}
+
+export default {
+  create(context: Context) {
+    return {
+      BinaryExpression(node: Node) {
+        if (node.operator === "/" && isZero(node.left) && isZero(node.right)) {
+          context.report({
+            message:
+              "Zero divided by zero: `0 / 0` is `NaN`. Use `NaN` directly if intentional. (clippy::zero_divided_by_zero)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};