Ensure that failure to start an isolate all end up in the future.

runtime/lib/isolate_patch.dart

 // Copyright (c) 2012, 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:collection" show HashMap;
 
 patch class ReceivePort {
   /* patch */ factory ReceivePort() = _ReceivePortImpl;
 
   /* patch */ factory ReceivePort.fromRawReceivePort(RawReceivePort rawPort) =
@@ skipping 182 matching lines @@
     // initial startup message has been received.
   }
 
   isolateStartHandler(message) {
     // We received the initial startup message. Ignore all further messages and
     // close the port which kept this isolate alive.
     Isolate._self.handler = ignoreHandler;
     keepAlivePort.close();
 
     SendPort replyTo = message[0];
-    if (replyTo != null) {
-      // TODO(floitsch): don't send ok-message if we can't find the entry point.
-      replyTo.send("started");
-    }
     if (isSpawnUri) {
       assert(message.length == 3);
       List<String> args = message[1];
       var isolateMessage = message[2];
-      if (entryPoint is _MainFunctionArgsMessage) {
+      if (entryPoint == null) {
+        // Set to null when lookup of "main" failed in C++ code.
+        if (replyTo != null) {
+          replyTo.send(["error",
+                        "No main method in isolate library"]);
+        }
+      } else if (entryPoint is _MainFunctionArgsMessage) {
+        if (replyTo != null) replyTo.send("started");
         entryPoint(args, isolateMessage);
       } else if (entryPoint is _MainFunctionArgs) {
+        if (replyTo != null) replyTo.send("started");
         entryPoint(args);
+      } else if (entryPoint is _MainFunction) {
+        if (replyTo != null) replyTo.send("started");
+        entryPoint();
       } else {
-        entryPoint();
+        // Report error back to spawner.
+        if (replyTo != null) {
+          replyTo.send(["error",
+                        "Incorrect parameter count on main: $entryPoint"]);
+        }
       }
     } else {
       assert(message.length == 2);
       var entryMessage = message[1];
+      if (replyTo != null) replyTo.send("started");
       entryPoint(entryMessage);
     }
   }
 
   Isolate._self.handler = isolateStartHandler;
 }
 
 patch class Isolate {
   /* patch */ static Future<Isolate> spawn(
       void entryPoint(message), var message, { bool paused: false }) {
@@ skipping 18 matching lines @@
   /* patch */ static Future<Isolate> spawnUri(
       Uri uri, List<String> args, var message, { bool paused: false }) {
     // `paused` isn't handled yet.
     try {
       // The VM will invoke [_startIsolate] and not `main`.
       SendPort controlPort = _spawnUri(uri.toString());
       RawReceivePort readyPort = new RawReceivePort();
       controlPort.send([readyPort.sendPort, args, message]);
       Completer completer = new Completer<Isolate>.sync();
       readyPort.handler = (readyMessage) {
-        assert(readyMessage == 'started');
         readyPort.close();
-        completer.complete(new Isolate(controlPort));
+        if ('started' == readyMessage) {
+          completer.complete(new Isolate(controlPort));
+        } else {
+          assert(readyMessage is List && readyMessage[0] == "error");
+          String error = readyMessage[1];
+          var remoteError = new IsolateSpawnException(error);
+          completer.completeError(remoteError);
+        }
       };
       return completer.future;
     } catch (e, st) {
       return new Future<Isolate>.error(e, st);
     };
     return completer.future;
   }
 
   static final RawReceivePort _self = _mainPort;
   static RawReceivePort get _mainPort native "Isolate_mainPort";
@@ skipping 32 matching lines @@
   }
 
   /* patch */ void addErrorListener(SendPort port) {
     throw new UnsupportedError("addErrorListener");
   }
 
   /* patch */ void removeErrorListener(SendPort port) {
     throw new UnsupportedError("removeErrorListener");
   }
 }