Use const for const/final top-levels, types, symbols.

lib/runtime/dart/_isolate_helper.js

 dart_library.library('dart/_isolate_helper', null, /* Imports */[
   "dart/_runtime",
   'dart/core',
   'dart/_interceptors',
   'dart/_js_helper',
   'dart/isolate',
   'dart/_foreign_helper',
   'dart/collection',
   'dart/async'
 ], /* Lazy imports */[
   'dart/_native_typed_data',
   'dart/_js_embedded_names'
 ], function(exports, dart, core, _interceptors, _js_helper, isolate, _foreign_helper, collection, async, _native_typed_data, _js_embedded_names) {
   'use strict';
   let dartx = dart.dartx;
   function _serializeMessage(message) {
     return new _Serializer().serialize(message);
   }
   dart.fn(_serializeMessage);
   function _deserializeMessage(message) {
     return new _Deserializer().deserialize(message);
   }
   dart.fn(_deserializeMessage);
   function _clone(message) {
     let serializer = new _Serializer({serializeSendPorts: false});
     let deserializer = new _Deserializer();
     return deserializer.deserialize(serializer.serialize(message));
   }
   dart.fn(_clone);
-  let _serializeSendPorts = Symbol('_serializeSendPorts');
-  let _workerId = Symbol('_workerId');
-  let _isolateId = Symbol('_isolateId');
-  let _receivePortId = Symbol('_receivePortId');
-  let _id = Symbol('_id');
-  let _receivePort = Symbol('_receivePort');
+  const _serializeSendPorts = Symbol('_serializeSendPorts');
+  const _workerId = Symbol('_workerId');
+  const _isolateId = Symbol('_isolateId');
+  const _receivePortId = Symbol('_receivePortId');
+  const _id = Symbol('_id');
+  const _receivePort = Symbol('_receivePort');
   class _Serializer extends core.Object {
     _Serializer(opts) {
       let serializeSendPorts = opts && 'serializeSendPorts' in opts ? opts.serializeSendPorts : true;
       this.serializedObjectIds = core.Map$(dart.dynamic, core.int).identity();
       this[_serializeSendPorts] = dart.as(serializeSendPorts, core.bool);
     }
     serialize(x) {
       if (dart.notNull(this.isPrimitive(x)))
         return this.serializePrimitive(x);
       let serializationId = this.serializedObjectIds.get(x);
@@ skipping 136 matching lines @@
       serializeArrayInPlace: [dart.dynamic, [_interceptors.JSArray]],
       serializeMap: [dart.dynamic, [core.Map]],
       serializeJSObject: [dart.dynamic, [_interceptors.JSObject]],
       serializeWorkerSendPort: [dart.dynamic, [_WorkerSendPort]],
       serializeJsSendPort: [dart.dynamic, [_NativeJsSendPort]],
       serializeCapability: [dart.dynamic, [CapabilityImpl]],
       serializeClosure: [dart.dynamic, [core.Function]],
       serializeDartObject: [dart.dynamic, [dart.dynamic]]
     })
   });
-  let _adjustSendPorts = Symbol('_adjustSendPorts');
+  const _adjustSendPorts = Symbol('_adjustSendPorts');
   class _Deserializer extends core.Object {
     _Deserializer(opts) {
       let adjustSendPorts = opts && 'adjustSendPorts' in opts ? opts.adjustSendPorts : true;
       this.deserializedObjects = core.List.new();
       this[_adjustSendPorts] = dart.as(adjustSendPorts, core.bool);
     }
     deserialize(x) {
       if (dart.notNull(this.isPrimitive(x)))
         return this.deserializePrimitive(x);
       if (!dart.is(x, _interceptors.JSArray))
@@ skipping 193 matching lines @@
       deserializeMutable: [core.List, [dart.dynamic]],
       deserializeConst: [core.List, [dart.dynamic]],
       deserializeMap: [core.Map, [dart.dynamic]],
       deserializeSendPort: [isolate.SendPort, [dart.dynamic]],
       deserializeRawSendPort: [isolate.SendPort, [dart.dynamic]],
       deserializeJSObject: [dart.dynamic, [dart.dynamic]],
       deserializeClosure: [core.Function, [dart.dynamic]],
       deserializeDartObject: [dart.dynamic, [dart.dynamic]]
     })
   });
-  let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  const __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   function _callInIsolate(isolate, func) {
     let result = isolate.eval(func);
     exports._globalState.topEventLoop.run();
     return result;
   }
   dart.fn(_callInIsolate, () => dart.definiteFunctionType(dart.dynamic, [_IsolateContext, core.Function]));
-  let _activeJsAsyncCount = Symbol('_activeJsAsyncCount');
+  const _activeJsAsyncCount = Symbol('_activeJsAsyncCount');
   function enterJsAsync() {
     let o = exports._globalState.topEventLoop;
     o[_activeJsAsyncCount] = dart.notNull(o[_activeJsAsyncCount]) + 1;
   }
   dart.fn(enterJsAsync);
   function leaveJsAsync() {
     let o = exports._globalState.topEventLoop;
     o[_activeJsAsyncCount] = dart.notNull(o[_activeJsAsyncCount]) - 1;
     dart.assert(dart.notNull(exports._globalState.topEventLoop[_activeJsAsyncCount]) >= 0);
   }
@@ skipping 34 matching lines @@
   }
   dart.fn(startRootIsolate, dart.void, [dart.dynamic, dart.dynamic]);
   dart.copyProperties(exports, {
     get _globalState() {
       return dart.as(dart.globalState, _Manager);
     },
     set _globalState(val) {
       dart.globalState = val;
     }
   });
-  let _nativeDetectEnvironment = Symbol('_nativeDetectEnvironment');
-  let _nativeInitWorkerMessageHandler = Symbol('_nativeInitWorkerMessageHandler');
+  const _nativeDetectEnvironment = Symbol('_nativeDetectEnvironment');
+  const _nativeInitWorkerMessageHandler = Symbol('_nativeInitWorkerMessageHandler');
   class _Manager extends core.Object {
     get useWorkers() {
       return this.supportsWorkers;
     }
     _Manager(entry) {
       this.entry = entry;
       this.nextIsolateId = 0;
       this.currentManagerId = 0;
       this.nextManagerId = 1;
       this.currentContext = null;
@@ skipping 50 matching lines @@
   dart.setSignature(_Manager, {
     constructors: () => ({_Manager: [_Manager, [core.Function]]}),
     methods: () => ({
       [_nativeDetectEnvironment]: [dart.void, []],
       [_nativeInitWorkerMessageHandler]: [dart.void, []],
       maybeCloseWorker: [dart.void, []]
     }),
     statics: () => ({_serializePrintMessage: [dart.dynamic, [dart.dynamic]]}),
     names: ['_serializePrintMessage']
   });
-  let _scheduledControlEvents = Symbol('_scheduledControlEvents');
-  let _isExecutingEvent = Symbol('_isExecutingEvent');
-  let _updateGlobalState = Symbol('_updateGlobalState');
-  let _setGlobals = Symbol('_setGlobals');
-  let _addRegistration = Symbol('_addRegistration');
-  let _close = Symbol('_close');
+  const _scheduledControlEvents = Symbol('_scheduledControlEvents');
+  const _isExecutingEvent = Symbol('_isExecutingEvent');
+  const _updateGlobalState = Symbol('_updateGlobalState');
+  const _setGlobals = Symbol('_setGlobals');
+  const _addRegistration = Symbol('_addRegistration');
+  const _close = Symbol('_close');
   class _IsolateContext extends core.Object {
     _IsolateContext() {
       this.id = (() => {
         let o = exports._globalState, x = o.nextIsolateId;
         o.nextIsolateId = dart.notNull(x) + 1;
         return x;
       })();
       this.ports = core.Map$(core.int, RawReceivePortImpl).new();
       this.weakPorts = core.Set$(core.int).new();
       this.isolateStatics = _foreign_helper.JS_CREATE_ISOLATE();
@@ skipping 263 matching lines @@
       handleControlMessage: [dart.void, [dart.dynamic]],
       lookup: [RawReceivePortImpl, [core.int]],
       [_addRegistration]: [dart.void, [core.int, RawReceivePortImpl]],
       register: [dart.void, [core.int, RawReceivePortImpl]],
       registerWeak: [dart.void, [core.int, RawReceivePortImpl]],
       [_updateGlobalState]: [dart.void, []],
       kill: [dart.void, []],
       unregister: [dart.void, [core.int]]
     })
   });
-  let _runHelper = Symbol('_runHelper');
+  const _runHelper = Symbol('_runHelper');
   class _EventLoop extends core.Object {
     _EventLoop() {
       this.events = collection.Queue$(_IsolateEvent).new();
       this[_activeJsAsyncCount] = 0;
     }
     enqueue(isolate, fn, msg) {
       this.events.addLast(new _IsolateEvent(dart.as(isolate, _IsolateContext), dart.as(fn, core.Function), dart.as(msg, core.String)));
     }
     prequeue(event) {
       this.events.addFirst(event);
@@ skipping 13 matching lines @@
       if (event == null) {
         this.checkOpenReceivePortsFromCommandLine();
         exports._globalState.maybeCloseWorker();
         return false;
       }
       event.process();
       return true;
     }
     [_runHelper]() {
       if (exports.globalWindow != null) {
-        let next = (function() {
+        const next = (function() {
           if (!dart.notNull(this.runIteration()))
             return;
           async.Timer.run(next);
         }).bind(this);
         dart.fn(next);
         next();
       } else {
         while (dart.notNull(this.runIteration())) {
         }
       }
@@ skipping 48 matching lines @@
     }
   });
   class _MainManagerStub extends core.Object {
     postMessage(msg) {
       exports._global.postMessage(msg);
     }
   }
   dart.setSignature(_MainManagerStub, {
     methods: () => ({postMessage: [dart.void, [dart.dynamic]]})
   });
-  let _SPAWNED_SIGNAL = "spawned";
-  let _SPAWN_FAILED_SIGNAL = "spawn failed";
+  const _SPAWNED_SIGNAL = "spawned";
+  const _SPAWN_FAILED_SIGNAL = "spawn failed";
   dart.copyProperties(exports, {
     get globalWindow() {
       return exports._global.window;
     },
     get globalWorker() {
       return exports._global.Worker;
     },
     get globalPostMessageDefined() {
       return !!exports._global.postMessage;
     }
   });
-  let _MainFunction = dart.typedef('_MainFunction', () => dart.functionType(dart.dynamic, []));
-  let _MainFunctionArgs = dart.typedef('_MainFunctionArgs', () => dart.functionType(dart.dynamic, [dart.dynamic]));
-  let _MainFunctionArgsMessage = dart.typedef('_MainFunctionArgsMessage', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
+  const _MainFunction = dart.typedef('_MainFunction', () => dart.functionType(dart.dynamic, []));
+  const _MainFunctionArgs = dart.typedef('_MainFunctionArgs', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  const _MainFunctionArgsMessage = dart.typedef('_MainFunctionArgsMessage', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
   class IsolateNatives extends core.Object {
     static computeThisScript() {
       let currentScript = document.currentScript;
       if (currentScript != null) {
         return String(currentScript.src);
       }
       if (dart.notNull(_js_helper.Primitives.isD8))
         return IsolateNatives.computeThisScriptD8();
       if (dart.notNull(_js_helper.Primitives.isJsshell))
         return IsolateNatives.computeThisScriptJsshell();
@@ skipping 284 matching lines @@
   IsolateNatives.enableSpawnWorker = null;
   dart.defineLazyProperties(IsolateNatives, {
     get thisScript() {
       return IsolateNatives.computeThisScript();
     },
     set thisScript(_) {},
     get workerIds() {
       return new (core.Expando$(core.int))();
     }
   });
-  let _checkReplyTo = Symbol('_checkReplyTo');
+  const _checkReplyTo = Symbol('_checkReplyTo');
   class _BaseSendPort extends core.Object {
     _BaseSendPort(isolateId) {
       this[_isolateId] = isolateId;
     }
     [_checkReplyTo](replyTo) {
       if (replyTo != null && !dart.is(replyTo, _NativeJsSendPort) && !dart.is(replyTo, _WorkerSendPort)) {
         dart.throw(core.Exception.new("SendPort.send: Illegal replyTo port type"));
       }
     }
   }
   _BaseSendPort[dart.implements] = () => [isolate.SendPort];
   dart.setSignature(_BaseSendPort, {
     constructors: () => ({_BaseSendPort: [_BaseSendPort, [core.int]]}),
     methods: () => ({[_checkReplyTo]: [dart.void, [isolate.SendPort]]})
   });
-  let _isClosed = Symbol('_isClosed');
-  let _add = Symbol('_add');
+  const _isClosed = Symbol('_isClosed');
+  const _add = Symbol('_add');
   class _NativeJsSendPort extends _BaseSendPort {
     _NativeJsSendPort(receivePort, isolateId) {
       this[_receivePort] = receivePort;
       super._BaseSendPort(isolateId);
     }
     send(message) {
       let isolate = exports._globalState.isolates.get(this[_isolateId]);
       if (isolate == null)
         return;
       if (dart.notNull(this[_receivePort][_isClosed]))
@@ skipping 43 matching lines @@
     }
     get hashCode() {
       return dart.notNull(this[_workerId]) << 16 ^ dart.notNull(this[_isolateId]) << 8 ^ dart.notNull(this[_receivePortId]);
     }
   }
   _WorkerSendPort[dart.implements] = () => [isolate.SendPort];
   dart.setSignature(_WorkerSendPort, {
     constructors: () => ({_WorkerSendPort: [_WorkerSendPort, [core.int, core.int, core.int]]}),
     methods: () => ({send: [dart.void, [dart.dynamic]]})
   });
-  let _handler = Symbol('_handler');
+  const _handler = Symbol('_handler');
   class RawReceivePortImpl extends core.Object {
     RawReceivePortImpl(handler) {
       this[_handler] = handler;
       this[_id] = (() => {
         let x = RawReceivePortImpl._nextFreeId;
         RawReceivePortImpl._nextFreeId = dart.notNull(x) + 1;
         return x;
       })();
       this[_isClosed] = false;
       exports._globalState.currentContext.register(this[_id], this);
@@ skipping 45 matching lines @@
       weak: [RawReceivePortImpl, [core.Function]],
       _controlPort: [RawReceivePortImpl, []]
     }),
     methods: () => ({
       [_close]: [dart.void, []],
       close: [dart.void, []],
       [_add]: [dart.void, [dart.dynamic]]
     })
   });
   RawReceivePortImpl._nextFreeId = 1;
-  let _rawPort = Symbol('_rawPort');
-  let _controller = Symbol('_controller');
+  const _rawPort = Symbol('_rawPort');
+  const _controller = Symbol('_controller');
   class ReceivePortImpl extends async.Stream {
     ReceivePortImpl() {
       this.fromRawReceivePort(new RawReceivePortImpl(null));
     }
     weak() {
       this.fromRawReceivePort(new RawReceivePortImpl.weak(null));
     }
     fromRawReceivePort(rawPort) {
       this[_rawPort] = rawPort;
       this[_controller] = null;
@@ skipping 22 matching lines @@
     constructors: () => ({
       ReceivePortImpl: [ReceivePortImpl, []],
       weak: [ReceivePortImpl, []],
       fromRawReceivePort: [ReceivePortImpl, [isolate.RawReceivePort]]
     }),
     methods: () => ({
       listen: [async.StreamSubscription, [dart.functionType(dart.void, [dart.dynamic])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}],
       close: [dart.void, []]
     })
   });
-  let _once = Symbol('_once');
-  let _inEventLoop = Symbol('_inEventLoop');
-  let _handle = Symbol('_handle');
+  const _once = Symbol('_once');
+  const _inEventLoop = Symbol('_inEventLoop');
+  const _handle = Symbol('_handle');
   class TimerImpl extends core.Object {
     TimerImpl(milliseconds, callback) {
       this[_once] = true;
       this[_inEventLoop] = false;
       this[_handle] = null;
       if (milliseconds == 0 && (!dart.notNull(hasTimer()) || dart.notNull(exports._globalState.isWorker))) {
-        let internalCallback = (function() {
+        const internalCallback = (function() {
           this[_handle] = null;
           callback();
         }).bind(this);
         dart.fn(internalCallback, dart.void, []);
         this[_handle] = 1;
         exports._globalState.topEventLoop.enqueue(exports._globalState.currentContext, internalCallback, 'timer');
         this[_inEventLoop] = true;
       } else if (dart.notNull(hasTimer())) {
-        let internalCallback = (function() {
+        const internalCallback = (function() {
           this[_handle] = null;
           leaveJsAsync();
           callback();
         }).bind(this);
         dart.fn(internalCallback, dart.void, []);
         enterJsAsync();
         this[_handle] = self.setTimeout(internalCallback, milliseconds);
       } else {
         dart.assert(dart.notNull(milliseconds) > 0);
         dart.throw(new core.UnsupportedError("Timer greater than 0."));
@@ skipping 88 matching lines @@
   exports.leaveJsAsync = leaveJsAsync;
   exports.isWorker = isWorker;
   exports.startRootIsolate = startRootIsolate;
   exports.IsolateNatives = IsolateNatives;
   exports.RawReceivePortImpl = RawReceivePortImpl;
   exports.ReceivePortImpl = ReceivePortImpl;
   exports.TimerImpl = TimerImpl;
   exports.hasTimer = hasTimer;
   exports.CapabilityImpl = CapabilityImpl;
 });