oxclippy 0.1.0

package/src/rules/filter-then-first.ts

@@ -0,0 +1,26 @@
+// clippy::filter_next — .filter(fn)[0] instead of .find(fn)
+// Detects: arr.filter(fn)[0] → arr.find(fn)
+// The Rust equivalent is .filter().next() → .find()
+
+import type { Context, Node } from "../types";
+import { isLiteral, isMethodCall } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      MemberExpression(node: Node) {
+        // arr.filter(fn)[0]
+        if (!node.computed || !isLiteral(node.property, 0)) return;
+
+        const obj = node.object;
+        if (!isMethodCall(obj, "filter")) return;
+
+        context.report({
+          message:
+            "Filter then first: `.filter(fn)[0]` is less efficient and readable than `.find(fn)`. (clippy::filter_next)",
+          node,
+        });
+      },
+    };
+  },
+};

package/src/rules/float-comparison.ts

@@ -0,0 +1,52 @@
+// clippy::float_cmp — direct equality comparison of floating-point numbers
+// Detects: x === 0.1 + 0.2, a === b where both are floats
+// In JS, 0.1 + 0.2 !== 0.3 due to IEEE 754 precision.
+// Only flags comparisons where at least one side is a float literal or float arithmetic.
+
+import type { Context, Node } from "../types";
+
+function isFloatLiteral(node: Node): boolean {
+  return node.type === "Literal" && typeof node.value === "number" && !Number.isInteger(node.value);
+}
+
+function isArithmetic(node: Node): boolean {
+  return (
+    node.type === "BinaryExpression" &&
+    (node.operator === "+" ||
+      node.operator === "-" ||
+      node.operator === "*" ||
+      node.operator === "/")
+  );
+}
+
+function involvesFloat(node: Node): boolean {
+  if (isFloatLiteral(node)) return true;
+  if (isArithmetic(node)) {
+    return involvesFloat(node.left) || involvesFloat(node.right);
+  }
+  return false;
+}
+
+export default {
+  create(context: Context) {
+    return {
+      BinaryExpression(node: Node) {
+        if (
+          node.operator !== "===" &&
+          node.operator !== "==" &&
+          node.operator !== "!==" &&
+          node.operator !== "!="
+        )
+          return;
+
+        if (involvesFloat(node.left) || involvesFloat(node.right)) {
+          context.report({
+            message:
+              "Float comparison: direct equality comparison of floating-point numbers is unreliable. Use `Math.abs(a - b) < Number.EPSILON` instead. (clippy::float_cmp)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/float-equality-without-abs.ts

@@ -0,0 +1,43 @@
+// clippy::float_equality_without_abs — float comparison without Math.abs()
+// Detects: (a - b) < EPSILON (missing abs — fails when a < b)
+
+import type { Context, Node } from "../types";
+
+function isEpsilonLike(node: Node): boolean {
+  // Number.EPSILON
+  if (
+    node.type === "MemberExpression" &&
+    node.object?.type === "Identifier" &&
+    node.object.name === "Number" &&
+    node.property?.type === "Identifier" &&
+    node.property.name === "EPSILON"
+  )
+    return true;
+  // Small float literal
+  if (node.type === "Literal" && typeof node.value === "number" && node.value > 0 && node.value < 1)
+    return true;
+  return false;
+}
+
+function isSubtraction(node: Node): boolean {
+  return node.type === "BinaryExpression" && node.operator === "-";
+}
+
+export default {
+  create(context: Context) {
+    return {
+      BinaryExpression(node: Node) {
+        if (node.operator !== "<" && node.operator !== "<=") return;
+
+        // (a - b) < epsilon
+        if (isSubtraction(node.left) && isEpsilonLike(node.right)) {
+          context.report({
+            message:
+              "Float equality without abs: `(a - b) < epsilon` fails when a < b. Use `Math.abs(a - b) < epsilon`. (clippy::float_equality_without_abs)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/fn-params-excessive-bools.ts

@@ -0,0 +1,49 @@
+// clippy::fn_params_excessive_bools — too many boolean parameters (easy to mix up at call sites)
+// Default threshold: 3 boolean params
+
+import type { Context, Node } from "../types";
+
+const THRESHOLD = 3;
+
+function countBoolParams(node: Node): number {
+  const params: Node[] = node.params;
+  if (!params) return 0;
+  let count = 0;
+  for (const p of params) {
+    // Check for TypeScript boolean type annotation: param: boolean
+    if (p.type === "Identifier" && p.typeAnnotation) {
+      const ann = p.typeAnnotation.typeAnnotation ?? p.typeAnnotation;
+      if (ann.type === "TSBooleanKeyword") count++;
+    }
+    // Also check assignment patterns with boolean defaults: param = true/false
+    if (
+      p.type === "AssignmentPattern" &&
+      p.right?.type === "Literal" &&
+      typeof p.right.value === "boolean"
+    ) {
+      count++;
+    }
+  }
+  return count;
+}
+
+function checkFunction(node: Node, context: Context) {
+  const boolCount = countBoolParams(node);
+  if (boolCount <= THRESHOLD) return;
+
+  const name = node.id?.name ?? "<anonymous>";
+  context.report({
+    message: `Excessive bools: \`${name}\` has ${boolCount} boolean parameters (max ${THRESHOLD}). Consider using an options object. (clippy::fn_params_excessive_bools)`,
+    node,
+  });
+}
+
+export default {
+  create(context: Context) {
+    return {
+      FunctionDeclaration: (node: Node) => checkFunction(node, context),
+      FunctionExpression: (node: Node) => checkFunction(node, context),
+      ArrowFunctionExpression: (node: Node) => checkFunction(node, context),
+    };
+  },
+};

package/src/rules/identity-op.ts

@@ -0,0 +1,46 @@
+// clippy::identity_op — operations that have no effect
+// Detects: x + 0, 0 + x, x - 0, x * 1, 1 * x, x / 1, x ** 1
+// NOT covered by oxc/erasing-op (which covers x * 0, x & 0 — destructive ops)
+
+import type { Context, Node } from "../types";
+import { isLiteral } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      BinaryExpression(node: Node) {
+        const { operator, left, right } = node;
+
+        let match = false;
+
+        switch (operator) {
+          case "+":
+            // Skip string concatenation: "str" + 0 is not identity
+            if (isLiteral(left) && typeof left.value === "string") break;
+            if (isLiteral(right) && typeof right.value === "string") break;
+            match = isLiteral(left, 0) || isLiteral(right, 0);
+            break;
+          case "-":
+            match = isLiteral(right, 0);
+            break;
+          case "*":
+            match = isLiteral(left, 1) || isLiteral(right, 1);
+            break;
+          case "/":
+            match = isLiteral(right, 1);
+            break;
+          case "**":
+            match = isLiteral(right, 1);
+            break;
+        }
+
+        if (match) {
+          context.report({
+            message: `Identity op: \`${operator} ${operator === "+" || operator === "-" ? "0" : "1"}\` has no effect. (clippy::identity_op)`,
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/if-same-then-else.ts

@@ -0,0 +1,34 @@
+// clippy::if_same_then_else — if/else with identical bodies
+// Almost certainly a bug or dead code.
+
+import type { Context, Node } from "../types";
+
+function sourceRange(node: Node, text: string): string {
+  if (node.start != null && node.end != null) {
+    return text.slice(node.start, node.end);
+  }
+  return "";
+}
+
+export default {
+  create(context: Context) {
+    return {
+      IfStatement(node: Node) {
+        if (!node.alternate) return;
+        if (node.alternate.type === "IfStatement") return; // skip else-if chains
+
+        const text = context.sourceCode.text;
+        const consequentSrc = sourceRange(node.consequent, text);
+        const alternateSrc = sourceRange(node.alternate, text);
+
+        if (consequentSrc && consequentSrc === alternateSrc) {
+          context.report({
+            message:
+              "If same then else: both branches of this if/else are identical. (clippy::if_same_then_else)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/int-plus-one.ts

@@ -0,0 +1,74 @@
+// clippy::int_plus_one — x >= y + 1 can be simplified to x > y
+// Also: x + 1 <= y → x < y, x - 1 >= y → x > y, etc.
+
+import type { Context, Node } from "../types";
+import { isLiteral } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      BinaryExpression(node: Node) {
+        const { operator, left, right } = node;
+
+        // x >= y + 1 → x > y
+        if (
+          operator === ">=" &&
+          right.type === "BinaryExpression" &&
+          right.operator === "+" &&
+          isLiteral(right.right, 1)
+        ) {
+          context.report({
+            message:
+              "Int plus one: `x >= y + 1` can be simplified to `x > y`. (clippy::int_plus_one)",
+            node,
+          });
+          return;
+        }
+
+        // x + 1 <= y → x < y
+        if (
+          operator === "<=" &&
+          left.type === "BinaryExpression" &&
+          left.operator === "+" &&
+          isLiteral(left.right, 1)
+        ) {
+          context.report({
+            message:
+              "Int plus one: `x + 1 <= y` can be simplified to `x < y`. (clippy::int_plus_one)",
+            node,
+          });
+          return;
+        }
+
+        // x - 1 >= y → x > y
+        if (
+          operator === ">=" &&
+          left.type === "BinaryExpression" &&
+          left.operator === "-" &&
+          isLiteral(left.right, 1)
+        ) {
+          context.report({
+            message:
+              "Int plus one: `x - 1 >= y` can be simplified to `x > y`. (clippy::int_plus_one)",
+            node,
+          });
+          return;
+        }
+
+        // y <= x - 1 → y < x
+        if (
+          operator === "<=" &&
+          right.type === "BinaryExpression" &&
+          right.operator === "-" &&
+          isLiteral(right.right, 1)
+        ) {
+          context.report({
+            message:
+              "Int plus one: `y <= x - 1` can be simplified to `y < x`. (clippy::int_plus_one)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/let-and-return.ts

@@ -0,0 +1,43 @@
+// clippy::let_and_return — unnecessary variable before return
+// Detects: const x = expr; return x; → return expr;
+// Only flags when the variable is declared and immediately returned with no other uses.
+
+import type { Context, Node } from "../types";
+import { getFunctionBody } from "../types";
+
+function checkBody(body: Node[], context: Context) {
+  if (body.length < 2) return;
+
+  const last = body[body.length - 1]!;
+  const secondLast = body[body.length - 2]!;
+
+  // Last must be: return x;
+  if (last.type !== "ReturnStatement" || !last.argument || last.argument.type !== "Identifier")
+    return;
+  const returnedName = last.argument.name;
+
+  // Second-to-last must be: const/let x = expr;
+  if (secondLast.type !== "VariableDeclaration" || secondLast.declarations.length !== 1) return;
+  const decl = secondLast.declarations[0]!;
+  if (decl.id?.type !== "Identifier" || decl.id.name !== returnedName || !decl.init) return;
+
+  context.report({
+    message: `Let and return: \`${returnedName}\` is immediately returned. Return the expression directly. (clippy::let_and_return)`,
+    node: secondLast,
+  });
+}
+
+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-clamp.ts

@@ -0,0 +1,63 @@
+// clippy::manual_clamp — manual min/max clamping patterns
+// Detects: Math.max(min, Math.min(val, max)) or Math.min(max, Math.max(val, min))
+// Suggests: use a clamp function or Math.min(Math.max(val, min), max) with a comment
+
+import type { Context, Node } from "../types";
+import { isIdentifier } from "../types";
+
+function isMathCall(node: Node, method: string): boolean {
+  if (node.type !== "CallExpression") return false;
+  const callee = node.callee;
+  return (
+    callee.type === "MemberExpression" &&
+    isIdentifier(callee.object, "Math") &&
+    isIdentifier(callee.property, method)
+  );
+}
+
+export default {
+  create(context: Context) {
+    return {
+      CallExpression(node: Node) {
+        const args = node.arguments;
+        if (!args || args.length !== 2) return;
+
+        // Math.max(min, Math.min(val, max))
+        if (isMathCall(node, "max") && isMathCall(args[0], "min")) {
+          context.report({
+            message:
+              "Manual clamp: this `Math.max(min, Math.min(val, max))` pattern is a clamp. Consider extracting a `clamp(val, min, max)` helper. (clippy::manual_clamp)",
+            node,
+          });
+          return;
+        }
+        if (isMathCall(node, "max") && isMathCall(args[1], "min")) {
+          context.report({
+            message:
+              "Manual clamp: this `Math.max(Math.min(val, max), min)` pattern is a clamp. Consider extracting a `clamp(val, min, max)` helper. (clippy::manual_clamp)",
+            node,
+          });
+          return;
+        }
+
+        // Math.min(max, Math.max(val, min))
+        if (isMathCall(node, "min") && isMathCall(args[0], "max")) {
+          context.report({
+            message:
+              "Manual clamp: this `Math.min(max, Math.max(val, min))` pattern is a clamp. Consider extracting a `clamp(val, min, max)` helper. (clippy::manual_clamp)",
+            node,
+          });
+          return;
+        }
+        if (isMathCall(node, "min") && isMathCall(args[1], "max")) {
+          context.report({
+            message:
+              "Manual clamp: this `Math.min(Math.max(val, min), max)` pattern is a clamp. Consider extracting a `clamp(val, min, max)` helper. (clippy::manual_clamp)",
+            node,
+          });
+          return;
+        }
+      },
+    };
+  },
+};

package/src/rules/manual-every.ts

@@ -0,0 +1,47 @@
+// clippy::manual_find (every variant) — for loop implementing .every()
+// Detects: for (const x of arr) { if (!cond(x)) return false; } return true;
+// Also: for (const x of arr) { if (cond(x)) return false; } return true;
+
+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, false)
+    )
+      continue;
+
+    const next: Node | undefined = body[i + 1];
+    if (next && next.type === "ReturnStatement" && isLiteral(next.argument, true)) {
+      context.report({
+        message: "Manual every: this loop can be replaced with `.every()`. (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-find.ts

@@ -0,0 +1,59 @@
+// clippy::manual_find — for loop that can be replaced with .find()
+// Detects: for (const x of arr) { if (cond(x)) return x; } return undefined;
+
+import type { Context, Node } from "../types";
+import { getForOfVar, getFunctionBody, unwrapBlock } from "../types";
+
+function isReturnOfVar(stmt: Node, varName: string): boolean {
+  if (stmt.type !== "ReturnStatement") return false;
+  return stmt.argument?.type === "Identifier" && stmt.argument.name === varName;
+}
+
+function isReturnNullish(stmt: Node): boolean {
+  if (stmt.type !== "ReturnStatement") return false;
+  if (!stmt.argument) return true; // bare return
+  if (stmt.argument.type === "Identifier" && stmt.argument.name === "undefined") return true;
+  if (stmt.argument.type === "Literal" && stmt.argument.value === null) return true;
+  return false;
+}
+
+function checkBody(body: Node[], context: Context) {
+  for (let i = 0; i < body.length; i++) {
+    const stmt = body[i]!;
+    if (stmt.type !== "ForOfStatement") continue;
+
+    const loopVar = getForOfVar(stmt);
+    if (!loopVar) continue;
+
+    const inner = unwrapBlock(stmt.body);
+    if (!inner) continue;
+
+    if (inner.type === "IfStatement" && !inner.alternate) {
+      const consequent = unwrapBlock(inner.consequent);
+      if (consequent && isReturnOfVar(consequent, loopVar)) {
+        const next: Node | undefined = body[i + 1];
+        if (next && isReturnNullish(next)) {
+          context.report({
+            message: "Manual find: this loop can be replaced with `.find()`. (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-includes.ts

@@ -0,0 +1,65 @@
+// clippy::manual_find (includes variant) — for loop implementing .includes()
+// Detects: for (const x of arr) { if (x === val) return true; } return false;
+
+import type { Context, Node } from "../types";
+import { getForOfVar, getFunctionBody, isLiteral, unwrapBlock } from "../types";
+
+function isEqualityCheck(test: Node, varName: string): boolean {
+  if (test.type !== "BinaryExpression") return false;
+  if (test.operator !== "===" && test.operator !== "==") return false;
+
+  const left = test.left;
+  const right = test.right;
+
+  return (
+    (left.type === "Identifier" && left.name === varName) ||
+    (right.type === "Identifier" && right.name === varName)
+  );
+}
+
+function checkBody(body: Node[], context: Context) {
+  for (let i = 0; i < body.length; i++) {
+    const stmt = body[i]!;
+    if (stmt.type !== "ForOfStatement") continue;
+
+    const loopVar = getForOfVar(stmt);
+    if (!loopVar) continue;
+
+    const inner = unwrapBlock(stmt.body);
+    if (!inner || inner.type !== "IfStatement" || inner.alternate) continue;
+
+    if (!isEqualityCheck(inner.test, loopVar)) 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 includes: this loop can be replaced with `.includes()`. (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-is-finite.ts

@@ -0,0 +1,57 @@
+// clippy::manual_is_finite / manual_is_infinite — manual infinity checks
+// Detects: x !== Infinity && x !== -Infinity → Number.isFinite(x)
+// Detects: x === Infinity || x === -Infinity → !Number.isFinite(x)
+
+import type { Context, Node } from "../types";
+
+function isInfinityCheck(node: Node, operator: string): boolean {
+  if (node.type !== "BinaryExpression" || node.operator !== operator) return false;
+  return isInfinityLiteral(node.right) || isInfinityLiteral(node.left);
+}
+
+function isInfinityLiteral(node: Node): boolean {
+  // Infinity
+  if (node.type === "Identifier" && node.name === "Infinity") return true;
+  // -Infinity
+  if (
+    node.type === "UnaryExpression" &&
+    node.operator === "-" &&
+    node.argument?.type === "Identifier" &&
+    node.argument.name === "Infinity"
+  )
+    return true;
+  return false;
+}
+
+export default {
+  create(context: Context) {
+    return {
+      LogicalExpression(node: Node) {
+        // x !== Infinity && x !== -Infinity → Number.isFinite(x)
+        if (
+          node.operator === "&&" &&
+          isInfinityCheck(node.left, "!==") &&
+          isInfinityCheck(node.right, "!==")
+        ) {
+          context.report({
+            message:
+              "Manual isFinite: this pattern checks for finiteness manually. Use `Number.isFinite(x)` instead. (clippy::manual_is_finite)",
+            node,
+          });
+        }
+        // x === Infinity || x === -Infinity → !Number.isFinite(x)
+        if (
+          node.operator === "||" &&
+          isInfinityCheck(node.left, "===") &&
+          isInfinityCheck(node.right, "===")
+        ) {
+          context.report({
+            message:
+              "Manual isInfinite: this pattern checks for infinity manually. Use `!Number.isFinite(x)` instead. (clippy::manual_is_infinite)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};