Can't set Isolate.addOnExitListener response parameter with Enum.

[ykmnkmi]

From Dart SDK Docs:

The response object must follow the same restrictions as enforced by SendPort.send. It is recommended to only use simple values that can be sent to all isolates, like null, booleans, numbers or strings.

Dart SDK version: 2.19.0-444.3.beta (beta) (Wed Jan 4 15:18:31 2023 +0000) on "windows_x64"

import 'dart:isolate';

void app(SendPort sendPort) {
  sendPort.send(Message.ok);
}

Future<void> main() async {
  var receivePort = ReceivePort();
  var sendPort = receivePort.sendPort;
  var isolate = await Isolate.spawn<SendPort>(app, sendPort, paused: true);
  isolate.addOnExitListener(sendPort, response: Message.done);

  void onMessage(Object? message) {
    switch (message) {
      case Message.ok:
        print('ok');
        break;
      case Message.done:
        print('done');
        receivePort.close();
        break;
      default:
        throw UnsupportedError('$message');
    }
  }

  receivePort.listen(onMessage);
  isolate.resume(isolate.pauseCapability!);
}

enum Message {
  ok,
  done,
}

[lrhn]

I'd have expected the message to be valid if you could send it to the same isolate through a normal port message, as the documentation also seems to say.

Seems the parameter to addOnExitListener is checked using the stronger check used for isolates not in the same isolate group.
I don't know if that's deliberate or an accident, but let's call it a bug. If it's intentional, it's a bug in the documentation.

[a-siva]

//cc @aam

[aam]

Seems the parameter to addOnExitListener is checked using the stronger check used for isolates not in the same isolate group.
I don't know if that's deliberate or an accident, but let's call it a bug. If it's intentional, it's a bug in the documentation.

It looks to be intentional back when response parameter was introduced in https://codereview.chromium.org/1074223002/patch/20001/30003

@@ -1056,13 +1075,15 @@ void Isolate::NotifyExitListeners() {
   if (listeners.IsNull()) return;
 
   SendPort& listener = SendPort::Handle(this);
-  for (intptr_t i = 0; i < listeners.Length(); i++) {
+  Instance& response = Instance::Handle(this);
+  for (intptr_t i = 0; i < listeners.Length(); i += 2) {
     listener ^= listeners.At(i);
     if (!listener.IsNull()) {
       Dart_Port port_id = listener.Id();
       uint8_t* data = NULL;
       intptr_t len = 0;
-      SerializeObject(Object::null_instance(), &data, &len, false);
+      response ^= listeners.At(i + 1);
+      SerializeObject(response, &data, &len, false);
       Message* msg = new Message(port_id, data, len, Message::kNormalPriority);
       PortMap::PostMessage(msg);
     }

Last false to SerializeObject indicates restricted message.

[lrhn]

It's a safe restriction to have, it avoids getting errors sending the message later when the isolate has already exited.
It may or may not be consistent with how we treat other messages (it's usually up to the sender to ensure that the value will work for its purpose), but if we want to keep the restriction, that's probably fine.
We should then makes sure to document it as a restriction on the addOnExitListener listener, and not just as a suggestion.