[tannevaled]

The last of the five defects in #799 that this repository can fix — it fails at
3.4.1 and at 4.0.9 alike — and the one that cost nothing at all before it was
looked for:

$ rbgo -e 'proc { |x| _1 }'   # on main
$                             # no error, no warning, nothing

MRI rejects that at parse time. A block cannot have both a written parameter
list and a numbered parameter, because the grammar reserves _1.._9 for the
numbered-parameter mechanism, so the two would be the same slot under two names.

language/numbered_parameters_spec.rb:49 pins eight shapes in one example, and
the pairing is the interesting part:

-> { eval("-> () { _1 }")         }.should.raise(SyntaxError, /ordinary parameter is defined/)
-> { eval("-> (x) { _1 }")        }.should.raise(SyntaxError, /ordinary parameter is defined/)
-> { eval("proc { || _1 }")       }.should.raise(SyntaxError, /ordinary parameter is defined/)
-> { eval("proc { |x| _1 }")      }.should.raise(SyntaxError, /ordinary parameter is defined/)
…

Each kind of block appears twice, once with an EMPTY written list and once with
a parameter in it: writing || or () at all is what declares the list, not
what it contains. A check that looked for a parameter would have passed four of
the eight.

Where it goes, and why there

blockParamsAreImplicit already tells a written list from one the parser
synthesised out of it / _1.._9 in the body — the trace being that a written
list pads Defaults to one entry per parameter and a synthesised one leaves it
empty. The builder now records that answer as writtenParams, set BEFORE the
body is compiled, because the body is where _1 is met.

The refusal itself sits in compileCall, beside the __LINE__ and
block_given? intrinsics and shaped like them — receiverless, blockless,
argumentless, bare name. Reaching that point means the name resolved to no
local, so it was about to become a receiverless send; that is exactly the
position in which MRI has already decided the program is ill-formed.

Two scopes are deliberately NOT covered, because MRI's answer there is a
different one and no spec in the gate asks for it:

• a for body (forScope), since for opens no Ruby scope;
• a method body and the top level, where _1 stays a runtime NameError.

Measured, with the control

language/numbered_parameters_spec.rb, pinned corpus 87b1631, shim at 3.4.1:

binary	result
main	pass=16 fail=1
this branch	pass=17 fail=0

The file is clean. The eight shapes, probed directly:

	main	this branch
-> () { _1 } … lambda { |x| _1 } (6 forms)	no error at all	SyntaxError
['a'].map { || _1 }, ['a'].map { |x| _1 }	NameError, at CALL time	SyntaxError
proc { _1 }.call(7)	7	7
proc { _1 + _2 }.call(3, 4)	7	7
proc { |x| _10 }	fine	fine

The two rows that said NameError are worth keeping in view: on main only the
shapes that were actually CALLED failed, and the four that were merely defined
raised nothing — so the defect was invisible to anything but a spec that
evaluates the source.

⛔ The local internal/vm run is VOID, and CI is the check

internal/compiler passes in 0.2s and internal/aot in 0.18s. The
internal/vm run beside them did not fail an assertion — it hit
panic: test timed out after 10m0s at 604s, where the same suite took 297s and
434s earlier this morning, with the machine at load 37.5 / 74.3 / 76.5 on 16
cores (around forty peer sessions are building across this fleet right now).

Above roughly 8 that machine stops measuring anything, so this is an artifact and
I am claiming neither a regression nor the absence of one from it. The three
test lanes here, on clean runners, are the verdict; if one of them reds, the
cause is in this diff and not in the load.

⛔ Not one row of the new test was run against a reference interpreter

The Ruby on this machine is 2.6.10 and numbered parameters arrived in 2.7, so
the local oracle cannot answer any of these. The authority is the spec file,
which pins all eight verbatim, and MRI's rule that the grammar reserves the
names. The test says so in its own comment rather than borrowing the
"verified against MRI 4.0.5" line its neighbour in the same file has earned.

Tests: internal/compiler/numbered_param_ordinary_test.go — the eight shapes,
three more written-list kinds (_9, a block parameter, a keyword), thirteen
controls, and a second test asserting the two refusals stay DISTINGUISHABLE:
binding _1 is "reserved for numbered parameters" and reading it beside an
ordinary parameter is "ordinary parameter is defined". They are different
sentences in MRI and the specs match them separately, so collapsing them into
one message would satisfy neither.

Refs #799

🤖 Generated with Claude Code

[tannevaled]

The red was a known flake, not this change

test (windows-latest) was the only failing lane; ubuntu and macOS passed, and
go vet ./... and go build ./... passed on windows too. The failing step is
"Test + 100% coverage gate", which since #542 does not enforce coverage on
windows — it prints "coverage ratchet not enforced on windows (POSIX-only paths
unreachable)" and only runs the -race suite. So the step failing there means a
real test failure, and the log names it:

--- FAIL: TestEtcd (32.06s)
    --- FAIL: TestEtcd/LockAndMaintenance (5.32s)
FAIL	github.com/go-embedded-ruby/ruby/internal/vm	2222.562s

TestEtcd is an embedded-etcd integration test with a port/serve dependency and
a known history of flaking on that lane. Nothing in this branch touches it: the
diff is internal/compiler only — one builder field, one refusal in
compileCall, and a test file.

gh run rerun refuses this run ("cannot be rerun"), so instead the branch now
carries a merge of current main — which re-triggers CI and is worth doing
on its own merits, since main has moved (#856 landed). internal/compiler and
internal/aot pass on the merged tree.

One note for whoever reads the job data rather than the log: that job reports
completed_at 09:34:56 before started_at 09:52:22, which is why
gh pr checks printed a duration of 0. A zero-second lane looks like one that
never started; this one ran for 37 minutes.

🤖 Generated with Claude Code