fixes #427, static fields emitted outside the scope of their class

lib/runtime/dart/async.js

 dart_library.library('dart/async', null, /* Imports */[
   'dart/_runtime',
   'dart/core',
   'dart/_internal',
   'dart/collection'
 ], /* Lazy imports */[
   'dart/_isolate_helper'
 ], function(exports, dart, core, _internal, collection, _isolate_helper) {
   'use strict';
   let dartx = dart.dartx;
@@ skipping 1171 matching lines @@
         [_onResume]: [dart.void, []],
         [_onCancel]: [Future, []],
         [_addPending]: [dart.void, [_DelayedEvent]],
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []],
         [_guardCallback]: [dart.void, [dart.dynamic]],
         [_checkState]: [dart.void, [core.bool]]
       })
     });
+    _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
+    _BufferingStreamSubscription._STATE_CLOSED = 2;
+    _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
+    _BufferingStreamSubscription._STATE_CANCELED = 8;
+    _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL = 16;
+    _BufferingStreamSubscription._STATE_IN_CALLBACK = 32;
+    _BufferingStreamSubscription._STATE_HAS_PENDING = 64;
+    _BufferingStreamSubscription._STATE_PAUSE_COUNT = 128;
+    _BufferingStreamSubscription._STATE_PAUSE_COUNT_SHIFT = 7;
     return _BufferingStreamSubscription;
   });
   let _BufferingStreamSubscription = _BufferingStreamSubscription$();
   const _recordCancel = Symbol('_recordCancel');
   const _recordPause = Symbol('_recordPause');
   const _recordResume = Symbol('_recordResume');
   const _ControllerSubscription$ = dart.generic(function(T) {
     class _ControllerSubscription extends _BufferingStreamSubscription$(T) {
       _ControllerSubscription(controller, onData, onError, onDone, cancelOnError) {
         this[_controller] = controller;
@@ skipping 51 matching lines @@
     }
     _BroadcastSubscription[dart.implements] = () => [_BroadcastSubscriptionLink];
     dart.setSignature(_BroadcastSubscription, {
       constructors: () => ({_BroadcastSubscription: [_BroadcastSubscription$(T), [_StreamControllerLifecycle, dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_expectsEvent]: [core.bool, [core.int]],
         [_toggleEventId]: [dart.void, []],
         [_setRemoveAfterFiring]: [dart.void, []]
       })
     });
+    _BroadcastSubscription._STATE_EVENT_ID = 1;
+    _BroadcastSubscription._STATE_FIRING = 2;
+    _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
     return _BroadcastSubscription;
   });
   let _BroadcastSubscription = _BroadcastSubscription$();
-  _BroadcastSubscription._STATE_EVENT_ID = 1;
-  _BroadcastSubscription._STATE_FIRING = 2;
-  _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
   const _addStreamState = Symbol('_addStreamState');
   const _doneFuture = Symbol('_doneFuture');
   const _isEmpty = Symbol('_isEmpty');
   const _hasOneListener = Symbol('_hasOneListener');
   const _isAddingStream = Symbol('_isAddingStream');
   const _mayAddEvent = Symbol('_mayAddEvent');
   const _ensureDoneFuture = Symbol('_ensureDoneFuture');
   const _addListener = Symbol('_addListener');
   const _removeListener = Symbol('_removeListener');
   const _callOnCancel = Symbol('_callOnCancel');
@@ skipping 215 matching lines @@
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [Future, []],
         addStream: [Future, [Stream$(T)], {cancelOnError: core.bool}],
         [_add]: [dart.void, [T]],
         [_addError]: [dart.void, [core.Object, core.StackTrace]],
         [_close]: [dart.void, []],
         [_forEachListener]: [dart.void, [dart.functionType(dart.void, [_BufferingStreamSubscription$(T)])]],
         [_callOnCancel]: [dart.void, []]
       })
     });
+    _BroadcastStreamController._STATE_INITIAL = 0;
+    _BroadcastStreamController._STATE_EVENT_ID = 1;
+    _BroadcastStreamController._STATE_FIRING = 2;
+    _BroadcastStreamController._STATE_CLOSED = 4;
+    _BroadcastStreamController._STATE_ADDSTREAM = 8;
     return _BroadcastStreamController;
   });
   let _BroadcastStreamController = _BroadcastStreamController$();
-  _BroadcastStreamController._STATE_INITIAL = 0;
-  _BroadcastStreamController._STATE_EVENT_ID = 1;
-  _BroadcastStreamController._STATE_FIRING = 2;
-  _BroadcastStreamController._STATE_CLOSED = 4;
-  _BroadcastStreamController._STATE_ADDSTREAM = 8;
   const _SyncBroadcastStreamController$ = dart.generic(function(T) {
     class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _SyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         dart.as(data, T);
         if (dart.notNull(this[_isEmpty])) return;
         if (dart.notNull(this[_hasOneListener])) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_FIRING);
@@ skipping 400 matching lines @@
         error: [Future$(T), [core.Object], [core.StackTrace]],
         delayed: [Future$(T), [core.Duration], [dart.functionType(T, [])]]
       }),
       statics: () => ({
         wait: [Future$(core.List), [core.Iterable$(Future$())], {eagerError: core.bool, cleanUp: dart.functionType(dart.void, [dart.dynamic])}],
         forEach: [Future$(), [core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic])]],
         doWhile: [Future$(), [dart.functionType(dart.dynamic, [])]]
       }),
       names: ['wait', 'forEach', 'doWhile']
     });
+    dart.defineLazyProperties(Future, {
+      get _nullFuture() {
+        return new _Future.immediate(null);
+      }
+    });
     return Future;
   });
   let Future = Future$();
-  dart.defineLazyProperties(Future, {
-    get _nullFuture() {
-      return new _Future.immediate(null);
-    }
-  });
   class TimeoutException extends core.Object {
     TimeoutException(message, duration) {
       if (duration === void 0) duration = null;
       this.message = message;
       this.duration = duration;
     }
     toString() {
       let result = "TimeoutException";
       if (this.duration != null) result = `TimeoutException after ${this.duration}`;
       if (this.message != null) result = `${result}: ${this.message}`;
@@ skipping 191 matching lines @@
       catchError: [_FutureListener, [_Future, core.Function, _FutureErrorTest]],
       whenComplete: [_FutureListener, [_Future, _FutureAction]],
       chain: [_FutureListener, [_Future]]
     })
   });
   _FutureListener.MASK_VALUE = 1;
   _FutureListener.MASK_ERROR = 2;
   _FutureListener.MASK_TEST_ERROR = 4;
   _FutureListener.MASK_WHENCOMPLETE = 8;
   _FutureListener.STATE_CHAIN = 0;
-  _FutureListener.STATE_THEN = _FutureListener.MASK_VALUE;
-  _FutureListener.STATE_THEN_ONERROR = dart.notNull(_FutureListener.MASK_VALUE) | dart.notNull(_FutureListener.MASK_ERROR);
-  _FutureListener.STATE_CATCHERROR = _FutureListener.MASK_ERROR;
-  _FutureListener.STATE_CATCHERROR_TEST = dart.notNull(_FutureListener.MASK_ERROR) | dart.notNull(_FutureListener.MASK_TEST_ERROR);
-  _FutureListener.STATE_WHENCOMPLETE = _FutureListener.MASK_WHENCOMPLETE;
+  dart.defineLazyProperties(_FutureListener, {
+    get STATE_THEN() {
+      return _FutureListener.MASK_VALUE;
+    },
+    get STATE_THEN_ONERROR() {
+      return dart.notNull(_FutureListener.MASK_VALUE) | dart.notNull(_FutureListener.MASK_ERROR);
+    },
+    get STATE_CATCHERROR() {
+      return _FutureListener.MASK_ERROR;
+    },
+    get STATE_CATCHERROR_TEST() {
+      return dart.notNull(_FutureListener.MASK_ERROR) | dart.notNull(_FutureListener.MASK_TEST_ERROR);
+    },
+    get STATE_WHENCOMPLETE() {
+      return _FutureListener.MASK_WHENCOMPLETE;
+    }
+  });
   const _resultOrListeners = Symbol('_resultOrListeners');
   const _isChained = Symbol('_isChained');
   const _isComplete = Symbol('_isComplete');
   const _hasValue = Symbol('_hasValue');
   const _hasError = Symbol('_hasError');
   const _markPendingCompletion = Symbol('_markPendingCompletion');
   const _value = Symbol('_value');
   const _error = Symbol('_error');
   const _setValue = Symbol('_setValue');
   const _setErrorObject = Symbol('_setErrorObject');
@@ skipping 435 matching lines @@
         [_asyncCompleteError]: [dart.void, [dart.dynamic, core.StackTrace]],
         timeout: [Future, [core.Duration], {onTimeout: dart.functionType(dart.dynamic, [])}]
       }),
       statics: () => ({
         _chainForeignFuture: [dart.void, [Future, _Future$()]],
         _chainCoreFuture: [dart.void, [_Future$(), _Future$()]],
         _propagateToListeners: [dart.void, [_Future$(), _FutureListener]]
       }),
       names: ['_chainForeignFuture', '_chainCoreFuture', '_propagateToListeners']
     });
+    _Future._INCOMPLETE = 0;
+    _Future._PENDING_COMPLETE = 1;
+    _Future._CHAINED = 2;
+    _Future._VALUE = 4;
+    _Future._ERROR = 8;
     return _Future;
   });
   let _Future = _Future$();
-  _Future._INCOMPLETE = 0;
-  _Future._PENDING_COMPLETE = 1;
-  _Future._CHAINED = 2;
-  _Future._VALUE = 4;
-  _Future._ERROR = 8;
   const __CastType6$ = dart.generic(function(T, S) {
     const __CastType6 = dart.typedef('__CastType6', () => dart.functionType(S, [T]));
     return __CastType6;
   });
   let __CastType6 = __CastType6$();
   const __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.dynamic]));
   const __CastType10 = dart.typedef('__CastType10', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   const _AsyncCallback = dart.typedef('_AsyncCallback', () => dart.functionType(dart.void, []));
   class _AsyncCallbackEntry extends core.Object {
     _AsyncCallbackEntry(callback) {
@@ skipping 549 matching lines @@
         [_closeUnchecked]: [dart.void, []],
         [_add]: [dart.void, [T]],
         [_addError]: [dart.void, [core.Object, core.StackTrace]],
         [_close]: [dart.void, []],
         [_subscribe]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         [_recordCancel]: [Future, [StreamSubscription$(T)]],
         [_recordPause]: [dart.void, [StreamSubscription$(T)]],
         [_recordResume]: [dart.void, [StreamSubscription$(T)]]
       })
     });
+    _StreamController._STATE_INITIAL = 0;
+    _StreamController._STATE_SUBSCRIBED = 1;
+    _StreamController._STATE_CANCELED = 2;
+    _StreamController._STATE_SUBSCRIPTION_MASK = 3;
+    _StreamController._STATE_CLOSED = 4;
+    _StreamController._STATE_ADDSTREAM = 8;
     return _StreamController;
   });
   let _StreamController = _StreamController$();
-  _StreamController._STATE_INITIAL = 0;
-  _StreamController._STATE_SUBSCRIBED = 1;
-  _StreamController._STATE_CANCELED = 2;
-  _StreamController._STATE_SUBSCRIPTION_MASK = 3;
-  _StreamController._STATE_CLOSED = 4;
-  _StreamController._STATE_ADDSTREAM = 8;
   const _SyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _SyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         dart.as(data, T);
         this[_subscription][_add](data);
       }
       [_sendError](error, stackTrace) {
         this[_subscription][_addError](error, stackTrace);
       }
       [_sendDone]() {
@@ skipping 217 matching lines @@
   const _EventSink$ = dart.generic(function(T) {
     class _EventSink extends core.Object {}
     return _EventSink;
   });
   let _EventSink = _EventSink$();
   const _EventDispatch$ = dart.generic(function(T) {
     class _EventDispatch extends core.Object {}
     return _EventDispatch;
   });
   let _EventDispatch = _EventDispatch$();
-  _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
-  _BufferingStreamSubscription._STATE_CLOSED = 2;
-  _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
-  _BufferingStreamSubscription._STATE_CANCELED = 8;
-  _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL = 16;
-  _BufferingStreamSubscription._STATE_IN_CALLBACK = 32;
-  _BufferingStreamSubscription._STATE_HAS_PENDING = 64;
-  _BufferingStreamSubscription._STATE_PAUSE_COUNT = 128;
-  _BufferingStreamSubscription._STATE_PAUSE_COUNT_SHIFT = 7;
   const _EventGenerator = dart.typedef('_EventGenerator', () => dart.functionType(_PendingEvents, []));
   const _isUsed = Symbol('_isUsed');
   const _GeneratedStreamImpl$ = dart.generic(function(T) {
     class _GeneratedStreamImpl extends _StreamImpl$(T) {
       _GeneratedStreamImpl(pending) {
         this[_pending] = pending;
         this[_isUsed] = false;
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
@@ skipping 42 matching lines @@
     cancelSchedule() {
       if (dart.notNull(this.isScheduled)) this[_state] = _PendingEvents._STATE_CANCELED;
     }
   }
   dart.setSignature(_PendingEvents, {
     methods: () => ({
       schedule: [dart.void, [_EventDispatch]],
       cancelSchedule: [dart.void, []]
     })
   });
+  _PendingEvents._STATE_UNSCHEDULED = 0;
+  _PendingEvents._STATE_SCHEDULED = 1;
+  _PendingEvents._STATE_CANCELED = 3;
   const _iterator = Symbol('_iterator');
   const _IterablePendingEvents$ = dart.generic(function(T) {
     class _IterablePendingEvents extends _PendingEvents {
       _IterablePendingEvents(data) {
         this[_iterator] = data[dartx.iterator];
         super._PendingEvents();
       }
       get isEmpty() {
         return this[_iterator] == null;
       }
@@ skipping 102 matching lines @@
     }
     set next(_) {
       dart.throw(new core.StateError("No events after a done."));
     }
   }
   _DelayedDone[dart.implements] = () => [_DelayedEvent];
   dart.setSignature(_DelayedDone, {
     constructors: () => ({_DelayedDone: [_DelayedDone, []]}),
     methods: () => ({perform: [dart.void, [_EventDispatch]]})
   });
-  _PendingEvents._STATE_UNSCHEDULED = 0;
-  _PendingEvents._STATE_SCHEDULED = 1;
-  _PendingEvents._STATE_CANCELED = 3;
   class _StreamImplEvents extends _PendingEvents {
     _StreamImplEvents() {
       this.firstPendingEvent = null;
       this.lastPendingEvent = null;
       super._PendingEvents();
     }
     get isEmpty() {
       return this.lastPendingEvent == null;
     }
     add(event) {
@@ skipping 123 matching lines @@
         onData: [dart.void, [dart.functionType(dart.void, [T])]],
         onError: [dart.void, [core.Function]],
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         cancel: [Future, []],
         asFuture: [Future, [], [dart.dynamic]],
         [_sendDone]: [dart.void, []]
       })
     });
+    _DoneStreamSubscription._DONE_SENT = 1;
+    _DoneStreamSubscription._SCHEDULED = 2;
+    _DoneStreamSubscription._PAUSED = 4;
     return _DoneStreamSubscription;
   });
   let _DoneStreamSubscription = _DoneStreamSubscription$();
-  _DoneStreamSubscription._DONE_SENT = 1;
-  _DoneStreamSubscription._SCHEDULED = 2;
-  _DoneStreamSubscription._PAUSED = 4;
   const _source = Symbol('_source');
   const _onListenHandler = Symbol('_onListenHandler');
   const _onCancelHandler = Symbol('_onCancelHandler');
   const _cancelSubscription = Symbol('_cancelSubscription');
   const _pauseSubscription = Symbol('_pauseSubscription');
   const _resumeSubscription = Symbol('_resumeSubscription');
   const _isSubscriptionPaused = Symbol('_isSubscriptionPaused');
   const _AsBroadcastStream$ = dart.generic(function(T) {
     class _AsBroadcastStream extends Stream$(T) {
       _AsBroadcastStream(source, onListenHandler, onCancelHandler) {
@@ skipping 241 matching lines @@
       constructors: () => ({_StreamIteratorImpl: [_StreamIteratorImpl$(T), [Stream$(T)]]}),
       methods: () => ({
         moveNext: [Future$(core.bool), []],
         [_clear]: [dart.void, []],
         cancel: [Future, []],
         [_onData]: [dart.void, [T]],
         [_onError]: [dart.void, [core.Object], [core.StackTrace]],
         [_onDone]: [dart.void, []]
       })
     });
+    _StreamIteratorImpl._STATE_FOUND = 0;
+    _StreamIteratorImpl._STATE_DONE = 1;
+    _StreamIteratorImpl._STATE_MOVING = 2;
+    _StreamIteratorImpl._STATE_EXTRA_DATA = 3;
+    _StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
+    _StreamIteratorImpl._STATE_EXTRA_DONE = 5;
     return _StreamIteratorImpl;
   });
   let _StreamIteratorImpl = _StreamIteratorImpl$();
-  _StreamIteratorImpl._STATE_FOUND = 0;
-  _StreamIteratorImpl._STATE_DONE = 1;
-  _StreamIteratorImpl._STATE_MOVING = 2;
-  _StreamIteratorImpl._STATE_EXTRA_DATA = 3;
-  _StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
-  _StreamIteratorImpl._STATE_EXTRA_DONE = 5;
   const __CastType20$ = dart.generic(function(T) {
     const __CastType20 = dart.typedef('__CastType20', () => dart.functionType(dart.void, [T]));
     return __CastType20;
   });
   let __CastType20 = __CastType20$();
   const __CastType22 = dart.typedef('__CastType22', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
   const __CastType25 = dart.typedef('__CastType25', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   function _runUserCode(userCode, onSuccess, onError) {
     try {
       dart.dcall(onSuccess, userCode());
@@ skipping 464 matching lines @@
             sink[_add](inputEvent);
             this[_previous] = inputEvent;
           }
         }
       }
     }
     dart.setSignature(_DistinctStream, {
       constructors: () => ({_DistinctStream: [_DistinctStream$(T), [Stream$(T), dart.functionType(core.bool, [T, T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
+    dart.defineLazyProperties(_DistinctStream, {
+      get _SENTINEL() {
+        return new core.Object();
+      },
+      set _SENTINEL(_) {}
+    });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$();
-  dart.defineLazyProperties(_DistinctStream, {
-    get _SENTINEL() {
-      return new core.Object();
-    },
-    set _SENTINEL(_) {}
-  });
   const _EventSinkWrapper$ = dart.generic(function(T) {
     class _EventSinkWrapper extends core.Object {
       _EventSinkWrapper(sink) {
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, T);
         this[_sink][_add](data);
       }
       addError(error, stackTrace) {
@@ skipping 460 matching lines @@
   }
   dart.defineNamedConstructor(Zone, '_');
   dart.setSignature(Zone, {
     constructors: () => ({_: [Zone, []]}),
     statics: () => ({
       _enter: [Zone, [Zone]],
       _leave: [dart.void, [Zone]]
     }),
     names: ['_enter', '_leave']
   });
-  class _Zone extends core.Object {
-    _Zone() {
-    }
-    inSameErrorZone(otherZone) {
-      return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
-    }
+  dart.defineLazyProperties(Zone, {
+    get ROOT() {
+      return _ROOT_ZONE;
+    },
+    get _current() {
+      return _ROOT_ZONE;
+    },
+    set _current(_) {}
+  });
+  const _delegate = Symbol('_delegate');
+  function _parentDelegate(zone) {
+    if (zone.parent == null) return null;
+    return zone.parent[_delegate];
   }
-  _Zone[dart.implements] = () => [Zone];
-  dart.setSignature(_Zone, {
-    constructors: () => ({_Zone: [_Zone, []]}),
-    methods: () => ({inSameErrorZone: [core.bool, [Zone]]})
-  });
+  dart.fn(_parentDelegate, () => dart.definiteFunctionType(ZoneDelegate, [_Zone]));
+  const _delegationTarget = Symbol('_delegationTarget');
+  const _handleUncaughtError = Symbol('_handleUncaughtError');
   const _run = Symbol('_run');
   const _runUnary = Symbol('_runUnary');
   const _runBinary = Symbol('_runBinary');
   const _registerCallback = Symbol('_registerCallback');
   const _registerUnaryCallback = Symbol('_registerUnaryCallback');
   const _registerBinaryCallback = Symbol('_registerBinaryCallback');
   const _errorCallback = Symbol('_errorCallback');
   const _scheduleMicrotask = Symbol('_scheduleMicrotask');
   const _createTimer = Symbol('_createTimer');
   const _createPeriodicTimer = Symbol('_createPeriodicTimer');
   const _print = Symbol('_print');
   const _fork = Symbol('_fork');
-  const _handleUncaughtError = Symbol('_handleUncaughtError');
-  const _map = Symbol('_map');
-  const _delegate = Symbol('_delegate');
-  class _RootZone extends _Zone {
-    _RootZone() {
-      super._Zone();
-    }
-    get [_run]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRun));
-    }
-    get [_runUnary]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunUnary));
-    }
-    get [_runBinary]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunBinary));
-    }
-    get [_registerCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback));
-    }
-    get [_registerUnaryCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback));
-    }
-    get [_registerBinaryCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback));
-    }
-    get [_errorCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootErrorCallback));
-    }
-    get [_scheduleMicrotask]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask));
-    }
-    get [_createTimer]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreateTimer));
-    }
-    get [_createPeriodicTimer]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer));
-    }
-    get [_print]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootPrint));
-    }
-    get [_fork]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootFork));
-    }
-    get [_handleUncaughtError]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError));
-    }
-    get parent() {
-      return null;
-    }
-    get [_map]() {
-      return _RootZone._rootMap;
-    }
-    get [_delegate]() {
-      if (_RootZone._rootDelegate != null) return _RootZone._rootDelegate;
-      return _RootZone._rootDelegate = new _ZoneDelegate(this);
-    }
-    get errorZone() {
-      return this;
-    }
-    runGuarded(f) {
-      try {
-        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
-          return f();
-        }
-        return _rootRun(null, null, this, f);
-      } catch (e) {
-        let s = dart.stackTrace(e);
-        return this.handleUncaughtError(e, s);
-      }
-
-    }
-    runUnaryGuarded(f, arg) {
-      try {
-        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
-          return dart.dcall(f, arg);
-        }
-        return _rootRunUnary(null, null, this, f, arg);
-      } catch (e) {
-        let s = dart.stackTrace(e);
-        return this.handleUncaughtError(e, s);
-      }
-
-    }
-    runBinaryGuarded(f, arg1, arg2) {
-      try {
-        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
-          return dart.dcall(f, arg1, arg2);
-        }
-        return _rootRunBinary(null, null, this, f, arg1, arg2);
-      } catch (e) {
-        let s = dart.stackTrace(e);
-        return this.handleUncaughtError(e, s);
-      }
-
-    }
-    bindCallback(f, opts) {
-      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      if (dart.notNull(runGuarded)) {
-        return dart.fn((() => this.runGuarded(f)).bind(this));
-      } else {
-        return dart.fn((() => this.run(f)).bind(this));
-      }
-    }
-    bindUnaryCallback(f, opts) {
-      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      if (dart.notNull(runGuarded)) {
-        return dart.fn((arg => this.runUnaryGuarded(f, arg)).bind(this));
-      } else {
-        return dart.fn((arg => this.runUnary(f, arg)).bind(this));
-      }
-    }
-    bindBinaryCallback(f, opts) {
-      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      if (dart.notNull(runGuarded)) {
-        return dart.fn(((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this));
-      } else {
-        return dart.fn(((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this));
-      }
-    }
-    get(key) {
-      return null;
-    }
-    handleUncaughtError(error, stackTrace) {
-      return _rootHandleUncaughtError(null, null, this, error, stackTrace);
-    }
-    fork(opts) {
-      let specification = opts && 'specification' in opts ? opts.specification : null;
-      let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
-      return _rootFork(null, null, this, specification, zoneValues);
-    }
-    run(f) {
-      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE))) return f();
-      return _rootRun(null, null, this, f);
-    }
-    runUnary(f, arg) {
-      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE))) return dart.dcall(f, arg);
-      return _rootRunUnary(null, null, this, f, arg);
-    }
-    runBinary(f, arg1, arg2) {
-      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE))) return dart.dcall(f, arg1, arg2);
-      return _rootRunBinary(null, null, this, f, arg1, arg2);
-    }
-    registerCallback(f) {
-      return f;
-    }
-    registerUnaryCallback(f) {
-      return f;
-    }
-    registerBinaryCallback(f) {
-      return f;
-    }
-    errorCallback(error, stackTrace) {
-      return null;
-    }
-    scheduleMicrotask(f) {
-      _rootScheduleMicrotask(null, null, this, f);
-    }
-    createTimer(duration, f) {
-      return Timer._createTimer(duration, f);
-    }
-    createPeriodicTimer(duration, f) {
-      return Timer._createPeriodicTimer(duration, f);
-    }
-    print(line) {
-      _internal.printToConsole(line);
-    }
-  }
-  dart.setSignature(_RootZone, {
-    constructors: () => ({_RootZone: [_RootZone, []]}),
-    methods: () => ({
-      runGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
-      runUnaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
-      runBinaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
-      bindCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])], {runGuarded: core.bool}],
-      bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])], {runGuarded: core.bool}],
-      bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {runGuarded: core.bool}],
-      get: [dart.dynamic, [core.Object]],
-      handleUncaughtError: [dart.dynamic, [dart.dynamic, core.StackTrace]],
-      fork: [Zone, [], {specification: ZoneSpecification, zoneValues: core.Map}],
-      run: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
-      runUnary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
-      runBinary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
-      registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
-      registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]],
-      registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
-      errorCallback: [AsyncError, [core.Object, core.StackTrace]],
-      scheduleMicrotask: [dart.void, [dart.functionType(dart.void, [])]],
-      createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
-      createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]],
-      print: [dart.void, [core.String]]
-    })
-  });
-  const _ROOT_ZONE = dart.const(new _RootZone());
-  Zone.ROOT = _ROOT_ZONE;
-  Zone._current = _ROOT_ZONE;
-  function _parentDelegate(zone) {
-    if (zone.parent == null) return null;
-    return zone.parent[_delegate];
-  }
-  dart.fn(_parentDelegate, ZoneDelegate, [_Zone]);
-  const _delegationTarget = Symbol('_delegationTarget');
   class _ZoneDelegate extends core.Object {
     _ZoneDelegate(delegationTarget) {
       this[_delegationTarget] = delegationTarget;
     }
     handleUncaughtError(zone, error, stackTrace) {
       let implementation = this[_delegationTarget][_handleUncaughtError];
       let implZone = implementation.zone;
       return dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace);
     }
     run(zone, f) {
@@ skipping 70 matching lines @@
       registerUnaryCallback: [ZoneUnaryCallback, [Zone, dart.functionType(dart.dynamic, [dart.dynamic])]],
       registerBinaryCallback: [ZoneBinaryCallback, [Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
       errorCallback: [AsyncError, [Zone, core.Object, core.StackTrace]],
       scheduleMicrotask: [dart.void, [Zone, dart.functionType(dart.dynamic, [])]],
       createTimer: [Timer, [Zone, core.Duration, dart.functionType(dart.void, [])]],
       createPeriodicTimer: [Timer, [Zone, core.Duration, dart.functionType(dart.void, [Timer])]],
       print: [dart.void, [Zone, core.String]],
       fork: [Zone, [Zone, ZoneSpecification, core.Map]]
     })
   });
+  class _Zone extends core.Object {
+    _Zone() {
+    }
+    inSameErrorZone(otherZone) {
+      return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
+    }
+  }
+  _Zone[dart.implements] = () => [Zone];
+  dart.setSignature(_Zone, {
+    constructors: () => ({_Zone: [_Zone, []]}),
+    methods: () => ({inSameErrorZone: [core.bool, [Zone]]})
+  });
   const _delegateCache = Symbol('_delegateCache');
+  const _map = Symbol('_map');
   class _CustomZone extends _Zone {
     get [_delegate]() {
       if (this[_delegateCache] != null) return this[_delegateCache];
       this[_delegateCache] = new _ZoneDelegate(this);
       return this[_delegateCache];
     }
     _CustomZone(parent, specification, map) {
       this.parent = parent;
       this[_map] = map;
       this[_runUnary] = null;
@@ skipping 340 matching lines @@
       return _rootCreatePeriodicTimer;
     }
     get print() {
       return _rootPrint;
     }
     get fork() {
       return _rootFork;
     }
   }
   _RootZoneSpecification[dart.implements] = () => [ZoneSpecification];
+  class _RootZone extends _Zone {
+    _RootZone() {
+      super._Zone();
+    }
+    get [_run]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRun));
+    }
+    get [_runUnary]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunUnary));
+    }
+    get [_runBinary]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunBinary));
+    }
+    get [_registerCallback]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback));
+    }
+    get [_registerUnaryCallback]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback));
+    }
+    get [_registerBinaryCallback]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback));
+    }
+    get [_errorCallback]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootErrorCallback));
+    }
+    get [_scheduleMicrotask]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask));
+    }
+    get [_createTimer]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreateTimer));
+    }
+    get [_createPeriodicTimer]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer));
+    }
+    get [_print]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootPrint));
+    }
+    get [_fork]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootFork));
+    }
+    get [_handleUncaughtError]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError));
+    }
+    get parent() {
+      return null;
+    }
+    get [_map]() {
+      return _RootZone._rootMap;
+    }
+    get [_delegate]() {
+      if (_RootZone._rootDelegate != null) return _RootZone._rootDelegate;
+      return _RootZone._rootDelegate = new _ZoneDelegate(this);
+    }
+    get errorZone() {
+      return this;
+    }
+    runGuarded(f) {
+      try {
+        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
+          return f();
+        }
+        return _rootRun(null, null, this, f);
+      } catch (e) {
+        let s = dart.stackTrace(e);
+        return this.handleUncaughtError(e, s);
+      }
+
+    }
+    runUnaryGuarded(f, arg) {
+      try {
+        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
+          return dart.dcall(f, arg);
+        }
+        return _rootRunUnary(null, null, this, f, arg);
+      } catch (e) {
+        let s = dart.stackTrace(e);
+        return this.handleUncaughtError(e, s);
+      }
+
+    }
+    runBinaryGuarded(f, arg1, arg2) {
+      try {
+        if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
+          return dart.dcall(f, arg1, arg2);
+        }
+        return _rootRunBinary(null, null, this, f, arg1, arg2);
+      } catch (e) {
+        let s = dart.stackTrace(e);
+        return this.handleUncaughtError(e, s);
+      }
+
+    }
+    bindCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
+      if (dart.notNull(runGuarded)) {
+        return dart.fn((() => this.runGuarded(f)).bind(this));
+      } else {
+        return dart.fn((() => this.run(f)).bind(this));
+      }
+    }
+    bindUnaryCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
+      if (dart.notNull(runGuarded)) {
+        return dart.fn((arg => this.runUnaryGuarded(f, arg)).bind(this));
+      } else {
+        return dart.fn((arg => this.runUnary(f, arg)).bind(this));
+      }
+    }
+    bindBinaryCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
+      if (dart.notNull(runGuarded)) {
+        return dart.fn(((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this));
+      } else {
+        return dart.fn(((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this));
+      }
+    }
+    get(key) {
+      return null;
+    }
+    handleUncaughtError(error, stackTrace) {
+      return _rootHandleUncaughtError(null, null, this, error, stackTrace);
+    }
+    fork(opts) {
+      let specification = opts && 'specification' in opts ? opts.specification : null;
+      let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
+      return _rootFork(null, null, this, specification, zoneValues);
+    }
+    run(f) {
+      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE))) return f();
+      return _rootRun(null, null, this, f);
+    }
+    runUnary(f, arg) {
+      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE))) return dart.dcall(f, arg);
+      return _rootRunUnary(null, null, this, f, arg);
+    }
+    runBinary(f, arg1, arg2) {
+      if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE))) return dart.dcall(f, arg1, arg2);
+      return _rootRunBinary(null, null, this, f, arg1, arg2);
+    }
+    registerCallback(f) {
+      return f;
+    }
+    registerUnaryCallback(f) {
+      return f;
+    }
+    registerBinaryCallback(f) {
+      return f;
+    }
+    errorCallback(error, stackTrace) {
+      return null;
+    }
+    scheduleMicrotask(f) {
+      _rootScheduleMicrotask(null, null, this, f);
+    }
+    createTimer(duration, f) {
+      return Timer._createTimer(duration, f);
+    }
+    createPeriodicTimer(duration, f) {
+      return Timer._createPeriodicTimer(duration, f);
+    }
+    print(line) {
+      _internal.printToConsole(line);
+    }
+  }
+  dart.setSignature(_RootZone, {
+    constructors: () => ({_RootZone: [_RootZone, []]}),
+    methods: () => ({
+      runGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
+      runUnaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
+      runBinaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
+      bindCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])], {runGuarded: core.bool}],
+      bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])], {runGuarded: core.bool}],
+      bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {runGuarded: core.bool}],
+      get: [dart.dynamic, [core.Object]],
+      handleUncaughtError: [dart.dynamic, [dart.dynamic, core.StackTrace]],
+      fork: [Zone, [], {specification: ZoneSpecification, zoneValues: core.Map}],
+      run: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
+      runUnary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
+      runBinary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
+      registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
+      registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]],
+      registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
+      errorCallback: [AsyncError, [core.Object, core.StackTrace]],
+      scheduleMicrotask: [dart.void, [dart.functionType(dart.void, [])]],
+      createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
+      createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]],
+      print: [dart.void, [core.String]]
+    })
+  });
   _RootZone._rootDelegate = null;
   dart.defineLazyProperties(_RootZone, {
     get _rootMap() {
       return collection.HashMap.new();
     },
     set _rootMap(_) {}
   });
+  const _ROOT_ZONE = dart.const(new _RootZone());
   function runZoned(body, opts) {
     let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
     let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
     let onError = opts && 'onError' in opts ? opts.onError : null;
     let errorHandler = null;
     if (onError != null) {
       errorHandler = dart.fn((self, parent, zone, error, stackTrace) => {
         try {
           if (dart.is(onError, ZoneBinaryCallback)) {
             return self.parent.runBinary(onError, error, stackTrace);
@@ skipping 86 matching lines @@
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
   exports.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 });