fix list literal initialization call fix typeof calls for primitive JS types add dart/collection.js…

lib/runtime/dart/_isolate_helper.js

 var _isolate_helper;
 (function(exports) {
   'use strict';
   // Function _serializeMessage: (dynamic) → dynamic
   function _serializeMessage(message) {
     return new _Serializer().serialize(message);
   }
   // Function _deserializeMessage: (dynamic) → dynamic
   function _deserializeMessage(message) {
     return new _Deserializer().deserialize(message);
@@ skipping 48 matching lines @@
       return this.serializeDartObject(x);
     }
     unsupported(x, message) {
       if (message === void 0)
         message = null;
       if (message === null)
         message = "Can't transmit:";
       throw new core.UnsupportedError(`${message} ${x}`);
     }
     makeRef(serializationId) {
-      return new List.from(["ref", serializationId]);
+      return new core.List.from(["ref", serializationId]);
     }
     isPrimitive(x) {
-      return dart.notNull(x === null) || dart.notNull(typeof x == string) || dart.notNull(dart.is(x, core.num)) || dart.notNull(typeof x == boolean);
+      return dart.notNull(x === null) || dart.notNull(typeof x == 'string') || dart.notNull(dart.is(x, core.num)) || dart.notNull(typeof x == 'boolean');
     }
     serializePrimitive(primitive) {
       return primitive;
     }
     serializeByteBuffer(buffer) {
-      return new List.from(["buffer", buffer]);
+      return new core.List.from(["buffer", buffer]);
     }
     serializeTypedData(data) {
-      return new List.from(["typed", data]);
+      return new core.List.from(["typed", data]);
     }
     serializeJSIndexable(indexable) {
-      dart.assert(!(typeof indexable == string));
+      dart.assert(!(typeof indexable == 'string'));
       let serialized = dart.as(this.serializeArray(dart.as(indexable, _interceptors.JSArray)), core.List);
       if (dart.is(indexable, _interceptors.JSFixedArray))
-        return new List.from(["fixed", serialized]);
+        return new core.List.from(["fixed", serialized]);
       if (dart.is(indexable, _interceptors.JSExtendableArray))
-        return new List.from(["extendable", serialized]);
+        return new core.List.from(["extendable", serialized]);
       if (dart.is(indexable, _interceptors.JSMutableArray))
-        return new List.from(["mutable", serialized]);
+        return new core.List.from(["mutable", serialized]);
       if (dart.is(indexable, _interceptors.JSArray))
-        return new List.from(["const", serialized]);
+        return new core.List.from(["const", serialized]);
       this.unsupported(indexable, "Can't serialize indexable: ");
       return null;
     }
     serializeArray(x) {
-      let serialized = new List.from([]);
+      let serialized = new core.List.from([]);
       serialized.length = x.length;
       for (let i = 0; dart.notNull(i) < dart.notNull(x.length); i = dart.notNull(i) + 1) {
         serialized.set(i, this.serialize(x.get(i)));
       }
       return serialized;
     }
     serializeArrayInPlace(x) {
       for (let i = 0; dart.notNull(i) < dart.notNull(x.length); i = dart.notNull(i) + 1) {
         x.set(i, this.serialize(x.get(i)));
       }
       return x;
     }
     serializeMap(x) {
       let serializeTearOff = this.serialize;
-      return new List.from(['map', x.keys.map(dart.as(serializeTearOff, dart.throw_("Unimplemented type (dynamic) → dynamic"))).toList(), x.values.map(dart.as(serializeTearOff, dart.throw_("Unimplemented type (dynamic) → dynamic"))).toList()]);
+      return new core.List.from(['map', x.keys.map(dart.as(serializeTearOff, dart.throw_("Unimplemented type (dynamic) → dynamic"))).toList(), x.values.map(dart.as(serializeTearOff, dart.throw_("Unimplemented type (dynamic) → dynamic"))).toList()]);
     }
     serializeJSObject(x) {
       if (!!x.constructor && x.constructor !== Object) {
         this.unsupported(x, "Only plain JS Objects are supported:");
       }
       let keys = dart.as(Object.keys(x), core.List);
-      let values = new List.from([]);
+      let values = new core.List.from([]);
       values.length = keys.length;
       for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); i = dart.notNull(i) + 1) {
         values.set(i, this.serialize(x[keys.get(i)]));
       }
-      return new List.from(['js-object', keys, values]);
+      return new core.List.from(['js-object', keys, values]);
     }
     serializeWorkerSendPort(x) {
       if (this[_serializeSendPorts]) {
-        return new List.from(['sendport', x[_workerId], x[_isolateId], x[_receivePortId]]);
+        return new core.List.from(['sendport', x[_workerId], x[_isolateId], x[_receivePortId]]);
       }
-      return new List.from(['raw sendport', x]);
+      return new core.List.from(['raw sendport', x]);
     }
     serializeJsSendPort(x) {
       if (this[_serializeSendPorts]) {
         let workerId = exports._globalState.currentManagerId;
-        return new List.from(['sendport', workerId, x[_isolateId], x[_receivePort][_id]]);
+        return new core.List.from(['sendport', workerId, x[_isolateId], x[_receivePort][_id]]);
       }
-      return new List.from(['raw sendport', x]);
+      return new core.List.from(['raw sendport', x]);
     }
     serializeCapability(x) {
-      return new List.from(['capability', x[_id]]);
+      return new core.List.from(['capability', x[_id]]);
     }
     serializeClosure(x) {
       let name = IsolateNatives._getJSFunctionName(x);
       if (name === null) {
         this.unsupported(x, "Closures can't be transmitted:");
       }
-      return new List.from(['function', name]);
+      return new core.List.from(['function', name]);
     }
     serializeDartObject(x) {
       let classExtractor = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.CLASS_ID_EXTRACTOR);
       let fieldsExtractor = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.CLASS_FIELDS_EXTRACTOR);
       let classId = classExtractor(x);
       let fields = dart.as(fieldsExtractor(x), core.List);
-      return new List.from(['dart', classId, this.serializeArrayInPlace(dart.as(fields, _interceptors.JSArray))]);
+      return new core.List.from(['dart', classId, this.serializeArrayInPlace(dart.as(fields, _interceptors.JSArray))]);
     }
   }
   let _adjustSendPorts = Symbol('_adjustSendPorts');
   class _Deserializer extends core.Object {
     _Deserializer(opts) {
       let adjustSendPorts = opts && 'adjustSendPorts' in opts ? opts.adjustSendPorts : true;
       this.deserializedObjects = new core.List();
       this[_adjustSendPorts] = dart.as(adjustSendPorts, core.bool);
     }
     deserialize(x) {
       if (this.isPrimitive(x))
         return this.deserializePrimitive(x);
       if (!dart.is(x, _interceptors.JSArray))
         throw new core.ArgumentError(`Bad serialized message: ${x}`);
       switch (dart.dload(x, 'first')) {
         case "ref":
+        {
           return this.deserializeRef(x);
+        }
         case "buffer":
+        {
           return this.deserializeByteBuffer(x);
+        }
         case "typed":
+        {
           return this.deserializeTypedData(x);
+        }
         case "fixed":
+        {
           return this.deserializeFixed(x);
+        }
         case "extendable":
+        {
           return this.deserializeExtendable(x);
+        }
         case "mutable":
+        {
           return this.deserializeMutable(x);
+        }
         case "const":
+        {
           return this.deserializeConst(x);
+        }
         case "map":
+        {
           return this.deserializeMap(x);
+        }
         case "sendport":
+        {
           return this.deserializeSendPort(x);
+        }
         case "raw sendport":
+        {
           return this.deserializeRawSendPort(x);
+        }
         case "js-object":
+        {
           return this.deserializeJSObject(x);
+        }
         case "function":
+        {
           return this.deserializeClosure(x);
+        }
         case "dart":
+        {
           return this.deserializeDartObject(x);
+        }
         default:
+        {
           throw `couldn't deserialize: ${x}`;
+        }
       }
     }
     isPrimitive(x) {
-      return dart.notNull(x === null) || dart.notNull(typeof x == string) || dart.notNull(dart.is(x, core.num)) || dart.notNull(typeof x == boolean);
+      return dart.notNull(x === null) || dart.notNull(typeof x == 'string') || dart.notNull(dart.is(x, core.num)) || dart.notNull(typeof x == 'boolean');
     }
     deserializePrimitive(x) {
       return x;
     }
     deserializeRef(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'ref'));
       let serializationId = dart.as(dart.dindex(x, 1), core.int);
       return this.deserializedObjects.get(serializationId);
     }
     deserializeByteBuffer(x) {
@@ skipping 127 matching lines @@
     return exports._globalState.isWorker;
   }
   // Function _currentIsolate: () → _IsolateContext
   function _currentIsolate() {
     return exports._globalState.currentContext;
   }
   // Function startRootIsolate: (dynamic, dynamic) → void
   function startRootIsolate(entry, args) {
     args = args;
     if (args === null)
-      args = new List.from([]);
+      args = new core.List.from([]);
     if (!dart.is(args, core.List)) {
       throw new core.ArgumentError(`Arguments to main must be a List: ${args}`);
     }
     exports._globalState = new _Manager(dart.as(entry, core.Function));
     if (exports._globalState.isWorker)
       return;
     let rootContext = new _IsolateContext();
     exports._globalState.rootContext = rootContext;
     exports._globalState.currentContext = rootContext;
     if (dart.is(entry, _MainFunctionArgs)) {
@@ skipping 88 matching lines @@
   let _addRegistration = Symbol('_addRegistration');
   class _IsolateContext extends core.Object {
     _IsolateContext() {
       this.id = ((x$) => exports._globalState.nextIsolateId = dart.notNull(x$) + 1, x$).bind(this)(exports._globalState.nextIsolateId);
       this.ports = new core.Map();
       this.weakPorts = new core.Set();
       this.isolateStatics = _foreign_helper.JS_CREATE_ISOLATE();
       this.controlPort = new RawReceivePortImpl._controlPort();
       this.pauseCapability = new isolate.Capability();
       this.terminateCapability = new isolate.Capability();
-      this.delayedEvents = dart.as(new List.from([]), core.List$(_IsolateEvent));
+      this.delayedEvents = dart.as(new core.List.from([]), core.List$(_IsolateEvent));
       this.pauseTokens = dart.as(new core.Set(), core.Set$(isolate.Capability));
       this.errorPorts = dart.as(new core.Set(), core.Set$(isolate.SendPort));
       this.initialized = false;
       this.isPaused = false;
       this.doneHandlers = null;
       this[_scheduledControlEvents] = null;
       this[_isExecutingEvent] = false;
       this.errorsAreFatal = true;
       this.registerWeak(this.controlPort[_id], this.controlPort);
     }
@@ skipping 13 matching lines @@
         while (this.delayedEvents.isNotEmpty) {
           let event = this.delayedEvents.removeLast();
           exports._globalState.topEventLoop.prequeue(event);
         }
         this.isPaused = false;
       }
       this[_updateGlobalState]();
     }
     addDoneListener(responsePort) {
       if (this.doneHandlers === null) {
-        this.doneHandlers = new List.from([]);
+        this.doneHandlers = new core.List.from([]);
       }
       if (dart.dinvoke(this.doneHandlers, 'contains', responsePort))
         return;
       dart.dinvoke(this.doneHandlers, 'add', responsePort);
     }
     removeDoneListener(responsePort) {
       if (this.doneHandlers === null)
         return;
       dart.dinvoke(this.doneHandlers, 'remove', responsePort);
     }
@@ skipping 94 matching lines @@
         }
       }
       return result;
     }
     [_setGlobals]() {
       _foreign_helper.JS_SET_CURRENT_ISOLATE(this.isolateStatics);
     }
     handleControlMessage(message) {
       switch (dart.dindex(message, 0)) {
         case "pause":
+        {
           this.addPause(dart.as(dart.dindex(message, 1), isolate.Capability), dart.as(dart.dindex(message, 2), isolate.Capability));
           break;
+        }
         case "resume":
+        {
           this.removePause(dart.as(dart.dindex(message, 1), isolate.Capability));
           break;
+        }
         case 'add-ondone':
+        {
           this.addDoneListener(dart.as(dart.dindex(message, 1), isolate.SendPort));
           break;
+        }
         case 'remove-ondone':
+        {
           this.removeDoneListener(dart.as(dart.dindex(message, 1), isolate.SendPort));
           break;
+        }
         case 'set-errors-fatal':
+        {
           this.setErrorsFatal(dart.as(dart.dindex(message, 1), isolate.Capability), dart.as(dart.dindex(message, 2), core.bool));
           break;
+        }
         case "ping":
+        {
           this.handlePing(dart.as(dart.dindex(message, 1), isolate.SendPort), dart.as(dart.dindex(message, 2), core.int));
           break;
+        }
         case "kill":
+        {
           this.handleKill(dart.as(dart.dindex(message, 1), isolate.Capability), dart.as(dart.dindex(message, 2), core.int));
           break;
+        }
         case "getErrors":
+        {
           this.addErrorListener(dart.as(dart.dindex(message, 1), isolate.SendPort));
           break;
+        }
         case "stopErrors":
+        {
           this.removeErrorListener(dart.as(dart.dindex(message, 1), isolate.SendPort));
           break;
+        }
         default:
       }
     }
     lookup(portId) {
       return this.ports.get(portId);
     }
     [_addRegistration](portId, port) {
       if (this.ports.containsKey(portId)) {
         throw new core.Exception("Registry: ports must be registered only once.");
       }
@@ skipping 189 matching lines @@
         return matches[1];
       throw new core.UnsupportedError(`Cannot extract URI from "${stack}"`);
     }
     static [_getEventData$](e) {
       return e.data;
     }
     static [_processWorkerMessage$](sender, e) {
       let msg = _deserializeMessage(_getEventData(e));
       switch (dart.dindex(msg, 'command')) {
         case 'start':
+        {
           exports._globalState.currentManagerId = dart.as(dart.dindex(msg, 'id'), core.int);
           let functionName = dart.as(dart.dindex(msg, 'functionName'), core.String);
           let entryPoint = dart.as(functionName === null ? exports._globalState.entry : _getJSFunctionFromName(functionName), core.Function);
           let args = dart.dindex(msg, 'args');
           let message = _deserializeMessage(dart.dindex(msg, 'msg'));
           let isSpawnUri = dart.dindex(msg, 'isSpawnUri');
           let startPaused = dart.dindex(msg, 'startPaused');
           let replyTo = _deserializeMessage(dart.dindex(msg, 'replyTo'));
           let context = new _IsolateContext();
           exports._globalState.topEventLoop.enqueue(context, () => {
             _startIsolate(entryPoint, dart.as(args, core.List$(core.String)), message, dart.as(isSpawnUri, core.bool), dart.as(startPaused, core.bool), dart.as(replyTo, isolate.SendPort));
           }, 'worker-start');
           exports._globalState.currentContext = context;
           exports._globalState.topEventLoop.run();
           break;
+        }
         case 'spawn-worker':
+        {
           if (enableSpawnWorker !== null)
             handleSpawnWorkerRequest(msg);
           break;
+        }
         case 'message':
+        {
           let port = dart.as(dart.dindex(msg, 'port'), isolate.SendPort);
           if (port !== null) {
             dart.dinvoke(dart.dindex(msg, 'port'), 'send', dart.dindex(msg, 'msg'));
           }
           exports._globalState.topEventLoop.run();
           break;
+        }
         case 'close':
+        {
           exports._globalState.managers.remove(workerIds.get(sender));
           sender.terminate();
           exports._globalState.topEventLoop.run();
           break;
+        }
         case 'log':
+        {
           _log(dart.dindex(msg, 'msg'));
           break;
+        }
         case 'print':
+        {
           if (exports._globalState.isWorker) {
             exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'print', msg: msg})));
           } else {
             core.print(dart.dindex(msg, 'msg'));
           }
           break;
+        }
         case 'error':
+        {
           throw dart.dindex(msg, 'msg');
+        }
       }
     }
     static handleSpawnWorkerRequest(msg) {
       let replyPort = dart.dindex(msg, 'replyPort');
       spawn(dart.as(dart.dindex(msg, 'functionName'), core.String), dart.as(dart.dindex(msg, 'uri'), core.String), dart.as(dart.dindex(msg, 'args'), core.List$(core.String)), dart.dindex(msg, 'msg'), false, dart.as(dart.dindex(msg, 'isSpawnUri'), core.bool), dart.as(dart.dindex(msg, 'startPaused'), core.bool)).then(dart.closureWrap((msg) => {
         dart.dinvoke(replyPort, 'send', msg);
       }, "(List<dynamic>) → dynamic"), {
         onError: (errorMessage) => {
-          dart.dinvoke(replyPort, 'send', new List.from([_SPAWN_FAILED_SIGNAL, errorMessage]));
+          dart.dinvoke(replyPort, 'send', new core.List.from([_SPAWN_FAILED_SIGNAL, errorMessage]));
         }
       });
     }
     static [_log$](msg) {
       if (exports._globalState.isWorker) {
         exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'log', msg: msg})));
       } else {
         try {
           _consoleLog(msg);
         } catch (e) {
@@ skipping 75 matching lines @@
         _startIsolate(dart.as(func, core.Function), args, message, isSpawnUri, startPaused, replyPort);
       }, 'nonworker start');
     }
     static get currentIsolate() {
       let context = dart.as(_foreign_helper.JS_CURRENT_ISOLATE_CONTEXT(), _IsolateContext);
       return new isolate.Isolate(context.controlPort.sendPort, {pauseCapability: context.pauseCapability, terminateCapability: context.terminateCapability});
     }
     static [_startIsolate$](topLevel, args, message, isSpawnUri, startPaused, replyTo) {
       let context = dart.as(_foreign_helper.JS_CURRENT_ISOLATE_CONTEXT(), _IsolateContext);
       _js_helper.Primitives.initializeStatics(context.id);
-      replyTo.send(new List.from([_SPAWNED_SIGNAL, context.controlPort.sendPort, context.pauseCapability, context.terminateCapability]));
+      replyTo.send(new core.List.from([_SPAWNED_SIGNAL, context.controlPort.sendPort, context.pauseCapability, context.terminateCapability]));
       // Function runStartFunction: () → void
       function runStartFunction() {
         context.initialized = true;
         if (!dart.notNull(isSpawnUri)) {
           dart.dinvokef(topLevel, message);
         } else if (dart.is(topLevel, _MainFunctionArgsMessage)) {
           dart.dinvokef(topLevel, args, message);
         } else if (dart.is(topLevel, _MainFunctionArgs)) {
           dart.dinvokef(topLevel, args);
         } else {
@@ skipping 300 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;
 })(_isolate_helper || (_isolate_helper = {}));