j.l.invoke and the wrapping of exceptions

[Paul Sandoz]

Hi,

Recent discussion on the wrapping of exceptions (any Throwable) in LinkageError be it for invokedynamic and BootstrapMethodError (a spec issue) or for signature polymorphic linkage (an implementation detail AFAICT) resulted in a more detailed look at the exception handling in the j.l.invoke code.

To partially fix signature polymorphic linkage i have made some small modifications [1] but i found i need to dig deeper as there are many other cases where Throwable is wrapped, specifically with the calls to MethodHandleStatic.newInternalError:

  /*non-public*/ static InternalError newInternalError(Throwable cause) {
      return new InternalError(cause);
  }

There is also MethodHandleStatic.uncaughtException

  /** Propagate unchecked exceptions and errors, but wrap anything checked and throw that instead. */
  /*non-public*/ static Error uncaughtException(Throwable ex) {
      if (ex instanceof Error)  throw (Error) ex;
      if (ex instanceof RuntimeException)  throw (RuntimeException) ex;
      throw newInternalError("uncaught exception", ex);
  }

There may be cases where these are interchangeable, it’s subtle, and i would be away of replacing calls to newInternalError with uncaughtException.

I propose the following:

1) change newInternalError(String message, Throwable cause) to newInternalError(String message, Exception cause)
We want to be clear that the cause is an Exception, since this method will always return InternalError with a message.

2) replace newInternalError(Throwable cause) with  errorOrNewInternalError(Throwable ex)

    /*non-public*/ static Error errorOrNewInternalError(Throwable ex) {
        if (ex instanceof Error) return (Error) ex;
        return newInternalError("uncaught exception", ex);
    }

In all cases existing Errors will never be wrapped.

3) It’s tempting to rename uncaughtException with uncheckedOrNewInternalError.

Paul.

[1]
diff -r 248159c6e61a src/java.base/share/classes/java/lang/invoke/LambdaForm.java
--- a/src/java.base/share/classes/java/lang/invoke/LambdaForm.java	Wed Aug 24 11:23:58 2016 -0700
+++ b/src/java.base/share/classes/java/lang/invoke/LambdaForm.java	Wed Aug 24 15:31:29 2016 -0700
@@ -41,7 +41,6 @@
 import static java.lang.invoke.LambdaForm.BasicType.*;
 import static java.lang.invoke.MethodHandleNatives.Constants.REF_invokeStatic;
 import static java.lang.invoke.MethodHandleStatics.*;
-import java.util.Objects;

 /**
  * The symbolic, non-executable form of a method handle's invocation semantics.
@@ -856,7 +855,7 @@
                 System.out.println("LambdaForm compilation failed: " + this);
                 bge.printStackTrace(System.out);
             }
-        } catch (Error | Exception e) {
+        } catch (Exception e) {
             throw newInternalError(this.toString(), e);
         }
     }
diff -r 248159c6e61a src/java.base/share/classes/java/lang/invoke/MethodHandle.java
--- a/src/java.base/share/classes/java/lang/invoke/MethodHandle.java	Wed Aug 24 11:23:58 2016 -0700
+++ b/src/java.base/share/classes/java/lang/invoke/MethodHandle.java	Wed Aug 24 15:31:29 2016 -0700
@@ -957,7 +957,7 @@
         if (!fail)  return needType;
         // elicit an error:
         this.asType(needType);
-        throw newInternalError("should not return", null);
+        throw newInternalError("should not return");
     }

     private void spreadArrayChecks(Class<?> arrayType, int arrayLength) {
diff -r 248159c6e61a src/java.base/share/classes/java/lang/invoke/MethodHandleNatives.java
--- a/src/java.base/share/classes/java/lang/invoke/MethodHandleNatives.java	Wed Aug 24 11:23:58 2016 -0700
+++ b/src/java.base/share/classes/java/lang/invoke/MethodHandleNatives.java	Wed Aug 24 15:31:29 2016 -0700
@@ -380,8 +380,11 @@
                 }
             }
         } catch (Throwable ex) {
-            if (ex instanceof LinkageError)
-                throw (LinkageError) ex;
+            // Pass through all instances of Error, thus ensuring errors such as
+            // ThreadDeath, StackOverflowException, OutOfMemoryException etc.
+            // are not wrapped
+            if (ex instanceof Error)
+                throw (Error) ex;
             else
                 throw new LinkageError(ex.getMessage(), ex);