Add constructors to signatures

lib/runtime/dart/_js_helper.js

 var _js_helper = dart.defineLibrary(_js_helper, {});
 var core = dart.import(core);
 var collection = dart.import(collection);
 var _internal = dart.import(_internal);
 var _foreign_helper = dart.import(_foreign_helper);
 var _js_embedded_names = dart.import(_js_embedded_names);
 var _interceptors = dart.lazyImport(_interceptors);
 var _js_names = dart.import(_js_names);
 var async = dart.import(async);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
 (function(exports, core, collection, _internal, _foreign_helper, _js_embedded_names, _interceptors, _js_names, async, _isolate_helper) {
   'use strict';
   class NoSideEffects extends core.Object {
     NoSideEffects() {
     }
   }
+  dart.setSignature(NoSideEffects, {
+    constructors: () => ({NoSideEffects: [NoSideEffects, []]})
+  });
   class NoThrows extends core.Object {
     NoThrows() {
     }
   }
+  dart.setSignature(NoThrows, {
+    constructors: () => ({NoThrows: [NoThrows, []]})
+  });
   class NoInline extends core.Object {
     NoInline() {
     }
   }
+  dart.setSignature(NoInline, {
+    constructors: () => ({NoInline: [NoInline, []]})
+  });
   class IrRepresentation extends core.Object {
     IrRepresentation(value) {
       this.value = value;
     }
   }
+  dart.setSignature(IrRepresentation, {
+    constructors: () => ({IrRepresentation: [IrRepresentation, [core.bool]]})
+  });
   class Native extends core.Object {
     Native(name) {
       this.name = name;
     }
   }
+  dart.setSignature(Native, {
+    constructors: () => ({Native: [Native, [core.String]]})
+  });
   let _throwUnmodifiable = Symbol('_throwUnmodifiable');
   let ConstantMap$ = dart.generic(function(K, V) {
     class ConstantMap extends core.Object {
       _() {
       }
       get isEmpty() {
         return this.length == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
@@ skipping 21 matching lines @@
         return this[_throwUnmodifiable]();
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
         return this[_throwUnmodifiable]();
       }
     }
     ConstantMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(ConstantMap, '_');
     dart.setSignature(ConstantMap, {
+      constructors: () => ({_: [ConstantMap$(K, V), []]}),
       methods: () => ({
         [_throwUnmodifiable]: [core.Object, []],
         set: [dart.void, [K, V]],
         putIfAbsent: [V, [K, dart.functionType(V, [])]],
         remove: [V, [core.Object]],
         clear: [dart.void, []],
         addAll: [dart.void, [core.Map$(K, V)]]
       })
     });
     return ConstantMap;
@@ skipping 39 matching lines @@
       get keys() {
         return new (_ConstantMapKeyIterable$(K))(this);
       }
       get values() {
         return new (_internal.MappedIterable$(K, V))(this[_keys], dart.fn((key => dart.as(this[_fetch](key), V)).bind(this), V, [core.Object]));
       }
     }
     ConstantStringMap[dart.implements] = () => [_internal.EfficientLength];
     dart.defineNamedConstructor(ConstantStringMap, '_');
     dart.setSignature(ConstantStringMap, {
+      constructors: () => ({_: [ConstantStringMap$(K, V), [core.int, core.Object, core.List$(K)]]}),
       methods: () => ({
         containsValue: [core.bool, [core.Object]],
         containsKey: [core.bool, [core.Object]],
         get: [V, [core.Object]],
         [_fetch]: [core.Object, [core.Object]],
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]]
       })
     });
     return ConstantStringMap;
   });
@@ skipping 10 matching lines @@
           return false;
         if (dart.equals('__proto__', key))
           return true;
         return jsHasOwnProperty(this[_jsObject], dart.as(key, core.String));
       }
       [_fetch](key) {
         return dart.equals('__proto__', key) ? this[_protoValue] : jsPropertyAccess(this[_jsObject], dart.as(key, core.String));
       }
     }
     dart.defineNamedConstructor(ConstantProtoMap, '_');
+    dart.setSignature(ConstantProtoMap, {
+      constructors: () => ({_: [ConstantProtoMap$(K, V), [core.Object, core.Object, core.Object, V]]})
+    });
     return ConstantProtoMap;
   });
   let ConstantProtoMap = ConstantProtoMap$();
   let _map = Symbol('_map');
   let _ConstantMapKeyIterable$ = dart.generic(function(K) {
     class _ConstantMapKeyIterable extends collection.IterableBase$(K) {
       _ConstantMapKeyIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get [core.$iterator]() {
         return this[_map][_keys][core.$iterator];
       }
       get [core.$length]() {
         return this[_map][_keys][core.$length];
       }
     }
+    dart.setSignature(_ConstantMapKeyIterable, {
+      constructors: () => ({_ConstantMapKeyIterable: [_ConstantMapKeyIterable$(K), [ConstantStringMap$(K, core.Object)]]})
+    });
     return _ConstantMapKeyIterable;
   });
   let _ConstantMapKeyIterable = _ConstantMapKeyIterable$();
   let _jsData = Symbol('_jsData');
   let _getMap = Symbol('_getMap');
   let GeneralConstantMap$ = dart.generic(function(K, V) {
     class GeneralConstantMap extends ConstantMap$(K, V) {
       GeneralConstantMap(jsData) {
         this[_jsData] = jsData;
         super._();
@@ skipping 22 matching lines @@
         return this[_getMap]().keys;
       }
       get values() {
         return this[_getMap]().values;
       }
       get length() {
         return this[_getMap]().length;
       }
     }
     dart.setSignature(GeneralConstantMap, {
+      constructors: () => ({GeneralConstantMap: [GeneralConstantMap$(K, V), [core.Object]]}),
       methods: () => ({
         [_getMap]: [core.Map$(K, V), []],
         containsValue: [core.bool, [core.Object]],
         containsKey: [core.bool, [core.Object]],
         get: [V, [core.Object]],
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]]
       })
     });
     return GeneralConstantMap;
   });
@@ skipping 382 matching lines @@
     }
     get isMultiLine() {
       return this[_isMultiLine];
     }
     get isCaseSensitive() {
       return this[_isCaseSensitive];
     }
   }
   JSSyntaxRegExp[dart.implements] = () => [core.RegExp];
   dart.setSignature(JSSyntaxRegExp, {
+    constructors: () => ({JSSyntaxRegExp: [JSSyntaxRegExp, [core.String], {ultiLin: core.bool, aseSensitiv: core.bool}]}),
     methods: () => ({
       firstMatch: [core.Match, [core.String]],
       hasMatch: [core.bool, [core.String]],
       stringMatch: [core.String, [core.String]],
       allMatches: [core.Iterable$(core.Match), [core.String], [core.int]],
       [_execGlobal]: [core.Match, [core.String, core.int]],
       [_execAnchored]: [core.Match, [core.String, core.int]],
       matchAsPrefix: [core.Match, [core.String], [core.int]]
     }),
     statics: () => ({makeNative: [core.Object, [core.String, core.bool, core.bool, core.bool]]}),
@@ skipping 28 matching lines @@
     groups(groups) {
       let out = dart.setType([], core.List$(core.String));
       for (let i of groups) {
         out[core.$add](this.group(i));
       }
       return out;
     }
   }
   _MatchImplementation[dart.implements] = () => [core.Match];
   dart.setSignature(_MatchImplementation, {
+    constructors: () => ({_MatchImplementation: [_MatchImplementation, [core.Pattern, core.List$(core.String)]]}),
     methods: () => ({
       group: [core.String, [core.int]],
       get: [core.String, [core.int]],
       groups: [core.List$(core.String), [core.List$(core.int)]]
     })
   });
   let _re = Symbol('_re');
   let _string = Symbol('_string');
   let _start = Symbol('_start');
   class _AllMatchesIterable extends collection.IterableBase$(core.Match) {
     _AllMatchesIterable(re, string, start) {
       this[_re] = re;
       this[_string] = string;
       this[_start] = start;
       super.IterableBase();
     }
     get [core.$iterator]() {
       return new _AllMatchesIterator(this[_re], this[_string], this[_start]);
     }
   }
+  dart.setSignature(_AllMatchesIterable, {
+    constructors: () => ({_AllMatchesIterable: [_AllMatchesIterable, [JSSyntaxRegExp, core.String, core.int]]})
+  });
   let _regExp = Symbol('_regExp');
   let _nextIndex = Symbol('_nextIndex');
   let _current = Symbol('_current');
   class _AllMatchesIterator extends core.Object {
     _AllMatchesIterator(regExp, string, nextIndex) {
       this[_regExp] = regExp;
       this[_string] = string;
       this[_nextIndex] = nextIndex;
       this[_current] = null;
     }
@@ skipping 15 matching lines @@
           return true;
         }
       }
       this[_current] = null;
       this[_string] = null;
       return false;
     }
   }
   _AllMatchesIterator[dart.implements] = () => [core.Iterator$(core.Match)];
   dart.setSignature(_AllMatchesIterator, {
+    constructors: () => ({_AllMatchesIterator: [_AllMatchesIterator, [JSSyntaxRegExp, core.String, core.int]]}),
     methods: () => ({moveNext: [core.bool, []]})
   });
   function firstMatchAfter(regExp, string, start) {
     return regExp[_execGlobal](string, start);
   }
   dart.fn(firstMatchAfter, core.Match, [JSSyntaxRegExp, core.String, core.int]);
   class StringMatch extends core.Object {
     StringMatch(start, input, pattern) {
       this.start = start;
       this.input = input;
@@ skipping 17 matching lines @@
     groups(groups_) {
       let result = new (core.List$(core.String))();
       for (let g of groups_) {
         result[core.$add](this.group(g));
       }
       return result;
     }
   }
   StringMatch[dart.implements] = () => [core.Match];
   dart.setSignature(StringMatch, {
+    constructors: () => ({StringMatch: [StringMatch, [core.int, core.String, core.String]]}),
     methods: () => ({
       get: [core.String, [core.int]],
       group: [core.String, [core.int]],
       groups: [core.List$(core.String), [core.List$(core.int)]]
     })
   });
   function allMatchesInStringUnchecked(needle, haystack, startIndex) {
     let result = new (core.List$(core.Match))();
     let length = haystack.length;
     let patternLength = needle.length;
@@ skipping 185 matching lines @@
       return this[_unmangledName] = unmangledName;
     }
     get hashCode() {
       return dart.hashCode(this[_typeName]);
     }
     ['=='](other) {
       return dart.is(other, TypeImpl) && dart.equals(this[_typeName], dart.dload(other, _typeName));
     }
   }
   TypeImpl[dart.implements] = () => [core.Type];
+  dart.setSignature(TypeImpl, {
+    constructors: () => ({TypeImpl: [TypeImpl, [core.String]]})
+  });
   class TypeVariable extends core.Object {
     TypeVariable(owner, name, bound) {
       this.owner = owner;
       this.name = name;
       this.bound = bound;
     }
   }
+  dart.setSignature(TypeVariable, {
+    constructors: () => ({TypeVariable: [TypeVariable, [core.Type, core.String, core.int]]})
+  });
   function getMangledTypeName(type) {
     return type[_typeName];
   }
   dart.fn(getMangledTypeName, core.Object, [TypeImpl]);
   function setRuntimeTypeInfo(target, typeInfo) {
     dart.assert(dart.notNull(typeInfo == null) || dart.notNull(isJsArray(typeInfo)));
     if (target != null)
       target.$builtinTypeInfo = typeInfo;
     return target;
   }
@@ skipping 424 matching lines @@
   }
   dart.fn(unmangleGlobalNameIfPreservedAnyways, core.String, [core.String]);
   function unmangleAllIdentifiersIfPreservedAnyways(str) {
     return str;
   }
   dart.fn(unmangleAllIdentifiersIfPreservedAnyways, core.String, [core.String]);
   class _Patch extends core.Object {
     _Patch() {
     }
   }
+  dart.setSignature(_Patch, {
+    constructors: () => ({_Patch: [_Patch, []]})
+  });
   let patch = dart.const(new _Patch());
   class InternalMap extends core.Object {}
   function requiresPreamble() {
   }
   dart.fn(requiresPreamble);
   function isJsIndexable(object, record) {
     if (record != null) {
       let result = _interceptors.dispatchRecordIndexability(record);
       if (result != null)
         return dart.as(result, core.bool);
@@ skipping 160 matching lines @@
       } else {
         return dart.dsend(cached, 'invokeOn', victim, invocation[_arguments]);
       }
     }
     static getCachedInvocation(invocation, victim) {
       return invocation[_getCachedInvocation](victim);
     }
   }
   JSInvocationMirror[dart.implements] = () => [core.Invocation];
   dart.setSignature(JSInvocationMirror, {
+    constructors: () => ({JSInvocationMirror: [JSInvocationMirror, [core.Object, core.String, core.int, core.List, core.List]]}),
     methods: () => ({[_getCachedInvocation]: [core.Object, [core.Object]]}),
     statics: () => ({
       invokeFromMirror: [core.Object, [JSInvocationMirror, core.Object]],
       getCachedInvocation: [core.Object, [JSInvocationMirror, core.Object]]
     }),
     names: ['invokeFromMirror', 'getCachedInvocation']
   });
   JSInvocationMirror.METHOD = 0;
   JSInvocationMirror.GETTER = 1;
   JSInvocationMirror.SETTER = 2;
@@ skipping 19 matching lines @@
         let _ = [victim];
         _[core.$addAll](arguments$);
         arguments$ = _;
         if (this.cachedInterceptor != null)
           receiver = this.cachedInterceptor;
       }
       return this.jsFunction.apply(receiver, arguments$);
     }
   }
   dart.setSignature(CachedInvocation, {
+    constructors: () => ({CachedInvocation: [CachedInvocation, [core.String, core.Object, core.bool, _interceptors.Interceptor]]}),
     methods: () => ({invokeOn: [core.Object, [core.Object, core.List]]})
   });
   class CachedCatchAllInvocation extends CachedInvocation {
     CachedCatchAllInvocation(name, jsFunction, isIntercepted, cachedInterceptor) {
       this.info = new ReflectionInfo(jsFunction);
       super.CachedInvocation(name, jsFunction, isIntercepted, cachedInterceptor);
     }
     get isGetterStub() {
       return false;
     }
@@ skipping 25 matching lines @@
         throw new UnimplementedNoSuchMethodError(`Invocation of unstubbed method '${this.info.reflectionName}'` + ` with ${providedArgumentCount} arguments (too few).`);
       } else if (dart.notNull(providedArgumentCount) > dart.notNull(fullParameterCount)) {
         throw new UnimplementedNoSuchMethodError(`Invocation of unstubbed method '${this.info.reflectionName}'` + ` with ${providedArgumentCount} arguments (too many).`);
       }
       for (let i = providedArgumentCount; dart.notNull(i) < dart.notNull(fullParameterCount); i = dart.notNull(i) + 1) {
         arguments$[core.$add](getMetadata(this.info.defaultValue(i)));
       }
       return this.jsFunction.apply(receiver, arguments$);
     }
   }
+  dart.setSignature(CachedCatchAllInvocation, {
+    constructors: () => ({CachedCatchAllInvocation: [CachedCatchAllInvocation, [core.String, core.Object, core.bool, _interceptors.Interceptor]]})
+  });
   class CachedNoSuchMethodInvocation extends core.Object {
     CachedNoSuchMethodInvocation(interceptor) {
       this.interceptor = interceptor;
     }
     get isNoSuchMethod() {
       return true;
     }
     get isGetterStub() {
       return false;
     }
     invokeOn(victim, invocation) {
       let receiver = this.interceptor == null ? victim : this.interceptor;
       return dart.dsend(receiver, 'noSuchMethod', invocation);
     }
   }
   dart.setSignature(CachedNoSuchMethodInvocation, {
+    constructors: () => ({CachedNoSuchMethodInvocation: [CachedNoSuchMethodInvocation, [core.Object]]}),
     methods: () => ({invokeOn: [core.Object, [core.Object, core.Invocation]]})
   });
   class ReflectionInfo extends core.Object {
     internal(jsFunction, data, isAccessor, requiredParameterCount, optionalParameterCount, areOptionalParametersNamed, functionType) {
       this.jsFunction = jsFunction;
       this.data = data;
       this.isAccessor = isAccessor;
       this.requiredParameterCount = requiredParameterCount;
       this.optionalParameterCount = optionalParameterCount;
       this.areOptionalParametersNamed = areOptionalParametersNamed;
@@ skipping 87 matching lines @@
       } else {
         throw new RuntimeError('Unexpected function type');
       }
     }
     get reflectionName() {
       return this.jsFunction.$reflectionName;
     }
   }
   dart.defineNamedConstructor(ReflectionInfo, 'internal');
   dart.setSignature(ReflectionInfo, {
+    constructors: () => ({
+      internal: [ReflectionInfo, [core.Object, core.List, core.bool, core.int, core.int, core.bool, core.Object]],
+      ReflectionInfo: [ReflectionInfo, [core.Object]]
+    }),
     methods: () => ({
       parameterName: [core.String, [core.int]],
       parameterMetadataAnnotations: [core.List$(core.int), [core.int]],
       defaultValue: [core.int, [core.int]],
       defaultValueInOrder: [core.int, [core.int]],
       parameterNameInOrder: [core.String, [core.int]],
       sortedIndex: [core.int, [core.int]],
       computeFunctionRti: [core.Object, [core.Object]]
     })
   });
@@ skipping 702 matching lines @@
           (void 0).$method$;
         } catch (e) {
           return e.message;
         }
 
       };
       return func();
     }
   }
   dart.setSignature(TypeErrorDecoder, {
+    constructors: () => ({TypeErrorDecoder: [TypeErrorDecoder, [core.int, core.int, core.int, core.int, core.int, core.String]]}),
     methods: () => ({matchTypeError: [core.Object, [core.Object]]}),
     statics: () => ({
       buildJavaScriptObject: [core.Object, []],
       buildJavaScriptObjectWithNonClosure: [core.Object, []],
       extractPattern: [core.Object, [core.String]],
       provokeCallErrorOn: [core.String, [core.Object]],
       provokeCallErrorOnNull: [core.String, []],
       provokeCallErrorOnUndefined: [core.String, []],
       provokePropertyErrorOn: [core.String, [core.Object]],
       provokePropertyErrorOnNull: [core.String, []],
@@ skipping 40 matching lines @@
       this[_method] = match == null ? null : dart.as(match.method, core.String);
       super.Error();
     }
     toString() {
       if (this[_method] == null)
         return `NullError: ${this[_message]}`;
       return `NullError: Cannot call "${this[_method]}" on null`;
     }
   }
   NullError[dart.implements] = () => [core.NoSuchMethodError];
+  dart.setSignature(NullError, {
+    constructors: () => ({NullError: [NullError, [core.String, core.Object]]})
+  });
   class JsNoSuchMethodError extends core.Error {
     JsNoSuchMethodError(message, match) {
       this[_message] = message;
       this[_method] = match == null ? null : dart.as(match.method, core.String);
       this[_receiver] = match == null ? null : dart.as(match.receiver, core.String);
       super.Error();
     }
     toString() {
       if (this[_method] == null)
         return `NoSuchMethodError: ${this[_message]}`;
       if (this[_receiver] == null) {
         return `NoSuchMethodError: Cannot call "${this[_method]}" (${this[_message]})`;
       }
       return `NoSuchMethodError: Cannot call "${this[_method]}" on "${this[_receiver]}" ` + `(${this[_message]})`;
     }
   }
   JsNoSuchMethodError[dart.implements] = () => [core.NoSuchMethodError];
+  dart.setSignature(JsNoSuchMethodError, {
+    constructors: () => ({JsNoSuchMethodError: [JsNoSuchMethodError, [core.String, core.Object]]})
+  });
   class UnknownJsTypeError extends core.Error {
     UnknownJsTypeError(message) {
       this[_message] = message;
       super.Error();
     }
     toString() {
       return this[_message].isEmpty ? 'Error' : `Error: ${this[_message]}`;
     }
   }
+  dart.setSignature(UnknownJsTypeError, {
+    constructors: () => ({UnknownJsTypeError: [UnknownJsTypeError, [core.String]]})
+  });
   function unwrapException(ex) {
     let saveStackTrace = error => {
       if (dart.is(error, core.Error)) {
         let thrownStackTrace = error.$thrownJsError;
         if (thrownStackTrace == null) {
           error.$thrownJsError = ex;
         }
       }
       return error;
     };
@@ skipping 77 matching lines @@
       if (this[_trace] != null)
         return this[_trace];
       let trace = null;
       if (typeof this[_exception] === "object") {
         trace = dart.as(this[_exception].stack, core.String);
       }
       return this[_trace] = trace == null ? '' : trace;
     }
   }
   _StackTrace[dart.implements] = () => [core.StackTrace];
+  dart.setSignature(_StackTrace, {
+    constructors: () => ({_StackTrace: [_StackTrace, [core.Object]]})
+  });
   function objectHashCode(object) {
     if (dart.notNull(object == null) || typeof object != 'object') {
       return dart.hashCode(object);
     } else {
       return Primitives.objectHashCode(object);
     }
   }
   dart.fn(objectHashCode, core.int, [core.Object]);
   function fillLiteralMap(keyValuePairs, result) {
     let index = 0;
@@ skipping 288 matching lines @@
         Closure.functionCounter = dart.notNull(x) + 1;
         return x;
       })()}` + '}')();
     }
     toString() {
       return "Closure";
     }
   }
   Closure[dart.implements] = () => [core.Function];
   dart.setSignature(Closure, {
+    constructors: () => ({Closure: [Closure, []]}),
     statics: () => ({
       fromTearOff: [core.Object, [core.Object, core.List, core.List, core.bool, core.Object, core.String]],
       cspForwardCall: [core.Object, [core.int, core.bool, core.String, core.Object]],
       forwardCallTo: [core.Object, [core.Object, core.Object, core.bool]],
       cspForwardInterceptedCall: [core.Object, [core.int, core.bool, core.String, core.Object]],
       forwardInterceptedCallTo: [core.Object, [core.Object, core.Object]]
     }),
     names: ['fromTearOff', 'cspForwardCall', 'forwardCallTo', 'cspForwardInterceptedCall', 'forwardInterceptedCallTo']
   });
   Closure.FUNCTION_INDEX = 0;
@@ skipping 69 matching lines @@
       let names = _interceptors.JSArray.markFixedList(dart.as(Object.getOwnPropertyNames(template), core.List));
       for (let i = 0; dart.notNull(i) < dart.notNull(names[core.$length]); i = dart.notNull(i) + 1) {
         let name = names[core.$get](i);
         if (template[name] === fieldName) {
           return name;
         }
       }
     }
   }
   dart.setSignature(BoundClosure, {
+    constructors: () => ({BoundClosure: [BoundClosure, [core.Object, core.Object, core.Object, core.String]]}),
     statics: () => ({
       selfOf: [core.Object, [BoundClosure]],
       targetOf: [core.Object, [BoundClosure]],
       receiverOf: [core.Object, [BoundClosure]],
       nameOf: [core.Object, [BoundClosure]],
       selfFieldName: [core.String, []],
       receiverFieldName: [core.String, []],
       computeFieldNamed: [core.String, [core.String]]
     }),
     names: ['selfOf', 'targetOf', 'receiverOf', 'nameOf', 'selfFieldName', 'receiverFieldName', 'computeFieldNamed']
@@ skipping 10 matching lines @@
   dart.fn(jsPropertyAccess, core.Object, [core.Object, core.String]);
   function getFallThroughError() {
     return new FallThroughErrorImplementation();
   }
   dart.fn(getFallThroughError);
   class Creates extends core.Object {
     Creates(types) {
       this.types = types;
     }
   }
+  dart.setSignature(Creates, {
+    constructors: () => ({Creates: [Creates, [core.String]]})
+  });
   class Returns extends core.Object {
     Returns(types) {
       this.types = types;
     }
   }
+  dart.setSignature(Returns, {
+    constructors: () => ({Returns: [Returns, [core.String]]})
+  });
   class JSName extends core.Object {
     JSName(name) {
       this.name = name;
     }
   }
+  dart.setSignature(JSName, {
+    constructors: () => ({JSName: [JSName, [core.String]]})
+  });
   function boolConversionCheck(value) {
     if (typeof value == 'boolean')
       return value;
     boolTypeCheck(value);
     dart.assert(value != null);
     return false;
   }
   dart.fn(boolConversionCheck);
   function stringTypeCheck(value) {
     if (value == null)
@@ skipping 264 matching lines @@
     fromMessage(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return this.message;
     }
   }
   TypeErrorImplementation[dart.implements] = () => [core.TypeError];
   dart.defineNamedConstructor(TypeErrorImplementation, 'fromMessage');
+  dart.setSignature(TypeErrorImplementation, {
+    constructors: () => ({
+      TypeErrorImplementation: [TypeErrorImplementation, [core.Object, core.String]],
+      fromMessage: [TypeErrorImplementation, [core.String]]
+    })
+  });
   class CastErrorImplementation extends core.Error {
     CastErrorImplementation(actualType, expectedType) {
       this.message = `CastError: Casting value of type ${actualType} to` + ` incompatible type ${expectedType}`;
       super.Error();
     }
     toString() {
       return this.message;
     }
   }
   CastErrorImplementation[dart.implements] = () => [core.CastError];
+  dart.setSignature(CastErrorImplementation, {
+    constructors: () => ({CastErrorImplementation: [CastErrorImplementation, [core.Object, core.Object]]})
+  });
   class FallThroughErrorImplementation extends core.FallThroughError {
     FallThroughErrorImplementation() {
       super.FallThroughError();
     }
     toString() {
       return "Switch case fall-through.";
     }
   }
+  dart.setSignature(FallThroughErrorImplementation, {
+    constructors: () => ({FallThroughErrorImplementation: [FallThroughErrorImplementation, []]})
+  });
   function assertHelper(condition) {
     if (!(typeof condition == 'boolean')) {
       if (dart.is(condition, core.Function))
         condition = dart.dcall(condition);
       if (!(typeof condition == 'boolean')) {
         throw new TypeErrorImplementation(condition, 'bool');
       }
     }
     if (!dart.equals(true, condition))
       throw new core.AssertionError();
@@ skipping 10 matching lines @@
   dart.fn(throwCyclicInit, dart.void, [core.String]);
   class RuntimeError extends core.Error {
     RuntimeError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `RuntimeError: ${this.message}`;
     }
   }
+  dart.setSignature(RuntimeError, {
+    constructors: () => ({RuntimeError: [RuntimeError, [core.Object]]})
+  });
   class DeferredNotLoadedError extends core.Error {
     DeferredNotLoadedError(libraryName) {
       this.libraryName = libraryName;
       super.Error();
     }
     toString() {
       return `Deferred library ${this.libraryName} was not loaded.`;
     }
   }
   DeferredNotLoadedError[dart.implements] = () => [core.NoSuchMethodError];
+  dart.setSignature(DeferredNotLoadedError, {
+    constructors: () => ({DeferredNotLoadedError: [DeferredNotLoadedError, [core.String]]})
+  });
   class RuntimeType extends core.Object {
     RuntimeType() {
     }
   }
+  dart.setSignature(RuntimeType, {
+    constructors: () => ({RuntimeType: [RuntimeType, []]})
+  });
   let _isTest = Symbol('_isTest');
   let _extractFunctionTypeObjectFrom = Symbol('_extractFunctionTypeObjectFrom');
   let _asCheck = Symbol('_asCheck');
   let _check = Symbol('_check');
   let _assertCheck = Symbol('_assertCheck');
   class RuntimeFunctionType extends RuntimeType {
     RuntimeFunctionType(returnType, parameterTypes, optionalParameterTypes, namedParameters) {
       this.returnType = returnType;
       this.parameterTypes = parameterTypes;
       this.optionalParameterTypes = optionalParameterTypes;
@@ skipping 122 matching lines @@
           result = dart.notNull(result) + `${rti} ${name}`;
           needsComma = true;
         }
         result = dart.notNull(result) + '}';
       }
       result = dart.notNull(result) + `) -> ${this.returnType}`;
       return result;
     }
   }
   dart.setSignature(RuntimeFunctionType, {
+    constructors: () => ({RuntimeFunctionType: [RuntimeFunctionType, [RuntimeType, core.List$(RuntimeType), core.List$(RuntimeType), core.Object]]}),
     methods: () => ({
       [_isTest]: [core.bool, [core.Object]],
       [_asCheck]: [core.Object, [core.Object]],
       [_assertCheck]: [core.Object, [core.Object]],
       [_check]: [core.Object, [core.Object, core.bool]],
       [_extractFunctionTypeObjectFrom]: [core.Object, [core.Object]],
       toRti: [core.Object, []]
     }),
     statics: () => ({listToRti: [core.Object, [core.Object]]}),
     names: ['listToRti']
@@ skipping 20 matching lines @@
       super.RuntimeType();
     }
     toString() {
       return 'dynamic';
     }
     toRti() {
       return null;
     }
   }
   dart.setSignature(DynamicRuntimeType, {
+    constructors: () => ({DynamicRuntimeType: [DynamicRuntimeType, []]}),
     methods: () => ({toRti: [core.Object, []]})
   });
   function getDynamicRuntimeType() {
     return dart.const(new DynamicRuntimeType());
   }
   dart.fn(getDynamicRuntimeType, RuntimeType, []);
   class VoidRuntimeType extends RuntimeType {
     VoidRuntimeType() {
       super.RuntimeType();
     }
     toString() {
       return 'void';
     }
     toRti() {
       return dart.throw_('internal error');
     }
   }
   dart.setSignature(VoidRuntimeType, {
+    constructors: () => ({VoidRuntimeType: [VoidRuntimeType, []]}),
     methods: () => ({toRti: [core.Object, []]})
   });
   function getVoidRuntimeType() {
     return dart.const(new VoidRuntimeType());
   }
   dart.fn(getVoidRuntimeType, RuntimeType, []);
   function functionTypeTestMetaHelper() {
     let dyn = x;
     let dyn2 = x;
     let fixedListOrNull = dart.as(x, core.List);
@@ skipping 41 matching lines @@
       let rti = allClasses[this.name];
       if (rti == null)
         throw `no type for '${this.name}'`;
       return rti;
     }
     toString() {
       return this.name;
     }
   }
   dart.setSignature(RuntimeTypePlain, {
+    constructors: () => ({RuntimeTypePlain: [RuntimeTypePlain, [core.String]]}),
     methods: () => ({toRti: [core.Object, []]})
   });
   class RuntimeTypeGeneric extends RuntimeType {
     RuntimeTypeGeneric(name, arguments$, rti) {
       this.name = name;
       this.arguments = arguments$;
       this.rti = rti;
       super.RuntimeType();
     }
     toRti() {
       if (this.rti != null)
         return this.rti;
       let allClasses = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.ALL_CLASSES);
       let result = [allClasses[this.name]];
       if (dart.dindex(result, 0) == null) {
         throw `no type for '${this.name}<...>'`;
       }
       for (let argument of this.arguments) {
         result.push(argument.toRti());
       }
       return this.rti = result;
     }
     toString() {
       return `${this.name}<${this.arguments[core.$join](", ")}>`;
     }
   }
   dart.setSignature(RuntimeTypeGeneric, {
+    constructors: () => ({RuntimeTypeGeneric: [RuntimeTypeGeneric, [core.String, core.List$(RuntimeType), core.Object]]}),
     methods: () => ({toRti: [core.Object, []]})
   });
   let _typeData = Symbol('_typeData');
   let _cachedToString = Symbol('_cachedToString');
   let _hasReturnType = Symbol('_hasReturnType');
   let _returnType = Symbol('_returnType');
   let _isVoid = Symbol('_isVoid');
   let _hasArguments = Symbol('_hasArguments');
   let _hasOptionalArguments = Symbol('_hasOptionalArguments');
   let _optionalArguments = Symbol('_optionalArguments');
@@ skipping 83 matching lines @@
         s = dart.notNull(s) + 'void';
       } else if (this[_hasReturnType]) {
         s = dart.notNull(s) + dart.notNull(this[_convert](this[_returnType]));
       } else {
         s = dart.notNull(s) + 'dynamic';
       }
       return this[_cachedToString] = `${s}`;
     }
   }
   dart.setSignature(FunctionTypeInfoDecoderRing, {
+    constructors: () => ({FunctionTypeInfoDecoderRing: [FunctionTypeInfoDecoderRing, [core.Object]]}),
     methods: () => ({
       toRuntimeType: [RuntimeType, []],
       [_convert]: [core.String, [core.Object]]
     })
   });
   class UnimplementedNoSuchMethodError extends core.Error {
     UnimplementedNoSuchMethodError(message) {
       this[_message] = message;
       super.Error();
     }
     toString() {
       return `Unsupported operation: ${this[_message]}`;
     }
   }
   UnimplementedNoSuchMethodError[dart.implements] = () => [core.NoSuchMethodError];
+  dart.setSignature(UnimplementedNoSuchMethodError, {
+    constructors: () => ({UnimplementedNoSuchMethodError: [UnimplementedNoSuchMethodError, [core.String]]})
+  });
   function random64() {
     let int32a = Math.random() * 0x100000000 >>> 0;
     let int32b = Math.random() * 0x100000000 >>> 0;
     return dart.notNull(int32a) + dart.notNull(int32b) * 4294967296;
   }
   dart.fn(random64, core.int, []);
   function jsonEncodeNative(string) {
     return JSON.stringify(string);
   }
   dart.fn(jsonEncodeNative, core.String, [core.String]);
@@ skipping 115 matching lines @@
   class MainError extends core.Error {
     MainError(message) {
       this[_message] = message;
       super.Error();
     }
     toString() {
       return `NoSuchMethodError: ${this[_message]}`;
     }
   }
   MainError[dart.implements] = () => [core.NoSuchMethodError];
+  dart.setSignature(MainError, {
+    constructors: () => ({MainError: [MainError, [core.String]]})
+  });
   function missingMain() {
     throw new MainError("No top-level function named 'main'.");
   }
   dart.fn(missingMain, dart.void, []);
   function badMain() {
     throw new MainError("'main' is not a function.");
   }
   dart.fn(badMain, dart.void, []);
   function mainHasTooManyParameters() {
     throw new MainError("'main' expects too many parameters.");
@@ skipping 227 matching lines @@
   exports.jsonEncodeNative = jsonEncodeNative;
   exports.getIsolateAffinityTag = getIsolateAffinityTag;
   exports.LoadLibraryFunctionType = LoadLibraryFunctionType;
   exports.DeferredLoadCallback = DeferredLoadCallback;
   exports.loadDeferredLibrary = loadDeferredLibrary;
   exports.MainError = MainError;
   exports.missingMain = missingMain;
   exports.badMain = badMain;
   exports.mainHasTooManyParameters = mainHasTooManyParameters;
 })(_js_helper, core, collection, _internal, _foreign_helper, _js_embedded_names, _interceptors, _js_names, async, _isolate_helper);