Use signature inheritance when method types are unchanged

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 27 matching lines @@
       toString: dart.functionType(String, []),
       noSuchMethod: dart.functionType(dart.dynamic, [Invocation])
     })
   });
   class JsName extends Object {
     JsName(opts) {
       let name = opts && 'name' in opts ? opts.name : null;
       this.name = name;
     }
   }
-  dart.setSignature(JsName, {});
   class JsPeerInterface extends Object {
     JsPeerInterface(opts) {
       let name = opts && 'name' in opts ? opts.name : null;
       this.name = name;
     }
   }
-  dart.setSignature(JsPeerInterface, {});
   class SupportJsExtensionMethod extends Object {
     SupportJsExtensionMethod() {
     }
   }
-  dart.setSignature(SupportJsExtensionMethod, {});
   class Deprecated extends Object {
     Deprecated(expires) {
       this.expires = expires;
     }
     toString() {
       return `Deprecated feature. Will be removed ${this.expires}`;
     }
   }
-  dart.setSignature(Deprecated, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   class _Override extends Object {
     _Override() {
     }
   }
-  dart.setSignature(_Override, {});
   let deprecated = dart.const(new Deprecated("next release"));
   let override = dart.const(new _Override());
   class _Proxy extends Object {
     _Proxy() {
     }
   }
-  dart.setSignature(_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, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   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 250 matching lines @@
     }
   }
   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, {
     methods: () => ({
-      '==': dart.functionType(bool, [dart.dynamic]),
       isBefore: dart.functionType(bool, [DateTime]),
       isAfter: dart.functionType(bool, [DateTime]),
       isAtSameMomentAs: dart.functionType(bool, [DateTime]),
       compareTo: dart.functionType(int, [DateTime]),
       toLocal: dart.functionType(DateTime, []),
       toUtc: dart.functionType(DateTime, []),
-      toString: dart.functionType(String, []),
       toIso8601String: dart.functionType(String, []),
       add: dart.functionType(DateTime, [Duration]),
       subtract: dart.functionType(DateTime, [Duration]),
       difference: dart.functionType(Duration, [DateTime])
     }),
     statics: () => ({
       parse: dart.functionType(DateTime, [String]),
       _fourDigits: dart.functionType(String, [int]),
       _sixDigits: dart.functionType(String, [int]),
       _threeDigits: dart.functionType(String, [int]),
@@ skipping 188 matching lines @@
   dart.setSignature(Duration, {
     methods: () => ({
       '+': dart.functionType(Duration, [Duration]),
       '-': dart.functionType(Duration, [Duration]),
       '*': dart.functionType(Duration, [num]),
       '~/': dart.functionType(Duration, [int]),
       '<': dart.functionType(bool, [Duration]),
       '>': dart.functionType(bool, [Duration]),
       '<=': dart.functionType(bool, [Duration]),
       '>=': dart.functionType(bool, [Duration]),
-      '==': dart.functionType(bool, [dart.dynamic]),
       compareTo: dart.functionType(int, [Duration]),
-      toString: dart.functionType(String, []),
       abs: dart.functionType(Duration, []),
       'unary-': dart.functionType(Duration, [])
     })
   });
   Duration.MICROSECONDS_PER_MILLISECOND = 1000;
   Duration.MILLISECONDS_PER_SECOND = 1000;
   Duration.SECONDS_PER_MINUTE = 60;
   Duration.MINUTES_PER_HOUR = 60;
   Duration.HOURS_PER_DAY = 24;
   Duration.MICROSECONDS_PER_SECOND = dart.notNull(Duration.MICROSECONDS_PER_MILLISECOND) * dart.notNull(Duration.MILLISECONDS_PER_SECOND);
@@ skipping 35 matching lines @@
       _stringToSafeString: dart.functionType(String, [String]),
       _objectToString: dart.functionType(String, [Object])
     }),
     names: ['safeToString', '_stringToSafeString', '_objectToString']
   });
   class AssertionError extends Error {
     AssertionError() {
       super.Error();
     }
   }
-  dart.setSignature(AssertionError, {});
   class TypeError extends AssertionError {}
-  dart.setSignature(TypeError, {});
   class CastError extends Error {
     CastError() {
       super.Error();
     }
   }
-  dart.setSignature(CastError, {});
   class NullThrownError extends Error {
     NullThrownError() {
       super.Error();
     }
     toString() {
       return "Throw of null.";
     }
   }
-  dart.setSignature(NullThrownError, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   let _hasValue = dart.JsSymbol('_hasValue');
   class ArgumentError extends Error {
     ArgumentError(message) {
       if (message === void 0)
         message = null;
       this.message = message;
       this.invalidValue = null;
       this[_hasValue] = false;
       this.name = null;
       super.Error();
@@ skipping 24 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, {
-    methods: () => ({toString: dart.functionType(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, {
-    methods: () => ({toString: dart.functionType(String, [])}),
     statics: () => ({
       checkValueInInterval: dart.functionType(dart.void, [int, int, int], [String, String]),
       checkValidIndex: dart.functionType(dart.void, [int, dart.dynamic], [String, int, String]),
       checkValidRange: dart.functionType(dart.void, [int, int, int], [String, String, String]),
       checkNotNegative: dart.functionType(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, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   class FallThroughError extends Error {
     FallThroughError() {
       super.Error();
     }
   }
-  dart.setSignature(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, {
-    methods: () => ({toString: dart.functionType(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, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   class UnsupportedError extends Error {
     UnsupportedError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `Unsupported operation: ${this.message}`;
     }
   }
-  dart.setSignature(UnsupportedError, {
-    methods: () => ({toString: dart.functionType(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, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   class StateError extends Error {
     StateError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `Bad state: ${this.message}`;
     }
   }
-  dart.setSignature(StateError, {
-    methods: () => ({toString: dart.functionType(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, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   class OutOfMemoryError extends Object {
     OutOfMemoryError() {
     }
     toString() {
       return "Out of Memory";
     }
     get stackTrace() {
       return null;
     }
   }
   OutOfMemoryError[dart.implements] = () => [Error];
-  dart.setSignature(OutOfMemoryError, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   class StackOverflowError extends Object {
     StackOverflowError() {
     }
     toString() {
       return "Stack Overflow";
     }
     get stackTrace() {
       return null;
     }
   }
   StackOverflowError[dart.implements] = () => [Error];
-  dart.setSignature(StackOverflowError, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   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, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   class Exception extends Object {
     Exception(message) {
       if (message === void 0)
         message = null;
       return new _ExceptionImplementation(message);
     }
   }
-  dart.setSignature(Exception, {});
   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, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   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, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   class IntegerDivisionByZeroException extends Object {
     IntegerDivisionByZeroException() {
     }
     toString() {
       return "IntegerDivisionByZeroException";
     }
   }
   IntegerDivisionByZeroException[dart.implements] = () => [Exception];
-  dart.setSignature(IntegerDivisionByZeroException, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   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 19 matching lines @@
             Expando$()._keyCount = dart.notNull(x) + 1;
             return x;
           })()}`;
           _js_helper.Primitives.setProperty(this, Expando$()._KEY_PROPERTY_NAME, key);
         }
         return key;
       }
     }
     dart.setSignature(Expando, {
       methods: () => ({
-        toString: dart.functionType(String, []),
         get: dart.functionType(T, [Object]),
         set: dart.functionType(dart.void, [Object, T]),
         [_getKey]: dart.functionType(String, [])
       })
     });
     return Expando;
   });
   let Expando = Expando$();
   Expando._KEY_PROPERTY_NAME = 'expando$key';
   Expando._EXPANDO_PROPERTY_NAME = 'expando$values';
@@ skipping 41 matching lines @@
   dart.defineNamedConstructor(int, 'fromEnvironment');
   dart.setSignature(int, {
     statics: () => ({parse: dart.functionType(int, [String], {adi: int, nErro: dart.functionType(int, [String])})}),
     names: ['parse']
   });
   class Invocation extends Object {
     get isAccessor() {
       return dart.notNull(this.isGetter) || dart.notNull(this.isSetter);
     }
   }
-  dart.setSignature(Invocation, {});
   let $iterator = dart.JsSymbol('$iterator');
   let $join = dart.JsSymbol('$join');
   let Iterable$ = dart.generic(function(E) {
     class Iterable extends Object {
       Iterable() {
       }
       generate(count, generator) {
         if (generator === void 0)
           generator = null;
         if (dart.notNull(count) <= 0)
@@ skipping 110 matching lines @@
     _GeneratorIterator[dart.implements] = () => [Iterator$(E)];
     dart.setSignature(_GeneratorIterator, {
       methods: () => ({moveNext: dart.functionType(bool, [])})
     });
     return _GeneratorIterator;
   });
   let _GeneratorIterator = _GeneratorIterator$();
   let BidirectionalIterator$ = dart.generic(function(E) {
     class BidirectionalIterator extends Object {}
     BidirectionalIterator[dart.implements] = () => [Iterator$(E)];
-    dart.setSignature(BidirectionalIterator, {});
     return BidirectionalIterator;
   });
   let BidirectionalIterator = BidirectionalIterator$();
   let Iterator$ = dart.generic(function(E) {
     class Iterator extends Object {}
-    dart.setSignature(Iterator, {});
     return Iterator;
   });
   let Iterator = Iterator$();
   let $set = dart.JsSymbol('$set');
   let $add = dart.JsSymbol('$add');
   let $checkMutable = dart.JsSymbol('$checkMutable');
   let $checkGrowable = dart.JsSymbol('$checkGrowable');
   let $where = dart.JsSymbol('$where');
   let $expand = dart.JsSymbol('$expand');
   let $forEach = dart.JsSymbol('$forEach');
@@ skipping 420 matching lines @@
         [$skipWhile]: dart.functionType(Iterable$(E), [dart.functionType(bool, [E])]),
         [$reduce]: dart.functionType(E, [dart.functionType(E, [E, E])]),
         [$fold]: dart.functionType(dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]),
         [$firstWhere]: dart.functionType(E, [dart.functionType(bool, [E])], {rEls: dart.functionType(E, [])}),
         [$lastWhere]: dart.functionType(E, [dart.functionType(bool, [E])], {rEls: dart.functionType(E, [])}),
         [$singleWhere]: dart.functionType(E, [dart.functionType(bool, [E])]),
         [$elementAt]: dart.functionType(E, [int]),
         [$any]: dart.functionType(bool, [dart.functionType(bool, [E])]),
         [$every]: dart.functionType(bool, [dart.functionType(bool, [E])]),
         [$contains]: dart.functionType(bool, [Object]),
-        [$toString]: dart.functionType(String, []),
         [$toList]: dart.functionType(List$(E), [], {rowabl: bool}),
         [$toSet]: dart.functionType(exports.Set$(E), []),
         [$get]: dart.functionType(E, [int]),
         [$set]: dart.functionType(dart.void, [int, E]),
         [$add]: dart.functionType(dart.void, [E]),
         [$addAll]: dart.functionType(dart.void, [Iterable$(E)]),
         [$sort]: dart.functionType(dart.void, [], [dart.functionType(int, [E, E])]),
         [$shuffle]: dart.functionType(dart.void, [], [math.Random]),
         [$indexOf]: dart.functionType(int, [E], [int]),
         [$lastIndexOf]: dart.functionType(int, [E], [int]),
@@ skipping 34 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, {});
     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, {
-    methods: () => ({toString: dart.functionType(String, [])})
-  });
   num._parseError = false;
   class Pattern extends Object {}
-  dart.setSignature(Pattern, {});
   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 {}
-  dart.setSignature(Match, {});
   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, {});
   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, {});
     return Set;
   });
   dart.defineLazyClassGeneric(exports, 'Set', {get: Set$});
   let Sink$ = dart.generic(function(T) {
     class Sink extends Object {}
-    dart.setSignature(Sink, {});
     return Sink;
   });
   let Sink = Sink$();
   class StackTrace extends Object {}
-  dart.setSignature(StackTrace, {});
   let _stop = dart.JsSymbol('_stop');
   class Stopwatch extends Object {
     get frequency() {
       return Stopwatch._frequency;
     }
     Stopwatch() {
       this[_start] = null;
       this[_stop] = null;
       Stopwatch._initTicker();
     }
@@ skipping 143 matching lines @@
           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, {});
       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 164 matching lines @@
     }
   }
   StringBuffer[dart.implements] = () => [StringSink];
   dart.setSignature(StringBuffer, {
     methods: () => ({
       write: dart.functionType(dart.void, [Object]),
       writeCharCode: dart.functionType(dart.void, [int]),
       writeAll: dart.functionType(dart.void, [Iterable], [String]),
       writeln: dart.functionType(dart.void, [], [Object]),
       clear: dart.functionType(dart.void, []),
-      toString: dart.functionType(String, []),
       [_writeString]: dart.functionType(dart.void, [dart.dynamic])
     })
   });
   class StringSink extends Object {}
-  dart.setSignature(StringSink, {});
   class Symbol extends Object {
     Symbol(name) {
       return new _internal.Symbol(name);
     }
   }
-  dart.setSignature(Symbol, {});
   class Type extends Object {}
-  dart.setSignature(Type, {});
   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');
   let _merge = dart.JsSymbol('_merge');
@@ skipping 1256 matching lines @@
     methods: () => ({
       replace: dart.functionType(Uri, [], {chem: String, serInf: String, os: String, or: int, at: String, athSegment: Iterable$(String), uer: String, ueryParameter: Map$(String, String), ragmen: String}),
       [_merge]: dart.functionType(String, [String, String]),
       [_hasDotSegments]: dart.functionType(bool, [String]),
       [_removeDotSegments]: dart.functionType(String, [String]),
       resolve: dart.functionType(Uri, [String]),
       resolveUri: dart.functionType(Uri, [Uri]),
       toFilePath: dart.functionType(String, [], {indow: bool}),
       [_toFilePath]: dart.functionType(String, []),
       [_toWindowsFilePath]: dart.functionType(String, []),
-      [_writeAuthority]: dart.functionType(dart.void, [StringSink]),
-      toString: dart.functionType(String, []),
-      '==': dart.functionType(bool, [dart.dynamic])
+      [_writeAuthority]: dart.functionType(dart.void, [StringSink])
     }),
     statics: () => ({
       _defaultPort: dart.functionType(int, [String]),
       parse: dart.functionType(Uri, [String]),
       _fail: dart.functionType(dart.void, [String, int, String]),
       _makeHttpUri: dart.functionType(Uri, [String, String, String, Map$(String, String)]),
       _checkNonWindowsPathReservedCharacters: dart.functionType(dart.dynamic, [List$(String), bool]),
       _checkWindowsPathReservedCharacters: dart.functionType(dart.dynamic, [List$(String), bool], [int]),
       _checkWindowsDriveLetter: dart.functionType(dart.dynamic, [int, bool]),
       _makeFileUri: dart.functionType(dart.dynamic, [String]),
@@ skipping 81 matching lines @@
     map.forEach(dart.fn((key, value) => {
       result.set(_symbolToString(key), value);
     }, dart.dynamic, [Symbol, dart.dynamic]));
     return result;
   }
   dart.fn(_symbolMapToStringMap, dart.dynamic, [Map$(Symbol, dart.dynamic)]);
   class SupportJsExtensionMethods extends Object {
     SupportJsExtensionMethods() {
     }
   }
-  dart.setSignature(SupportJsExtensionMethods, {});
   class _ListConstructorSentinel extends Object {
     _ListConstructorSentinel() {
     }
   }
-  dart.setSignature(_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);