Round 2: Rails/Puppet parse-conformance 83%→94%

[tannevaled]

Summary

Round-2 front-end work driving go-ruby-parser toward 100% parse-conformance,
measured against the Rails and Puppet corpora with MRI 4.0.x (ruby -c) as the
oracle. Every feature has MRI-verified repros and MRI-parity table tests; the
package stays at 100% statement coverage (CI gate) and go test -race,
gofmt, and go vet are all clean.

Parse-conformance delta (files that parse cleanly)

Corpus	Before	After	Gain
Rails	83.1% (2844/3423)	94.3% (3228/3423)	+384 files
Puppet	82.5% (1778/2156)	93.6% (2017/2156)	+239 files

Features landed (each MRI-verified)

1. do…end block on a receiver command call — obj.foo bar do … end now
   attaches the block to the command call (and continues the postfix chain so a
   block-bearing command can be chained). This was the single largest gap.
2. Single-target implicit array assignment — args = "-t", "--server", x ≡
   args = [...], including a *splat (a = *list, y).
3. Trailing keyword-operator / modifier continuation — a line ending in
   and/or/if/unless/while/until joins the next line.
4. =begin … =end block comments, plus the previously-missing bitwise
   op-assignments |=, &=, ^=, >>=.
5. Backtick command literals (`cmd` → the %x{} XStr node) and the
   full operator-method def set (===, =~, &, |, ^, >>, **,
   the unary +@/-@/~@, ~, !, and def / without regexp confusion).
6. *splat in rescue/when lists and masgn RHS — rescue *EX => e,
   when *LIST, path, headers = *args.
7. Quoted string-key symbol shorthand — {'a': 1}, {"d-a-s-h": 2},
   tag(:div, "@click": "f"), interpolated "x#{y}": → a dynamic .to_sym key.
8. Stabby lambda with unparenthesized params — ->x { }, -> ctx { },
   ->a, b { }, -> message do … end.
9. Modifier if/unless and statement sequences inside parens —
   (expr if cond), (x if y) || z, (a; b).
10. Keyword args in block params — |a, b:|, |c, count: nil, timeout: 5|.
11. Multi-line / scoped-default parenthesised parameter lists.

Additional gaps closed by the corpus sweep

• alias NewName OldName / undef name[, …] keyword statements (new Alias /
  Undef nodes).
• Chained masgn RHS — a, b = c = expr, _, h, _ = resp = call(x).
• def with an instance/class/global-variable receiver (def @ctrl.foo); def
  as a paren-less command argument (module_function def foo; end).
• #{…} interpolation bodies parsed as full statements (trailing modifiers,
  multiple statements).
• Scope-resolved constant assignment A::B = v (new ScopedConstAssign node);
  expression superclasses class A < Struct.new(:x), class A < self.

rbgo (go-embedded-ruby) compiler follow-ups

Verified end-to-end against rbgo via a throwaway replace (NOT committed).
Almost everything lowers with the existing compiler — the do-block, RHS array
(non-splat), backtick, keyword continuation, operator def, block kwargs, lambda
args, and statement interpolation all run. The new AST shapes the compiler does
not yet handle (separate go-embedded-ruby work):

• *ast.Alias, *ast.Undef, *ast.ScopedConstAssign — new node kinds.
• *ast.SplatArg in masgn / RHS-array value position (a, b = *x, a = *x, y)
  — the compiler currently handles SplatArg only inside call arguments.

Testing

• New MRI-parity table tests per feature; go test -race ./... green.
• 100% statement coverage with the CI's -coverpkg gate.
• Validated on the Rails and Puppet corpora (numbers above).

🤖 Generated with Claude Code