support the JS builtin

test/codegen/expect/_isolate_helper/_isolate_helper.js

 var _isolate_helper;
 (function(_isolate_helper) {
   'use strict';
   // 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++;
   }
   // Function leaveJsAsync: () → dynamic
   function leaveJsAsync() {
     _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
   function startRootIsolate(entry, args) {
-    args = _foreign_helper.JS("", "#", args);
+    args = args;
     if (args === null)
       args = new List.from([]);
     if (!dart.is(args, core.List)) {
       throw new core.ArgumentError(`Arguments to main must be a List: ${args}`);
     }
     _isolate_helper._globalState = new _Manager(dart.as(entry, core.Function));
     if (_isolate_helper._globalState.isWorker)
       return;
     let rootContext = new _IsolateContext();
     _isolate_helper._globalState.rootContext = rootContext;
     _isolate_helper._globalState.currentContext = rootContext;
     if (dart.is(entry, _MainFunctionArgs)) {
       rootContext.eval(() => {
         dart.dinvokef(entry, args);
       });
     } else if (dart.is(entry, _MainFunctionArgsMessage)) {
       rootContext.eval(() => {
         dart.dinvokef(entry, args, null);
       });
     } else {
       rootContext.eval(dart.as(entry, core.Function));
     }
     _isolate_helper._globalState.topEventLoop.run();
   }
   dart.copyProperties(_isolate_helper, {
     get _globalState() {
-      return dart.as(_foreign_helper.JS("_Manager", "init.globalState"), _Manager);
+      return dart.as(init.globalState, _Manager);
     },
     set _globalState(val) {
-      _foreign_helper.JS("void", "init.globalState = #", val);
+      init.globalState = val;
     }
   });
   class _Manager extends dart.Object {
     get useWorkers() {
       return this.supportsWorkers;
     }
     _Manager(entry) {
       this.entry = entry;
       this.nextIsolateId = 0;
       this.currentManagerId = 0;
@@ skipping 17 matching lines @@
       }
     }
     _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() {
-      let function = _foreign_helper.JS('', "(function (f, a) { return function (e) { f(a, e); }})(#, #)", _foreign_helper.DART_CLOSURE_TO_JS(IsolateNatives._processWorkerMessage), this.mainManager);
-      _foreign_helper.JS("void", "self.onmessage = #", function);
-      _foreign_helper.JS('', 'self.dartPrint = self.dartPrint || (function(serialize) {\n  return function (object) {\n    if (self.console && self.console.log) {\n      self.console.log(object)\n    } else {\n      self.postMessage(serialize(object));\n    }\n  }\n})(#)', _foreign_helper.DART_CLOSURE_TO_JS(_serializePrintMessage));
+      let function = function(f, a) {
+        return function(e) {
+          f(a, e);
+        };
+      }(_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) {
       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)) {
         this.mainManager.postMessage(_serializeMessage(dart.map({command: 'close'})));
       }
     }
   }
@@ skipping 96 matching lines @@
       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))) {
           return;
         }
-        if (_foreign_helper.JS('bool', 'self.console && self.console.error')) {
-          _foreign_helper.JS('void', 'self.console.error(#, #)', error, stackTrace);
+        if (self.console && self.console.error) {
+          self.console.error(error, stackTrace);
         } else {
           core.print(error);
           if (stackTrace !== null)
             core.print(stackTrace);
         }
         return;
       }
       let message = new core.List(2);
       message.set(0, dart.dinvoke(error, 'toString'));
       message.set(1, stackTrace === null ? null : stackTrace.toString());
@@ skipping 183 matching lines @@
       if (this.isolate.isPaused) {
         this.isolate.delayedEvents.add(this);
         return;
       }
       this.isolate.eval(this.fn);
     }
   }
   class _MainManagerStub extends dart.Object {
     postMessage(msg) {
       _js_helper.requiresPreamble();
-      _foreign_helper.JS("void", "self.postMessage(#)", msg);
+      self.postMessage(msg);
     }
   }
   let _SPAWNED_SIGNAL = "spawned";
   let _SPAWN_FAILED_SIGNAL = "spawn failed";
   dart.copyProperties(_isolate_helper, {
     get globalWindow() {
       _js_helper.requiresPreamble();
-      return _foreign_helper.JS('', "self.window");
+      return self.window;
     },
     get globalWorker() {
       _js_helper.requiresPreamble();
-      return _foreign_helper.JS('', "self.Worker");
+      return self.Worker;
     },
     get globalPostMessageDefined() {
       _js_helper.requiresPreamble();
-      return dart.as(_foreign_helper.JS('bool', "!!self.postMessage"), core.bool);
+      return !!self.postMessage;
     }
   });
   class IsolateNatives extends dart.Object {
     static computeThisScript() {
       let currentScript = _foreign_helper.JS_EMBEDDED_GLOBAL('', dart.as(_js_embedded_names.CURRENT_SCRIPT, core.String));
       if (currentScript !== null) {
-        return dart.as(_foreign_helper.JS('String', 'String(#.src)', currentScript), core.String);
+        return String(currentScript.src);
       }
       if (_js_helper.Primitives.isD8)
         return computeThisScriptD8();
       if (_js_helper.Primitives.isJsshell)
         return computeThisScriptJsshell();
       if (_isolate_helper._globalState.isWorker)
         return computeThisScriptFromTrace();
       return null;
     }
     static computeThisScriptJsshell() {
-      return dart.as(_foreign_helper.JS('String|Null', 'thisFilename()'), core.String);
+      return dart.as(thisFilename(), core.String);
     }
     static computeThisScriptD8() {
       return computeThisScriptFromTrace();
     }
     static computeThisScriptFromTrace() {
-      let stack = _foreign_helper.JS('String|Null', 'new Error().stack');
+      let stack = new Error().stack;
       if (stack === null) {
-        stack = _foreign_helper.JS('String|Null', '(function() {' + 'try { throw new Error() } catch(e) { return e.stack }' + '})()');
+        stack = function() {
+          try {
+            throw new Error();
+          } catch (e) {
+            return e.stack;
+          }
+
+        }();
         if (stack === null)
           throw new core.UnsupportedError('No stack trace');
       }
       let pattern = null, matches = null;
-      pattern = _foreign_helper.JS('', 'new RegExp("^ *at [^(]*\\\\((.*):[0-9]*:[0-9]*\\\\)$", "m")');
-      matches = _foreign_helper.JS('JSExtendableArray|Null', '#.match(#)', stack, pattern);
+      pattern = new RegExp("^ *at [^(]*\\((.*):[0-9]*:[0-9]*\\)$", "m");
+      matches = stack.match(pattern);
       if (matches !== null)
-        return dart.as(_foreign_helper.JS('String', '#[1]', matches), core.String);
-      pattern = _foreign_helper.JS('', 'new RegExp("^[^@]*@(.*):[0-9]*$", "m")');
-      matches = _foreign_helper.JS('JSExtendableArray|Null', '#.match(#)', stack, pattern);
+        return matches[1];
+      pattern = new RegExp("^[^@]*@(.*):[0-9]*$", "m");
+      matches = stack.match(pattern);
       if (matches !== null)
-        return dart.as(_foreign_helper.JS('String', '#[1]', matches), core.String);
+        return matches[1];
       throw new core.UnsupportedError(`Cannot extract URI from "${stack}"`);
     }
     static _getEventData(e) {
-      return _foreign_helper.JS("", "#.data", e);
+      return e.data;
     }
     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'));
@@ skipping 13 matching lines @@
           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'));
           }
           _isolate_helper._globalState.topEventLoop.run();
           break;
         case 'close':
           _isolate_helper._globalState.managers.remove(workerIds.get(sender));
-          _foreign_helper.JS('void', '#.terminate()', sender);
+          sender.terminate();
           _isolate_helper._globalState.topEventLoop.run();
           break;
         case 'log':
           _log(dart.dindex(msg, 'msg'));
           break;
         case 'print':
           if (_isolate_helper._globalState.isWorker) {
             _isolate_helper._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'print', msg: msg})));
           } else {
             core.print(dart.dindex(msg, 'msg'));
@@ skipping 21 matching lines @@
           _consoleLog(msg);
         } catch (e) {
           let trace = dart.stackTrace(e);
           throw new core.Exception(trace);
         }
 
       }
     }
     static _consoleLog(msg) {
       _js_helper.requiresPreamble();
-      _foreign_helper.JS("void", "self.console.log(#)", msg);
+      self.console.log(msg);
     }
     static _getJSFunctionFromName(functionName) {
       let globalFunctionsContainer = _foreign_helper.JS_EMBEDDED_GLOBAL("", dart.as(_js_embedded_names.GLOBAL_FUNCTIONS, core.String));
-      return _foreign_helper.JS("", "#[#]()", globalFunctionsContainer, functionName);
+      return globalFunctionsContainer[functionName]();
     }
     static _getJSFunctionName(f) {
-      return dart.as(dart.is(f, _js_helper.Closure) ? _foreign_helper.JS("String|Null", '#.$name', f) : null, core.String);
+      return dart.as(dart.is(f, _js_helper.Closure) ? f.$name : null, core.String);
     }
     static _allocate(ctor) {
-      return _foreign_helper.JS("", "new #()", 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;
       return spawn(name, null, null, message, isLight, isSpawnUri, startPaused);
@@ skipping 70 matching lines @@
       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) {
       if (uri === null)
         uri = thisScript;
-      let worker = _foreign_helper.JS('var', 'new Worker(#)', uri);
-      let onerrorTrampoline = _foreign_helper.JS('', '\n(function (f, u, c) {\n  return function(e) {\n    return f(e, u, c)\n  }\n})(#, #, #)', _foreign_helper.DART_CLOSURE_TO_JS(workerOnError), uri, onError);
-      _foreign_helper.JS('void', '#.onerror = #', worker, onerrorTrampoline);
-      let processWorkerMessageTrampoline = _foreign_helper.JS('', "\n(function (f, a) {\n  return function (e) {\n    // We can stop listening for errors when the first message is received as\n    // we only listen for messages to determine if the uri was bad.\n    e.onerror = null;\n    return f(a, e);\n  }\n})(#, #)", _foreign_helper.DART_CLOSURE_TO_JS(_processWorkerMessage), worker);
-      _foreign_helper.JS('void', '#.onmessage = #', worker, processWorkerMessageTrampoline);
+      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 = _isolate_helper._globalState.nextManagerId++;
       workerIds.set(worker, workerId);
       _isolate_helper._globalState.managers.set(workerId, worker);
-      _foreign_helper.JS('void', '#.postMessage(#)', worker, _serializeMessage(dart.map({command: 'start', id: workerId, replyTo: _serializeMessage(replyPort), args: args, msg: _serializeMessage(message), isSpawnUri: isSpawnUri, startPaused: startPaused, functionName: functionName})));
+      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) {
-      _foreign_helper.JS('void', '#.preventDefault()', event);
-      let message = dart.as(_foreign_helper.JS('String|Null', '#.message', event), core.String);
+      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;
@@ skipping 51 matching lines @@
       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);
         if (manager !== null) {
-          _foreign_helper.JS('void', '#.postMessage(#)', manager, workerMessage);
+          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'));
     }
     get hashCode() {
       return this._workerId << 16 ^ this._isolateId << 8 ^ this._receivePortId;
     }
   }
@@ skipping 86 matching lines @@
         _isolate_helper._globalState.topEventLoop.enqueue(_isolate_helper._globalState.currentContext, internalCallback, 'timer');
         this._inEventLoop = true;
       } else if (hasTimer()) {
         // Function internalCallback: () → void
         function internalCallback() {
           this._handle = dart.as(null, core.int);
           leaveJsAsync();
           callback();
         }
         enterJsAsync();
-        this._handle = dart.as(_foreign_helper.JS('int', 'self.setTimeout(#, #)', _js_helper.convertDartClosureToJS(internalCallback, 0), milliseconds), core.int);
+        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);
       if (hasTimer()) {
         enterJsAsync();
-        this._handle = dart.as(_foreign_helper.JS('int', 'self.setInterval(#, #)', _js_helper.convertDartClosureToJS((() => {
+        this._handle = self.setInterval(_js_helper.convertDartClosureToJS((() => {
           callback(this);
-        }).bind(this), 0), milliseconds), core.int);
+        }).bind(this), 0), milliseconds);
       } else {
         throw new core.UnsupportedError("Periodic timer.");
       }
     }
     cancel() {
       if (hasTimer()) {
         if (this._inEventLoop) {
           throw new core.UnsupportedError("Timer in event loop cannot be canceled.");
         }
         if (this._handle === null)
           return;
         leaveJsAsync();
         if (this._once) {
-          _foreign_helper.JS('void', 'self.clearTimeout(#)', this._handle);
+          self.clearTimeout(this._handle);
         } else {
-          _foreign_helper.JS('void', 'self.clearInterval(#)', this._handle);
+          self.clearInterval(this._handle);
         }
         this._handle = dart.as(null, core.int);
       } else {
         throw new core.UnsupportedError("Canceling a timer.");
       }
     }
     get isActive() {
       return this._handle !== null;
     }
   }
   dart.defineNamedConstructor(TimerImpl, 'periodic');
   // Function hasTimer: () → bool
   function hasTimer() {
     _js_helper.requiresPreamble();
-    return _foreign_helper.JS('', 'self.setTimeout') !== null;
+    return self.setTimeout !== null;
   }
   class CapabilityImpl extends dart.Object {
     CapabilityImpl() {
       this.CapabilityImpl$_internal(_js_helper.random64());
     }
     CapabilityImpl$_internal(_id) {
       this._id = _id;
     }
     get hashCode() {
       let hash = this._id;
@@ skipping 115 matching lines @@
       for (let i = 0; i < x.length; i++) {
         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()]);
     }
     serializeJSObject(x) {
-      if (dart.dbinary(_foreign_helper.JS('bool', '!!(#.constructor)', x), '&&', _foreign_helper.JS('bool', 'x.constructor !== Object'))) {
+      if (dart.notNull(!!x.constructor) && dart.notNull(x.constructor !== Object)) {
         this.unsupported(x, "Only plain JS Objects are supported:");
       }
-      let keys = dart.as(_foreign_helper.JS('JSArray', 'Object.keys(#)', x), core.List);
+      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(_foreign_helper.JS('', '#[#]', x, keys.get(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]);
       }
       return new List.from(['raw sendport', x]);
     }
     serializeJsSendPort(x) {
       if (this._serializeSendPorts) {
         let workerId = _isolate_helper._globalState.currentManagerId;
         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]);
     }
     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 = dart.as(_foreign_helper.JS('String', '#(#)', classExtractor, x), core.String);
-      let fields = dart.as(_foreign_helper.JS('JSArray', '#(#)', fieldsExtractor, x), core.List);
+      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);
     }
     deserialize(x) {
@@ skipping 120 matching lines @@
     deserializeRawSendPort(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'raw sendport'));
       let result = dart.as(dart.dindex(x, 1), isolate.SendPort);
       this.deserializedObjects.add(result);
       return result;
     }
     deserializeJSObject(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'js-object'));
       let keys = dart.as(dart.dindex(x, 1), core.List);
       let values = dart.as(dart.dindex(x, 2), core.List);
-      let o = _foreign_helper.JS('', '{}');
+      let o = {};
       this.deserializedObjects.add(o);
       for (let i = 0; i < keys.length; i++) {
-        _foreign_helper.JS('', '#[#]=#', o, keys.get(i), this.deserialize(values.get(i)));
+        o[keys.get(i)] = this.deserialize(values.get(i));
       }
       return o;
     }
     deserializeClosure(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'function'));
       let name = dart.as(dart.dindex(x, 1), core.String);
       let result = dart.as(IsolateNatives._getJSFunctionFromName(name), core.Function);
       this.deserializedObjects.add(result);
       return result;
     }
     deserializeDartObject(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'dart'));
       let classId = dart.as(dart.dindex(x, 1), core.String);
       let fields = dart.as(dart.dindex(x, 2), core.List);
       let instanceFromClassId = _foreign_helper.JS_EMBEDDED_GLOBAL('', dart.as(_js_embedded_names.INSTANCE_FROM_CLASS_ID, core.String));
       let initializeObject = _foreign_helper.JS_EMBEDDED_GLOBAL('', dart.as(_js_embedded_names.INITIALIZE_EMPTY_INSTANCE, core.String));
-      let emptyInstance = _foreign_helper.JS('', '#(#)', instanceFromClassId, classId);
+      let emptyInstance = instanceFromClassId(classId);
       this.deserializedObjects.add(emptyInstance);
       this.deserializeArrayInPlace(dart.as(fields, _interceptors.JSArray));
-      return _foreign_helper.JS('', '#(#, #, #)', initializeObject, classId, emptyInstance, fields);
+      return initializeObject(classId, emptyInstance, fields);
     }
   }
   // Exports:
   _isolate_helper.enterJsAsync = enterJsAsync;
   _isolate_helper.leaveJsAsync = leaveJsAsync;
   _isolate_helper.isWorker = isWorker;
   _isolate_helper.startRootIsolate = startRootIsolate;
   _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 = {}));