Handle dynamic as bottom inside of function type reps

lib/runtime/dart/_js_helper.js

 dart_library.library('dart/_js_helper', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core',
   'dart/collection',
   'dart/_interceptors',
   'dart/_foreign_helper'
 ], /* Lazy imports */[
 ], function(exports, dart, core, collection, _interceptors, _foreign_helper) {
   'use strict';
   let dartx = dart.dartx;
@@ skipping 40 matching lines @@
   class SupportJsExtensionMethods extends core.Object {
     SupportJsExtensionMethods() {
     }
   }
   dart.setSignature(SupportJsExtensionMethods, {
     constructors: () => ({SupportJsExtensionMethods: [SupportJsExtensionMethods, []]})
   });
   function defineProperty(obj, property, value) {
     Object.defineProperty(obj, property, {value: value, enumerable: false, writable: true, configurable: true});
   }
-  dart.fn(defineProperty, dart.void, [core.Object, core.String, core.Object]);
+  dart.fn(defineProperty, dart.void, [dart.dynamic, core.String, dart.dynamic]);
   let _nativeRegExp = Symbol('_nativeRegExp');
   function regExpGetNative(regexp) {
     return regexp[_nativeRegExp];
   }
-  dart.fn(regExpGetNative, () => dart.functionType(core.Object, [JSSyntaxRegExp]));
+  dart.fn(regExpGetNative, () => dart.definiteFunctionType(dart.dynamic, [JSSyntaxRegExp]));
   let _nativeGlobalVersion = Symbol('_nativeGlobalVersion');
   function regExpGetGlobalNative(regexp) {
     let nativeRegexp = regexp[_nativeGlobalVersion];
     nativeRegexp.lastIndex = 0;
     return nativeRegexp;
   }
-  dart.fn(regExpGetGlobalNative, () => dart.functionType(core.Object, [JSSyntaxRegExp]));
+  dart.fn(regExpGetGlobalNative, () => dart.definiteFunctionType(dart.dynamic, [JSSyntaxRegExp]));
   let _nativeAnchoredVersion = Symbol('_nativeAnchoredVersion');
   function regExpCaptureCount(regexp) {
     let nativeAnchoredRegExp = regexp[_nativeAnchoredVersion];
     let match = nativeAnchoredRegExp.exec('');
     return dart.as(dart.dsend(dart.dload(match, 'length'), '-', 2), core.int);
   }
-  dart.fn(regExpCaptureCount, () => dart.functionType(core.int, [JSSyntaxRegExp]));
+  dart.fn(regExpCaptureCount, () => dart.definiteFunctionType(core.int, [JSSyntaxRegExp]));
   let _nativeGlobalRegExp = Symbol('_nativeGlobalRegExp');
   let _nativeAnchoredRegExp = Symbol('_nativeAnchoredRegExp');
   let _isMultiLine = Symbol('_isMultiLine');
   let _isCaseSensitive = Symbol('_isCaseSensitive');
   let _execGlobal = Symbol('_execGlobal');
   let _execAnchored = Symbol('_execAnchored');
   class JSSyntaxRegExp extends core.Object {
     toString() {
       return `RegExp/${this.pattern}/`;
     }
@@ skipping 103 matching lines @@
     constructors: () => ({JSSyntaxRegExp: [JSSyntaxRegExp, [core.String], {multiLine: core.bool, caseSensitive: 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]]}),
+    statics: () => ({makeNative: [dart.dynamic, [core.String, core.bool, core.bool, core.bool]]}),
     names: ['makeNative']
   });
   dart.defineExtensionMembers(JSSyntaxRegExp, ['allMatches', 'matchAsPrefix']);
   let _match = Symbol('_match');
   class _MatchImplementation extends core.Object {
     _MatchImplementation(pattern, match) {
       this.pattern = pattern;
       this[_match] = match;
       dart.assert(typeof this[_match].input == 'string');
       dart.assert(typeof this[_match].index == 'number');
@@ skipping 293 matching lines @@
       if (dart.notNull(dart.as(dart.dsend(index, '<', 0), core.bool)))
         return receiver;
       return `${dart.dsend(receiver, 'substring', 0, index)}${to}` + `${dart.dsend(receiver, 'substring', dart.dsend(index, '+', dart.dload(from, 'length')))}`;
     } else if (dart.is(from, JSSyntaxRegExp)) {
       return startIndex == 0 ? stringReplaceJS(receiver, regExpGetNative(dart.as(from, JSSyntaxRegExp)), to) : stringReplaceFirstRE(receiver, from, to, startIndex);
     } else {
       checkNull(from);
       throw "String.replace(Pattern) UNIMPLEMENTED";
     }
   }
-  dart.fn(stringReplaceFirstUnchecked, core.Object, [core.Object, core.Object, core.Object], [core.int]);
+  dart.fn(stringReplaceFirstUnchecked, dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic], [core.int]);
   function stringJoinUnchecked(array, separator) {
     return array.join(separator);
   }
   dart.fn(stringJoinUnchecked);
   function getRuntimeType(object) {
     return dart.as(dart.realRuntimeType(object), core.Type);
   }
-  dart.fn(getRuntimeType, core.Type, [core.Object]);
+  dart.fn(getRuntimeType, core.Type, [dart.dynamic]);
   function getIndex(array, index) {
     dart.assert(isJsArray(array));
     return array[index];
   }
-  dart.fn(getIndex, core.Object, [core.Object, core.int]);
+  dart.fn(getIndex, dart.dynamic, [dart.dynamic, core.int]);
   function getLength(array) {
     dart.assert(isJsArray(array));
     return array.length;
   }
-  dart.fn(getLength, core.int, [core.Object]);
+  dart.fn(getLength, core.int, [dart.dynamic]);
   function isJsArray(value) {
     return dart.is(value, _interceptors.JSArray);
   }
-  dart.fn(isJsArray, core.bool, [core.Object]);
+  dart.fn(isJsArray, core.bool, [dart.dynamic]);
   class _Patch extends core.Object {
     _Patch() {
     }
   }
   dart.setSignature(_Patch, {
     constructors: () => ({_Patch: [_Patch, []]})
   });
   let patch = dart.const(new _Patch());
   class InternalMap extends core.Object {}
   class Primitives extends core.Object {
     static initializeStatics(id) {
       Primitives.mirrorFunctionCacheName = dart.notNull(Primitives.mirrorFunctionCacheName) + `_${id}`;
       Primitives.mirrorInvokeCacheName = dart.notNull(Primitives.mirrorInvokeCacheName) + `_${id}`;
     }
     static objectHashCode(object) {
       let hash = dart.as(object.$identityHash, core.int);
       if (hash == null) {
         hash = Math.random() * 0x3fffffff | 0;
         object.$identityHash = hash;
       }
       return hash;
     }
     static _throwFormatException(string) {
       throw new core.FormatException(string);
     }
     static parseInt(source, radix, handleError) {
       if (handleError == null)
-        handleError = dart.fn(s => dart.as(Primitives._throwFormatException(dart.as(s, core.String)), core.int), core.int, [core.Object]);
+        handleError = dart.fn(s => dart.as(Primitives._throwFormatException(dart.as(s, core.String)), core.int), core.int, [dart.dynamic]);
       checkString(source);
       let match = /^\s*[+-]?((0x[a-f0-9]+)|(\d+)|([a-z0-9]+))\s*$/i.exec(source);
       let digitsIndex = 1;
       let hexIndex = 2;
       let decimalIndex = 3;
       let nonDecimalHexIndex = 4;
       if (radix == null) {
         radix = 10;
         if (match != null) {
           if (dart.dindex(match, hexIndex) != null) {
@@ skipping 31 matching lines @@
           }
         }
       }
       if (match == null)
         return handleError(source);
       return parseInt(source, radix);
     }
     static parseDouble(source, handleError) {
       checkString(source);
       if (handleError == null)
-        handleError = dart.fn(s => dart.as(Primitives._throwFormatException(dart.as(s, core.String)), core.double), core.double, [core.Object]);
+        handleError = dart.fn(s => dart.as(Primitives._throwFormatException(dart.as(s, core.String)), core.double), core.double, [dart.dynamic]);
       if (!/^\s*[+-]?(?:Infinity|NaN|(?:\.\d+|\d+(?:\.\d*)?)(?:[eE][+-]?\d+)?)\s*$/.test(source)) {
         return handleError(source);
       }
       let result = parseFloat(source);
       if (dart.notNull(result[dartx.isNaN])) {
         let trimmed = source[dartx.trim]();
         if (trimmed == 'NaN' || trimmed == '+NaN' || trimmed == '-NaN') {
           return result;
         }
         return handleError(source);
@@ skipping 205 matching lines @@
     static identicalImplementation(a, b) {
       return a == null ? b == null : a === b;
     }
     static extractStackTrace(error) {
       return getTraceFromException(error.$thrownJsError);
     }
   }
   dart.setSignature(Primitives, {
     statics: () => ({
       initializeStatics: [dart.void, [core.int]],
-      objectHashCode: [core.int, [core.Object]],
-      _throwFormatException: [core.Object, [core.String]],
+      objectHashCode: [core.int, [dart.dynamic]],
+      _throwFormatException: [dart.dynamic, [core.String]],
       parseInt: [core.int, [core.String, core.int, dart.functionType(core.int, [core.String])]],
       parseDouble: [core.double, [core.String, dart.functionType(core.double, [core.String])]],
       objectTypeName: [core.String, [core.Object]],
       objectToString: [core.String, [core.Object]],
       dateNow: [core.num, []],
       initTicker: [dart.void, []],
       currentUri: [core.String, []],
       _fromCharCodeApply: [core.String, [core.List$(core.int)]],
-      stringFromCodePoints: [core.String, [core.Object]],
-      stringFromCharCodes: [core.String, [core.Object]],
-      stringFromCharCode: [core.String, [core.Object]],
+      stringFromCodePoints: [core.String, [dart.dynamic]],
+      stringFromCharCodes: [core.String, [dart.dynamic]],
+      stringFromCharCode: [core.String, [dart.dynamic]],
       stringConcatUnchecked: [core.String, [core.String, core.String]],
       flattenString: [core.String, [core.String]],
-      getTimeZoneName: [core.String, [core.Object]],
-      getTimeZoneOffsetInMinutes: [core.int, [core.Object]],
-      valueFromDecomposedDate: [core.Object, [core.Object, core.Object, core.Object, core.Object, core.Object, core.Object, core.Object, core.Object]],
-      patchUpY2K: [core.Object, [core.Object, core.Object, core.Object]],
-      lazyAsJsDate: [core.Object, [core.Object]],
-      getYear: [core.Object, [core.Object]],
-      getMonth: [core.Object, [core.Object]],
-      getDay: [core.Object, [core.Object]],
-      getHours: [core.Object, [core.Object]],
-      getMinutes: [core.Object, [core.Object]],
-      getSeconds: [core.Object, [core.Object]],
-      getMilliseconds: [core.Object, [core.Object]],
-      getWeekday: [core.Object, [core.Object]],
-      valueFromDateString: [core.Object, [core.Object]],
-      getProperty: [core.Object, [core.Object, core.Object]],
-      setProperty: [dart.void, [core.Object, core.Object, core.Object]],
-      identicalImplementation: [core.bool, [core.Object, core.Object]],
+      getTimeZoneName: [core.String, [dart.dynamic]],
+      getTimeZoneOffsetInMinutes: [core.int, [dart.dynamic]],
+      valueFromDecomposedDate: [dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]],
+      patchUpY2K: [dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic]],
+      lazyAsJsDate: [dart.dynamic, [dart.dynamic]],
+      getYear: [dart.dynamic, [dart.dynamic]],
+      getMonth: [dart.dynamic, [dart.dynamic]],
+      getDay: [dart.dynamic, [dart.dynamic]],
+      getHours: [dart.dynamic, [dart.dynamic]],
+      getMinutes: [dart.dynamic, [dart.dynamic]],
+      getSeconds: [dart.dynamic, [dart.dynamic]],
+      getMilliseconds: [dart.dynamic, [dart.dynamic]],
+      getWeekday: [dart.dynamic, [dart.dynamic]],
+      valueFromDateString: [dart.dynamic, [dart.dynamic]],
+      getProperty: [dart.dynamic, [dart.dynamic, dart.dynamic]],
+      setProperty: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+      identicalImplementation: [core.bool, [dart.dynamic, dart.dynamic]],
       extractStackTrace: [core.StackTrace, [core.Error]]
     }),
     names: ['initializeStatics', 'objectHashCode', '_throwFormatException', 'parseInt', 'parseDouble', 'objectTypeName', 'objectToString', 'dateNow', 'initTicker', 'currentUri', '_fromCharCodeApply', 'stringFromCodePoints', 'stringFromCharCodes', 'stringFromCharCode', 'stringConcatUnchecked', 'flattenString', 'getTimeZoneName', 'getTimeZoneOffsetInMinutes', 'valueFromDecomposedDate', 'patchUpY2K', 'lazyAsJsDate', 'getYear', 'getMonth', 'getDay', 'getHours', 'getMinutes', 'getSeconds', 'getMilliseconds', 'getWeekday', 'valueFromDateString', 'getProperty', 'setProperty', 'identicalImplementation', 'extractStackTrace']
   });
   Primitives.mirrorFunctionCacheName = '$cachedFunction';
   Primitives.mirrorInvokeCacheName = '$cachedInvocation';
   Primitives.DOLLAR_CHAR_VALUE = 36;
   Primitives.timerFrequency = null;
   Primitives.timerTicks = null;
   function stringLastIndexOfUnchecked(receiver, element, start) {
@@ skipping 51 matching lines @@
       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]]})
+    constructors: () => ({NullError: [NullError, [core.String, dart.dynamic]]})
   });
   let _receiver = Symbol('_receiver');
   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]]})
+    constructors: () => ({JsNoSuchMethodError: [JsNoSuchMethodError, [core.String, dart.dynamic]]})
   });
   class UnknownJsTypeError extends core.Error {
     UnknownJsTypeError(message) {
       this[_message] = message;
       super.Error();
     }
     toString() {
       return dart.notNull(this[_message][dartx.isEmpty]) ? 'Error' : `Error: ${this[_message]}`;
     }
   }
   dart.setSignature(UnknownJsTypeError, {
     constructors: () => ({UnknownJsTypeError: [UnknownJsTypeError, [core.String]]})
   });
   function getTraceFromException(exception) {
     return new _StackTrace(exception);
   }
-  dart.fn(getTraceFromException, core.StackTrace, [core.Object]);
+  dart.fn(getTraceFromException, core.StackTrace, [dart.dynamic]);
   let _exception = Symbol('_exception');
   let _trace = Symbol('_trace');
   class _StackTrace extends core.Object {
     _StackTrace(exception) {
       this[_exception] = exception;
       this[_trace] = null;
     }
     toString() {
       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]]})
+    constructors: () => ({_StackTrace: [_StackTrace, [dart.dynamic]]})
   });
   function objectHashCode(object) {
     if (object == null || typeof object != 'object') {
       return dart.hashCode(object);
     } else {
       return Primitives.objectHashCode(object);
     }
   }
-  dart.fn(objectHashCode, core.int, [core.Object]);
+  dart.fn(objectHashCode, core.int, [dart.dynamic]);
   function fillLiteralMap(keyValuePairs, result) {
     let index = 0;
     let length = getLength(keyValuePairs);
     while (dart.notNull(index) < dart.notNull(length)) {
       let key = getIndex(keyValuePairs, (() => {
         let x = index;
         index = dart.notNull(x) + 1;
         return x;
       })());
       let value = getIndex(keyValuePairs, (() => {
         let x = index;
         index = dart.notNull(x) + 1;
         return x;
       })());
       result.set(key, value);
     }
     return result;
   }
-  dart.fn(fillLiteralMap, core.Object, [core.Object, core.Map]);
+  dart.fn(fillLiteralMap, dart.dynamic, [dart.dynamic, core.Map]);
   function convertDartClosureToJS(closure, arity) {
     return closure;
   }
-  dart.fn(convertDartClosureToJS, core.Object, [core.Object, core.int]);
+  dart.fn(convertDartClosureToJS, dart.dynamic, [dart.dynamic, core.int]);
   function jsHasOwnProperty(jsObject, property) {
     return jsObject.hasOwnProperty(property);
   }
-  dart.fn(jsHasOwnProperty, core.bool, [core.Object, core.String]);
+  dart.fn(jsHasOwnProperty, core.bool, [dart.dynamic, core.String]);
   function jsPropertyAccess(jsObject, property) {
     return jsObject[property];
   }
-  dart.fn(jsPropertyAccess, core.Object, [core.Object, core.String]);
+  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, {
@@ skipping 64 matching lines @@
   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]]})
+    constructors: () => ({RuntimeError: [RuntimeError, [dart.dynamic]]})
   });
   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);
   }
@@ skipping 52 matching lines @@
   exports.Returns = Returns;
   exports.JSName = JSName;
   exports.JavaScriptIndexingBehavior = JavaScriptIndexingBehavior;
   exports.TypeErrorImplementation = TypeErrorImplementation;
   exports.CastErrorImplementation = CastErrorImplementation;
   exports.FallThroughErrorImplementation = FallThroughErrorImplementation;
   exports.RuntimeError = RuntimeError;
   exports.random64 = random64;
   exports.jsonEncodeNative = jsonEncodeNative;
 });