[tannevaled]

Conformance wave 25, core/kernel + core/string. Every change was made after
reading the MRI C source for the method, and each one was witnessed
byte-for-byte against MRI 4.0.5 (ruby -e vs the built rbgo -e, raw bytes)
before and after.

Result (pinned rubyspec corpus, fail+error)

suite	before	after
core/kernel	233	184
core/string	179	153

No spec file anywhere in core/kernel or core/string regressed; the three
pre-existing crashes (kernel/exit_spec, kernel/sleep_spec,
string/unpack/carret_spec) are unchanged.

Biggest movers: require_relative_spec 26 → 2, require_spec 29 → 14,
load_spec 17 → 7, byterindex_spec 10 → 2, byteindex_spec 7 → 1,
split_spec 6 → 1, to_sym_spec 6 → 3, chars_spec / each_char_spec
3 → 1 each.

What was fixed, and what was read for it

load.c — rb_f_require_relative, search_required, load_lock

• rb_f_require_relative is
  rb_require_string_internal(rb_file_absolute_path(fname, dirname(base))), and
  rb_file_absolute_path ignores the base when fname is already absolute.
  rbgo joined it onto the requiring file's directory, so every absolute
  require_relative failed.
• The same expansion happens before require_internal runs, so the failing
  name load_failed reports — and the @path it stamps — is the expanded,
  cleaned absolute path with no .rb appended.
• load_lock issues the circular-require warning through rb_warning, so only
  in verbose mode, and only when rb_thread_shield_owned says the current
  thread already holds the feature's shield. A second thread arriving mid-load
  is a concurrent require, not a circular one — the loading marker is keyed by
  thread so the concurrent case stays silent.
• search_required asks rb_feature_p before rb_find_file_ext; for a name
  with no extension, a $LOADED_FEATURES entry equal to that name answers
  'u', and require reports false instead of raising.

file.c — rb_get_path, rb_find_file, is_explicit_relative

• rb_get_path = rb_get_path_check_to_string + rb_get_path_check_convert.
  The first takes a String as-is, else calls #to_path through
  rb_check_funcall_default(obj, to_path, 0, 0, obj) and runs StringValue
  over the result — so a #to_path returning a non-String has #to_str
  called on that value. requireName accepted a String only.
• rb_find_file expands a leading ~ through HOME and returns directly; an
  absolute path and an explicitly-relative one (./x, ../x) likewise return
  before the $LOAD_PATH walk. rbgo searched the load path for all three.
• Every $LOAD_PATH entry goes through rb_get_path as the list is walked, so
  an entry answering #to_path is a usable directory.
• isdirsep accepts a backslash only on Windows, so is_explicit_relative
  answers differently per platform; os.IsPathSeparator draws the same line.

error.c — raise_loaderror, rb_builtin_class_name

• rb_attr(rb_eLoadError, path, TRUE, FALSE, FALSE) exposes the path
  raise_loaderror stamps from the fname as passed. LoadError#path was
  missing.
• rb_builtin_class_name spells nil/true/false as those words; rbgo's
  classNameOf collapsed every object to "Object", so
  "no implicit conversion of true into String" read "... of Object ...".

string.c — rb_str_byteindex_m, rb_str_byterindex_m, rb_str_split_m,
chopped_length, rb_str_chars, rb_str_intern

• Both byte-index methods read the offset with NUM2LONG and the pattern with
  StringValue, so #to_int and #to_str apply; rbgo hard-checked both types.
• rb_str_byterindex_m searches with rb_reg_search(sub, str, pos, 1) — the
  trailing 1 is onig_search's reverse flag, so the search runs backwards
  over the whole subject. rbgo matched against the tail slice s[p:], which
  makes every slice start look like the start of the string: /\A/ reported 9
  instead of 0. Replaced with an anchored probe downwards from the offset, the
  byte-indexed twin of the existing strRindexRegexp.
• rb_str_split_m calls mustnot_broken on a String pattern and on the
  receiver; the awk and regexp paths reach the same refusal through
  rb_enc_check and the regexp engine. Its limit is read with NUM2INT, so a
  value outside the 32-bit range is a RangeError — and #to_int runs exactly
  once.
• chopped_length walks back with rb_enc_prev_char, and rb_str_chars steps
  with rb_enc_mbclen: "the last character" and "a character" are questions
  the encoding answers. Decoding as UTF-8 regardless took two bytes off a
  binary string, and — worse than a length error — the []rune round trip
  rewrote every invalid byte in the prefix as U+FFFD, corrupting bytes the
  operation never touched. That was the real cause of the split spec that builds
  its broken string with chop!.
• rb_str_intern re-tags an ASCII-only string as US-ASCII whatever encoding it
  arrived in; sym_encoding is rb_obj_encoding(rb_sym2str(sym)).
  Symbol#encoding was missing entirely.

One finding worth flagging: core/string/valid_encoding/utf_8_spec.rb

This file was the wave's headline target at pass=0 / 28 errors, described as
"probably one missing behaviour". It is not a VM gap at all. MRI 4.0.5 scores
exactly the same 0 pass / 28 error on it with this harness.

The file defines a utf8 helper with def inside a describe block and calls
it from it blocks in nested describes. The shim's SpecContext#run
instance_evals each example against the innermost context object, so self
is rebound and the helper — which landed on the outer context's singleton — is
unreachable. mspec calls example blocks plainly, leaving self as the
lexically enclosing describe's context, which is why it works there. rbgo
already matches MRI byte-for-byte on valid_encoding? for every case the file
exercises. The fix belongs in scripts/conformance/rubyspec/spec_helper.rb,
which this branch does not own.

Deliberately left red

Named here rather than accommodated, so none of them is sealed in by a weakened
assertion:

• "helloYOU.".byterindex(/YOU\G/, 8) needs the match's \G anchor pinned to
  the search start rather than to the probed start; the pinned
  go-ruby-regexp engine exposes no API for a separate global position.
• The EUC-JP Encoding::CompatibilityError cases in byte_index_common need
  regexp-side encoding negotiation.
• Three to_sym specs need the symbol to carry its source encoding
  (UTF-16LE, binary non-ASCII, and re-interning under a different encoding).
  rbgo's object.Symbol is an untagged Go string; Symbol#encoding derives
  US-ASCII / UTF-8 / ASCII-8BIT from the bytes, which matches MRI for every
  case this VM can represent, and answers by shape rather than provenance for
  the rest.
• require still resolves a bare name against the requiring file's directory
  and the CWD before $LOAD_PATH; MRI searches $LOAD_PATH only. That is a
  deliberate, long-standing rbgo convenience, and changing it reaches well
  beyond this suite — left for a wave that can measure the app and library
  suites alongside.
• gsub has the same slice-anchoring bug that byterindex had
  ("Text\n".gsub(/^/, " ") gives " T e x t \n ", and /\A/ re-matches every
  iteration), worth ~2 of gsub_spec's 12. The scan loop lives in
  internal/vm/regexp.go, outside this branch's file ownership for the wave, so
  it is reported rather than touched.

One pinned test updated

TestLoadPathRequire asserted that a non-String $LOAD_PATH entry is silently
skipped. MRI raises TypeError instead, and because
rb_get_expanded_load_path coerces the whole list before the search begins, the
position of the bad entry makes no difference — witnessed with 123 both
unshifted before and pushed after a directory that does hold the feature. The
test now pins the MRI-verified behaviour and gains the #to_path entry case.

Gates

• CGO_ENABLED=0 go build ./... and the full GOWORK=off go test ./... green
  (the only noise is the pre-existing tests dialing 127.0.0.1:1).
• internal/vm coverage 99.9%, with require.go and string_byteops.go at
  100% and the set of functions below 100% identical to main's, compared
  against a coverage profile taken from a worktree at the merge base. Twelve new
  whitebox tests cover every added branch.
• gofmt -l internal/vm/ empty; GOOS=wasip1 GOARCH=wasm and
  GOOS=windows GOARCH=amd64 both build; the one platform-dependent assertion
  is guarded on runtime.GOOS.

🤖 Generated with Claude Code