fixes #193, factory constructors as static methods

lib/runtime/dart/core.js

 var core = dart.defineLibrary(core, {});
 var _js_helper = dart.lazyImport(_js_helper);
 var _internal = dart.lazyImport(_internal);
 var collection = dart.lazyImport(collection);
 var _interceptors = dart.lazyImport(_interceptors);
 var math = dart.lazyImport(math);
 var convert = dart.lazyImport(convert);
 (function(exports, _js_helper, _internal, collection, _interceptors, math, convert) {
   'use strict';
   class Object {
@@ skipping 76 matching lines @@
   let override = dart.const(new _Override());
   class _Proxy extends Object {
     _Proxy() {
     }
   }
   dart.setSignature(_Proxy, {
     constructors: () => ({_Proxy: [_Proxy, []]})
   });
   let proxy = dart.const(new _Proxy());
   class bool extends Object {
-    fromEnvironment(name, opts) {
+    static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : false;
       throw new UnsupportedError('bool.fromEnvironment can only be used as a const constructor');
     }
     toString() {
       return this ? "true" : "false";
     }
   }
-  dart.defineNamedConstructor(bool, 'fromEnvironment');
   dart.setSignature(bool, {
     constructors: () => ({fromEnvironment: [bool, [String], {defaultValue: bool}]})
   });
   let Comparator$ = dart.generic(function(T) {
     let Comparator = dart.typedef('Comparator', () => dart.functionType(int, [T, T]));
     return Comparator;
   });
   let Comparator = Comparator$();
   let Comparable$ = dart.generic(function(T) {
     class Comparable extends Object {
@@ skipping 36 matching lines @@
       if (second === void 0)
         second = 0;
       if (millisecond === void 0)
         millisecond = 0;
       this._internal(year, month, day, hour, minute, second, millisecond, true);
     }
     now() {
       this._now();
     }
     static parse(formattedString) {
-      let re = new RegExp('^([+-]?\\d{4,6})-?(\\d\\d)-?(\\d\\d)' + '(?:[ T](\\d\\d)(?::?(\\d\\d)(?::?(\\d\\d)(.\\d{1,6})?)?)?' + '( ?[zZ]| ?([-+])(\\d\\d)(?::?(\\d\\d))?)?)?$');
+      let re = RegExp.new('^([+-]?\\d{4,6})-?(\\d\\d)-?(\\d\\d)' + '(?:[ T](\\d\\d)(?::?(\\d\\d)(?::?(\\d\\d)(.\\d{1,6})?)?)?' + '( ?[zZ]| ?([-+])(\\d\\d)(?::?(\\d\\d))?)?)?$');
       let match = re.firstMatch(formattedString);
       if (match != null) {
         let parseIntOrZero = matched => {
           if (matched == null)
             return 0;
           return int.parse(matched);
         };
         dart.fn(parseIntOrZero, int, [String]);
         let parseDoubleOrZero = matched => {
           if (matched == null)
@@ skipping 568 matching lines @@
     }
     range(invalidValue, minValue, maxValue, name, message) {
       if (name === void 0)
         name = null;
       if (message === void 0)
         message = null;
       this.start = minValue;
       this.end = maxValue;
       super.value(invalidValue, name, message != null ? message : "Invalid value");
     }
-    index(index, indexable, name, message, length) {
+    static index(index, indexable, name, message, length) {
       return new IndexError(index, indexable, name, message, length);
     }
     static checkValueInInterval(value, minValue, maxValue, name, message) {
       if (name === void 0)
         name = null;
       if (message === void 0)
         message = null;
       if (dart.notNull(value) < dart.notNull(minValue) || dart.notNull(value) > dart.notNull(maxValue)) {
         throw new RangeError.range(value, minValue, maxValue, name, message);
       }
     }
     static checkValidIndex(index, indexable, name, length, message) {
       if (name === void 0)
         name = null;
       if (length === void 0)
         length = null;
       if (message === void 0)
         message = null;
       if (length == null)
         length = dart.as(dart.dload(indexable, 'length'), int);
       if (dart.notNull(index) < 0 || dart.notNull(index) >= dart.notNull(length)) {
         if (name == null)
           name = "index";
-        throw new RangeError.index(index, indexable, name, message, length);
+        throw RangeError.index(index, indexable, name, message, length);
       }
     }
     static checkValidRange(start, end, length, startName, endName, message) {
       if (startName === void 0)
         startName = null;
       if (endName === void 0)
         endName = null;
       if (message === void 0)
         message = null;
       if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(length)) {
@@ skipping 31 matching lines @@
       } else if (dart.notNull(this.end) < dart.notNull(this.start)) {
         explanation = ": Valid value range is empty";
       } else {
         explanation = `: Only valid value is ${this.start}`;
       }
       return `RangeError: ${this.message} (${value})${explanation}`;
     }
   }
   dart.defineNamedConstructor(RangeError, 'value');
   dart.defineNamedConstructor(RangeError, 'range');
-  dart.defineNamedConstructor(RangeError, 'index');
   dart.setSignature(RangeError, {
     constructors: () => ({
       RangeError: [RangeError, [Object]],
       value: [RangeError, [num], [String, String]],
       range: [RangeError, [num, int, int], [String, String]],
       index: [RangeError, [int, Object], [String, String, int]]
     }),
     statics: () => ({
       checkValueInInterval: [dart.void, [int, int, int], [String, String]],
       checkValidIndex: [dart.void, [int, Object], [String, int, String]],
@@ skipping 206 matching lines @@
       super.Error();
     }
     toString() {
       return this.variableName == null ? "Reading static variable during its initialization" : `Reading static variable '${this.variableName}' during its initialization`;
     }
   }
   dart.setSignature(CyclicInitializationError, {
     constructors: () => ({CyclicInitializationError: [CyclicInitializationError, [], [String]]})
   });
   class Exception extends Object {
-    Exception(message) {
+    static new(message) {
       if (message === void 0)
         message = null;
       return new _ExceptionImplementation(message);
     }
   }
   dart.setSignature(Exception, {
-    constructors: () => ({Exception: [Exception, [], [Object]]})
+    constructors: () => ({new: [Exception, [], [Object]]})
   });
   class _ExceptionImplementation extends Object {
     _ExceptionImplementation(message) {
       if (message === void 0)
         message = null;
       this.message = message;
     }
     toString() {
       if (this.message == null)
         return "Exception";
@@ skipping 181 matching lines @@
   });
   function identical(a, b) {
     return _js_helper.Primitives.identicalImplementation(a, b);
   }
   dart.fn(identical, bool, [Object, Object]);
   function identityHashCode(object) {
     return _js_helper.objectHashCode(object);
   }
   dart.fn(identityHashCode, () => dart.functionType(int, [Object]));
   class int extends num {
-    fromEnvironment(name, opts) {
+    static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
       throw new UnsupportedError('int.fromEnvironment can only be used as a const constructor');
     }
     static parse(source, opts) {
       let radix = opts && 'radix' in opts ? opts.radix : null;
       let onError = opts && 'onError' in opts ? opts.onError : null;
       return _js_helper.Primitives.parseInt(source, radix, onError);
     }
   }
-  dart.defineNamedConstructor(int, 'fromEnvironment');
   dart.setSignature(int, {
     constructors: () => ({fromEnvironment: [int, [String], {defaultValue: int}]}),
     statics: () => ({parse: [int, [String], {radix: int, onError: dart.functionType(int, [String])}]}),
     names: ['parse']
   });
   class Invocation extends Object {
     get isAccessor() {
       return dart.notNull(this.isGetter) || dart.notNull(this.isSetter);
     }
   }
   let $iterator = dart.JsSymbol('$iterator');
   let $join = dart.JsSymbol('$join');
   let Iterable$ = dart.generic(function(E) {
     class Iterable extends Object {
       Iterable() {
       }
-      generate(count, generator) {
+      static generate(count, generator) {
         if (generator === void 0)
           generator = null;
         if (dart.notNull(count) <= 0)
           return new (_internal.EmptyIterable$(E))();
         return new (exports._GeneratorIterable$(E))(count, generator);
       }
       [dart.JsSymbol.iterator]() {
         return new dart.JsIterator(this[$iterator]);
       }
       [$join](separator) {
         if (separator === void 0)
           separator = "";
         let buffer = new StringBuffer();
         buffer.writeAll(this, separator);
         return dart.toString(buffer);
       }
     }
-    dart.defineNamedConstructor(Iterable, 'generate');
     dart.setSignature(Iterable, {
       constructors: () => ({
         Iterable: [Iterable$(E), []],
         generate: [Iterable$(E), [int], [dart.functionType(E, [int])]]
       }),
       methods: () => ({[$join]: [String, [], [String]]})
     });
     return Iterable;
   });
   let Iterable = Iterable$();
@@ skipping 154 matching lines @@
   let $retainWhere = dart.JsSymbol('$retainWhere');
   let $sublist = dart.JsSymbol('$sublist');
   let $getRange = dart.JsSymbol('$getRange');
   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) {
+      static new(length) {
         if (length === void 0)
           length = null;
         let list = null;
         if (length == null) {
           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;
         }
         dart.setType(list, List$(E));
         return dart.as(list, List$(E));
       }
-      filled(length, fill) {
-        let result = new (List$(E))(length);
+      static filled(length, fill) {
+        let result = List$(E).new(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 result;
       }
-      from(elements, opts) {
+      static from(elements, opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
-        let list = new (List$(E))();
+        let list = List$(E).new();
         for (let e of elements) {
           list[$add](dart.as(e, E));
         }
         if (growable)
           return list;
         return dart.as(_internal.makeListFixedLength(list), List$(E));
       }
-      generate(length, generator, opts) {
+      static generate(length, generator, opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = null;
         if (growable) {
           result = dart.setType([], List$(E));
           result[$length] = length;
         } else {
-          result = new (List$(E))(length);
+          result = List$(E).new(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]));
@@ skipping 13 matching lines @@
           }
         }
       }
       [$map](f) {
         dart.as(f, dart.functionType(Object, [E]));
         return _internal.IterableMixinWorkaround.mapList(this, f);
       }
       [$join](separator) {
         if (separator === void 0)
           separator = "";
-        let list = new (List$())(this[$length]);
+        let list = List$().new(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]));
@@ skipping 72 matching lines @@
         return !dart.notNull(this[$isEmpty]);
       }
       [$toString]() {
         return collection.ListBase.listToString(this);
       }
       [$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         return dart.as(dart.setType(this.slice(), core.List$(E)), List$(E));
       }
       [$toSet]() {
-        return new (exports.Set$(E)).from(this);
+        return exports.Set$(E).from(this);
       }
       get [$iterator]() {
         return new (_internal.ListIterator$(E))(this);
       }
       get [$hashCode]() {
         return _js_helper.Primitives.objectHashCode(this);
       }
       [$get](index) {
         if (!(typeof index == 'number'))
           throw new ArgumentError(index);
@@ skipping 128 matching lines @@
           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));
+        return _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);
@@ skipping 21 matching lines @@
         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');
     dart.setSignature(List, {
       constructors: () => ({
-        List: [List$(E), [], [int]],
+        new: [List$(E), [], [int]],
         filled: [List$(E), [int, E]],
         from: [List$(E), [Iterable], {growable: bool}],
         generate: [List$(E), [int, dart.functionType(E, [int])], {growable: bool}]
       }),
       methods: () => ({
         [$checkMutable]: [Object, [Object]],
         [$checkGrowable]: [Object, [Object]],
         [$where]: [Iterable$(E), [dart.functionType(bool, [E])]],
         [$expand]: [Iterable, [dart.functionType(Iterable, [E])]],
         [$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
@@ skipping 39 matching lines @@
         [$replaceRange]: [dart.void, [int, int, Iterable$(E)]],
         [$asMap]: [Map$(int, E), []]
       })
     });
     return List;
   });
   let List = List$();
   dart.registerExtension(dart.global.Array, List);
   let Map$ = dart.generic(function(K, V) {
     class Map extends Object {
-      Map() {
-        return new (collection.LinkedHashMap$(K, V))();
+      static new() {
+        return collection.LinkedHashMap$(K, V).new();
       }
-      from(other) {
-        return new (collection.LinkedHashMap$(K, V)).from(other);
+      static from(other) {
+        return collection.LinkedHashMap$(K, V).from(other);
       }
-      identity() {
-        return new (collection.LinkedHashMap$(K, V)).identity();
+      static identity() {
+        return collection.LinkedHashMap$(K, V).identity();
       }
-      fromIterable(iterable, opts) {
-        return new (collection.LinkedHashMap$(K, V)).fromIterable(iterable, opts);
+      static fromIterable(iterable, opts) {
+        return collection.LinkedHashMap$(K, V).fromIterable(iterable, opts);
       }
-      fromIterables(keys, values) {
-        return new (collection.LinkedHashMap$(K, V)).fromIterables(keys, values);
+      static fromIterables(keys, values) {
+        return collection.LinkedHashMap$(K, V).fromIterables(keys, values);
       }
     }
-    dart.defineNamedConstructor(Map, 'from');
-    dart.defineNamedConstructor(Map, 'identity');
-    dart.defineNamedConstructor(Map, 'fromIterable');
-    dart.defineNamedConstructor(Map, 'fromIterables');
     dart.setSignature(Map, {
       constructors: () => ({
-        Map: [Map$(K, V), []],
+        new: [Map$(K, V), []],
         from: [Map$(K, V), [Map$()]],
         identity: [Map$(K, V), []],
         fromIterable: [Map$(K, V), [Iterable], {key: dart.functionType(K, [dart.bottom]), value: dart.functionType(V, [dart.bottom])}],
         fromIterables: [Map$(K, V), [Iterable$(K), Iterable$(V)]]
       })
     });
     return Map;
   });
   let Map = Map$();
   class Null extends Object {
-    _uninstantiable() {
+    static _uninstantiable() {
       throw new UnsupportedError('class Null cannot be instantiated');
     }
     toString() {
       return "null";
     }
   }
-  dart.defineNamedConstructor(Null, '_uninstantiable');
   dart.setSignature(Null, {
     constructors: () => ({_uninstantiable: [Null, []]})
   });
   num._parseError = false;
   class Pattern extends Object {}
   function print(object) {
     let line = `${object}`;
     if (_internal.printToZone == null) {
       _internal.printToConsole(line);
     } else {
       dart.dcall(_internal.printToZone, line);
     }
   }
   dart.fn(print, dart.void, [Object]);
   class Match extends Object {}
   class RegExp extends Object {
-    RegExp(source, opts) {
+    static new(source, opts) {
       let multiLine = opts && 'multiLine' in opts ? opts.multiLine : false;
       let caseSensitive = opts && 'caseSensitive' in opts ? opts.caseSensitive : true;
       return new _js_helper.JSSyntaxRegExp(source, {multiLine: multiLine, caseSensitive: caseSensitive});
     }
   }
   RegExp[dart.implements] = () => [Pattern];
   dart.setSignature(RegExp, {
-    constructors: () => ({RegExp: [RegExp, [String], {multiLine: bool, caseSensitive: bool}]})
+    constructors: () => ({new: [RegExp, [String], {multiLine: bool, caseSensitive: bool}]})
   });
   let Set$ = dart.generic(function(E) {
     class Set extends collection.IterableBase$(E) {
-      Set() {
-        return new (collection.LinkedHashSet$(E))();
+      static new() {
+        return collection.LinkedHashSet$(E).new();
       }
-      identity() {
-        return new (collection.LinkedHashSet$(E)).identity();
+      static identity() {
+        return collection.LinkedHashSet$(E).identity();
       }
-      from(elements) {
-        return new (collection.LinkedHashSet$(E)).from(elements);
+      static from(elements) {
+        return collection.LinkedHashSet$(E).from(elements);
       }
     }
     Set[dart.implements] = () => [_internal.EfficientLength];
-    dart.defineNamedConstructor(Set, 'identity');
-    dart.defineNamedConstructor(Set, 'from');
     dart.setSignature(Set, {
       constructors: () => ({
-        Set: [exports.Set$(E), []],
+        new: [exports.Set$(E), []],
         identity: [exports.Set$(E), []],
         from: [exports.Set$(E), [Iterable]]
       })
     });
     return Set;
   });
   dart.defineLazyClassGeneric(exports, 'Set', {get: Set$});
   let Sink$ = dart.generic(function(T) {
     class Sink extends Object {}
     return Sink;
@@ skipping 67 matching lines @@
       reset: [dart.void, []]
     }),
     statics: () => ({
       _initTicker: [dart.void, []],
       _now: [int, []]
     }),
     names: ['_initTicker', '_now']
   });
   Stopwatch._frequency = null;
   class String extends Object {
-    fromCharCodes(charCodes, start, end) {
+    static fromCharCodes(charCodes, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       if (!dart.is(charCodes, _interceptors.JSArray)) {
         return String._stringFromIterable(charCodes, start, end);
       }
       let list = dart.as(charCodes, List);
       let len = list[$length];
       if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(len)) {
         throw new RangeError.range(start, 0, len);
       }
       if (end == null) {
         end = len;
       } else if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(len)) {
         throw new RangeError.range(end, start, len);
       }
       if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(len)) {
         list = list[$sublist](start, end);
       }
       return _js_helper.Primitives.stringFromCharCodes(list);
     }
-    fromCharCode(charCode) {
+    static fromCharCode(charCode) {
       return _js_helper.Primitives.stringFromCharCode(charCode);
     }
-    fromEnvironment(name, opts) {
+    static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
       throw new UnsupportedError('String.fromEnvironment can only be used as a const constructor');
     }
     static _stringFromIterable(charCodes, start, end) {
       if (dart.notNull(start) < 0)
         throw new RangeError.range(start, 0, charCodes[$length]);
       if (end != null && dart.notNull(end) < dart.notNull(start)) {
         throw new RangeError.range(end, start, charCodes[$length]);
       }
       let it = charCodes[$iterator];
@@ skipping 11 matching lines @@
           if (!dart.notNull(it.moveNext())) {
             throw new RangeError.range(end, start, i);
           }
           list[$add](it.current);
         }
       }
       return _js_helper.Primitives.stringFromCharCodes(list);
     }
   }
   String[dart.implements] = () => [Comparable$(String), Pattern];
-  dart.defineNamedConstructor(String, 'fromCharCodes');
-  dart.defineNamedConstructor(String, 'fromCharCode');
-  dart.defineNamedConstructor(String, 'fromEnvironment');
   dart.setSignature(String, {
     constructors: () => ({
       fromCharCodes: [String, [Iterable$(int)], [int, int]],
       fromCharCode: [String, [int]],
       fromEnvironment: [String, [String], {defaultValue: String}]
     }),
     statics: () => ({_stringFromIterable: [String, [Iterable$(int), int, int]]}),
     names: ['_stringFromIterable']
   });
   dart.defineLazyClass(exports, {
@@ skipping 161 matching lines @@
     get isEmpty() {
       return this.length == 0;
     }
     get isNotEmpty() {
       return !dart.notNull(this.isEmpty);
     }
     write(obj) {
       this[_writeString](`${obj}`);
     }
     writeCharCode(charCode) {
-      this[_writeString](new String.fromCharCode(charCode));
+      this[_writeString](String.fromCharCode(charCode));
     }
     writeAll(objects, separator) {
       if (separator === void 0)
         separator = "";
       let iterator = objects[$iterator];
       if (!dart.notNull(iterator.moveNext()))
         return;
       if (separator.isEmpty) {
         do {
           this.write(iterator.current);
@@ skipping 29 matching lines @@
       write: [dart.void, [Object]],
       writeCharCode: [dart.void, [int]],
       writeAll: [dart.void, [Iterable], [String]],
       writeln: [dart.void, [], [Object]],
       clear: [dart.void, []],
       [_writeString]: [dart.void, [Object]]
     })
   });
   class StringSink extends Object {}
   class Symbol extends Object {
-    Symbol(name) {
+    static new(name) {
       return new _internal.Symbol(name);
     }
   }
   dart.setSignature(Symbol, {
-    constructors: () => ({Symbol: [Symbol, [String]]})
+    constructors: () => ({new: [Symbol, [String]]})
   });
   class Type extends Object {}
   let _writeAuthority = dart.JsSymbol('_writeAuthority');
   let _userInfo = dart.JsSymbol('_userInfo');
   let _host = dart.JsSymbol('_host');
   let _port = dart.JsSymbol('_port');
   let _path = dart.JsSymbol('_path');
   let _query = dart.JsSymbol('_query');
   let _fragment = dart.JsSymbol('_fragment');
   let _pathSegments = dart.JsSymbol('_pathSegments');
@@ skipping 215 matching lines @@
       this.scheme = scheme;
       this[_userInfo] = userInfo;
       this[_host] = host;
       this[_port] = port;
       this[_path] = path;
       this[_query] = query;
       this[_fragment] = fragment;
       this[_pathSegments] = null;
       this[_queryParameters] = null;
     }
-    Uri(opts) {
+    static new(opts) {
       let scheme = opts && 'scheme' in opts ? opts.scheme : "";
       let userInfo = opts && 'userInfo' in opts ? opts.userInfo : "";
       let host = opts && 'host' in opts ? opts.host : null;
       let port = opts && 'port' in opts ? opts.port : null;
       let path = opts && 'path' in opts ? opts.path : null;
       let pathSegments = opts && 'pathSegments' in opts ? opts.pathSegments : null;
       let query = opts && 'query' in opts ? opts.query : null;
       let queryParameters = opts && 'queryParameters' in opts ? opts.queryParameters : null;
       let fragment = opts && 'fragment' in opts ? opts.fragment : null;
       scheme = Uri._makeScheme(scheme, Uri._stringOrNullLength(scheme));
       userInfo = Uri._makeUserInfo(userInfo, 0, Uri._stringOrNullLength(userInfo));
       host = Uri._makeHost(host, 0, Uri._stringOrNullLength(host), false);
       if (query == "")
         query = null;
       query = Uri._makeQuery(query, 0, Uri._stringOrNullLength(query), queryParameters);
       fragment = Uri._makeFragment(fragment, 0, Uri._stringOrNullLength(fragment));
       port = Uri._makePort(port, scheme);
       let isFile = scheme == "file";
       if (host == null && (dart.notNull(userInfo.isNotEmpty) || port != null || dart.notNull(isFile))) {
         host = "";
       }
       let ensureLeadingSlash = host != null;
       path = Uri._makePath(path, 0, Uri._stringOrNullLength(path), pathSegments, ensureLeadingSlash, isFile);
       return new Uri._internal(scheme, userInfo, host, port, path, query, fragment);
     }
-    http(authority, unencodedPath, queryParameters) {
+    static http(authority, unencodedPath, queryParameters) {
       if (queryParameters === void 0)
         queryParameters = null;
       return Uri._makeHttpUri("http", authority, unencodedPath, queryParameters);
     }
-    https(authority, unencodedPath, queryParameters) {
+    static https(authority, unencodedPath, queryParameters) {
       if (queryParameters === void 0)
         queryParameters = null;
       return Uri._makeHttpUri("https", authority, unencodedPath, queryParameters);
     }
     static _makeHttpUri(scheme, authority, unencodedPath, queryParameters) {
       let userInfo = "";
       let host = null;
       let port = null;
       if (authority != null && dart.notNull(authority.isNotEmpty)) {
         let hostStart = 0;
@@ skipping 25 matching lines @@
         for (; dart.notNull(hostEnd) < dart.notNull(authority.length); hostEnd = dart.notNull(hostEnd) + 1) {
           if (authority.codeUnitAt(hostEnd) == Uri._COLON) {
             let portString = authority.substring(dart.notNull(hostEnd) + 1);
             if (portString.isNotEmpty)
               port = int.parse(portString);
             break;
           }
         }
         host = authority.substring(hostStart, hostEnd);
       }
-      return new Uri({scheme: scheme, userInfo: userInfo, host: dart.as(host, String), port: dart.as(port, int), pathSegments: unencodedPath.split("/"), queryParameters: queryParameters});
+      return Uri.new({scheme: scheme, userInfo: userInfo, host: dart.as(host, String), port: dart.as(port, int), pathSegments: unencodedPath.split("/"), queryParameters: queryParameters});
     }
-    file(path, opts) {
+    static file(path, opts) {
       let windows = opts && 'windows' in opts ? opts.windows : null;
       windows = windows == null ? Uri._isWindows : windows;
       return windows ? dart.as(Uri._makeWindowsFileUrl(path), Uri) : dart.as(Uri._makeFileUri(path), Uri);
     }
     static get base() {
       let uri = _js_helper.Primitives.currentUri();
       if (uri != null)
         return Uri.parse(uri);
       throw new UnsupportedError("'Uri.base' is not supported");
     }
     static get _isWindows() {
       return false;
     }
     static _checkNonWindowsPathReservedCharacters(segments, argumentError) {
       segments[$forEach](dart.fn(segment => {
         if (dart.dsend(segment, 'contains', "/")) {
           if (argumentError) {
             throw new ArgumentError(`Illegal path character ${segment}`);
           } else {
             throw new UnsupportedError(`Illegal path character ${segment}`);
           }
         }
       }));
     }
     static _checkWindowsPathReservedCharacters(segments, argumentError, firstSegment) {
       if (firstSegment === void 0)
         firstSegment = 0;
       segments[$skip](firstSegment)[$forEach](dart.fn(segment => {
-        if (dart.dsend(segment, 'contains', new RegExp('["*/:<>?\\\\|]'))) {
+        if (dart.dsend(segment, 'contains', RegExp.new('["*/:<>?\\\\|]'))) {
           if (argumentError) {
             throw new ArgumentError("Illegal character in path");
           } else {
             throw new UnsupportedError("Illegal character in path");
           }
         }
       }));
     }
     static _checkWindowsDriveLetter(charCode, argumentError) {
       if (dart.notNull(Uri._UPPER_CASE_A) <= dart.notNull(charCode) && dart.notNull(charCode) <= dart.notNull(Uri._UPPER_CASE_Z) || dart.notNull(Uri._LOWER_CASE_A) <= dart.notNull(charCode) && dart.notNull(charCode) <= dart.notNull(Uri._LOWER_CASE_Z)) {
         return;
       }
       if (argumentError) {
-        throw new ArgumentError("Illegal drive letter " + dart.notNull(new String.fromCharCode(charCode)));
+        throw new ArgumentError("Illegal drive letter " + dart.notNull(String.fromCharCode(charCode)));
       } else {
-        throw new UnsupportedError("Illegal drive letter " + dart.notNull(new String.fromCharCode(charCode)));
+        throw new UnsupportedError("Illegal drive letter " + dart.notNull(String.fromCharCode(charCode)));
       }
     }
     static _makeFileUri(path) {
       let sep = "/";
       if (path.startsWith(sep)) {
-        return new Uri({scheme: "file", pathSegments: path.split(sep)});
+        return Uri.new({scheme: "file", pathSegments: path.split(sep)});
       } else {
-        return new Uri({pathSegments: path.split(sep)});
+        return Uri.new({pathSegments: path.split(sep)});
       }
     }
     static _makeWindowsFileUrl(path) {
       if (path.startsWith("\\\\?\\")) {
         if (path.startsWith("\\\\?\\UNC\\")) {
           path = `\\${path.substring(7)}`;
         } else {
           path = path.substring(4);
           if (dart.notNull(path.length) < 3 || path.codeUnitAt(1) != Uri._COLON || path.codeUnitAt(2) != Uri._BACKSLASH) {
             throw new ArgumentError("Windows paths with \\\\?\\ prefix must be absolute");
           }
         }
       } else {
         path = path.replaceAll("/", "\\");
       }
       let sep = "\\";
       if (dart.notNull(path.length) > 1 && path.get(1) == ":") {
         Uri._checkWindowsDriveLetter(path.codeUnitAt(0), true);
         if (path.length == 2 || path.codeUnitAt(2) != Uri._BACKSLASH) {
           throw new ArgumentError("Windows paths with drive letter must be absolute");
         }
         let pathSegments = path.split(sep);
         Uri._checkWindowsPathReservedCharacters(pathSegments, true, 1);
-        return new Uri({scheme: "file", pathSegments: pathSegments});
+        return Uri.new({scheme: "file", pathSegments: pathSegments});
       }
       if (dart.notNull(path.length) > 0 && path.get(0) == sep) {
         if (dart.notNull(path.length) > 1 && path.get(1) == sep) {
           let pathStart = path.indexOf("\\", 2);
           let hostPart = pathStart == -1 ? path.substring(2) : path.substring(2, pathStart);
           let pathPart = pathStart == -1 ? "" : path.substring(dart.notNull(pathStart) + 1);
           let pathSegments = pathPart.split(sep);
           Uri._checkWindowsPathReservedCharacters(pathSegments, true);
-          return new Uri({scheme: "file", host: hostPart, pathSegments: pathSegments});
+          return Uri.new({scheme: "file", host: hostPart, pathSegments: pathSegments});
         } else {
           let pathSegments = path.split(sep);
           Uri._checkWindowsPathReservedCharacters(pathSegments, true);
-          return new Uri({scheme: "file", pathSegments: pathSegments});
+          return Uri.new({scheme: "file", pathSegments: pathSegments});
         }
       } else {
         let pathSegments = path.split(sep);
         Uri._checkWindowsPathReservedCharacters(pathSegments, true);
-        return new Uri({pathSegments: pathSegments});
+        return Uri.new({pathSegments: pathSegments});
       }
     }
     replace(opts) {
       let scheme = opts && 'scheme' in opts ? opts.scheme : null;
       let userInfo = opts && 'userInfo' in opts ? opts.userInfo : null;
       let host = opts && 'host' in opts ? opts.host : null;
       let port = opts && 'port' in opts ? opts.port : null;
       let path = opts && 'path' in opts ? opts.path : null;
       let pathSegments = opts && 'pathSegments' in opts ? opts.pathSegments : null;
       let query = opts && 'query' in opts ? opts.query : null;
@@ skipping 44 matching lines @@
       if (fragment != null) {
         fragment = Uri._makeFragment(fragment, 0, fragment.length);
       } else if (this.hasFragment) {
         fragment = this.fragment;
       }
       return new Uri._internal(scheme, userInfo, host, port, path, query, fragment);
     }
     get pathSegments() {
       if (this[_pathSegments] == null) {
         let pathToSplit = !dart.notNull(this.path.isEmpty) && this.path.codeUnitAt(0) == Uri._SLASH ? this.path.substring(1) : this.path;
-        this[_pathSegments] = new (collection.UnmodifiableListView$(String))(pathToSplit == "" ? dart.const(dart.setType([], List$(String))) : new (List$(String)).from(pathToSplit.split("/")[$map](Uri.decodeComponent), {growable: false}));
+        this[_pathSegments] = new (collection.UnmodifiableListView$(String))(pathToSplit == "" ? dart.const(dart.setType([], List$(String))) : List$(String).from(pathToSplit.split("/")[$map](Uri.decodeComponent), {growable: false}));
       }
       return this[_pathSegments];
     }
     get queryParameters() {
       if (this[_queryParameters] == null) {
         this[_queryParameters] = new (collection.UnmodifiableMapView$(String, String))(Uri.splitQueryString(this.query));
       }
       return this[_queryParameters];
     }
     static _makePort(port, scheme) {
@@ skipping 198 matching lines @@
       let firstDigit = source.codeUnitAt(dart.notNull(index) + 1);
       let secondDigit = source.codeUnitAt(dart.notNull(index) + 2);
       if (!dart.notNull(Uri._isHexDigit(firstDigit)) || !dart.notNull(Uri._isHexDigit(secondDigit))) {
         return "%";
       }
       let value = dart.notNull(Uri._hexValue(firstDigit)) * 16 + dart.notNull(Uri._hexValue(secondDigit));
       if (Uri._isUnreservedChar(value)) {
         if (dart.notNull(lowerCase) && dart.notNull(Uri._UPPER_CASE_A) <= dart.notNull(value) && dart.notNull(Uri._UPPER_CASE_Z) >= dart.notNull(value)) {
           value = dart.notNull(value) | 32;
         }
-        return new String.fromCharCode(value);
+        return String.fromCharCode(value);
       }
       if (dart.notNull(firstDigit) >= dart.notNull(Uri._LOWER_CASE_A) || dart.notNull(secondDigit) >= dart.notNull(Uri._LOWER_CASE_A)) {
         return source.substring(index, dart.notNull(index) + 3).toUpperCase();
       }
       return null;
     }
     static _isUnreservedChar(ch) {
       return dart.notNull(ch) < 127 && dart.notNull(!dart.equals(dart.dsend(Uri._unreservedTable[$get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0));
     }
     static _escapeChar(char) {
       dart.assert(dart.dsend(char, '<=', 1114111));
       let hexDigits = "0123456789ABCDEF";
       let codeUnits = null;
       if (dart.dsend(char, '<', 128)) {
-        codeUnits = new List(3);
+        codeUnits = List.new(3);
         codeUnits[$set](0, Uri._PERCENT);
         codeUnits[$set](1, hexDigits.codeUnitAt(dart.as(dart.dsend(char, '>>', 4), int)));
         codeUnits[$set](2, hexDigits.codeUnitAt(dart.as(dart.dsend(char, '&', 15), int)));
       } else {
         let flag = 192;
         let encodedBytes = 2;
         if (dart.dsend(char, '>', 2047)) {
           flag = 224;
           encodedBytes = 3;
           if (dart.dsend(char, '>', 65535)) {
             encodedBytes = 4;
             flag = 240;
           }
         }
-        codeUnits = new List(3 * dart.notNull(encodedBytes));
+        codeUnits = List.new(3 * dart.notNull(encodedBytes));
         let index = 0;
         while ((encodedBytes = dart.notNull(encodedBytes) - 1) >= 0) {
           let byte = dart.as(dart.dsend(dart.dsend(dart.dsend(char, '>>', 6 * dart.notNull(encodedBytes)), '&', 63), '|', flag), int);
           codeUnits[$set](index, Uri._PERCENT);
           codeUnits[$set](dart.notNull(index) + 1, hexDigits.codeUnitAt(dart.notNull(byte) >> 4));
           codeUnits[$set](dart.notNull(index) + 2, hexDigits.codeUnitAt(dart.notNull(byte) & 15));
           index = dart.notNull(index) + 3;
           flag = 128;
         }
       }
-      return new String.fromCharCodes(dart.as(codeUnits, Iterable$(int)));
+      return String.fromCharCodes(dart.as(codeUnits, Iterable$(int)));
     }
     static _normalize(component, start, end, charTable) {
       let buffer = null;
       let sectionStart = start;
       let index = start;
       while (dart.notNull(index) < dart.notNull(end)) {
         let char = component.codeUnitAt(index);
         if (dart.notNull(char) < 127 && (dart.notNull(charTable[$get](dart.notNull(char) >> 4)) & 1 << (dart.notNull(char) & 15)) != 0) {
           index = dart.notNull(index) + 1;
         } else {
@@ skipping 408 matching lines @@
         }
 
       }
       if (wildcardSeen) {
         if (dart.notNull(parts[$length]) > 7) {
           error('an address with a wildcard must have less than 7 parts');
         }
       } else if (parts[$length] != 8) {
         error('an address without a wildcard must contain exactly 8 parts');
       }
-      let bytes = new (List$(int))(16);
+      let bytes = List$(int).new(16);
       for (let i = 0, index = 0; dart.notNull(i) < dart.notNull(parts[$length]); i = dart.notNull(i) + 1) {
         let value = parts[$get](i);
         if (value == -1) {
           let wildCardLength = 9 - dart.notNull(parts[$length]);
           for (let j = 0; dart.notNull(j) < dart.notNull(wildCardLength); j = dart.notNull(j) + 1) {
             bytes[$set](index, 0);
             bytes[$set](dart.notNull(index) + 1, 0);
             index = dart.notNull(index) + 2;
           }
         } else {
@@ skipping 54 matching lines @@
         simple = codeUnit != Uri._PERCENT && codeUnit != Uri._PLUS;
       }
       let bytes = null;
       if (simple) {
         if (dart.notNull(dart.equals(encoding, convert.UTF8)) || dart.notNull(dart.equals(encoding, convert.LATIN1))) {
           return text;
         } else {
           bytes = text.codeUnits;
         }
       } else {
-        bytes = new (List$(int))();
+        bytes = List$(int).new();
         for (let i = 0; dart.notNull(i) < dart.notNull(text.length); i = dart.notNull(i) + 1) {
           let codeUnit = text.codeUnitAt(i);
           if (dart.notNull(codeUnit) > 127) {
             throw new ArgumentError("Illegal percent encoding in URI");
           }
           if (codeUnit == Uri._PERCENT) {
             if (dart.notNull(i) + 3 > dart.notNull(text.length)) {
               throw new ArgumentError('Truncated URI');
             }
             bytes[$add](Uri._hexCharPairToByte(text, dart.notNull(i) + 1));
             i = dart.notNull(i) + 2;
           } else if (dart.notNull(plusToSpace) && codeUnit == Uri._PLUS) {
             bytes[$add](Uri._SPACE);
           } else {
             bytes[$add](codeUnit);
           }
         }
       }
       return encoding.decode(bytes);
     }
     static _isAlphabeticCharacter(codeUnit) {
       return dart.notNull(codeUnit) >= dart.notNull(Uri._LOWER_CASE_A) && dart.notNull(codeUnit) <= dart.notNull(Uri._LOWER_CASE_Z) || dart.notNull(codeUnit) >= dart.notNull(Uri._UPPER_CASE_A) && dart.notNull(codeUnit) <= dart.notNull(Uri._UPPER_CASE_Z);
     }
   }
   dart.defineNamedConstructor(Uri, '_internal');
-  dart.defineNamedConstructor(Uri, 'http');
-  dart.defineNamedConstructor(Uri, 'https');
-  dart.defineNamedConstructor(Uri, 'file');
   dart.setSignature(Uri, {
     constructors: () => ({
       _internal: [Uri, [String, String, String, num, String, String, String]],
-      Uri: [Uri, [], {scheme: String, userInfo: String, host: String, port: int, path: String, pathSegments: Iterable$(String), query: String, queryParameters: Map$(String, String), fragment: String}],
+      new: [Uri, [], {scheme: String, userInfo: String, host: String, port: int, path: String, pathSegments: Iterable$(String), query: String, queryParameters: Map$(String, String), fragment: String}],
       http: [Uri, [String, String], [Map$(String, String)]],
       https: [Uri, [String, String], [Map$(String, String)]],
       file: [Uri, [String], {windows: bool}]
     }),
     methods: () => ({
       replace: [Uri, [], {scheme: String, userInfo: String, host: String, port: int, path: String, pathSegments: Iterable$(String), query: String, queryParameters: Map$(String, String), fragment: String}],
       [_merge]: [String, [String, String]],
       [_hasDotSegments]: [bool, [String]],
       [_removeDotSegments]: [String, [String]],
       resolve: [Uri, [String]],
@@ skipping 85 matching lines @@
   Uri._pathCharTable = dart.const([0, 0, 32722, 12287, 65535, 34815, 65534, 18431]);
   Uri._pathCharOrSlashTable = dart.const([0, 0, 65490, 12287, 65535, 34815, 65534, 18431]);
   Uri._queryCharTable = dart.const([0, 0, 65490, 45055, 65535, 34815, 65534, 18431]);
   function _symbolToString(symbol) {
     return _internal.Symbol.getName(dart.as(symbol, _internal.Symbol));
   }
   dart.fn(_symbolToString, String, [Symbol]);
   function _symbolMapToStringMap(map) {
     if (map == null)
       return null;
-    let result = new (Map$(String, Object))();
+    let result = Map$(String, Object).new();
     map.forEach(dart.fn((key, value) => {
       result.set(_symbolToString(key), value);
     }, Object, [Symbol, Object]));
     return result;
   }
   dart.fn(_symbolMapToStringMap, Object, [Map$(Symbol, Object)]);
   class SupportJsExtensionMethods extends Object {
     SupportJsExtensionMethods() {
     }
   }
@@ skipping 131 matching lines @@
   exports.Stopwatch = Stopwatch;
   exports.String = String;
   exports.RuneIterator = RuneIterator;
   exports.StringBuffer = StringBuffer;
   exports.StringSink = StringSink;
   exports.Symbol = Symbol;
   exports.Type = Type;
   exports.Uri = Uri;
   exports.SupportJsExtensionMethods = SupportJsExtensionMethods;
 })(core, _js_helper, _internal, collection, _interceptors, math, convert);