fix(deps): update module github.com/odvcencio/gotreesitter to v0.55.0

[renovate]

This PR contains the following updates:

Package	Change	Age	Confidence
github.com/odvcencio/gotreesitter	v0.53.0 → v0.55.0

---

Release Notes

odvcencio/gotreesitter (github.com/odvcencio/gotreesitter)

v0.55.0: gotreesitter v0.55.0

Compare Source

Added

• Add WithHighlighterAdmissionCandidateRoute to select the route for the
  document parser and injected parsers (#​1281).
• Add optional compact parser telemetry for peak frontier headers and derivations
  (#​1285).
  Locked C checks cover three fresh JSON trees and seven fresh CSV witnesses.
  One incremental edit per language also matches with subtree reuse.

Changed

• Give explicit process settings priority over the language admission allowlist.
  A parser override still has first priority. The allowlist now widens only
  the implicit default. This behavior change requires a minor release.
  Both SetAdmissionCandidateRouteDefault(false) and
  GTS_ADMISSION_CANDIDATE=0 keep production selected
  (#​1281).

Fixed

• Ignore Accept when the compact reduction collector checks whether a source can shift
  (#​1284).
  Four strict Scala witnesses match locked C without compact fallback.
• Elect accepted material paths inside the winning compact recovery group
  (#​1286).
  Preserve acceptance identity across grammar forks and closed error regions.
  Decline unsupported paths without publishing a guessed tree. The PHP compact request still falls back before acceptance.
• Bound end-of-file (EOF) recovery versions before allocating reduction parents
  (#​1287).
  Apply the native symbol-zero trial only to the certified Scala grammar blob.
  The Scala suffix suite records 50 exact matches and seven unchanged gaps across 57 cases.
  The 104,681-byte Swift witness completes without truncation or a memory stop.
• Prevent overlapping Python escape_sequence nodes when escaped backslashes
  precede a newline. All 18 fixtures now match the locked C tree on both routes;
  12 matched before the fix. Fixes #​1275
  (#​1276).
• Preserve Python list_splat binding for attribute and subscript suffixes
  during mixed flat and graph stack merges. Seven C fixtures match on both routes.
  Exact C tree differences across 2,932 Django files fell from 101 to 6.
  Fixes #​1274
  (#​1277).
• Reject query runs that cannot reach a required successor before enumerating
  capture combinations. Preserve highlight capture order for identical spans
  and prefer a highlight over @spell. Report quantified roots as non-rooted
  in IsPatternRooted (#​1278).
  The production query on 755 Nushell comments fell from 16,577.358 to 0.360 ms.
  Full highlighting of that 8 KB file took 20.132 ms after the change.
• Cache raw-shape error costs during generalized left-to-right (GLR) elections.
  Bound graph reachability checks and reject impossible merges earlier
  (#​1279).
  The reporter's C# fixture changed from quadratic growth to approximately linear growth.
  Production parsing at 32 KB fell from 12,662 to 900 ms.
  A separate 137 KB run measured a 3,008 ms median after the final merge precheck.
• Stop Make forest rescue at the first dead end when it cannot accept recovery.
  A reconstructed 3.5 KB fixture with an early error fell from 27,377.173 to
  13.015 ms on production (#​1282).
• Build C-certified HTTP sections directly for newline-terminated, nonblank
  # comments under the certified grammar hash. Preserve deadlines and
  memory budgets; disable incremental reuse for these direct trees
  (#​1282).
  Production parsing at 32 KB fell from 2,160.112 to 1.657 ms.
  The result now matches the complete C tree instead of returning one error node.
  Maximum resident memory fell from 2,178,624 to 12,892 KiB.
• Stop incremental reuse with low yield after bounded work and retry a fresh parse.
  The guard requires an early edit, a live graph fork, and at most four root children.
  The guard applies across grammars (#​1282).
  Production insertion in the reconstructed 137 KB Dart fixture fell from
  258.646 to 119.063 ms. Maximum resident memory fell from 220,912 to 123,796 KiB.

Measurement scope

These measurements come from the linked pull requests on Linux amd64.
They do not establish Windows performance. C# runs used the reporter's exact
fixture; Make, HTTP, and Dart used deterministic reconstructions.
Host load varied during the C# sweeps. The Nushell baseline used one repetition;
the result after the change used the median of three repetitions.

PR #​1282 completed the standard Go trio with 20 shuffle seeds and 750 ms per benchmark.
It used one process per seed, GOMAXPROCS=1, and GOWORK=off.
The benchmark comparison found no significant time change:

Benchmark	Before ns/op	After ns/op	B/op, unchanged	allocs/op, unchanged
Full parse	3,456,000	3,411,000	1.224 KiB	8
Single-byte edit	91,310	90,720	386	5
No edit	3.307	3.294	0	0

The linked pull requests contain reproduction commands and separate correctness evidence.

PRs #​1284–#​1287 each record 20-seed randomized comparisons without significant changes in the three primary parse times.
PR #​1285 shared its host with another workload; its timing evidence has that limit.
PR #​1286 measured 111,092 KiB maximum resident memory for a 512 KiB Go parse.
PR #​1287 measured warm Swift maximum resident memory of 257,440 KiB before and 257,332 KiB after the change.
Its primary allocation counts remained 8, 5, and 0.

Publication exception

On 2026-09-24, the owner approved a one-time tag-creation exception for v0.55.0.
The exception permits publication without a workflow-only tag-creation actor rule.
All other gates remain mandatory under the release process.

Known gaps

• #​1280 remains open and is excluded.
  Transient-error incremental trees and the diff and LESS edit mismatches remain unresolved.
  Its locked C gate still fails for malformed JavaScript, LESS, and TOML fixtures.
• C# still takes about three seconds at 137 KB on the measured host.
  Graph stack merges remain under investigation; the sub-second target remains open.
• Scala remains unresolved. A Linux bisect identifies grammar update 74159ec1b
  as the fresh-parse regression trigger. Linux edits did not reproduce the
  Windows slowdown. Preserve the new grammar's coverage while investigating its cost.
• Blank HTTP # comments retain the existing parser route and need a locked C regression.
• Six Django files retain separate C tree differences after the Python splat fix.
• CSV , and a,b, still differ from locked C on both parser routes.
• The PHP compact recovery winner remains open; the generated corpus records 6 of 25 exact deep matches.
• Seven Scala suffix gaps predate the EOF recovery bound. Other grammar blobs retain the exact EOF row.

v0.54.0: gotreesitter v0.54.0

Compare Source

Added

• Add FactProgram.ExtractInto to reuse caller-owned fact storage across trees.
• Add a per-language admission allowlist (empty by default) so a later change
  can graduate one language's compact route without flipping the global
  default.
• Add the admission_route_performance_sanity CI gate, comparing the compact
  route against the production route in-process, interleaved, on a fixed
  9-language corpus.

Changed

• Default the compact ("candidate") admission route to off. Buildbox's
  tamarack harness measured it 1.1x to 2.2x slower than production on typical
  files across Python, Rust, Markdown, Lua, CSS, Bash, and Go, and
  TypeScript/YAML paid for both routes on every parse (compact declines, then
  production reparses). Set GTS_ADMISSION_CANDIDATE=1 (or true/on/yes)
  to opt back in.
• Throttle the compact scheduler's memory-footprint poll: recompute the exact
  footprint on the first poll of a parse attempt, every 64th poll after it, or
  whenever a cheap, O(1) capacity-based growth proxy shows growth covering
  1/16th of the configured budget since the last exact check. This bounds
  worst-case overshoot by construction, not just by dispatch count. Measured
  peak-footprint overshoot: 1.25-2.16% over budget on an adversarial witness.
• Make ExternalLexer's read-frontier tracking lazy: skip the frontier
  recompute once the recorded values already provably cover the current
  position. This benefits every route that uses an external scanner (YAML,
  Python, Markdown, Bash, and others), not just the compact route.

Fixed

• Preserve explicit end-token acceptance when importing and minimizing C lexer
  states. Regenerate CSV from its locked C source. Older blobs retain their
  end-of-input fallback.
• grammargen gives a named token.immediate() terminal with a string body the
  same specificity bonus that an inline one gets. The lexer again accepts the
  immediate terminal instead of a plain string literal with the same text.
  Swift var opt: Int? parsed with an ERROR after a table rebuild, because the
  anonymous ? won the same-span tie over _immediate_quest. Pattern-bodied
  named immediate terminals keep their authored precedence.
• Fix parser_result_yaml.go silently clearing HasError() for a lone
  unmatched YAML flow-collection opener (for example a bare [ at end of
  input), which diverged from the C reference's (ERROR ...) shape. The
  production route now declines recovery for a bare [/{ and promotes an
  all-ERROR reduction to the ERROR root itself. This bug predates this
  release; the compact-route default flip is what exposed it.
• The scanner fuzz allocation check now measures the minimum across 5 samples
  instead of requiring every re-run to exceed budget, removing a transient
  GC-timing false failure. The byte-budget assertion is skipped under the
  race detector, where instrumentation noise swung a measured TotalAlloc delta
  for the same input from about 66KB to about 29MB (more than 400x) and could
  no longer separate noise from a real finding. The elapsed-time check and the
  parser memory budget (WithParserPoolMemoryBudgetBytes) remain the hard
  bounds under -race.
• Invalidate the GLR shape-prefix cache only when a stack merge rewrites a
  link 0, not on every successful merge. A fixed nesting depth that forks and
  merges on every token used to rewalk the whole spine on the next head hash,
  which turned the parse superlinear past depth 1600 (issue #​454). An
  extra-link-only merge now keeps its exact cached prefixes.
• Resume C and Java TokenSource scanning from the still-valid queued
  literal-tail tokens, instead of resetting and relexing, when incremental
  reuse resumes inside an already-queued string or character literal. The
  reset path used to drop the queue and misread the remaining bytes, so the
  incremental tree could differ from a fresh parse.
• Track reused bytes for plain ParseIncremental, not only for
  ParseIncrementalProfiled, so the reuse-budget stop arms on both entry
  points. ParseIncremental allocates no timing record, so a reuse-hostile
  edit taken through that entry point never armed the stop before this fix.
• Exempt extra (comment and whitespace) leaves from the compact incremental
  reuse proof. One unproven extra leaf used to disable incremental reuse for
  the whole compact tree; an ordinary leaf still requires a proof.
• Fall back to a fresh full parse when ParseIncremental receives an old
  tree with no recorded Tree.Edit call and a new source of a different
  length. The incremental path used to trust stale byte positions against
  the new source in that case, with no error or ParseStoppedEarly signal.
• Route every Groovy incremental parse through a fresh full parse. The
  Groovy grammar table derives a function-call juxtaposition only for a
  block's first statement, so spliced incremental reuse could produce a tree
  that a fresh parse of the same bytes never produces. Groovy's incremental
  performance is unchanged; parity with a fresh parse is now guaranteed
  instead of usually holding.

Known gaps

• COBOL's column-dependency edit-invalidation over-invalidates a later-line
  token after an earlier-line, non-crossing edit. This is fail-safe (extra
  reparse work, not a wrong tree); COBOL does not support incremental reuse
  today, so it has no current observable effect. Root cause is out of scope
  for this release.

Breaking Changes

• GTS_ADMISSION_CANDIDATE now defaults off; its meaning is inverted from the
  prior release. Set it to 1, true, on, or yes to keep the compact
  route on.

Performance evidence

Buildbox's tamarack harness measured the default route's in-process Go/C
ratio across three independent interleaved runs on a fixed 9-language
typical-file corpus, comparing this release's candidate code against the
prior default:

lang	before	after	speedup
go	5.97x	5.42x	1.10x
python	2.87x	1.54x	1.86x
typescript	3.17x (100% fallback)	2.31x	1.37x
rust	5.06x	2.53x	2.00x
yaml	3.56x (100% fallback)	2.34x	1.52x
bash	3.65x	2.08x	1.75x
markdown	6.36x	2.87x	2.22x
lua	4.66x	2.33x	2.00x
css	4.60x	2.36x	1.95x

The lever-2 overshoot-bound refinement (dominant-capacity growth trigger) cost
nothing measurable; the ratio table is unchanged within run-to-run noise after
it landed. Source: #​1264. A downstream #​454 report attributes its resolved
regressions to the production route becoming the default.

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • At any time (no schedule defined)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.

[coderabbitai]

Important

Review skipped

Bot user detected.

To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Advanced

Run ID: 4c1180dd-15cd-4a78-9502-e4460e809596

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

---

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

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 88.18%. Comparing base (1e7ba32) to head (30f5bcb).

Additional details and impacted files

@@           Coverage Diff           @@
##             main     #365   +/-   ##
=======================================
  Coverage   88.17%   88.18%           
=======================================
  Files         362      362           
  Lines       34743    34743           
=======================================
+ Hits        30636    30637    +1     
+ Misses       4102     4101    -1     
  Partials        5        5           

Flag	Coverage Δ
unittests	88.18% <ø> (+<0.01%)	⬆️

Flags with carried forward coverage won't be shown. Click here to find out more.

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud