Skip to content

perf(linter): remove unnecessary Vec collect in CFG edge traversal#22167

Merged
graphite-app[bot] merged 1 commit into
mainfrom
perf/cfg-collect-removal
May 6, 2026
Merged

perf(linter): remove unnecessary Vec collect in CFG edge traversal#22167
graphite-app[bot] merged 1 commit into
mainfrom
perf/cfg-collect-removal

Conversation

@connorshea

@connorshea connorshea commented May 6, 2026

Copy link
Copy Markdown
Member

Same idea as #22166, the pattern was reused elsewhere so this fixes those as well. Benchmarked and the change is at worst neutral, at best a decent improvement for these code paths, and pretty consistently saves allocations.

Claude's description is below.


Summary

Remove unnecessary .collect::<Vec<_>>() in CFG DFS traversals for three linter rules:

  • promise/always-return
  • promise/no-multiple-resolved
  • vue/return-in-computed-property

Same optimization as #22166 (getter-return). In all cases, graph.edges_connecting(a, b) was collected into a Vec just to call .iter().any() or iterate with for. Since edges_connecting returns a cheap iterator over the adjacency list, the Vec allocation is pure overhead — and it fires on every TreeEdge during DFS, making it the hottest allocation in these rules.

The pattern was introduced in the first CFG-based rule and copy-pasted into the others without deliberate reason (confirmed via git blame — all four sites were present from initial implementation).

Benchmark results

Paired interleaved benchmarks (N=60, alternating execution order, parse-only control).

Wall-clock (paired analysis)

Rule Baseline mean Optimized mean Rule-attributable delta t-stat Win/Loss
always-return 12.12 ms 11.99 ms 0.050 ms 0.88 38/22
no-multiple-resolved 283.36 ms 281.00 ms 2.262 ms 2.03 36/24
  • no-multiple-resolved shows a borderline-significant improvement (t=2.03, threshold ~2.0), with a clean parse-only control (t=0.63).
  • always-return is too cheap (~2ms rule cost) for the improvement to register at binary level, but the allocation reduction is real.
  • return-in-computed-property was not benchmarked (Vue-only rule requiring .vue file fixtures), but uses the identical pattern.

Memory (counting global allocator, rule-attributable = total minus parse-only)

Rule Metric Baseline Optimized Saved % reduction
always-return alloc count 66,045 60,045 6,000 9.1%
alloc bytes 6,115,232 5,539,251 575,981 (563 KB) 9.4%
no-multiple-resolved alloc count 183,041 171,041 12,000 6.6%
alloc bytes 13,159,807 12,007,826 1,151,981 (1.1 MB) 8.8%

For reference, the same fix on getter-return (#22166) eliminated 77,300 allocations and 7.1 MB of heap churn (72.7% reduction in rule-attributable allocations).

All fixtures use ~3,000 instances of the pattern each rule checks (promise .then() callbacks, new Promise constructors, getter definitions).

Test plan

  • All three rules' tests pass (cargo test -p oxc_linter)
  • Behavioral parity confirmed (identical --format=json output between baseline and optimized binaries)
  • Parse-only controls confirm no binary-layout effects

🤖 Generated with Claude Code

@github-actions github-actions Bot added the A-linter Area - Linter label May 6, 2026
@connorshea connorshea marked this pull request as ready for review May 6, 2026 03:47
@connorshea connorshea requested a review from camc314 as a code owner May 6, 2026 03:47
Copilot AI review requested due to automatic review settings May 6, 2026 03:47

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Pull request overview

This PR optimizes several CFG DFS traversal hot paths in the linter by removing unnecessary collect::<Vec<_>>() allocations when inspecting edges between CFG nodes, reducing heap churn during rule execution.

Changes:

  • Replace edges_connecting(...).collect::<Vec<_>>() + iter() usage with direct iterator traversal for any() checks.
  • Remove Vec allocation in no-multiple-resolved and iterate edges_connecting directly.
  • Apply the same optimization pattern across the Vue and Promise CFG-based rules mentioned in the PR description.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 1 comment.

File Description
crates/oxc_linter/src/rules/vue/return_in_computed_property.rs Removes per-DFS-edge Vec allocation by calling .any() directly on edges_connecting.
crates/oxc_linter/src/rules/promise/no_multiple_resolved.rs Removes Vec allocation; switches to direct iteration/.any() over edges_connecting.
crates/oxc_linter/src/rules/promise/always_return.rs Removes per-DFS-edge Vec allocation by calling .any() directly on edges_connecting.

Comment thread crates/oxc_linter/src/rules/promise/no_multiple_resolved.rs
@codspeed-hq

codspeed-hq Bot commented May 6, 2026

Copy link
Copy Markdown

Merging this PR will not alter performance

✅ 4 untouched benchmarks
⏩ 47 skipped benchmarks1


Comparing perf/cfg-collect-removal (94a6e5b) with main (c9ce045)

Open in CodSpeed

Footnotes

  1. 47 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports.

@camchenry camchenry left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🚀

@camchenry camchenry added the 0-merge Merge with Graphite Merge Queue label May 6, 2026

camchenry commented May 6, 2026

Copy link
Copy Markdown
Member

Merge activity

@connorshea connorshea force-pushed the perf/cfg-collect-removal branch from 94a6e5b to c833d35 Compare May 6, 2026 04:24
…22167)

Same idea as #22166, the pattern was reused elsewhere so this fixes those as well. Benchmarked and the change is at worst neutral, at best a decent improvement for these code paths, and pretty consistently saves allocations.

Claude's description is below.

---

## Summary

Remove unnecessary `.collect::<Vec<_>>()` in CFG DFS traversals for three linter rules:

- `promise/always-return`
- `promise/no-multiple-resolved`
- `vue/return-in-computed-property`

Same optimization as #22166 (`getter-return`). In all cases, `graph.edges_connecting(a, b)` was collected into a `Vec` just to call `.iter().any()` or iterate with `for`. Since `edges_connecting` returns a cheap iterator over the adjacency list, the Vec allocation is pure overhead — and it fires on every `TreeEdge` during DFS, making it the hottest allocation in these rules.

The pattern was introduced in the first CFG-based rule and copy-pasted into the others without deliberate reason (confirmed via git blame — all four sites were present from initial implementation).

## Benchmark results

Paired interleaved benchmarks (N=60, alternating execution order, parse-only control).

### Wall-clock (paired analysis)

| Rule | Baseline mean | Optimized mean | Rule-attributable delta | t-stat | Win/Loss |
|---|---|---|---|---|---|
| `always-return` | 12.12 ms | 11.99 ms | 0.050 ms | 0.88 | 38/22 |
| `no-multiple-resolved` | 283.36 ms | 281.00 ms | 2.262 ms | 2.03 | 36/24 |

- `no-multiple-resolved` shows a borderline-significant improvement (t=2.03, threshold ~2.0), with a clean parse-only control (t=0.63).
- `always-return` is too cheap (~2ms rule cost) for the improvement to register at binary level, but the allocation reduction is real.
- `return-in-computed-property` was not benchmarked (Vue-only rule requiring `.vue` file fixtures), but uses the identical pattern.

### Memory (counting global allocator, rule-attributable = total minus parse-only)

| Rule | Metric | Baseline | Optimized | Saved | % reduction |
|---|---|---|---|---|---|
| `always-return` | alloc count | 66,045 | 60,045 | **6,000** | 9.1% |
| | alloc bytes | 6,115,232 | 5,539,251 | **575,981 (563 KB)** | 9.4% |
| `no-multiple-resolved` | alloc count | 183,041 | 171,041 | **12,000** | 6.6% |
| | alloc bytes | 13,159,807 | 12,007,826 | **1,151,981 (1.1 MB)** | 8.8% |

For reference, the same fix on `getter-return` (#22166) eliminated **77,300 allocations and 7.1 MB** of heap churn (72.7% reduction in rule-attributable allocations).

All fixtures use ~3,000 instances of the pattern each rule checks (promise `.then()` callbacks, `new Promise` constructors, getter definitions).

## Test plan

- [x] All three rules' tests pass (`cargo test -p oxc_linter`)
- [x] Behavioral parity confirmed (identical `--format=json` output between baseline and optimized binaries)
- [x] Parse-only controls confirm no binary-layout effects

🤖 Generated with [Claude Code](https://claude.com/claude-code)
@graphite-app graphite-app Bot force-pushed the perf/cfg-collect-removal branch from c833d35 to 9551d53 Compare May 6, 2026 04:29
@graphite-app graphite-app Bot merged commit 9551d53 into main May 6, 2026
28 checks passed
@graphite-app graphite-app Bot removed the 0-merge Merge with Graphite Merge Queue label May 6, 2026
@graphite-app graphite-app Bot deleted the perf/cfg-collect-removal branch May 6, 2026 04:33
graphite-app Bot pushed a commit that referenced this pull request May 6, 2026
…h rfind (#22172)

Another minor optimization + code simplification. Claude's summary is below. As with all of these, the benchmark is based on running the rule on a file with a lot of specific code that isn't likely to occur in real codebases. So the % drops shouldn't be seen as representative of much beyond "this specific code path is faster".

---

## Summary

Two allocations per `@property` JSDoc tag with a dot — the `Vec<&str>` from `split + collect` and the `String` from `join(".")` — collapse to a single slice index using `rfind('.')`.

```rust
// before
if type_name.contains('.') {
    let mut parts = type_name.split('.').collect::<Vec<_>>();
    parts.pop();                                // `foo[].bar` -> `foo[]`
    let parent_name = parts.join(".");
    let parent_name = parent_name.trim_end_matches("[]");
    ...
}

// after
if let Some(dot_idx) = type_name.rfind('.') {
    let parent_name = type_name[..dot_idx].trim_end_matches("[]");  // `foo[].bar` -> `foo[]` -> `foo`
    ...
}
```

`rfind('.')` matches the last dot; the original `split + pop + join` reassembled all-but-the-last segment with `.` as the separator — equivalent.

Same family as #22164/#22166/#22167/#22168.

## Benchmark

Synthetic fixture: 30 JS files × 60 typedef blocks × 16 `@property` tags ≈ **28,800 tags**, ~80% with dots. Counting global allocator (system alloc, no mimalloc) on the rule-on and parse-only configs; rule-attributable = total − parse-only.

### Wall-clock (paired interleaved, N=60)

| | Baseline | Optimized | Δ |
|---|---|---|---|
| Rule ON | 21.564 ms | 20.550 ms | **−1.014 ms** |
| Parse-only | 7.319 ms | 7.326 ms | +0.007 ms (noise) |

- Paired t-stat: **5.02** (rule-on); **−0.05** (parse-only control)
- Win/Loss/Tie: **42 / 18 / 0**
- Parse-only is flat, so the delta isn't a binary-layout artifact.

### Allocations (rule-attributable)

| Metric | Baseline | Optimized | Saved | Reduction |
|---|---|---|---|---|
| Count | 318,002 | 282,603 | **35,399** | **11.1%** |
| Bytes | 30.7 MB | 29.4 MB | **1.32 MB** | **4.3%** |

Saves ~1.5 allocations per dotted tag on this fixture (Vec is sometimes elided when the path is `a.b`, but `String` from `join` always allocates).

## Test plan

- [x] `cargo test -p oxc_linter --lib jsdoc::check_property_names` — passes
- [x] `--format=json` parity confirmed across baseline and optimized binaries on the fixture (only `start_time` differs)
- [x] Parse-only control confirms no binary-layout effect (t = −0.05)
- [x] `just fmt` clean

🤖 Generated with [Claude Code](https://claude.com/claude-code)
camc314 added a commit that referenced this pull request May 11, 2026
# Oxlint
### 💥 BREAKING CHANGES

- 00ce512 oxlint/lsp: [**BREAKING**] Don't fix suggestions on fixAll
code actions & command (#22195) (Sysix)

### 🚀 Features

- 0eeceaf linter/no-unused-vars: Rename parameter with initializer
(#22308) (camc314)
- fa0232b linter/no-unused-vars: Add param rename suggestion (#22285)
(Ryota Misumi)
- ae59305 linter/promise/no-promise-in-callback: Add
`exemptDeclarations` option (#22275) (Mikhail Baev)
- 60bed4a linter: Extends `no-redundant-roles` and
`prefer-tag-over-role` support roles (#22069) (mehm8128)
- 545c80f linter/eslint: Implement `prefer-regex-literals` rule (#22192)
(Mikhail Baev)
- cf86d7a linter: Bulk suppression (#19328) (Said Atrahouch)
- 23abd22 linter/jsx-a11y: Implement
no-noninteractive-element-to-interactive-role (#21264) (Pedro Tainha)
- fbb8f22 linter: Support `ignores` in overrides (#22148) (camc314)
- 5a4414d oxlint/lsp: Support `rulesCustomization` lsp option (#21858)
(Sysix)

### 🐛 Bug Fixes

- 610f4c7 linter/no-unused-vars: Avoid renaming captured vars (#22310)
(camc314)
- 6b50f23 oxlint/cli: Load root config by searching up parent
directories (#22272) (Sysix)
- 31a5de7 linter: Rename override `ignores` to `excludeFiles` (#22283)
(camc314)
- 26d5d7b linter: Add missing vitest/valid-describe-callback
functionality (#22279) (camchenry)
- 784530f linter: `valid-title`: detect `String.raw` strings (#22271)
(Sysix)
- 080d90e linter: Move `no-debugger` fix to suggestion (#22256) (Sysix)
- 25b7017 linter: Undocument override `ignores` option (#22213)
(camc314)
- 7bb00dd linter: Fix role-has-required-aria-props (#22097) (mehm8128)
- d25279e linter/disable-directives: Improve parsing of names,
descriptions (#22184) (camc314)
- a59e447 linter/disable-directives: Ignore invalid enable suffixes
(#22179) (camc314)
- aafef0f ci: Disable bulk supression test on big endian (#22175)
(camc314)
- 281daec linter/vue/define-props-destructuring: Add
`only-when-assigned` config opt (#22142) (camc314)
- 46ab679 linter/plugins: Trim leading newline for partial sources
(#20928) (bab)
- 29ff6d9 linter: Update docs for no_alias_methods rule to be
Vitest-specific and add toThrowError alias (#22129) (camchenry)

### ⚡ Performance

- 9414bee linter/role-has-required-aria-props: Avoid intermediate vec
(#22212) (camc314)
- 3883ea3 linter/no-useless-escape: Drop unnecessary Vec collect
(#22171) (connorshea)
- 42c3029 linter/check-property-names: Replace split-collect-pop-join
with rfind (#22172) (connorshea)
- 9551d53 linter: Remove unnecessary Vec collect in CFG edge traversal
(#22167) (connorshea)
- 26fa2fc linter/aria-role: Remove unnecessary string allocations in run
method (#22168) (connorshea)
- c9ce045 linter/getter-return: Remove unnecessary Vec collect in CFG
edge traversal (#22166) (connorshea)
- 72bd846 linter/no-this-in-sfc: Reorder cheap name check, avoid String
allocation (#22164) (connorshea)

### 📚 Documentation

- 4da212a linter/no-unused-vars: Add docs to
`rename_unused_function_parameter` (#22311) (camc314)
- 27c4628 linter/forbid-dom-props: Escape jsx examples in lint rule docs
(#22254) (4MBL)
- 3f81147 linter: Improve the `react/jsx-key` rule docs. (#22162)
(connorshea)
- 07f03cc linter/consistent-return: Add note about `noImplicitReturns`
coverage (#22156) (camc314)
- 7c1e049 oxlint/lsp: Improve autogenerated lsp docs (#22154) (Sysix)
- 87b3e38 linter: Update docs to be vitest-specific for
consistent-test-it (#22128) (camchenry)
# Oxfmt
### 💥 BREAKING CHANGES

- 5c6c390 oxfmt: [**BREAKING**] Respect more git ignore options, align
with Oxlint (#22210) (leaysgur)

### 🚀 Features

- 6e8e818 oxfmt: Experimental .svelte support (#21700) (leaysgur)

### 🐛 Bug Fixes

- e2a20b6 formatter: Add space after commas in import attributes
(#22274) (Leonabcd123)

### ⚡ Performance

- b756682 oxfmt: Optimize nested config prescan (#22232) (Jovi De
Croock)
- f14e81e formatter/sort_imports: Skip sort for single import runs
(#22204) (leaysgur)
- 32255b1 formatter: Process `ImportDeclaration`s in a run (#22079)
(overlookmotel)

### 📚 Documentation

- 4da6f4c formatter: Correct comment (#22217) (overlookmotel)
- ef3507d formatter/sort_imports: Refresh docs (#22203) (leaysgur)

Co-authored-by: Cameron <cameron.clark@hey.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

A-linter Area - Linter

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants