[ruby-core:121216] [Ruby master Misc#20968] `Array#fetch_values` unexpected method name in stack trace

Issue #20968 has been updated by ioquatix (Samuel Williams).


I also agree this is not a bug and the expanded stack trace is good. But let me talk about my experience with Objective-C.

A long time ago, I created Objective-C applications with Apple's Cocoa framework. It uses "delegate" pattern extensively which are essentially callbacks wrapped in objects with a well defined interface.

In particular, Apple's frameworks were soemtimes buggy, but using adebugger, all the intermediate stack traces are hidden. So a stack trace (or thread backtrace) would show something like:

```
<your delegate implementation>
<hidden internal function call>
<hidden internal function call>
<hidden internal function call>
<possibly user code>
```

This made debugging EXTREMELY difficult because it was impossible to figure out what the expectations of the `<hidden internal function call>` were - no way to correlate it back to code or even inspect what was going on.

Now, back to Ruby. I greatly prefer visibility in the stack trace. If something goes wrong (usual cause of exception with backtrace), even if it was the user code that made a mistake (e.g.  the implementation of `hash` or something invoked by the internal code), it can be extremely helpful if the user can easily find that code in order to read it and debug their own code.

This difficulty with Objective-C was one of the reasons I eventually stopped using it - the frameworks were too opaque and it made debugging extremely painful.

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

* 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 -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/