Some native exceptions are wrapped too agressively

I think the simplest answer might be to have a JRuby ext that wraps the Clojure STM and allows the exceptions to propagate out. Current Java integration in JRuby can't support propagating the actual exception (because people have dependencies on the wrapper) and there are some tricky issues to move that direction in the future.

I am working on an experimental patch that removes the wrapping. After spiking a few ideas, I think I've come up with one that will work.

We will allow the real exception to propagate. We will no longer wrap it. Rescue clauses already can rescue the real exception class, but in the future that will be strongly recommended.

However, to make sure existing code continues to work, rescuing NativeException will still rescue Java exceptions propagating through JRuby. We wil lazily wrap them in a NativeException object, so it will work as before.

There are some grey areas, of course:

• Rescuing Object or Exception will, as they do now, rescue Java exceptions. However, they'll get the real exception rather than the NativeException wrapper. This could affect code that does a blanket rescue and then expects to get a NativeException object.
• Re-raising a NativeException should probably actually raise the wrapped Throwable. Raising the wrapper would cause upstream code to get unpredictable results.
• Entry points into JRuby currently do not "throws" anything. We may need to add "throws Throwable" entry points to allow callers to catch any exception type. This is entirely to appease Java's checked exceptions.

Once I have a prototype that does all this, I'll post a patch.

I have landed a change in 3391966 that fixes this. There's some additional work to be done, but the basics are there.

With the change, Java exceptions always propagate as themselves, even propagating all the way out of JRuby. The NativeException wrapper is mostly eliminated.

commit 33919667a45607aa3e7a23765e396d2dd940d643
Author: Charles Oliver Nutter <headius@headius.com>
Date:   Mon Apr 9 10:40:30 2012 -0500

    Propagate Java exceptions without wrapping in NativeException.
    
    Fix for JRUBY-6149 and others.
    
    Previous versions of JRuby wrapped Java exceptions raised from
    calling Java methods inside NativeException. This provided a way
    to rescue them, but also caused them to remain wrapped when they
    eventually leave Ruby-space. This in turn prevented some libraries
    that depend on the *original* exception propagating from working
    correctly, like Clojure wanting IllegalStateException to know an
    STM commit should be run again.
    
    This change removes NativeException from propagating, and instead
    actually propagates the original Java exception in JI-wrapped
    form. Rescue NativeException still works, but it rescues the real
    Java exception instead of a NativeException instance. This may
    need to be modified to wrap in NativeException.