Handle dynamic as bottom inside of function type reps

lib/runtime/dart/core.js

 dart_library.library('dart/core', null, /* Imports */[
   "dart_runtime/dart"
 ], /* Lazy imports */[
   'dart/_js_helper',
   'dart/_internal',
   'dart/collection',
   'dart/_interceptors',
   'dart/convert'
 ], function(exports, dart, _js_helper, _internal, collection, _interceptors, convert) {
   'use strict';
@@ skipping 19 matching lines @@
     noSuchMethod(invocation) {
       throw new NoSuchMethodError(this, invocation.memberName, invocation.positionalArguments, invocation.namedArguments);
     }
     get runtimeType() {
       return dart.realRuntimeType(this);
     }
   }
   dart.setSignature(Object, {
     constructors: () => ({Object: [Object, []]}),
     methods: () => ({
-      '==': [bool, [Object]],
+      '==': [bool, [dart.dynamic]],
       toString: [String, []],
-      noSuchMethod: [Object, [Invocation]]
+      noSuchMethod: [dart.dynamic, [Invocation]]
     })
   });
   class Deprecated extends Object {
     Deprecated(expires) {
       this.expires = expires;
     }
     toString() {
       return `Deprecated feature. Will be removed ${this.expires}`;
     }
   }
@@ skipping 640 matching lines @@
       if (this.name != null) {
         nameString = ` (${this.name})`;
       }
       return `${this.message}${nameString}: ${Error.safeToString(this.invalidValue)}`;
     }
   }
   dart.defineNamedConstructor(ArgumentError, 'value');
   dart.defineNamedConstructor(ArgumentError, 'notNull');
   dart.setSignature(ArgumentError, {
     constructors: () => ({
-      ArgumentError: [ArgumentError, [], [Object]],
-      value: [ArgumentError, [Object], [String, String]],
+      ArgumentError: [ArgumentError, [], [dart.dynamic]],
+      value: [ArgumentError, [dart.dynamic], [String, String]],
       notNull: [ArgumentError, [], [String]]
     })
   });
   class RangeError extends ArgumentError {
     RangeError(message) {
       this.start = null;
       this.end = null;
       super.ArgumentError(message);
     }
     value(value, name, message) {
@@ skipping 85 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.setSignature(RangeError, {
     constructors: () => ({
-      RangeError: [RangeError, [Object]],
+      RangeError: [RangeError, [dart.dynamic]],
       value: [RangeError, [num], [String, String]],
       range: [RangeError, [num, int, int], [String, String]],
-      index: [RangeError, [int, Object], [String, String, int]]
+      index: [RangeError, [int, dart.dynamic], [String, String, int]]
     }),
     statics: () => ({
       checkValueInInterval: [dart.void, [int, int, int], [String, String]],
-      checkValidIndex: [dart.void, [int, Object], [String, int, String]],
+      checkValidIndex: [dart.void, [int, dart.dynamic], [String, int, String]],
       checkValidRange: [dart.void, [int, int, int], [String, String, String]],
       checkNotNegative: [dart.void, [int], [String, String]]
     }),
     names: ['checkValueInInterval', 'checkValidIndex', 'checkValidRange', 'checkNotNegative']
   });
   class IndexError extends ArgumentError {
     IndexError(invalidValue, indexable, name, message, length) {
       if (name === void 0)
         name = null;
       if (message === void 0)
@@ skipping 15 matching lines @@
       let target = Error.safeToString(this.indexable);
       let explanation = `index should be less than ${this.length}`;
       if (dart.notNull(dart.as(dart.dsend(this.invalidValue, '<', 0), bool))) {
         explanation = "index must not be negative";
       }
       return `RangeError: ${this.message} (${target}[${this.invalidValue}]): ${explanation}`;
     }
   }
   IndexError[dart.implements] = () => [RangeError];
   dart.setSignature(IndexError, {
-    constructors: () => ({IndexError: [IndexError, [int, Object], [String, String, int]]})
+    constructors: () => ({IndexError: [IndexError, [int, dart.dynamic], [String, String, int]]})
   });
   class FallThroughError extends Error {
     FallThroughError() {
       super.Error();
     }
   }
   dart.setSignature(FallThroughError, {
     constructors: () => ({FallThroughError: [FallThroughError, []]})
   });
   let _className = dart.JsSymbol('_className');
@@ skipping 38 matching lines @@
       }
       if (this[_namedArguments] != null) {
         this[_namedArguments].forEach(dart.fn((key, value) => {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
           sb.write(_symbolToString(key));
           sb.write(": ");
           sb.write(Error.safeToString(value));
           i = dart.notNull(i) + 1;
-        }, Object, [Symbol, Object]));
+        }, dart.dynamic, [Symbol, dart.dynamic]));
       }
       if (this[_existingArgumentNames] == null) {
         return `NoSuchMethodError : method not found: '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Arguments: [${sb}]`;
       } else {
         let actualParameters = dart.toString(sb);
         sb = new StringBuffer();
         for (let i = 0; dart.notNull(i) < dart.notNull(this[_existingArgumentNames][dartx.length]); i = dart.notNull(i) + 1) {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
           sb.write(this[_existingArgumentNames][dartx.get](i));
         }
         let formalParameters = dart.toString(sb);
         return "NoSuchMethodError: incorrect number of arguments passed to " + `method named '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Tried calling: ${this[_memberName]}(${actualParameters})\n` + `Found: ${this[_memberName]}(${formalParameters})`;
       }
     }
   }
   dart.setSignature(NoSuchMethodError, {
-    constructors: () => ({NoSuchMethodError: [NoSuchMethodError, [Object, Symbol, List, Map$(Symbol, Object)], [List]]})
+    constructors: () => ({NoSuchMethodError: [NoSuchMethodError, [Object, Symbol, List, Map$(Symbol, dart.dynamic)], [List]]})
   });
   class UnsupportedError extends Error {
     UnsupportedError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `Unsupported operation: ${this.message}`;
     }
   }
@@ skipping 87 matching lines @@
     constructors: () => ({CyclicInitializationError: [CyclicInitializationError, [], [String]]})
   });
   class Exception extends Object {
     static new(message) {
       if (message === void 0)
         message = null;
       return new _ExceptionImplementation(message);
     }
   }
   dart.setSignature(Exception, {
-    constructors: () => ({new: [Exception, [], [Object]]})
+    constructors: () => ({new: [Exception, [], [dart.dynamic]]})
   });
   class _ExceptionImplementation extends Object {
     _ExceptionImplementation(message) {
       if (message === void 0)
         message = null;
       this.message = message;
     }
     toString() {
       if (this.message == null)
         return "Exception";
       return `Exception: ${this.message}`;
     }
   }
   _ExceptionImplementation[dart.implements] = () => [Exception];
   dart.setSignature(_ExceptionImplementation, {
-    constructors: () => ({_ExceptionImplementation: [_ExceptionImplementation, [], [Object]]})
+    constructors: () => ({_ExceptionImplementation: [_ExceptionImplementation, [], [dart.dynamic]]})
   });
   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;
@@ skipping 71 matching lines @@
           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[dartx.length]);
       return `${report}${prefix}${slice}${postfix}\n${" "[dartx['*']](markOffset)}^\n`;
     }
   }
   FormatException[dart.implements] = () => [Exception];
   dart.setSignature(FormatException, {
-    constructors: () => ({FormatException: [FormatException, [], [String, Object, int]]})
+    constructors: () => ({FormatException: [FormatException, [], [String, dart.dynamic, int]]})
   });
   class IntegerDivisionByZeroException extends Object {
     IntegerDivisionByZeroException() {
     }
     toString() {
       return "IntegerDivisionByZeroException";
     }
   }
   IntegerDivisionByZeroException[dart.implements] = () => [Exception];
   dart.setSignature(IntegerDivisionByZeroException, {
@@ skipping 59 matching lines @@
     static _toMangledNames(namedArguments) {
       let result = dart.map();
       namedArguments.forEach(dart.fn((symbol, value) => {
         result.set(_symbolToString(dart.as(symbol, Symbol)), value);
       }));
       return result;
     }
   }
   dart.setSignature(Function, {
     statics: () => ({
-      apply: [Object, [Function, List], [Map$(Symbol, Object)]],
-      _toMangledNames: [Map$(String, Object), [Map$(Symbol, Object)]]
+      apply: [dart.dynamic, [Function, List], [Map$(Symbol, dart.dynamic)]],
+      _toMangledNames: [Map$(String, dart.dynamic), [Map$(Symbol, dart.dynamic)]]
     }),
     names: ['apply', '_toMangledNames']
   });
   function identical(a, b) {
     return _js_helper.Primitives.identicalImplementation(a, b);
   }
   dart.fn(identical, bool, [Object, Object]);
   function identityHashCode(object) {
     return _js_helper.objectHashCode(object);
   }
-  dart.fn(identityHashCode, () => dart.functionType(int, [Object]));
+  dart.fn(identityHashCode, () => dart.definiteFunctionType(int, [Object]));
   class int extends num {
     static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
       throw new UnsupportedError('int.fromEnvironment can only be used as a const constructor');
     }
     static parse(source, opts) {
       let radix = opts && 'radix' in opts ? opts.radix : null;
       let onError = opts && 'onError' in opts ? opts.onError : null;
       return _js_helper.Primitives.parseInt(source, radix, onError);
     }
@@ skipping 235 matching lines @@
       }
       static fromIterables(keys, values) {
         return collection.LinkedHashMap$(K, V).fromIterables(keys, values);
       }
     }
     dart.setSignature(Map, {
       constructors: () => ({
         new: [Map$(K, V), []],
         from: [Map$(K, V), [Map$()]],
         identity: [Map$(K, V), []],
-        fromIterable: [Map$(K, V), [Iterable], {key: dart.functionType(K, [dart.bottom]), value: dart.functionType(V, [dart.bottom])}],
+        fromIterable: [Map$(K, V), [Iterable], {key: dart.functionType(K, [dart.dynamic]), value: dart.functionType(V, [dart.dynamic])}],
         fromIterables: [Map$(K, V), [Iterable$(K), Iterable$(V)]]
       })
     });
     return Map;
   });
   let Map = Map$();
   class Null extends Object {
     static _uninstantiable() {
       throw new UnsupportedError('class Null cannot be instantiated');
     }
@@ skipping 408 matching lines @@
   }
   StringBuffer[dart.implements] = () => [StringSink];
   dart.setSignature(StringBuffer, {
     constructors: () => ({StringBuffer: [StringBuffer, [], [Object]]}),
     methods: () => ({
       write: [dart.void, [Object]],
       writeCharCode: [dart.void, [int]],
       writeAll: [dart.void, [Iterable], [String]],
       writeln: [dart.void, [], [Object]],
       clear: [dart.void, []],
-      [_writeString]: [dart.void, [Object]]
+      [_writeString]: [dart.void, [dart.dynamic]]
     })
   });
   class StringSink extends Object {}
   class Symbol extends Object {
     static new(name) {
       return new _internal.Symbol(name);
     }
   }
   dart.setSignature(Symbol, {
     constructors: () => ({new: [Symbol, [String]]})
@@ skipping 614 matching lines @@
     static _makePath(path, start, end, pathSegments, ensureLeadingSlash, isFile) {
       if (path == null && pathSegments == null)
         return dart.notNull(isFile) ? "/" : "";
       if (path != null && pathSegments != null) {
         throw new ArgumentError('Both path and pathSegments specified');
       }
       let result = null;
       if (path != null) {
         result = Uri._normalize(path, start, end, dart.as(Uri._pathCharOrSlashTable, List$(int)));
       } else {
-        result = pathSegments[dartx.map](dart.fn(s => Uri._uriEncode(dart.as(Uri._pathCharTable, List$(int)), dart.as(s, String)), String, [Object]))[dartx.join]("/");
+        result = pathSegments[dartx.map](dart.fn(s => Uri._uriEncode(dart.as(Uri._pathCharTable, List$(int)), dart.as(s, String)), String, [dart.dynamic]))[dartx.join]("/");
       }
       if (dart.notNull(dart.as(dart.dload(result, 'isEmpty'), bool))) {
         if (dart.notNull(isFile))
           return "/";
       } else if ((dart.notNull(isFile) || dart.notNull(ensureLeadingSlash)) && !dart.equals(dart.dsend(result, 'codeUnitAt', 0), Uri._SLASH)) {
         return `/${result}`;
       }
       return dart.as(result, String);
     }
     static _makeQuery(query, start, end, queryParameters) {
@@ skipping 377 matching lines @@
     ['=='](other) {
       if (!dart.is(other, Uri))
         return false;
       let uri = dart.as(other, Uri);
       return this.scheme == uri.scheme && this.hasAuthority == uri.hasAuthority && this.userInfo == uri.userInfo && this.host == uri.host && this.port == uri.port && this.path == uri.path && this.hasQuery == uri.hasQuery && this.query == uri.query && this.hasFragment == uri.hasFragment && this.fragment == uri.fragment;
     }
     get hashCode() {
       let combine = (part, current) => {
         return dart.as(dart.dsend(dart.dsend(dart.dsend(current, '*', 31), '+', dart.hashCode(part)), '&', 1073741823), int);
       };
-      dart.fn(combine, int, [Object, Object]);
+      dart.fn(combine, int, [dart.dynamic, dart.dynamic]);
       return combine(this.scheme, combine(this.userInfo, combine(this.host, combine(this.port, combine(this.path, combine(this.query, combine(this.fragment, 1)))))));
     }
     static _addIfNonEmpty(sb, test, first, second) {
       if ("" != test) {
         sb.write(first);
         sb.write(second);
       }
     }
     static encodeComponent(component) {
       return Uri._uriEncode(dart.as(Uri._unreserved2396Table, List$(int)), component);
@@ skipping 53 matching lines @@
         start = 0;
       if (end === void 0)
         end = null;
       if (end == null)
         end = host[dartx.length];
       let error = (msg, position) => {
         if (position === void 0)
           position = null;
         throw new FormatException(`Illegal IPv6 address, ${msg}`, host, dart.as(position, int));
       };
-      dart.fn(error, dart.void, [String], [Object]);
+      dart.fn(error, dart.void, [String], [dart.dynamic]);
       let parseHex = (start, end) => {
         if (dart.notNull(end) - dart.notNull(start) > 4) {
           error('an IPv6 part can only contain a maximum of 4 hex digits', start);
         }
         let value = int.parse(host[dartx.substring](start, end), {radix: 16});
         if (dart.notNull(value) < 0 || dart.notNull(value) > (1 << 16) - 1) {
           error('each part must be in the range of `0x0..0xFFFF`', start);
         }
         return value;
       };
@@ skipping 172 matching lines @@
       toFilePath: [String, [], {windows: bool}],
       [_toFilePath]: [String, []],
       [_toWindowsFilePath]: [String, []],
       [_writeAuthority]: [dart.void, [StringSink]]
     }),
     statics: () => ({
       _defaultPort: [int, [String]],
       parse: [Uri, [String]],
       _fail: [dart.void, [String, int, String]],
       _makeHttpUri: [Uri, [String, String, String, Map$(String, String)]],
-      _checkNonWindowsPathReservedCharacters: [Object, [List$(String), bool]],
-      _checkWindowsPathReservedCharacters: [Object, [List$(String), bool], [int]],
-      _checkWindowsDriveLetter: [Object, [int, bool]],
-      _makeFileUri: [Object, [String]],
-      _makeWindowsFileUrl: [Object, [String]],
+      _checkNonWindowsPathReservedCharacters: [dart.dynamic, [List$(String), bool]],
+      _checkWindowsPathReservedCharacters: [dart.dynamic, [List$(String), bool], [int]],
+      _checkWindowsDriveLetter: [dart.dynamic, [int, bool]],
+      _makeFileUri: [dart.dynamic, [String]],
+      _makeWindowsFileUrl: [dart.dynamic, [String]],
       _makePort: [int, [int, String]],
       _makeHost: [String, [String, int, int, bool]],
       _isRegNameChar: [bool, [int]],
       _normalizeRegName: [String, [String, int, int]],
       _makeScheme: [String, [String, int]],
       _makeUserInfo: [String, [String, int, int]],
       _makePath: [String, [String, int, int, Iterable$(String), bool, bool]],
       _makeQuery: [String, [String, int, int, Map$(String, String)]],
       _makeFragment: [String, [String, int, int]],
       _stringOrNullLength: [int, [String]],
       _isHexDigit: [bool, [int]],
       _hexValue: [int, [int]],
       _normalizeEscape: [String, [String, int, bool]],
       _isUnreservedChar: [bool, [int]],
-      _escapeChar: [String, [Object]],
+      _escapeChar: [String, [dart.dynamic]],
       _normalize: [String, [String, int, int, List$(int)]],
       _isSchemeCharacter: [bool, [int]],
       _isGeneralDelimiter: [bool, [int]],
       _addIfNonEmpty: [dart.void, [StringBuffer, String, String, String]],
       encodeComponent: [String, [String]],
       encodeQueryComponent: [String, [String], {encoding: convert.Encoding}],
       decodeComponent: [String, [String]],
       decodeQueryComponent: [String, [String], {encoding: convert.Encoding}],
       encodeFull: [String, [String]],
       decodeFull: [String, [String]],
@@ skipping 112 matching lines @@
   exports.StackTrace = StackTrace;
   exports.Stopwatch = Stopwatch;
   exports.String = String;
   exports.RuneIterator = RuneIterator;
   exports.StringBuffer = StringBuffer;
   exports.StringSink = StringSink;
   exports.Symbol = Symbol;
   exports.Type = Type;
   exports.Uri = Uri;
 });