[tannevaled]

Four compiler-side gaps the v0.2.0 parser (#625) exposed, and a fifth found while
chasing them. Three of the four spec files this unblocks had been contributing
zero to both columns of the conformance measurement — not failing, invisible.

language/ over the whole tree (find language -name '*_spec.rb', 80 files),
main @ 097d86a vs this branch, same binary lineage and the same harness:

	pass	fail	error
main	1776	310	126
this branch	2158	382	130

+382 passing, and no file loses an example. The only four files that move at
all are the three unblocked ones and rescue_spec, which gains one:

language/block_spec.rb      (0, 0, 0)  -> (139, 27, 0)   +139
language/defined_spec.rb    (0, 0, 0)  -> (213, 45, 0)   +213
language/for_spec.rb        (0, 0, 0)  -> (29,  0,  5)   +29
language/rescue_spec.rb     (49, 7, 4) -> (50,  7,  3)   +1

The rise in fail+error (436 → 512) is entirely the examples those three files can
now reach at all; every one of them was previously unmeasured.

rescue_spec's +1 is not incidental: its "using a safely navigated setter method
on a nil target" example (rescue => o&.captured_error) reaches the same store arm
the for safe-navigation fix below repairs, and stopped raising NoMethodError.

1. Block-local variables — { |a; b| … }

They are fresh, nil-valued locals of the block that shadow any enclosing binding.
The parser carries them on Block.Locals; the compiler ignored the field, so
block_spec.rb stopped at "undefined local variable" before one example ran.

MRI read: prism_compile.c v3_4_0:6325-6334 walks the block-parameters node's
locals list and calls pm_insert_local_index for each, after the
requireds/optionals/rest/posts and before the "fill in any locals we missed" pass
— table entries, not parameters, so they start nil. parse.y v3_4_0:5128-5148
gives the grammar (opt_bv_decl/bv_decls/bvar).

One example in that group still fails, and deliberately: { |foo; foo| } is a
SyntaxError in MRI, raised by the PARSER (parse.y v3_4_0:13621, new_bv →
shadowing_lvar_0), and go-ruby-parser does not raise it yet. Nothing is forced
here on its behalf — localLookup answers with the first slot of a name, so the
repeated declaration is dead and the name keeps meaning the parameter. Raising
belongs where MRI raises it.

2. for — For.Target, the block's parameter shape, and the scope

Four things, all in the lowering of for.

For.Target. v0.2.0 puts every loop variable Vars cannot spell into
For.Target and leaves Vars empty — a lone non-local (for @v in …,
for a[0] in …), or any list with a *rest, a nested group, a non-local, or a
trailing comma. The compiler read only Vars, so for i, in [[1,2]] compiled a
loop over nothing.

The each-block's parameter shape. MRI picks it by the kind of loop variable
(prism_compile.c v3_4_0:6293-6301): a lone local target bumps lead_num, so the
block takes one required argument; anything else sets has_rest, so the block
collects every yielded value into an Array. rbgo always took one required
argument, so a for x, y in o over an each that does yield 1, 2 bound y to
nil where MRI binds 2. The single-non-local arm is MRI's expandarray 1, 0 on
that rest Array (prism_compile.c v3_4_0:4862-4880), which is why the loop
variable takes the FIRST yielded value and drops the others.

For the multi-target arm MRI emits (args.length == 1 && Array.try_convert(args[0])) || args
then expandarray (compile.c compile_for_masgn v3_4_0:8302-8329, and the
identical prism arm at prism_compile.c v3_4_0:4881-4919). The try_convert half
is redundant in front of an expandarray that already converts: when args holds
one element, expanding args[0] yields its Array conversion if it has one and the
one-element list [args[0]] otherwise — which is what expanding args gives. So
the same lowering is args.length == 1 ? args[0] : args, emitted with the same
idLength and idAREF sends MRI uses, and a redefined Array#length or
Array#[] is honoured here exactly as it is there.

for o&.target in m. storeMultiTarget ignored Call.Safe, so a nil receiver
raised NoMethodError instead of skipping the write. A multiple assignment can never
reach that branch (a&.x, b = … is a SyntaxError), but a for-var can:
prism_compile.c v3_4_0:4862 routes PM_CALL_TARGET_NODE through
pm_compile_target_node, which honours PM_CALL_NODE_FLAGS_SAFE_NAVIGATION.

for opens no scope. Its each-block is a block ISeq but not a Ruby scope, so a
variable FIRST ASSIGNED in the body belongs to the scope around the loop: after
for a in [6]; for b in [7]; c = a * b; end; end, c is a local of the enclosing
method. It hops out of enclosing for bodies but not out of an enclosing
block, which is a scope — the for_spec example "can be nested with blocks in
between" pins both halves. builder.declOwner names that scope, and every site
that declares a named local now goes through it (assignment, op-assignment, named
regexp captures, rescue => e), which also removes four copies of the
resolve-or-allocate dance.

3. defined? — the locals its operand declares, and two tags

defined? inspects its operand's syntactic kind instead of compiling it, so the
assignments inside emit nothing — but they still DECLARE. MRI builds its local
table in the PARSER, which walks the operand like any other code, so
defined?(a += 1) leaves a a nil local of the enclosing scope and a later bare
a is a local-variable read. rbgo declares as it compiles, so a got no slot and
the next mention of it — defined?(a.b += 1) six lines further on, whose receiver
the compiler DOES evaluate — failed to compile. Verified against MRI:
defined?(a += 1); p a prints nil.

Two tags were also wrong:

• a.b += 1 and a[:b] ||= 1 reach the compiler as the parser's textual
  desugaring into a setter Call and were tagged "method". MRI tags them
  "assignment": PM_CALL_OPERATOR_WRITE_NODE, PM_CALL_OR_WRITE_NODE,
  PM_CALL_AND_WRITE_NODE and the PM_INDEX_* trio are all in the DEFINED_ASGN
  group (prism_compile.c v3_4_0:4052-4093; compile.c's
  NODE_OP_ASGN1/NODE_OP_ASGN2 at v3_4_0:6151-6164 says the same). A plain
  a[0] = 1 is NOT in that group — it is an ordinary attrasgn call and stays
  "method", which ruby/spec pins.
• A ||= v and A::B ||= v desugar to (defined?(A) && A) || A = v and so
  arrived as a ||, tagged "expression". MRI tags them "assignment"
  (PM_CONSTANT_OR_WRITE_NODE / PM_CONSTANT_PATH_OR_WRITE_NODE,
  prism_compile.c v3_4_0:4059 and 4063; compile.c's NODE_OP_CDECL at
  v3_4_0:6162).

Both desugarings are recognised by AST pointer identity between the shared
read and the write, the test opassign.go already uses — a hand-written
(defined?(A) && A) || A = 1 has distinct reads and stays "expression", which MRI
confirms.

4. variables_spec — already fixed, and I can show it

The brief listed cannot compile *ast.SplatArg in language/variables_spec.rb as
the largest of the four. It does not reproduce, on either parser version.

main @ ddf7195 (parser v0.1.9):  RBGO_RESULT pass=113 fail=5 error=1
main @ 097d86a (parser v0.2.0):  RBGO_RESULT pass=113 fail=5 error=1
this branch:                     RBGO_RESULT pass=113 fail=5 error=1

Compiling every *_spec.rb under language/ turns up no cannot compile *ast.SplatArg anywhere. The wave-25 work had already closed it; the 113 examples
were the precedent the brief cites, not a pending item. Nothing to do, so nothing
was done — an honest three.

5. Found on the way: ... forwarding lost its block depth

mustResolve returned a slot and discarded the depth, so g(...) written inside
ANY block — def f(...); [1].each { g(...) }; end as much as a for body —
indexed the block's own frame and died with a Go index-out-of-range surfaced as
ArgumentError. Pre-existing and independent of for; for_spec is simply the file
that exposes it.

Gates

• CGO_ENABLED=0 go build ./..., CGO_ENABLED=0 GOOS=wasip1 GOARCH=wasm go build ./..., gofmt -l internal/ empty.
• CGO_ENABLED=0 GOWORK=off go test ./... — full suite green, TestEmbeddedPreludeMatchesSource included (nothing prelude.rb uses changed shape, so prelude_frozen_gen.go is untouched and still matches).
• Coverage: every new function at 100% in the package profile; compared per
  function against main, nothing that was at 100% dropped and no function
  decreased at all. Total 98.4% → 98.7%.
• Byte-for-byte against MRI 4.0.5 for every construct touched: the for shapes
  (including the hash, multi-yield, attribute, safe-navigation, index and
  leak-past-the-loop cases), block-locals, and the defined? tags and
  declarations — diff of raw output, identical.

Known-remaining, deliberately not in this PR

In defined_spec's 45 remaining failures, two groups dominate and neither is a
regression: defined?(super) answers "expression" instead of "super"/nil (18
examples — it needs a new opcode and VM support), and the tag Strings are not
frozen (about 12; half of that is one line in internal/vm/defined.go, outside
this branch's file set). for_spec's 5 errors are Kernel#local_variables and
#redo, neither implemented. assignments_spec wants a rescuable SyntaxError
where the compiler currently reports cannot compile *ast.BlockPass.

🤖 Generated with Claude Code