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

runtime/vm/isolate.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "lib/mirrors.h"
@@ skipping 573 matching lines @@
 
     // Set up specific unhandled exception handler.
     const String& callback_name = String::Handle(
         isolate, String::New(state->exception_callback_name()));
     isolate->object_store()->
         set_unhandled_exception_handler(callback_name);
 
     Object& result = Object::Handle();
     result = state->ResolveFunction();
     bool is_spawn_uri = state->is_spawn_uri();
+
+    Instance& entryFunc = Instance::Handle(isolate);
     if (result.IsError()) {
-      StoreError(isolate, result);
-      return false;
+      if (is_spawn_uri) {
+        // Report failure to look up "main" in isolate when we have a
+        // port to reply it to.
+        entryFunc ^= Object::null_instance().raw();
+      } else {
+        StoreError(isolate, result);
+        return false;
+      }
+    } else {
+      ASSERT(result.IsFunction());
+      Function& function = Function::Handle(isolate);
+      function ^= result.raw();
+      function = function.ImplicitClosureFunction();
+      entryFunc ^= function.ImplicitStaticClosure();
     }
-    ASSERT(result.IsFunction());
-    Function& func = Function::Handle(isolate);
-    func ^= result.raw();
-    func = func.ImplicitClosureFunction();
 
     // Instead of directly invoking the entry point we call '_startIsolate' with
     // the entry point as argument. The '_startIsolate' function will
     // communicate with the spawner to receive the initial message before it
     // executes the real entry point.
     // Since this function ("RunIsolate") is used for both Isolate.spawn and
     // Isolate.spawnUri we also send a boolean flag as argument so that the
     // "_startIsolate" function can act corresponding to how the isolate was
     // created.
     const Array& args = Array::Handle(Array::New(2));
-    args.SetAt(0, Instance::Handle(func.ImplicitStaticClosure()));
+    args.SetAt(0, entryFunc);
     args.SetAt(1, is_spawn_uri ? Bool::True() : Bool::False());
 
     const Library& lib = Library::Handle(Library::IsolateLibrary());
     const String& entry_name = String::Handle(String::New("_startIsolate"));
     const Function& entry_point =
         Function::Handle(lib.LookupLocalFunction(entry_name));
     ASSERT(entry_point.IsFunction() && !entry_point.IsNull());
 
     result = DartEntry::InvokeFunction(entry_point, args);
     if (result.IsError()) {
@@ skipping 574 matching lines @@
   return func.raw();
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(isolate());
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart