Issue #20968 has been updated by Eregon (Benoit Daloze). Another way to look at it is if `Array#fetch_values` was defined by a gem (e.g. by `activesupport`), then everyone would expect: ``` <internal:array>:211:in 'Array#fetch': index 42 outside of array bounds: -1...1 (IndexError) from /path/to/activesupport/some/file.rb:211:in 'block in Array#fetch_values' from /path/to/activesupport/some/file.rb:211:in 'Array#map!' from /path/to/activesupport/some/file.rb:211:in 'Array#fetch_values' from -e:1:in '<main>' ``` So the fact it's `<internal:array>:211` instead of `/path/to/activesupport/some/file.rb:211` in the description seems a very small expected difference, it's just defined "in a core library Ruby file" vs "in a gem Ruby file". I think this argument is strong enough on its own to not change stacktraces until a concrete problem is reported with the current core library stacktraces. --- Maybe the core library Ruby paths could be a bit nicer like `<internal:/path/to/array.rb>:211` then potentially editors could just open that. It would be pretty cool if users could just see the implementation of some core library methods defined in Ruby. FWIW TruffleRuby uses `<internal:core> core/array.rb:211` which I think is nice and clear: ``` $ ruby -e '1.tap { raise "foo" }' -e:1:in `block in <main>': foo (RuntimeError) from <internal:core> core/kernel.rb:520:in `tap' from -e:1:in `<main>' ``` We could ship these core files with CRuby to make it easier to understand what's going on. We'd add a comment on top of the file explaining modifying the file would have no effect as the source is not used, only its bytecode. ---------------------------------------- Misc #20968: `Array#fetch_values` unexpected method name in stack trace https://bugs.ruby-lang.org/issues/20968#change-112044 * 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/