allow JS builtin to be typed as needed

lib/runtime/dart/collection.js

 dart_library.library('dart/collection', null, /* Imports */[
   'dart/_runtime',
   'dart/core'
 ], /* Lazy imports */[
   'dart/_internal',
   'dart/_js_helper',
   'dart/math'
 ], function(exports, dart, core, _internal, _js_helper, math) {
   'use strict';
   let dartx = dart.dartx;
@@ skipping 4103 matching lines @@
         }
       }
       [_remove](key) {
         let rest = this[_rest];
         if (rest == null) return null;
         let bucket = this[_getBucket](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         if (dart.notNull(index) < 0) return null;
         this[_length] = dart.notNull(this[_length]) - 1;
         this[_keys] = null;
-        return dart.as(bucket.splice(index, 2)[1], V);
+        return bucket.splice(index, 2)[1];
       }
       clear() {
         if (dart.notNull(this[_length]) > 0) {
           this[_strings] = this[_nums] = this[_rest] = this[_keys] = null;
           this[_length] = 0;
         }
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [K, V]));
         let keys = this[_computeKeys]();
@@ skipping 89 matching lines @@
           table[key] = table;
         } else {
           table[key] = value;
         }
       }
       static _deleteTableEntry(table, key) {
         delete table[key];
       }
       [_getBucket](table, key) {
         let hash = this[_computeHashCode](key);
-        return dart.as(table[hash], core.List);
+        return table[hash];
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null) return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 2) {
           if (dart.equals(bucket[i], key)) return i;
         }
         return -1;
       }
       static _newHashTable() {
@@ skipping 90 matching lines @@
         if (!dart.notNull(this[_validKey](key))) return null;
         return super[_remove](key);
       }
       [_computeHashCode](key) {
         return this[_hashCode](dart.as(key, K)) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null) return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 2) {
-          if (dart.notNull(this[_equals](dart.as(bucket[i], K), dart.as(key, K)))) return i;
+          if (dart.notNull(this[_equals](bucket[i], dart.as(key, K)))) return i;
         }
         return -1;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     dart.setSignature(_CustomHashMap, {
       constructors: () => ({_CustomHashMap: [_CustomHashMap$(K, V), [_Equality$(K), _Hasher$(K), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
@@ skipping 20 matching lines @@
       get iterator() {
         return new (HashMapKeyIterator$(E))(this[_map], dart.as(dart.dsend(this[_map], _computeKeys), core.List));
       }
       contains(element) {
         return dart.as(dart.dsend(this[_map], 'containsKey', element), core.bool);
       }
       forEach(f) {
         dart.as(f, dart.functionType(dart.void, [E]));
         let keys = dart.as(dart.dsend(this[_map], _computeKeys), core.List);
         for (let i = 0, length = keys.length; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          f(dart.as(keys[i], E));
+          f(keys[i]);
           if (keys !== dart.dload(this[_map], _keys)) {
             dart.throw(new core.ConcurrentModificationError(this[_map]));
           }
         }
       }
     }
     HashMapKeyIterable[dart.implements] = () => [_internal.EfficientLength];
     dart.setSignature(HashMapKeyIterable, {
       constructors: () => ({HashMapKeyIterable: [HashMapKeyIterable$(E), [dart.dynamic]]}),
       methods: () => ({forEach: [dart.void, [dart.functionType(dart.void, [E])]]})
@@ skipping 22 matching lines @@
       }
       moveNext() {
         let keys = this[_keys];
         let offset = this[_offset];
         if (keys !== dart.dload(this[_map], _keys)) {
           dart.throw(new core.ConcurrentModificationError(this[_map]));
         } else if (dart.notNull(offset) >= keys.length) {
           this[_current] = null;
           return false;
         } else {
-          this[_current] = dart.as(keys[offset], E);
+          this[_current] = keys[offset];
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
     HashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(HashMapKeyIterator, {
       constructors: () => ({HashMapKeyIterator: [HashMapKeyIterator$(E), [dart.dynamic, core.List]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
@@ skipping 78 matching lines @@
         } else {
           return this[_get](key);
         }
       }
       [_get](key) {
         let rest = this[_rest];
         if (rest == null) return null;
         let bucket = this[_getBucket](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         if (dart.notNull(index) < 0) return null;
-        let cell = dart.as(bucket[index], LinkedHashMapCell);
+        let cell = bucket[index];
         return dart.as(cell[_value], V);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
         if (dart.notNull(_LinkedHashMap$()._isStringKey(key))) {
           let strings = this[_strings];
           if (strings == null) this[_strings] = strings = _LinkedHashMap$()._newHashTable();
           this[_addHashTableEntry](strings, key, value);
         } else if (dart.notNull(_LinkedHashMap$()._isNumericKey(key))) {
@@ skipping 11 matching lines @@
         let rest = this[_rest];
         if (rest == null) this[_rest] = rest = _LinkedHashMap$()._newHashTable();
         let hash = this[_computeHashCode](key);
         let bucket = rest[hash];
         if (bucket == null) {
           let cell = this[_newLinkedCell](key, value);
           _LinkedHashMap$()._setTableEntry(rest, hash, [cell]);
         } else {
           let index = this[_findBucketIndex](bucket, key);
           if (dart.notNull(index) >= 0) {
-            let cell = dart.as(bucket[index], LinkedHashMapCell);
+            let cell = bucket[index];
             cell[_value] = value;
           } else {
             let cell = this[_newLinkedCell](key, value);
             bucket.push(cell);
           }
         }
       }
       putIfAbsent(key, ifAbsent) {
         dart.as(key, K);
         dart.as(ifAbsent, dart.functionType(V, []));
@@ skipping 10 matching lines @@
         } else {
           return this[_remove](key);
         }
       }
       [_remove](key) {
         let rest = this[_rest];
         if (rest == null) return null;
         let bucket = this[_getBucket](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         if (dart.notNull(index) < 0) return null;
-        let cell = dart.as(bucket.splice(index, 1)[0], LinkedHashMapCell);
+        let cell = bucket.splice(index, 1)[0];
         this[_unlinkCell](cell);
         return dart.as(cell[_value], V);
       }
       clear() {
         if (dart.notNull(this[_length]) > 0) {
           this[_strings] = this[_nums] = this[_rest] = this[_first] = this[_last] = null;
           this[_length] = 0;
           this[_modified]();
         }
       }
@@ skipping 77 matching lines @@
       }
       static _setTableEntry(table, key, value) {
         dart.assert(value != null);
         table[key] = value;
       }
       static _deleteTableEntry(table, key) {
         delete table[key];
       }
       [_getBucket](table, key) {
         let hash = this[_computeHashCode](key);
-        return dart.as(table[hash], core.List);
+        return table[hash];
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null) return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          let cell = dart.as(bucket[i], LinkedHashMapCell);
+          let cell = bucket[i];
           if (dart.equals(cell[_key], key)) return i;
         }
         return -1;
       }
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _LinkedHashMap$()._setTableEntry(table, temporaryKey, table);
         _LinkedHashMap$()._deleteTableEntry(table, temporaryKey);
         return table;
@@ skipping 46 matching lines @@
       _LinkedIdentityHashMap() {
         super._LinkedHashMap();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null) return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          let cell = dart.as(bucket[i], LinkedHashMapCell);
+          let cell = bucket[i];
           if (dart.notNull(core.identical(cell[_key], key))) return i;
         }
         return -1;
       }
     }
     return _LinkedIdentityHashMap;
   });
   let _LinkedIdentityHashMap = _LinkedIdentityHashMap$();
   const _LinkedCustomHashMap$ = dart.generic(function(K, V) {
     class _LinkedCustomHashMap extends _LinkedHashMap$(K, V) {
@@ skipping 21 matching lines @@
         if (!dart.notNull(this[_validKey](key))) return null;
         return super[_remove](key);
       }
       [_computeHashCode](key) {
         return this[_hashCode](dart.as(key, K)) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null) return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          let cell = dart.as(bucket[i], LinkedHashMapCell);
+          let cell = bucket[i];
           if (dart.notNull(this[_equals](dart.as(cell[_key], K), dart.as(key, K)))) return i;
         }
         return -1;
       }
     }
     dart.setSignature(_LinkedCustomHashMap, {
       constructors: () => ({_LinkedCustomHashMap: [_LinkedCustomHashMap$(K, V), [_Equality$(K), _Hasher$(K), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
         get: [V, [core.Object]],
         set: [dart.void, [K, V]],
@@ skipping 290 matching lines @@
       }
       static _setTableEntry(table, key, value) {
         dart.assert(value != null);
         table[key] = value;
       }
       static _deleteTableEntry(table, key) {
         delete table[key];
       }
       [_getBucket](table, element) {
         let hash = this[_computeHashCode](element);
-        return dart.as(table[hash], core.List);
+        return table[hash];
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null) return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (dart.equals(bucket[i], element)) return i;
         }
         return -1;
       }
       static _newHashTable() {
@@ skipping 81 matching lines @@
         this[_validKey] = dart.as(validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [core.Object]), _Predicate$(core.Object));
         super._HashSet();
       }
       [_newSet]() {
         return new (_CustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null) return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          if (dart.notNull(this[_equality](dart.as(bucket[i], E), dart.as(element, E)))) return i;
+          if (dart.notNull(this[_equality](bucket[i], dart.as(element, E)))) return i;
         }
         return -1;
       }
       [_computeHashCode](element) {
         return this[_hasher](dart.as(element, E)) & 0x3ffffff;
       }
       add(object) {
         dart.as(object, E);
         return super[_add](object);
       }
@@ skipping 35 matching lines @@
       }
       moveNext() {
         let elements = this[_elements];
         let offset = this[_offset];
         if (elements !== dart.dload(this[_set], _elements)) {
           dart.throw(new core.ConcurrentModificationError(this[_set]));
         } else if (dart.notNull(offset) >= elements.length) {
           this[_current] = null;
           return false;
         } else {
-          this[_current] = dart.as(elements[offset], E);
+          this[_current] = elements[offset];
           this[_offset] = dart.notNull(offset) + 1;
           return true;
         }
       }
     }
     HashSetIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(HashSetIterator, {
       constructors: () => ({HashSetIterator: [HashSetIterator$(E), [dart.dynamic, core.List]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
@@ skipping 125 matching lines @@
         } 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 (dart.notNull(index) < 0) return false;
-        let cell = dart.as(bucket.splice(index, 1)[0], LinkedHashSetCell);
+        let cell = bucket.splice(index, 1)[0];
         this[_unlinkCell](cell);
         return true;
       }
       removeWhere(test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         this[_filterWhere](test, true);
       }
       retainWhere(test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         this[_filterWhere](test, false);
@@ skipping 84 matching lines @@
       }
       static _setTableEntry(table, key, value) {
         dart.assert(value != null);
         table[key] = value;
       }
       static _deleteTableEntry(table, key) {
         delete table[key];
       }
       [_getBucket](table, element) {
         let hash = this[_computeHashCode](element);
-        return dart.as(table[hash], core.List);
+        return table[hash];
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null) return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          let cell = dart.as(bucket[i], LinkedHashSetCell);
+          let cell = bucket[i];
           if (dart.equals(cell[_element], element)) return i;
         }
         return -1;
       }
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
         _LinkedHashSet$()._setTableEntry(table, temporaryKey, table);
         _LinkedHashSet$()._deleteTableEntry(table, temporaryKey);
         return table;
@@ skipping 57 matching lines @@
       [_newSet]() {
         return new (_LinkedIdentityHashSet$(E))();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null) return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          let cell = dart.as(bucket[i], LinkedHashSetCell);
+          let cell = bucket[i];
           if (dart.notNull(core.identical(cell[_element], element))) return i;
         }
         return -1;
       }
     }
     dart.setSignature(_LinkedIdentityHashSet, {
       methods: () => ({[_newSet]: [core.Set$(E), []]})
     });
     return _LinkedIdentityHashSet;
   });
   let _LinkedIdentityHashSet = _LinkedIdentityHashSet$();
   const _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 : dart.fn(x => dart.is(x, E), core.bool, [core.Object]), _Predicate$(core.Object));
         super._LinkedHashSet();
       }
       [_newSet]() {
         return new (_LinkedCustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null) return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          let cell = dart.as(bucket[i], LinkedHashSetCell);
+          let cell = bucket[i];
           if (dart.notNull(this[_equality](dart.as(cell[_element], E), dart.as(element, E)))) return i;
         }
         return -1;
       }
       [_computeHashCode](element) {
         return this[_hasher](dart.as(element, E)) & 0x3ffffff;
       }
       add(element) {
         dart.as(element, E);
         return super[_add](element);
@@ skipping 138 matching lines @@
   exports.LinkedHashMapKeyIterable$ = LinkedHashMapKeyIterable$;
   exports.LinkedHashMapKeyIterable = LinkedHashMapKeyIterable;
   exports.LinkedHashMapKeyIterator$ = LinkedHashMapKeyIterator$;
   exports.LinkedHashMapKeyIterator = LinkedHashMapKeyIterator;
   exports.HashSetIterator$ = HashSetIterator$;
   exports.HashSetIterator = HashSetIterator;
   exports.LinkedHashSetCell = LinkedHashSetCell;
   exports.LinkedHashSetIterator$ = LinkedHashSetIterator$;
   exports.LinkedHashSetIterator = LinkedHashSetIterator;
 });