Add constructors to signatures

lib/runtime/dart/_interceptors.js

 var _interceptors = dart.defineLibrary(_interceptors, {});
 var core = dart.import(core);
 var _js_helper = dart.lazyImport(_js_helper);
 var _internal = dart.import(_internal);
 var _foreign_helper = dart.import(_foreign_helper);
 var _js_embedded_names = dart.import(_js_embedded_names);
 (function(exports, core, _js_helper, _internal, _foreign_helper, _js_embedded_names) {
   'use strict';
   let JSArray = Array;
   let JSMutableArray$ = dart.generic(function(E) {
@@ skipping 29 matching lines @@
       return _js_helper.Primitives.objectToString(this);
     }
     noSuchMethod(invocation) {
       throw new core.NoSuchMethodError(this, invocation.memberName, invocation.positionalArguments, invocation.namedArguments);
     }
     get runtimeType() {
       return _js_helper.getRuntimeType(this);
     }
   }
   dart.setSignature(Interceptor, {
+    constructors: () => ({Interceptor: [Interceptor, []]}),
     methods: () => ({'==': [core.bool, [core.Object]]})
   });
   let _isInt32 = Symbol('_isInt32');
   let _tdivFast = Symbol('_tdivFast');
   let _tdivSlow = Symbol('_tdivSlow');
   let _shlPositive = Symbol('_shlPositive');
   let _shrReceiverPositive = Symbol('_shrReceiverPositive');
   let _shrOtherPositive = Symbol('_shrOtherPositive');
   let _shrBothPositive = Symbol('_shrBothPositive');
   class JSNumber extends Interceptor {
@@ skipping 296 matching lines @@
       if (!dart.is(other, core.num))
         throw new core.ArgumentError(other);
       return this >= other;
     }
     get runtimeType() {
       return core.num;
     }
   }
   JSNumber[dart.implements] = () => [core.num];
   dart.setSignature(JSNumber, {
+    constructors: () => ({JSNumber: [JSNumber, []]}),
     methods: () => ({
       compareTo: [core.int, [core.num]],
       remainder: [core.num, [core.num]],
       abs: [core.num, []],
       toInt: [core.int, []],
       truncate: [core.int, []],
       ceil: [core.int, []],
       floor: [core.int, []],
       round: [core.int, []],
       ceilToDouble: [core.double, []],
@@ skipping 87 matching lines @@
     }
     get runtimeType() {
       return core.int;
     }
     ['~']() {
       return dart.as(~this >>> 0, core.int);
     }
   }
   JSInt[dart.implements] = () => [core.int, core.double];
   dart.setSignature(JSInt, {
+    constructors: () => ({JSInt: [JSInt, []]}),
     methods: () => ({
       toUnsigned: [core.int, [core.int]],
       toSigned: [core.int, [core.int]],
       '~': [core.int, []]
     }),
     statics: () => ({
       _bitCount: [core.int, [core.int]],
       _shru: [core.Object, [core.int, core.int]],
       _shrs: [core.Object, [core.int, core.int]],
       _ors: [core.Object, [core.int, core.int]],
       _spread: [core.int, [core.int]]
     }),
     names: ['_bitCount', '_shru', '_shrs', '_ors', '_spread']
   });
   class JSDouble extends JSNumber {
     JSDouble() {
       super.JSNumber();
     }
     get runtimeType() {
       return core.double;
     }
   }
   JSDouble[dart.implements] = () => [core.double];
+  dart.setSignature(JSDouble, {
+    constructors: () => ({JSDouble: [JSDouble, []]})
+  });
   class JSPositiveInt extends JSInt {
     JSPositiveInt() {
       super.JSInt();
     }
   }
   class JSUInt32 extends JSPositiveInt {}
   class JSUInt31 extends JSUInt32 {}
   let _defaultSplit = Symbol('_defaultSplit');
   class JSString extends Interceptor {
     JSString() {
@@ skipping 407 matching lines @@
     get(index) {
       if (!(typeof index == 'number'))
         throw new core.ArgumentError(index);
       if (dart.notNull(index) >= dart.notNull(this.length) || dart.notNull(index) < 0)
         throw new core.RangeError.value(index);
       return this[index];
     }
   }
   JSString[dart.implements] = () => [core.String, JSIndexable];
   dart.setSignature(JSString, {
+    constructors: () => ({JSString: [JSString, []]}),
     methods: () => ({
       codeUnitAt: [core.int, [core.int]],
       allMatches: [core.Iterable$(core.Match), [core.String], [core.int]],
       matchAsPrefix: [core.Match, [core.String], [core.int]],
       '+': [core.String, [core.String]],
       endsWith: [core.bool, [core.String]],
       replaceAll: [core.String, [core.Pattern, core.String]],
       replaceAllMapped: [core.String, [core.Pattern, dart.functionType(core.String, [core.Match])]],
       splitMapJoin: [core.String, [core.Pattern], {nMatc: dart.functionType(core.String, [core.Match]), nNonMatc: dart.functionType(core.String, [core.String])}],
       replaceFirst: [core.String, [core.Pattern, core.String], [core.int]],
@@ skipping 28 matching lines @@
       this[_string] = string;
     }
     get [core.$length]() {
       return this[_string].length;
     }
     [core.$get](i) {
       return this[_string].codeUnitAt(i);
     }
   }
   dart.setSignature(_CodeUnits, {
+    constructors: () => ({_CodeUnits: [_CodeUnits, [core.String]]}),
     methods: () => ({[core.$get]: [core.int, [core.int]]})
   });
   function _symbolToString(symbol) {
     return _internal.Symbol.getName(dart.as(symbol, _internal.Symbol));
   }
   dart.fn(_symbolToString, core.String, [core.Symbol]);
   function _symbolMapToStringMap(map) {
     if (map == null)
       return null;
     let result = new (core.Map$(core.String, core.Object))();
@@ skipping 121 matching lines @@
       return String(this);
     }
     get hashCode() {
       return this ? 2 * 3 * 23 * 3761 : 269 * 811;
     }
     get runtimeType() {
       return core.bool;
     }
   }
   JSBool[dart.implements] = () => [core.bool];
+  dart.setSignature(JSBool, {
+    constructors: () => ({JSBool: [JSBool, []]})
+  });
   class JSNull extends Interceptor {
     JSNull() {
       super.Interceptor();
     }
     ['=='](other) {
       return core.identical(null, other);
     }
     toString() {
       return 'null';
     }
     get hashCode() {
       return 0;
     }
     get runtimeType() {
       return core.Null;
     }
     noSuchMethod(invocation) {
       return super.noSuchMethod(invocation);
     }
   }
   JSNull[dart.implements] = () => [core.Null];
   dart.setSignature(JSNull, {
+    constructors: () => ({JSNull: [JSNull, []]}),
     methods: () => ({'==': [core.bool, [core.Object]]})
   });
   class JSIndexable extends core.Object {}
   class JSMutableIndexable extends JSIndexable {}
   class JSObject extends core.Object {}
   class JavaScriptObject extends Interceptor {
     JavaScriptObject() {
       super.Interceptor();
     }
     get hashCode() {
       return 0;
     }
     get runtimeType() {
       return JSObject;
     }
   }
   JavaScriptObject[dart.implements] = () => [JSObject];
+  dart.setSignature(JavaScriptObject, {
+    constructors: () => ({JavaScriptObject: [JavaScriptObject, []]})
+  });
   class PlainJavaScriptObject extends JavaScriptObject {
     PlainJavaScriptObject() {
       super.JavaScriptObject();
     }
   }
+  dart.setSignature(PlainJavaScriptObject, {
+    constructors: () => ({PlainJavaScriptObject: [PlainJavaScriptObject, []]})
+  });
   class UnknownJavaScriptObject extends JavaScriptObject {
     UnknownJavaScriptObject() {
       super.JavaScriptObject();
     }
     toString() {
       return String(this);
     }
   }
+  dart.setSignature(UnknownJavaScriptObject, {
+    constructors: () => ({UnknownJavaScriptObject: [UnknownJavaScriptObject, []]})
+  });
   // Exports:
   exports.JSArray = JSArray;
   exports.JSMutableArray$ = JSMutableArray$;
   exports.JSMutableArray = JSMutableArray;
   exports.JSFixedArray$ = JSFixedArray$;
   exports.JSFixedArray = JSFixedArray;
   exports.JSExtendableArray$ = JSExtendableArray$;
   exports.JSExtendableArray = JSExtendableArray;
   exports.Interceptor = Interceptor;
   exports.JSNumber = JSNumber;
@@ skipping 18 matching lines @@
   exports.findInterceptorForType = findInterceptorForType;
   exports.JSBool = JSBool;
   exports.JSNull = JSNull;
   exports.JSIndexable = JSIndexable;
   exports.JSMutableIndexable = JSMutableIndexable;
   exports.JSObject = JSObject;
   exports.JavaScriptObject = JavaScriptObject;
   exports.PlainJavaScriptObject = PlainJavaScriptObject;
   exports.UnknownJavaScriptObject = UnknownJavaScriptObject;
 })(_interceptors, core, _js_helper, _internal, _foreign_helper, _js_embedded_names);