daniellansun commented on code in PR #3298:
URL: https://github.com/apache/groovy/pull/3298#discussion_r4571183253


##########
COMPATIBILITY.md:
##########
@@ -1683,6 +1683,24 @@ time, is unaffected.
 **Who is not affected (binary).** Existing call sites are compiled against
 the unchanged existing overloads.
 
+### Groovy 6.0.1 — async constructs rethrow a checked exception as itself 
(GROOVY-12763)
+
+In 6.0.0, `await` rethrew a checked exception from an async task unchanged,
+but other async constructs wrapped it: a scope's child task failure and a
+`defer` action in `RuntimeException`, a `withScope` body and a generator body
+in `UndeclaredThrowableException`, and a `Flow.Publisher` error consumed with
+`for await` in `RuntimeException`. All of them now rethrow the original
+exception, as `await` does. Async/await is incubating.
+
+**Who is affected.** Code that catches `RuntimeException` or
+`UndeclaredThrowableException` around these constructs and reads
+`getCause()` to find a checked exception. Catch the checked exception
+directly instead. Java callers of `AsyncScope.close()` and `withScope`,
+which declare no checked exceptions, catch `Exception` and test its type.
+
+**What is unchanged.** Unchecked exceptions and errors, which were never
+wrapped, and `await` itself. There are no API changes.

Review Comment:
   Minor wording nit: since `org.apache.groovy.runtime.async.AsyncSupport` 
promotes `rethrow(Throwable)` to `public static RuntimeException` and adds 
`public static Throwable unwrapUndeclared(Throwable)` for cross-package access 
from `groovy.concurrent`, would it be slightly more accurate to scope this 
statement to `groovy.concurrent`?
   
   ```suggestion
   **What is unchanged.** Unchecked exceptions and errors, which were never
   wrapped, and `await` itself. There are no public API signature changes in 
`groovy.concurrent`.
   ```



##########
src/main/java/org/apache/groovy/runtime/async/AsyncSupport.java:
##########
@@ -265,15 +265,14 @@ public static void executeDeferScope(Deque<Callable<?>> 
scope) {
             } catch (Throwable t) {
                 if (firstError == null) {
                     firstError = t;
-                } else {
+                } else if (t != firstError) {
+                    // Deferred actions may rethrow one shared exception 
instance
                     firstError.addSuppressed(t);
                 }
             }
         }
         if (firstError != null) {
-            if (firstError instanceof RuntimeException re) throw re;
-            if (firstError instanceof Error err) throw err;
-            throw new RuntimeException(firstError);
+            throw rethrow(firstError);

Review Comment:
   Two subtle observations on `executeDeferScope`:
   
   1. **Wrapper behavior across `async` tasks vs. `async` generators:** 
`executeDeferScope` itself keeps `firstError` as-is (`throw 
rethrow(firstError)` without calling `unwrap`). In 
`testScopeChildAndDeferUnwrapAsAwaitDoes`, `await async { defer { throw new 
ExecutionException(new IOException('inner')) }; 1 }` unwraps 
`ExecutionException` only because the outer `await` runs 
`AsyncSupport.unwrap(...)` on the completed future. If the exact same `defer` 
block runs inside an `async` generator (`yield return`), `GeneratorBridge` 
calls `unwrapUndeclared` rather than `unwrap`, so `ExecutionException` is 
preserved. Keeping `executeDeferScope` wrapper-neutral here actually feels like 
the right design—just worth noting so the test comment / PR description aligns 
with what happens in generator-hosted `defer` blocks.
   2. **Transitive duplicate suppression:** `t != firstError` prevents 
self-suppression against `firstError`, which fixes the crash in `GROOVY-12764`. 
If Action 1 throws `errA` and Actions 2 and 3 both rethrow a shared `errB` 
(`errB != errA`), `errB` is still appended twice to `errA.getSuppressed()`. A 
small `addSuppressedUnique(firstError, t)` helper (shared with 
`DefaultAsyncScope.close()`) would keep `getSuppressed()` free of duplicate 
object references in fan-out cleanup scenarios.



##########
src/main/java/org/apache/groovy/runtime/async/AsyncSupport.java:
##########
@@ -547,11 +546,35 @@ public static Throwable unwrap(Throwable t) {
     }
 
     /**
-     * Rethrows {@code failure} as itself, including a checked exception.
+     * Removes the {@link UndeclaredThrowableException} that converting a 
closure
+     * to a functional interface such as {@code Function} or {@code Consumer} 
puts
+     * around a checked exception. Only that layer is removed: any other 
wrapper,
+     * including one the code threw itself, is returned unchanged.
+     *
+     * @param t the exception thrown through the converted closure
+     * @return the checked exception it carries, or {@code t} itself
+     */
+    public static Throwable unwrapUndeclared(Throwable t) {
+        if (t instanceof UndeclaredThrowableException) {
+            Throwable cause = t.getCause();
+            if (cause != null && !(cause instanceof RuntimeException) && 
!(cause instanceof Error)) {
+                return cause;
+            }
+        }
+        return t;
+    }

Review Comment:
   If I am tracing this right, stripping a wrapper via `t.getCause()` in both 
`unwrapUndeclared` and `unwrap` (just above line 546) will silently drop any 
suppressed exceptions that were attached to the outer wrapper 
(`t.getSuppressed()`).
   
   For example, when an earlier-executed `defer` action (or a `Future.get()` / 
reflective `Method.invoke()` call inside `async`) throws 
`ExecutionException(IOException('primary'))` and a subsequent `defer` action 
(or inner `try-with-resources`) throws `IOException('cleanup')`:
   1. `executeDeferScope` attaches `IOException('cleanup')` via 
`firstError.addSuppressed(...)` onto the outer `ExecutionException`.
   2. `await` (or `DefaultAsyncScope.close()`) calls 
`AsyncSupport.unwrap(...)`, returning the inner `IOException('primary')` with 
`getSuppressed().length == 0`—losing `'cleanup'`.
   
   The same loss can happen in `unwrapUndeclared` if an intermediate resource 
guard attaches a suppressed exception onto `UndeclaredThrowableException` 
before `withScope` or `GeneratorBridge` unwraps it. Since 
`Throwable.getSuppressed()` returns a shared empty array constant in OpenJDK 
when no suppressed exceptions exist, migrating them is allocation-free on the 
common path:
   
   ```suggestion
       public static Throwable unwrapUndeclared(Throwable t) {
           if (t instanceof UndeclaredThrowableException) {
               Throwable cause = t.getCause();
               if (cause != null && !(cause instanceof RuntimeException) && 
!(cause instanceof Error)) {
                   return transferSuppressed(t, cause);
               }
           }
           return t;
       }
   
       private static Throwable transferSuppressed(Throwable wrapper, Throwable 
unwrapped) {
           for (Throwable suppressed : wrapper.getSuppressed()) {
               if (suppressed != unwrapped) {
                   unwrapped.addSuppressed(suppressed);
               }
           }
           return unwrapped;
       }
   ```
   
   If we apply the same `transferSuppressed(current, next)` step inside 
`unwrap(Throwable t)`'s loop above, suppressed cleanup failures across `await`, 
`DefaultAsyncScope.close()`, `withScope`, and `GeneratorBridge` will all be 
preserved intact.
   
   *(Minor side note: adding a brief Javadoc sentence on `unwrapUndeclared` and 
`rethrow` noting that `AsyncSupport` is internal runtime infrastructure—not 
user-facing public API—could also help preserve refactoring flexibility when we 
revisit closure conversion in a later release.)*



##########
src/main/java/org/apache/groovy/runtime/async/FlowPublisherAdapter.java:
##########
@@ -268,9 +268,7 @@ public boolean hasNext() {
                 }
                 if (item == ERROR) {
                     terminated = true;
-                    if (error instanceof RuntimeException re) throw re;
-                    if (error instanceof Error err) throw err;
-                    throw new RuntimeException(error);
+                    throw AsyncSupport.rethrow(error);

Review Comment:
   +1 on using plain `AsyncSupport.rethrow(error)` here without `unwrap` or 
`unwrapUndeclared`. That ensures publisher-originated wrappers in reactive 
ecosystems (such as Project Reactor's `Exceptions.propagate` / 
`ReactiveException`) are preserved as upstream semantics rather than stripped 
as Groovy machinery, while raw checked exceptions signaled via 
`onError(Throwable)` propagate transparently.



##########
src/main/java/org/apache/groovy/runtime/async/GeneratorBridge.java:
##########
@@ -117,9 +117,8 @@ public boolean hasNext() {
             done = true;
             Throwable error = (Throwable) pending[1];
             pending = null;
-            if (error instanceof RuntimeException re) throw re;
-            if (error instanceof Error err) throw err;
-            throw new RuntimeException(error);
+            // A checked exception from the generator body arrives wrapped by 
its SAM coercion
+            throw AsyncSupport.rethrow(AsyncSupport.unwrapUndeclared(error));

Review Comment:
   Non-blocking thought on the known limitation noted in the PR description: in 
real-world code, `UndeclaredThrowableException(checked)` most often comes from 
JDK `java.lang.reflect.Proxy` invocation handlers (Spring AOP, MyBatis mappers, 
RPC stubs) rather than manual `new UndeclaredThrowableException(...)`. Because 
`UndeclaredThrowableException` is unchecked, dynamic `ConvertedClosure` adds no 
second layer (and `@CompileStatic` `LambdaMetafactory` never adds 
`UndeclaredThrowableException` at all), so `unwrapUndeclared` will strip the 
framework proxy's wrapper in both modes.
   
   Leaving `AsyncScope.withScope` entry-point changes for a later release makes 
total sense (since adding a 1-arg `ThrowingFunction` overload on `AsyncScope` 
would trigger Java lambda ambiguity, and keeping `groovy-concurrent-java` free 
of `Closure` is desirable). Just as food for thought when you revisit this: 
since `AsyncSupport.asyncGenerator` is internal `@GroovyABI` compiler plumbing 
rather than a user-called API, adding a distinct internal entry point taking a 
`ThrowingConsumer` SAM (while keeping `asyncGenerator(Consumer<Object>)` as a 
binary bridge for `6.0.0` classfiles) could avoid SAM wrapping on generators 
without any public API impact. Totally fine to defer both together to keep 
`6.0.1` minimal!



##########
src/main/java/groovy/concurrent/AsyncScope.java:
##########
@@ -46,6 +46,15 @@
  * task completes exceptionally, all sibling tasks are cancelled
  * immediately. The first failure becomes the primary exception;
  * subsequent failures are added as suppressed exceptions.
+ * <p>
+ * A failure is rethrown as the exception the task threw, including a
+ * checked exception, as {@code await} does.
+ *
+ * @apiNote {@link #close()} and {@code withScope} declare no checked
+ * exceptions but can still throw one. Java callers that need to handle a
+ * checked failure should catch {@code Exception} and test its type, as
+ * the Java compiler rejects a {@code catch} of a checked exception the
+ * try block does not declare.

Review Comment:
   Nice addition—documenting the sneaky-throw behavior explicitly via 
`@apiNote` on `AsyncScope` and `close()` is very helpful for pure Java callers 
of `groovy-concurrent-java`, where `javac` rejects catching undeclared checked 
exceptions per JLS §11.2.3.
   
   Two small optional doc refinements if helpful:
   1. **Cross-referencing on `withScope` overloads:** Adding a short `@apiNote` 
pointer on the `withScope` methods back to the class-level note would let IDE 
hover tooltips on `AsyncScope.withScope(...)` surface this caveat directly to 
Java callers.
   2. **Contrasting `withScope` with Java `try-with-resources`:** When a scope 
body and a child task fail with (or `await`) the same exception instance, 
`withScope` safely guards `if (closeError != bodyError)` at line 186, whereas 
Java's `try (var scope = AsyncScope.create())` emits an unconditional 
`primary.addSuppressed(closeError)` (`JDK-8317229`) and would throw 
`IllegalArgumentException: Self-suppression not permitted` now that `close()` 
rethrows the raw failure unwrapped.



##########
src/test/groovy/groovy/AsyncAwaitTest.groovy:
##########
@@ -4115,17 +4115,228 @@ final class AsyncAwaitTest {
     }
 
     @Test
-    void testScopeCloseWithCheckedExceptionWrapped() {
+    void testScopeCloseRethrowsCheckedExceptionUnwrapped() {
         assertScript '''
             import groovy.concurrent.AsyncScope
 
             def scope = AsyncScope.create()
-            scope.async { throw new Exception('checked-err') }
+            scope.async { throw new IOException('checked-err') }
             try {
                 scope.close()
                 assert false
-            } catch (RuntimeException e) {
-                assert e.cause.message == 'checked-err'
+            } catch (IOException e) {
+                assert e.message == 'checked-err'
+            }
+        '''
+    }
+
+    // Checked exceptions surface as themselves from every async construct, as 
from await
+
+    @Test
+    void testWithScopeChildCheckedExceptionTransparency() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+
+            try {
+                AsyncScope.withScope { scope ->
+                    scope.async { throw new IOException('child') }
+                    null
+                }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'child'
+            }
+        '''
+    }
+
+    @Test
+    void testWithScopeBodyCheckedExceptionTransparency() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import java.time.Duration
+
+            try {
+                AsyncScope.withScope { scope -> throw new IOException('body') }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'body'
+            }
+            try {
+                AsyncScope.withScope(Duration.ofSeconds(5)) { scope -> throw 
new IOException('timed body') }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'timed body'
+            }
+        '''
+    }
+
+    @Test
+    void testWithScopeBodyKeepsAWrapperTheCodeThrew() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import java.util.concurrent.ExecutionException
+
+            try {
+                AsyncScope.withScope { scope -> throw new 
ExecutionException(new IOException('inner')) }
+                assert false
+            } catch (ExecutionException e) {
+                assert e.cause instanceof IOException
+            }
+        '''
+    }
+
+    @Test
+    void testGeneratorKeepsAWrapperTheCodeThrew() {
+        assertScript '''
+            import java.util.concurrent.ExecutionException
+
+            def gen = async {
+                yield return 1
+                throw new ExecutionException(new IOException('inner'))
+            }
+            try {
+                for (x in gen) { }
+                assert false
+            } catch (ExecutionException e) {
+                assert e.cause instanceof IOException
+            }
+        '''
+    }
+
+    @Test
+    void testDeferCheckedExceptionTransparency() {
+        assertScript '''
+            try {
+                await async {
+                    defer { throw new IOException('cleanup') }
+                    1
+                }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'cleanup'
+            }
+        '''
+    }
+
+    @Test
+    void testGeneratorCheckedExceptionTransparency() {
+        assertScript '''
+            def gen = async {
+                yield return 1
+                throw new IOException('gen')
+            }
+            def seen = []
+            try {
+                for (x in gen) { seen << x }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'gen'
+            }
+            assert seen == [1]
+        '''
+    }
+
+    @Test
+    void testFlowPublisherCheckedExceptionTransparency() {
+        assertScript '''
+            import java.util.concurrent.SubmissionPublisher
+
+            def pub = new SubmissionPublisher<Integer>()
+            def seen = []
+            def producer = Thread.start {
+                while (pub.numberOfSubscribers == 0) Thread.onSpinWait()
+                pub.submit(1)
+                // closeExceptionally may overtake an undelivered item
+                while (pub.estimateMaximumLag() > 0) Thread.onSpinWait()
+                pub.closeExceptionally(new IOException('flow'))
+            }
+            try {
+                for await (x in pub) { seen << x }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'flow'
+            }
+            producer.join()
+            assert seen == [1]
+        '''
+    }
+
+    @Test
+    void testFlowPublisherKeepsAWrapperTheCodeThrew() {
+        assertScript '''
+            import java.util.concurrent.ExecutionException
+            import java.util.concurrent.SubmissionPublisher
+
+            def pub = new SubmissionPublisher<Integer>()
+            def producer = Thread.start {
+                while (pub.numberOfSubscribers == 0) Thread.onSpinWait()
+                pub.closeExceptionally(new ExecutionException(new 
IOException('inner')))
+            }
+            try {
+                for await (x in pub) { }
+                assert false
+            } catch (ExecutionException e) {
+                assert e.cause instanceof IOException
+            }
+            producer.join()
+        '''
+    }
+
+    // A wrapper thrown by a child task or deferred action is removed, exactly 
as await removes it
+
+    @Test
+    void testScopeChildAndDeferUnwrapAsAwaitDoes() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import java.util.concurrent.ExecutionException
+            import static groovy.test.GroovyAssert.shouldFail
+
+            def wrapped = { new ExecutionException(new IOException('inner')) }
+            def viaAwait = shouldFail(IOException) { await async { throw 
wrapped() } }
+            def viaChild = shouldFail(IOException) {
+                AsyncScope.withScope { scope -> scope.async { throw wrapped() 
}; null }
+            }
+            def viaDefer = shouldFail(IOException) {
+                await async { defer { throw wrapped() }; 1 }
+            }
+            assert [viaAwait, viaChild, viaDefer]*.message == ['inner'] * 3
+        '''
+    }
+
+    @Test
+    void testCheckedExceptionTransparencyUnderCompileStatic() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import groovy.transform.CompileStatic
+            import static groovy.test.GroovyAssert.shouldFail
+
+            @CompileStatic
+            class Paths {
+                static void child() {
+                    AsyncScope.withScope { AsyncScope scope -> scope.async { 
throw new IOException('child') }; null }
+                }
+                static void body() {
+                    AsyncScope.withScope { AsyncScope scope -> throw new 
IOException('body') }
+                }
+                static void deferred() {
+                    await async { defer { throw new IOException('defer') }; 1 }
+                }
+                static void generator() {
+                    def gen = async { yield return 1; throw new 
IOException('gen') }
+                    for (x in gen) { }
+                }
+            }
+
+            ['child', 'body', 'defer', 'gen'].eachWithIndex { String msg, int 
i ->
+                def e = shouldFail(IOException) {
+                    switch (i) {
+                        case 0 -> Paths.child()
+                        case 1 -> Paths.body()
+                        case 2 -> Paths.deferred()
+                        default -> Paths.generator()
+                    }
+                }
+                assert e.message == msg
             }

Review Comment:
   Thorough regression suite—especially spinning on `pub.estimateMaximumLag() > 
0` before `closeExceptionally` to avoid `SubmissionPublisher` race flakiness!
   
   Three targeted additions would round out the test matrix nicely:
   1. **`@CompileStatic` parity for `for await` and timed `withScope`:** 
`Paths` above exercises `child`, `body`, `defer`, and `generator` under 
`@CompileStatic`, while `FlowPublisherAdapter` (`for await`) and 
`withScope(Duration, ...)` are currently only covered in dynamic mode.
   2. **Timed `withScope(Duration, ...)` shared-failure & timeout-cause 
tests:** Testing a shared checked `IOException` awaited by both a timed 
`withScope(Duration.ofSeconds(5))` body and its child task (regression test for 
`withScopeTimeout`'s `try-with-resources` self-suppression), plus verifying 
`TimeoutException.getCause()` is `InterruptedException` rather than 
`UndeclaredThrowableException` when a dynamic timed scope expires.
   3. **Suppressed-exception preservation across wrapper removal:** Verifying 
that when an outer wrapper (such as `ExecutionException(new 
IOException('primary'))` in a `defer` block followed by another `defer` 
throwing `IOException('cleanup')`) is unwrapped, `'cleanup'` remains attached 
to `primary.getSuppressed()`.



##########
src/main/java/org/apache/groovy/runtime/async/DefaultAsyncScope.java:
##########
@@ -156,13 +156,14 @@ public void close() {
                 }
                 if (firstError == null) {
                     firstError = cause;
-                } else {
+                } else if (cause != firstError) {
+                    // Children may share one failure instance, e.g. by 
awaiting the same task
                     firstError.addSuppressed(cause);
                 }
             } catch (Exception e) {
                 if (firstError == null) {
                     firstError = e;
-                } else {
+                } else if (e != firstError) {
                     firstError.addSuppressed(e);
                 }
             }

Review Comment:
   Optional refinement: `cause != firstError` cleanly prevents 
`Self-suppression not permitted` when the repeated failure is the very first 
error. In a fan-out scope where Child 1 fails with `errA` and Children 2..N all 
`await` the same failed upstream task (`errB`), `errB != errA` evaluates to 
`true` on each iteration and attaches the same `errB` instance `N - 1` times to 
`firstError.getSuppressed()`. Delegating both sites here (and in 
`executeDeferScope`) to a tiny identity-checking helper (e.g., skipping if 
`cause` is already in `firstError.getSuppressed()`) would avoid duplicate 
suppressed stack traces in fan-out workloads.



##########
src/test/groovy/groovy/AsyncAwaitTest.groovy:
##########
@@ -4115,17 +4115,228 @@ final class AsyncAwaitTest {
     }
 
     @Test
-    void testScopeCloseWithCheckedExceptionWrapped() {
+    void testScopeCloseRethrowsCheckedExceptionUnwrapped() {
         assertScript '''
             import groovy.concurrent.AsyncScope
 
             def scope = AsyncScope.create()
-            scope.async { throw new Exception('checked-err') }
+            scope.async { throw new IOException('checked-err') }
             try {
                 scope.close()
                 assert false
-            } catch (RuntimeException e) {
-                assert e.cause.message == 'checked-err'
+            } catch (IOException e) {
+                assert e.message == 'checked-err'
+            }
+        '''
+    }
+
+    // Checked exceptions surface as themselves from every async construct, as 
from await
+
+    @Test
+    void testWithScopeChildCheckedExceptionTransparency() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+
+            try {
+                AsyncScope.withScope { scope ->
+                    scope.async { throw new IOException('child') }
+                    null
+                }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'child'
+            }
+        '''
+    }
+
+    @Test
+    void testWithScopeBodyCheckedExceptionTransparency() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import java.time.Duration
+
+            try {
+                AsyncScope.withScope { scope -> throw new IOException('body') }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'body'
+            }
+            try {
+                AsyncScope.withScope(Duration.ofSeconds(5)) { scope -> throw 
new IOException('timed body') }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'timed body'
+            }
+        '''
+    }
+
+    @Test
+    void testWithScopeBodyKeepsAWrapperTheCodeThrew() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import java.util.concurrent.ExecutionException
+
+            try {
+                AsyncScope.withScope { scope -> throw new 
ExecutionException(new IOException('inner')) }
+                assert false
+            } catch (ExecutionException e) {
+                assert e.cause instanceof IOException
+            }
+        '''
+    }
+
+    @Test
+    void testGeneratorKeepsAWrapperTheCodeThrew() {
+        assertScript '''
+            import java.util.concurrent.ExecutionException
+
+            def gen = async {
+                yield return 1
+                throw new ExecutionException(new IOException('inner'))
+            }
+            try {
+                for (x in gen) { }
+                assert false
+            } catch (ExecutionException e) {
+                assert e.cause instanceof IOException
+            }
+        '''
+    }
+
+    @Test
+    void testDeferCheckedExceptionTransparency() {
+        assertScript '''
+            try {
+                await async {
+                    defer { throw new IOException('cleanup') }
+                    1
+                }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'cleanup'
+            }
+        '''
+    }
+
+    @Test
+    void testGeneratorCheckedExceptionTransparency() {
+        assertScript '''
+            def gen = async {
+                yield return 1
+                throw new IOException('gen')
+            }
+            def seen = []
+            try {
+                for (x in gen) { seen << x }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'gen'
+            }
+            assert seen == [1]
+        '''
+    }
+
+    @Test
+    void testFlowPublisherCheckedExceptionTransparency() {
+        assertScript '''
+            import java.util.concurrent.SubmissionPublisher
+
+            def pub = new SubmissionPublisher<Integer>()
+            def seen = []
+            def producer = Thread.start {
+                while (pub.numberOfSubscribers == 0) Thread.onSpinWait()
+                pub.submit(1)
+                // closeExceptionally may overtake an undelivered item
+                while (pub.estimateMaximumLag() > 0) Thread.onSpinWait()
+                pub.closeExceptionally(new IOException('flow'))
+            }
+            try {
+                for await (x in pub) { seen << x }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'flow'
+            }
+            producer.join()
+            assert seen == [1]
+        '''
+    }
+
+    @Test
+    void testFlowPublisherKeepsAWrapperTheCodeThrew() {
+        assertScript '''
+            import java.util.concurrent.ExecutionException
+            import java.util.concurrent.SubmissionPublisher
+
+            def pub = new SubmissionPublisher<Integer>()
+            def producer = Thread.start {
+                while (pub.numberOfSubscribers == 0) Thread.onSpinWait()
+                pub.closeExceptionally(new ExecutionException(new 
IOException('inner')))
+            }
+            try {
+                for await (x in pub) { }
+                assert false
+            } catch (ExecutionException e) {
+                assert e.cause instanceof IOException
+            }
+            producer.join()
+        '''
+    }
+
+    // A wrapper thrown by a child task or deferred action is removed, exactly 
as await removes it
+
+    @Test
+    void testScopeChildAndDeferUnwrapAsAwaitDoes() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import java.util.concurrent.ExecutionException
+            import static groovy.test.GroovyAssert.shouldFail
+
+            def wrapped = { new ExecutionException(new IOException('inner')) }
+            def viaAwait = shouldFail(IOException) { await async { throw 
wrapped() } }
+            def viaChild = shouldFail(IOException) {
+                AsyncScope.withScope { scope -> scope.async { throw wrapped() 
}; null }
+            }
+            def viaDefer = shouldFail(IOException) {
+                await async { defer { throw wrapped() }; 1 }
+            }
+            assert [viaAwait, viaChild, viaDefer]*.message == ['inner'] * 3
+        '''
+    }
+
+    @Test
+    void testCheckedExceptionTransparencyUnderCompileStatic() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import groovy.transform.CompileStatic
+            import static groovy.test.GroovyAssert.shouldFail
+
+            @CompileStatic
+            class Paths {
+                static void child() {
+                    AsyncScope.withScope { AsyncScope scope -> scope.async { 
throw new IOException('child') }; null }
+                }
+                static void body() {
+                    AsyncScope.withScope { AsyncScope scope -> throw new 
IOException('body') }
+                }
+                static void deferred() {
+                    await async { defer { throw new IOException('defer') }; 1 }
+                }
+                static void generator() {
+                    def gen = async { yield return 1; throw new 
IOException('gen') }
+                    for (x in gen) { }
+                }
+            }
+
+            ['child', 'body', 'defer', 'gen'].eachWithIndex { String msg, int 
i ->
+                def e = shouldFail(IOException) {
+                    switch (i) {
+                        case 0 -> Paths.child()
+                        case 1 -> Paths.body()
+                        case 2 -> Paths.deferred()
+                        default -> Paths.generator()
+                    }
+                }
+                assert e.message == msg

Review Comment:
   `Paths` nicely verifies 4 of the 5 constructs under `@CompileStatic`. Could 
we also include the 5th path (`for await` over a `SubmissionPublisher`) and the 
timed `AsyncScope.withScope(Duration, ...)` overload here (plus a test 
asserting `te.cause instanceof InterruptedException` when `withScope(Duration, 
...)` times out in dynamic mode)? Since `@CompileStatic` uses 
`LambdaMetafactory` and distinct STC rules for `for await` and `throws 
TimeoutException` overloads, covering those two paths here will give full 
parity across dynamic and static compilation:
   
   ```groovy
                   static void timedBody() {
                       AsyncScope.withScope(java.time.Duration.ofSeconds(5)) { 
AsyncScope scope ->
                           throw new IOException('timed')
                       }
                   }
                   static void flowPublisher() {
                       def pub = new 
java.util.concurrent.SubmissionPublisher<Integer>()
                       Thread.start {
                           while (pub.numberOfSubscribers == 0) 
Thread.onSpinWait()
                           pub.closeExceptionally(new IOException('flow'))
                       }
                       for await (Integer x in pub) { }
                   }
   ```



##########
src/test/groovy/groovy/AsyncAwaitTest.groovy:
##########
@@ -4242,4 +4453,43 @@ final class AsyncAwaitTest {
         '''
     }
 
+    // One failure instance reaching close or defer twice is rethrown once, 
not suppressed into itself
+
+    @Test
+    void testScopeCloseSharedFailureIsNotSelfSuppressed() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import static groovy.test.GroovyAssert.shouldFail
+
+            def shared = new IllegalStateException('shared')
+            def e = shouldFail(IllegalStateException) {
+                AsyncScope.withScope { scope ->
+                    scope.async { throw shared }
+                    scope.async { throw shared }
+                    null
+                }
+            }
+            assert e.is(shared)
+            assert e.suppressed.length == 0
+        '''
+    }

Review Comment:
   To lock in the fix for `DefaultAsyncScope.withScopeTimeout`'s 
`try-with-resources` self-suppression edge case (where both the timed scope 
body and a child task throw or `await` the same checked exception instance), 
could we add a timed-scope assertion alongside this test?
   
   ```groovy
       @Test
       void testWithScopeTimeoutSharedFailureIsNotSelfSuppressed() {
           assertScript '''
               import groovy.concurrent.AsyncScope
               import java.time.Duration
               import static groovy.test.GroovyAssert.shouldFail
   
               def shared = new IOException('shared-timed')
               def e = shouldFail(IOException) {
                   AsyncScope.withScope(Duration.ofSeconds(5)) { scope ->
                       def child = scope.async { throw shared }
                       try { await child } catch (Throwable ignored) {}
                       throw shared
                   }
               }
               assert e.is(shared)
               assert e.suppressed.length == 0
           '''
       }
   ```



##########
src/main/java/org/apache/groovy/runtime/async/DefaultAsyncScope.java:
##########
@@ -284,7 +283,8 @@ public static <T> T withScopeTimeout(Executor executor, 
Duration timeout,
                     te.initCause(e);
                     throw te;
                 }
-                throw e;
+                // A checked exception from a Closure body arrives wrapped by 
its SAM coercion
+                throw AsyncSupport.rethrow(AsyncSupport.unwrapUndeclared(e));

Review Comment:
   I think `withScopeTimeout` still has a critical interaction with 
`try-with-resources` (line 268) and `unwrapUndeclared` that reintroduces 
`IllegalArgumentException: Self-suppression not permitted` (`GROOVY-12764`), 
plus two subtle differences from `AsyncScope.withScope`:
   
   1. **Unguarded `try-with-resources` self-suppression crash:** Unlike 
`AsyncScope.withScope` (which closes `scope` manually with `if (closeError != 
bodyError)`), `withScopeTimeout` uses `try (DefaultAsyncScope scope = new 
DefaultAsyncScope(executor))`. Per JLS §14.20.3 (and confirmed as `Won't Fix` 
in OpenJDK `JDK-8317229`), `javac` emits an unconditional 
`primary.addSuppressed(closeError)`. Previously, a shared checked exception was 
masked because the body threw `UndeclaredThrowableException(shared)` while 
`close()` threw `RuntimeException(shared)` (two distinct wrapper objects). Now 
that line 287 rethrows `unwrapUndeclared(e)` and `close()` rethrows 
`firstError` directly, when both the timed body and a child task fail with (or 
`await`) the same exception instance:
      ```groovy
      def upstream = async { throw new IOException('boom') }
      AsyncScope.withScope(Duration.ofSeconds(5)) { scope ->
          scope.async { await upstream }
          await upstream
      }
      ```
      `withScopeTimeout` throws `java.lang.IllegalArgumentException: 
Self-suppression not permitted` instead of `IOException('boom')`.
   
   2. **Timeout cause retains `UndeclaredThrowableException` in dynamic 
Groovy:** When `timedOut.get()` is `true` after `bodyThread.interrupt()`, a 
blocking call in a dynamic Groovy closure throws `InterruptedException` wrapped 
in `UndeclaredThrowableException` by SAM coercion. Calling `te.initCause(e)` at 
line 283 *before* `unwrapUndeclared(e)` leaves `te.cause` as 
`UndeclaredThrowableException(InterruptedException)` in dynamic mode, whereas 
`@CompileStatic` (`LambdaMetafactory`, no `Proxy`) sets `te.cause` to 
`InterruptedException` directly.
   
   3. **`catch (Exception e)` vs. `catch (Throwable thrown)` & late timer 
race:** `AsyncScope.withScope` catches `Throwable` (and `unwrapUndeclared` 
checks `!(cause instanceof RuntimeException) && !(cause instanceof Error)` per 
JLS §11.1.1), whereas `catch (Exception e)` here misses direct checked 
`Throwable` subclasses under `@CompileStatic`. Also, if the timer fires right 
as `body.apply(scope)` returns normally without blocking, `bodyThread`'s 
interrupt flag remains set on the caller thread because `Thread.interrupted()` 
only runs inside `catch`.
   
   Aligning `withScopeTimeout` with `AsyncScope.withScope`'s manual close 
structure resolves all three cleanly:
   
   ```java
       public static <T> T withScopeTimeout(Executor executor, Duration timeout,
                                            Function<AsyncScope, T> body) 
throws TimeoutException {
           Objects.requireNonNull(timeout, "timeout must not be null");
           Objects.requireNonNull(body, "body must not be null");
           var timedOut = new AtomicBoolean(false);
           Thread bodyThread = Thread.currentThread();
           DefaultAsyncScope scope = new DefaultAsyncScope(executor);
           ScheduledFuture<?> timer = AsyncSupport.getScheduler().schedule(() 
-> {
               timedOut.set(true);
               scope.cancelAll();
               bodyThread.interrupt();
           }, timeout.toMillis(), TimeUnit.MILLISECONDS);
           T result;
           try {
               result = withCurrent(scope, () -> body.apply(scope));
           } catch (Throwable thrown) {
               timer.cancel(false);
               Throwable bodyError = AsyncSupport.unwrapUndeclared(thrown);
               if (timedOut.get() && !(bodyError instanceof Error)) {
                   // Clear the interrupt flag set by the timeout
                   Thread.interrupted();
                   TimeoutException te = new TimeoutException("Scope timed out 
after " + timeout);
                   te.initCause(bodyError);
                   bodyError = te;
               }
               try {
                   scope.close();
               } catch (Throwable closeError) {
                   if (closeError != bodyError) {
                       bodyError.addSuppressed(closeError);
                   }
               }
               throw AsyncSupport.rethrow(bodyError);
           }
           if (!timer.cancel(false) && timedOut.get()) {
               Thread.interrupted();
           }
           scope.close();
           return result;
       }
   ```



##########
src/test/groovy/groovy/AsyncAwaitTest.groovy:
##########
@@ -4115,17 +4115,228 @@ final class AsyncAwaitTest {
     }
 
     @Test
-    void testScopeCloseWithCheckedExceptionWrapped() {
+    void testScopeCloseRethrowsCheckedExceptionUnwrapped() {
         assertScript '''
             import groovy.concurrent.AsyncScope
 
             def scope = AsyncScope.create()
-            scope.async { throw new Exception('checked-err') }
+            scope.async { throw new IOException('checked-err') }
             try {
                 scope.close()
                 assert false
-            } catch (RuntimeException e) {
-                assert e.cause.message == 'checked-err'
+            } catch (IOException e) {
+                assert e.message == 'checked-err'
+            }
+        '''
+    }
+
+    // Checked exceptions surface as themselves from every async construct, as 
from await
+
+    @Test
+    void testWithScopeChildCheckedExceptionTransparency() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+
+            try {
+                AsyncScope.withScope { scope ->
+                    scope.async { throw new IOException('child') }
+                    null
+                }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'child'
+            }
+        '''
+    }
+
+    @Test
+    void testWithScopeBodyCheckedExceptionTransparency() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import java.time.Duration
+
+            try {
+                AsyncScope.withScope { scope -> throw new IOException('body') }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'body'
+            }
+            try {
+                AsyncScope.withScope(Duration.ofSeconds(5)) { scope -> throw 
new IOException('timed body') }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'timed body'
+            }
+        '''
+    }
+
+    @Test
+    void testWithScopeBodyKeepsAWrapperTheCodeThrew() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import java.util.concurrent.ExecutionException
+
+            try {
+                AsyncScope.withScope { scope -> throw new 
ExecutionException(new IOException('inner')) }
+                assert false
+            } catch (ExecutionException e) {
+                assert e.cause instanceof IOException
+            }
+        '''
+    }
+
+    @Test
+    void testGeneratorKeepsAWrapperTheCodeThrew() {
+        assertScript '''
+            import java.util.concurrent.ExecutionException
+
+            def gen = async {
+                yield return 1
+                throw new ExecutionException(new IOException('inner'))
+            }
+            try {
+                for (x in gen) { }
+                assert false
+            } catch (ExecutionException e) {
+                assert e.cause instanceof IOException
+            }
+        '''
+    }
+
+    @Test
+    void testDeferCheckedExceptionTransparency() {
+        assertScript '''
+            try {
+                await async {
+                    defer { throw new IOException('cleanup') }
+                    1
+                }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'cleanup'
+            }
+        '''
+    }
+
+    @Test
+    void testGeneratorCheckedExceptionTransparency() {
+        assertScript '''
+            def gen = async {
+                yield return 1
+                throw new IOException('gen')
+            }
+            def seen = []
+            try {
+                for (x in gen) { seen << x }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'gen'
+            }
+            assert seen == [1]
+        '''
+    }
+
+    @Test
+    void testFlowPublisherCheckedExceptionTransparency() {
+        assertScript '''
+            import java.util.concurrent.SubmissionPublisher
+
+            def pub = new SubmissionPublisher<Integer>()
+            def seen = []
+            def producer = Thread.start {
+                while (pub.numberOfSubscribers == 0) Thread.onSpinWait()
+                pub.submit(1)
+                // closeExceptionally may overtake an undelivered item
+                while (pub.estimateMaximumLag() > 0) Thread.onSpinWait()
+                pub.closeExceptionally(new IOException('flow'))
+            }
+            try {
+                for await (x in pub) { seen << x }
+                assert false
+            } catch (IOException e) {
+                assert e.message == 'flow'
+            }
+            producer.join()
+            assert seen == [1]
+        '''
+    }
+
+    @Test
+    void testFlowPublisherKeepsAWrapperTheCodeThrew() {
+        assertScript '''
+            import java.util.concurrent.ExecutionException
+            import java.util.concurrent.SubmissionPublisher
+
+            def pub = new SubmissionPublisher<Integer>()
+            def producer = Thread.start {
+                while (pub.numberOfSubscribers == 0) Thread.onSpinWait()
+                pub.closeExceptionally(new ExecutionException(new 
IOException('inner')))
+            }
+            try {
+                for await (x in pub) { }
+                assert false
+            } catch (ExecutionException e) {
+                assert e.cause instanceof IOException
+            }
+            producer.join()
+        '''
+    }
+
+    // A wrapper thrown by a child task or deferred action is removed, exactly 
as await removes it
+
+    @Test
+    void testScopeChildAndDeferUnwrapAsAwaitDoes() {
+        assertScript '''
+            import groovy.concurrent.AsyncScope
+            import java.util.concurrent.ExecutionException
+            import static groovy.test.GroovyAssert.shouldFail
+
+            def wrapped = { new ExecutionException(new IOException('inner')) }
+            def viaAwait = shouldFail(IOException) { await async { throw 
wrapped() } }
+            def viaChild = shouldFail(IOException) {
+                AsyncScope.withScope { scope -> scope.async { throw wrapped() 
}; null }
+            }
+            def viaDefer = shouldFail(IOException) {
+                await async { defer { throw wrapped() }; 1 }
+            }
+            assert [viaAwait, viaChild, viaDefer]*.message == ['inner'] * 3
+        '''
+    }

Review Comment:
   Related to the comment on `AsyncSupport.executeDeferScope`: in `viaDefer` 
(`await async { defer { throw wrapped() }; 1 }`), `ExecutionException` is 
actually stripped by the outer `await` rather than by `defer` itself—whereas 
inside an `async` generator (`def gen = async { defer { throw wrapped() }; 
yield return 1 }`), `ExecutionException` is kept. Clarifying the comment above 
line 4285 (and perhaps asserting the generator-hosted `defer` case too) would 
help document that distinction.
   
   It would also be great to add a regression test here verifying that 
suppressed cleanup exceptions attached to a stripped wrapper survive unwrapping 
(see Comment on `AsyncSupport.unwrapUndeclared`):
   
   ```groovy
       @Test
       void testSuppressedExceptionPreservedWhenWrapperIsUnwrapped() {
           assertScript '''
               import java.util.concurrent.ExecutionException
               import static groovy.test.GroovyAssert.shouldFail
   
               def e = shouldFail(IOException) {
                   await async {
                       defer { throw new IOException('cleanup-err') }
                       defer { throw new ExecutionException(new 
IOException('primary-err')) }
                       1
                   }
               }
               assert e.message == 'primary-err'
               assert e.suppressed.length == 1
               assert e.suppressed[0] instanceof IOException
               assert e.suppressed[0].message == 'cleanup-err'
           '''
       }
   ```



##########
src/main/java/groovy/concurrent/AsyncScope.java:
##########
@@ -100,6 +109,9 @@ public interface AsyncScope extends AutoCloseable {
      * Closes the scope, waiting for all child tasks to complete.
      * If any child failed and fail-fast is enabled, remaining children
      * are cancelled and the first failure is rethrown.
+     *
+     * @apiNote The failure is rethrown as itself, so this method can throw a
+     * checked exception it does not declare; see the class documentation.

Review Comment:
   The new `@apiNote` here and on the class header is very clear for Java 
callers. Two small edge cases we might optionally mention (either here or in 
the class `@apiNote`):
   
   1. **Direct `try-with-resources` usage (`try (var scope = 
AsyncScope.create())`):** Unlike `withScope` (which guards `if (closeError != 
bodyError)`), `javac` desugars `try-with-resources` into an unconditional 
`primary.addSuppressed(closeError)` (JLS §14.20.3 / OpenJDK `JDK-8317229`). If 
caller code inside `try (var scope = AsyncScope.create())` awaits a failed 
child of `scope` and lets that exception escape the `try` block, 
`scope.close()` will rethrow the exact same unwrapped instance and trigger 
`IllegalArgumentException: Self-suppression not permitted` unless `withScope` 
is used instead.
   2. **Worker-originated `InterruptedException`:** When a child task throws 
`InterruptedException` on a worker thread, `close()` now rethrows that 
`InterruptedException` onto the calling thread while 
`Thread.currentThread().isInterrupted()` remains `false` (distinct from 
interruption of the calling thread itself).



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to