Round 4: close parse-conformance gaps (Rails 96.8% → 99.6%)

[tannevaled]

Summary

Round 4 of the push to 100% parse-conformance for go-embedded-ruby. Lands the ten requested features plus the adjacent gaps each one exposed, all verified against MRI 4.0 (ruby -c).

Rails corpus (MRI-valid .rb files that parse): 3314/3423 (96.82%) → 3409/3423 (99.59%).

Features (MRI-verified)

1. Parenthesized masgn LHS — (a, b) = x, y, nested ((a, b), c), inner splat (a, *b), group-as-target a, (b, c) = …. Nested groups are a MultiAssign (nil Values) target node.
2. Scope-resolution method calls — Syslog::LOG_UPTO(x), Mod::meth arg, obj::Down x, y (+ do-block), kept distinct from scoped constants (Math::PI).
3. Trailing <</&/|/^ line continuation — disambiguated from block-pass / block-params / heredoc / pattern-pin by lexer binary-position state.
4. Anonymous-argument forwarding — foo(&), bar(*), g(**), to_str[*].
5. Assignment inside a ternary branch — cond ? a = b : c, x ? ENV["k"] = v : super.
6. class/module/class << x as a value — c = class Foo < Bar; …; end.
7. Unicode identifiers / method names / symbols / labels — def なまえ, { 🎃: … }, :🇺🇸, :røcket (widened the identifier byte predicate; multi-byte ?é char-literal path preserved).
8. Safe-navigation operator methods — x&.[](i), obj&.+(y), plus the full operator-method-name set after ./&. including []/[]=.
9. Operator/backtick method symbols + !~ — : `, :!~, the new NMATCH operator, and def \(cmd); end`.
10. Beginless ranges as args & scoped const patterns — foo(...0), [...11, 11] vs ... forwarding; in Prism::CaseNode[a], Const[label:].

Adjacent gaps closed in passing

end if cond / end.html_safe (if/unless/while/until/def/class/module as expressions); super { … }; alias eql? == (fitem lists no longer over-continue a trailing operator); attribute/index array-RHS (self.x = :a, b); break/next comma values; ::Time.zone = … masgn targets; rescue => @e; predicate labels (frozen?:); rational/imaginary literals (2r, 3i, 2.5ri); nested compound assignment (a && count += 1); parameter defaults calling a same-named method (def f(secret = secret("x"))); class names with an expression receiver path (class self.class::Foo); nested do-block inside a command-argument brace block (include Module.new { define_method(:x) do … end }); option globals ($-I); constant conversion command calls (BigDecimal "0.01").

Quality

• 100% statement coverage (CI gate), via round4_features_test.go + round4_coverage_test.go MRI-parity tables.
• go test ./..., go vet ./..., gofmt all clean; CGO=0.

Remaining (deferred — 14 files)

Deep edges, mostly multi-issue files: regex-literal-inside-interpolation-inside-regex, an interpolation containing a paren-less command with a comma list, and a couple of constructs MRI itself rejects in isolation. No COMPILE-blocking parser gaps remain.

rbgo follow-ups (compiler cases the new AST needs)

• Paren-masgn: a nested MultiAssign target (Values=nil) — destructure one value into sub-targets.
• class/module-as-value: ClassDef/ModuleDef/SingletonClassDef in rvalue position must yield the body's last value.
• Anonymous forwarding call args: SplatArg{Value:nil} / BlockPass{Value:nil} / anonymous ** (key nil, value nil) — forward the enclosing method's anonymous */**/&.
• New literal nodes: RationalLit / ImaginaryLit (wrap an Int/Bignum/Float; ri nests).
• RescueClause.VarTarget: assign the caught exception to a non-local target.
• Super.Block: pass the block to super.
• !~ desugars to !(recv =~ arg).

The end-to-end rbgo build could not be exercised in this environment (a pre-existing unrelated cloud-boot/godoom replace points at a missing sibling repo); parser-level verification (all repros parse + Rails 99.59%) stands as the functional proof.

🤖 Generated with Claude Code