From: "mame (Yusuke Endoh) via ruby-core" <ruby-core@...>
Date: 2025-03-13T11:06:11+00:00
Subject: [ruby-core:121325] [Ruby master Misc#20968] `Array#fetch_values` unexpected method name in stack trace

Issue #20968 has been updated by mame (Yusuke Endoh).


I reconfirmed this with @matz during the dev meeting. He reiterated that `<internal:` should not be displayed.

To address this issue, the following approach is proposed:

1. Merge the consecutive `<internal:` frames into a single frame.
2. Use the method name of the bottom-most (closest to the root) frame for the merged frame.
3. Set the location (`filename:lineno`) of the merged frame to that of the first Ruby frame below the consecutive `<internal:` frames.

For example, consider the following frames:

```
...
        from bar.rb:1:in 'Bar#bar'
        from <internal:array>:111:in '...'
        from <internal:array>:111:in '...'
        from <internal:array>:111:in '...'
        from <internal:array>:111:in 'Array#fetch_values'
        from foo.rb:1:in 'Foo#foo'
...
```

When creating a backtrace object (such as when creating an exception object, calling `Kernel#caller_locations`, etc.), this should be condensed to:

```
...
        from bar.rb:1:in 'Bar#bar'
        from foo.rb:1:in 'Array#fetch_values'
        from foo.rb:1:in 'Foo#foo'
...
```

(`Array#fetch_values` is just an example; other built-in methods should be handled in the same way.)

----------------------------------------
Misc #20968: `Array#fetch_values` unexpected method name in stack trace
https://bugs.ruby-lang.org/issues/20968#change-112292

* Author: koic (Koichi ITO)
* Status: Open
----------------------------------------

It seems that the current Ruby implementation is displaying unexpected method name in stack trace.

## Expected

Similar to `Hash#fetch_values`, the method name `Array#fetch_values` is expected to be displayed in the stack trace.

```console
$ ruby -e '{k: 42}.fetch_values(:unknown)'
-e:1:in 'Hash#fetch_values': key not found: :unknown (KeyError)
        from -e:1:in '<main>'

$ ruby -e '[1].fetch_values(42)'
-e:1:in 'Array#fetch_values': index 42 outside of array bounds: -1...1 (IndexError)
        from -e:1:in '<main>'
```


## Actual

The stack trace displays the `Array#fetch` method, which user is not aware of, along with the `<internal.array>` stack trace.

```console
$ ruby -e '[1].fetch_values(42)'
<internal:array>:211:in 'Array#fetch': index 42 outside of array bounds: -1...1 (IndexError)
        from <internal:array>:211:in 'block in Array#fetch_values'
        from <internal:array>:211:in 'Array#map!'
        from <internal:array>:211:in 'Array#fetch_values'
        from -e:1:in '<main>'
```


It likely requires an approach such as implementing it in C, as suggested in https://github.com/ruby/ruby/pull/11555.



-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/