canonicalize const

lib/runtime/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dcall(errorHandler, error, stackTrace);
     } else {
       return dart.dcall(errorHandler, error);
     }
@@ skipping 1042 matching lines @@
         }
       }
       [_close]() {
         dart.assert(!dart.notNull(this[_isClosed]));
         if (this[_isCanceled])
           return;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription[_STATE_CLOSED]);
         if (this[_canFire]) {
           this[_sendDone]();
         } else {
-          this[_addPending](new _DelayedDone());
+          this[_addPending](dart.const(new _DelayedDone()));
         }
       }
       [_onPause]() {
         dart.assert(this[_isInputPaused]);
       }
       [_onResume]() {
         dart.assert(!dart.notNull(this[_isInputPaused]));
       }
       [_onCancel]() {
         dart.assert(this[_isCanceled]);
@@ skipping 455 matching lines @@
       [_sendError](error, stackTrace) {
         for (let link = this[_next]; !dart.notNull(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]) {
             let subscription = dart.as(link, _BroadcastSubscription$(T));
-            subscription[_addPending](new _DelayedDone());
+            subscription[_addPending](dart.const(new _DelayedDone()));
           }
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     return _AsyncBroadcastStreamController;
   });
@@ skipping 33 matching lines @@
         }
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
         this[_sendError](error, stackTrace);
         while (this[_hasPending]) {
           this[_pending].handleNext(this);
         }
       }
       close() {
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
-          this[_addPendingEvent](new _DelayedDone());
+          this[_addPendingEvent](dart.const(new _DelayedDone()));
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController[_STATE_CLOSED]);
           return super.done;
         }
         let result = super.close();
         dart.assert(!dart.notNull(this[_hasPending]));
         return result;
       }
       [_callOnCancel]() {
         if (this[_hasPending]) {
           this[_pending].clear();
@@ skipping 192 matching lines @@
                   dart.dcall(cleanUp, value);
                 });
               }
               if (remaining == 0 && !dart.notNull(eagerError)) {
                 result[_completeError](error, stackTrace);
               }
             }
           }, {onError: handleError});
         }
         if (remaining == 0) {
-          return new Future$(core.List).value(/* Unimplemented const */[]);
+          return new Future$(core.List).value(dart.const([]));
         }
         values = new core.List(remaining);
         return result;
       }
       static forEach(input, f) {
         let iterator = input[core.$iterator];
         return Future.doWhile(() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
           return new Future.sync(() => dart.dcall(f, iterator.current)).then(_ => true);
@@ skipping 1072 matching lines @@
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         this[_closeUnchecked]();
         return this[_ensureDoneFuture]();
       }
       [_closeUnchecked]() {
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController[_STATE_CLOSED]);
         if (this.hasListener) {
           this[_sendDone]();
         } else if (this[_isInitialState]) {
-          this[_ensurePendingEvents]().add(new _DelayedDone());
+          this[_ensurePendingEvents]().add(dart.const(new _DelayedDone()));
         }
       }
       [_add](value) {
         if (this.hasListener) {
           this[_sendData](value);
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(new (_DelayedData$(T))(value));
         }
       }
       [_addError](error, stackTrace) {
@@ skipping 108 matching lines @@
   let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$();
   let _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _AsyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         this[_subscription][_addPending](new _DelayedData(data));
       }
       [_sendError](error, stackTrace) {
         this[_subscription][_addPending](new _DelayedError(error, stackTrace));
       }
       [_sendDone]() {
-        this[_subscription][_addPending](new _DelayedDone());
+        this[_subscription][_addPending](dart.const(new _DelayedDone()));
       }
     }
     _AsyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     return _AsyncStreamControllerDispatch;
   });
   let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$();
   let _AsyncStreamController$ = dart.generic(function(T) {
     class _AsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T)) {
       _AsyncStreamController(onListen, onPause, onResume, onCancel) {
         this[_onListen] = onListen;
@@ skipping 1869 matching lines @@
     _internal.printToConsole(line);
   }
   // Function _printToZone: (String) → void
   function _printToZone(line) {
     Zone.current.print(line);
   }
   // Function _rootFork: (Zone, ZoneDelegate, Zone, ZoneSpecification, Map<dynamic, dynamic>) → Zone
   function _rootFork(self, parent, zone, specification, zoneValues) {
     _internal.printToZone = _printToZone;
     if (specification == null) {
-      specification = new ZoneSpecification();
+      specification = dart.const(new ZoneSpecification());
     } else if (!dart.is(specification, _ZoneSpecification)) {
       throw new core.ArgumentError("ZoneSpecifications must be instantiated" + " with the provided constructor.");
     }
     let valueMap = null;
     if (zoneValues == null) {
       if (dart.is(zone, _Zone)) {
         valueMap = zone[_map];
       } else {
         valueMap = new collection.HashMap();
       }
@@ skipping 44 matching lines @@
     }
   }
   _RootZoneSpecification[dart.implements] = () => [ZoneSpecification];
   let _rootMap = Symbol('_rootMap');
   let _rootDelegate = Symbol('_rootDelegate');
   class _RootZone extends _Zone {
     _RootZone() {
       super._Zone();
     }
     get [_run]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootRun);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRun));
     }
     get [_runUnary]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootRunUnary);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunUnary));
     }
     get [_runBinary]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootRunBinary);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunBinary));
     }
     get [_registerCallback]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback));
     }
     get [_registerUnaryCallback]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback));
     }
     get [_registerBinaryCallback]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback));
     }
     get [_errorCallback]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootErrorCallback);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootErrorCallback));
     }
     get [_scheduleMicrotask]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask));
     }
     get [_createTimer]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootCreateTimer);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreateTimer));
     }
     get [_createPeriodicTimer]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer));
     }
     get [_print]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootPrint);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootPrint));
     }
     get [_fork]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootFork);
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootFork));
     }
     get [_handleUncaughtError]() {
-      return new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError);
+      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];
@@ skipping 113 matching lines @@
       _internal.printToConsole(line);
     }
   }
   _RootZone._rootDelegate = null;
   dart.defineLazyProperties(_RootZone, {
     get _rootMap() {
       return new collection.HashMap();
     },
     set _rootMap(_) {}
   });
-  let _ROOT_ZONE = new _RootZone();
+  let _ROOT_ZONE = dart.const(new _RootZone());
   // Function runZoned: (() → dynamic, {zoneValues: Map<dynamic, dynamic>, zoneSpecification: ZoneSpecification, onError: Function}) → dynamic
   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 = (self, parent, zone, error, stackTrace) => {
         try {
           if (dart.is(onError, ZoneBinaryCallback)) {
@@ 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;
 })(async || (async = {}));