[vm/isolates] Include retaining path into an illegal send argument exception.

The exception contains retaining path that looks like this:
```
Invalid argument(s): Illegal argument in isolate message: (object extends NativeWrapper - Library:'dart:io' Class: _RandomAccessFileOpsImpl@14069316)
 <- Library:'dart:io' Class: _RandomAccessFile@14069316
 <- Library:'file:///vm/dart/isolates/send_unsupported_objects_test.dart' Class: SomeLog
 <- Library:'file:///vm/dart/isolates/send_unsupported_objects_test.dart' Class: SomeState
 <-  Class: Context
 <- Library:'dart:core' Class: _Closure@0150898

```

BUG=#51115
BUG=#48592
TEST=send_unsupported_objects_test

Change-Id: I022e693adccf43a7d2c95e1c7283fd7f210cf1d7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/280523
Commit-Queue: Alexander Aprelev <aam@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>
Reviewed-by: Ryan Macnak <rmacnak@google.com>

Author: aam

runtime/lib/isolate.cc

@@ -278,7 +278,13 @@ static ObjectPtr ValidateMessageObject(Zone* zone,
 
     const Array& args = Array::Handle(zone, Array::New(3));
     args.SetAt(0, illegal_object);
-    args.SetAt(2, String::Handle(zone, String::New(exception_message)));
+    args.SetAt(2, String::Handle(
+                      zone, String::NewFormatted(
+                                "%s%s",
+                                FindRetainingPath(
+                                    zone, isolate, obj, illegal_object,
+                                    TraversalRules::kInternalToIsolateGroup),
+                                exception_message)));
     const Object& exception = Object::Handle(
         zone, Exceptions::Create(Exceptions::kArgumentValue, args));
     return UnhandledException::New(Instance::Cast(exception),

runtime/tests/vm/dart/isolates/send_unsupported_objects_deep_test.dart

@@ -0,0 +1,45 @@
+// Copyright (c) 2023, 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 'dart:async';
+import 'dart:isolate';
+
+import "package:async_helper/async_helper.dart";
+import 'package:expect/expect.dart';
+
+import 'send_unsupported_objects_test.dart';
+
+const NESTED_DEPTH = 500;
+Future<List> buildNestedList(List<dynamic> list, int level) async {
+  final fu = level == NESTED_DEPTH ? Fu.unsendable("$level") : Fu("$level");
+  final newlist = <dynamic>[list, fu];
+  if (--level == 0) {
+    return newlist;
+  }
+  return await buildNestedList(newlist, level);
+}
+
+main() async {
+  asyncStart();
+  try {
+    final nestedList = await buildNestedList(<dynamic>[], NESTED_DEPTH);
+    // Send closure capturing nestedList
+    await Isolate.spawn((arg) {
+      arg();
+    }, () {
+      print('$nestedList');
+    });
+  } catch (e) {
+    checkForRetainingPath(e, <String>[
+      'NativeWrapper',
+      'Baz',
+      'Fu',
+      'Closure',
+    ]);
+
+    final msg = e.toString();
+    Expect.isTrue(msg.split('\n').length > NESTED_DEPTH * 2);
+    asyncEnd();
+  }
+}

runtime/tests/vm/dart/isolates/send_unsupported_objects_exit_test.dart

@@ -0,0 +1,33 @@
+// Copyright (c) 2023, 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 'dart:async';
+import 'dart:io';
+import 'dart:isolate';
+
+import "package:async_helper/async_helper.dart";
+import 'package:expect/expect.dart';
+
+import 'send_unsupported_objects_test.dart';
+
+worker(SendPort sp) async {
+  try {
+    Isolate.exit(sp, Fu.unsendable('fu'));
+  } catch (e) {
+    checkForRetainingPath(e, <String>[
+      'NativeWrapper',
+      'Baz',
+      'Fu',
+    ]);
+    sp.send(true);
+  }
+}
+
+main() async {
+  asyncStart();
+  final rp = ReceivePort();
+  await Isolate.spawn(worker, rp.sendPort);
+  Expect.isTrue(await rp.first);
+  asyncEnd();
+}

runtime/tests/vm/dart/isolates/send_unsupported_objects_init_isolate_test.dart

@@ -0,0 +1,35 @@
+// Copyright (c) 2023, 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 'dart:async';
+import 'dart:isolate';
+
+import 'package:async_helper/async_helper.dart';
+import 'package:expect/expect.dart';
+
+import 'send_unsupported_objects_test.dart';
+
+main() async {
+  asyncStart();
+
+  final fu = Fu.unsendable('fu');
+  try {
+    // Pass a closure that captures [fu]
+    await Isolate.spawn((arg) {
+      arg();
+    }, () {
+      print('${fu.label}');
+      Expect.fail('This closure should fail to be sent, shouldn\'t be called');
+    });
+  } catch (e) {
+    checkForRetainingPath(e, <String>[
+      'NativeWrapper',
+      'Baz',
+      'Fu',
+      'Context',
+      'Closure',
+    ]);
+    asyncEnd();
+  }
+}

runtime/tests/vm/dart/isolates/send_unsupported_objects_spawnuri_test.dart

@@ -0,0 +1,51 @@
+// Copyright (c) 2023, 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.
+
+// Verifies retaining path in error message for spawnUri'ed worker attempt
+// to send regular class instance.
+
+import 'dart:async';
+import 'dart:io';
+import 'dart:isolate';
+import 'dart:nativewrappers';
+
+import 'package:async_helper/async_helper.dart';
+import 'package:expect/expect.dart';
+
+import 'send_unsupported_objects_test.dart';
+
+class ConstFoo {
+  const ConstFoo(this.name);
+  final String name;
+}
+
+Future<void> main(args, message) async {
+  if (message == null) {
+    final receivePort = ReceivePort();
+    final isolate = await Isolate.spawnUri(
+        Platform.script, <String>['worker'], <SendPort>[receivePort.sendPort],
+        errorsAreFatal: true);
+    final result = await receivePort.first;
+    Expect.equals('done', result);
+    return;
+  }
+
+  Expect.equals('worker', args[0]);
+  final SendPort sendPort = message[0] as SendPort;
+  Expect.throws(() {
+    sendPort.send(<dynamic>[
+      <dynamic>[
+        <dynamic>[const ConstFoo("42")],
+      ],
+    ]);
+  }, (e) {
+    print(e);
+    checkForRetainingPath(e, <String>['ConstFoo']);
+
+    final msg = e.toString();
+    Expect.equals(3, msg.split('\n').where((s) => s.contains('_List')).length);
+    return true;
+  });
+  sendPort.send('done');
+}

runtime/tests/vm/dart/isolates/send_unsupported_objects_test.dart

@@ -0,0 +1,64 @@
+// Copyright (c) 2023, 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 'dart:async';
+import 'dart:io';
+import 'dart:isolate';
+import 'dart:nativewrappers';
+
+import 'package:async_helper/async_helper.dart';
+import 'package:expect/expect.dart';
+
+import 'send_unsupported_objects_init_isolate_test.dart';
+
+class Foo {
+  int i = 42;
+}
+
+class Bar {
+  Foo foo = Foo();
+}
+
+class NativeClass extends NativeFieldWrapperClass1 {}
+
+class Baz {
+  @pragma('vm:entry-point') // prevent tree-shaking of the field.
+  NativeClass? nativeClass;
+  Baz();
+}
+
+class Fu {
+  String label;
+  Bar bar = Bar();
+  Baz baz = Baz();
+
+  Fu(this.label);
+  Fu.unsendable(this.label) {
+    baz.nativeClass = NativeClass();
+  }
+}
+
+void checkForRetainingPath(Object? e, List<String> list) {
+  Expect.isTrue(e is ArgumentError);
+  final msg = e.toString();
+  list.forEach((s) {
+    Expect.contains(s, msg);
+  });
+}
+
+main() async {
+  asyncStart();
+  final rp = ReceivePort();
+  try {
+    rp.sendPort.send(Fu.unsendable('fu'));
+  } catch (e) {
+    checkForRetainingPath(e, <String>[
+      'NativeWrapper',
+      'Baz',
+      'Fu',
+    ]);
+  }
+  rp.close();
+  asyncEnd();
+}

runtime/tests/vm/dart_2/isolates/send_unsupported_objects_deep_test.dart

@@ -0,0 +1,47 @@
+// Copyright (c) 2023, 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.
+
+// @dart = 2.9
+
+import 'dart:async';
+import 'dart:isolate';
+
+import "package:async_helper/async_helper.dart";
+import 'package:expect/expect.dart';
+
+import 'send_unsupported_objects_test.dart';
+
+const NESTED_DEPTH = 500;
+Future<List> buildNestedList(List<dynamic> list, int level) async {
+  final fu = level == NESTED_DEPTH ? Fu.unsendable("$level") : Fu("$level");
+  final newlist = <dynamic>[list, fu];
+  if (--level == 0) {
+    return newlist;
+  }
+  return await buildNestedList(newlist, level);
+}
+
+main() async {
+  asyncStart();
+  try {
+    final nestedList = await buildNestedList(<dynamic>[], NESTED_DEPTH);
+    // Send closure capturing nestedList
+    await Isolate.spawn((arg) {
+      arg();
+    }, () {
+      print('$nestedList');
+    });
+  } catch (e) {
+    checkForRetainingPath(e, <String>[
+      'NativeWrapper',
+      'Baz',
+      'Fu',
+      'Closure',
+    ]);
+
+    final msg = e.toString();
+    Expect.isTrue(msg.split('\n').length > NESTED_DEPTH * 2);
+    asyncEnd();
+  }
+}

runtime/tests/vm/dart_2/isolates/send_unsupported_objects_exit_test.dart

@@ -0,0 +1,35 @@
+// Copyright (c) 2023, 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.
+
+// @dart = 2.9
+
+import 'dart:async';
+import 'dart:io';
+import 'dart:isolate';
+
+import "package:async_helper/async_helper.dart";
+import 'package:expect/expect.dart';
+
+import 'send_unsupported_objects_test.dart';
+
+worker(SendPort sp) async {
+  try {
+    Isolate.exit(sp, Fu.unsendable('fu'));
+  } catch (e) {
+    checkForRetainingPath(e, <String>[
+      'NativeWrapper',
+      'Baz',
+      'Fu',
+    ]);
+    sp.send(true);
+  }
+}
+
+main() async {
+  asyncStart();
+  final rp = ReceivePort();
+  await Isolate.spawn(worker, rp.sendPort);
+  Expect.isTrue(await rp.first);
+  asyncEnd();
+}

runtime/tests/vm/dart_2/isolates/send_unsupported_objects_init_isolate_test.dart

@@ -0,0 +1,37 @@
+// Copyright (c) 2023, 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.
+
+// @dart = 2.9
+
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:async_helper/async_helper.dart';
+import 'package:expect/expect.dart';
+
+import 'send_unsupported_objects_test.dart';
+
+main() async {
+  asyncStart();
+
+  final fu = Fu.unsendable('fu');
+  try {
+    // Pass a closure that captures [fu]
+    await Isolate.spawn((arg) {
+      arg();
+    }, () {
+      print('${fu.label}');
+      Expect.fail('This closure should fail to be sent, shouldn\'t be called');
+    });
+  } catch (e) {
+    checkForRetainingPath(e, <String>[
+      'NativeWrapper',
+      'Baz',
+      'Fu',
+      'Context',
+      'Closure',
+    ]);
+    asyncEnd();
+  }
+}