Swift recovery: upstream unsafe gap and locked-C structural divergence

[odvcencio]

Summary

This issue tracks two independent facts that share one Swift witness.

1. The locked Swift grammar does not recognize unsafe as an expression prefix.
2. Go and locked C produce different deep trees after the shared syntax error.

The first fact is an upstream grammar gap.
The second fact is a gotreesitter strict-parity gap.
Close each scope only with its own proof.

Witnesses

Use these checked-in files:

• grammars/testdata/swift_corpus/stdlib_FloatingPointToString.swift
• grammars/testdata/swift_corpus/stdlib_CollectionAlgorithms.swift

The minimal syntax trigger is:

let x = unsafe bar()

Swift accepts this syntax.
The locked tree-sitter-swift grammar reports an error.

Locked reference

Use tree-sitter-swift commit 41d6e5fe811ec94229ee71771174a8cce558dfee.

The current deep digests differ on both tracked files.

Witness	Go deep SHA-256	C deep SHA-256
FloatingPointToString	ec51c633a3f99515cc0cd1c0cff435a44ddc7db8e83705977d28f78bdfb0fc0e	ab96dddf088487acc700d72af9342c338901504dcf1d32b9644e9f6f6638190d
CollectionAlgorithms	79cf919059aa656c0d01a9a9f01d658e98e4e13d174de4bbf6560def035cb285	132d332f511f12735d80e846f52ec1fddf5f3d0dcd7a097779640a7710497487

Shared HasError() status and full-span coverage do not prove structural parity.

Gotreesitter scope

Restore exact locked-C deep-tree identity through a generic parser mechanism.
Do not add a Swift-only tree repair.
Do not add a source hash, language-name rule, or blob exception.

Keep fresh, incremental, recovery, and special routes exact.

Upstream grammar scope

Track support for the Swift unsafe expression prefix upstream.
When the locked grammar changes, import it through the normal grammar pipeline.
Do not hide the local strict-parity gap behind an upstream syntax change.

Acceptance

Close the gotreesitter scope when both witnesses match locked C node for node.
Require matching symbols, fields, spans, extras, missing nodes, and error nodes.

Close the upstream scope when the accepted locked grammar recognizes the syntax.
Regenerate the Go grammar and preserve exact C identity.

Issue #586 separately tracks shared recovery cost, memory, and retry economy.
PR #683 recorded candidate evidence but closed without merge or correctness credit.

[odvcencio]

The shared recovery-cost investigation is now tracked in #586.

It requires default-limit measurements for the 105 KiB witness, Swift Docker C parity, maximum resident set size, CPU profiles, and phase attribution.

#576 continues to track the upstream tree-sitter-swift grammar gap.

[odvcencio]

Correction: local strict parity remains open

The current body is not correct about local C parity.

• Locked C digest: cd1bc1…edfbf
• Go digest: 721848…221b65

The C outer error contains a nested non-extra error. The Go tree does not.
This is a generic recovery and materialization mismatch.

The Swift dispatcher rewrote zero nodes for this witness.
Issue #586 continues to track the separate shared recovery-cost cliff.

Retain the upstream syntax gap as a separate fact.
Keep this issue open until Go matches the locked C tree.

[odvcencio]

This issue is now the umbrella for the Swift-recovery-versus-locked-C-oracle divergence family. We checked every item below against current main using the locked C reference parser (alex-pinkus/tree-sitter-swift, at the commit grammars/languages.lock pins). All of them still diverge. We closed the individual issues below and moved their reproductions here.

Upstream grammar gaps

Both Go and the locked C oracle report an error on these, but the recovered tree shapes differ.

• Swift strict parity: masking shift recovery differs from locked C #574, masking shift. let x = 1&<<7. The C oracle emits two source_file children; Go absorbs the second into the first. Ratchet row: stdlib_ASCII.swift.
• Swift strict parity: __consuming recovery differs from locked C #575, __consuming. override __consuming func on a protocol requirement. The C oracle's ERROR node spans bytes 49-61 with two children and a missing let; Go's ERROR spans bytes 50-61 with no children. Ratchet row: stdlib_Collection.swift.
• Swift recovery: upstream unsafe gap and locked-C structural divergence #576, unsafe (this issue). let x = unsafe bar(). The C oracle wraps the orphaned call in an ERROR node with one child; Go's ERROR node has none. Ratchet rows: stdlib_FloatingPointToString.swift, stdlib_CollectionAlgorithms.swift. The recovery-cost side of this file has its own tracking issue, GLR recovery: bound shared error cost after Swift unsafe parse failures #586.
• Swift strict parity: associatedtype fields and recovery differ from C #578, associatedtype conformance list. associatedtype Stride: SignedNumeric, Comparable. fix(parser): Preserve projected hidden fields #592 already fixed the name field projection for this shape. The ERROR node's byte range still differs: Go covers bytes 51-64, the C oracle covers bytes 51-63. Ratchet row: stdlib_Stride.swift.

Local recovery misses

The locked C oracle reports no error on these; Go still does.

• Swift: recover optional-binding headers that swallow then blocks #590, optional-binding headers that swallow a then block. Two witnesses:
  • A nested if let x = y { if g(a, b.c) { return } } inside an extension, followed by another extension declaration.
  • if let first = first, let second = second { ... } else { ... }, where only the second binding's right-hand side needs wrapping.
  • Ratchet rows: swift-algorithms_Chunked.swift, swift-algorithms_FlattenCollection.swift.
• Swift: recover comparison conditions with nested else-if errors #591, comparison conditions with a nested optional-binding branch below the condition. The later else if let idx = ... lands in an ERROR node under the condition's own call expression. Ratchet row: swift-algorithms_Stride.swift.

We reran all six reproductions against current main with the locked C oracle immediately before writing this comment, so the state above is current.