add checks needed for covariant generics, and List<E>

lib/runtime/dart/core.js

 var core;
 (function(exports) {
   'use strict';
   class Object {
     constructor() {
       let name = this.constructor.name;
       let init = this[name];
       let result = void 0;
       if (init)
         result = init.apply(this, arguments);
@@ skipping 1005 matching lines @@
         this.name = name;
       }
       toString() {
         return `Expando:${this.name}`;
       }
       get(object) {
         let values = _js_helper.Primitives.getProperty(object, Expando._EXPANDO_PROPERTY_NAME);
         return dart.as(values == null ? null : _js_helper.Primitives.getProperty(values, this[_getKey]()), T);
       }
       set(object, value) {
+        dart.as(value, T);
         let values = _js_helper.Primitives.getProperty(object, Expando._EXPANDO_PROPERTY_NAME);
         if (values == null) {
           values = new Object();
           _js_helper.Primitives.setProperty(object, Expando._EXPANDO_PROPERTY_NAME, values);
         }
         _js_helper.Primitives.setProperty(values, this[_getKey](), value);
       }
       [_getKey]() {
         let key = dart.as(_js_helper.Primitives.getProperty(this, Expando._KEY_PROPERTY_NAME), String);
         if (key == null) {
@@ skipping 216 matching lines @@
   let $setRange = dart.JsSymbol('$setRange');
   let $removeRange = dart.JsSymbol('$removeRange');
   let $fillRange = dart.JsSymbol('$fillRange');
   let $replaceRange = dart.JsSymbol('$replaceRange');
   let $asMap = dart.JsSymbol('$asMap');
   let List$ = dart.generic(function(E) {
     class List extends Object {
       List(length) {
         if (length === void 0)
           length = null;
+        let list = null;
         if (length == null) {
-          return dart.as([], List$(E));
+          list = [];
+        } else {
+          if (!(typeof length == 'number') || dart.notNull(length) < 0) {
+            throw new ArgumentError(`Length must be a non-negative integer: ${length}`);
+          }
+          list = new Array(length);
+          list.fixed$length = Array;
         }
-        if (!(typeof length == 'number') || dart.notNull(length) < 0) {
-          throw new ArgumentError(`Length must be a non-negative integer: ${length}`);
-        }
-        let list = new Array(length);
-        list.fixed$length = Array;
+        dart.setType(list, List$(E));
         return dart.as(list, List$(E));
       }
       filled(length, fill) {
-        let result = new _interceptors.JSArray$(E).fixed(length);
+        let result = new (List$(E))(length);
         if (length != 0 && dart.notNull(fill != null)) {
           for (let i = 0; dart.notNull(i) < dart.notNull(result[$length]); i = dart.notNull(i) + 1) {
             result[$set](i, fill);
           }
         }
         return dart.as(result, List$(E));
       }
       from(elements, opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let list = new (List$(E))();
@@ skipping 14 matching lines @@
           result = new (List$(E))(length);
         }
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result[$set](i, generator(i));
         }
         return result;
       }
       [$checkMutable](reason) {}
       [$checkGrowable](reason) {}
       [$where](f) {
+        dart.as(f, dart.functionType(bool, [E]));
         return new (_internal.IterableMixinWorkaround$(E))().where(this, f);
       }
       [$expand](f) {
+        dart.as(f, dart.functionType(Iterable, [E]));
         return _internal.IterableMixinWorkaround.expand(this, f);
       }
       [$forEach](f) {
+        dart.as(f, dart.functionType(dart.void, [E]));
         let length = this[$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           f(dart.as(this[i], E));
           if (length != this[$length]) {
             throw new ConcurrentModificationError(this);
           }
         }
       }
       [$map](f) {
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
         return _internal.IterableMixinWorkaround.mapList(this, f);
       }
       [$join](separator) {
         if (separator === void 0)
           separator = "";
         let list = new List(this[$length]);
         for (let i = 0; dart.notNull(i) < dart.notNull(this[$length]); i = dart.notNull(i) + 1) {
           list[$set](i, `${this[$get](i)}`);
         }
         return list.join(separator);
       }
       [$take](n) {
         return new (_internal.IterableMixinWorkaround$(E))().takeList(this, n);
       }
       [$takeWhile](test) {
+        dart.as(test, dart.functionType(bool, [E]));
         return new (_internal.IterableMixinWorkaround$(E))().takeWhile(this, test);
       }
       [$skip](n) {
         return new (_internal.IterableMixinWorkaround$(E))().skipList(this, n);
       }
       [$skipWhile](test) {
+        dart.as(test, dart.functionType(bool, [E]));
         return new (_internal.IterableMixinWorkaround$(E))().skipWhile(this, test);
       }
       [$reduce](combine) {
+        dart.as(combine, dart.functionType(E, [E, E]));
         return dart.as(_internal.IterableMixinWorkaround.reduce(this, combine), E);
       }
       [$fold](initialValue, combine) {
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
         return _internal.IterableMixinWorkaround.fold(this, initialValue, combine);
       }
       [$firstWhere](test, opts) {
+        dart.as(test, dart.functionType(bool, [E]));
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
+        dart.as(orElse, dart.functionType(E, []));
         return dart.as(_internal.IterableMixinWorkaround.firstWhere(this, test, orElse), E);
       }
       [$lastWhere](test, opts) {
+        dart.as(test, dart.functionType(bool, [E]));
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
+        dart.as(orElse, dart.functionType(E, []));
         return dart.as(_internal.IterableMixinWorkaround.lastWhereList(this, test, orElse), E);
       }
       [$singleWhere](test) {
+        dart.as(test, dart.functionType(bool, [E]));
         return dart.as(_internal.IterableMixinWorkaround.singleWhere(this, test), E);
       }
       [$elementAt](index) {
         return this[$get](index);
       }
       get [$first]() {
         if (dart.notNull(this[$length]) > 0)
           return this[$get](0);
         throw new StateError("No elements");
       }
       get [$last]() {
         if (dart.notNull(this[$length]) > 0)
           return this[$get](dart.notNull(this[$length]) - 1);
         throw new StateError("No elements");
       }
       get [$single]() {
         if (this[$length] == 1)
           return this[$get](0);
         if (this[$length] == 0)
           throw new StateError("No elements");
         throw new StateError("More than one element");
       }
       [$any](f) {
+        dart.as(f, dart.functionType(bool, [E]));
         return _internal.IterableMixinWorkaround.any(this, f);
       }
       [$every](f) {
+        dart.as(f, dart.functionType(bool, [E]));
         return _internal.IterableMixinWorkaround.every(this, f);
       }
       [$sort](compare) {
         if (compare === void 0)
           compare = null;
+        dart.as(compare, dart.functionType(int, [E, E]));
         this[$checkMutable]('sort');
         _internal.IterableMixinWorkaround.sortList(this, compare);
       }
       [$contains](other) {
         for (let i = 0; dart.notNull(i) < dart.notNull(this[$length]); i = dart.notNull(i) + 1) {
           if (dart.equals(this[$get](i), other))
             return true;
         }
         return false;
       }
@@ skipping 24 matching lines @@
         return _js_helper.Primitives.objectHashCode(this);
       }
       [$get](index) {
         if (!(typeof index == 'number'))
           throw new ArgumentError(index);
         if (dart.notNull(index) >= dart.notNull(this[$length]) || dart.notNull(index) < 0)
           throw new RangeError.value(index);
         return dart.as(this[index], E);
       }
       [$set](index, value) {
+        dart.as(value, E);
         this[$checkMutable]('indexed set');
         if (!(typeof index == 'number'))
           throw new ArgumentError(index);
         if (dart.notNull(index) >= dart.notNull(this[$length]) || dart.notNull(index) < 0)
           throw new RangeError.value(index);
         this[index] = value;
       }
       get [$length]() {
         return dart.as(this.length, int);
       }
       set [$length](newLength) {
         if (!(typeof newLength == 'number'))
           throw new ArgumentError(newLength);
         if (dart.notNull(newLength) < 0)
           throw new RangeError.value(newLength);
         this[$checkGrowable]('set length');
         this.length = newLength;
       }
       [$add](value) {
+        dart.as(value, E);
         this[$checkGrowable]('add');
         this.push(value);
       }
       [$addAll](iterable) {
+        dart.as(iterable, Iterable$(E));
         for (let e of iterable) {
           this[$add](e);
         }
       }
       get [$reversed]() {
         return new (_internal.IterableMixinWorkaround$(E))().reversedList(this);
       }
       [$sort](compare) {
         if (compare === void 0)
           compare = null;
+        dart.as(compare, dart.functionType(int, [E, E]));
         _internal.IterableMixinWorkaround.sortList(this, compare);
       }
       [$shuffle](random) {
         if (random === void 0)
           random = null;
         _internal.IterableMixinWorkaround.shuffleList(this, random);
       }
       [$indexOf](element, start) {
+        dart.as(element, E);
         if (start === void 0)
           start = 0;
         return _internal.IterableMixinWorkaround.indexOfList(this, element, start);
       }
       [$lastIndexOf](element, start) {
+        dart.as(element, E);
         if (start === void 0)
           start = null;
         return _internal.IterableMixinWorkaround.lastIndexOfList(this, element, start);
       }
       [$clear]() {
         this[$length] = 0;
       }
       [$insert](index, element) {
+        dart.as(element, E);
         if (!(typeof index == 'number'))
           throw new ArgumentError(index);
         if (dart.notNull(index) < 0 || dart.notNull(index) > dart.notNull(this[$length])) {
           throw new RangeError.value(index);
         }
         this[$checkGrowable]('insert');
         this.splice(index, 0, element);
       }
       [$insertAll](index, iterable) {
+        dart.as(iterable, Iterable$(E));
         this[$checkGrowable]('insertAll');
         _internal.IterableMixinWorkaround.insertAllList(this, index, iterable);
       }
       [$setAll](index, iterable) {
+        dart.as(iterable, Iterable$(E));
         this[$checkMutable]('setAll');
         _internal.IterableMixinWorkaround.setAllList(this, index, iterable);
       }
       [$remove](element) {
         this[$checkGrowable]('remove');
         for (let i = 0; dart.notNull(i) < dart.notNull(this[$length]); i = dart.notNull(i) + 1) {
           if (dart.equals(this[$get](i), /* Unimplemented unknown name */value)) {
             this.splice(i, 1);
             return true;
           }
         }
         return false;
       }
       [$removeAt](index) {
         if (!(typeof index == 'number'))
           throw new ArgumentError(index);
         if (dart.notNull(index) < 0 || dart.notNull(index) >= dart.notNull(this[$length])) {
           throw new RangeError.value(index);
         }
         this[$checkGrowable]('removeAt');
         return dart.as(this.splice(index, 1)[0], E);
       }
       [$removeLast]() {
         this[$checkGrowable]('removeLast');
         if (this[$length] == 0)
           throw new RangeError.value(-1);
         return dart.as(this.pop(), E);
       }
       [$removeWhere](test) {
+        dart.as(test, dart.functionType(bool, [E]));
         _internal.IterableMixinWorkaround.removeWhereList(this, test);
       }
       [$retainWhere](test) {
+        dart.as(test, dart.functionType(bool, [E]));
         _internal.IterableMixinWorkaround.removeWhereList(this, element => !dart.notNull(test(element)));
       }
       [$sublist](start, end) {
         if (end === void 0)
           end = null;
         dart.dcall(/* Unimplemented unknown name */checkNull, start);
         if (!(typeof start == 'number'))
           throw new ArgumentError(start);
         if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(this[$length])) {
           throw new RangeError.range(start, 0, this[$length]);
         }
         if (end == null) {
           end = this[$length];
         } else {
           if (!(typeof end == 'number'))
             throw new ArgumentError(end);
           if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(this[$length])) {
             throw new RangeError.range(end, start, this[$length]);
           }
         }
         if (start == end)
           return dart.setType([], List$(E));
         return new _interceptors.JSArray$(E).markGrowable(this.slice(start, end));
       }
       [$getRange](start, end) {
         return new (_internal.IterableMixinWorkaround$(E))().getRangeList(this, start, end);
       }
       [$setRange](start, end, iterable, skipCount) {
+        dart.as(iterable, Iterable$(E));
         if (skipCount === void 0)
           skipCount = 0;
         this[$checkMutable]('set range');
         _internal.IterableMixinWorkaround.setRangeList(this, start, end, iterable, skipCount);
       }
       [$removeRange](start, end) {
         this[$checkGrowable]('removeRange');
         let receiverLength = this[$length];
         if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(receiverLength)) {
           throw new RangeError.range(start, 0, receiverLength);
         }
         if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(receiverLength)) {
           throw new RangeError.range(end, start, receiverLength);
         }
         _internal.Lists.copy(this, end, this, start, dart.notNull(receiverLength) - dart.notNull(end));
         this[$length] = dart.notNull(receiverLength) - (dart.notNull(end) - dart.notNull(start));
       }
       [$fillRange](start, end, fillValue) {
         if (fillValue === void 0)
           fillValue = null;
+        dart.as(fillValue, E);
         this[$checkMutable]('fill range');
         _internal.IterableMixinWorkaround.fillRangeList(this, start, end, fillValue);
       }
       [$replaceRange](start, end, replacement) {
+        dart.as(replacement, Iterable$(E));
         this[$checkGrowable]('removeRange');
         _internal.IterableMixinWorkaround.replaceRangeList(this, start, end, replacement);
       }
       [$asMap]() {
         return new (_internal.IterableMixinWorkaround$(E))().asMapList(this);
       }
     }
+    dart.setBaseClass(List, dart.global.Array);
     List[dart.implements] = () => [Iterable$(E), _internal.EfficientLength];
     dart.defineNamedConstructor(List, 'filled');
     dart.defineNamedConstructor(List, 'from');
     dart.defineNamedConstructor(List, 'generate');
     return List;
   });
   let List = List$();
   dart.registerExtension(dart.global.Array, List);
   let Map$ = dart.generic(function(K, V) {
     class Map extends Object {
@@ skipping 1839 matching lines @@
   exports.StackTrace = StackTrace;
   exports.Stopwatch = Stopwatch;
   exports.String = String;
   exports.RuneIterator = RuneIterator;
   exports.StringBuffer = StringBuffer;
   exports.StringSink = StringSink;
   exports.Symbol = Symbol;
   exports.Type = Type;
   exports.Uri = Uri;
 })(core || (core = {}));