fix(parser): allow nested destructured arrow functions inside ternary-consequent bodies

[Zelys-DFKH]

Fixes #10131.

The parser was rejecting valid code like this:

const handleClick = onClick
  ? (offset: number) =>
      ({ photo, index, event }: ClickHandlerProps<TPhoto>) => {
        onClick({ photos: photosArray, index: offset + index, photo, event });
      }
  : undefined;

parse_arrow_body uses parse_assignment_expression_or_higher_no_arrow when in_conditional_consequent is set and the body starts with ({ or ([. The guard is there for a real reason: in TypeScript mode, the ternary : can be misread as a return-type annotation, and the alternate's => gets consumed as the arrow, making a parenthesized object literal look like a valid arrow function.

The guard was too broad. It was blocking legitimate nested arrows along with the false positives it was meant to prevent.

Before falling back to _no_arrow, a new helper scans forward token by token (tracking paren depth) to find the closing ), then checks whether => follows immediately. If it does, the expression must be a nested arrow, so normal parsing is allowed. => only appears in arrow function syntax, which makes it a cleaner discriminator than checking : (TypeScript return-type annotations also produce :).

fn is_paren_group_followed_by_fat_arrow(p: &mut JsParser) -> bool {
    // tracks ( / ) depth so parens inside type annotations don't mislead
    ...
    return p.nth_at(offset + 1, T![=>]);
}

One pre-existing edge case stays unchanged from main: a nested arrow with both destructuring params and a return-type annotation, like ({x}: T): R => body, inside another arrow body in a ternary consequent. That's a separate problem and I kept scope narrow here.

Test plan

Added crates/biome_js_parser/tests/js_test_suite/ok/conditional_nested_arrow_in_consequent.ts and .js, covering:

• Object destructuring: (offset: number) => ({ photo, index, event }: ClickHandlerProps<TPhoto>) => { ... }
• Array destructuring: (n: number) => ([a, b]: [string, string]) => { ... }
• Existing behavior preserved: (i: number) => ({ [CONTENT_SLOT]: i }) still parses the body as a parenthesized object expression

All 688 parser spec tests pass.

Docs

No documentation changes needed.

[changeset-bot]

🦋 Changeset detected

Latest commit: 1db27bc

The changes in this PR will be included in the next version bump.

This PR includes changesets to release 13 packages

Name	Type
@biomejs/biome	Patch
@biomejs/cli-win32-x64	Patch
@biomejs/cli-win32-arm64	Patch
@biomejs/cli-darwin-x64	Patch
@biomejs/cli-darwin-arm64	Patch
@biomejs/cli-linux-x64	Patch
@biomejs/cli-linux-arm64	Patch
@biomejs/cli-linux-x64-musl	Patch
@biomejs/cli-linux-arm64-musl	Patch
@biomejs/wasm-web	Patch
@biomejs/wasm-bundler	Patch
@biomejs/wasm-nodejs	Patch
@biomejs/backend-jsonrpc	Patch

Not sure what this means? Click here to learn what changesets are.

Click here if you're a maintainer who wants to add another changeset to this PR

[coderabbitai]

Walkthrough

This PR fixes a parser regression where curried arrow functions with destructured parameters inside a ternary consequent were mis-parsed. It adds a lookahead that matches a parenthesised parameter group to check for a following =>, forces the ternary-consequent flag off when parsing arrow bodies, and suppresses speculative “no-arrow” parsing for ({ or ([ starts unless the group is actually followed by =>. A changeset and JS/TS regression tests were added.

Suggested reviewers

• dyc3

🚥 Pre-merge checks | ✅ 4

✅ Passed checks (4 passed)

Check name	Status	Explanation
Title check	✅ Passed	Title clearly and concisely describes the main fix: allowing nested destructured arrow functions inside ternary-consequent bodies, matching the core change.
Linked Issues check	✅ Passed	The PR fully addresses #10131 by implementing parser fixes [parser function.rs, changeset] to restore correct parsing of nested destructured arrow functions in ternary consequents and adding regression tests [.ts and .js fixtures].
Out of Scope Changes check	✅ Passed	All changes are tightly scoped to fixing the nested destructured arrow parsing issue; no unrelated modifications present.
Description check	✅ Passed	The PR description clearly explains the parsing bug, the root cause of the overly broad guard, and the solution using a token-level lookahead helper.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[dyc3]

nitpick: i think all the comments added in this pr are a bit hard to understand. they already include some abbreviated code samples, but maybe some more complete ones would help? idk, maybe i need sleep.

[dyc3]

what does "curried" mean in this context?

[Zelys-DFKH]

Sorry for the unclear comments — I've been writing a novel and apparently it's bleeding into my code reviews. Rewrote the function.rs comment blocks with concrete before/after code snippets instead of prose. Left the test fixture comments as-is to avoid touching the snapshots — happy to update those separately if you'd prefer a different description there. Ping me if anything's still off.

[codspeed-hq]

Merging this PR will not alter performance

✅ 58 untouched benchmarks
⏩ 196 skipped benchmarks¹

---

_{Comparing Zelys-DFKH:fix/parser-nested-destructured-arrow-ternary (1db27bc) with main (e94acb2)}

Footnotes

1. 196 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. ↩

[ematipico]

We usually want to add a small message with debug assertions. The message should be actionable, or try to be. The message should explain the error and hint at a possible solution (hence, actionable)