Add a few more known non-null cases

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 304 matching lines @@
           try {
             buffer.write(element);
           } catch (e) {
             let s = dart.stackTrace(e);
             _cancelAndErrorWithReplacement(subscription, result, e, s);
           }
 
         }, dart.void, [T]), {onError: dart.fn(e => {
             result[_completeError](e);
           }), onDone: dart.fn(() => {
-            result[_complete](dart.toString(buffer));
+            result[_complete](buffer.toString());
           }, dart.void, []), cancelOnError: true});
         return result;
       }
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => dart.equals(element, needle), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
@@ skipping 462 matching lines @@
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
       }
       get hashCode() {
         return dart.notNull(dart.hashCode(this[_controller])) ^ 892482866;
       }
       ['=='](other) {
-        if (dart.notNull(core.identical(this, other))) return true;
+        if (core.identical(this, other)) return true;
         if (!dart.is(other, _ControllerStream$())) return false;
         let otherStream = dart.as(other, _ControllerStream$());
         return core.identical(otherStream[_controller], this[_controller]);
       }
     }
     dart.setSignature(_ControllerStream, {
       constructors: () => ({_ControllerStream: [_ControllerStream$(T), [_StreamControllerLifecycle$(T)]]}),
       methods: () => ({
         [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         '==': [core.bool, [core.Object]]
@@ skipping 518 matching lines @@
         dart.assert(core.identical(subscription[_next], subscription));
         subscription[_previous] = this[_previous];
         subscription[_next] = this;
         this[_previous][_next] = subscription;
         this[_previous] = subscription;
         subscription[_eventState] = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController$()._STATE_EVENT_ID);
       }
       [_removeListener](subscription) {
         dart.as(subscription, _BroadcastSubscription$(T));
         dart.assert(core.identical(subscription[_controller], this));
-        dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
+        dart.assert(!core.identical(subscription[_next], subscription));
         let previous = subscription[_previous];
         let next = subscription[_next];
         previous[_next] = next;
         next[_previous] = previous;
         subscription[_next] = subscription[_previous] = subscription;
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         if (dart.notNull(this.isClosed)) {
           if (onDone == null) onDone = _nullDoneHandler;
           return new (_DoneStreamSubscription$(T))(onDone);
         }
         let subscription = new (_BroadcastSubscription$(T))(this, onData, onError, onDone, cancelOnError);
         this[_addListener](dart.as(subscription, _BroadcastSubscription$(T)));
-        if (dart.notNull(core.identical(this[_next], this[_previous]))) {
+        if (core.identical(this[_next], this[_previous])) {
           _runGuarded(this[_onListen]);
         }
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](sub) {
         dart.as(sub, StreamSubscription$(T));
         let subscription = dart.as(sub, _BroadcastSubscription$(T));
-        if (dart.notNull(core.identical(subscription[_next], subscription))) return null;
-        dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
+        if (core.identical(subscription[_next], subscription)) return null;
+        dart.assert(!core.identical(subscription[_next], subscription));
         if (dart.notNull(subscription[_isFiring])) {
           subscription[_setRemoveAfterFiring]();
         } else {
-          dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
+          dart.assert(!core.identical(subscription[_next], subscription));
           this[_removeListener](subscription);
           if (!dart.notNull(this[_isFiring]) && dart.notNull(this[_isEmpty])) {
             this[_callOnCancel]();
           }
         }
         return null;
       }
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
@@ skipping 61 matching lines @@
       }
       [_forEachListener](action) {
         dart.as(action, dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
         if (dart.notNull(this[_isFiring])) {
           dart.throw(new core.StateError("Cannot fire new event. Controller is already firing an event"));
         }
         if (dart.notNull(this[_isEmpty])) return;
         let id = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController$()._STATE_EVENT_ID);
         this[_state] = dart.notNull(this[_state]) ^ (dart.notNull(_BroadcastStreamController$()._STATE_EVENT_ID) | dart.notNull(_BroadcastStreamController$()._STATE_FIRING));
         let link = this[_next];
-        while (!dart.notNull(core.identical(link, this))) {
+        while (!core.identical(link, this)) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
           if (dart.notNull(subscription[_expectsEvent](id))) {
             subscription[_eventState] = dart.notNull(subscription[_eventState]) | dart.notNull(_BroadcastSubscription._STATE_FIRING);
             action(subscription);
             subscription[_toggleEventId]();
             link = subscription[_next];
             if (dart.notNull(subscription[_removeAfterFiring])) {
               this[_removeListener](subscription);
             }
             subscription[_eventState] = dart.notNull(subscription[_eventState]) & ~dart.notNull(_BroadcastSubscription._STATE_FIRING);
@@ skipping 99 matching lines @@
     return _SyncBroadcastStreamController;
   });
   let _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
   const _AsyncBroadcastStreamController$ = dart.generic(function(T) {
     class _AsyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _AsyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         dart.as(data, T);
-        for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
+        for (let link = this[_next]; !core.identical(link, this); link = link[_next]) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
           subscription[_addPending](new _DelayedData(data));
         }
       }
       [_sendError](error, stackTrace) {
-        for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
+        for (let link = this[_next]; !core.identical(link, this); link = link[_next]) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
           subscription[_addPending](new _DelayedError(error, stackTrace));
         }
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
-          for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
+          for (let link = this[_next]; !core.identical(link, this); link = link[_next]) {
             let subscription = dart.as(link, _BroadcastSubscription$(T));
             subscription[_addPending](dart.const(new _DelayedDone()));
           }
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
@@ skipping 197 matching lines @@
         }
 
       }
       static value(value) {
         if (value === void 0) value = null;
         return new (_Future$(T)).immediate(value);
       }
       static error(error, stackTrace) {
         if (stackTrace === void 0) stackTrace = null;
         error = _nonNullError(error);
-        if (!dart.notNull(core.identical(Zone.current, _ROOT_ZONE))) {
+        if (!core.identical(Zone.current, _ROOT_ZONE)) {
           let replacement = Zone.current.errorCallback(error, stackTrace);
           if (replacement != null) {
             error = _nonNullError(replacement.error);
             stackTrace = replacement.stackTrace;
           }
         }
         return new (_Future$(T)).immediateError(error, stackTrace);
       }
       static delayed(duration, computation) {
         if (computation === void 0) computation = null;
@@ skipping 394 matching lines @@
           this[_state] = _Future$()._CHAINED;
         } else {
           dart.assert(this[_isChained]);
           this[_state] = _Future$()._INCOMPLETE;
         }
       }
       then(f, opts) {
         dart.as(f, dart.functionType(dart.dynamic, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let result = new (_Future$())();
-        if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
+        if (!core.identical(result[_zone], _ROOT_ZONE)) {
           f = dart.as(result[_zone].registerUnaryCallback(f), __CastType4);
           if (onError != null) {
             onError = _registerErrorHandler(onError, result[_zone]);
           }
         }
         this[_addListener](new _FutureListener.then(result, f, onError));
         return result;
       }
       catchError(onError, opts) {
         let test = opts && 'test' in opts ? opts.test : null;
         dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         let result = new (_Future$())();
-        if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
+        if (!core.identical(result[_zone], _ROOT_ZONE)) {
           onError = _registerErrorHandler(onError, result[_zone]);
           if (test != null) test = dart.as(result[_zone].registerUnaryCallback(test), __CastType6);
         }
         this[_addListener](new _FutureListener.catchError(result, onError, test));
         return result;
       }
       whenComplete(action) {
         dart.as(action, dart.functionType(dart.dynamic, []));
         let result = new (_Future$(T))();
-        if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
+        if (!core.identical(result[_zone], _ROOT_ZONE)) {
           action = result[_zone].registerCallback(action);
         }
         this[_addListener](new _FutureListener.whenComplete(result, action));
         return dart.as(result, Future$(T));
       }
       asStream() {
         return Stream$(T).fromFuture(this);
       }
       [_markPendingCompletion]() {
         if (!dart.notNull(this[_mayComplete])) dart.throw(new core.StateError("Future already completed"));
@@ skipping 154 matching lines @@
           let listenerValueOrError = sourceValue;
           let isPropagationAborted = false;
           if (dart.notNull(hasError) || dart.notNull(listener.handlesValue) || dart.notNull(listener.handlesComplete)) {
             let zone = listener[_zone];
             if (dart.notNull(hasError) && !dart.notNull(source[_zone].inSameErrorZone(zone))) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
               return;
             }
             let oldZone = null;
-            if (!dart.notNull(core.identical(Zone.current, zone))) {
+            if (!core.identical(Zone.current, zone)) {
               oldZone = Zone._enter(zone);
             }
             function handleValueCallback() {
               try {
                 listenerValueOrError = zone.runUnary(listener[_onValue], sourceValue);
                 return true;
               } catch (e) {
                 let s = dart.stackTrace(e);
                 listenerValueOrError = new AsyncError(e, s);
                 return false;
               }
 
             }
             dart.fn(handleValueCallback, core.bool, []);
             function handleError() {
               let asyncError = source[_error];
               let matchesTest = true;
               if (dart.notNull(listener.hasErrorTest)) {
                 let test = listener[_errorTest];
                 try {
                   matchesTest = dart.as(zone.runUnary(test, asyncError.error), core.bool);
                 } catch (e) {
                   let s = dart.stackTrace(e);
-                  listenerValueOrError = dart.notNull(core.identical(asyncError.error, e)) ? asyncError : new AsyncError(e, s);
+                  listenerValueOrError = core.identical(asyncError.error, e) ? asyncError : new AsyncError(e, s);
                   listenerHasValue = false;
                   return;
                 }
 
               }
               let errorCallback = listener[_onError];
               if (dart.notNull(matchesTest) && errorCallback != null) {
                 try {
                   if (dart.is(errorCallback, ZoneBinaryCallback)) {
                     listenerValueOrError = zone.runBinary(errorCallback, asyncError.error, asyncError.stackTrace);
                   } else {
                     listenerValueOrError = zone.runUnary(dart.as(errorCallback, __CastType8), asyncError.error);
                   }
                 } catch (e) {
                   let s = dart.stackTrace(e);
-                  listenerValueOrError = dart.notNull(core.identical(asyncError.error, e)) ? asyncError : new AsyncError(e, s);
+                  listenerValueOrError = core.identical(asyncError.error, e) ? asyncError : new AsyncError(e, s);
                   listenerHasValue = false;
                   return;
                 }
 
                 listenerHasValue = true;
               } else {
                 listenerValueOrError = asyncError;
                 listenerHasValue = false;
               }
             }
             dart.fn(handleError, dart.void, []);
             function handleWhenCompleteCallback() {
               let completeResult = null;
               try {
                 completeResult = zone.run(listener[_whenCompleteAction]);
               } catch (e) {
                 let s = dart.stackTrace(e);
-                if (dart.notNull(hasError) && dart.notNull(core.identical(source[_error].error, e))) {
+                if (dart.notNull(hasError) && core.identical(source[_error].error, e)) {
                   listenerValueOrError = source[_error];
                 } else {
                   listenerValueOrError = new AsyncError(e, s);
                 }
                 listenerHasValue = false;
                 return;
               }
 
               if (dart.is(completeResult, Future)) {
                 let result = listener.result;
@@ skipping 17 matching lines @@
                 listenerHasValue = handleValueCallback();
               }
             } else {
               handleError();
             }
             if (dart.notNull(listener.handlesComplete)) {
               handleWhenCompleteCallback();
             }
             if (oldZone != null) Zone._leave(oldZone);
             if (isPropagationAborted) return;
-            if (dart.notNull(listenerHasValue) && !dart.notNull(core.identical(sourceValue, listenerValueOrError)) && dart.is(listenerValueOrError, Future)) {
+            if (dart.notNull(listenerHasValue) && !core.identical(sourceValue, listenerValueOrError) && dart.is(listenerValueOrError, Future)) {
               let chainSource = dart.as(listenerValueOrError, Future);
               let result = listener.result;
               if (dart.is(chainSource, _Future$())) {
                 if (dart.notNull(chainSource[_isComplete])) {
                   result[_isChained] = true;
                   source = chainSource;
                   listeners = new _FutureListener.chain(result);
                   continue;
                 } else {
                   _Future$()._chainCoreFuture(chainSource, result);
@@ skipping 162 matching lines @@
       entry.next = exports._lastPriorityCallback.next;
       exports._lastPriorityCallback.next = entry;
       exports._lastPriorityCallback = entry;
       if (entry.next == null) {
         exports._lastCallback = entry;
       }
     }
   }
   dart.fn(_schedulePriorityAsyncCallback, dart.void, [dart.dynamic]);
   function scheduleMicrotask(callback) {
-    if (dart.notNull(core.identical(_ROOT_ZONE, Zone.current))) {
+    if (core.identical(_ROOT_ZONE, Zone.current)) {
       _rootScheduleMicrotask(null, null, _ROOT_ZONE, callback);
       return;
     }
     Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuarded: true}));
   }
   dart.fn(scheduleMicrotask, dart.void, [dart.functionType(dart.void, [])]);
   class _AsyncRun extends core.Object {
     static _scheduleImmediate(callback) {
       dart.dcall(_AsyncRun.scheduleImmediateClosure, callback);
     }
@@ skipping 1619 matching lines @@
             _addErrorWithReplacement(sink, e, s);
             return;
           }
 
         }
         if (dart.notNull(matches)) {
           try {
             _invokeErrorHandler(this[_transform], error, stackTrace);
           } catch (e) {
             let s = dart.stackTrace(e);
-            if (dart.notNull(core.identical(e, error))) {
+            if (core.identical(e, error)) {
               sink[_addError](error, stackTrace);
             } else {
               _addErrorWithReplacement(sink, e, s);
             }
             return;
           }
 
         } else {
           sink[_addError](error, stackTrace);
         }
@@ skipping 137 matching lines @@
   const _DistinctStream$ = dart.generic(function(T) {
     class _DistinctStream extends _ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
         this[_previous] = _DistinctStream$()._SENTINEL;
         this[_equals] = equals;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
-        if (dart.notNull(core.identical(this[_previous], _DistinctStream$()._SENTINEL))) {
+        if (core.identical(this[_previous], _DistinctStream$()._SENTINEL)) {
           this[_previous] = inputEvent;
           return sink[_add](inputEvent);
         } else {
           let isEqual = null;
           try {
             if (this[_equals] == null) {
               isEqual = dart.equals(this[_previous], inputEvent);
             } else {
               isEqual = this[_equals](dart.as(this[_previous], T), inputEvent);
             }
@@ skipping 109 matching lines @@
           this[_addError](e, s);
         }
 
       }
       [_handleError](error, stackTrace) {
         if (stackTrace === void 0) stackTrace = null;
         try {
           this[_transformerSink].addError(error, dart.as(stackTrace, core.StackTrace));
         } catch (e) {
           let s = dart.stackTrace(e);
-          if (dart.notNull(core.identical(e, error))) {
+          if (core.identical(e, error)) {
             this[_addError](error, dart.as(stackTrace, core.StackTrace));
           } else {
             this[_addError](e, s);
           }
         }
 
       }
       [_handleDone]() {
         try {
           this[_subscription] = null;
@@ skipping 337 matching lines @@
   });
   class ZoneDelegate extends core.Object {}
   class Zone extends core.Object {
     _() {
     }
     static get current() {
       return Zone._current;
     }
     static _enter(zone) {
       dart.assert(zone != null);
-      dart.assert(!dart.notNull(core.identical(zone, Zone._current)));
+      dart.assert(!core.identical(zone, Zone._current));
       let previous = Zone._current;
       Zone._current = zone;
       return previous;
     }
     static _leave(previous) {
       dart.assert(previous != null);
       Zone._current = previous;
     }
   }
   dart.defineNamedConstructor(Zone, '_');
@@ skipping 69 matching lines @@
       return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneUnaryCallback);
     }
     registerBinaryCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerBinaryCallback];
       let implZone = implementation.zone;
       return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneBinaryCallback);
     }
     errorCallback(zone, error, stackTrace) {
       let implementation = this[_delegationTarget][_errorCallback];
       let implZone = implementation.zone;
-      if (dart.notNull(core.identical(implZone, _ROOT_ZONE))) return null;
+      if (core.identical(implZone, _ROOT_ZONE)) return null;
       return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace), AsyncError);
     }
     scheduleMicrotask(zone, f) {
       let implementation = this[_delegationTarget][_scheduleMicrotask];
       let implZone = implementation.zone;
       dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, f);
     }
     createTimer(zone, duration, f) {
       let implementation = this[_delegationTarget][_createTimer];
       let implZone = implementation.zone;
@@ skipping 31 matching lines @@
       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));
+      return core.identical(this, otherZone) || 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 {
@@ skipping 151 matching lines @@
     registerBinaryCallback(f) {
       let implementation = this[_registerBinaryCallback];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
       return dart.as(dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f), ZoneBinaryCallback);
     }
     errorCallback(error, stackTrace) {
       let implementation = this[_errorCallback];
       dart.assert(implementation != null);
       let implementationZone = implementation.zone;
-      if (dart.notNull(core.identical(implementationZone, _ROOT_ZONE))) return null;
+      if (core.identical(implementationZone, _ROOT_ZONE)) return null;
       let parentDelegate = _parentDelegate(dart.as(implementationZone, _Zone));
       return dart.as(dart.dcall(implementation.function, implementationZone, parentDelegate, this, error, stackTrace), AsyncError);
     }
     scheduleMicrotask(f) {
       let implementation = this[_scheduleMicrotask];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
       return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, f);
     }
     createTimer(duration, f) {
@@ skipping 86 matching lines @@
   dart.fn(_rootRegisterUnaryCallback, ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]);
   function _rootRegisterBinaryCallback(self, parent, zone, f) {
     return f;
   }
   dart.fn(_rootRegisterBinaryCallback, ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]);
   function _rootErrorCallback(self, parent, zone, error, stackTrace) {
     return null;
   }
   dart.fn(_rootErrorCallback, AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]);
   function _rootScheduleMicrotask(self, parent, zone, f) {
-    if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
+    if (!core.identical(_ROOT_ZONE, zone)) {
       let hasErrorHandler = !dart.notNull(_ROOT_ZONE.inSameErrorZone(zone));
       f = zone.bindCallback(f, {runGuarded: hasErrorHandler});
     }
     _scheduleAsyncCallback(f);
   }
   dart.fn(_rootScheduleMicrotask, dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]);
   function _rootCreateTimer(self, parent, zone, duration, callback) {
-    if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
+    if (!core.identical(_ROOT_ZONE, zone)) {
       callback = zone.bindCallback(callback);
     }
     return Timer._createTimer(duration, callback);
   }
   dart.fn(_rootCreateTimer, Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]);
   function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
-    if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
+    if (!core.identical(_ROOT_ZONE, zone)) {
       callback = dart.as(zone.bindUnaryCallback(callback), __CastType25);
     }
     return Timer._createPeriodicTimer(duration, callback);
   }
   dart.fn(_rootCreatePeriodicTimer, Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]);
   function _rootPrint(self, parent, zone, line) {
     _internal.printToConsole(line);
   }
   dart.fn(_rootPrint, dart.void, [Zone, ZoneDelegate, Zone, core.String]);
   function _printToZone(line) {
@@ skipping 113 matching lines @@
     }
     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))) {
+        if (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))) {
+        if (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))) {
+        if (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) {
@@ skipping 25 matching lines @@
     }
     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();
+      if (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);
+      if (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);
+      if (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;
@@ skipping 54 matching lines @@
     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);
           }
           return self.parent.runUnary(dart.as(onError, __CastType27), error);
         } catch (e) {
           let s = dart.stackTrace(e);
-          if (dart.notNull(core.identical(e, error))) {
+          if (core.identical(e, error)) {
             return parent.handleUncaughtError(zone, error, stackTrace);
           } else {
             return parent.handleUncaughtError(zone, e, s);
           }
         }
 
       }, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]);
     }
     if (zoneSpecification == null) {
       zoneSpecification = ZoneSpecification.new({handleUncaughtError: errorHandler});
@@ skipping 58 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;
 });