implement private members, fixes #74

test/codegen/expect/_isolate_helper/_isolate_helper.js

 var _isolate_helper;
 (function(_isolate_helper) {
   'use strict';
+  let _activeJsAsyncCount = Symbol('_activeJsAsyncCount');
+  let _nativeDetectEnvironment = Symbol('_nativeDetectEnvironment');
+  let _nativeInitWorkerMessageHandler = Symbol('_nativeInitWorkerMessageHandler');
+  let _processWorkerMessage = Symbol('_processWorkerMessage');
+  let _serializePrintMessage = Symbol('_serializePrintMessage');
+  let _scheduledControlEvents = Symbol('_scheduledControlEvents');
+  let _isExecutingEvent = Symbol('_isExecutingEvent');
+  let _id = Symbol('_id');
+  let _updateGlobalState = Symbol('_updateGlobalState');
+  let _setGlobals = Symbol('_setGlobals');
+  let _addRegistration = Symbol('_addRegistration');
+  let _runHelper = Symbol('_runHelper');
+  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 _isolateId = Symbol('_isolateId');
+  let _checkReplyTo = Symbol('_checkReplyTo');
+  let _receivePort = Symbol('_receivePort');
+  let _isClosed = Symbol('_isClosed');
+  let _workerId = Symbol('_workerId');
+  let _receivePortId = Symbol('_receivePortId');
+  let _handler = Symbol('_handler');
+  let _close = Symbol('_close');
+  let _add = Symbol('_add');
+  let _rawPort = Symbol('_rawPort');
+  let _controller = Symbol('_controller');
+  let _once = Symbol('_once');
+  let _inEventLoop = Symbol('_inEventLoop');
+  let _handle = Symbol('_handle');
+  let _serializeSendPorts = Symbol('_serializeSendPorts');
+  let _adjustSendPorts = Symbol('_adjustSendPorts');
   // Function _callInIsolate: (_IsolateContext, Function) → dynamic
   function _callInIsolate(isolate, function) {
     let result = isolate.eval(function);
     _isolate_helper._globalState.topEventLoop.run();
     return result;
   }
   // Function enterJsAsync: () → dynamic
   function enterJsAsync() {
-    _isolate_helper._globalState.topEventLoop._activeJsAsyncCount++;
+    _isolate_helper._globalState.topEventLoop[_activeJsAsyncCount]++;
   }
   // Function leaveJsAsync: () → dynamic
   function leaveJsAsync() {
-    _isolate_helper._globalState.topEventLoop._activeJsAsyncCount--;
-    dart.assert(_isolate_helper._globalState.topEventLoop._activeJsAsyncCount >= 0);
+    _isolate_helper._globalState.topEventLoop[_activeJsAsyncCount]--;
+    dart.assert(_isolate_helper._globalState.topEventLoop[_activeJsAsyncCount] >= 0);
   }
   // Function isWorker: () → bool
   function isWorker() {
     return _isolate_helper._globalState.isWorker;
   }
   // Function _currentIsolate: () → _IsolateContext
   function _currentIsolate() {
     return _isolate_helper._globalState.currentContext;
   }
   // Function startRootIsolate: (dynamic, dynamic) → void
@@ skipping 42 matching lines @@
       this.nextManagerId = 1;
       this.currentContext = null;
       this.rootContext = null;
       this.topEventLoop = null;
       this.fromCommandLine = null;
       this.isWorker = null;
       this.supportsWorkers = null;
       this.isolates = null;
       this.mainManager = null;
       this.managers = null;
-      this._nativeDetectEnvironment();
+      this[_nativeDetectEnvironment]();
       this.topEventLoop = new _EventLoop();
       this.isolates = new core.Map();
       this.managers = new core.Map();
       if (this.isWorker) {
         this.mainManager = new _MainManagerStub();
-        this._nativeInitWorkerMessageHandler();
+        this[_nativeInitWorkerMessageHandler]();
       }
     }
-    _nativeDetectEnvironment() {
+    [_nativeDetectEnvironment]() {
       let isWindowDefined = _isolate_helper.globalWindow !== null;
       let isWorkerDefined = _isolate_helper.globalWorker !== null;
       this.isWorker = dart.notNull(!dart.notNull(isWindowDefined)) && dart.notNull(_isolate_helper.globalPostMessageDefined);
       this.supportsWorkers = dart.notNull(this.isWorker) || dart.notNull(dart.notNull(isWorkerDefined) && dart.notNull(IsolateNatives.thisScript !== null));
       this.fromCommandLine = dart.notNull(!dart.notNull(isWindowDefined)) && dart.notNull(!dart.notNull(this.isWorker));
     }
-    _nativeInitWorkerMessageHandler() {
+    [_nativeInitWorkerMessageHandler]() {
       let function = function(f, a) {
         return function(e) {
           f(a, e);
         };
-      }(_foreign_helper.DART_CLOSURE_TO_JS(IsolateNatives._processWorkerMessage), this.mainManager);
+      }(_foreign_helper.DART_CLOSURE_TO_JS(IsolateNatives[_processWorkerMessage]), this.mainManager);
       self.onmessage = function;
       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(dart.notNull(this.isWorker) && dart.notNull(this.isolates.isEmpty)) && dart.notNull(this.topEventLoop._activeJsAsyncCount === 0)) {
+      if (dart.notNull(dart.notNull(this.isWorker) && dart.notNull(this.isolates.isEmpty)) && dart.notNull(this.topEventLoop[_activeJsAsyncCount] === 0)) {
         this.mainManager.postMessage(_serializeMessage(dart.map({command: 'close'})));
       }
     }
   }
   class _IsolateContext extends dart.Object {
     _IsolateContext() {
       this.id = _isolate_helper._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;
       this.isPaused = false;
       this.doneHandlers = null;
-      this._scheduledControlEvents = null;
-      this._isExecutingEvent = false;
+      this[_scheduledControlEvents] = null;
+      this[_isExecutingEvent] = false;
       this.errorsAreFatal = true;
-      this.registerWeak(this.controlPort._id, this.controlPort);
+      this.registerWeak(this.controlPort[_id], this.controlPort);
     }
     addPause(authentification, resume) {
       if (!dart.equals(this.pauseCapability, authentification))
         return;
       if (dart.notNull(this.pauseTokens.add(resume)) && dart.notNull(!dart.notNull(this.isPaused))) {
         this.isPaused = true;
       }
-      this._updateGlobalState();
+      this[_updateGlobalState]();
     }
     removePause(resume) {
       if (!dart.notNull(this.isPaused))
         return;
       this.pauseTokens.remove(resume);
       if (this.pauseTokens.isEmpty) {
         while (this.delayedEvents.isNotEmpty) {
           let event = this.delayedEvents.removeLast();
           _isolate_helper._globalState.topEventLoop.prequeue(event);
         }
         this.isPaused = false;
       }
-      this._updateGlobalState();
+      this[_updateGlobalState]();
     }
     addDoneListener(responsePort) {
       if (this.doneHandlers === null) {
         this.doneHandlers = new 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);
     }
     setErrorsFatal(authentification, errorsAreFatal) {
       if (!dart.equals(this.terminateCapability, authentification))
         return;
       this.errorsAreFatal = errorsAreFatal;
     }
     handlePing(responsePort, pingType) {
-      if (dart.notNull(pingType === isolate.Isolate.IMMEDIATE) || dart.notNull(dart.notNull(pingType === isolate.Isolate.BEFORE_NEXT_EVENT) && dart.notNull(!dart.notNull(this._isExecutingEvent)))) {
+      if (dart.notNull(pingType === isolate.Isolate.IMMEDIATE) || dart.notNull(dart.notNull(pingType === isolate.Isolate.BEFORE_NEXT_EVENT) && dart.notNull(!dart.notNull(this[_isExecutingEvent])))) {
         responsePort.send(null);
         return;
       }
       // Function respond: () → void
       function respond() {
         responsePort.send(null);
       }
       if (pingType === isolate.Isolate.AS_EVENT) {
         _isolate_helper._globalState.topEventLoop.enqueue(this, respond, "ping");
         return;
       }
       dart.assert(pingType === isolate.Isolate.BEFORE_NEXT_EVENT);
-      if (this._scheduledControlEvents === null) {
-        this._scheduledControlEvents = new collection.Queue();
+      if (this[_scheduledControlEvents] === null) {
+        this[_scheduledControlEvents] = new collection.Queue();
       }
-      dart.dinvoke(this._scheduledControlEvents, 'addLast', respond);
+      dart.dinvoke(this[_scheduledControlEvents], 'addLast', respond);
     }
     handleKill(authentification, priority) {
       if (!dart.equals(this.terminateCapability, authentification))
         return;
-      if (dart.notNull(priority === isolate.Isolate.IMMEDIATE) || dart.notNull(dart.notNull(priority === isolate.Isolate.BEFORE_NEXT_EVENT) && dart.notNull(!dart.notNull(this._isExecutingEvent)))) {
+      if (dart.notNull(priority === isolate.Isolate.IMMEDIATE) || dart.notNull(dart.notNull(priority === isolate.Isolate.BEFORE_NEXT_EVENT) && dart.notNull(!dart.notNull(this[_isExecutingEvent])))) {
         this.kill();
         return;
       }
       if (priority === isolate.Isolate.AS_EVENT) {
         _isolate_helper._globalState.topEventLoop.enqueue(this, this.kill, "kill");
         return;
       }
       dart.assert(priority === isolate.Isolate.BEFORE_NEXT_EVENT);
-      if (this._scheduledControlEvents === null) {
-        this._scheduledControlEvents = new collection.Queue();
+      if (this[_scheduledControlEvents] === null) {
+        this[_scheduledControlEvents] = new collection.Queue();
       }
-      dart.dinvoke(this._scheduledControlEvents, 'addLast', this.kill);
+      dart.dinvoke(this[_scheduledControlEvents], 'addLast', this.kill);
     }
     addErrorListener(port) {
       this.errorPorts.add(port);
     }
     removeErrorListener(port) {
       this.errorPorts.remove(port);
     }
     handleUncaughtError(error, stackTrace) {
       if (this.errorPorts.isEmpty) {
         if (dart.notNull(this.errorsAreFatal) && dart.notNull(core.identical(this, _isolate_helper._globalState.rootContext))) {
@@ skipping 12 matching lines @@
       message.set(0, dart.dinvoke(error, 'toString'));
       message.set(1, stackTrace === null ? null : stackTrace.toString());
       for (let port of this.errorPorts)
         port.send(message);
     }
     eval(code) {
       let old = _isolate_helper._globalState.currentContext;
       _isolate_helper._globalState.currentContext = this;
       this._setGlobals();
       let result = null;
-      this._isExecutingEvent = true;
+      this[_isExecutingEvent] = true;
       try {
         result = dart.dinvokef(code);
       } catch (e) {
         let s = dart.stackTrace(e);
         this.handleUncaughtError(e, s);
         if (this.errorsAreFatal) {
           this.kill();
           if (core.identical(this, _isolate_helper._globalState.rootContext)) {
             dart.throw_("Unimplemented RethrowExpression: rethrow");
           }
         }
       }
  finally {
-        this._isExecutingEvent = false;
+        this[_isExecutingEvent] = false;
         _isolate_helper._globalState.currentContext = old;
         if (old !== null)
           old._setGlobals();
-        if (this._scheduledControlEvents !== null) {
-          while (dart.dload(this._scheduledControlEvents, 'isNotEmpty')) {
-            dart.dinvokef(dart.dinvoke(this._scheduledControlEvents, 'removeFirst'));
+        if (this[_scheduledControlEvents] !== null) {
+          while (dart.dload(this[_scheduledControlEvents], 'isNotEmpty')) {
+            dart.dinvokef(dart.dinvoke(this[_scheduledControlEvents], 'removeFirst'));
           }
         }
       }
       return result;
     }
-    _setGlobals() {
+    [_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;
@@ skipping 17 matching lines @@
           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) {
+    [_addRegistration](portId, port) {
       if (this.ports.containsKey(portId)) {
         throw new core.Exception("Registry: ports must be registered only once.");
       }
       this.ports.set(portId, port);
     }
     register(portId, port) {
-      this._addRegistration(portId, port);
-      this._updateGlobalState();
+      this[_addRegistration](portId, port);
+      this[_updateGlobalState]();
     }
     registerWeak(portId, port) {
       this.weakPorts.add(portId);
-      this._addRegistration(portId, port);
+      this[_addRegistration](portId, port);
     }
-    _updateGlobalState() {
+    [_updateGlobalState]() {
       if (dart.notNull(dart.notNull(this.ports.length - this.weakPorts.length > 0) || dart.notNull(this.isPaused)) || dart.notNull(!dart.notNull(this.initialized))) {
         _isolate_helper._globalState.isolates.set(this.id, this);
       } else {
         this.kill();
       }
     }
     kill() {
-      if (this._scheduledControlEvents !== null) {
-        dart.dinvoke(this._scheduledControlEvents, 'clear');
+      if (this[_scheduledControlEvents] !== null) {
+        dart.dinvoke(this[_scheduledControlEvents], 'clear');
       }
       for (let port of this.ports.values) {
         dart.dinvoke(port, '_close');
       }
       this.ports.clear();
       this.weakPorts.clear();
       _isolate_helper._globalState.isolates.remove(this.id);
       this.errorPorts.clear();
       if (this.doneHandlers !== null) {
         for (let port of this.doneHandlers) {
           port.send(null);
         }
         this.doneHandlers = null;
       }
     }
     unregister(portId) {
       this.ports.remove(portId);
       this.weakPorts.remove(portId);
-      this._updateGlobalState();
+      this[_updateGlobalState]();
     }
   }
   class _EventLoop extends dart.Object {
     _EventLoop() {
       this.events = new collection.Queue();
-      this._activeJsAsyncCount = 0;
+      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);
     }
     dequeue() {
       if (this.events.isEmpty)
         return null;
       return this.events.removeFirst();
     }
     checkOpenReceivePortsFromCommandLine() {
       if (dart.notNull(dart.notNull(dart.notNull(_isolate_helper._globalState.rootContext !== null) && dart.notNull(_isolate_helper._globalState.isolates.containsKey(_isolate_helper._globalState.rootContext.id))) && dart.notNull(_isolate_helper._globalState.fromCommandLine)) && dart.notNull(_isolate_helper._globalState.rootContext.ports.isEmpty)) {
         throw new core.Exception("Program exited with open ReceivePorts.");
       }
     }
     runIteration() {
       let event = this.dequeue();
       if (event === null) {
         this.checkOpenReceivePortsFromCommandLine();
         _isolate_helper._globalState.maybeCloseWorker();
         return false;
       }
       event.process();
       return true;
     }
-    _runHelper() {
+    [_runHelper]() {
       if (_isolate_helper.globalWindow !== null) {
         // Function next: () → void
         function next() {
           if (!dart.notNull(this.runIteration()))
             return;
           async.Timer.run(next);
         }
         next();
       } else {
         while (this.runIteration()) {
         }
       }
     }
     run() {
       if (!dart.notNull(_isolate_helper._globalState.isWorker)) {
-        this._runHelper();
+        this[_runHelper]();
       } else {
         try {
-          this._runHelper();
+          this[_runHelper]();
         } catch (e) {
           let trace = dart.stackTrace(e);
           _isolate_helper._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'error', msg: `${e}\n${trace}`})));
         }
 
       }
     }
   }
   class _IsolateEvent extends dart.Object {
     _IsolateEvent(isolate, fn, message) {
@@ skipping 69 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':
           _isolate_helper._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 ? _isolate_helper._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((msg) => {
         dart.dinvoke(replyPort, 'send', msg);
       }, {
         onError: (errorMessage) => {
           dart.dinvoke(replyPort, 'send', new List.from([_SPAWN_FAILED_SIGNAL, errorMessage]));
         }
       });
     }
-    static _log(msg) {
+    static [_log](msg) {
       if (_isolate_helper._globalState.isWorker) {
         _isolate_helper._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("", dart.as(_js_embedded_names.GLOBAL_FUNCTIONS, core.String));
       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) {
+    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.");
       }
       let isLight = false;
       let isSpawnUri = false;
@@ skipping 19 matching lines @@
         }
       }).bind(this));
       let signalReply = port.sendPort;
       if (dart.notNull(_isolate_helper._globalState.useWorkers) && dart.notNull(!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 (_isolate_helper._globalState.isWorker) {
         _isolate_helper._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);
       _isolate_helper._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);
         _isolate_helper._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) {
@@ skipping 24 matching lines @@
   dart.defineLazyProperties(IsolateNatives, {
     get thisScript() {
       return computeThisScript();
     },
     set thisScript() {},
     get workerIds() {
       return new core.Expando();
     }
   });
   class _BaseSendPort extends dart.Object {
-    _BaseSendPort(_isolateId) {
-      this._isolateId = _isolateId;
+    _BaseSendPort($_isolateId) {
+      this[_isolateId] = $_isolateId;
     }
-    _checkReplyTo(replyTo) {
+    [_checkReplyTo](replyTo) {
       if (dart.notNull(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");
       }
     }
   }
   class _NativeJsSendPort extends _BaseSendPort {
-    _NativeJsSendPort(_receivePort, isolateId) {
-      this._receivePort = _receivePort;
+    _NativeJsSendPort($_receivePort, isolateId) {
+      this[_receivePort] = $_receivePort;
       super._BaseSendPort(isolateId);
     }
     send(message) {
-      let isolate = _isolate_helper._globalState.isolates.get(this._isolateId);
+      let isolate = _isolate_helper._globalState.isolates.get(this[_isolateId]);
       if (isolate === null)
         return;
-      if (this._receivePort._isClosed)
+      if (this[_receivePort][_isClosed])
         return;
       let msg = _clone(message);
-      if (dart.equals(isolate.controlPort, this._receivePort)) {
+      if (dart.equals(isolate.controlPort, this[_receivePort])) {
         isolate.handleControlMessage(msg);
         return;
       }
       _isolate_helper._globalState.topEventLoop.enqueue(isolate, (() => {
-        if (!dart.notNull(this._receivePort._isClosed)) {
-          this._receivePort._add(msg);
+        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')));
+      return dart.notNull(dart.is(other, _NativeJsSendPort)) && dart.notNull(dart.equals(this[_receivePort], dart.dload(other, '_receivePort')));
     }
     get hashCode() {
-      return this._receivePort._id;
+      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 (_isolate_helper._globalState.isWorker) {
         _isolate_helper._globalState.mainManager.postMessage(workerMessage);
       } else {
-        let manager = _isolate_helper._globalState.managers.get(this._workerId);
+        let manager = _isolate_helper._globalState.managers.get(this[_workerId]);
         if (manager !== null) {
           manager.postMessage(workerMessage);
         }
       }
     }
     ['=='](other) {
-      return dart.notNull(dart.notNull(dart.notNull(dart.is(other, _WorkerSendPort)) && dart.notNull(this._workerId === dart.dload(other, '_workerId'))) && dart.notNull(this._isolateId === dart.dload(other, '_isolateId'))) && dart.notNull(this._receivePortId === dart.dload(other, '_receivePortId'));
+      return dart.notNull(dart.notNull(dart.notNull(dart.is(other, _WorkerSendPort)) && dart.notNull(this[_workerId] === dart.dload(other, '_workerId'))) && dart.notNull(this[_isolateId] === dart.dload(other, '_isolateId'))) && dart.notNull(this[_receivePortId] === dart.dload(other, '_receivePortId'));
     }
     get hashCode() {
-      return this._workerId << 16 ^ this._isolateId << 8 ^ this._receivePortId;
+      return this[_workerId] << 16 ^ this[_isolateId] << 8 ^ this[_receivePortId];
     }
   }
   class RawReceivePortImpl extends dart.Object {
-    RawReceivePortImpl(_handler) {
-      this._handler = _handler;
-      this._id = _nextFreeId++;
-      this._isClosed = false;
-      _isolate_helper._globalState.currentContext.register(this._id, this);
+    RawReceivePortImpl($_handler) {
+      this[_handler] = $_handler;
+      this[_id] = _nextFreeId++;
+      this[_isClosed] = false;
+      _isolate_helper._globalState.currentContext.register(this[_id], this);
     }
-    RawReceivePortImpl$weak(_handler) {
-      this._handler = _handler;
-      this._id = _nextFreeId++;
-      this._isClosed = false;
-      _isolate_helper._globalState.currentContext.registerWeak(this._id, this);
+    RawReceivePortImpl$weak($_handler) {
+      this[_handler] = $_handler;
+      this[_id] = _nextFreeId++;
+      this[_isClosed] = false;
+      _isolate_helper._globalState.currentContext.registerWeak(this[_id], this);
     }
     RawReceivePortImpl$_controlPort() {
-      this._handler = null;
-      this._id = 0;
-      this._isClosed = false;
+      this[_handler] = null;
+      this[_id] = 0;
+      this[_isClosed] = false;
     }
     set handler(newHandler) {
-      this._handler = newHandler;
+      this[_handler] = newHandler;
     }
-    _close() {
-      this._isClosed = true;
-      this._handler = null;
+    [_close]() {
+      this[_isClosed] = true;
+      this[_handler] = null;
     }
     close() {
-      if (this._isClosed)
+      if (this[_isClosed])
         return;
-      this._isClosed = true;
-      this._handler = null;
-      _isolate_helper._globalState.currentContext.unregister(this._id);
+      this[_isClosed] = true;
+      this[_handler] = null;
+      _isolate_helper._globalState.currentContext.unregister(this[_id]);
     }
-    _add(dataEvent) {
-      if (this._isClosed)
+    [_add](dataEvent) {
+      if (this[_isClosed])
         return;
-      dart.dinvokef(this._handler, dataEvent);
+      dart.dinvokef(this[_handler], dataEvent);
     }
     get sendPort() {
       return new _NativeJsSendPort(this, _isolate_helper._globalState.currentContext.id);
     }
   }
   dart.defineNamedConstructor(RawReceivePortImpl, 'weak');
   dart.defineNamedConstructor(RawReceivePortImpl, '_controlPort');
   RawReceivePortImpl._nextFreeId = 1;
   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;
-      this._controller = null;
+    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;
+      this[_controller] = new async.StreamController({onCancel: this.close, sync: true});
+      this[_rawPort].handler = this[_controller].add;
     }
     listen(onData, opt$) {
       let onError = opt$.onError === void 0 ? null : opt$.onError;
       let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
       let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
-      return this._controller.stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
+      return this[_controller].stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
     }
     close() {
-      this._rawPort.close();
-      this._controller.close();
+      this[_rawPort].close();
+      this[_controller].close();
     }
     get sendPort() {
-      return this._rawPort.sendPort;
+      return this[_rawPort].sendPort;
     }
   }
   dart.defineNamedConstructor(ReceivePortImpl, 'weak');
   dart.defineNamedConstructor(ReceivePortImpl, 'fromRawReceivePort');
   class TimerImpl extends dart.Object {
     TimerImpl(milliseconds, callback) {
-      this._once = true;
-      this._inEventLoop = false;
-      this._handle = dart.as(null, core.int);
+      this[_once] = true;
+      this[_inEventLoop] = false;
+      this[_handle] = dart.as(null, core.int);
       if (dart.notNull(milliseconds === 0) && dart.notNull(dart.notNull(!dart.notNull(hasTimer())) || dart.notNull(_isolate_helper._globalState.isWorker))) {
         // Function internalCallback: () → void
         function internalCallback() {
-          this._handle = dart.as(null, core.int);
+          this[_handle] = dart.as(null, core.int);
           callback();
         }
-        this._handle = 1;
+        this[_handle] = 1;
         _isolate_helper._globalState.topEventLoop.enqueue(_isolate_helper._globalState.currentContext, internalCallback, 'timer');
-        this._inEventLoop = true;
+        this[_inEventLoop] = true;
       } else if (hasTimer()) {
         // Function internalCallback: () → void
         function internalCallback() {
-          this._handle = dart.as(null, core.int);
+          this[_handle] = dart.as(null, core.int);
           leaveJsAsync();
           callback();
         }
         enterJsAsync();
-        this._handle = self.setTimeout(_js_helper.convertDartClosureToJS(internalCallback, 0), milliseconds);
+        this[_handle] = self.setTimeout(_js_helper.convertDartClosureToJS(internalCallback, 0), milliseconds);
       } else {
         dart.assert(milliseconds > 0);
         throw new core.UnsupportedError("Timer greater than 0.");
       }
     }
     TimerImpl$periodic(milliseconds, callback) {
-      this._once = false;
-      this._inEventLoop = false;
-      this._handle = dart.as(null, core.int);
+      this[_once] = false;
+      this[_inEventLoop] = false;
+      this[_handle] = dart.as(null, core.int);
       if (hasTimer()) {
         enterJsAsync();
-        this._handle = self.setInterval(_js_helper.convertDartClosureToJS((() => {
+        this[_handle] = self.setInterval(_js_helper.convertDartClosureToJS((() => {
           callback(this);
         }).bind(this), 0), milliseconds);
       } else {
         throw new core.UnsupportedError("Periodic timer.");
       }
     }
     cancel() {
       if (hasTimer()) {
-        if (this._inEventLoop) {
+        if (this[_inEventLoop]) {
           throw new core.UnsupportedError("Timer in event loop cannot be canceled.");
         }
-        if (this._handle === null)
+        if (this[_handle] === null)
           return;
         leaveJsAsync();
-        if (this._once) {
-          self.clearTimeout(this._handle);
+        if (this[_once]) {
+          self.clearTimeout(this[_handle]);
         } else {
-          self.clearInterval(this._handle);
+          self.clearInterval(this[_handle]);
         }
-        this._handle = dart.as(null, core.int);
+        this[_handle] = dart.as(null, core.int);
       } else {
         throw new core.UnsupportedError("Canceling a timer.");
       }
     }
     get isActive() {
-      return this._handle !== null;
+      return this[_handle] !== null;
     }
   }
   dart.defineNamedConstructor(TimerImpl, 'periodic');
   // Function hasTimer: () → bool
   function hasTimer() {
     _js_helper.requiresPreamble();
     return self.setTimeout !== null;
   }
   class CapabilityImpl extends dart.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;
+      let hash = this[_id];
       hash = hash >> 0 ^ (hash / 4294967296).truncate();
       hash = ~hash + (hash << 15) & 4294967295;
       hash = hash >> 12;
       hash = hash * 5 & 4294967295;
       hash = hash >> 4;
       hash = hash * 2057 & 4294967295;
       hash = hash >> 16;
       return hash;
     }
     ['=='](other) {
       if (core.identical(other, this))
         return true;
       if (dart.is(other, CapabilityImpl)) {
-        return core.identical(this._id, other._id);
+        return core.identical(this[_id], other[_id]);
       }
       return false;
     }
   }
   dart.defineNamedConstructor(CapabilityImpl, '_internal');
   // 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));
   }
   class _Serializer extends dart.Object {
     _Serializer(opt$) {
       let serializeSendPorts = opt$.serializeSendPorts === void 0 ? true : opt$.serializeSendPorts;
       this.serializedObjectIds = new core.Map.identity();
-      this._serializeSendPorts = dart.as(serializeSendPorts, core.bool);
+      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;
       this.serializedObjectIds.set(x, serializationId);
       if (dart.is(x, _native_typed_data.NativeByteBuffer))
@@ skipping 79 matching lines @@
       }
       let keys = dart.as(Object.keys(x), core.List);
       let values = new List.from([]);
       values.length = keys.length;
       for (let i = 0; i < keys.length; i++) {
         values.set(i, this.serialize(x[keys.get(i)]));
       }
       return new List.from(['js-object', keys, values]);
     }
     serializeWorkerSendPort(x) {
-      if (this._serializeSendPorts) {
-        return new List.from(['sendport', x._workerId, x._isolateId, x._receivePortId]);
+      if (this[_serializeSendPorts]) {
+        return new List.from(['sendport', x[_workerId], x[_isolateId], x[_receivePortId]]);
       }
       return new List.from(['raw sendport', x]);
     }
     serializeJsSendPort(x) {
-      if (this._serializeSendPorts) {
+      if (this[_serializeSendPorts]) {
         let workerId = _isolate_helper._globalState.currentManagerId;
-        return new List.from(['sendport', workerId, x._isolateId, x._receivePort._id]);
+        return new List.from(['sendport', workerId, x[_isolateId], x[_receivePort][_id]]);
       }
       return new List.from(['raw sendport', x]);
     }
     serializeCapability(x) {
-      return new List.from(['capability', x._id]);
+      return new 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]);
     }
     serializeDartObject(x) {
       let classExtractor = _foreign_helper.JS_EMBEDDED_GLOBAL('', dart.as(_js_embedded_names.CLASS_ID_EXTRACTOR, core.String));
       let fieldsExtractor = _foreign_helper.JS_EMBEDDED_GLOBAL('', dart.as(_js_embedded_names.CLASS_FIELDS_EXTRACTOR, core.String));
       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))]);
     }
   }
   class _Deserializer extends dart.Object {
     _Deserializer(opt$) {
       let adjustSendPorts = opt$.adjustSendPorts === void 0 ? true : opt$.adjustSendPorts;
       this.deserializedObjects = new core.List();
-      this._adjustSendPorts = dart.as(adjustSendPorts, core.bool);
+      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":
@@ skipping 153 matching lines @@
   _isolate_helper.globalWindow = globalWindow;
   _isolate_helper.globalWorker = globalWorker;
   _isolate_helper.globalPostMessageDefined = globalPostMessageDefined;
   _isolate_helper.IsolateNatives = IsolateNatives;
   _isolate_helper.RawReceivePortImpl = RawReceivePortImpl;
   _isolate_helper.ReceivePortImpl = ReceivePortImpl;
   _isolate_helper.TimerImpl = TimerImpl;
   _isolate_helper.hasTimer = hasTimer;
   _isolate_helper.CapabilityImpl = CapabilityImpl;
 })(_isolate_helper || (_isolate_helper = {}));