more care around generated names, fixes #60 #82 and #97

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);
   }
   // Function _clone: (dynamic) → dynamic
   function _clone(message) {
     let serializer = new _Serializer({serializeSendPorts: false});
     let deserializer = new _Deserializer();
     return deserializer.deserialize(serializer.serialize(message));
   }
   let _serializeSendPorts = Symbol('_serializeSendPorts');
   let _workerId = Symbol('_workerId');
   let _isolateId = Symbol('_isolateId');
   let _receivePortId = Symbol('_receivePortId');
   let _receivePort = Symbol('_receivePort');
   let _id = Symbol('_id');
   class _Serializer extends core.Object {
-    _Serializer(opt$) {
-      let serializeSendPorts = opt$ && 'serializeSendPorts' in opt$ ? opt$.serializeSendPorts : true;
+    _Serializer(opts) {
+      let serializeSendPorts = opts && 'serializeSendPorts' in opts ? opts.serializeSendPorts : true;
       this.serializedObjectIds = new core.Map.identity();
       this[_serializeSendPorts] = dart.as(serializeSendPorts, core.bool);
     }
     serialize(x) {
       if (this.isPrimitive(x))
         return this.serializePrimitive(x);
       let serializationId = this.serializedObjectIds.get(x);
       if (serializationId !== null)
         return this.makeRef(serializationId);
       serializationId = this.serializedObjectIds.length;
@@ skipping 113 matching lines @@
     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))]);
     }
   }
   let _adjustSendPorts = Symbol('_adjustSendPorts');
   class _Deserializer extends core.Object {
-    _Deserializer(opt$) {
-      let adjustSendPorts = opt$ && 'adjustSendPorts' in opt$ ? opt$.adjustSendPorts : true;
+    _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":
@@ skipping 141 matching lines @@
       let fields = dart.as(dart.dindex(x, 2), core.List);
       let instanceFromClassId = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.INSTANCE_FROM_CLASS_ID);
       let initializeObject = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.INITIALIZE_EMPTY_INSTANCE);
       let emptyInstance = instanceFromClassId(classId);
       this.deserializedObjects.add(emptyInstance);
       this.deserializeArrayInPlace(dart.as(fields, _interceptors.JSArray));
       return initializeObject(classId, emptyInstance, fields);
     }
   }
   // Function _callInIsolate: (_IsolateContext, Function) → dynamic
-  function _callInIsolate(isolate, function) {
-    let result = isolate.eval(function);
+  function _callInIsolate(isolate, function$0) {
+    let result = isolate.eval(function$0);
     exports._globalState.topEventLoop.run();
     return result;
   }
   let _activeJsAsyncCount = Symbol('_activeJsAsyncCount');
   // Function enterJsAsync: () → dynamic
   function enterJsAsync() {
     exports._globalState.topEventLoop[_activeJsAsyncCount] = dart.notNull(exports._globalState.topEventLoop[_activeJsAsyncCount]) + 1;
   }
   // Function leaveJsAsync: () → dynamic
   function leaveJsAsync() {
@@ skipping 38 matching lines @@
   dart.copyProperties(exports, {
     get _globalState() {
       return dart.as(init.globalState, _Manager);
     },
     set _globalState(val) {
       init.globalState = val;
     }
   });
   let _nativeDetectEnvironment = Symbol('_nativeDetectEnvironment');
   let _nativeInitWorkerMessageHandler = Symbol('_nativeInitWorkerMessageHandler');
-  let _processWorkerMessage = Symbol('_processWorkerMessage');
-  let _serializePrintMessage = Symbol('_serializePrintMessage');
+  let _processWorkerMessage$ = Symbol('_processWorkerMessage');
+  let _serializePrintMessage$ = Symbol('_serializePrintMessage');
   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 15 matching lines @@
       }
     }
     [_nativeDetectEnvironment]() {
       let isWindowDefined = exports.globalWindow !== null;
       let isWorkerDefined = exports.globalWorker !== null;
       this.isWorker = !dart.notNull(isWindowDefined) && dart.notNull(exports.globalPostMessageDefined);
       this.supportsWorkers = dart.notNull(this.isWorker) || dart.notNull(isWorkerDefined) && dart.notNull(IsolateNatives.thisScript !== null);
       this.fromCommandLine = !dart.notNull(isWindowDefined) && !dart.notNull(this.isWorker);
     }
     [_nativeInitWorkerMessageHandler]() {
-      let function = function(f, a) {
+      let function$0 = function(f, a) {
         return function(e) {
           f(a, e);
         };
-      }(_foreign_helper.DART_CLOSURE_TO_JS(IsolateNatives[_processWorkerMessage]), this.mainManager);
-      self.onmessage = function;
+      }(_foreign_helper.DART_CLOSURE_TO_JS(IsolateNatives[_processWorkerMessage$]), this.mainManager);
+      self.onmessage = function$0;
       self.dartPrint = self.dartPrint || function(serialize) {
         return function(object) {
           if (self.console && self.console.log) {
             self.console.log(object);
           } else {
             self.postMessage(serialize(object));
           }
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(_serializePrintMessage));
     }
-    static [_serializePrintMessage](object) {
+    static [_serializePrintMessage$](object) {
       return _serializeMessage(dart.map({command: "print", msg: object}));
     }
     maybeCloseWorker() {
       if (dart.notNull(this.isWorker) && dart.notNull(this.isolates.isEmpty) && this.topEventLoop[_activeJsAsyncCount] === 0) {
         this.mainManager.postMessage(_serializeMessage(dart.map({command: 'close'})));
       }
     }
   }
   let _scheduledControlEvents = Symbol('_scheduledControlEvents');
   let _isExecutingEvent = Symbol('_isExecutingEvent');
   let _updateGlobalState = Symbol('_updateGlobalState');
   let _setGlobals = Symbol('_setGlobals');
   let _addRegistration = Symbol('_addRegistration');
   class _IsolateContext extends core.Object {
     _IsolateContext() {
-      this.id = (($tmp) => exports._globalState.nextIsolateId = dart.notNull($tmp) + 1, $tmp).bind(this)(exports._globalState.nextIsolateId);
+      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.pauseTokens = dart.as(new core.Set(), core.Set$(isolate.Capability));
       this.errorPorts = dart.as(new core.Set(), core.Set$(isolate.SendPort));
       this.initialized = false;
@@ skipping 308 matching lines @@
     },
     get globalWorker() {
       _js_helper.requiresPreamble();
       return self.Worker;
     },
     get globalPostMessageDefined() {
       _js_helper.requiresPreamble();
       return !!self.postMessage;
     }
   });
-  let _getEventData = Symbol('_getEventData');
-  let _log = Symbol('_log');
-  let _consoleLog = Symbol('_consoleLog');
-  let _getJSFunctionFromName = Symbol('_getJSFunctionFromName');
-  let _getJSFunctionName = Symbol('_getJSFunctionName');
+  let _getEventData$ = Symbol('_getEventData');
+  let _log$ = Symbol('_log');
+  let _consoleLog$ = Symbol('_consoleLog');
+  let _getJSFunctionFromName$ = Symbol('_getJSFunctionFromName');
+  let _getJSFunctionName$ = Symbol('_getJSFunctionName');
   let _allocate = Symbol('_allocate');
-  let _startWorker = Symbol('_startWorker');
-  let _startNonWorker = Symbol('_startNonWorker');
-  let _startIsolate = Symbol('_startIsolate');
-  let _spawnWorker = Symbol('_spawnWorker');
+  let _startWorker$ = Symbol('_startWorker');
+  let _startNonWorker$ = Symbol('_startNonWorker');
+  let _startIsolate$ = Symbol('_startIsolate');
+  let _spawnWorker$ = Symbol('_spawnWorker');
   class IsolateNatives extends core.Object {
     static computeThisScript() {
       let currentScript = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.CURRENT_SCRIPT);
       if (currentScript !== null) {
         return String(currentScript.src);
       }
       if (_js_helper.Primitives.isD8)
         return computeThisScriptD8();
       if (_js_helper.Primitives.isJsshell)
         return computeThisScriptJsshell();
@@ skipping 25 matching lines @@
       pattern = new RegExp("^ *at [^(]*\\((.*):[0-9]*:[0-9]*\\)$", "m");
       matches = stack.match(pattern);
       if (matches !== null)
         return matches[1];
       pattern = new RegExp("^[^@]*@(.*):[0-9]*$", "m");
       matches = stack.match(pattern);
       if (matches !== null)
         return matches[1];
       throw new core.UnsupportedError(`Cannot extract URI from "${stack}"`);
     }
-    static [_getEventData](e) {
+    static [_getEventData$](e) {
       return e.data;
     }
-    static [_processWorkerMessage](sender, e) {
+    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');
@@ skipping 38 matching lines @@
     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]));
         }
       });
     }
-    static [_log](msg) {
+    static [_log$](msg) {
       if (exports._globalState.isWorker) {
         exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'log', msg: msg})));
       } else {
         try {
           _consoleLog(msg);
         } catch (e) {
           let trace = dart.stackTrace(e);
           throw new core.Exception(trace);
         }
 
       }
     }
-    static [_consoleLog](msg) {
+    static [_consoleLog$](msg) {
       _js_helper.requiresPreamble();
       self.console.log(msg);
     }
-    static [_getJSFunctionFromName](functionName) {
+    static [_getJSFunctionFromName$](functionName) {
       let globalFunctionsContainer = _foreign_helper.JS_EMBEDDED_GLOBAL("", _js_embedded_names.GLOBAL_FUNCTIONS);
       return globalFunctionsContainer[functionName]();
     }
-    static [_getJSFunctionName](f) {
+    static [_getJSFunctionName$](f) {
       return dart.as(dart.is(f, _js_helper.Closure) ? f.$name : null, core.String);
     }
     static [_allocate](ctor) {
       return new ctor();
     }
     static spawnFunction(topLevelFunction, message, startPaused) {
       IsolateNatives.enableSpawnWorker = true;
       let name = _getJSFunctionName(topLevelFunction);
       if (name === null) {
         throw new core.UnsupportedError("only top-level functions can be spawned.");
@@ skipping 22 matching lines @@
         }
       }).bind(this));
       let signalReply = port.sendPort;
       if (dart.notNull(exports._globalState.useWorkers) && !dart.notNull(isLight)) {
         _startWorker(functionName, uri, args, message, isSpawnUri, startPaused, signalReply, ((message) => completer.completeError(message)).bind(this));
       } else {
         _startNonWorker(functionName, uri, args, message, isSpawnUri, startPaused, signalReply);
       }
       return completer.future;
     }
-    static [_startWorker](functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError) {
+    static [_startWorker$](functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError) {
       if (args !== null)
         args = new core.List.from(args);
       if (exports._globalState.isWorker) {
         exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'spawn-worker', functionName: functionName, args: args, msg: message, uri: uri, isSpawnUri: isSpawnUri, startPaused: startPaused, replyPort: replyPort})));
       } else {
         _spawnWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError);
       }
     }
-    static [_startNonWorker](functionName, uri, args, message, isSpawnUri, startPaused, replyPort) {
+    static [_startNonWorker$](functionName, uri, args, message, isSpawnUri, startPaused, replyPort) {
       if (uri !== null) {
         throw new core.UnsupportedError("Currently spawnUri is not supported without web workers.");
       }
       message = _clone(message);
       if (args !== null)
         args = new core.List.from(args);
       exports._globalState.topEventLoop.enqueue(new _IsolateContext(), () => {
         let func = _getJSFunctionFromName(functionName);
         _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) {
+    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]));
       // 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 {
           dart.dinvokef(topLevel);
         }
       }
       if (startPaused) {
         context.addPause(context.pauseCapability, context.pauseCapability);
         exports._globalState.topEventLoop.enqueue(context, runStartFunction, 'start isolate');
       } else {
         runStartFunction();
       }
     }
-    static [_spawnWorker](functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError) {
+    static [_spawnWorker$](functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError) {
       if (uri === null)
         uri = thisScript;
       let worker = new Worker(uri);
       let onerrorTrampoline = function(f, u, c) {
         return function(e) {
           return f(e, u, c);
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(workerOnError), uri, onError);
       worker.onerror = onerrorTrampoline;
       let processWorkerMessageTrampoline = function(f, a) {
         return function(e) {
           e.onerror = null;
           return f(a, e);
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(_processWorkerMessage), worker);
       worker.onmessage = processWorkerMessageTrampoline;
-      let workerId = (($tmp) => exports._globalState.nextManagerId = dart.notNull($tmp) + 1, $tmp).bind(this)(exports._globalState.nextManagerId);
+      let workerId = ((x) => exports._globalState.nextManagerId = dart.notNull(x$) + 1, x$).bind(this)(exports._globalState.nextManagerId);
       workerIds.set(worker, workerId);
       exports._globalState.managers.set(workerId, worker);
       worker.postMessage(_serializeMessage(dart.map({command: 'start', id: workerId, replyTo: _serializeMessage(replyPort), args: args, msg: _serializeMessage(message), isSpawnUri: isSpawnUri, startPaused: startPaused, functionName: functionName})));
     }
     static workerOnError(event, uri, onError) {
       event.preventDefault();
       let message = dart.as(event.message, core.String);
       if (message === null) {
         message = `Error spawning worker for ${uri}`;
       } else {
         message = `Error spawning worker for ${uri} (${message})`;
       }
       onError(message);
       return true;
     }
   }
   IsolateNatives.enableSpawnWorker = null;
   dart.defineLazyProperties(IsolateNatives, {
     get thisScript() {
       return computeThisScript();
     },
     set thisScript(_) {},
     get workerIds() {
       return new core.Expando();
     }
   });
   let _checkReplyTo = Symbol('_checkReplyTo');
   class _BaseSendPort extends core.Object {
-    _BaseSendPort($_isolateId) {
-      this[_isolateId] = $_isolateId;
+    _BaseSendPort(isolateId$) {
+      this[_isolateId] = isolateId$;
     }
     [_checkReplyTo](replyTo) {
       if (dart.notNull(replyTo !== null) && dart.notNull(!dart.is(replyTo, _NativeJsSendPort)) && dart.notNull(!dart.is(replyTo, _WorkerSendPort))) {
         throw new core.Exception("SendPort.send: Illegal replyTo port type");
       }
     }
   }
   let _isClosed = Symbol('_isClosed');
   class _NativeJsSendPort extends _BaseSendPort {
-    _NativeJsSendPort($_receivePort, isolateId) {
-      this[_receivePort] = $_receivePort;
+    _NativeJsSendPort(receivePort$, isolateId) {
+      this[_receivePort] = receivePort$;
       super._BaseSendPort(isolateId);
     }
     send(message) {
       let isolate = exports._globalState.isolates.get(this[_isolateId]);
       if (isolate === null)
         return;
       if (this[_receivePort][_isClosed])
         return;
       let msg = _clone(message);
       if (dart.equals(isolate.controlPort, this[_receivePort])) {
         isolate.handleControlMessage(msg);
         return;
       }
       exports._globalState.topEventLoop.enqueue(isolate, (() => {
         if (!dart.notNull(this[_receivePort][_isClosed])) {
           this[_receivePort]._add(msg);
         }
       }).bind(this), `receive ${message}`);
     }
     ['=='](other) {
       return dart.notNull(dart.is(other, _NativeJsSendPort)) && dart.notNull(dart.equals(this[_receivePort], dart.dload(other, '_receivePort')));
     }
     get hashCode() {
       return this[_receivePort][_id];
     }
   }
   class _WorkerSendPort extends _BaseSendPort {
-    _WorkerSendPort($_workerId, isolateId, $_receivePortId) {
-      this[_workerId] = $_workerId;
-      this[_receivePortId] = $_receivePortId;
+    _WorkerSendPort(workerId$, isolateId, receivePortId$) {
+      this[_workerId] = workerId$;
+      this[_receivePortId] = receivePortId$;
       super._BaseSendPort(isolateId);
     }
     send(message) {
       let workerMessage = _serializeMessage(dart.map({command: 'message', port: this, msg: message}));
       if (exports._globalState.isWorker) {
         exports._globalState.mainManager.postMessage(workerMessage);
       } else {
         let manager = exports._globalState.managers.get(this[_workerId]);
         if (manager !== null) {
           manager.postMessage(workerMessage);
         }
       }
     }
     ['=='](other) {
       return dart.notNull(dart.is(other, _WorkerSendPort)) && this[_workerId] === dart.dload(other, '_workerId') && this[_isolateId] === dart.dload(other, '_isolateId') && this[_receivePortId] === dart.dload(other, '_receivePortId');
     }
     get hashCode() {
       return dart.notNull(this[_workerId]) << 16 ^ dart.notNull(this[_isolateId]) << 8 ^ dart.notNull(this[_receivePortId]);
     }
   }
   let _handler = Symbol('_handler');
   let _close = Symbol('_close');
   let _add = Symbol('_add');
   class RawReceivePortImpl extends core.Object {
-    RawReceivePortImpl($_handler) {
-      this[_handler] = $_handler;
-      this[_id] = (($tmp) => _nextFreeId = dart.notNull($tmp) + 1, $tmp)(_nextFreeId);
+    RawReceivePortImpl(handler) {
+      this[_handler] = handler;
+      this[_id] = ((x) => _nextFreeId = dart.notNull(x$) + 1, x$)(_nextFreeId);
       this[_isClosed] = false;
       exports._globalState.currentContext.register(this[_id], this);
     }
-    RawReceivePortImpl$weak($_handler) {
-      this[_handler] = $_handler;
-      this[_id] = (($tmp) => _nextFreeId = dart.notNull($tmp) + 1, $tmp)(_nextFreeId);
+    RawReceivePortImpl$weak(handler) {
+      this[_handler] = handler;
+      this[_id] = ((x) => _nextFreeId = dart.notNull(x$) + 1, x$)(_nextFreeId);
       this[_isClosed] = false;
       exports._globalState.currentContext.registerWeak(this[_id], this);
     }
     RawReceivePortImpl$_controlPort() {
       this[_handler] = null;
       this[_id] = 0;
       this[_isClosed] = false;
     }
     set handler(newHandler) {
       this[_handler] = newHandler;
@@ skipping 23 matching lines @@
   RawReceivePortImpl._nextFreeId = 1;
   let _rawPort = Symbol('_rawPort');
   let _controller = Symbol('_controller');
   class ReceivePortImpl extends async.Stream {
     ReceivePortImpl() {
       this.ReceivePortImpl$fromRawReceivePort(new RawReceivePortImpl(null));
     }
     ReceivePortImpl$weak() {
       this.ReceivePortImpl$fromRawReceivePort(new RawReceivePortImpl.weak(null));
     }
-    ReceivePortImpl$fromRawReceivePort($_rawPort) {
-      this[_rawPort] = $_rawPort;
+    ReceivePortImpl$fromRawReceivePort(rawPort) {
+      this[_rawPort] = rawPort;
       this[_controller] = null;
       super.Stream();
       this[_controller] = new async.StreamController({onCancel: this.close, sync: true});
       this[_rawPort].handler = this[_controller].add;
     }
-    listen(onData, opt$) {
-      let onError = opt$ && 'onError' in opt$ ? opt$.onError : null;
-      let onDone = opt$ && 'onDone' in opt$ ? opt$.onDone : null;
-      let cancelOnError = opt$ && 'cancelOnError' in opt$ ? opt$.cancelOnError : null;
+    listen(onData, opts) {
+      let onError = opts && 'onError' in opts ? opts.onError : null;
+      let onDone = opts && 'onDone' in opts ? opts.onDone : null;
+      let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
       return this[_controller].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
     }
     close() {
       this[_rawPort].close();
       this[_controller].close();
     }
     get sendPort() {
       return this[_rawPort].sendPort;
     }
   }
@@ skipping 68 matching lines @@
   dart.defineNamedConstructor(TimerImpl, 'periodic');
   // Function hasTimer: () → bool
   function hasTimer() {
     _js_helper.requiresPreamble();
     return self.setTimeout !== null;
   }
   class CapabilityImpl extends core.Object {
     CapabilityImpl() {
       this.CapabilityImpl$_internal(_js_helper.random64());
     }
-    CapabilityImpl$_internal($_id) {
-      this[_id] = $_id;
+    CapabilityImpl$_internal(id) {
+      this[_id] = id;
     }
     get hashCode() {
       let hash = this[_id];
       hash = dart.notNull(hash) >> 0 ^ (dart.notNull(hash) / 4294967296).truncate();
       hash = ~dart.notNull(hash) + (dart.notNull(hash) << 15) & 4294967295;
       hash = dart.notNull(hash) >> 12;
       hash = dart.notNull(hash) * 5 & 4294967295;
       hash = dart.notNull(hash) >> 4;
       hash = dart.notNull(hash) * 2057 & 4294967295;
       hash = dart.notNull(hash) >> 16;
@@ skipping 14 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 = {}));