Make uncaught errors terminating isolates only get printed if nobody is listening.

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 "vm/code_observers.h"
@@ skipping 551 matching lines @@
 
     const Instance& stacktrace = Instance::Handle(I, uhe.stacktrace());
     tmp = DartLibraryCalls::ToString(stacktrace);
     if (!tmp.IsString()) {
       tmp = String::New(stacktrace.ToCString());
     }
     stacktrace_str ^= tmp.raw();;
   } else {
     exc_str = String::New(result.ToErrorCString());
   }
-  I->NotifyErrorListeners(exc_str, stacktrace_str);
+  bool has_listener = I->NotifyErrorListeners(exc_str, stacktrace_str);
 
   if (I->ErrorsFatal()) {
-    I->object_store()->set_sticky_error(result);
+    if (has_listener) {
+      const String& msg = String::Handle(String::New("isolate terminated"));
+      const UnwindError& error = UnwindError::Handle(UnwindError::New(msg));
+      I->object_store()->set_sticky_error(error);

[Ivan Posva, 2015/08/14 05:18:30]

If we have notified the listener, then we can just clear the sticky error and
return false from this function.

+    } else {
+      I->object_store()->set_sticky_error(result);
+    }
     return false;
   }
   return true;
 }
 
 
 Isolate::Flags::Flags()
   : type_checks_(FLAG_enable_type_checks),
     asserts_(FLAG_enable_asserts),
     error_on_bad_type_(FLAG_error_on_bad_type),
@@ skipping 610 matching lines @@
     if (!current.IsNull() && (current.Id() == listener.Id())) {
       // Remove the matching listener from the list.
       current = SendPort::null();
       listeners.SetAt(i, current);
       return;
     }
   }
 }
 
 
-void Isolate::NotifyErrorListeners(const String& msg,
+bool Isolate::NotifyErrorListeners(const String& msg,
                                    const String& stacktrace) {
   const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
       this, this->object_store()->error_listeners());
-  if (listeners.IsNull()) return;
+  if (listeners.IsNull()) return false;
 
   const Array& arr = Array::Handle(this, Array::New(2));
   arr.SetAt(0, msg);
   arr.SetAt(1, stacktrace);
   SendPort& listener = SendPort::Handle(this);
   for (intptr_t i = 0; i < listeners.Length(); i++) {
     listener ^= listeners.At(i);
     if (!listener.IsNull()) {
       Dart_Port port_id = listener.Id();
       uint8_t* data = NULL;
       intptr_t len = 0;
       SerializeObject(arr, &data, &len, false);
       Message* msg = new Message(port_id, data, len, Message::kNormalPriority);
       PortMap::PostMessage(msg);
     }
   }
+  return listeners.Length() > 0;
 }
 
 
 static void StoreError(Isolate* isolate, const Object& obj) {
   ASSERT(obj.IsError());
   isolate->object_store()->set_sticky_error(Error::Cast(obj));
 }
 
 
 static bool RunIsolate(uword parameter) {
@@ skipping 923 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart