Use signature inheritance when method types are unchanged

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, {});
   class NoThrows extends core.Object {
     NoThrows() {
     }
   }
-  dart.setSignature(NoThrows, {});
   class NoInline extends core.Object {
     NoInline() {
     }
   }
-  dart.setSignature(NoInline, {});
   class IrRepresentation extends core.Object {
     IrRepresentation(value) {
       this.value = value;
     }
   }
-  dart.setSignature(IrRepresentation, {});
   class Native extends core.Object {
     Native(name) {
       this.name = name;
     }
   }
-  dart.setSignature(Native, {});
   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 22 matching lines @@
       }
       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, {
       methods: () => ({
-        toString: dart.functionType(core.String, []),
         [_throwUnmodifiable]: dart.functionType(dart.dynamic, []),
         set: dart.functionType(dart.void, [K, V]),
         putIfAbsent: dart.functionType(V, [K, dart.functionType(V, [])]),
         remove: dart.functionType(V, [core.Object]),
         clear: dart.functionType(dart.void, []),
         addAll: dart.functionType(dart.void, [core.Map$(K, V)])
       })
     });
     return ConstantMap;
   });
@@ skipping 68 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, {
-      methods: () => ({
-        containsKey: dart.functionType(core.bool, [core.Object]),
-        [_fetch]: dart.functionType(dart.dynamic, [dart.dynamic])
-      })
-    });
     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, {});
     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 425 matching lines @@
     get isMultiLine() {
       return this[_isMultiLine];
     }
     get isCaseSensitive() {
       return this[_isCaseSensitive];
     }
   }
   JSSyntaxRegExp[dart.implements] = () => [core.RegExp];
   dart.setSignature(JSSyntaxRegExp, {
     methods: () => ({
-      toString: dart.functionType(core.String, []),
       firstMatch: dart.functionType(core.Match, [core.String]),
       hasMatch: dart.functionType(core.bool, [core.String]),
       stringMatch: dart.functionType(core.String, [core.String]),
       allMatches: dart.functionType(core.Iterable$(core.Match), [core.String], [core.int]),
       [_execGlobal]: dart.functionType(core.Match, [core.String, core.int]),
       [_execAnchored]: dart.functionType(core.Match, [core.String, core.int]),
       matchAsPrefix: dart.functionType(core.Match, [core.String], [core.int])
     }),
     statics: () => ({makeNative: dart.functionType(dart.dynamic, [core.String, core.bool, core.bool, core.bool])}),
     names: ['makeNative']
@@ skipping 47 matching lines @@
     _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, {});
   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 257 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, {
-    methods: () => ({
-      toString: dart.functionType(core.String, []),
-      '==': dart.functionType(core.bool, [dart.dynamic])
-    })
-  });
   class TypeVariable extends core.Object {
     TypeVariable(owner, name, bound) {
       this.owner = owner;
       this.name = name;
       this.bound = bound;
     }
   }
-  dart.setSignature(TypeVariable, {});
   function getMangledTypeName(type) {
     return type[_typeName];
   }
   dart.fn(getMangledTypeName, dart.dynamic, [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, {});
   let patch = dart.const(new _Patch());
   class InternalMap extends core.Object {}
-  dart.setSignature(InternalMap, {});
   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);
     }
     return dart.is(object, exports.JavaScriptIndexingBehavior);
@@ skipping 242 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, {
-    methods: () => ({invokeOn: dart.functionType(dart.dynamic, [core.Object, core.List])})
-  });
   class CachedNoSuchMethodInvocation extends core.Object {
     CachedNoSuchMethodInvocation(interceptor) {
       this.interceptor = interceptor;
     }
     get isNoSuchMethod() {
       return true;
     }
     get isGetterStub() {
       return false;
     }
@@ skipping 885 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, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
-  });
   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, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
-  });
   class UnknownJsTypeError extends core.Error {
     UnknownJsTypeError(message) {
       this[_message] = message;
       super.Error();
     }
     toString() {
       return this[_message].isEmpty ? 'Error' : `Error: ${this[_message]}`;
     }
   }
-  dart.setSignature(UnknownJsTypeError, {
-    methods: () => ({toString: dart.functionType(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, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
-  });
   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, [dart.dynamic]);
   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, {
-    methods: () => ({toString: dart.functionType(core.String, [])}),
     statics: () => ({
       fromTearOff: dart.functionType(dart.dynamic, [dart.dynamic, core.List, core.List, core.bool, dart.dynamic, core.String]),
       cspForwardCall: dart.functionType(dart.dynamic, [core.int, core.bool, core.String, dart.dynamic]),
       forwardCallTo: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic, core.bool]),
       cspForwardInterceptedCall: dart.functionType(dart.dynamic, [core.int, core.bool, core.String, dart.dynamic]),
       forwardInterceptedCallTo: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])
     }),
     names: ['fromTearOff', 'cspForwardCall', 'forwardCallTo', 'cspForwardInterceptedCall', 'forwardInterceptedCallTo']
   });
   Closure.FUNCTION_INDEX = 0;
   Closure.NAME_INDEX = 1;
   Closure.CALL_NAME_INDEX = 2;
   Closure.REQUIRED_PARAMETER_INDEX = 3;
   Closure.OPTIONAL_PARAMETER_INDEX = 4;
   Closure.DEFAULT_ARGUMENTS_INDEX = 5;
   Closure.functionCounter = 0;
   function closureFromTearOff(receiver, functions, reflectionInfo, isStatic, jsArguments, name) {
     return Closure.fromTearOff(receiver, _interceptors.JSArray.markFixedList(dart.as(functions, core.List)), _interceptors.JSArray.markFixedList(dart.as(reflectionInfo, core.List)), !!isStatic, jsArguments, name);
   }
   dart.fn(closureFromTearOff);
   class TearOffClosure extends Closure {
     TearOffClosure() {
       super.Closure();
     }
   }
-  dart.setSignature(TearOffClosure, {});
   let _self = Symbol('_self');
   let _target = Symbol('_target');
   let _name = Symbol('_name');
   class BoundClosure extends TearOffClosure {
     BoundClosure(self, target, receiver, name) {
       this[_self] = self;
       this[_target] = target;
       this[_receiver] = receiver;
       this[_name] = name;
     }
@@ skipping 44 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, {
-    methods: () => ({'==': dart.functionType(core.bool, [dart.dynamic])}),
     statics: () => ({
       selfOf: dart.functionType(dart.dynamic, [BoundClosure]),
       targetOf: dart.functionType(dart.dynamic, [BoundClosure]),
       receiverOf: dart.functionType(dart.dynamic, [BoundClosure]),
       nameOf: dart.functionType(dart.dynamic, [BoundClosure]),
       selfFieldName: dart.functionType(core.String, []),
       receiverFieldName: dart.functionType(core.String, []),
       computeFieldNamed: dart.functionType(core.String, [core.String])
     }),
     names: ['selfOf', 'targetOf', 'receiverOf', 'nameOf', 'selfFieldName', 'receiverFieldName', 'computeFieldNamed']
@@ skipping 10 matching lines @@
   dart.fn(jsPropertyAccess, dart.dynamic, [dart.dynamic, core.String]);
   function getFallThroughError() {
     return new FallThroughErrorImplementation();
   }
   dart.fn(getFallThroughError);
   class Creates extends core.Object {
     Creates(types) {
       this.types = types;
     }
   }
-  dart.setSignature(Creates, {});
   class Returns extends core.Object {
     Returns(types) {
       this.types = types;
     }
   }
-  dart.setSignature(Returns, {});
   class JSName extends core.Object {
     JSName(name) {
       this.name = name;
     }
   }
-  dart.setSignature(JSName, {});
   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 246 matching lines @@
   dart.fn(checkMalformedType);
   function checkDeferredIsLoaded(loadId, uri) {
     if (!dart.notNull(exports._loadedLibraries[core.$contains](loadId))) {
       throw new DeferredNotLoadedError(uri);
     }
   }
   dart.fn(checkDeferredIsLoaded, dart.void, [core.String, core.String]);
   dart.defineLazyClass(exports, {
     get JavaScriptIndexingBehavior() {
       class JavaScriptIndexingBehavior extends _interceptors.JSMutableIndexable {}
-      dart.setSignature(JavaScriptIndexingBehavior, {});
       return JavaScriptIndexingBehavior;
     }
   });
   class TypeErrorImplementation extends core.Error {
     TypeErrorImplementation(value, type) {
       this.message = `type '${Primitives.objectTypeName(value)}' is not a subtype ` + `of type '${type}'`;
       super.Error();
     }
     fromMessage(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return this.message;
     }
   }
   TypeErrorImplementation[dart.implements] = () => [core.TypeError];
   dart.defineNamedConstructor(TypeErrorImplementation, 'fromMessage');
-  dart.setSignature(TypeErrorImplementation, {
-    methods: () => ({toString: dart.functionType(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, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
-  });
   class FallThroughErrorImplementation extends core.FallThroughError {
     FallThroughErrorImplementation() {
       super.FallThroughError();
     }
     toString() {
       return "Switch case fall-through.";
     }
   }
-  dart.setSignature(FallThroughErrorImplementation, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
-  });
   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, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
-  });
   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, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
-  });
   class RuntimeType extends core.Object {
     RuntimeType() {
     }
   }
-  dart.setSignature(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 128 matching lines @@
       return result;
     }
   }
   dart.setSignature(RuntimeFunctionType, {
     methods: () => ({
       [_isTest]: dart.functionType(core.bool, [dart.dynamic]),
       [_asCheck]: dart.functionType(dart.dynamic, [dart.dynamic]),
       [_assertCheck]: dart.functionType(dart.dynamic, [dart.dynamic]),
       [_check]: dart.functionType(dart.dynamic, [dart.dynamic, core.bool]),
       [_extractFunctionTypeObjectFrom]: dart.functionType(dart.dynamic, [dart.dynamic]),
-      toRti: dart.functionType(dart.dynamic, []),
-      toString: dart.functionType(core.String, [])
+      toRti: dart.functionType(dart.dynamic, [])
     }),
     statics: () => ({listToRti: dart.functionType(dart.dynamic, [dart.dynamic])}),
     names: ['listToRti']
   });
   RuntimeFunctionType.inAssert = false;
   function buildFunctionType(returnType, parameterTypes, optionalParameterTypes) {
     return new RuntimeFunctionType(dart.as(returnType, RuntimeType), dart.as(parameterTypes, core.List$(RuntimeType)), dart.as(optionalParameterTypes, core.List$(RuntimeType)), null);
   }
   dart.fn(buildFunctionType, RuntimeFunctionType, [dart.dynamic, dart.dynamic, dart.dynamic]);
   function buildNamedFunctionType(returnType, parameterTypes, namedParameters) {
@@ skipping 13 matching lines @@
       super.RuntimeType();
     }
     toString() {
       return 'dynamic';
     }
     toRti() {
       return null;
     }
   }
   dart.setSignature(DynamicRuntimeType, {
-    methods: () => ({
-      toString: dart.functionType(core.String, []),
-      toRti: dart.functionType(dart.dynamic, [])
-    })
+    methods: () => ({toRti: dart.functionType(dart.dynamic, [])})
   });
   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, {
-    methods: () => ({
-      toString: dart.functionType(core.String, []),
-      toRti: dart.functionType(dart.dynamic, [])
-    })
+    methods: () => ({toRti: dart.functionType(dart.dynamic, [])})
   });
   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);
     let fixedListOrNull2 = dart.as(x, core.List);
@@ skipping 40 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, {
-    methods: () => ({
-      toRti: dart.functionType(dart.dynamic, []),
-      toString: dart.functionType(core.String, [])
-    })
+    methods: () => ({toRti: dart.functionType(dart.dynamic, [])})
   });
   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, {
-    methods: () => ({
-      toRti: dart.functionType(dart.dynamic, []),
-      toString: dart.functionType(core.String, [])
-    })
+    methods: () => ({toRti: dart.functionType(dart.dynamic, [])})
   });
   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');
   let _hasNamedArguments = Symbol('_hasNamedArguments');
@@ skipping 84 matching lines @@
         s = dart.notNull(s) + dart.notNull(this[_convert](this[_returnType]));
       } else {
         s = dart.notNull(s) + 'dynamic';
       }
       return this[_cachedToString] = `${s}`;
     }
   }
   dart.setSignature(FunctionTypeInfoDecoderRing, {
     methods: () => ({
       toRuntimeType: dart.functionType(RuntimeType, []),
-      [_convert]: dart.functionType(core.String, [dart.dynamic]),
-      toString: dart.functionType(core.String, [])
+      [_convert]: dart.functionType(core.String, [dart.dynamic])
     })
   });
   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, {
-    methods: () => ({toString: dart.functionType(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, {
-    methods: () => ({toString: dart.functionType(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);