[dart2wasm] Store exception/stacktrace for nested catch blocks.

The async state machine uses a single state in the heap to store the current exception and stacktrace when within a catch block in case they need to be rethrown. When catch blocks are nested this state can be overwritten.

With this new change, before entering a new catch we store the current value of the exception/stacktrace in a local that we can restore after exiting the associated catch blocks. A wasm catch can represent multiple Dart catch blocks so we only need to store the state per wasm catch.

Fixes: #59981
Change-Id: I738084fdecdf5aceac65c5d3698e40b791175171
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/405920
Reviewed-by: Martin Kustermann <[email protected]>
Commit-Queue: Nate Biggs <[email protected]>

Author: natebiggs

pkg/dart2wasm/lib/state_machine.dart

@@ -145,6 +145,7 @@ class _YieldFinder extends RecursiveVisitor {
       addTarget(c, _StateTargetPlacement.Inner);
       recurse(c.body);
     }
+    addTarget(node.catches.last, _StateTargetPlacement.After);
     addTarget(node, _StateTargetPlacement.After);
   }
 
@@ -237,6 +238,10 @@ class ExceptionHandlerStack {
 
   final StateMachineCodeGenerator codeGen;
 
+  /// Holds exceptions and stacktraces from nested catch blocks so that the
+  /// enclosing ones can be restored when an inner block is exited.
+  final List<(w.Local, w.Local)> _previousCatchLocals = [];
+
   ExceptionHandlerStack(this.codeGen);
 
   void _pushTryCatch(TryCatch node) {
@@ -317,6 +322,14 @@ class ExceptionHandlerStack {
       final exceptionLocal =
           b.addLocal(codeGen.translator.topInfo.nonNullableType);
 
+      final previousException =
+          b.addLocal(codeGen.translator.topInfo.nullableType);
+
+      final previousStackTrace =
+          b.addLocal(codeGen.translator.stackTraceInfo.repr.nullableType);
+
+      _previousCatchLocals.add((previousException, previousStackTrace));
+
       void generateCatchBody() {
         // Set continuations of finalizers that can be reached by this `catch`
         // (or `catch_all`) as "rethrow".
@@ -328,6 +341,12 @@ class ExceptionHandlerStack {
           }
         }
 
+        // Store the current exception in case we enter a nested catch block.
+        codeGen.getSuspendStateCurrentException();
+        b.local_set(previousException);
+        codeGen.getSuspendStateCurrentStackTrace();
+        b.local_set(previousStackTrace);
+
         // Set the untyped "current exception" variable. Catch blocks will do the
         // type tests as necessary using this variable and set their exception
         // and stack trace locals.
@@ -377,6 +396,22 @@ class ExceptionHandlerStack {
 
     _tryBlockNumHandlers.clear();
   }
+
+  void _finalizeCatchBlocks(Object? debug) {
+    if (_previousCatchLocals.isEmpty) return;
+
+    final (previousException, previousStackTrace) =
+        _previousCatchLocals.removeLast();
+
+    final b = codeGen.b;
+
+    // Restore the exception and stacktrace from the enclosing try/catch
+    // if there is one.
+    codeGen
+        .setSuspendStateCurrentException(() => b.local_get(previousException));
+    codeGen.setSuspendStateCurrentStackTrace(
+        () => b.local_get(previousStackTrace));
+  }
 }
 
 /// Represents an exception handler (`catch` or `finally`).
@@ -976,6 +1011,8 @@ abstract class StateMachineCodeGenerator extends AstCodeGenerator {
     exceptionHandlers._terminateTryBlocks();
     exceptionHandlers._pop();
 
+    final afterCatch = afterTargets[node.catches.last]!;
+
     void emitCatchBlock(Catch catch_, Catch? nextCatch, bool emitGuard) {
       if (emitGuard) {
         getSuspendStateCurrentException();
@@ -1023,7 +1060,7 @@ abstract class StateMachineCodeGenerator extends AstCodeGenerator {
 
       catchVariableStack.removeLast();
 
-      _jumpToTarget(after);
+      _jumpToTarget(afterCatch);
     }
 
     for (int catchIdx = 0; catchIdx < node.catches.length; catchIdx += 1) {
@@ -1054,6 +1091,12 @@ abstract class StateMachineCodeGenerator extends AstCodeGenerator {
     b.ref_as_non_null();
     b.throw_(translator.getExceptionTag(b.module));
 
+    emitTargetLabel(afterCatch);
+
+    exceptionHandlers._finalizeCatchBlocks(node.location);
+
+    _jumpToTarget(after);
+
     emitTargetLabel(after);
   }
 

tests/web/wasm/regress_59981_test.dart

@@ -0,0 +1,105 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart';
+
+void exception1(String e) {
+  throw e;
+}
+
+void exception2(String e) {
+  throw e;
+}
+
+Future<void> doThrow1() async {
+  try {
+    exception1('outer');
+  } on Object {
+    try {
+      exception2('inner');
+    } on Object {
+      // ignore
+    }
+    rethrow;
+  }
+}
+
+Future<void> doThrow2() async {
+  try {
+    exception2('outer');
+  } on Object {
+    try {
+      exception1('inner');
+    } on Object {
+      try {
+        exception1('more inner');
+      } on Object {
+        // ignore
+      }
+    }
+    rethrow;
+  }
+}
+
+Future<void> doThrow3() async {
+  try {
+    exception1('outer');
+  } on Object {
+    try {
+      // don't throw
+    } on Object {
+      try {
+        // also don't throw
+      } on Object {
+        // ignore
+      }
+    }
+    rethrow;
+  }
+}
+
+Future<void> doThrow4() async {
+  try {
+    exception1('outer');
+  } on Object {
+    try {
+      exception2('inner');
+    } on bool {}
+    rethrow;
+  }
+}
+
+void main() async {
+  try {
+    await doThrow1();
+    Expect.fail('should throw');
+  } catch (e, s) {
+    Expect.equals(e, 'outer');
+    Expect.isTrue('$s'.contains('exception1'));
+  }
+
+  try {
+    await doThrow2();
+    Expect.fail('should throw');
+  } catch (e, s) {
+    Expect.equals(e, 'outer');
+    Expect.isTrue('$s'.contains('exception2'));
+  }
+
+  try {
+    await doThrow3();
+    Expect.fail('should throw');
+  } catch (e, s) {
+    Expect.equals(e, 'outer');
+    Expect.isTrue('$s'.contains('exception1'));
+  }
+
+  try {
+    await doThrow4();
+    Expect.fail('should throw');
+  } catch (e, s) {
+    Expect.equals(e, 'inner');
+    Expect.isTrue('$s'.contains('exception2'));
+  }
+}