[GR-75874] Fix incorrect OtherContextException wrapper when exception returns to creator context.

PullRequest: graal/24167

Author: chumer

truffle/src/com.oracle.truffle.api.instrumentation.test/src/com/oracle/truffle/api/instrumentation/test/TruffleContextTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -614,6 +614,31 @@ public void testEvalInnerContextError() throws InteropException {
         innerContext.close();
     }
 
+    @Test
+    public void testInnerContextRethrowsOuterContextError() throws InteropException {
+        EvalContextTestException outerException = new EvalContextTestException();
+        EvalContextRethrowingObject innerObject = new EvalContextRethrowingObject(outerException);
+        AtomicReference<AbstractTruffleException> innerCaughtException = new AtomicReference<>();
+        setupLanguageThatReturns(() -> innerObject);
+
+        TruffleContext innerContext = languageEnv.newInnerContextBuilder().initializeCreatorContext(true).build();
+        outerException.expectedContext = languageEnv.getContext();
+        innerObject.expectedContext = innerContext;
+        innerObject.innerCaughtException = innerCaughtException;
+
+        Object result = innerContext.evalInternal(null, newTruffleSource());
+        assertNotEquals("must be wrapped", innerObject, result);
+        try {
+            InteropLibrary.getUncached().execute(result, outerException);
+            fail();
+        } catch (AbstractTruffleException e) {
+            assertSame(outerException, e);
+        }
+        assertNotNull(innerCaughtException.get());
+        assertEquals(1, innerObject.executeCount);
+        innerContext.close();
+    }
+
     @SuppressWarnings("serial")
     @ExportLibrary(InteropLibrary.class)
     static class EvalContextTestException extends AbstractTruffleException {
@@ -658,6 +683,45 @@ final Object execute(Object[] args) {
         }
     }
 
+    @ExportLibrary(InteropLibrary.class)
+    static class EvalContextRethrowingObject implements TruffleObject {
+
+        final EvalContextTestException outerException;
+        TruffleContext expectedContext;
+        AtomicReference<AbstractTruffleException> innerCaughtException;
+        int executeCount;
+
+        EvalContextRethrowingObject(EvalContextTestException outerException) {
+            this.outerException = outerException;
+        }
+
+        @ExportMessage
+        @TruffleBoundary
+        final boolean isExecutable() {
+            assertTrue(expectedContext.isEntered());
+            return true;
+        }
+
+        @ExportMessage
+        @TruffleBoundary
+        final Object execute(Object[] args) {
+            assertTrue(expectedContext.isEntered());
+            assertEquals(1, args.length);
+            executeCount++;
+            try {
+                InteropLibrary.getUncached().throwException(args[0]);
+                fail();
+            } catch (AbstractTruffleException e) {
+                Assert.assertNotSame(outerException, e);
+                innerCaughtException.set(e);
+                throw e;
+            } catch (InteropException e) {
+                throw CompilerDirectives.shouldNotReachHere(e);
+            }
+            return null;
+        }
+    }
+
     @Test
     public void testPublicEvalInnerContext() {
         // test that primitive values can just be passed through

truffle/src/com.oracle.truffle.api/src/com/oracle/truffle/api/TruffleContext.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -1274,7 +1274,7 @@ public Builder onExited(Consumer<Integer> r) {
 
         /**
          * Specifies a {@link Runnable} that will be executed when some operation on the new context
-         * attenmpted while the context is already {@link TruffleContext#close()} closed}. However,
+         * attempted while the context is already {@link TruffleContext#close() closed}. However,
          * the runnable will only be executed if the outer context is not closed.
          *
          * The purpose of the runnable is to allow throwing a custom guest exception before the

truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/OtherContextGuestObject.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -181,10 +181,16 @@ static Object sendImpl(Node node, PolyglotSharingLayer layer, Object receiver, M
     @TruffleBoundary
     static <T extends Throwable> RuntimeException migrateException(PolyglotContextImpl receiverContext, Throwable e, PolyglotContextImpl valueContext) throws T {
         if (e instanceof OtherContextException) {
+            // Same logic as in migrateValue()
             OtherContextException other = (OtherContextException) e;
             if (other.receiverContext == receiverContext && other.delegateContext == valueContext) {
+                // reuse wrapper it is already wrapped
                 throw other;
+            } else if (other.receiverContext == valueContext && other.delegateContext == receiverContext) {
+                // unpack foreign value it belongs to that context
+                throw (T) other.delegate;
             } else {
+                // Preserve original context of the delegate when forwarding through third context
                 throw new OtherContextException(receiverContext, other.delegate, other.delegateContext);
             }
         } else if (InteropLibrary.getUncached().isException(e)) {
@@ -338,13 +344,13 @@ static class OtherContextException extends AbstractTruffleException {
         }
 
         @TruffleBoundary
-        OtherContextException(PolyglotContextImpl thisContext, Exception delegate, PolyglotContextImpl delegateContext) {
+        OtherContextException(PolyglotContextImpl receiverContext, Exception delegate, PolyglotContextImpl delegateContext) {
             super(delegate.getMessage());
             assert !(delegate instanceof OtherContextException) : "recursive host foreign value found";
-            assert thisContext != null && delegateContext != null : "Must have associated contexts.";
-            assert thisContext != delegateContext : "no need for foreign value if contexts match";
+            assert receiverContext != null && delegateContext != null : "Must have associated contexts.";
+            assert receiverContext != delegateContext : "no need for foreign value if contexts match";
             this.delegate = delegate;
-            this.receiverContext = thisContext;
+            this.receiverContext = receiverContext;
             this.delegateContext = delegateContext;
         }
 

truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/PolyglotContextImpl.java

@@ -1720,6 +1720,7 @@ Object migrateValue(Object value, PolyglotContextImpl valueContext) {
         // guaranteed by migrateValue
         assert value instanceof TruffleObject;
         if (value instanceof OtherContextGuestObject) {
+            // Same logic as in migrateException()
             OtherContextGuestObject otherValue = (OtherContextGuestObject) value;
             if (otherValue.receiverContext == this && otherValue.delegateContext == valueContext) {
                 // reuse wrapper it is already wrapped