[tannevaled]

What this is

Wave 27, the predefined-globals / Kernel / Module lane. Every item was read out
of the MRI C source first (the file and function are named in each commit
message) and then checked byte for byte against ruby 4.0.5 on this machine
before any code was written.

Measured

Whole language/ tree (walked with find, not a flat glob — it has
subdirectories), core/kernel and core/module, before and after, per FILE:

area	before	after
language/predefined_spec.rb	73 pass, 88 fail+error	124 pass, 37 fail+error
language/ (80 files)	2222 pass, 448 fail+error	2273 pass, 397 fail+error
core/kernel (118 files)	1952 pass, 184 fail+error	1978 pass, 158 fail+error
core/module (85 files)	866 pass, 160 fail+error	872 pass, 154 fail+error

Whole language/ + core/ ratchet: 21810 → 21899 (+89), floor 21740 (not
touched). Re-measured from scratch after merging origin/main (#628, #537),
two clean runs a side. Compared per file, not just in total: every file that moves, moves
up — nothing regressed anywhere in core/ or language/.

core/builtin_constants/builtin_constants_spec.rb   13 -> 17
core/exception/backtrace_spec.rb                   10 -> 11
core/exception/set_backtrace_spec.rb                9 -> 10
core/kernel/Complex_spec.rb                        54 -> 60
core/kernel/open_spec.rb                            9 -> 14
core/kernel/require_spec.rb                        65 -> 69
core/kernel/trace_var_spec.rb                       0 -> 6
core/kernel/untrace_var_spec.rb                     0 -> 2
core/kernel/warn_spec.rb                           18 -> 21
core/module/module_function_spec.rb                20 -> 26
language/predefined_spec.rb                        73 -> 124

core/module/autoload_spec.rb still swings between 57 and 0 between runs, on
this branch exactly as on main — issue #615. Re-run and it comes back; the
totals above are from runs where it reported.

One other file, core/random/bytes_spec.rb, keeps coming out 9 or 8 between
sweeps. Two consecutive full runs of the base binary alone give 8 then 9,
so it is flaky independently of this branch — checked from the base side rather
than assumed, since a loss hiding inside a net gain is exactly what comparing
per file is for.

The ceiling, measured rather than assumed

MRI 4.0.5 was run over the same corpus under the same vendored spec_helper.rb
shim, which gives the score that is actually reachable: 5780 in those three
trees against rbgo's 5028 before this branch. 94 examples in them cannot pass
whatever rbgo does, because the shim differs from real mspec. That measurement
is what says, below, which of the remaining failures are ours.

Fixed

The predefined globals (globals.go, regexp.go) — read from
variable.c (rb_gvar_readonly_setter, and rb_define_hooked_variable's
if (!setter) setter = rb_gvar_readonly_setter, which is what silently makes
every rb_define_virtual_variable(name, getter, 0) read-only), eval.c
(errat_getter/errat_setter, errinfo_getter), re.c (match_setter,
ignorecase_getter), io.c (deprecated_str_setter, must_respond_to,
argf_lineno_setter, set_LAST_READ_LINE), string.c (rb_str_setter,
rb_fs_setter, rb_fs_check), load.c, process.c, ruby.c
(verbose_setter, opt_W_getter, set_arg0) and error.c
(deprecation_warning_enabled). Read-only globals raise NameError naming the
spelling written through; $/ $-0 $\ $, $; type-check; $. takes #to_int;
$stdout/$stderr/$> must answer #write; $~ moves the backref so the
derived $& $ $' $+ $1..follow;$@reads and writes the rescued exception's backtrace;$VERBOSE/$DEBUGreadfalse; $-0 $-F $-I $-v $-w
$-d $>resolve to their shared slot through onecanonicalGvar` on both sides.
+51 on predefined_spec alone.

RUBY_RELEASE_DATE / RUBY_REVISION, frozen Strings, from version.h at
tag v3_4_1 (RUBY_RELEASE_DATE is composed from the release
year/month/day, RUBY_REVISION comes from the generated revision.h — the
tagged commit, 48d4efcb85… of 2024-12-25). builtin_constants 13 → 17, zero
failures left in that file.

Exception#set_backtrace from an Array of Thread::Backtrace::Location —
error.c exc_set_backtrace tries rb_location_ary_to_backtrace FIRST and only
then applies rb_check_backtrace's String rules.

Kernel#trace_var / #untrace_var (variable.c rb_f_trace_var,
rb_f_untrace_var, rb_gvar_set_entry) — did not exist. Hooks fire after the
setter, most recently registered first, never when the setter raised; a String
command is evaluated, not called; untrace_var returns the removed commands.
Both spec files go to a full score. The hook table is a lazily created ivar on
the Kernel module, so a program that never traces a global allocates nothing.

require's rb_feature_p (load.c, with loaded_feature_path) — require
decided "already loaded?" by absolute path, MRI decides it by NAME before
touching the filesystem, matching "#{name}#{e}" or
"#{load_path[j]}/#{name}#{e}". That is why a feature stays loaded once when
$LOAD_PATH is rearranged under it, and why an entry a program pushed by hand
suppresses the require of that spelling.

Kernel#Complex (complex.c nucomp_convert, rewritten in that function's
own order) — a 22-case probe table now agrees with 4.0.5 byte for byte. The
subtle one: complex.c's internal f_real_p is NOT Complex#real?; for a
Complex it is f_zero_p(imag), so it calls Complex(1, 0.0) real although
Complex#real? returns false for every Complex. That is the whole reason
Complex(Complex(1, 0.0), 2) is (1+2i) with an Integer imaginary part while
Complex(1, 0.0) + Complex(0, 2) is (1+2.0i). Also: exception: false is
not a blanket rescue — MRI applies it at exactly three points and lets
nucomp_real_check's "not a real" through, so Complex(:sym, 0, exception: false) really does raise.

Kernel#open redirects to #to_open (io.c rb_f_open) — it tests
rb_respond_to(argv[0], to_open) FIRST, before treating the argument as a path
at all, and hands back whatever #to_open returns; the open-uri protocol is
built on that. rbgo went straight to the path conversion. With a block the
result is yielded and then closed through a CHECKED #close, so a value that
cannot be closed is left alone.

Kernel#warn (error.c rb_warn_m / rb_warn_category) — rb_warn_m
wraps its whole body in if (!NIL_P(ruby_verbose) && argc > 0), so
$VERBOSE = nil makes it a no-op (rbgo wrote regardless); the message is
assembled by rb_io_puts, so an Array argument writes one line per element and
an empty Array writes nothing (rbgo inspected it); the level goes through
NUM2LONG, so a Float or Rational truncates; and a Warning.warn that takes
exactly one argument is called WITHOUT the category keyword
(rb_warning_warn_arity() == 1). With a level, MRI's own no-location fallback
prefix "warning: " is now emitted — which is the truthful answer for every
level here, since rbgo has no line numbers, and it makes the "uplevel too
large" case match byte for byte.

Module#module_function (vm_method.c rb_mod_modfunc /
rb_mod_define_method) — the T_MODULE guard, Class's undef tombstone, the
search_method(rb_cObject, …) fallback that makes module_function :require
work, and define_method honouring the toggle.

Pinned tests updated, each to a value witnessed on MRI

Seven Go tests were asserting behaviour this branch replaces. Every replacement
was checked against ruby 4.0.5 first, and the comment says which C function
decides it: $VERBOSE reads false; $LOAD_PATH = 42 and $ERROR_INFO = …
are NameErrors; a $stdout that never answered #write can no longer be
assigned (the three fallback tests now bind an object that answers #write and
then remove the method, so the branch stays covered and the comments say
plainly that MRI raises NoMethodError where rbgo tolerates); Complex(1, "b") is an ArgumentError; a lone non-real Numeric comes back unchanged; and
warn("x", uplevel: 0) now carries MRI's no-location "warning: " prefix
(the comment says what MRI produces there and why rbgo cannot yet).

The windows-only failure, and which side was wrong

The first push was red on test (windows-latest) alone, on three subtests of
TestFeatureProvided. The matching was right; the fixture was POSIX-shaped.

load.c decides the prefix boundary with a bare name[plen-1] != '/' and
carries no separator conditional anywhere — grep for isdirsep,
FILE_ALT_SEPARATOR and _WIN32 over the file finds zero. The
"and a backslash on Windows" rule is file.c's, whose isdirsep macro drives
is_explicit_relative — a different function, already modelled by
isExplicitRelative with os.IsPathSeparator. So the loaded-features matching
is /-only on every platform and teaching it about backslashes would have been
the divergence.

The divergence was then located rather than inferred. featureProvided has
exactly one platform-dependent step — expandedLoadPath runs each $LOAD_PATH
entry through filepath.Abs — and feeding it a path darwin does not call
absolute reproduces the symptom here:

lp="/lib"          expanded=["/lib"]                    -> true
lp="lib"           expanded=["<cwd>/internal/vm/lib"]   -> false
lp=<t.TempDir()>   expanded=[<same>]                    -> true

/lib on Windows is the middle case: rooted, but with no volume name, so
filepath.IsAbs is false. The eight prefixed cases now build on t.TempDir()
— which both sides of MRI's own comparison have anyway — and the fixture's
premise is asserted in one line rather than assumed. Deliberately not a
runtime.GOOS skip: the matching keeps being exercised on Windows, and gains a
case pinning that a prefix ending in a backslash must not match there (read
from the source, not witnessed — there is no Windows MRI on this host, and the
comment says so).

Worth recording: only the three cases expecting a match actually failed. The
five expecting no match passed on Windows for the wrong reason — the prefix
never matched at all, so the rule each names was never reached. All eight test
what they mean now.

Gates

go build ./..., go vet ./..., full go test ./... green; gofmt -l internal/vm/ empty; CGO_ENABLED=0 GOOS=wasip1 GOARCH=wasm go build ./...
green; and a GOOS=windows go vet ./internal/vm/ to typecheck the tests for
that lane. Coverage run the way CI runs it (-coverpkg over ./internal/...,
./...): the set of functions below 100% is byte-identical to the same run
on the merged origin/main in this environment — every function this branch adds or
edits is at 100.0%, in a new predefined_globals_internal_test.go plus the
existing suites.

Out of reach from this branch, and why

Reported rather than forced, with the measurement that says so:

• const_source_location (30 examples, the biggest single gap in
  core/module) is blocked on line numbers, not on a constant-assignment
  hook. rbgo has NO line tracking at all: __LINE__ is 0 everywhere, and
  every expectation in that file is [__FILE__, __LINE__ - 1], i.e. -1. A
  perfect const_source_location would answer [path, 0] and still fail all
  30. MRI scores 42 on the file under the same shim. The fix belongs in
  internal/compiler. Same root cause for the 4 Kernel#warn :uplevel
  examples that are still red — they are now ALL of warn_spec's remaining
  failures that are ours — and for language/line_spec.rb (0/6).
• $! frame scoping (10 examples in predefined_spec) — "cleared when an
  exception is rescued", "set to the value of $! before the begin after a
  successful rescue", and $@'s "is cleared when an exception is rescued".
  vm.curExc is saved and restored per FRAME (vm.go around the rescue
  dispatch); MRI clears errinfo when a rescue clause completes. vm.go is a
  sibling's this wave, so the $@ half is done here and this half is not.
• **$& $ $' $+"is read-only" (4)** want aSyntaxErrorfromeval("$& = ''"), which is a parse-time rejection (internal/compiler). They now raise NameErrorinstead of silently succeeding, which is nearer but still not equal. The 4 "read-only when aliased" wantalias $x $&to carry the read-only-ness; global aliasing isobject_model.go:709 (vm.globals[new] = vm.gvar(old)`, a snapshot, not an alias), a sibling's
  file.
• nil = 1 / self = 1 SyntaxError messages (4) — the parser's message,
  internal/compiler.
• The deprecation-warning examples (5 for $/ $-0 $\ $, $;, 2 for $=, 4 in
  deprecate_constant_spec) are shim artefacts, not divergences. error.c deprecation_warning_enabled() needs BOTH a non-nil $VERBOSE and
  Warning[:deprecated], and the category is off by default. Verified: MRI
  4.0.5 prints nothing under exactly the conditions the vendored shim sets up,
  and rbgo now prints nothing too — byte-identical. Real mspec enables the
  category; the vendored spec_helper.rb does not, and it is a sibling's file
  this wave. Making rbgo warn anyway would be a divergence, so it does not.
• 6 of Complex_spec's 14 and 2 of warn_spec's are the same kind of
  thing: MRI fails them under this shim too (the shim's mock_numeric is a
  plain mock, not a Numeric). Complex_spec is finished at 60 of a reachable
  62.
• $VERBOSE seeded to false in the globals map — MRI-correct, and it
  surfaces a real defect I could not fix from here. $VERBOSE now reads
  false, but rbgo's rb_warn gate still keys on the raw unset slot, so
  rb_warn-class warnings stay silent on a default run where MRI emits them.
  Seeding the slot (a one-line change, tried and measured) makes three
  warnings appear on EVERY run — already initialized constant Slim::Engine,
  Haml::Engine, OptParse — because rbgo's own prelude re-assigns constants
  the Go registration already set (prelude.rb:2261, 2347, 2417 over
  slim.go:36, haml.go:35, optparse.go:79). 48 pinned Go tests then fail
  on the extra stdout. The conformance benefit is zero (measured: 21804 in
  both states, and identical in all three target trees), so the seeding is not
  in this PR. The duplicate definitions are the thing to fix, in files outside
  this wave's allocation.
• core/kernel/sleep_spec.rb scores 0 because ONE example hangs the whole
  file. Fiber.new(blocking: false) { sleep }.resume never returns:
  Kernel#sleep (thread.go:1072) does not consult Fiber.scheduler, and
  fiber.go:307 says so in as many words ("rbgo runs every fiber blocking, so
  nothing consults the scheduler yet"). MRI dispatches to the scheduler's
  #kernel_sleep. Reduced to a 10-line reproduction. That file is worth 15
  examples and the fix is small, but it is thread.go + fiber.go, outside
  this wave's file allocation — flagging rather than reaching in.
• require does not search only $LOAD_PATH. file.c rb_find_file
  searches the load path ALONE for a bare name; rbgo also tries the requiring
  file's directory and the process CWD first (requireCandidates' default
  arm), which is what "does not load a bare filename unless the current
  working directory is in $LOAD_PATH" (2 examples) is about. Removing the
  fallback is MRI-correct but rbgo's $LOAD_PATH starts EMPTY, so it would
  change how every app-level require resolves. That is a project decision, not
  a conformance patch, so it is only reported.
• globals.go was not in this wave's allocation list, and neither was it in
  the do-not-touch list; it is where setGVar/specialGvar live, so the
  predefined-globals work is in it. complex.go was offered in the brief and
  taken. builtins.go, require.go, modulefunc.go and
  kernel_introspect.go are mine. Nothing under internal/compiler,
  internal/bytecode, vm.go, defined.go, object_model.go, file*.go,
  dir.go, exception.go, errno.go, go.mod, FLOOR or spec_helper.rb
  was touched.

🤖 Generated with Claude Code