Calls such as `(x ? a(y) : 0, y)` and `(x && a(y), y)` consume `a` even though their results are discarded. Track that consumption through surrounding expressions, resetting at function boundaries so discarded self-referencing closures remain unused, matching ESLint.
Addresses report 1 (`eslint/no-unused-vars`) in #27746.
Calls such as `if (a && s.match(/x/))` and `if (s.match(/x/) || a)` were skipped even though their results are only tested for truthiness. Follow `&&`/`||` operands to the enclosing boolean context, matching Unicorn, while preserving value-producing uses and nullish expressions. Add diagnostic and autofix regressions for `.match()` and `.exec()`.
Addresses report 9 (`unicorn/prefer-regexp-test`) in #27746.
Methods such as `t(errors = this.errors) { return errors; }` and fields such as `f = (x = this.y) => x` were reported despite using `this` in their defaults. Visit parameters with the existing `ThisFinder` to match ESLint while preserving nested function boundaries.
Addresses report 2 (`eslint/class-methods-use-this`) in #27746.
Report assignments such as `function f(...args) { args = []; }`, matching ESLint. Rest parameters now use the same reference and property checks as regular parameters, with regression coverage for destructuring, nested scopes, and property-ignore options.
Addresses #27746, report 11 (`eslint/no-param-reassign`).
Unwrap parentheses when identifying type checks so `!(x instanceof Y)` and `!(typeof x === "string")` report `throw new Error(...)` and fix it to `TypeError`, matching Unicorn. Includes regressions for nested conditions and both autofixes.
Addresses report 16 (`unicorn/prefer-type-error`) in #27746.
Match Unicorn by exempting only the exact unused name `_`. Unused `_err` and `__` are now reported and renamed in catch clauses and promise rejection handlers. Regression tests preserve the `_` exemption and configured names/ignore patterns.
Addresses report 15 (`unicorn/catch-error-name`) in #27746.
Match Unicorn by ignoring call expressions passed as callbacks, including `arr.forEach(make(x))` and `arr.map(make(x))`. Suggesting an arrow wrapper would run the factory once per element instead of once per array method call.
Addresses report 4 (`unicorn/no-array-callback-reference`) in #27746.
Count rest parameters toward the limit for functions, arrows, and TypeScript function types, matching ESLint. For example, `function f(a, b, c, ...rest) {}` now reports four parameters with the default maximum of three.
Addresses report 12 (`eslint/max-params`) in #27746.
Move inline `oxc_ast::…` references into module-level imports throughout `oxc_linter`, reusing existing imports where available. This replaces 133 qualified paths across 56 files without changing lint behavior.
Validated after rebasing with crate-wide tests (1,289 passed), Clippy, and formatting. Three parallel reviewers found no issues in the import refactor.
AI assistance: implemented and reviewed with Codex.
Track function parameter bindings so `function f(p) { p = 5; p = 6; return p; }` reports `p = 5`, matching ESLint. This also covers defaulted, destructured, and rest parameters.
Keep writes during parameter initialization excluded: the CFG does not model skipped defaults or their destructuring evaluation order reliably. Reads in defaults still count as uses.
Fixes#27720
Oxlint currently allows descriptor setters such as `Object.defineProperty(o, "x", { set: value => value })`, while ESLint reports the returned value.
Recognize setters passed to `Object.defineProperty`, `Reflect.defineProperty`, `Object.defineProperties`, and `Object.create`, including concise arrows. Check argument positions and global bindings, preserve nested-function boundaries, and enable the upstream descriptor tests with additional regression coverage.
Addresses report 1 (`eslint/no-setter-return`) in #27710.
`id-length` missed identifiers used as destructuring assignment targets,
including `[q] = values` and `for ([ix, s] of values) {}`. Check array
and object targets, defaults, and rest elements, matching ESLint
10.12.0.
Preserve `properties: "never"` exemptions and report the key when an
explicit object property's key and target share a name, including
parenthesized computed keys. Regression tests cover assignment targets,
exempt reads, and diagnostic locations.
Part of #27710 (report 3).
---------
Co-authored-by: Cameron Clark <cameron.clark@hey.com>
Treat a function's reference to its own variable binding as a parent-scope capture, matching eslint-plugin-unicorn. For example, a nested `const builder = (...args) => builder.apply(null, args)` was incorrectly reported as movable even though it captures `builder` from the enclosing scope.
Limit the recursion exemption to function-name symbols. Add regression cases for arrow functions, anonymous and named function expressions, parameter defaults, and `var` bindings, while retaining warnings for internal function-name recursion and shadowed parameters.
Addresses report 5 (`unicorn/consistent-function-scoping`) in #27710.
Makes the `Formatter` a concrete type that writes into one element stack, instead of writing through `&mut dyn Buffer` into separate buffers.
### Before
- `Formatter` held a `&mut dyn Buffer`, so every element write was a virtual call.
- There were 4 `Buffer` implementations, one per use:
- `VecBuffer`: the root document, written directly into the arena.
- `HeapVecBuffer`: nested staging (`intern`, best fitting variants), a watermarked view of a shared heap vector, copied into the arena one element at a time (`from_iter_in`).
- `AccumulatorBuffer`: writes into a `ScratchBuffer`'s heap vector (JSX children, assignment left-hand sides).
- `RemoveSoftLinesBuffer`: a wrapper buffer for `remove_soft_lines`.
### After
- `Formatter { state, start, soft_lines }` is concrete.
- A write is a `push_fast` that inlines into the builders.
- `FormatState` owns one element stack in the arena:
- The root formatter writes at the bottom.
- `into_vec` returns the vector as is, so the document needs no copy (same as `VecBuffer`).
- Nested formatters write past their parent's elements. They are taken off as one
exactly-sized bulk copy.
- `ScratchBuffer::write(f, |f| ..)` writes past the stack, then moves the elements into its heap vector.
- `remove_soft_lines` is a mode of `Formatter`, kept off the hot path (`#[cold]`).
- Removed: `VecBuffer`, `HeapVecr`, `RemoveSoftLinesBuffer`.
- Entry points change from `VecBuffer::new` / `with_capacity` to `Formatter::new` / `with_capacity` + `into_vec`.
monitor-oxc's Test262 job fails on every run because `cargo coverage
runtime` no longer matches `runtime.snap`. The runtime suite skips the
cases V8's `test262.status` lists as failing, and it fetches that file
from V8's `main` branch at run time. On 2026-10-09 V8 landed
`03af3c3548` ("[scopes] Reject var arguments in parameter eval") and
removed the 88 `language/eval-code/direct/*declare-arguments*` entries.
Node 26.5 bundles V8 14.6.202, which predates that fix, so those 88
cases now run and fail with `Expected a SyntaxError to be thrown`.
The skip list exists to hide bugs of the engine that executes the cases,
and that engine is Node's V8, not V8 `main`. `main` is wrong in both
directions: it un-skips cases V8 fixed after Node's branch cut, and it
skips 236 entries for test262 files newer than the pinned checkout.
The list is now fetched at the V8 version reported by `node -p
process.versions.v8` (`14.6.202.34`, which V8 tags on GitHub), falling
back to `main` only when that tag does not exist. The gitignored cache
file carries the version in its name so a Node bump cannot serve a stale
list.
With the pinned list the snapshot only changes when the test262 pin or
`.node-version` moves. Regenerated against Node 26.5.0 it adds nothing
and drops: four `delete/super-property-uninitialized-this` cases that V8
fixed upstream after 14.6, the `typeof/symbol.js` timeout, and the two
`bigint-and-number-extremes` minify cases that #27656 fixed (the regular
CI does not run the runtime suite, so that PR could not update the
snapshot):
| skip list | cases | passed | new failures |
| --- | --- | --- | --- |
| V8 `main` today | 18369 | 17307 | 88 |
| V8 `14.6.202.34` | 18277 | 17306 | 0 |
Written with Claude Code; reviewed and tested by me.
add missing de morgan law optimizations in context of void expression
`(!a || b === c) && b()` -> `a && b !== c || b()`
limitations: due to how nodes are processed, currently simple rewrites
like `!a || b()` are not rewritten to `a && b()` and follow same
limitations as optimizations of `not unary expression`
#27642 added an aarch64 Neon implementation of `classify`. So now we have 3 implementations.
Add a CI job to test and lint the Neon implementation on a Linux aarch64 runner on PRs which touch `oxc_lexer` crate.
#27642 added an aarch64 Neon implementation of `classify`. So now we have 2 SIMD implementations. This makes the previous output "Lexer implementation: SIMD" / "Lexer implementation: scalar" ambiguous - which SIMD?
Fix that, and also update some comments to match.
`unicorn/catch-error-name` could rename a parameter to an existing binding, producing invalid syntax or capturing another variable. The fixer now appends underscores until the configured name is available in the parameter's scope and every scope where it is referenced, and avoids capturing unresolved references in its body. Diagnostics show the selected name.
Adds regressions for both reported examples, unused catch parameters, nested references, globals, promise callbacks, configured names, and repeated suffix collisions. Generated names are also accepted when the configured name already ends in an underscore.
Fixes#27700.
TypeScript config load errors currently advertise `^20.19.0 || >=22.18.0`, even though Node 20 cannot load TypeScript files natively. Remove the Node 20 range from the shared Oxlint/Oxfmt diagnostic and the matching TypeScript plugin documentation, including generated schema, declarations, and website snapshot. Package engine requirements stay the same.
Fixes#27678
leaysgur
Cam McHenry
Boshen
camc314
Yunus OzenandCameron Clark
Armano
Dunqing
overlookmotel