[ruby-core:86528] [Ruby trunk Bug#14684] IRB swallows exceptions

[ruby-core:86528] [Ruby trunk Bug#14684] IRB swallows exceptions

[msiegel]

Issue #14684 has been reported by RubyBugs (A Nonymous).

----------------------------------------
Bug #14684: IRB swallows exceptions
https://bugs.ruby-lang.org/issues/14684

* Author: RubyBugs (A Nonymous)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
* ruby -v: ruby 2.3.4p301 (2017-03-30 revision 58214) [x86_64-darwin15]
* Backport: 2.3: UNKNOWN, 2.4: UNKNOWN, 2.5: UNKNOWN
----------------------------------------
# Summary

IRB swallows exceptions, doesn't provide programatic access to raised exception in session.

## Details

On Ruby 2.3.4, we find it surprising that exceptions in IRB are swallowed, and are not accessible at the two locations we checked:

1. In the global variable for most recent exception `$!`
2. In the return value of evaluating the expression `_`

Consider this IRB session:

~~~ ruby
def method_which_raises
  1/0
end

method_which_raises

# ZeroDivisionError: divided by 0
#	from (irb):10:in `/'
#	from (irb):10:in `method_which_raises'
#	from (irb):13
#	from /Users/marcsiegel/.rubies/ruby-2.3.4/bin/irb:11:in `<main>'
~~~

### Observed

Neither `_` nor `$!` give access to the raised exception, so that during development or debugging, one could dig further into what had occurred.

### Expected

Either `_` or `$!` would give programmatic access in IRB to an exception




-- 
https://bugs.ruby-lang.org/

[ruby-core:86535] [Ruby trunk Bug#14684][Assigned] IRB swallows exceptions

[hsbt]

Issue #14684 has been updated by hsbt (Hiroshi SHIBATA).

Status changed from Open to Assigned
Assignee set to keiju (Keiju Ishitsuka)

----------------------------------------
Bug #14684: IRB swallows exceptions
https://bugs.ruby-lang.org/issues/14684#change-71474

* Author: RubyBugs (A Nonymous)
* Status: Assigned
* Priority: Normal
* Assignee: keiju (Keiju Ishitsuka)
* Target version: 
* ruby -v: ruby 2.3.4p301 (2017-03-30 revision 58214) [x86_64-darwin15]
* Backport: 2.3: UNKNOWN, 2.4: UNKNOWN, 2.5: UNKNOWN
----------------------------------------
# Summary

IRB swallows exceptions, doesn't provide programatic access to raised exception in session.

## Details

On Ruby 2.3.4, we find it surprising that exceptions in IRB are swallowed, and are not accessible at the two locations we checked:

1. In the global variable for most recent exception `$!`
2. In the return value of evaluating the expression `_`

Consider this IRB session:

~~~ ruby
def method_which_raises
  1/0
end

method_which_raises

# ZeroDivisionError: divided by 0
#	from (irb):10:in `/'
#	from (irb):10:in `method_which_raises'
#	from (irb):13
#	from /Users/marcsiegel/.rubies/ruby-2.3.4/bin/irb:11:in `<main>'
~~~

### Observed

Neither `_` nor `$!` give access to the raised exception, so that during development or debugging, one could dig further into what had occurred.

### Expected

Either `_` or `$!` would give programmatic access in IRB to an exception




-- 
https://bugs.ruby-lang.org/

[ruby-core:86541] [Ruby trunk Bug#14684] IRB swallows exceptions

[nobu]

Issue #14684 has been updated by nobu (Nobuyoshi Nakada).


`$!` isn't accessible outside `rescue` clause, even without irb.

----------------------------------------
Bug #14684: IRB swallows exceptions
https://bugs.ruby-lang.org/issues/14684#change-71479

* Author: RubyBugs (A Nonymous)
* Status: Assigned
* Priority: Normal
* Assignee: keiju (Keiju Ishitsuka)
* Target version: 
* ruby -v: ruby 2.3.4p301 (2017-03-30 revision 58214) [x86_64-darwin15]
* Backport: 2.3: UNKNOWN, 2.4: UNKNOWN, 2.5: UNKNOWN
----------------------------------------
# Summary

IRB swallows exceptions, doesn't provide programatic access to raised exception in session.

## Details

On Ruby 2.3.4, we find it surprising that exceptions in IRB are swallowed, and are not accessible at the two locations we checked:

1. In the global variable for most recent exception `$!`
2. In the return value of evaluating the expression `_`

Consider this IRB session:

~~~ ruby
def method_which_raises
  1/0
end

method_which_raises

# ZeroDivisionError: divided by 0
#	from (irb):10:in `/'
#	from (irb):10:in `method_which_raises'
#	from (irb):13
#	from /Users/marcsiegel/.rubies/ruby-2.3.4/bin/irb:11:in `<main>'
~~~

### Observed

Neither `_` nor `$!` give access to the raised exception, so that during development or debugging, one could dig further into what had occurred.

### Expected

Either `_` or `$!` would give programmatic access in IRB to an exception




-- 
https://bugs.ruby-lang.org/

[ruby-core:86542] [Ruby trunk Feature#14684] IRB swallows exceptions

[msiegel]

Issue #14684 has been updated by RubyBugs (A Nonymous).


nobu (Nobuyoshi Nakada) wrote:
> `$!` isn't accessible outside `rescue` clause, even without irb.

In IRB, should `$!` be set, or a proxy for it be set, when the IRB eval handles an exception?

----------------------------------------
Feature #14684: IRB swallows exceptions
https://bugs.ruby-lang.org/issues/14684#change-71482

* Author: RubyBugs (A Nonymous)
* Status: Assigned
* Priority: Normal
* Assignee: keiju (Keiju Ishitsuka)
* Target version: 
----------------------------------------
# Summary

IRB swallows exceptions, doesn't provide programatic access to raised exception in session.

## Details

On Ruby 2.3.4, we find it surprising that exceptions in IRB are swallowed, and are not accessible at the two locations we checked:

1. In the global variable for most recent exception `$!`
2. In the return value of evaluating the expression `_`

Consider this IRB session:

~~~ ruby
def method_which_raises
  1/0
end

method_which_raises

# ZeroDivisionError: divided by 0
#	from (irb):10:in `/'
#	from (irb):10:in `method_which_raises'
#	from (irb):13
#	from /Users/marcsiegel/.rubies/ruby-2.3.4/bin/irb:11:in `<main>'
~~~

### Observed

Neither `_` nor `$!` give access to the raised exception, so that during development or debugging, one could dig further into what had occurred.

### Expected

Either `_` or `$!` would give programmatic access in IRB to an exception




-- 
https://bugs.ruby-lang.org/

[ruby-core:86558] [Ruby trunk Feature#14684] IRB swallows exceptions

[msiegel]

Issue #14684 has been updated by RubyBugs (A Nonymous).


@nobu:

Would it be possible to back-port this to Ruby 2.3, 2.4, and 2.5?

Or, would you be willing to review patches from me to back-port this?

----------------------------------------
Feature #14684: IRB swallows exceptions
https://bugs.ruby-lang.org/issues/14684#change-71500

* Author: RubyBugs (A Nonymous)
* Status: Closed
* Priority: Normal
* Assignee: keiju (Keiju Ishitsuka)
* Target version: 
----------------------------------------
# Summary

IRB swallows exceptions, doesn't provide programatic access to raised exception in session.

## Details

On Ruby 2.3.4, we find it surprising that exceptions in IRB are swallowed, and are not accessible at the two locations we checked:

1. In the global variable for most recent exception `$!`
2. In the return value of evaluating the expression `_`

Consider this IRB session:

~~~ ruby
def method_which_raises
  1/0
end

method_which_raises

# ZeroDivisionError: divided by 0
#	from (irb):10:in `/'
#	from (irb):10:in `method_which_raises'
#	from (irb):13
#	from /Users/marcsiegel/.rubies/ruby-2.3.4/bin/irb:11:in `<main>'
~~~

### Observed

Neither `_` nor `$!` give access to the raised exception, so that during development or debugging, one could dig further into what had occurred.

### Expected

Either `_` or `$!` would give programmatic access in IRB to an exception




-- 
https://bugs.ruby-lang.org/

[ruby-core:86559] [Ruby trunk Feature#14684] IRB swallows exceptions

[nobu]

Issue #14684 has been updated by nobu (Nobuyoshi Nakada).


I changed the tracker to "Feature", as I thought it would not need to backport.
But branch maintainers may have different opinion.
It seems easy to apply the commits to the old branches.

----------------------------------------
Feature #14684: IRB swallows exceptions
https://bugs.ruby-lang.org/issues/14684#change-71501

* Author: RubyBugs (A Nonymous)
* Status: Closed
* Priority: Normal
* Assignee: keiju (Keiju Ishitsuka)
* Target version: 
----------------------------------------
# Summary

IRB swallows exceptions, doesn't provide programatic access to raised exception in session.

## Details

On Ruby 2.3.4, we find it surprising that exceptions in IRB are swallowed, and are not accessible at the two locations we checked:

1. In the global variable for most recent exception `$!`
2. In the return value of evaluating the expression `_`

Consider this IRB session:

~~~ ruby
def method_which_raises
  1/0
end

method_which_raises

# ZeroDivisionError: divided by 0
#	from (irb):10:in `/'
#	from (irb):10:in `method_which_raises'
#	from (irb):13
#	from /Users/marcsiegel/.rubies/ruby-2.3.4/bin/irb:11:in `<main>'
~~~

### Observed

Neither `_` nor `$!` give access to the raised exception, so that during development or debugging, one could dig further into what had occurred.

### Expected

Either `_` or `$!` would give programmatic access in IRB to an exception




-- 
https://bugs.ruby-lang.org/

[ruby-core:86565] [Ruby trunk Feature#14684] IRB swallows exceptions

[msiegel]

Issue #14684 has been updated by RubyBugs (A Nonymous).


Hmm. Our hope would be to have this "easy" change back-ported to 2.3, 2.4, and 2.5 -- waiting until December to have it in final 2.6 seems a long time to wait for this? Please let us know how we can help.

----------------------------------------
Feature #14684: IRB swallows exceptions
https://bugs.ruby-lang.org/issues/14684#change-71505

* Author: RubyBugs (A Nonymous)
* Status: Closed
* Priority: Normal
* Assignee: keiju (Keiju Ishitsuka)
* Target version: 
----------------------------------------
# Summary

IRB swallows exceptions, doesn't provide programatic access to raised exception in session.

## Details

On Ruby 2.3.4, we find it surprising that exceptions in IRB are swallowed, and are not accessible at the two locations we checked:

1. In the global variable for most recent exception `$!`
2. In the return value of evaluating the expression `_`

Consider this IRB session:

~~~ ruby
def method_which_raises
  1/0
end

method_which_raises

# ZeroDivisionError: divided by 0
#	from (irb):10:in `/'
#	from (irb):10:in `method_which_raises'
#	from (irb):13
#	from /Users/marcsiegel/.rubies/ruby-2.3.4/bin/irb:11:in `<main>'
~~~

### Observed

Neither `_` nor `$!` give access to the raised exception, so that during development or debugging, one could dig further into what had occurred.

### Expected

Either `_` or `$!` would give programmatic access in IRB to an exception




-- 
https://bugs.ruby-lang.org/