fixes #193, factory constructors as static methods

lib/runtime/dart/collection.js

 var collection = dart.defineLibrary(collection, {});
 var _internal = dart.lazyImport(_internal);
 var core = dart.import(core);
 var _js_helper = dart.lazyImport(_js_helper);
 var math = dart.lazyImport(math);
 (function(exports, _internal, core, _js_helper, math) {
   'use strict';
   let _source = Symbol('_source');
   let UnmodifiableListView$ = dart.generic(function(E) {
     class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
@@ skipping 27 matching lines @@
     return _Equality;
   });
   let _Equality = _Equality$();
   let _Hasher$ = dart.generic(function(K) {
     let _Hasher = dart.typedef('_Hasher', () => dart.functionType(core.int, [K]));
     return _Hasher;
   });
   let _Hasher = _Hasher$();
   let HashMap$ = dart.generic(function(K, V) {
     class HashMap extends core.Object {
-      HashMap(opts) {
+      static new(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_HashMap$(K, V))();
             }
             hashCode = _defaultHashCode;
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
               return new (_IdentityHashMap$(K, V))();
             }
             if (equals == null) {
               equals = _defaultEquals;
             }
           }
         } else {
           if (hashCode == null) {
             hashCode = _defaultHashCode;
           }
           if (equals == null) {
             equals = _defaultEquals;
           }
         }
         return new (_CustomHashMap$(K, V))(equals, hashCode, isValidKey);
       }
-      identity() {
+      static identity() {
         return new (_IdentityHashMap$(K, V))();
       }
-      from(other) {
-        let result = new (HashMap$(K, V))();
+      static from(other) {
+        let result = HashMap$(K, V).new();
         other.forEach(dart.fn((k, v) => {
           result.set(k, dart.as(v, V));
         }));
         return result;
       }
-      fromIterable(iterable, opts) {
+      static fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
-        let map = new (HashMap$(K, V))();
+        let map = HashMap$(K, V).new();
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
       }
-      fromIterables(keys, values) {
-        let map = new (HashMap$(K, V))();
+      static fromIterables(keys, values) {
+        let map = HashMap$(K, V).new();
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
     }
     HashMap[dart.implements] = () => [core.Map$(K, V)];
-    dart.defineNamedConstructor(HashMap, 'identity');
-    dart.defineNamedConstructor(HashMap, 'from');
-    dart.defineNamedConstructor(HashMap, 'fromIterable');
-    dart.defineNamedConstructor(HashMap, 'fromIterables');
     dart.setSignature(HashMap, {
       constructors: () => ({
-        HashMap: [HashMap$(K, V), [], {equals: dart.functionType(core.bool, [K, K]), hashCode: dart.functionType(core.int, [K]), isValidKey: dart.functionType(core.bool, [core.Object])}],
+        new: [HashMap$(K, V), [], {equals: dart.functionType(core.bool, [K, K]), hashCode: dart.functionType(core.int, [K]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         identity: [HashMap$(K, V), []],
         from: [HashMap$(K, V), [core.Map]],
         fromIterable: [HashMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.bottom]), value: dart.functionType(V, [dart.bottom])}],
         fromIterables: [HashMap$(K, V), [core.Iterable$(K), core.Iterable$(V)]]
       })
     });
     return HashMap;
   });
   let HashMap = HashMap$();
   let SetMixin$ = dart.generic(function(E) {
@@ skipping 69 matching lines @@
         let result = this[core.$toSet]();
         for (let element of this) {
           if (other[core.$contains](element))
             result.remove(element);
         }
         return result;
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = growable ? (() => {
-          let _ = new (core.List$(E))();
+          let _ = core.List$(E).new();
           _[core.$length] = this[core.$length];
           return _;
-        }).bind(this)() : new (core.List$(E))(this[core.$length]);
+        }).bind(this)() : core.List$(E).new(this[core.$length]);
         let i = 0;
         for (let element of this)
           result[core.$set]((() => {
             let x = i;
             i = dart.notNull(x) + 1;
             return x;
           })(), element);
         return result;
       }
       [core.$map](f) {
@@ skipping 74 matching lines @@
       }
       [core.$any](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (test(element))
             return true;
         }
         return false;
       }
       [core.$take](n) {
-        return new (_internal.TakeIterable$(E))(this, n);
+        return _internal.TakeIterable$(E).new(this, n);
       }
       [core.$takeWhile](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$skip](n) {
-        return new (_internal.SkipIterable$(E))(this, n);
+        return _internal.SkipIterable$(E).new(this, n);
       }
       [core.$skipWhile](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get [core.$first]() {
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
@@ skipping 60 matching lines @@
       [core.$elementAt](index) {
         if (!(typeof index == 'number'))
           throw new core.ArgumentError.notNull("index");
         core.RangeError.checkNotNegative(index, "index");
         let elementIndex = 0;
         for (let element of this) {
           if (index == elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
-        throw new core.RangeError.index(index, this, "index", null, elementIndex);
+        throw core.RangeError.index(index, this, "index", null, elementIndex);
       }
     }
     SetMixin[dart.implements] = () => [core.Set$(E)];
     dart.setSignature(SetMixin, {
       methods: () => ({
         clear: [dart.void, []],
         addAll: [dart.void, [core.Iterable$(E)]],
         removeAll: [dart.void, [core.Iterable$(core.Object)]],
         retainAll: [dart.void, [core.Iterable$(core.Object)]],
         removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
@@ skipping 70 matching lines @@
         difference: [core.Set$(E), [core.Set$(core.Object)]],
         intersection: [core.Set$(E), [core.Set$(core.Object)]],
         [core.$toSet]: [core.Set$(E), []]
       })
     });
     return _HashSetBase;
   });
   let _HashSetBase = _HashSetBase$();
   let HashSet$ = dart.generic(function(E) {
     class HashSet extends core.Object {
-      HashSet(opts) {
+      static new(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_HashSet$(E))();
             }
             hashCode = _defaultHashCode;
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
               return new (_IdentityHashSet$(E))();
             }
             if (equals == null) {
               equals = _defaultEquals;
             }
           }
         } else {
           if (hashCode == null) {
             hashCode = _defaultHashCode;
           }
           if (equals == null) {
             equals = _defaultEquals;
           }
         }
         return new (_CustomHashSet$(E))(equals, hashCode, isValidKey);
       }
-      identity() {
+      static identity() {
         return new (_IdentityHashSet$(E))();
       }
-      from(elements) {
-        let result = new (HashSet$(E))();
+      static from(elements) {
+        let result = HashSet$(E).new();
         for (let e of dart.as(elements, core.Iterable$(E)))
           result.add(e);
         return result;
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     HashSet[dart.implements] = () => [core.Set$(E)];
-    dart.defineNamedConstructor(HashSet, 'identity');
-    dart.defineNamedConstructor(HashSet, 'from');
     dart.setSignature(HashSet, {
       constructors: () => ({
-        HashSet: [HashSet$(E), [], {equals: dart.functionType(core.bool, [E, E]), hashCode: dart.functionType(core.int, [E]), isValidKey: dart.functionType(core.bool, [core.Object])}],
+        new: [HashSet$(E), [], {equals: dart.functionType(core.bool, [E, E]), hashCode: dart.functionType(core.int, [E]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         identity: [HashSet$(E), []],
         from: [HashSet$(E), [core.Iterable]]
       })
     });
     return HashSet;
   });
   let HashSet = HashSet$();
   let IterableMixin$ = dart.generic(function(E) {
     class IterableMixin extends core.Object {
       [core.$map](f) {
         dart.as(f, dart.functionType(core.Object, [E]));
-        return new (_internal.MappedIterable$(E, core.Object))(this, f);
+        return _internal.MappedIterable$(E, core.Object).new(this, f);
       }
       [core.$where](f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       [core.$expand](f) {
         dart.as(f, dart.functionType(core.Iterable, [E]));
         return new (_internal.ExpandIterable$(E, core.Object))(this, f);
       }
       [core.$contains](element) {
@@ skipping 58 matching lines @@
       [core.$any](f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (f(element))
             return true;
         }
         return false;
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
-        return new (core.List$(E)).from(this, {growable: growable});
+        return core.List$(E).from(this, {growable: growable});
       }
       [core.$toSet]() {
-        return new (core.Set$(E)).from(this);
+        return core.Set$(E).from(this);
       }
       get [core.$length]() {
         dart.assert(!dart.is(this, _internal.EfficientLength));
         let count = 0;
         let it = this[core.$iterator];
         while (it.moveNext()) {
           count = dart.notNull(count) + 1;
         }
         return count;
       }
       get [core.$isEmpty]() {
         return !dart.notNull(this[core.$iterator].moveNext());
       }
       get [core.$isNotEmpty]() {
         return !dart.notNull(this[core.$isEmpty]);
       }
       [core.$take](n) {
-        return new (_internal.TakeIterable$(E))(this, n);
+        return _internal.TakeIterable$(E).new(this, n);
       }
       [core.$takeWhile](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$skip](n) {
-        return new (_internal.SkipIterable$(E))(this, n);
+        return _internal.SkipIterable$(E).new(this, n);
       }
       [core.$skipWhile](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get [core.$first]() {
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
@@ skipping 69 matching lines @@
       [core.$elementAt](index) {
         if (!(typeof index == 'number'))
           throw new core.ArgumentError.notNull("index");
         core.RangeError.checkNotNegative(index, "index");
         let elementIndex = 0;
         for (let element of this) {
           if (index == elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
-        throw new core.RangeError.index(index, this, "index", null, elementIndex);
+        throw core.RangeError.index(index, this, "index", null, elementIndex);
       }
       toString() {
         return IterableBase.iterableToShortString(this, '(', ')');
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     IterableMixin[dart.implements] = () => [core.Iterable$(E)];
     dart.setSignature(IterableMixin, {
@@ skipping 22 matching lines @@
     });
     return IterableMixin;
   });
   let IterableMixin = IterableMixin$();
   let IterableBase$ = dart.generic(function(E) {
     class IterableBase extends core.Object {
       IterableBase() {
       }
       [core.$map](f) {
         dart.as(f, dart.functionType(core.Object, [E]));
-        return new (_internal.MappedIterable$(E, core.Object))(this, f);
+        return _internal.MappedIterable$(E, core.Object).new(this, f);
       }
       [core.$where](f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       [core.$expand](f) {
         dart.as(f, dart.functionType(core.Iterable, [E]));
         return new (_internal.ExpandIterable$(E, core.Object))(this, f);
       }
       [core.$contains](element) {
@@ skipping 58 matching lines @@
       [core.$any](f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         for (let element of this) {
           if (f(element))
             return true;
         }
         return false;
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
-        return new (core.List$(E)).from(this, {growable: growable});
+        return core.List$(E).from(this, {growable: growable});
       }
       [core.$toSet]() {
-        return new (core.Set$(E)).from(this);
+        return core.Set$(E).from(this);
       }
       get [core.$length]() {
         dart.assert(!dart.is(this, _internal.EfficientLength));
         let count = 0;
         let it = this[core.$iterator];
         while (it.moveNext()) {
           count = dart.notNull(count) + 1;
         }
         return count;
       }
       get [core.$isEmpty]() {
         return !dart.notNull(this[core.$iterator].moveNext());
       }
       get [core.$isNotEmpty]() {
         return !dart.notNull(this[core.$isEmpty]);
       }
       [core.$take](n) {
-        return new (_internal.TakeIterable$(E))(this, n);
+        return _internal.TakeIterable$(E).new(this, n);
       }
       [core.$takeWhile](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$skip](n) {
-        return new (_internal.SkipIterable$(E))(this, n);
+        return _internal.SkipIterable$(E).new(this, n);
       }
       [core.$skipWhile](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.SkipWhileIterable$(E))(this, test);
       }
       get [core.$first]() {
         let it = this[core.$iterator];
         if (!dart.notNull(it.moveNext())) {
           throw _internal.IterableElementError.noElement();
         }
@@ skipping 69 matching lines @@
       [core.$elementAt](index) {
         if (!(typeof index == 'number'))
           throw new core.ArgumentError.notNull("index");
         core.RangeError.checkNotNegative(index, "index");
         let elementIndex = 0;
         for (let element of this) {
           if (index == elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
-        throw new core.RangeError.index(index, this, "index", null, elementIndex);
+        throw core.RangeError.index(index, this, "index", null, elementIndex);
       }
       toString() {
         return IterableBase$().iterableToShortString(this, '(', ')');
       }
       static iterableToShortString(iterable, leftDelimiter, rightDelimiter) {
         if (leftDelimiter === void 0)
           leftDelimiter = '(';
         if (rightDelimiter === void 0)
           rightDelimiter = ')';
         if (IterableBase$()._isToStringVisiting(iterable)) {
@@ skipping 204 matching lines @@
       })
     });
     return HasNextIterator;
   });
   let HasNextIterator = HasNextIterator$();
   HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT = 0;
   HasNextIterator._NO_NEXT = 1;
   HasNextIterator._NOT_MOVED_YET = 2;
   let LinkedHashMap$ = dart.generic(function(K, V) {
     class LinkedHashMap extends core.Object {
-      LinkedHashMap(opts) {
+      static new(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_LinkedHashMap$(K, V))();
             }
             hashCode = _defaultHashCode;
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
               return new (_LinkedIdentityHashMap$(K, V))();
             }
             if (equals == null) {
               equals = _defaultEquals;
             }
           }
         } else {
           if (hashCode == null) {
             hashCode = _defaultHashCode;
           }
           if (equals == null) {
             equals = _defaultEquals;
           }
         }
         return new (_LinkedCustomHashMap$(K, V))(equals, hashCode, isValidKey);
       }
-      identity() {
+      static identity() {
         return new (_LinkedIdentityHashMap$(K, V))();
       }
-      from(other) {
-        let result = new (LinkedHashMap$(K, V))();
+      static from(other) {
+        let result = LinkedHashMap$(K, V).new();
         other.forEach(dart.fn((k, v) => {
           result.set(k, dart.as(v, V));
         }));
         return result;
       }
-      fromIterable(iterable, opts) {
+      static fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
-        let map = new (LinkedHashMap$(K, V))();
+        let map = LinkedHashMap$(K, V).new();
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
       }
-      fromIterables(keys, values) {
-        let map = new (LinkedHashMap$(K, V))();
+      static fromIterables(keys, values) {
+        let map = LinkedHashMap$(K, V).new();
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
-      _literal(keyValuePairs) {
+      static _literal(keyValuePairs) {
         return dart.as(_js_helper.fillLiteralMap(keyValuePairs, new (_LinkedHashMap$(K, V))()), LinkedHashMap$(K, V));
       }
-      _empty() {
+      static _empty() {
         return new (_LinkedHashMap$(K, V))();
       }
     }
     LinkedHashMap[dart.implements] = () => [HashMap$(K, V)];
-    dart.defineNamedConstructor(LinkedHashMap, 'identity');
-    dart.defineNamedConstructor(LinkedHashMap, 'from');
-    dart.defineNamedConstructor(LinkedHashMap, 'fromIterable');
-    dart.defineNamedConstructor(LinkedHashMap, 'fromIterables');
-    dart.defineNamedConstructor(LinkedHashMap, '_literal');
-    dart.defineNamedConstructor(LinkedHashMap, '_empty');
     dart.setSignature(LinkedHashMap, {
       constructors: () => ({
-        LinkedHashMap: [LinkedHashMap$(K, V), [], {equals: dart.functionType(core.bool, [K, K]), hashCode: dart.functionType(core.int, [K]), isValidKey: dart.functionType(core.bool, [core.Object])}],
+        new: [LinkedHashMap$(K, V), [], {equals: dart.functionType(core.bool, [K, K]), hashCode: dart.functionType(core.int, [K]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         identity: [LinkedHashMap$(K, V), []],
         from: [LinkedHashMap$(K, V), [core.Map]],
         fromIterable: [LinkedHashMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.bottom]), value: dart.functionType(V, [dart.bottom])}],
         fromIterables: [LinkedHashMap$(K, V), [core.Iterable$(K), core.Iterable$(V)]],
         _literal: [LinkedHashMap$(K, V), [core.List]],
         _empty: [LinkedHashMap$(K, V), []]
       })
     });
     return LinkedHashMap;
   });
   let LinkedHashMap = LinkedHashMap$();
   let LinkedHashSet$ = dart.generic(function(E) {
     class LinkedHashSet extends core.Object {
-      LinkedHashSet(opts) {
+      static new(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_LinkedHashSet$(E))();
             }
             hashCode = _defaultHashCode;
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
               return new (_LinkedIdentityHashSet$(E))();
             }
             if (equals == null) {
               equals = _defaultEquals;
             }
           }
         } else {
           if (hashCode == null) {
             hashCode = _defaultHashCode;
           }
           if (equals == null) {
             equals = _defaultEquals;
           }
         }
         return new (_LinkedCustomHashSet$(E))(equals, hashCode, isValidKey);
       }
-      identity() {
+      static identity() {
         return new (_LinkedIdentityHashSet$(E))();
       }
-      from(elements) {
-        let result = new (LinkedHashSet$(E))();
+      static from(elements) {
+        let result = LinkedHashSet$(E).new();
         for (let element of elements) {
           result.add(element);
         }
         return result;
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     LinkedHashSet[dart.implements] = () => [HashSet$(E)];
-    dart.defineNamedConstructor(LinkedHashSet, 'identity');
-    dart.defineNamedConstructor(LinkedHashSet, 'from');
     dart.setSignature(LinkedHashSet, {
       constructors: () => ({
-        LinkedHashSet: [LinkedHashSet$(E), [], {equals: dart.functionType(core.bool, [E, E]), hashCode: dart.functionType(core.int, [E]), isValidKey: dart.functionType(core.bool, [core.Object])}],
+        new: [LinkedHashSet$(E), [], {equals: dart.functionType(core.bool, [E, E]), hashCode: dart.functionType(core.int, [E]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         identity: [LinkedHashSet$(E), []],
         from: [LinkedHashSet$(E), [core.Iterable$(E)]]
       })
     });
     return LinkedHashSet;
   });
   let LinkedHashSet = LinkedHashSet$();
   let _modificationCount = Symbol('_modificationCount');
   let _length = Symbol('_length');
   let _next = Symbol('_next');
@@ skipping 400 matching lines @@
         return new (_internal.SubListIterable$(E))(this, 0, count);
       }
       [core.$takeWhile](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.TakeWhileIterable$(E))(this, test);
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = null;
         if (growable) {
-          result = new (core.List$(E))();
+          result = core.List$(E).new();
           result[core.$length] = this[core.$length];
         } else {
-          result = new (core.List$(E))(this[core.$length]);
+          result = core.List$(E).new(this[core.$length]);
         }
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           result[core.$set](i, this[core.$get](i));
         }
         return result;
       }
       [core.$toSet]() {
-        let result = new (core.Set$(E))();
+        let result = core.Set$(E).new();
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           result.add(this[core.$get](i));
         }
         return result;
       }
       [core.$add](element) {
         dart.as(element, E);
         this[core.$set]((() => {
           let x = this[core.$length];
           this[core.$length] = dart.notNull(x) + 1;
@@ skipping 60 matching lines @@
       [core.$sort](compare) {
         if (compare === void 0)
           compare = null;
         dart.as(compare, dart.functionType(core.int, [E, E]));
         _internal.Sort.sort(this, compare == null ? core.Comparable.compare : compare);
       }
       [core.$shuffle](random) {
         if (random === void 0)
           random = null;
         if (random == null)
-          random = new math.Random();
+          random = math.Random.new();
         let length = this[core.$length];
         while (dart.notNull(length) > 1) {
           let pos = random.nextInt(length);
           length = dart.notNull(length) - 1;
           let tmp = this[core.$get](length);
           this[core.$set](length, this[core.$get](pos));
           this[core.$set](pos, tmp);
         }
       }
       [core.$asMap]() {
         return new (_internal.ListMapView$(E))(this);
       }
       [core.$sublist](start, end) {
         if (end === void 0)
           end = null;
         let listLength = this[core.$length];
         if (end == null)
           end = listLength;
         core.RangeError.checkValidRange(start, end, listLength);
         let length = dart.notNull(end) - dart.notNull(start);
-        let result = new (core.List$(E))();
+        let result = core.List$(E).new();
         result[core.$length] = length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result[core.$set](i, this[core.$get](dart.notNull(start) + dart.notNull(i)));
         }
         return result;
       }
       [core.$getRange](start, end) {
         core.RangeError.checkValidRange(start, end, this[core.$length]);
         return new (_internal.SubListIterable$(E))(this, start, end);
       }
@@ skipping 584 matching lines @@
       isNotEmpty: [core.bool, [core.Map]],
       mapToString: [core.String, [core.Map]],
       _id: [core.Object, [core.Object]],
       _fillMapWithMappedIterable: [dart.void, [core.Map, core.Iterable, dart.functionType(core.Object, [dart.bottom]), dart.functionType(core.Object, [dart.bottom])]],
       _fillMapWithIterables: [dart.void, [core.Map, core.Iterable, core.Iterable]]
     }),
     names: ['containsValue', 'containsKey', 'putIfAbsent', 'clear', 'forEach', 'getValues', 'length', 'isEmpty', 'isNotEmpty', 'mapToString', '_id', '_fillMapWithMappedIterable', '_fillMapWithIterables']
   });
   let Queue$ = dart.generic(function(E) {
     class Queue extends core.Object {
-      Queue() {
+      static new() {
         return new (ListQueue$(E))();
       }
-      from(elements) {
-        return new (ListQueue$(E)).from(elements);
+      static from(elements) {
+        return ListQueue$(E).from(elements);
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     Queue[dart.implements] = () => [core.Iterable$(E), _internal.EfficientLength];
-    dart.defineNamedConstructor(Queue, 'from');
     dart.setSignature(Queue, {
       constructors: () => ({
-        Queue: [Queue$(E), []],
+        new: [Queue$(E), []],
         from: [Queue$(E), [core.Iterable]]
       })
     });
     return Queue;
   });
   let Queue = Queue$();
   let _element = Symbol('_element');
   let _link = Symbol('_link');
   let _asNonSentinelEntry = Symbol('_asNonSentinelEntry');
   let DoubleLinkedQueueEntry$ = dart.generic(function(E) {
@@ skipping 92 matching lines @@
   let _elementCount = Symbol('_elementCount');
   let _filter = Symbol('_filter');
   let DoubleLinkedQueue$ = dart.generic(function(E) {
     class DoubleLinkedQueue extends IterableBase$(E) {
       DoubleLinkedQueue() {
         this[_sentinel] = null;
         this[_elementCount] = 0;
         super.IterableBase();
         this[_sentinel] = new (_DoubleLinkedQueueEntrySentinel$(E))();
       }
-      from(elements) {
+      static from(elements) {
         let list = new (DoubleLinkedQueue$(E))();
         for (let e of dart.as(elements, core.Iterable$(E))) {
           list.addLast(e);
         }
         return dart.as(list, DoubleLinkedQueue$(E));
       }
       get [core.$length]() {
         return this[_elementCount];
       }
       addLast(value) {
@@ skipping 96 matching lines @@
         }
       }
       get [core.$iterator]() {
         return new (_DoubleLinkedQueueIterator$(E))(this[_sentinel]);
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     DoubleLinkedQueue[dart.implements] = () => [Queue$(E)];
-    dart.defineNamedConstructor(DoubleLinkedQueue, 'from');
     dart.setSignature(DoubleLinkedQueue, {
       constructors: () => ({
         DoubleLinkedQueue: [DoubleLinkedQueue$(E), []],
         from: [DoubleLinkedQueue$(E), [core.Iterable]]
       }),
       methods: () => ({
         addLast: [dart.void, [E]],
         addFirst: [dart.void, [E]],
         add: [dart.void, [E]],
         addAll: [dart.void, [core.Iterable$(E)]],
@@ skipping 61 matching lines @@
         this[_tail] = 0;
         this[_table] = null;
         this[_modificationCount] = 0;
         super.IterableBase();
         if (initialCapacity == null || dart.notNull(initialCapacity) < dart.notNull(ListQueue$()._INITIAL_CAPACITY)) {
           initialCapacity = ListQueue$()._INITIAL_CAPACITY;
         } else if (!dart.notNull(ListQueue$()._isPowerOf2(initialCapacity))) {
           initialCapacity = ListQueue$()._nextPowerOf2(initialCapacity);
         }
         dart.assert(ListQueue$()._isPowerOf2(initialCapacity));
-        this[_table] = new (core.List$(E))(initialCapacity);
+        this[_table] = core.List$(E).new(initialCapacity);
       }
-      from(elements) {
+      static from(elements) {
         if (dart.is(elements, core.List)) {
           let length = elements[core.$length];
           let queue = new (ListQueue$(E))(dart.notNull(length) + 1);
           dart.assert(dart.notNull(queue[_table][core.$length]) > dart.notNull(length));
           let sourceList = elements;
           queue[_table][core.$setRange](0, length, dart.as(sourceList, core.Iterable$(E)), 0);
           queue[_tail] = length;
           return queue;
         } else {
           let capacity = ListQueue$()._INITIAL_CAPACITY;
@@ skipping 42 matching lines @@
         return this[_table][core.$get](this[_head]);
       }
       [core.$elementAt](index) {
         core.RangeError.checkValidIndex(index, this);
         return this[_table][core.$get](dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][core.$length]) - 1);
       }
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let list = null;
         if (growable) {
-          list = new (core.List$(E))();
+          list = core.List$(E).new();
           list[core.$length] = this[core.$length];
         } else {
-          list = new (core.List$(E))(this[core.$length]);
+          list = core.List$(E).new(this[core.$length]);
         }
         this[_writeToList](list);
         return list;
       }
       add(element) {
         dart.as(element, E);
         this[_add](element);
       }
       addAll(elements) {
         dart.as(elements, core.Iterable$(E));
@@ skipping 147 matching lines @@
           while (i != this[_tail]) {
             let nextOffset = dart.notNull(i) + 1 & dart.notNull(mask);
             this[_table][core.$set](i, this[_table][core.$get](nextOffset));
             i = nextOffset;
           }
           this[_table][core.$set](this[_tail], null);
           return offset;
         }
       }
       [_grow]() {
-        let newTable = new (core.List$(E))(dart.notNull(this[_table][core.$length]) * 2);
+        let newTable = core.List$(E).new(dart.notNull(this[_table][core.$length]) * 2);
         let split = dart.notNull(this[_table][core.$length]) - dart.notNull(this[_head]);
         newTable[core.$setRange](0, split, this[_table], this[_head]);
         newTable[core.$setRange](split, dart.notNull(split) + dart.notNull(this[_head]), this[_table], 0);
         this[_head] = 0;
         this[_tail] = this[_table][core.$length];
         this[_table] = newTable;
       }
       [_writeToList](target) {
         dart.as(target, core.List$(E));
         dart.assert(dart.notNull(target[core.$length]) >= dart.notNull(this[core.$length]));
         if (dart.notNull(this[_head]) <= dart.notNull(this[_tail])) {
           let length = dart.notNull(this[_tail]) - dart.notNull(this[_head]);
           target[core.$setRange](0, length, this[_table], this[_head]);
           return length;
         } else {
           let firstPartSize = dart.notNull(this[_table][core.$length]) - dart.notNull(this[_head]);
           target[core.$setRange](0, firstPartSize, this[_table], this[_head]);
           target[core.$setRange](firstPartSize, dart.notNull(firstPartSize) + dart.notNull(this[_tail]), this[_table], 0);
           return dart.notNull(this[_tail]) + dart.notNull(firstPartSize);
         }
       }
       [_preGrow](newElementCount) {
         dart.assert(dart.notNull(newElementCount) >= dart.notNull(this[core.$length]));
         newElementCount = dart.notNull(newElementCount) + (dart.notNull(newElementCount) >> 1);
         let newCapacity = ListQueue$()._nextPowerOf2(newElementCount);
-        let newTable = new (core.List$(E))(newCapacity);
+        let newTable = core.List$(E).new(newCapacity);
         this[_tail] = this[_writeToList](newTable);
         this[_table] = newTable;
         this[_head] = 0;
       }
     }
     ListQueue[dart.implements] = () => [Queue$(E)];
-    dart.defineNamedConstructor(ListQueue, 'from');
     dart.setSignature(ListQueue, {
       constructors: () => ({
         ListQueue: [ListQueue$(E), [], [core.int]],
         from: [ListQueue$(E), [core.Iterable]]
       }),
       methods: () => ({
         [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
         [core.$elementAt]: [E, [core.int]],
         [core.$toList]: [core.List$(E), [], {growable: core.bool}],
         add: [dart.void, [E]],
@@ skipping 262 matching lines @@
     class SplayTreeMap extends _SplayTree$(K) {
       SplayTreeMap(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? core.Comparable.compare : compare, core.Comparator$(K));
         this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, K), core.bool, [core.Object]);
         super._SplayTree();
       }
-      from(other, compare, isValidKey) {
+      static from(other, compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         let result = new (SplayTreeMap$(K, V))();
         other.forEach(dart.fn((k, v) => {
           result.set(k, dart.as(v, V));
         }));
         return result;
       }
-      fromIterable(iterable, opts) {
+      static fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
         let compare = opts && 'compare' in opts ? opts.compare : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         let map = new (SplayTreeMap$(K, V))(compare, isValidKey);
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
       }
-      fromIterables(keys, values, compare, isValidKey) {
+      static fromIterables(keys, values, compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         let map = new (SplayTreeMap$(K, V))(compare, isValidKey);
         Maps._fillMapWithIterables(map, keys, values);
         return map;
       }
       [_compare](key1, key2) {
         dart.as(key1, K);
@@ skipping 161 matching lines @@
         let node = this[_root].right;
         if (node == null)
           return null;
         while (node.left != null) {
           node = node.left;
         }
         return node.key;
       }
     }
     SplayTreeMap[dart.implements] = () => [core.Map$(K, V)];
-    dart.defineNamedConstructor(SplayTreeMap, 'from');
-    dart.defineNamedConstructor(SplayTreeMap, 'fromIterable');
-    dart.defineNamedConstructor(SplayTreeMap, 'fromIterables');
     dart.defineNamedConstructor(SplayTreeMap, '_internal');
     dart.setSignature(SplayTreeMap, {
       constructors: () => ({
         SplayTreeMap: [SplayTreeMap$(K, V), [], [dart.functionType(core.int, [K, K]), dart.functionType(core.bool, [core.Object])]],
         from: [SplayTreeMap$(K, V), [core.Map], [dart.functionType(core.int, [K, K]), dart.functionType(core.bool, [core.Object])]],
         fromIterable: [SplayTreeMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.bottom]), value: dart.functionType(V, [dart.bottom]), compare: dart.functionType(core.int, [K, K]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         fromIterables: [SplayTreeMap$(K, V), [core.Iterable$(K), core.Iterable$(V)], [dart.functionType(core.int, [K, K]), dart.functionType(core.bool, [core.Object])]],
         _internal: [SplayTreeMap$(K, V), []]
       }),
       methods: () => ({
@@ skipping 217 matching lines @@
     class SplayTreeSet extends dart.mixin(_SplayTree$(E), IterableMixin$(E), SetMixin$(E)) {
       SplayTreeSet(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? core.Comparable.compare : compare, core.Comparator$(E));
         this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, E), core.bool, [core.Object]);
         super._SplayTree();
       }
-      from(elements, compare, isValidKey) {
+      static from(elements, compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         let result = new (SplayTreeSet$(E))(compare, isValidKey);
         for (let element of dart.as(elements, core.Iterable$(E))) {
           result.add(element);
         }
         return result;
       }
@@ skipping 126 matching lines @@
       clear() {
         this[_clear]();
       }
       [core.$toSet]() {
         return this[_clone]();
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
-    dart.defineNamedConstructor(SplayTreeSet, 'from');
     dart.setSignature(SplayTreeSet, {
       constructors: () => ({
         SplayTreeSet: [SplayTreeSet$(E), [], [dart.functionType(core.int, [E, E]), dart.functionType(core.bool, [core.Object])]],
         from: [SplayTreeSet$(E), [core.Iterable], [dart.functionType(core.int, [E, E]), dart.functionType(core.bool, [core.Object])]]
       }),
       methods: () => ({
         [_compare]: [core.int, [E, E]],
         [core.$contains]: [core.bool, [core.Object]],
         add: [core.bool, [E]],
         remove: [core.bool, [core.Object]],
@@ skipping 43 matching lines @@
       get isEmpty() {
         return this[_length] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new (HashMapKeyIterable$(K))(this);
       }
       get values() {
-        return new (_internal.MappedIterable$(K, V))(this.keys, dart.fn((each => this.get(each)).bind(this), V, [core.Object]));
+        return _internal.MappedIterable$(K, V).new(this.keys, dart.fn((each => this.get(each)).bind(this), V, [core.Object]));
       }
       containsKey(key) {
         if (_HashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           return strings == null ? false : _HashMap$()._hasTableEntry(strings, key);
         } else if (_HashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           return nums == null ? false : _HashMap$()._hasTableEntry(nums, key);
         } else {
           return this[_containsKey](key);
@@ skipping 119 matching lines @@
           let key = keys[i];
           action(dart.as(key, K), this.get(key));
           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 result = core.List.new(this[_length]);
         let index = 0;
         let strings = this[_strings];
         if (strings != null) {
           let names = Object.getOwnPropertyNames(strings);
           let entries = names.length;
           for (let i = 0; dart.notNull(i) < dart.notNull(entries); i = dart.notNull(i) + 1) {
             let key = names[i];
             result[index] = key;
             index = dart.notNull(index) + 1;
           }
@@ skipping 308 matching lines @@
       get isEmpty() {
         return this[_length] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new (LinkedHashMapKeyIterable$(K))(this);
       }
       get values() {
-        return new (_internal.MappedIterable$(K, V))(this.keys, dart.fn((each => this.get(each)).bind(this), V, [core.Object]));
+        return _internal.MappedIterable$(K, V).new(this.keys, dart.fn((each => this.get(each)).bind(this), V, [core.Object]));
       }
       containsKey(key) {
         if (_LinkedHashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
             return false;
           let cell = dart.as(_LinkedHashMap$()._getTableEntry(strings, key), LinkedHashMapCell);
           return cell != null;
         } else if (_LinkedHashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
@@ skipping 567 matching lines @@
       }
       clear() {
         if (dart.notNull(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 result = core.List.new(this[_length]);
         let index = 0;
         let strings = this[_strings];
         if (strings != null) {
           let names = Object.getOwnPropertyNames(strings);
           let entries = names.length;
           for (let i = 0; dart.notNull(i) < dart.notNull(entries); i = dart.notNull(i) + 1) {
             let element = names[i];
             result[index] = element;
             index = dart.notNull(index) + 1;
           }
@@ skipping 755 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;
 })(collection, _internal, core, _js_helper, math);