[tannevaled]

Harvest the line map: owner-qualified labels, warn(uplevel:), Thread.each_caller_location

Until #645 the parser's AST carried no source positions, so __LINE__ was 0 everywhere and the ISeq had no line table. #645 built MRI's compressed insns_info/positions table on ast.Program.Lines. Four spec files were waiting on that. This PR takes three of them; the fourth is blocked and is explained below.

Every behaviour here was checked byte-for-byte against ruby 4.0.5 before it was written, and each spec file was also run through the same shim under MRI so that a shim limitation is never mistaken for an rbgo defect.

1. warn(uplevel:) prepends the caller's file and line

internal/vm/io.go. Read: error.c rb_warn_m. The location comes from rb_ec_backtrace_location_ary(ec, lev + 1, 1, TRUE) and is formatted rb_sprintf("%s:%ld: warning: ", path, lineno), falling back to a bare "warning: " when there is none. The + 1 skips the warn cfunc's own frame; rbgo pushes no frame for a native, so level 0 is already the top of frameNames.

The scaffolding carried the comment "rbgo has no caller line to prepend". That is no longer true, and the comment is gone with the code.

Also from rb_warn_m: category: goes through rb_to_symbol_type, i.e. rb_convert_type_with_id(val, T_SYMBOL, "Symbol", idTo_sym). Anything answering #to_sym converts; rbgo accepted only Symbol and String and raised TypeError on the rest. Both TypeError messages now match MRI exactly. The level is also converted once rather than twice on the raise path.

2. Thread.each_caller_location

internal/vm/thread.go. Read: vm_backtrace.c each_caller_location (:1401) and ec_backtrace_range (:1300). It selects its range with ec_backtrace_range(ec, argc, argv, 1, 1, &n) — the same lev_default/lev_plus rb_f_caller_locations passes — so its argument handling is Kernel#caller_locations'. callerSlice therefore serves both instead of the rule being restated.

Three details that came from reading it rather than from the spec:

• rb_scan_args(argc, argv, "02:") caps the positionals at two, and the rb_get_kwargs after it runs against an empty keyword table — so every keyword is an unknown one.
• the LocalJumpError is raised by the rb_yield inside the iteration, not by a guard before it. A selection that yields nothing is not an error even with no block.
• the message is "no block given", not the "(yield)" form.

3. The owner prefix on every backtrace label

internal/vm/kernel_introspect.go, exception.go. Read: vm_backtrace.c rb_gen_method_name (:205), calculate_iseq_label (:229), location_label (:285), location_to_str (:460); variable.c classname / rb_mod_name0 (:104).

rbgo printed foo where ruby prints Object#foo. location_label and location_to_str both go through rb_gen_method_name, so the prefix lands on Thread::Backtrace::Location#label, on Kernel#caller and on the lines of an exception's backtrace alike.

Points that mattered:

• the prefix appears only when the class path is permanent. classname() reports permanent_classpath beside the path and a non-permanent one drops the prefix, so an anonymous Class.new labels its methods bare — as does a class given Module#set_temporary_name.
• calculate_iseq_label recurses through the block decoration, so the owner belongs to the method the block was written in and block (2 levels) in goes back in front of the qualified name.
• ISEQ_TYPE_TOP/CLASS return location.label untouched: <main>, <class:K>, <module:M> and a singleton-class body take no prefix.
• rbgo files a class method under the class (C.smethods, owner == C) where MRI files it under C's singleton class, so which of the two tables holds the name is what picks # from ..

Two things fell out of reading the C that the spec does not ask for:

• an aliased method now reports its original name. MRI's label is the ISeq's location.label, the name the body was defined under; rbgo printed the name it was called by. The other half is already in frameMethods[i].orig.
• Location#base_label must strip both decorations. MRI reads it from a separate field holding the plain compiled name, so "block (2 levels) in C#foo" has base label "foo". stripOwnerPrefix removes the owner only when what precedes the separator is a constant path (reusing isConstantPath, MRI's is_constant_path) — which is what leaves main.label_sdef_method_of_main whole.

Verified byte-for-byte on a 15-case matrix: instance method, block in one, nested block, def self.x, class << self, alias, base_label, module function, module instance method via extend, a nested class path, a top-level def, a per-object singleton, an anonymous class, a top-level block, and an exception backtrace line.

A latent defect this surfaced: three parallel frame stacks, four places that move one of them

frameNames, frameCrefs and frameMethods mirror each other one-for-one, and index i means the same frame in all three only while they are the same length. exec pushes and pops them together and every unwind restores them together — except at four sites that truncate frameNames alone:

site	trigger
internal/vm/builtins.go:381 (Kernel#catch)	fixed in this PR
internal/vm/find.go:153 (findYield)	Find.prune inside Find.find
internal/vm/irb_bind.go:65	any exception raised in an IRB statement
internal/vm/pstore.go:366	PStore#transaction with #commit / #abort

The drift is reachable from Ruby today — it is not merely latent. Nothing noticed while a backtrace read frameNames alone; frameLabel now reads all three, and one leaked entry made every later label some other frame's. Reproductions, both against ruby 4.0.5:

# Kernel#catch — fixed here
def probe(t); puts "#{t}: #{caller_locations(0)[0].label}"; end
probe("before")
def deep(n); n.zero? ? throw(:done, 1) : deep(n - 1); end
catch(:done) { deep(5) }
probe("after")
# ruby: Object#probe / Object#probe.  Before this fix: Object#probe / probe.

# Find.prune — NOT fixed here (internal/vm/find.go is not this wave's file)
require 'find'
def probe(t); puts "#{t}: #{caller_locations(0)[0].label}"; end
probe("before")
Find.find("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/some/dir") { |p| Find.prune if File.directory?(p) }
probe("after")
# ruby: Object#probe / Object#probe.  rbgo: Object#probe / probe.

I did not reach into the other three files. frameStacksAligned makes a drift from any of them cost the prefix rather than print another frame's owner — a visible degradation instead of a wrong answer — but it is a guard, not the fix. These three deserve their own issue, and the reproduction above is ready to paste into it.

On the shape. Three parallel slices kept in step by hand at seven push/pop/restore sites is a structure that will drift again; it already has, four times. The shape that makes it impossible is one slice of one struct — frameCode in the same file is already half of that, merging iseq and pc into a frameCode struct for exactly this reason, and its comment records that the merge cost nothing measurable (bench/blocks.rb, +7% either way). Folding frameNames, frameFiles, frameCrefs and frameMethods into that same struct would make a partial restore unrepresentable rather than merely wrong: there would be one slice to truncate. I have not done it — it touches vm.go, which another agent owns this wave — but the measurement that would normally gate it has already been taken.

Measurements

core/thread + core/module + core/kernel + language/ (recursive), 336 files, per file, at most 2-way:

file	before	after
core/thread/backtrace/location/label_spec.rb	7	27
core/thread/each_caller_location_spec.rb	0	5
every other file	—	unchanged

Total 5459 → 5484 (+25), with no per-file regression.

Two numbers that needed re-running before being believed, both pre-existing and neither caused by this branch:

• core/kernel/require_spec.rb read 68 under load and 69 serially; it is 69 both before and after.
• core/module/autoload_spec.rb (Intermittent crash popping a frame: slice bounds out of range [:-1] #615) crashes roughly 1 run in 4 and then contributes 0, which reads as a ~60-example regression. Measured on this branch: 60, 61, 61. On main: crash, 61. One sweep of three showed the crash; the other two did not.

language/ensure_spec.rb genuinely regressed 31 → 30 mid-way, which is how the frame-stack drift was found; it is back to 31 with the Kernel#catch fix.

FLOOR is untouched, as instructed. The ratchet is now +25 above it.

Gates

• CGO_ENABLED=0 go build ./... — clean; GOOS=wasip1 GOARCH=wasm — clean.
• CGO_ENABLED=0 GOWORK=off go test ./... — the full suite, green.
• gofmt -l internal/vm/ — empty.
• Coverage compared as a list against origin/main, not as a rounded total. internal/vm shows the same 15 functions under 100% on main and on this branch, at the same percentages: no gap opened, none closed, and none of the new functions is among them.
  A trap worth recording: go tool cover -func resolves a profile's line numbers against the working directory's source. Reading main's profile from this worktree misattributed 18 functions to 0.0% and made the branch look like it had closed 18 gaps. Each profile has to be rendered from its own tree.
• One branch was deleted rather than covered: frameOwner tested cref.attached.(*RClass) as a second route to rb_gen_method_name's "attached object is a class" case. All three sites that set attached store a per-object receiver, and ensureSingleton refuses a class outright (case *RClass: return nil, false), so the assertion could never succeed. metaOf is that case.

Six pinned assertions moved

Each was re-measured by writing the test's exact source to a file and running ruby 4.0.5 on it:

test	was	now
TestBacktraceCaptureChain	'foo', 'bar'	'Object#foo', 'Object#bar'
TestReRaisePreservesBacktrace	'deep'	'Object#deep'
TestFullMessageShape	'foo'	'Object#foo'
TestUncaughtBacktraceEscaping	'boom'	'Object#boom'
TestCallerStillWorks	'a'	'Object#a'
TestKernelWarn	"warning: x\n"	"(rbgo):1: warning: x\n" (two uplevel: cases)

TestStripBlockQualifier is replaced by TestSplitBlockQualifier and TestStripOwnerPrefix, the two halves base_label now has to undo.

Left undone, and why

core/module/const_source_location_spec.rb (30 examples) — not attempted. It cannot be done from this wave's files.

The prerequisite really is in place; the blocker is ownership, not the line map. const_source_location needs the file and line recorded where a constant is assigned, and in rbgo every user-level constant assignment funnels through assignConstIn (internal/vm/vm.go:2480), reached from OpSetConstIn (:1671) and OpSetConst (:1684). All three are in vm.go, which another agent owns this wave. I checked for a hook I could use instead: fireConstAdded exists in builtins.go and would have been exactly right, but it is called only from Module#const_set and from autoload.go — a plain A::B = v does not fire it. Reading the location back in module_residuals.go is a handful of lines once the recording exists.

Read for it anyway, so the next attempt does not have to: variable.c rb_const_source_location → rb_const_location(klass, id, FALSE, TRUE, FALSE) → rb_const_location_from (:3195). Note if (NIL_P(ce->file)) return rb_ary_new() — a constant defined in C answers [], not nil; a private constant answers nil under visibility; an autoload that has not fired answers the autoload's file and line only while the autoload mutex is held; and for a module receiver the search falls back to rb_cObject after the ancestor walk.

Two more gaps outside this wave's files, each of which blocks specs that would otherwise pass:

• methodSourceLocation (internal/vm/method_reflect2.go:190) returns line 0 rather than is.FirstLine, although Proc#source_location in builtins.go already uses the line map. This is a one-line change and it gates 4 of the 8 warn(uplevel:) examples: the spec computes its expected line as method(:f1).source_location[1] + 1, which is 1 instead of 434, so every uplevel assertion compares against the wrong number. core/kernel/warn_spec.rb therefore stays at pass=21 even though the output is byte-identical to MRI's. MRI under the same shim scores 25; the other 4 it beats us by are shim limits (the Warning[:deprecated] default and Warning.warn arity), which MRI fails too.

• a bare constant inside a class A::B body does not resolve through the enclosing lexical scope. class M::D nested in module S cannot see S::LABEL; MRI can. OpDefineClass's scoped-path branch (vm.go:1980) does not give the new class the enclosing scope as its lexParent. This costs 6 of the 14 remaining label_spec examples, as NameError: uninitialized constant LABEL from the fixture.

  module S
    LABEL = 42
    module M; end
    class M::D; def f = LABEL; end
  end
  p S::M::D.new.f   # ruby: 42   rbgo: NameError

label_spec is at 27 of 41 against MRI's 40 under the same shim. The 13:

#	example(s)	cause
6	M::D#scoped_method and five siblings	the class A::B constant-lookup gap above (vm.go)
1	a core method defined natively	needs a cfunc frame in the backtrace; rbgo pushes no frame for a native (vm.go)
1	a core method defined in Ruby	Kernel.instance_method(:tap).source_location — method_reflect2.go, and the prelude carries no file
2	a method defined via module_exec, M#module_eval_method	the frame records the lexical scope; for a method defined inside a module_exec/module_eval block the def target and the textual nesting differ, and the owner is not recoverable from the frame. Reports the bare name rather than a wrong owner.
1	M.mod_function	module_function files one Method in both tables; MRI tells the two call paths apart by the cme the call resolved to, which rbgo does not carry per frame. The instance form is chosen, so M#mod_function passes and M.mod_function does not.
1	return the same name as the caller for eval	eval frame labels
1	returns the base label of the call frame	MRI fails this under the shim too — not an rbgo gap

each_caller_location is at 5 of 6. The sixth, stops the backtrace iteration if 'break' occurs, fails on a pre-existing defect with no Thread in it: a break out of a block leaves its exec frame on vm.frameNames, because exec's recover truncates for a returnSignal only and a breakSignal re-panics past it. Every backtrace taken after a break is one frame too deep.

def top
  [1,2,3].each { |x| break x if x == 2 }
  p caller_locations(1,2).map(&:to_s)
end
def mid; top; end
mid
# ruby 4.0.5 -> ["...:5:in 'Object#mid'", "...:6:in '<main>'"]
# rbgo       -> ["...:3:in 'top'",        "...:5:in 'mid'"]

The fix belongs in exec's recover (vm.go) or in callBlock (object_model.go), both owned elsewhere this wave.

🤖 Generated with Claude Code