support the JS builtin

test/codegen/expect/collection/collection.js

 var collection;
 (function(collection) {
   'use strict';
   let _HashMap$ = dart.generic(function(K, V) {
     class _HashMap extends dart.Object {
       _HashMap() {
         this._length = 0;
         this._strings = null;
         this._nums = null;
         this._rest = null;
@@ skipping 50 matching lines @@
         } else {
           return this._get(key);
         }
       }
       _get(key) {
         let rest = this._rest;
         if (rest === null)
           return dart.as(null, V);
         let bucket = this._getBucket(rest, key);
         let index = this._findBucketIndex(bucket, key);
-        return dart.as(index < 0 ? null : _foreign_helper.JS('var', '#[#]', bucket, index + 1), V);
+        return dart.as(index < 0 ? null : bucket[index + 1], V);
       }
       set(key, value) {
         if (_isStringKey(key)) {
           let strings = this._strings;
           if (strings === null)
             this._strings = strings = _newHashTable();
           this._addHashTableEntry(strings, key, value);
         } else if (_isNumericKey(key)) {
           let nums = this._nums;
           if (nums === null)
             this._nums = nums = _newHashTable();
           this._addHashTableEntry(nums, key, value);
         } else {
           this._set(key, value);
         }
       }
       _set(key, value) {
         let rest = this._rest;
         if (rest === null)
           this._rest = rest = _newHashTable();
         let hash = this._computeHashCode(key);
-        let bucket = _foreign_helper.JS('var', '#[#]', rest, hash);
+        let bucket = rest[hash];
         if (bucket === null) {
-          _setTableEntry(rest, hash, _foreign_helper.JS('var', '[#, #]', key, value));
+          _setTableEntry(rest, hash, [key, value]);
           this._length++;
           this._keys = null;
         } else {
           let index = this._findBucketIndex(bucket, key);
           if (index >= 0) {
-            _foreign_helper.JS('void', '#[#] = #', bucket, index + 1, value);
+            bucket[index + 1] = value;
           } else {
-            _foreign_helper.JS('void', '#.push(#, #)', bucket, key, value);
+            bucket.push(key, value);
             this._length++;
             this._keys = null;
           }
         }
       }
       putIfAbsent(key, ifAbsent) {
         if (this.containsKey(key))
           return this.get(key);
         let value = ifAbsent();
         this.set(key, value);
@@ skipping 11 matching lines @@
       _remove(key) {
         let rest = this._rest;
         if (rest === null)
           return dart.as(null, V);
         let bucket = this._getBucket(rest, key);
         let index = this._findBucketIndex(bucket, key);
         if (index < 0)
           return dart.as(null, V);
         this._length--;
         this._keys = null;
-        return dart.as(_foreign_helper.JS('var', '#.splice(#, 2)[1]', bucket, index), V);
+        return dart.as(bucket.splice(index, 2)[1], V);
       }
       clear() {
         if (this._length > 0) {
           this._strings = this._nums = this._rest = this._keys = null;
           this._length = 0;
         }
       }
       forEach(action) {
         let keys = this._computeKeys();
         for (let i = 0, length = keys.length; i < length; i++) {
-          let key = _foreign_helper.JS('var', '#[#]', keys, i);
+          let key = keys[i];
           action(dart.as(key, K), this.get(key));
-          if (_foreign_helper.JS('bool', '# !== #', keys, this._keys)) {
+          if (keys !== this._keys) {
             throw new core.ConcurrentModificationError(this);
           }
         }
       }
       _computeKeys() {
         if (this._keys !== null)
           return this._keys;
         let result = new core.List(this._length);
         let index = 0;
         let strings = this._strings;
         if (strings !== null) {
-          let names = _foreign_helper.JS('var', 'Object.getOwnPropertyNames(#)', strings);
-          let entries = dart.as(_foreign_helper.JS('int', '#.length', names), core.int);
+          let names = Object.getOwnPropertyNames(strings);
+          let entries = names.length;
           for (let i = 0; i < entries; i++) {
-            let key = dart.as(_foreign_helper.JS('String', '#[#]', names, i), core.String);
-            _foreign_helper.JS('void', '#[#] = #', result, index, key);
+            let key = names[i];
+            result[index] = key;
             index++;
           }
         }
         let nums = this._nums;
         if (nums !== null) {
-          let names = _foreign_helper.JS('var', 'Object.getOwnPropertyNames(#)', nums);
-          let entries = dart.as(_foreign_helper.JS('int', '#.length', names), core.int);
+          let names = Object.getOwnPropertyNames(nums);
+          let entries = names.length;
           for (let i = 0; i < entries; i++) {
-            let key = dart.as(_foreign_helper.JS('num', '+#[#]', names, i), core.num);
-            _foreign_helper.JS('void', '#[#] = #', result, index, key);
+            let key = +names[i];
+            result[index] = key;
             index++;
           }
         }
         let rest = this._rest;
         if (rest !== null) {
-          let names = _foreign_helper.JS('var', 'Object.getOwnPropertyNames(#)', rest);
-          let entries = dart.as(_foreign_helper.JS('int', '#.length', names), core.int);
+          let names = Object.getOwnPropertyNames(rest);
+          let entries = names.length;
           for (let i = 0; i < entries; i++) {
-            let key = _foreign_helper.JS('String', '#[#]', names, i);
-            let bucket = _foreign_helper.JS('var', '#[#]', rest, key);
-            let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+            let key = names[i];
+            let bucket = rest[key];
+            let length = bucket.length;
             for (let i = 0; i < length; i = 2) {
-              let key = _foreign_helper.JS('var', '#[#]', bucket, i);
-              _foreign_helper.JS('void', '#[#] = #', result, index, key);
+              let key = bucket[i];
+              result[index] = key;
               index++;
             }
           }
         }
         dart.assert(index === this._length);
         return this._keys = result;
       }
       _addHashTableEntry(table, key, value) {
         if (!dart.notNull(_hasTableEntry(table, key))) {
           this._length++;
           this._keys = null;
         }
         _setTableEntry(table, key, value);
       }
       _removeHashTableEntry(table, key) {
         if (dart.notNull(table !== null) && dart.notNull(_hasTableEntry(table, key))) {
           let value = dart.as(_getTableEntry(table, key), V);
           _deleteTableEntry(table, key);
           this._length--;
           this._keys = null;
           return value;
         } else {
           return dart.as(null, V);
         }
       }
       static _isStringKey(key) {
         return dart.notNull(typeof key == string) && dart.notNull(!dart.equals(key, '__proto__'));
       }
       static _isNumericKey(key) {
-        return core.bool['&&'](dart.is(key, core.num), _foreign_helper.JS('bool', '(# & 0x3ffffff) === #', key, key));
+        return dart.notNull(dart.is(key, core.num)) && dart.notNull((key & 0x3ffffff) === key);

[Jennifer Messerly, 2015/02/27 14:59:23]

filed https://github.com/dart-lang/dev_compiler/issues/68 ... the result of `is`
can't be null

[vsm, 2015/02/27 17:20:05]

Commented there.  I think the cleanest solution is some form of non-nullability
at the type level.

       }
       _computeHashCode(key) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', dart.dload(key, 'hashCode')), core.int);
+        return dart.dload(key, 'hashCode') & 0x3ffffff;
       }
       static _hasTableEntry(table, key) {
-        let entry = _foreign_helper.JS('var', '#[#]', table, key);
+        let entry = table[key];
         return entry !== null;
       }
       static _getTableEntry(table, key) {
-        let entry = _foreign_helper.JS('var', '#[#]', table, key);
-        return _foreign_helper.JS('bool', '# === #', entry, table) ? null : entry;
+        let entry = table[key];
+        return entry === table ? null : entry;
       }
       static _setTableEntry(table, key, value) {
         if (value === null) {
-          _foreign_helper.JS('void', '#[#] = #', table, key, table);
+          table[key] = table;
         } else {
-          _foreign_helper.JS('void', '#[#] = #', table, key, value);
+          table[key] = value;
         }
       }
       static _deleteTableEntry(table, key) {
-        _foreign_helper.JS('void', 'delete #[#]', table, key);
+        delete table[key];
       }
       _getBucket(table, key) {
         let hash = this._computeHashCode(key);
-        return dart.as(_foreign_helper.JS('var', '#[#]', table, hash), core.List);
+        return dart.as(table[hash], core.List);
       }
       _findBucketIndex(bucket, key) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i = 2) {
-          if (dart.equals(_foreign_helper.JS('var', '#[#]', bucket, i), key))
+          if (dart.equals(bucket[i], key))
             return i;
         }
         return -1;
       }
       static _newHashTable() {
-        let table = _foreign_helper.JS('var', 'Object.create(null)');
+        let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _setTableEntry(table, temporaryKey, table);
         _deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     return _HashMap;
   });
   let _HashMap = _HashMap$(dynamic, dynamic);
   let _IdentityHashMap$ = dart.generic(function(K, V) {
     class _IdentityHashMap extends _HashMap$(K, V) {
       _computeHashCode(key) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', core.identityHashCode(key)), core.int);
+        return core.identityHashCode(key) & 0x3ffffff;
       }
       _findBucketIndex(bucket, key) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i = 2) {
-          if (core.identical(_foreign_helper.JS('var', '#[#]', bucket, i), key))
+          if (core.identical(bucket[i], key))
             return i;
         }
         return -1;
       }
     }
     return _IdentityHashMap;
   });
   let _IdentityHashMap = _IdentityHashMap$(dynamic, dynamic);
   let _CustomHashMap$ = dart.generic(function(K, V) {
     class _CustomHashMap extends _HashMap$(K, V) {
@@ skipping 15 matching lines @@
         if (!dart.notNull(this._validKey(key)))
           return false;
         return super._containsKey(key);
       }
       remove(key) {
         if (!dart.notNull(this._validKey(key)))
           return dart.as(null, V);
         return super._remove(key);
       }
       _computeHashCode(key) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', this._hashCode(dart.as(key, K))), core.int);
+        return this._hashCode(dart.as(key, K)) & 0x3ffffff;
       }
       _findBucketIndex(bucket, key) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i = 2) {
-          if (this._equals(dart.as(_foreign_helper.JS('var', '#[#]', bucket, i), K), dart.as(key, K)))
+          if (this._equals(dart.as(bucket[i], K), dart.as(key, K)))
             return i;
         }
         return -1;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     return _CustomHashMap;
   });
@@ skipping 11 matching lines @@
         return dart.equals(dart.dload(this._map, '_length'), 0);
       }
       get iterator() {
         return new HashMapKeyIterator(this._map, dart.as(dart.dinvoke(this._map, '_computeKeys'), core.List));
       }
       contains(element) {
         return dart.as(dart.dinvoke(this._map, 'containsKey', element), core.bool);
       }
       forEach(f) {
         let keys = dart.as(dart.dinvoke(this._map, '_computeKeys'), core.List);
-        for (let i = 0, length = dart.as(_foreign_helper.JS('int', '#.length', keys), core.int); i < length; i++) {
-          f(dart.as(_foreign_helper.JS('var', '#[#]', keys, i), E));
-          if (_foreign_helper.JS('bool', '# !== #', keys, dart.dload(this._map, '_keys'))) {
+        for (let i = 0, length = keys.length; i < length; i++) {
+          f(dart.as(keys[i], E));
+          if (keys !== dart.dload(this._map, '_keys')) {
             throw new core.ConcurrentModificationError(this._map);
           }
         }
       }
     }
     return HashMapKeyIterable;
   });
   let HashMapKeyIterable = HashMapKeyIterable$(dynamic);
   let HashMapKeyIterator$ = dart.generic(function(E) {
     class HashMapKeyIterator extends dart.Object {
       HashMapKeyIterator(_map, _keys) {
         this._map = _map;
         this._keys = _keys;
         this._offset = 0;
         this._current = dart.as(null, E);
       }
       get current() {
         return this._current;
       }
       moveNext() {
         let keys = this._keys;
         let offset = this._offset;
-        if (_foreign_helper.JS('bool', '# !== #', keys, dart.dload(this._map, '_keys'))) {
+        if (keys !== dart.dload(this._map, '_keys')) {
           throw new core.ConcurrentModificationError(this._map);
-        } else if (offset['>='](_foreign_helper.JS('int', '#.length', keys))) {
+        } else if (offset >= keys.length) {
           this._current = dart.as(null, E);
           return false;
         } else {
-          this._current = dart.as(_foreign_helper.JS('var', '#[#]', keys, offset), E);
-          this._offset = dart.as(_foreign_helper.JS('int', '#', offset + 1), core.int);
+          this._current = dart.as(keys[offset], E);
+          this._offset = offset + 1;
           return true;
         }
       }
     }
     return HashMapKeyIterator;
   });
   let HashMapKeyIterator = HashMapKeyIterator$(dynamic);
   let _LinkedHashMap$ = dart.generic(function(K, V) {
     class _LinkedHashMap extends dart.Object {
       _LinkedHashMap() {
@@ skipping 70 matching lines @@
         }
       }
       _get(key) {
         let rest = this._rest;
         if (rest === null)
           return dart.as(null, V);
         let bucket = this._getBucket(rest, key);
         let index = this._findBucketIndex(bucket, key);
         if (index < 0)
           return dart.as(null, V);
-        let cell = dart.as(_foreign_helper.JS('var', '#[#]', bucket, index), LinkedHashMapCell);
+        let cell = dart.as(bucket[index], LinkedHashMapCell);
         return dart.as(cell._value, V);
       }
       set(key, value) {
         if (_isStringKey(key)) {
           let strings = this._strings;
           if (strings === null)
             this._strings = strings = _newHashTable();
           this._addHashTableEntry(strings, key, value);
         } else if (_isNumericKey(key)) {
           let nums = this._nums;
           if (nums === null)
             this._nums = nums = _newHashTable();
           this._addHashTableEntry(nums, key, value);
         } else {
           this._set(key, value);
         }
       }
       _set(key, value) {
         let rest = this._rest;
         if (rest === null)
           this._rest = rest = _newHashTable();
         let hash = this._computeHashCode(key);
-        let bucket = _foreign_helper.JS('var', '#[#]', rest, hash);
+        let bucket = rest[hash];
         if (bucket === null) {
           let cell = this._newLinkedCell(key, value);
-          _setTableEntry(rest, hash, _foreign_helper.JS('var', '[#]', cell));
+          _setTableEntry(rest, hash, [cell]);
         } else {
           let index = this._findBucketIndex(bucket, key);
           if (index >= 0) {
-            let cell = dart.as(_foreign_helper.JS('var', '#[#]', bucket, index), LinkedHashMapCell);
+            let cell = dart.as(bucket[index], LinkedHashMapCell);
             cell._value = value;
           } else {
             let cell = this._newLinkedCell(key, value);
-            _foreign_helper.JS('void', '#.push(#)', bucket, cell);
+            bucket.push(cell);
           }
         }
       }
       putIfAbsent(key, ifAbsent) {
         if (this.containsKey(key))
           return this.get(key);
         let value = ifAbsent();
         this.set(key, value);
         return value;
       }
       remove(key) {
         if (_isStringKey(key)) {
           return this._removeHashTableEntry(this._strings, key);
         } else if (_isNumericKey(key)) {
           return this._removeHashTableEntry(this._nums, key);
         } else {
           return this._remove(key);
         }
       }
       _remove(key) {
         let rest = this._rest;
         if (rest === null)
           return dart.as(null, V);
         let bucket = this._getBucket(rest, key);
         let index = this._findBucketIndex(bucket, key);
         if (index < 0)
           return dart.as(null, V);
-        let cell = dart.as(_foreign_helper.JS('var', '#.splice(#, 1)[0]', bucket, index), LinkedHashMapCell);
+        let cell = dart.as(bucket.splice(index, 1)[0], LinkedHashMapCell);
         this._unlinkCell(cell);
         return dart.as(cell._value, V);
       }
       clear() {
         if (this._length > 0) {
           this._strings = this._nums = this._rest = this._first = this._last = null;
           this._length = 0;
           this._modified();
         }
       }
@@ skipping 57 matching lines @@
         } else {
           next._previous = previous;
         }
         this._length--;
         this._modified();
       }
       static _isStringKey(key) {
         return dart.notNull(typeof key == string) && dart.notNull(!dart.equals(key, '__proto__'));
       }
       static _isNumericKey(key) {
-        return core.bool['&&'](dart.is(key, core.num), _foreign_helper.JS('bool', '(# & 0x3ffffff) === #', key, key));
+        return dart.notNull(dart.is(key, core.num)) && dart.notNull((key & 0x3ffffff) === key);
       }
       _computeHashCode(key) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', dart.dload(key, 'hashCode')), core.int);
+        return dart.dload(key, 'hashCode') & 0x3ffffff;
       }
       static _getTableEntry(table, key) {
-        return _foreign_helper.JS('var', '#[#]', table, key);
+        return table[key];
       }
       static _setTableEntry(table, key, value) {
         dart.assert(value !== null);
-        _foreign_helper.JS('void', '#[#] = #', table, key, value);
+        table[key] = value;
       }
       static _deleteTableEntry(table, key) {
-        _foreign_helper.JS('void', 'delete #[#]', table, key);
+        delete table[key];
       }
       _getBucket(table, key) {
         let hash = this._computeHashCode(key);
-        return dart.as(_foreign_helper.JS('var', '#[#]', table, hash), core.List);
+        return dart.as(table[hash], core.List);
       }
       _findBucketIndex(bucket, key) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i++) {
-          let cell = dart.as(_foreign_helper.JS('var', '#[#]', bucket, i), LinkedHashMapCell);
+          let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (dart.equals(cell._key, key))
             return i;
         }
         return -1;
       }
       static _newHashTable() {
-        let table = _foreign_helper.JS('var', 'Object.create(null)');
+        let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _setTableEntry(table, temporaryKey, table);
         _deleteTableEntry(table, temporaryKey);
         return table;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     return _LinkedHashMap;
   });
   let _LinkedHashMap = _LinkedHashMap$(dynamic, dynamic);
   let _LinkedIdentityHashMap$ = dart.generic(function(K, V) {
     class _LinkedIdentityHashMap extends _LinkedHashMap$(K, V) {
       _computeHashCode(key) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', core.identityHashCode(key)), core.int);
+        return core.identityHashCode(key) & 0x3ffffff;
       }
       _findBucketIndex(bucket, key) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i++) {
-          let cell = dart.as(_foreign_helper.JS('var', '#[#]', bucket, i), LinkedHashMapCell);
+          let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (core.identical(cell._key, key))
             return i;
         }
         return -1;
       }
     }
     return _LinkedIdentityHashMap;
   });
   let _LinkedIdentityHashMap = _LinkedIdentityHashMap$(dynamic, dynamic);
   let _LinkedCustomHashMap$ = dart.generic(function(K, V) {
@@ skipping 16 matching lines @@
         if (!dart.notNull(this._validKey(key)))
           return false;
         return super._containsKey(key);
       }
       remove(key) {
         if (!dart.notNull(this._validKey(key)))
           return dart.as(null, V);
         return super._remove(key);
       }
       _computeHashCode(key) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', this._hashCode(dart.as(key, K))), core.int);
+        return this._hashCode(dart.as(key, K)) & 0x3ffffff;
       }
       _findBucketIndex(bucket, key) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i++) {
-          let cell = dart.as(_foreign_helper.JS('var', '#[#]', bucket, i), LinkedHashMapCell);
+          let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (this._equals(dart.as(cell._key, K), dart.as(key, K)))
             return i;
         }
         return -1;
       }
     }
     return _LinkedCustomHashMap;
   });
   let _LinkedCustomHashMap = _LinkedCustomHashMap$(dynamic, dynamic);
   class LinkedHashMapCell extends dart.Object {
@@ skipping 137 matching lines @@
           return this._addHashTableEntry(nums, element);
         } else {
           return this._add(element);
         }
       }
       _add(element) {
         let rest = this._rest;
         if (rest === null)
           this._rest = rest = _newHashTable();
         let hash = this._computeHashCode(element);
-        let bucket = _foreign_helper.JS('var', '#[#]', rest, hash);
+        let bucket = rest[hash];
         if (bucket === null) {
-          _setTableEntry(rest, hash, _foreign_helper.JS('var', '[#]', element));
+          _setTableEntry(rest, hash, [element]);
         } else {
           let index = this._findBucketIndex(bucket, element);
           if (index >= 0)
             return false;
-          _foreign_helper.JS('void', '#.push(#)', bucket, element);
+          bucket.push(element);
         }
         this._length++;
         this._elements = null;
         return true;
       }
       addAll(objects) {
         for (let each of objects) {
           this.add(each);
         }
       }
       remove(object) {
         if (_isStringElement(object)) {
           return this._removeHashTableEntry(this._strings, object);
         } else if (_isNumericElement(object)) {
           return this._removeHashTableEntry(this._nums, object);
         } else {
           return this._remove(object);
         }
       }
       _remove(object) {
         let rest = this._rest;
         if (rest === null)
           return false;
         let bucket = this._getBucket(rest, object);
         let index = this._findBucketIndex(bucket, object);
         if (index < 0)
           return false;
         this._length--;
         this._elements = null;
-        _foreign_helper.JS('void', '#.splice(#, 1)', bucket, index);
+        bucket.splice(index, 1);
         return true;
       }
       clear() {
         if (this._length > 0) {
           this._strings = this._nums = this._rest = this._elements = null;
           this._length = 0;
         }
       }
       _computeElements() {
         if (this._elements !== null)
           return this._elements;
         let result = new core.List(this._length);
         let index = 0;
         let strings = this._strings;
         if (strings !== null) {
-          let names = _foreign_helper.JS('var', 'Object.getOwnPropertyNames(#)', strings);
-          let entries = dart.as(_foreign_helper.JS('int', '#.length', names), core.int);
+          let names = Object.getOwnPropertyNames(strings);
+          let entries = names.length;
           for (let i = 0; i < entries; i++) {
-            let element = dart.as(_foreign_helper.JS('String', '#[#]', names, i), core.String);
-            _foreign_helper.JS('void', '#[#] = #', result, index, element);
+            let element = names[i];
+            result[index] = element;
             index++;
           }
         }
         let nums = this._nums;
         if (nums !== null) {
-          let names = _foreign_helper.JS('var', 'Object.getOwnPropertyNames(#)', nums);
-          let entries = dart.as(_foreign_helper.JS('int', '#.length', names), core.int);
+          let names = Object.getOwnPropertyNames(nums);
+          let entries = names.length;
           for (let i = 0; i < entries; i++) {
-            let element = dart.as(_foreign_helper.JS('num', '+#[#]', names, i), core.num);
-            _foreign_helper.JS('void', '#[#] = #', result, index, element);
+            let element = +names[i];
+            result[index] = element;
             index++;
           }
         }
         let rest = this._rest;
         if (rest !== null) {
-          let names = _foreign_helper.JS('var', 'Object.getOwnPropertyNames(#)', rest);
-          let entries = dart.as(_foreign_helper.JS('int', '#.length', names), core.int);
+          let names = Object.getOwnPropertyNames(rest);
+          let entries = names.length;
           for (let i = 0; i < entries; i++) {
-            let entry = _foreign_helper.JS('String', '#[#]', names, i);
-            let bucket = _foreign_helper.JS('var', '#[#]', rest, entry);
-            let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+            let entry = names[i];
+            let bucket = rest[entry];
+            let length = bucket.length;
             for (let i = 0; i < length; i++) {
-              _foreign_helper.JS('void', '#[#] = #[#]', result, index, bucket, i);
+              result[index] = bucket[i];
               index++;
             }
           }
         }
         dart.assert(index === this._length);
         return this._elements = result;
       }
       _addHashTableEntry(table, element) {
         if (_hasTableEntry(table, element))
           return false;
         _setTableEntry(table, element, 0);
         this._length++;
         this._elements = null;
         return true;
       }
       _removeHashTableEntry(table, element) {
         if (dart.notNull(table !== null) && dart.notNull(_hasTableEntry(table, element))) {
           _deleteTableEntry(table, element);
           this._length--;
           this._elements = null;
           return true;
         } else {
           return false;
         }
       }
       static _isStringElement(element) {
         return dart.notNull(typeof element == string) && dart.notNull(!dart.equals(element, '__proto__'));
       }
       static _isNumericElement(element) {
-        return core.bool['&&'](dart.is(element, core.num), _foreign_helper.JS('bool', '(# & 0x3ffffff) === #', element, element));
+        return dart.notNull(dart.is(element, core.num)) && dart.notNull((element & 0x3ffffff) === element);
       }
       _computeHashCode(element) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', dart.dload(element, 'hashCode')), core.int);
+        return dart.dload(element, 'hashCode') & 0x3ffffff;
       }
       static _hasTableEntry(table, key) {
-        let entry = _foreign_helper.JS('var', '#[#]', table, key);
+        let entry = table[key];
         return entry !== null;
       }
       static _setTableEntry(table, key, value) {
         dart.assert(value !== null);
-        _foreign_helper.JS('void', '#[#] = #', table, key, value);
+        table[key] = value;
       }
       static _deleteTableEntry(table, key) {
-        _foreign_helper.JS('void', 'delete #[#]', table, key);
+        delete table[key];
       }
       _getBucket(table, element) {
         let hash = this._computeHashCode(element);
-        return dart.as(_foreign_helper.JS('var', '#[#]', table, hash), core.List);
+        return dart.as(table[hash], core.List);
       }
       _findBucketIndex(bucket, element) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i++) {
-          if (dart.equals(_foreign_helper.JS('var', '#[#]', bucket, i), element))
+          if (dart.equals(bucket[i], element))
             return i;
         }
         return -1;
       }
       static _newHashTable() {
-        let table = _foreign_helper.JS('var', 'Object.create(null)');
+        let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _setTableEntry(table, temporaryKey, table);
         _deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     return _HashSet;
   });
   let _HashSet = _HashSet$(dynamic);
   let _IdentityHashSet$ = dart.generic(function(E) {
     class _IdentityHashSet extends _HashSet$(E) {
       _newSet() {
         return new _IdentityHashSet();
       }
       _computeHashCode(key) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', core.identityHashCode(key)), core.int);
+        return core.identityHashCode(key) & 0x3ffffff;
       }
       _findBucketIndex(bucket, element) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i++) {
-          if (core.identical(_foreign_helper.JS('var', '#[#]', bucket, i), element))
+          if (core.identical(bucket[i], element))
             return i;
         }
         return -1;
       }
     }
     return _IdentityHashSet;
   });
   let _IdentityHashSet = _IdentityHashSet$(dynamic);
   let _CustomHashSet$ = dart.generic(function(E) {
     class _CustomHashSet extends _HashSet$(E) {
       _CustomHashSet(_equality, _hasher, validKey) {
         this._equality = _equality;
         this._hasher = _hasher;
         this._validKey = dart.as(validKey !== null ? validKey : (x) => dart.is(x, E), _Predicate);
         super._HashSet();
       }
       _newSet() {
         return new _CustomHashSet(this._equality, this._hasher, this._validKey);
       }
       _findBucketIndex(bucket, element) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i++) {
-          if (this._equality(dart.as(_foreign_helper.JS('var', '#[#]', bucket, i), E), dart.as(element, E)))
+          if (this._equality(dart.as(bucket[i], E), dart.as(element, E)))
             return i;
         }
         return -1;
       }
       _computeHashCode(element) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', this._hasher(dart.as(element, E))), core.int);
+        return this._hasher(dart.as(element, E)) & 0x3ffffff;
       }
       add(object) {
         return super._add(object);
       }
       contains(object) {
         if (!dart.notNull(this._validKey(object)))
           return false;
         return super._contains(object);
       }
       lookup(object) {
@@ skipping 17 matching lines @@
         this._elements = _elements;
         this._offset = 0;
         this._current = dart.as(null, E);
       }
       get current() {
         return this._current;
       }
       moveNext() {
         let elements = this._elements;
         let offset = this._offset;
-        if (_foreign_helper.JS('bool', '# !== #', elements, dart.dload(this._set, '_elements'))) {
+        if (elements !== dart.dload(this._set, '_elements')) {
           throw new core.ConcurrentModificationError(this._set);
-        } else if (offset['>='](_foreign_helper.JS('int', '#.length', elements))) {
+        } else if (offset >= elements.length) {
           this._current = dart.as(null, E);
           return false;
         } else {
-          this._current = dart.as(_foreign_helper.JS('var', '#[#]', elements, offset), E);
-          this._offset = dart.as(_foreign_helper.JS('int', '#', offset + 1), core.int);
+          this._current = dart.as(elements[offset], E);
+          this._offset = offset + 1;
           return true;
         }
       }
     }
     return HashSetIterator;
   });
   let HashSetIterator = HashSetIterator$(dynamic);
   let _LinkedHashSet$ = dart.generic(function(E) {
     class _LinkedHashSet extends _HashSetBase$(E) {
       _LinkedHashSet() {
@@ skipping 99 matching lines @@
           return this._addHashTableEntry(nums, element);
         } else {
           return this._add(element);
         }
       }
       _add(element) {
         let rest = this._rest;
         if (rest === null)
           this._rest = rest = _newHashTable();
         let hash = this._computeHashCode(element);
-        let bucket = _foreign_helper.JS('var', '#[#]', rest, hash);
+        let bucket = rest[hash];
         if (bucket === null) {
           let cell = this._newLinkedCell(element);
-          _setTableEntry(rest, hash, _foreign_helper.JS('var', '[#]', cell));
+          _setTableEntry(rest, hash, [cell]);
         } else {
           let index = this._findBucketIndex(bucket, element);
           if (index >= 0)
             return false;
           let cell = this._newLinkedCell(element);
-          _foreign_helper.JS('void', '#.push(#)', bucket, cell);
+          bucket.push(cell);
         }
         return true;
       }
       remove(object) {
         if (_isStringElement(object)) {
           return this._removeHashTableEntry(this._strings, object);
         } else if (_isNumericElement(object)) {
           return this._removeHashTableEntry(this._nums, object);
         } else {
           return this._remove(object);
         }
       }
       _remove(object) {
         let rest = this._rest;
         if (rest === null)
           return false;
         let bucket = this._getBucket(rest, object);
         let index = this._findBucketIndex(bucket, object);
         if (index < 0)
           return false;
-        let cell = dart.as(_foreign_helper.JS('var', '#.splice(#, 1)[0]', bucket, index), LinkedHashSetCell);
+        let cell = dart.as(bucket.splice(index, 1)[0], LinkedHashSetCell);
         this._unlinkCell(cell);
         return true;
       }
       removeWhere(test) {
         this._filterWhere(test, true);
       }
       retainWhere(test) {
         this._filterWhere(test, false);
       }
       _filterWhere(test, removeMatching) {
@@ skipping 66 matching lines @@
         } else {
           next._previous = previous;
         }
         this._length--;
         this._modified();
       }
       static _isStringElement(element) {
         return dart.notNull(typeof element == string) && dart.notNull(!dart.equals(element, '__proto__'));
       }
       static _isNumericElement(element) {
-        return core.bool['&&'](dart.is(element, core.num), _foreign_helper.JS('bool', '(# & 0x3ffffff) === #', element, element));
+        return dart.notNull(dart.is(element, core.num)) && dart.notNull((element & 0x3ffffff) === element);
       }
       _computeHashCode(element) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', dart.dload(element, 'hashCode')), core.int);
+        return dart.dload(element, 'hashCode') & 0x3ffffff;
       }
       static _getTableEntry(table, key) {
-        return _foreign_helper.JS('var', '#[#]', table, key);
+        return table[key];
       }
       static _setTableEntry(table, key, value) {
         dart.assert(value !== null);
-        _foreign_helper.JS('void', '#[#] = #', table, key, value);
+        table[key] = value;
       }
       static _deleteTableEntry(table, key) {
-        _foreign_helper.JS('void', 'delete #[#]', table, key);
+        delete table[key];
       }
       _getBucket(table, element) {
         let hash = this._computeHashCode(element);
-        return dart.as(_foreign_helper.JS('var', '#[#]', table, hash), core.List);
+        return dart.as(table[hash], core.List);
       }
       _findBucketIndex(bucket, element) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i++) {
-          let cell = dart.as(_foreign_helper.JS('var', '#[#]', bucket, i), LinkedHashSetCell);
+          let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (dart.equals(cell._element, element))
             return i;
         }
         return -1;
       }
       static _newHashTable() {
-        let table = _foreign_helper.JS('var', 'Object.create(null)');
+        let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _setTableEntry(table, temporaryKey, table);
         _deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     return _LinkedHashSet;
   });
   let _LinkedHashSet = _LinkedHashSet$(dynamic);
   let _LinkedIdentityHashSet$ = dart.generic(function(E) {
     class _LinkedIdentityHashSet extends _LinkedHashSet$(E) {
       _newSet() {
         return new _LinkedIdentityHashSet();
       }
       _computeHashCode(key) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', core.identityHashCode(key)), core.int);
+        return core.identityHashCode(key) & 0x3ffffff;
       }
       _findBucketIndex(bucket, element) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i++) {
-          let cell = dart.as(_foreign_helper.JS('var', '#[#]', bucket, i), LinkedHashSetCell);
+          let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (core.identical(cell._element, element))
             return i;
         }
         return -1;
       }
     }
     return _LinkedIdentityHashSet;
   });
   let _LinkedIdentityHashSet = _LinkedIdentityHashSet$(dynamic);
   let _LinkedCustomHashSet$ = dart.generic(function(E) {
     class _LinkedCustomHashSet extends _LinkedHashSet$(E) {
       _LinkedCustomHashSet(_equality, _hasher, validKey) {
         this._equality = _equality;
         this._hasher = _hasher;
         this._validKey = dart.as(validKey !== null ? validKey : (x) => dart.is(x, E), _Predicate);
         super._LinkedHashSet();
       }
       _newSet() {
         return new _LinkedCustomHashSet(this._equality, this._hasher, this._validKey);
       }
       _findBucketIndex(bucket, element) {
         if (bucket === null)
           return -1;
-        let length = dart.as(_foreign_helper.JS('int', '#.length', bucket), core.int);
+        let length = bucket.length;
         for (let i = 0; i < length; i++) {
-          let cell = dart.as(_foreign_helper.JS('var', '#[#]', bucket, i), LinkedHashSetCell);
+          let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (this._equality(dart.as(cell._element, E), dart.as(element, E)))
             return i;
         }
         return -1;
       }
       _computeHashCode(element) {
-        return dart.as(_foreign_helper.JS('int', '# & 0x3ffffff', this._hasher(dart.as(element, E))), core.int);
+        return this._hasher(dart.as(element, E)) & 0x3ffffff;
       }
       add(element) {
         return super._add(element);
       }
       contains(object) {
         if (!dart.notNull(this._validKey(object)))
           return false;
         return super._contains(object);
       }
       lookup(object) {
@@ skipping 3342 matching lines @@
   collection.ListQueue$ = ListQueue$;
   collection.SetMixin = SetMixin;
   collection.SetMixin$ = SetMixin$;
   collection.SetBase = SetBase;
   collection.SetBase$ = SetBase$;
   collection.SplayTreeMap = SplayTreeMap;
   collection.SplayTreeMap$ = SplayTreeMap$;
   collection.SplayTreeSet = SplayTreeSet;
   collection.SplayTreeSet$ = SplayTreeSet$;
 })(collection || (collection = {}));