Add constructors to signatures

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 15 matching lines @@
       return _js_helper.Primitives.objectToString(this);
     }
     noSuchMethod(invocation) {
       throw new NoSuchMethodError(this, invocation.memberName, invocation.positionalArguments, invocation.namedArguments);
     }
     get runtimeType() {
       return dart.realRuntimeType(this);
     }
   }
   dart.setSignature(Object, {
+    constructors: () => ({Object: [Object, []]}),
     methods: () => ({
       '==': [bool, [Object]],
       toString: [String, []],
       noSuchMethod: [Object, [Invocation]]
     })
   });
   class JsName extends Object {
     JsName(opts) {
       let name = opts && 'name' in opts ? opts.name : null;
       this.name = name;
     }
   }
+  dart.setSignature(JsName, {
+    constructors: () => ({JsName: [JsName, [], {am: String}]})
+  });
   class JsPeerInterface extends Object {
     JsPeerInterface(opts) {
       let name = opts && 'name' in opts ? opts.name : null;
       this.name = name;
     }
   }
+  dart.setSignature(JsPeerInterface, {
+    constructors: () => ({JsPeerInterface: [JsPeerInterface, [], {am: String}]})
+  });
   class SupportJsExtensionMethod extends Object {
     SupportJsExtensionMethod() {
     }
   }
+  dart.setSignature(SupportJsExtensionMethod, {
+    constructors: () => ({SupportJsExtensionMethod: [SupportJsExtensionMethod, []]})
+  });
   class Deprecated extends Object {
     Deprecated(expires) {
       this.expires = expires;
     }
     toString() {
       return `Deprecated feature. Will be removed ${this.expires}`;
     }
   }
+  dart.setSignature(Deprecated, {
+    constructors: () => ({Deprecated: [Deprecated, [String]]})
+  });
   class _Override extends Object {
     _Override() {
     }
   }
+  dart.setSignature(_Override, {
+    constructors: () => ({_Override: [_Override, []]})
+  });
   let deprecated = dart.const(new Deprecated("next release"));
   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) {
       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], {efaultValu: 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 {
       static compare(a, b) {
         return a.compareTo(b);
       }
@@ skipping 249 matching lines @@
       return dart.as(_js_helper.Primitives.getWeekday(this), int);
     }
   }
   DateTime[dart.implements] = () => [Comparable];
   dart.defineNamedConstructor(DateTime, 'utc');
   dart.defineNamedConstructor(DateTime, 'now');
   dart.defineNamedConstructor(DateTime, 'fromMillisecondsSinceEpoch');
   dart.defineNamedConstructor(DateTime, '_internal');
   dart.defineNamedConstructor(DateTime, '_now');
   dart.setSignature(DateTime, {
+    constructors: () => ({
+      DateTime: [DateTime, [int], [int, int, int, int, int, int]],
+      utc: [DateTime, [int], [int, int, int, int, int, int]],
+      now: [DateTime, []],
+      fromMillisecondsSinceEpoch: [DateTime, [int], {sUt: bool}],
+      _internal: [DateTime, [int, int, int, int, int, int, int, bool]],
+      _now: [DateTime, []]
+    }),
     methods: () => ({
       isBefore: [bool, [DateTime]],
       isAfter: [bool, [DateTime]],
       isAtSameMomentAs: [bool, [DateTime]],
       compareTo: [int, [DateTime]],
       toLocal: [DateTime, []],
       toUtc: [DateTime, []],
       toIso8601String: [String, []],
       add: [DateTime, [Duration]],
       subtract: [DateTime, [Duration]],
@@ skipping 186 matching lines @@
     abs() {
       return new Duration._microseconds(this[_duration].abs());
     }
     ['unary-']() {
       return new Duration._microseconds(-dart.notNull(this[_duration]));
     }
   }
   Duration[dart.implements] = () => [Comparable$(Duration)];
   dart.defineNamedConstructor(Duration, '_microseconds');
   dart.setSignature(Duration, {
+    constructors: () => ({
+      Duration: [Duration, [], {ay: int, our: int, inute: int, econd: int, illisecond: int, icrosecond: int}],

[vsm, 2015/05/21 21:21:17]

Looks like the param names are getting cut off.

[Leaf, 2015/05/21 21:35:19]

Yes, I'm looking into this.  I'll either add a fix to this CL or send it as a
separate CL if I don't get a fix shortly.

+      _microseconds: [Duration, [int]]
+    }),
     methods: () => ({
       '+': [Duration, [Duration]],
       '-': [Duration, [Duration]],
       '*': [Duration, [num]],
       '~/': [Duration, [int]],
       '<': [bool, [Duration]],
       '>': [bool, [Duration]],
       '<=': [bool, [Duration]],
       '>=': [bool, [Duration]],
       compareTo: [int, [Duration]],
@@ skipping 33 matching lines @@
       return _js_helper.jsonEncodeNative(string);
     }
     static _objectToString(object) {
       return _js_helper.Primitives.objectToString(object);
     }
     get stackTrace() {
       return _js_helper.Primitives.extractStackTrace(this);
     }
   }
   dart.setSignature(Error, {
+    constructors: () => ({Error: [Error, []]}),
     statics: () => ({
       safeToString: [String, [Object]],
       _stringToSafeString: [String, [String]],
       _objectToString: [String, [Object]]
     }),
     names: ['safeToString', '_stringToSafeString', '_objectToString']
   });
   class AssertionError extends Error {
     AssertionError() {
       super.Error();
@@ skipping 50 matching lines @@
       }
       let nameString = "";
       if (this.name != null) {
         nameString = ` (${this.name})`;
       }
       return `${this.message}${nameString}: ${Error.safeToString(this.invalidValue)}`;
     }
   }
   dart.defineNamedConstructor(ArgumentError, 'value');
   dart.defineNamedConstructor(ArgumentError, 'notNull');
+  dart.setSignature(ArgumentError, {
+    constructors: () => ({
+      ArgumentError: [ArgumentError, [], [Object]],
+      value: [ArgumentError, [Object], [String, String]],
+      notNull: [ArgumentError, [], [String]]
+    })
+  });
   class RangeError extends ArgumentError {
     RangeError(message) {
       this.start = null;
       this.end = null;
       super.ArgumentError(message);
     }
     value(value, name, message) {
       if (name === void 0)
         name = null;
       if (message === void 0)
@@ skipping 82 matching lines @@
       } 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]],
       checkValidRange: [dart.void, [int, int, int], [String, String, String]],
       checkNotNegative: [dart.void, [int], [String, String]]
     }),
     names: ['checkValueInInterval', 'checkValidIndex', 'checkValidRange', 'checkNotNegative']
   });
   class IndexError extends ArgumentError {
     IndexError(invalidValue, indexable, name, message, length) {
@@ skipping 17 matching lines @@
       dart.assert(this[_hasValue]);
       let target = Error.safeToString(this.indexable);
       let explanation = `index should be less than ${this.length}`;
       if (dart.dsend(this.invalidValue, '<', 0)) {
         explanation = "index must not be negative";
       }
       return `RangeError: ${this.message} (${target}[${this.invalidValue}]): ${explanation}`;
     }
   }
   IndexError[dart.implements] = () => [RangeError];
+  dart.setSignature(IndexError, {
+    constructors: () => ({IndexError: [IndexError, [int, Object], [String, String, int]]})
+  });
   class FallThroughError extends Error {
     FallThroughError() {
       super.Error();
     }
   }
+  dart.setSignature(FallThroughError, {
+    constructors: () => ({FallThroughError: [FallThroughError, []]})
+  });
   let _className = dart.JsSymbol('_className');
   class AbstractClassInstantiationError extends Error {
     AbstractClassInstantiationError(className) {
       this[_className] = className;
       super.Error();
     }
     toString() {
       return `Cannot instantiate abstract class: '${this[_className]}'`;
     }
   }
+  dart.setSignature(AbstractClassInstantiationError, {
+    constructors: () => ({AbstractClassInstantiationError: [AbstractClassInstantiationError, [String]]})
+  });
   let _receiver = dart.JsSymbol('_receiver');
   let _memberName = dart.JsSymbol('_memberName');
   let _arguments = dart.JsSymbol('_arguments');
   let _namedArguments = dart.JsSymbol('_namedArguments');
   let _existingArgumentNames = dart.JsSymbol('_existingArgumentNames');
   let $length = dart.JsSymbol('$length');
   let $get = dart.JsSymbol('$get');
   class NoSuchMethodError extends Error {
     NoSuchMethodError(receiver, memberName, positionalArguments, namedArguments, existingArgumentNames) {
       if (existingArgumentNames === void 0)
@@ skipping 36 matching lines @@
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
           sb.write(this[_existingArgumentNames][$get](i));
         }
         let formalParameters = dart.toString(sb);
         return "NoSuchMethodError: incorrect number of arguments passed to " + `method named '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Tried calling: ${this[_memberName]}(${actualParameters})\n` + `Found: ${this[_memberName]}(${formalParameters})`;
       }
     }
   }
+  dart.setSignature(NoSuchMethodError, {
+    constructors: () => ({NoSuchMethodError: [NoSuchMethodError, [Object, Symbol, List, Map$(Symbol, Object)], [List]]})
+  });
   class UnsupportedError extends Error {
     UnsupportedError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `Unsupported operation: ${this.message}`;
     }
   }
+  dart.setSignature(UnsupportedError, {
+    constructors: () => ({UnsupportedError: [UnsupportedError, [String]]})
+  });
   class UnimplementedError extends Error {
     UnimplementedError(message) {
       if (message === void 0)
         message = null;
       this.message = message;
       super.Error();
     }
     toString() {
       return this.message != null ? `UnimplementedError: ${this.message}` : "UnimplementedError";
     }
   }
   UnimplementedError[dart.implements] = () => [UnsupportedError];
+  dart.setSignature(UnimplementedError, {
+    constructors: () => ({UnimplementedError: [UnimplementedError, [], [String]]})
+  });
   class StateError extends Error {
     StateError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `Bad state: ${this.message}`;
     }
   }
+  dart.setSignature(StateError, {
+    constructors: () => ({StateError: [StateError, [String]]})
+  });
   class ConcurrentModificationError extends Error {
     ConcurrentModificationError(modifiedObject) {
       if (modifiedObject === void 0)
         modifiedObject = null;
       this.modifiedObject = modifiedObject;
       super.Error();
     }
     toString() {
       if (this.modifiedObject == null) {
         return "Concurrent modification during iteration.";
       }
       return "Concurrent modification during iteration: " + `${Error.safeToString(this.modifiedObject)}.`;
     }
   }
+  dart.setSignature(ConcurrentModificationError, {
+    constructors: () => ({ConcurrentModificationError: [ConcurrentModificationError, [], [Object]]})
+  });
   class OutOfMemoryError extends Object {
     OutOfMemoryError() {
     }
     toString() {
       return "Out of Memory";
     }
     get stackTrace() {
       return null;
     }
   }
   OutOfMemoryError[dart.implements] = () => [Error];
+  dart.setSignature(OutOfMemoryError, {
+    constructors: () => ({OutOfMemoryError: [OutOfMemoryError, []]})
+  });
   class StackOverflowError extends Object {
     StackOverflowError() {
     }
     toString() {
       return "Stack Overflow";
     }
     get stackTrace() {
       return null;
     }
   }
   StackOverflowError[dart.implements] = () => [Error];
+  dart.setSignature(StackOverflowError, {
+    constructors: () => ({StackOverflowError: [StackOverflowError, []]})
+  });
   class CyclicInitializationError extends Error {
     CyclicInitializationError(variableName) {
       if (variableName === void 0)
         variableName = null;
       this.variableName = variableName;
       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) {
       if (message === void 0)
         message = null;
       return new _ExceptionImplementation(message);
     }
   }
+  dart.setSignature(Exception, {
+    constructors: () => ({Exception: [Exception, [], [Object]]})
+  });
   class _ExceptionImplementation extends Object {
     _ExceptionImplementation(message) {
       if (message === void 0)
         message = null;
       this.message = message;
     }
     toString() {
       if (this.message == null)
         return "Exception";
       return `Exception: ${this.message}`;
     }
   }
   _ExceptionImplementation[dart.implements] = () => [Exception];
+  dart.setSignature(_ExceptionImplementation, {
+    constructors: () => ({_ExceptionImplementation: [_ExceptionImplementation, [], [Object]]})
+  });
   class FormatException extends Object {
     FormatException(message, source, offset) {
       if (message === void 0)
         message = "";
       if (source === void 0)
         source = null;
       if (offset === void 0)
         offset = -1;
       this.message = message;
       this.source = source;
@@ skipping 69 matching lines @@
           end = dart.notNull(offset) + 36;
           prefix = postfix = "...";
         }
       }
       let slice = dart.as(dart.dsend(this.source, 'substring', start, end), String);
       let markOffset = dart.notNull(offset) - dart.notNull(start) + dart.notNull(prefix.length);
       return `${report}${prefix}${slice}${postfix}\n${" "['*'](markOffset)}^\n`;
     }
   }
   FormatException[dart.implements] = () => [Exception];
+  dart.setSignature(FormatException, {
+    constructors: () => ({FormatException: [FormatException, [], [String, Object, int]]})
+  });
   class IntegerDivisionByZeroException extends Object {
     IntegerDivisionByZeroException() {
     }
     toString() {
       return "IntegerDivisionByZeroException";
     }
   }
   IntegerDivisionByZeroException[dart.implements] = () => [Exception];
+  dart.setSignature(IntegerDivisionByZeroException, {
+    constructors: () => ({IntegerDivisionByZeroException: [IntegerDivisionByZeroException, []]})
+  });
   let _getKey = dart.JsSymbol('_getKey');
   let Expando$ = dart.generic(function(T) {
     class Expando extends Object {
       Expando(name) {
         if (name === void 0)
           name = null;
         this.name = name;
       }
       toString() {
         return `Expando:${this.name}`;
@@ skipping 18 matching lines @@
             let x = Expando$()._keyCount;
             Expando$()._keyCount = dart.notNull(x) + 1;
             return x;
           })()}`;
           _js_helper.Primitives.setProperty(this, Expando$()._KEY_PROPERTY_NAME, key);
         }
         return key;
       }
     }
     dart.setSignature(Expando, {
+      constructors: () => ({Expando: [Expando$(T), [], [String]]}),
       methods: () => ({
         get: [T, [Object]],
         set: [dart.void, [Object, T]],
         [_getKey]: [String, []]
       })
     });
     return Expando;
   });
   let Expando = Expando$();
   Expando._KEY_PROPERTY_NAME = 'expando$key';
@@ skipping 34 matching lines @@
       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], {efaultValu: int}]}),
     statics: () => ({parse: [int, [String], {adi: int, nErro: dart.functionType(int, [String])}]}),

[vsm, 2015/05/21 21:21:17]

Looks like this bug is from an earlier CL - "nErro" should onError.

[Leaf, 2015/05/21 21:35:19]

Acknowledged.

     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) {
@@ skipping 13 matching lines @@
       [$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$();
   let _Generator$ = dart.generic(function(E) {
     let _Generator = dart.typedef('_Generator', () => dart.functionType(E, [int]));
     return _Generator;
   });
   let _Generator = _Generator$();
@@ skipping 40 matching lines @@
           return this;
         return new (exports._GeneratorIterable$(E)).slice(this[_start], newEnd, this[_generator]);
       }
       static _id(n) {
         return n;
       }
     }
     _GeneratorIterable[dart.implements] = () => [_internal.EfficientLength];
     dart.defineNamedConstructor(_GeneratorIterable, 'slice');
     dart.setSignature(_GeneratorIterable, {
+      constructors: () => ({
+        _GeneratorIterable: [exports._GeneratorIterable$(E), [int, dart.functionType(E, [int])]],
+        slice: [exports._GeneratorIterable$(E), [int, int, _Generator$(E)]]
+      }),
       methods: () => ({
         [$skip]: [Iterable$(E), [int]],
         [$take]: [Iterable$(E), [int]]
       }),
       statics: () => ({_id: [int, [int]]}),
       names: ['_id']
     });
     return _GeneratorIterable;
   });
   dart.defineLazyClassGeneric(exports, '_GeneratorIterable', {get: _GeneratorIterable$});
@@ skipping 16 matching lines @@
           this[_current] = null;
           return false;
         }
       }
       get current() {
         return this[_current];
       }
     }
     _GeneratorIterator[dart.implements] = () => [Iterator$(E)];
     dart.setSignature(_GeneratorIterator, {
+      constructors: () => ({_GeneratorIterator: [_GeneratorIterator$(E), [int, int, _Generator$(E)]]}),
       methods: () => ({moveNext: [bool, []]})
     });
     return _GeneratorIterator;
   });
   let _GeneratorIterator = _GeneratorIterator$();
   let BidirectionalIterator$ = dart.generic(function(E) {
     class BidirectionalIterator extends Object {}
     BidirectionalIterator[dart.implements] = () => [Iterator$(E)];
     return BidirectionalIterator;
   });
@@ skipping 412 matching lines @@
       [$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]],
+        filled: [List$(E), [int, E]],
+        from: [List$(E), [Iterable], {rowabl: bool}],
+        generate: [List$(E), [int, dart.functionType(E, [int])], {rowabl: 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])]],
         [$map]: [Iterable, [dart.functionType(Object, [E])]],
         [$join]: [String, [], [String]],
         [$take]: [Iterable$(E), [int]],
         [$takeWhile]: [Iterable$(E), [dart.functionType(bool, [E])]],
@@ skipping 55 matching lines @@
         return new (collection.LinkedHashMap$(K, V)).fromIterable(iterable, opts);
       }
       fromIterables(keys, values) {
         return new (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), []],
+        from: [Map$(K, V), [Map$()]],
+        identity: [Map$(K, V), []],
+        fromIterable: [Map$(K, V), [Iterable], {e: dart.functionType(K, [dart.bottom]), alu: dart.functionType(V, [dart.bottom])}],
+        fromIterables: [Map$(K, V), [Iterable$(K), Iterable$(V)]]
+      })
+    });
     return Map;
   });
   let Map = Map$();
   class Null extends Object {
     _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) {
       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], {ultiLin: bool, aseSensitiv: bool}]})
+  });
   let Set$ = dart.generic(function(E) {
     class Set extends collection.IterableBase$(E) {
       Set() {
         return new (collection.LinkedHashSet$(E))();
       }
       identity() {
         return new (collection.LinkedHashSet$(E)).identity();
       }
       from(elements) {
         return new (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), []],
+        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;
   });
   let Sink = Sink$();
   class StackTrace extends Object {}
   let _stop = dart.JsSymbol('_stop');
@@ skipping 49 matching lines @@
     }
     static _initTicker() {
       _js_helper.Primitives.initTicker();
       Stopwatch._frequency = _js_helper.Primitives.timerFrequency;
     }
     static _now() {
       return dart.as(dart.dcall(_js_helper.Primitives.timerTicks), int);
     }
   }
   dart.setSignature(Stopwatch, {
+    constructors: () => ({Stopwatch: [Stopwatch, []]}),
     methods: () => ({
       start: [dart.void, []],
       stop: [dart.void, []],
       reset: [dart.void, []]
     }),
     statics: () => ({
       _initTicker: [dart.void, []],
       _now: [int, []]
     }),
     names: ['_initTicker', '_now']
@@ skipping 55 matching lines @@
         }
       }
       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], {efaultValu: String}]
+    }),
     statics: () => ({_stringFromIterable: [String, [Iterable$(int), int, int]]}),
     names: ['_stringFromIterable']
   });
   dart.defineLazyClass(exports, {
     get Runes() {
       class Runes extends collection.IterableBase$(int) {
         Runes(string) {
           this.string = string;
           super.IterableBase();
         }
         get [$iterator]() {
           return new RuneIterator(this.string);
         }
         get [$last]() {
           if (this.string.length == 0) {
             throw new StateError('No elements.');
           }
           let length = this.string.length;
           let code = this.string.codeUnitAt(dart.notNull(length) - 1);
           if (dart.notNull(_isTrailSurrogate(code)) && dart.notNull(this.string.length) > 1) {
             let previousCode = this.string.codeUnitAt(dart.notNull(length) - 2);
             if (_isLeadSurrogate(previousCode)) {
               return _combineSurrogatePair(previousCode, code);
             }
           }
           return code;
         }
       }
+      dart.setSignature(Runes, {
+        constructors: () => ({Runes: [exports.Runes, [String]]})
+      });
       return Runes;
     }
   });
   function _isLeadSurrogate(code) {
     return (dart.notNull(code) & 64512) == 55296;
   }
   dart.fn(_isLeadSurrogate, bool, [int]);
   function _isTrailSurrogate(code) {
     return (dart.notNull(code) & 64512) == 56320;
   }
@@ skipping 92 matching lines @@
         }
       }
       this[_position] = position;
       this[_currentCodePoint] = codeUnit;
       return true;
     }
   }
   RuneIterator[dart.implements] = () => [BidirectionalIterator$(int)];
   dart.defineNamedConstructor(RuneIterator, 'at');
   dart.setSignature(RuneIterator, {
+    constructors: () => ({
+      RuneIterator: [RuneIterator, [String]],
+      at: [RuneIterator, [String, int]]
+    }),
     methods: () => ({
       [_checkSplitSurrogate]: [dart.void, [int]],
       reset: [dart.void, [], [int]],
       moveNext: [bool, []],
       movePrevious: [bool, []]
     })
   });
   let _contents = dart.JsSymbol('_contents');
   let _writeString = dart.JsSymbol('_writeString');
   class StringBuffer extends Object {
@@ skipping 46 matching lines @@
     }
     toString() {
       return _js_helper.Primitives.flattenString(this[_contents]);
     }
     [_writeString](str) {
       this[_contents] = _js_helper.Primitives.stringConcatUnchecked(this[_contents], dart.as(str, String));
     }
   }
   StringBuffer[dart.implements] = () => [StringSink];
   dart.setSignature(StringBuffer, {
+    constructors: () => ({StringBuffer: [StringBuffer, [], [Object]]}),
     methods: () => ({
       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) {
       return new _internal.Symbol(name);
     }
   }
+  dart.setSignature(Symbol, {
+    constructors: () => ({Symbol: [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');
   let _queryParameters = dart.JsSymbol('_queryParameters');
@@ skipping 1247 matching lines @@
     }
     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, [], {chem: String, serInf: String, os: String, or: int, at: String, athSegment: Iterable$(String), uer: String, ueryParameter: Map$(String, String), ragmen: String}],
+      http: [Uri, [String, String], [Map$(String, String)]],
+      https: [Uri, [String, String], [Map$(String, String)]],
+      file: [Uri, [String], {indow: bool}]
+    }),
     methods: () => ({
       replace: [Uri, [], {chem: String, serInf: String, os: String, or: int, at: String, athSegment: Iterable$(String), uer: String, ueryParameter: Map$(String, String), ragmen: String}],
       [_merge]: [String, [String, String]],
       [_hasDotSegments]: [bool, [String]],
       [_removeDotSegments]: [String, [String]],
       resolve: [Uri, [String]],
       resolveUri: [Uri, [Uri]],
       toFilePath: [String, [], {indow: bool}],
       [_toFilePath]: [String, []],
       [_toWindowsFilePath]: [String, []],
@@ skipping 92 matching lines @@
     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() {
     }
   }
+  dart.setSignature(SupportJsExtensionMethods, {
+    constructors: () => ({SupportJsExtensionMethods: [SupportJsExtensionMethods, []]})
+  });
   class _ListConstructorSentinel extends Object {
     _ListConstructorSentinel() {
     }
   }
+  dart.setSignature(_ListConstructorSentinel, {
+    constructors: () => ({_ListConstructorSentinel: [_ListConstructorSentinel, []]})
+  });
   // Exports:
   exports.Object = Object;
   exports.JsName = JsName;
   exports.JsPeerInterface = JsPeerInterface;
   exports.SupportJsExtensionMethod = SupportJsExtensionMethod;
   exports.Deprecated = Deprecated;
   exports.deprecated = deprecated;
   exports.override = override;
   exports.proxy = proxy;
   exports.bool = bool;
@@ skipping 111 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);