Do not allow a hot reload if the isolate has a sticky error

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 "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/text_buffer.h"
@@ skipping 2174 matching lines @@
       OS::Print(
           "[+%" Pd64 "ms] Isolate %s invoking _runExtension for %s\n",
           Dart::timestamp(), name(), method_name.ToCString());
     }
     result = DartEntry::InvokeFunction(run_extension, arguments);
     if (FLAG_trace_service) {
       OS::Print(
           "[+%" Pd64 "ms] Isolate %s : _runExtension complete for %s\n",
           Dart::timestamp(), name(), method_name.ToCString());
     }
+    // Propagate the error.
     if (result.IsError()) {
-      if (result.IsUnwindError()) {
-        // Propagate the unwind error. Remaining service extension calls
-        // are dropped.
-        return result.raw();
-      } else {
+      // Remaining service extension calls are dropped.
+      if (!result.IsUnwindError()) {
         // Send error back over the protocol.
         Service::PostError(method_name,
                            parameter_keys,
                            parameter_values,
                            reply_port,
                            id,
                            Error::Cast(result));
       }
+      return result.raw();
     }
+    // Drain the microtask queue.
     result = DartLibraryCalls::DrainMicrotaskQueue();
+    // Propagate the error.
     if (result.IsError()) {
+      // Remaining service extension calls are dropped.

[siva, 2016/08/24 17:53:24]

Should this error also be posted back over the protocol so that clients
listening are aware of it?

[Cutch, 2016/08/24 18:30:49]

The code Service::PostError is actually responding to the JSON-RPC request. The
idea is that if the function that implements the service extension throws an
error that we should send back a JSON-RPC error so the client doesn't wait
forever. If the microtask queue generates an error we can't be certain that it
means the service request wasn't already responded to.

       return result.raw();
     }
   }
   return Object::null();
 }
 
 
 RawGrowableObjectArray* Isolate::GetAndClearPendingServiceExtensionCalls() {
   RawGrowableObjectArray* r = pending_service_extension_calls_;
   pending_service_extension_calls_ = GrowableObjectArray::null();
@@ skipping 676 matching lines @@
 void IsolateSpawnState::DecrementSpawnCount() {
   ASSERT(spawn_count_monitor_ != NULL);
   ASSERT(spawn_count_ != NULL);
   MonitorLocker ml(spawn_count_monitor_);
   ASSERT(*spawn_count_ > 0);
   *spawn_count_ = *spawn_count_ - 1;
   ml.Notify();
 }
 
 }  // namespace dart