oxclippy 0.1.0

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "oxclippy",
+  "version": "0.1.0",
+  "description": "An oxlint JS plugin that mirrors Rust Clippy rules for TypeScript/JavaScript",
+  "keywords": [
+    "clippy",
+    "javascript",
+    "lint",
+    "linter",
+    "oxc",
+    "oxlint",
+    "plugin",
+    "typescript"
+  ],
+  "homepage": "https://github.com/rayhanadev/oxclippy#readme",
+  "bugs": {
+    "url": "https://github.com/rayhanadev/oxclippy/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rayhanadev/oxclippy"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "main": "dist/oxclippy.js",
+  "exports": {
+    ".": "./dist/oxclippy.js"
+  },
+  "scripts": {
+    "build": "bun build src/plugin.ts --outfile dist/oxclippy.js --format esm",
+    "lint": "oxlint",
+    "format": "oxfmt",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "oxc-parser": "^0.123.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "oxfmt": "^0.43.0",
+    "oxlint": "^1.58.0",
+    "oxlint-tsgolint": "^0.19.0"
+  },
+  "peerDependencies": {
+    "typescript": "^6"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { default } from "./plugin";

package/src/plugin.ts

@@ -0,0 +1,134 @@
+// oxclippy: An oxlint JS plugin that mirrors Rust Clippy rules for TypeScript/JavaScript
+//
+// Each rule is named after its Clippy counterpart. Rules that already exist in
+// oxlint's built-in plugins (eslint, typescript, unicorn, oxc) are intentionally
+// omitted to avoid duplication.
+
+import needlessBool from "./rules/needless-bool";
+import collapsibleIf from "./rules/collapsible-if";
+import negMultiply from "./rules/neg-multiply";
+import boolComparison from "./rules/bool-comparison";
+import identityOp from "./rules/identity-op";
+import singleCaseSwitch from "./rules/single-case-switch";
+import tooManyArguments from "./rules/too-many-arguments";
+import tooManyLines from "./rules/too-many-lines";
+import filterThenFirst from "./rules/filter-then-first";
+import mapVoidReturn from "./rules/map-void-return";
+import uselessConversion from "./rules/useless-conversion";
+import manualClamp from "./rules/manual-clamp";
+import manualStrip from "./rules/manual-strip";
+import manualFind from "./rules/manual-find";
+import manualSome from "./rules/manual-some";
+import manualEvery from "./rules/manual-every";
+import manualIncludes from "./rules/manual-includes";
+import cognitiveComplexity from "./rules/cognitive-complexity";
+import floatComparison from "./rules/float-comparison";
+import needlessRangeLoop from "./rules/needless-range-loop";
+import manualSwap from "./rules/manual-swap";
+import searchIsSome from "./rules/search-is-some";
+import letAndReturn from "./rules/let-and-return";
+import xorUsedAsPow from "./rules/xor-used-as-pow";
+import mapIdentity from "./rules/map-identity";
+import redundantClosureCall from "./rules/redundant-closure-call";
+import almostSwapped from "./rules/almost-swapped";
+import ifSameThenElse from "./rules/if-same-then-else";
+import neverLoop from "./rules/never-loop";
+import explicitCounterLoop from "./rules/explicit-counter-loop";
+import excessiveNesting from "./rules/excessive-nesting";
+import fnParamsExcessiveBools from "./rules/fn-params-excessive-bools";
+import floatEqualityWithoutAbs from "./rules/float-equality-without-abs";
+import manualIsFinite from "./rules/manual-is-finite";
+import unnecessaryFold from "./rules/unnecessary-fold";
+import needlessLateInit from "./rules/needless-late-init";
+import singleElementLoop from "./rules/single-element-loop";
+import intPlusOne from "./rules/int-plus-one";
+import zeroDividedByZero from "./rules/zero-divided-by-zero";
+import redundantClosure from "./rules/redundant-closure";
+import unnecessaryReduceCollect from "./rules/unnecessary-reduce-collect";
+import preferStructuredClone from "./rules/prefer-structured-clone";
+import objectKeysValues from "./rules/object-keys-values";
+import promiseNewResolve from "./rules/promise-new-resolve";
+import similarNames from "./rules/similar-names";
+import matchSameArms from "./rules/match-same-arms";
+import usedUnderscoreBinding from "./rules/used-underscore-binding";
+import needlessContinue from "./rules/needless-continue";
+import enumVariantNames from "./rules/enum-variant-names";
+import structFieldNames from "./rules/struct-field-names";
+import unreadableLiteral from "./rules/unreadable-literal";
+import boolToIntWithIf from "./rules/bool-to-int-with-if";
+
+const plugin = {
+  meta: {
+    name: "oxclippy",
+    version: "0.1.0",
+  },
+  rules: {
+    // Style — code clarity and readability
+    "needless-bool": needlessBool,
+    "collapsible-if": collapsibleIf,
+    "neg-multiply": negMultiply,
+    "bool-comparison": boolComparison,
+    "single-case-switch": singleCaseSwitch,
+    "let-and-return": letAndReturn,
+    "int-plus-one": intPlusOne,
+    "needless-late-init": needlessLateInit,
+
+    // Complexity — simplifiable patterns
+    "identity-op": identityOp,
+    "manual-clamp": manualClamp,
+    "manual-strip": manualStrip,
+    "useless-conversion": uselessConversion,
+    "manual-swap": manualSwap,
+    "manual-is-finite": manualIsFinite,
+
+    // Correctness — likely bugs
+    "float-comparison": floatComparison,
+    "xor-used-as-pow": xorUsedAsPow,
+    "almost-swapped": almostSwapped,
+    "if-same-then-else": ifSameThenElse,
+    "never-loop": neverLoop,
+    "float-equality-without-abs": floatEqualityWithoutAbs,
+    "zero-divided-by-zero": zeroDividedByZero,
+
+    // Iterator — loops replaceable with array methods
+    "filter-then-first": filterThenFirst,
+    "map-void-return": mapVoidReturn,
+    "map-identity": mapIdentity,
+    "manual-find": manualFind,
+    "manual-some": manualSome,
+    "manual-every": manualEvery,
+    "manual-includes": manualIncludes,
+    "search-is-some": searchIsSome,
+    "needless-range-loop": needlessRangeLoop,
+    "redundant-closure-call": redundantClosureCall,
+    "explicit-counter-loop": explicitCounterLoop,
+    "unnecessary-fold": unnecessaryFold,
+    "single-element-loop": singleElementLoop,
+
+    // Functions — function-level quality
+    "too-many-arguments": tooManyArguments,
+    "too-many-lines": tooManyLines,
+    "cognitive-complexity": cognitiveComplexity,
+    "excessive-nesting": excessiveNesting,
+    "fn-params-excessive-bools": fnParamsExcessiveBools,
+
+    // Principles — idiomatic JS/TS from Clippy philosophy
+    "redundant-closure": redundantClosure,
+    "unnecessary-reduce-collect": unnecessaryReduceCollect,
+    "prefer-structured-clone": preferStructuredClone,
+    "object-keys-values": objectKeysValues,
+    "promise-new-resolve": promiseNewResolve,
+
+    // Pedantic — naming, style, readability
+    "similar-names": similarNames,
+    "match-same-arms": matchSameArms,
+    "used-underscore-binding": usedUnderscoreBinding,
+    "needless-continue": needlessContinue,
+    "enum-variant-names": enumVariantNames,
+    "struct-field-names": structFieldNames,
+    "unreadable-literal": unreadableLiteral,
+    "bool-to-int-with-if": boolToIntWithIf,
+  },
+};
+
+export default plugin;

package/src/rules/almost-swapped.ts

@@ -0,0 +1,52 @@
+// clippy::almost_swapped — broken swap: a = b; b = a; (original a is lost)
+// Detects: consecutive assignments that look like a swap but forgot the temp variable.
+
+import type { Context, Node } from "../types";
+
+function assignTarget(node: Node): string | null {
+  if (node.type !== "ExpressionStatement") return null;
+  const expr = node.expression;
+  if (expr.type !== "AssignmentExpression" || expr.operator !== "=") return null;
+  if (expr.left.type === "Identifier") return expr.left.name;
+  return null;
+}
+
+function assignSource(node: Node): string | null {
+  if (node.type !== "ExpressionStatement") return null;
+  const expr = node.expression;
+  if (expr.type !== "AssignmentExpression" || expr.operator !== "=") return null;
+  if (expr.right.type === "Identifier") return expr.right.name;
+  return null;
+}
+
+function checkBody(body: Node[], context: Context) {
+  for (let i = 0; i < body.length - 1; i++) {
+    const s1 = body[i]!;
+    const s2 = body[i + 1]!;
+
+    const t1 = assignTarget(s1);
+    const src1 = assignSource(s1);
+    const t2 = assignTarget(s2);
+    const src2 = assignSource(s2);
+
+    if (t1 && src1 && t2 && src2 && t1 === src2 && t2 === src1 && t1 !== t2) {
+      context.report({
+        message: `Almost swapped: \`${t1} = ${src1}; ${t2} = ${src2};\` overwrites \`${t1}\` before saving it. Use \`[${t1}, ${t2}] = [${t2}, ${t1}]\`. (clippy::almost_swapped)`,
+        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/bool-comparison.ts

@@ -0,0 +1,38 @@
+// clippy::bool_comparison — explicit comparison to boolean literals
+// Detects: x === true → x, x === false → !x, x !== true → !x, x !== false → x
+// NOT covered by oxlint's built-in rules (no-unnecessary-boolean-literal-compare is not in oxlint)
+
+import type { Context, Node } from "../types";
+import { isBoolLiteral } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      BinaryExpression(node: Node) {
+        if (node.operator !== "===" && node.operator !== "!==") return;
+
+        const leftBool = isBoolLiteral(node.left);
+        const rightBool = isBoolLiteral(node.right);
+
+        if (!leftBool && !rightBool) return;
+        // Skip if both sides are bool literals (that's a different issue)
+        if (leftBool && rightBool) return;
+
+        const boolVal = leftBool ? node.left.value : node.right.value;
+        const isEqual = node.operator === "===";
+
+        let suggestion: string;
+        if ((boolVal && isEqual) || (!boolVal && !isEqual)) {
+          suggestion = "use the expression directly";
+        } else {
+          suggestion = "negate the expression with `!`";
+        }
+
+        context.report({
+          message: `Bool comparison: comparison to \`${boolVal}\` is needless. Instead, ${suggestion}. (clippy::bool_comparison)`,
+          node,
+        });
+      },
+    };
+  },
+};

package/src/rules/bool-to-int-with-if.ts

@@ -0,0 +1,30 @@
+// clippy::bool_to_int_with_if — converting a boolean to 0/1 with a ternary or if/else
+// Detects: cond ? 1 : 0 → +cond or Number(cond)
+// Detects: cond ? 0 : 1 → +!cond or Number(!cond)
+
+import type { Context, Node } from "../types";
+import { isLiteral } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      ConditionalExpression(node: Node) {
+        const { consequent, alternate } = node;
+
+        if (isLiteral(consequent, 1) && isLiteral(alternate, 0)) {
+          context.report({
+            message:
+              "Bool to int with if: `cond ? 1 : 0` can be simplified to `Number(cond)` or `+cond`. (clippy::bool_to_int_with_if)",
+            node,
+          });
+        } else if (isLiteral(consequent, 0) && isLiteral(alternate, 1)) {
+          context.report({
+            message:
+              "Bool to int with if: `cond ? 0 : 1` can be simplified to `Number(!cond)` or `+!cond`. (clippy::bool_to_int_with_if)",
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/cognitive-complexity.ts

@@ -0,0 +1,137 @@
+// clippy::cognitive_complexity — function exceeds complexity threshold
+// Uses a simplified cognitive complexity model:
+// - +1 for each: if, else if, else, for, for-in, for-of, while, do-while, catch, ternary (?:)
+// - +1 for each: &&, || (logical operators)
+// - +1 nesting bonus per level of nesting for control flow
+// Default threshold: 25 (matches Clippy)
+
+import type { Context, Node } from "../types";
+
+const THRESHOLD = 25;
+
+function calculateComplexity(node: Node): number {
+  let complexity = 0;
+
+  function walk(n: Node, nesting: number) {
+    if (!n || typeof n !== "object") return;
+
+    switch (n.type) {
+      case "IfStatement":
+        complexity += 1 + nesting;
+        walk(n.test, nesting);
+        walk(n.consequent, nesting + 1);
+        if (n.alternate) {
+          if (n.alternate.type === "IfStatement") {
+            // else if: +1 but no nesting increase
+            complexity += 1;
+            walk(n.alternate.test, nesting);
+            walk(n.alternate.consequent, nesting + 1);
+            if (n.alternate.alternate) {
+              walk(n.alternate.alternate, nesting);
+            }
+          } else {
+            // else: +1
+            complexity += 1;
+            walk(n.alternate, nesting + 1);
+          }
+        }
+        return; // handled children manually
+
+      case "ForStatement":
+      case "ForInStatement":
+      case "ForOfStatement":
+      case "WhileStatement":
+      case "DoWhileStatement":
+        complexity += 1 + nesting;
+        walkChildren(n, nesting + 1);
+        return;
+
+      case "CatchClause":
+        complexity += 1 + nesting;
+        walkChildren(n, nesting + 1);
+        return;
+
+      case "SwitchStatement":
+        complexity += 1 + nesting;
+        walkChildren(n, nesting + 1);
+        return;
+
+      case "ConditionalExpression":
+        complexity += 1 + nesting;
+        walk(n.test, nesting);
+        walk(n.consequent, nesting + 1);
+        walk(n.alternate, nesting + 1);
+        return;
+
+      case "LogicalExpression":
+        // Each && or || adds 1 (no nesting bonus for these)
+        complexity += 1;
+        walk(n.left, nesting);
+        walk(n.right, nesting);
+        return;
+
+      // Don't recurse into nested function declarations/expressions
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        return;
+    }
+
+    walkChildren(n, nesting);
+  }
+
+  function walkChildren(n: Node, nesting: number) {
+    for (const key of Object.keys(n)) {
+      if (key === "type" || key === "loc" || key === "range" || key === "parent") continue;
+      const val = n[key];
+      if (Array.isArray(val)) {
+        for (const child of val) {
+          if (child && typeof child === "object" && child.type) {
+            walk(child, nesting);
+          }
+        }
+      } else if (val && typeof val === "object" && val.type) {
+        walk(val, nesting);
+      }
+    }
+  }
+
+  // Start walking from the function body
+  if (node.body) {
+    if (node.body.type === "BlockStatement") {
+      for (const stmt of node.body.body) {
+        walk(stmt, 0);
+      }
+    } else {
+      // Arrow function with expression body
+      walk(node.body, 0);
+    }
+  }
+
+  return complexity;
+}
+
+export default {
+  create(context: Context) {
+    function checkFunction(node: Node) {
+      const complexity = calculateComplexity(node);
+      if (complexity <= THRESHOLD) return;
+
+      const name =
+        node.id?.name ??
+        (node.parent?.type === "VariableDeclarator" ? node.parent.id?.name : null) ??
+        "<anonymous>";
+
+      context.report({
+        message: `Cognitive complexity: \`${name}\` has a complexity of ${complexity} (max ${THRESHOLD}). Consider refactoring into smaller functions. (clippy::cognitive_complexity)`,
+        node,
+      });
+    }
+
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction,
+    };
+  },
+};

package/src/rules/collapsible-if.ts

@@ -0,0 +1,38 @@
+// clippy::collapsible_if — nested ifs that can be merged with &&
+// Detects: if (a) { if (b) { ... } } → if (a && b) { ... }
+// NOT covered by eslint/no-lonely-if (which only catches else { if })
+
+import type { Context, Node } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      IfStatement(node: Node) {
+        // Only applies when outer if has no else
+        if (node.alternate) return;
+
+        const body = node.consequent;
+        if (!body) return;
+
+        // Get the single statement inside the consequent block
+        let inner: Node | null = null;
+        if (body.type === "BlockStatement" && body.body.length === 1) {
+          inner = body.body[0];
+        } else if (body.type === "IfStatement") {
+          inner = body;
+        }
+
+        if (!inner || inner.type !== "IfStatement") return;
+
+        // Inner if must also have no else
+        if (inner.alternate) return;
+
+        context.report({
+          message:
+            "Collapsible if: these nested ifs can be combined with `&&`. (clippy::collapsible_if)",
+          node,
+        });
+      },
+    };
+  },
+};

package/src/rules/enum-variant-names.ts

@@ -0,0 +1,45 @@
+// clippy::enum_variant_names — TS enum members with redundant prefix or suffix
+// Detects: enum Color { ColorRed, ColorGreen, ColorBlue } — "Color" prefix is redundant
+// Also: enum Status { StatusActive, StatusInactive } — all share the enum name as prefix
+
+import type { Context, Node } from "../types";
+
+export default {
+  create(context: Context) {
+    return {
+      TSEnumDeclaration(node: Node) {
+        const enumName = node.id?.name;
+        if (!enumName) return;
+        const members: Node[] = node.members ?? node.body?.members;
+        if (!members || members.length < 2) return;
+
+        const names: string[] = members
+          .map((m: Node) => (m.id?.type === "Identifier" ? m.id.name : null))
+          .filter((n: string | null): n is string => n !== null);
+
+        if (names.length < 2) return;
+
+        const lowerEnum = enumName.toLowerCase();
+
+        // Check prefix: all members start with the enum name
+        const allPrefixed = names.every((n) => n.toLowerCase().startsWith(lowerEnum));
+        if (allPrefixed) {
+          context.report({
+            message: `Enum variant names: all members of \`${enumName}\` are prefixed with \`${enumName}\`. Remove the redundant prefix. (clippy::enum_variant_names)`,
+            node,
+          });
+          return;
+        }
+
+        // Check suffix: all members end with the enum name
+        const allSuffixed = names.every((n) => n.toLowerCase().endsWith(lowerEnum));
+        if (allSuffixed) {
+          context.report({
+            message: `Enum variant names: all members of \`${enumName}\` are suffixed with \`${enumName}\`. Remove the redundant suffix. (clippy::enum_variant_names)`,
+            node,
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/excessive-nesting.ts

@@ -0,0 +1,84 @@
+// clippy::excessive_nesting — code nested beyond a threshold
+// Default threshold: 5 levels
+
+import type { Context, Node } from "../types";
+
+const THRESHOLD = 5;
+
+const NESTING_NODES = new Set([
+  "IfStatement",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "WhileStatement",
+  "DoWhileStatement",
+  "SwitchStatement",
+  "TryStatement",
+]);
+
+export default {
+  create(context: Context) {
+    let reported = false;
+
+    function walk(node: Node, depth: number) {
+      if (!node || typeof node !== "object" || !node.type) return;
+      if (reported) return;
+
+      const isNesting = NESTING_NODES.has(node.type);
+      const newDepth = isNesting ? depth + 1 : depth;
+
+      if (newDepth > THRESHOLD && isNesting) {
+        reported = true;
+        context.report({
+          message: `Excessive nesting: this code is nested ${newDepth} levels deep (max ${THRESHOLD}). Consider extracting into helper functions. (clippy::excessive_nesting)`,
+          node,
+        });
+        return;
+      }
+
+      // Don't recurse into nested functions
+      if (
+        node.type === "FunctionDeclaration" ||
+        node.type === "FunctionExpression" ||
+        node.type === "ArrowFunctionExpression"
+      ) {
+        if (depth > 0) return; // only skip nested functions, not the top-level one
+      }
+
+      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) walk(child, newDepth);
+          }
+        } else if (val && typeof val === "object" && val.type) {
+          walk(val, newDepth);
+        }
+      }
+    }
+
+    return {
+      FunctionDeclaration(node: Node) {
+        reported = false;
+        walk(node.body, 0);
+      },
+      FunctionExpression(node: Node) {
+        reported = false;
+        walk(node.body, 0);
+      },
+      ArrowFunctionExpression(node: Node) {
+        reported = false;
+        walk(node.body, 0);
+      },
+    };
+  },
+};

package/src/rules/explicit-counter-loop.ts

@@ -0,0 +1,66 @@
+// clippy::explicit_counter_loop — manual counter variable with for-of
+// Detects: let i = 0; for (const x of arr) { ...i...; i++; }
+// Suggests: for (const [i, x] of arr.entries())
+
+import type { Context, Node } from "../types";
+import { getFunctionBody, getForOfVar } from "../types";
+
+function checkBody(body: Node[], context: Context) {
+  for (let i = 0; i < body.length - 1; i++) {
+    const decl = body[i]!;
+    const loop = body[i + 1]!;
+
+    // decl: let counter = 0;
+    if (decl.type !== "VariableDeclaration" || decl.declarations.length !== 1) continue;
+    const d = decl.declarations[0]!;
+    if (d.id?.type !== "Identifier" || d.init?.type !== "Literal" || d.init.value !== 0) continue;
+    const counterName = d.id.name;
+
+    // loop: for (const x of arr) { ... counter++; }
+    if (loop.type !== "ForOfStatement") continue;
+    if (loop.body?.type !== "BlockStatement" || loop.body.body.length === 0) continue;
+
+    const stmts: Node[] = loop.body.body;
+    const last = stmts[stmts.length - 1]!;
+
+    // Check last statement is counter++ or counter += 1
+    const isIncrement =
+      (last.type === "ExpressionStatement" &&
+        last.expression?.type === "UpdateExpression" &&
+        last.expression.operator === "++" &&
+        last.expression.argument?.type === "Identifier" &&
+        last.expression.argument.name === counterName) ||
+      (last.type === "ExpressionStatement" &&
+        last.expression?.type === "AssignmentExpression" &&
+        last.expression.operator === "+=" &&
+        last.expression.left?.type === "Identifier" &&
+        last.expression.left.name === counterName &&
+        last.expression.right?.type === "Literal" &&
+        last.expression.right.value === 1);
+
+    if (isIncrement) {
+      context.report({
+        message: `Explicit counter loop: manual counter \`${counterName}\` can be replaced with \`for (const [${counterName}, item] of arr.entries())\`. (clippy::explicit_counter_loop)`,
+        node: loop,
+      });
+    }
+  }
+}
+
+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,
+      Program(node: Node) {
+        if (node.body) checkBody(node.body, context);
+      },
+    };
+  },
+};