Typecheck constructor initializers properly

test/codegen/expect/_internal/_internal.js

 var _internal;
 (function(_internal) {
   'use strict';
   let POWERS_OF_TEN = /* Unimplemented const */new List.from([1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0, 1e+21, 1e+22]);
   class EfficientLength extends dart.Object {
   }
   let ListIterable$ = dart.generic(function(E) {
     class ListIterable extends collection.IterableBase$(E) {
       ListIterable() {
         super.IterableBase();
@@ skipping 142 matching lines @@
               throw new core.ConcurrentModificationError(this);
             }
           }
           return buffer.toString();
         }
       }
       where(test) {
         return super.where(test);
       }
       map(f) {
-        return new MappedListIterable(this, f);
+        return new MappedListIterable(this, dart.as(f, dart.throw_("Unimplemented type (dynamic) → dynamic")));
       }
       reduce(combine) {
         let length = this.length;
         if (length === 0)
           throw IterableElementError.noElement();
         let value = this.elementAt(0);
         for (let i = 1; i < length; i++) {
           value = combine(value, this.elementAt(i));
           if (length !== this.length) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       fold(initialValue, combine) {
         let value = initialValue;
         let length = this.length;
         for (let i = 0; i < length; i++) {
           value = combine(value, this.elementAt(i));
           if (length !== this.length) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       skip(count) {
-        return new SubListIterable(this, count, null);
+        return new SubListIterable(this, count, dart.as(null, core.int));
       }
       skipWhile(test) {
         return super.skipWhile(test);
       }
       take(count) {
         return new SubListIterable(this, 0, count);
       }
       takeWhile(test) {
         return super.takeWhile(test);
       }
@@ skipping 137 matching lines @@
     }
     return ListIterator;
   });
   let ListIterator = ListIterator$(dynamic);
   let MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
       MappedIterable(iterable, function) {
         if (dart.is(iterable, EfficientLength)) {
           return new EfficientLengthMappedIterable(iterable, function);
         }
-        return new MappedIterable._(iterable, function);
+        return new MappedIterable._(dart.as(iterable, core.Iterable$(S)), function);
       }
       MappedIterable$_(_iterable, _f) {
         this._iterable = _iterable;
         this._f = _f;
         super.IterableBase();
       }
       get iterator() {
         return new MappedIterator(this._iterable.iterator, this._f);
       }
       get length() {
@@ skipping 105 matching lines @@
   });
   let WhereIterator = WhereIterator$(dynamic);
   let ExpandIterable$ = dart.generic(function(S, T) {
     class ExpandIterable extends collection.IterableBase$(T) {
       ExpandIterable(_iterable, _f) {
         this._iterable = _iterable;
         this._f = _f;
         super.IterableBase();
       }
       get iterator() {
-        return new ExpandIterator(this._iterable.iterator, this._f);
+        return new ExpandIterator(this._iterable.iterator, dart.as(this._f, dart.throw_("Unimplemented type (S) → Iterable<T>")));
       }
     }
     return ExpandIterable;
   });
   let ExpandIterable = ExpandIterable$(dynamic, dynamic);
   let ExpandIterator$ = dart.generic(function(S, T) {
     class ExpandIterator extends dart.Object {
       ExpandIterator(_iterator, _f) {
         this._iterator = _iterator;
         this._f = _f;
@@ skipping 527 matching lines @@
         } else {
           buffer.write(list.get(0));
           for (let i = 1; i < list.length; i++) {
             buffer.write(separator);
             buffer.write(list.get(i));
           }
         }
         return buffer.toString();
       }
       where(iterable, f) {
-        return new WhereIterable(iterable, f);
+        return new WhereIterable(dart.as(iterable, core.Iterable$(T)), f);
       }
       static map(iterable, f) {
         return new MappedIterable(iterable, f);
       }
       static mapList(list, f) {
         return new MappedListIterable(list, f);
       }
       static expand(iterable, f) {
         return new ExpandIterable(iterable, f);
       }
       takeList(list, n) {
-        return new SubListIterable(list, 0, n);
+        return new SubListIterable(dart.as(list, core.Iterable$(T)), 0, n);
       }
       takeWhile(iterable, test) {
-        return new TakeWhileIterable(iterable, test);
+        return new TakeWhileIterable(dart.as(iterable, core.Iterable$(T)), test);
       }
       skipList(list, n) {
-        return new SubListIterable(list, n, null);
+        return new SubListIterable(dart.as(list, core.Iterable$(T)), n, dart.as(null, core.int));
       }
       skipWhile(iterable, test) {
-        return new SkipWhileIterable(iterable, test);
+        return new SkipWhileIterable(dart.as(iterable, core.Iterable$(T)), test);
       }
       reversedList(list) {
-        return new ReversedListIterable(list);
+        return new ReversedListIterable(dart.as(list, core.Iterable$(T)));
       }
       static sortList(list, compare) {
         if (compare === null)
           compare = dart.as(core.Comparable.compare, dart.throw_("Unimplemented type (dynamic, dynamic) → int"));
         Sort.sort(list, compare);
       }
       static shuffleList(list, random) {
         if (random === null)
           random = new math.Random();
         let length = list.length;
@@ skipping 11 matching lines @@
       static lastIndexOfList(list, element, start) {
         if (start === null)
           start = list.length - 1;
         return Lists.lastIndexOf(list, element, start);
       }
       static _rangeCheck(list, start, end) {
         core.RangeError.checkValidRange(start, end, list.length);
       }
       getRangeList(list, start, end) {
         _rangeCheck(list, start, end);
-        return new SubListIterable(list, start, end);
+        return new SubListIterable(dart.as(list, core.Iterable$(T)), start, end);
       }
       static setRangeList(list, start, end, from, skipCount) {
         _rangeCheck(list, start, end);
         let length = end - start;
         if (length === 0)
           return;
         if (skipCount < 0)
           throw new core.ArgumentError(skipCount);
         let otherList = null;
         let otherStart = null;
@@ skipping 52 matching lines @@
           list.set(index++, element);
         }
       }
       static setAllList(list, index, iterable) {
         core.RangeError.checkValueInInterval(index, 0, list.length, "index");
         for (let element of iterable) {
           list.set(index++, element);
         }
       }
       asMapList(l) {
-        return new ListMapView(l);
+        return new ListMapView(dart.as(l, core.List$(T)));
       }
       static setContainsAll(set, other) {
         for (let element of other) {
           if (!dart.notNull(set.contains(element)))
             return false;
         }
         return true;
       }
       static setIntersection(set, other, result) {
         let smaller = null;
@@ skipping 186 matching lines @@
       ListMapView(_values) {
         this._values = _values;
       }
       get(key) {
         return dart.as(this.containsKey(key) ? this._values.get(key) : null, E);
       }
       get length() {
         return this._values.length;
       }
       get values() {
-        return new SubListIterable(this._values, 0, null);
+        return new SubListIterable(this._values, 0, dart.as(null, core.int));
       }
       get keys() {
         return new _ListIndicesIterable(this._values);
       }
       get isEmpty() {
         return this._values.isEmpty;
       }
       get isNotEmpty() {
         return this._values.isNotEmpty;
       }
@@ skipping 490 matching lines @@
   _internal.ReversedListIterable = ReversedListIterable;
   _internal.ReversedListIterable$ = ReversedListIterable$;
   _internal.UnmodifiableListError = UnmodifiableListError;
   _internal.NonGrowableListError = NonGrowableListError;
   _internal.makeListFixedLength = makeListFixedLength;
   _internal.Lists = Lists;
   _internal.printToConsole = printToConsole;
   _internal.Sort = Sort;
   _internal.Symbol = Symbol;
 })(_internal || (_internal = {}));