Rethrow JVM errors unchanged in MethodHandleFactory.invokeExact (#70)

An undeclared Error raised through the MethodHandle lookup path (an
OutOfMemoryError, for example) was wrapped in IllegalStateException,
demoting it from Error to RuntimeException and hiding it from
supervisors that handle Error separately. Rethrow it unchanged; the
IllegalStateException wrap now covers runtime exceptions only, since
the looked-up factory methods declare no other checked exceptions.
Assert instance identity, not just type, on both rethrow paths.

Assisted-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CLnTBsvmYtxzNTWVGNyz33

Author: ppkarwasz

src/main/java/org/apache/commons/xml/secure/MethodHandleFactory.java

@@ -56,7 +56,11 @@ static <T, E extends Throwable> T invokeExact(final ThrowableCallable<T> methodH
             if (rethrow.isInstance(e)) {
                 throw rethrow.cast(e);
             }
-            // Unreachable: the looked-up method declares no other exceptions.
+            if (e instanceof Error) {
+                // A JVM error (OutOfMemoryError, ...) must keep its type; only exceptions are wrapped.
+                throw (Error) e;
+            }
+            // The looked-up method declares no checked exceptions besides rethrow's type, so this wraps runtime exceptions only.
             throw new IllegalStateException(e);
         }
     }

src/test/java/org/apache/commons/xml/secure/MethodHandleFactoryTest.java

@@ -21,6 +21,7 @@
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.lang.invoke.MethodHandle;
@@ -54,9 +55,20 @@ void findStaticReturnsNullForMissingMethod() {
 
     @Test
     void invokeExactRethrowsDeclaredException() {
-        assertThrows(FactoryConfigurationError.class, () -> MethodHandleFactory.invokeExact(() -> {
-            throw new FactoryConfigurationError("boom");
+        final FactoryConfigurationError declared = new FactoryConfigurationError("boom");
+        final FactoryConfigurationError thrown = assertThrows(FactoryConfigurationError.class, () -> MethodHandleFactory.invokeExact(() -> {
+            throw declared;
         }, FactoryConfigurationError.class), "an exception of the declared type must be rethrown");
+        assertSame(declared, thrown, "the declared exception must propagate unchanged");
+    }
+
+    @Test
+    void invokeExactRethrowsUndeclaredError() {
+        final OutOfMemoryError error = new OutOfMemoryError("boom");
+        final OutOfMemoryError thrown = assertThrows(OutOfMemoryError.class, () -> MethodHandleFactory.invokeExact(() -> {
+            throw error;
+        }, FactoryConfigurationError.class), "a JVM error must keep its type");
+        assertSame(error, thrown, "the error must propagate unchanged");
     }
 
     @Test