Reland "[dart2wasm] Don't dartify JS values when returning as void"

This is a reland of commit 4bb05dc

Initial commit didn't properly box the `void` return value, so when we
cast the return value to `ref #Top` to pass it to a Dart function (as
`Object?` or `dynamic`) it caused "illegal cast" traps.

In this commit we properly box the `externref` as `JSValue` (a proper
Dart class). A new test added passing the return value of a `void` JS
return to `print`.

Original change's description:
> [dart2wasm] Don't dartify JS values when returning as void
>
> When calling a JS function that returns `void`, avoid dartifying the
> result.
>
> Technically the return value of `void` functions can still be used, by
> casting the return type to `Object?` or `dynamic`. However this
> shouldn't be done, and `dartifyRaw` overhead just to support this case
> which should be extremely rare is too much.
>
> Any hacky code that uses return values of `void`-returning JS interop
> functions can manually dartify the retrun values with `toDart` or
> similar.
>
> Issue: #60357
> Change-Id: Ic370c7cf6eb6982f61f8a07c91e3bb93c5345ac6
> Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/417240
> Reviewed-by: Srujan Gaddam <[email protected]>
> Reviewed-by: Martin Kustermann <[email protected]>
> Commit-Queue: Ömer Ağacan <[email protected]>

Change-Id: I264211cca4f6b87e63d68909647975ab96f0b5bd
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/421080
Commit-Queue: Ömer Ağacan <[email protected]>
Reviewed-by: Srujan Gaddam <[email protected]>

Author: osa1

pkg/dart2wasm/lib/js/util.dart

@@ -286,36 +286,39 @@ class CoreTypesUtil {
   Expression castInvocationForReturn(
       Expression invocation, DartType returnType) {
     if (returnType is VoidType) {
-      // `undefined` may be returned for `void` external members. It, however,
-      // is an extern ref, and therefore needs to be made a Dart type before
-      // we can finish the invocation.
-      return invokeOneArg(dartifyRawTarget, invocation);
-    } else {
-      Expression expression;
-      if (isJSValueType(returnType)) {
-        // TODO(joshualitt): Expose boxed `JSNull` and `JSUndefined` to Dart
-        // code after migrating existing users of js interop on Dart2Wasm.
-        // expression = _createJSValue(invocation);
-        // Casts are expensive, so we stick to a null-assertion if needed. If
-        // the nullability can't be determined, cast.
-        expression = invokeOneArg(jsValueBoxTarget, invocation);
-        final nullability = returnType.extensionTypeErasure.nullability;
-        if (nullability == Nullability.nonNullable) {
-          expression = NullCheck(expression);
-        } else if (nullability == Nullability.undetermined) {
-          expression = AsExpression(expression, returnType);
-        }
-      } else {
-        // Because we simply don't have enough information, we leave all JS
-        // numbers as doubles. However, in cases where we know the user expects
-        // an `int` we check that the double is an integer, and then insert a
-        // cast. We also let static interop types flow through without
-        // conversion, both as arguments, and as the return type.
-        expression = convertAndCast(
-            returnType, invokeOneArg(dartifyRawTarget, invocation));
+      // Technically a `void` return value can still be used, by casting the
+      // return type to `dynamic` or `Object?`. However this case should be
+      // extremely rare, and `dartifyRaw` overhead for return values that will
+      // never be used in practice is too much, so we avoid `dartifyRaw` on
+      // `void` returns. We still box the `externref` as the value can be passed
+      // around as a Dart object.
+      return StaticInvocation(jsValueBoxTarget, Arguments([invocation]));
+    }
+
+    Expression expression;
+    if (isJSValueType(returnType)) {
+      // TODO(joshualitt): Expose boxed `JSNull` and `JSUndefined` to Dart
+      // code after migrating existing users of js interop on Dart2Wasm.
+      // expression = _createJSValue(invocation);
+      // Casts are expensive, so we stick to a null-assertion if needed. If
+      // the nullability can't be determined, cast.
+      expression = invokeOneArg(jsValueBoxTarget, invocation);
+      final nullability = returnType.extensionTypeErasure.nullability;
+      if (nullability == Nullability.nonNullable) {
+        expression = NullCheck(expression);
+      } else if (nullability == Nullability.undetermined) {
+        expression = AsExpression(expression, returnType);
       }
-      return expression;
+    } else {
+      // Because we simply don't have enough information, we leave all JS
+      // numbers as doubles. However, in cases where we know the user expects
+      // an `int` we check that the double is an integer, and then insert a
+      // cast. We also let static interop types flow through without
+      // conversion, both as arguments, and as the return type.
+      expression = convertAndCast(
+          returnType, invokeOneArg(dartifyRawTarget, invocation));
     }
+    return expression;
   }
 
   // Handles any necessary type conversions. Today this is just for handling the

tests/lib/js/static_interop_test/void_return_test.dart

@@ -0,0 +1,17 @@
+// 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.
+
+// Check that `void` return values can be passed around as Dart objects.
+
+import 'dart:js_interop';
+
+@JS()
+external void eval(String code);
+
+void main() {
+  Object? x = eval('1 + 1') as dynamic;
+
+  // It doesn't matter what this prints, it just shouldn't crash.
+  print(x);
+}