Make root-zone handleUncaughtError rethrow with the correct stack.

sdk/lib/async/zone.dart

 // 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.
 
 part of dart.async;
 
 typedef dynamic ZoneCallback();
 typedef dynamic ZoneUnaryCallback(arg);
 typedef dynamic ZoneBinaryCallback(arg1, arg2);
 
@@ skipping 873 matching lines @@
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     PrintHandler handler = implementation.function;
     return handler(implementation.zone, parentDelegate, this, line);
   }
 }
 
 void _rootHandleUncaughtError(
     Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace) {
   _schedulePriorityAsyncCallback(() {
-    throw new _UncaughtAsyncError(error, stackTrace);
+    if (error == null) error = new NullThrownError();

[turnidge, 2015/10/02 21:00:53]

Use {}'s here and below.

[Lasse Reichstein Nielsen, 2015/10/02 22:50:59]

We don't generally do that (the surrounding code is full of other examples).

[turnidge, 2015/10/02 22:54:35]

Acknowledged.

+    if (stackTrace == null) throw error;
+    _rethrow(error, stackTrace);
   });
 }
 
+external void _rethrow(Object error, StackTrace stackTrace);

[Ivan Posva, 2015/10/02 23:40:39]

Nit: I think it would be better to match the signature of the calling function
which does not have Object as the error being thrown which is more correct in my
opinion.

[Lasse Reichstein Nielsen, 2015/10/05 06:18:49]

I think Object is the right type here - it's accepting any object, and we won't
use it dynamically, so Object is the precise type. 

I also think that the Zone's error object should have been typed as Object, but
I guess that's too late to fix.

+
 dynamic _rootRun(Zone self, ZoneDelegate parent, Zone zone, f()) {
   if (Zone._current == zone) return f();
 
   Zone old = Zone._enter(zone);
   try {
     return f();
   } finally {
     Zone._leave(old);
   }
 }
@@ skipping 94 matching lines @@
       valueMap = zone._map;
     } else {
       valueMap = new HashMap();
     }
   } else {
     valueMap = new HashMap.from(zoneValues);
   }
   return new _CustomZone(zone, specification, valueMap);
 }
 
-class _RootZoneSpecification implements ZoneSpecification {
-  HandleUncaughtErrorHandler get handleUncaughtError =>
-      _rootHandleUncaughtError;
-  RunHandler get run => _rootRun;
-  RunUnaryHandler get runUnary => _rootRunUnary;
-  RunBinaryHandler get runBinary => _rootRunBinary;
-  RegisterCallbackHandler get registerCallback => _rootRegisterCallback;
-  RegisterUnaryCallbackHandler get registerUnaryCallback =>
-      _rootRegisterUnaryCallback;
-  RegisterBinaryCallbackHandler get registerBinaryCallback =>
-      _rootRegisterBinaryCallback;
-  ErrorCallbackHandler get errorCallback => _rootErrorCallback;
-  ScheduleMicrotaskHandler get scheduleMicrotask => _rootScheduleMicrotask;
-  CreateTimerHandler get createTimer => _rootCreateTimer;
-  CreatePeriodicTimerHandler get createPeriodicTimer =>
-      _rootCreatePeriodicTimer;
-  PrintHandler get print => _rootPrint;
-  ForkHandler get fork => _rootFork;
-}

[turnidge, 2015/10/02 21:00:53]

What's all this about?

[Lasse Reichstein Nielsen, 2015/10/02 22:50:59]

My editor told me the class was unused, so I removed it. Pure clean-up
while-I-was-here.

-
 class _RootZone extends _Zone {
   const _RootZone();
 
   _ZoneFunction get _run =>
       const _ZoneFunction(_ROOT_ZONE, _rootRun);
   _ZoneFunction get _runUnary =>
       const _ZoneFunction(_ROOT_ZONE, _rootRunUnary);
   _ZoneFunction get _runBinary =>
       const _ZoneFunction(_ROOT_ZONE, _rootRunBinary);
   _ZoneFunction get _registerCallback =>
@@ skipping 212 matching lines @@
                                    handleUncaughtError: errorHandler);
   }
   Zone zone = Zone.current.fork(specification: zoneSpecification,
                                 zoneValues: zoneValues);
   if (onError != null) {
     return zone.runGuarded(body);
   } else {
     return zone.run(body);
   }
 }