No dynamic at runtime

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);
@@ skipping 56 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: () => ({
-        [_throwUnmodifiable]: [dart.dynamic, []],
+        [_throwUnmodifiable]: [core.Object, []],
         set: [dart.void, [K, V]],
         putIfAbsent: [V, [K, dart.functionType(V, [])]],
         remove: [V, [core.Object]],
         clear: [dart.void, []],
         addAll: [dart.void, [core.Map$(K, V)]]
       })
     });
     return ConstantMap;
   });
   let ConstantMap = ConstantMap$();
@@ skipping 31 matching lines @@
         let keys = this[_keys];
         for (let i = 0; dart.notNull(i) < dart.notNull(dart.as(dart.dload(keys, 'length'), core.num)); i = dart.notNull(i) + 1) {
           let key = dart.dindex(keys, i);
           f(dart.as(key, K), dart.as(this[_fetch](key), V));
         }
       }
       get keys() {
         return new (_ConstantMapKeyIterable$(K))(this);
       }
       get values() {
-        return new (_internal.MappedIterable$(K, V))(this[_keys], dart.fn((key => dart.as(this[_fetch](key), V)).bind(this), V, [dart.dynamic]));
+        return new (_internal.MappedIterable$(K, V))(this[_keys], dart.fn((key => dart.as(this[_fetch](key), V)).bind(this), V, [core.Object]));
       }
     }
     ConstantStringMap[dart.implements] = () => [_internal.EfficientLength];
     dart.defineNamedConstructor(ConstantStringMap, '_');
     dart.setSignature(ConstantStringMap, {
       methods: () => ({
         containsValue: [core.bool, [core.Object]],
         containsKey: [core.bool, [core.Object]],
         get: [V, [core.Object]],
-        [_fetch]: [dart.dynamic, [dart.dynamic]],
+        [_fetch]: [core.Object, [core.Object]],
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]]
       })
     });
     return ConstantStringMap;
   });
   let ConstantStringMap = ConstantStringMap$();
   let _protoValue = Symbol('_protoValue');
   let ConstantProtoMap$ = dart.generic(function(K, V) {
     class ConstantProtoMap extends ConstantStringMap$(K, V) {
       _(length, jsObject, keys, protoValue) {
@@ skipping 86 matching lines @@
     return userAgent.indexOf(name) != -1;
   }
   dart.fn(contains, core.bool, [core.String, core.String]);
   function arrayLength(array) {
     return array.length;
   }
   dart.fn(arrayLength, core.int, [core.List]);
   function arrayGet(array, index) {
     return array[index];
   }
-  dart.fn(arrayGet, dart.dynamic, [core.List, core.int]);
+  dart.fn(arrayGet, core.Object, [core.List, core.int]);
   function arraySet(array, index, value) {
     array[index] = value;
   }
-  dart.fn(arraySet, dart.void, [core.List, core.int, dart.dynamic]);
+  dart.fn(arraySet, dart.void, [core.List, core.int, core.Object]);
   function propertyGet(object, property) {
     return object[property];
   }
-  dart.fn(propertyGet, dart.dynamic, [dart.dynamic, core.String]);
+  dart.fn(propertyGet, core.Object, [core.Object, core.String]);
   function callHasOwnProperty(func, object, property) {
     return func.call(object, property);
   }
-  dart.fn(callHasOwnProperty, core.bool, [dart.dynamic, dart.dynamic, core.String]);
+  dart.fn(callHasOwnProperty, core.bool, [core.Object, core.Object, core.String]);
   function propertySet(object, property, value) {
     object[property] = value;
   }
-  dart.fn(propertySet, dart.void, [dart.dynamic, core.String, dart.dynamic]);
+  dart.fn(propertySet, dart.void, [core.Object, core.String, core.Object]);
   function getPropertyFromPrototype(object, name) {
     return Object.getPrototypeOf(object)[name];
   }
-  dart.fn(getPropertyFromPrototype, dart.dynamic, [dart.dynamic, core.String]);
+  dart.fn(getPropertyFromPrototype, core.Object, [core.Object, core.String]);
   exports.getTagFunction = null;
   exports.alternateTagFunction = null;
   exports.prototypeForTagFunction = null;
   function toStringForNativeObject(obj) {
     let name = exports.getTagFunction == null ? '<Unknown>' : dart.dcall(exports.getTagFunction, obj);
     return `Instance of ${name}`;
   }
-  dart.fn(toStringForNativeObject, core.String, [dart.dynamic]);
+  dart.fn(toStringForNativeObject, core.String, [core.Object]);
   function hashCodeForNativeObject(object) {
     return Primitives.objectHashCode(object);
   }
-  dart.fn(hashCodeForNativeObject, core.int, [dart.dynamic]);
+  dart.fn(hashCodeForNativeObject, core.int, [core.Object]);
   function defineProperty(obj, property, value) {
     Object.defineProperty(obj, property, {value: value, enumerable: false, writable: true, configurable: true});
   }
-  dart.fn(defineProperty, dart.void, [dart.dynamic, core.String, dart.dynamic]);
+  dart.fn(defineProperty, dart.void, [core.Object, core.String, core.Object]);
   function isDartObject(obj) {
     return obj instanceof _foreign_helper.JS_DART_OBJECT_CONSTRUCTOR();
   }
-  dart.fn(isDartObject, core.bool, [dart.dynamic]);
+  dart.fn(isDartObject, core.bool, [core.Object]);
   dart.copyProperties(exports, {
     get interceptorsByTag() {
       return _foreign_helper.JS_EMBEDDED_GLOBAL('=Object', _js_embedded_names.INTERCEPTORS_BY_TAG);
     },
     get leafTags() {
       return _foreign_helper.JS_EMBEDDED_GLOBAL('=Object', _js_embedded_names.LEAF_TAGS);
     }
   });
   function findDispatchTagForInterceptorClass(interceptorClassConstructor) {
     return dart.as(interceptorClassConstructor[_js_embedded_names.NATIVE_SUPERCLASS_TAG_NAME], core.String);
   }
-  dart.fn(findDispatchTagForInterceptorClass, core.String, [dart.dynamic]);
+  dart.fn(findDispatchTagForInterceptorClass, core.String, [core.Object]);
   exports.dispatchRecordsForInstanceTags = null;
   exports.interceptorsForUncacheableTags = null;
   function lookupInterceptor(tag) {
     return propertyGet(exports.interceptorsByTag, tag);
   }
-  dart.fn(lookupInterceptor, dart.dynamic, [core.String]);
+  dart.fn(lookupInterceptor, core.Object, [core.String]);
   let UNCACHED_MARK = '~';
   let INSTANCE_CACHED_MARK = '!';
   let LEAF_MARK = '-';
   let INTERIOR_MARK = '+';
   let DISCRIMINATED_MARK = '*';
   function lookupAndCacheInterceptor(obj) {
     dart.assert(!dart.notNull(isDartObject(obj)));
     let tag = dart.as(dart.dcall(exports.getTagFunction, obj), core.String);
     let record = propertyGet(exports.dispatchRecordsForInstanceTags, tag);
     if (record != null)
@@ skipping 78 matching lines @@
     }
   }
   dart.fn(makeDefaultDispatchRecord);
   function setNativeSubclassDispatchRecord(proto, interceptor) {
     _interceptors.setDispatchProperty(proto, makeLeafDispatchRecord(interceptor));
   }
   dart.fn(setNativeSubclassDispatchRecord);
   function constructorNameFallback(object) {
     return _constructorNameFallback(object);
   }
-  dart.fn(constructorNameFallback, core.String, [dart.dynamic]);
+  dart.fn(constructorNameFallback, core.String, [core.Object]);
   exports.initNativeDispatchFlag = null;
   function initNativeDispatch() {
     if (dart.equals(true, exports.initNativeDispatchFlag))
       return;
     exports.initNativeDispatchFlag = true;
     initNativeDispatchContinue();
   }
   dart.fn(initNativeDispatch, dart.void, []);
   function initNativeDispatchContinue() {
     exports.dispatchRecordsForInstanceTags = Object.create(null);
@@ skipping 52 matching lines @@
           if (typeof transformer == "function") {
             hooks = applyHooksTransformer(transformer, hooks);
           }
         }
       }
     }
     let getTag = hooks.getTag;
     let getUnknownTag = hooks.getUnknownTag;
     let prototypeForTag = hooks.prototypeForTag;
     exports.getTagFunction = dart.fn(o => getTag(o));
-    exports.alternateTagFunction = dart.fn((o, tag) => getUnknownTag(o, tag), dart.dynamic, [dart.dynamic, core.String]);
-    exports.prototypeForTagFunction = dart.fn(tag => prototypeForTag(tag), dart.dynamic, [core.String]);
+    exports.alternateTagFunction = dart.fn((o, tag) => getUnknownTag(o, tag), core.Object, [core.Object, core.String]);
+    exports.prototypeForTagFunction = dart.fn(tag => prototypeForTag(tag), core.Object, [core.String]);
   }
   dart.fn(initHooks, dart.void, []);
   function applyHooksTransformer(transformer, hooks) {
     let newHooks = transformer(hooks);
     return newHooks || hooks;
   }
   dart.fn(applyHooksTransformer);
   let _baseHooks = dart.const(new _foreign_helper.JS_CONST('function() {\n  function typeNameInChrome(o) {\n    var constructor = o.constructor;\n    if (constructor) {\n      var name = constructor.name;\n      if (name) return name;\n    }\n    var s = Object.prototype.toString.call(o);\n    return s.substring(8, s.length - 1);\n  }\n  function getUnknownTag(object, tag) {\n    // This code really belongs in [getUnknownTagGenericBrowser] but having it\n    // here allows [getUnknownTag] to be tested on d8.\n    if (/^HTML[A-Z].*Element$/.test(tag)) {\n      // Check that it is not a simple JavaScript object.\n      var name = Object.prototype.toString.call(object);\n      if (name == "[object Object]") return null;\n      return "HTMLElement";\n    }\n  }\n  function getUnknownTagGenericBrowser(object, tag) {\n    if (self.HTMLElement && object instanceof HTMLElement) return "HTMLElement";\n    return getUnknownTag(object, tag);\n  }\n  function prototypeForTag(tag) {\n    if (typeof window == "undefined") return null;\n    if (typeof window[tag] == "undefined") return null;\n    var constructor = window[tag];\n    if (typeof constructor != "function") return null;\n    return constructor.prototype;\n  }\n  function discriminator(tag) { return null; }\n\n  var isBrowser = typeof navigator == "object";\n\n  return {\n    getTag: typeNameInChrome,\n    getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag,\n    prototypeForTag: prototypeForTag,\n    discriminator: discriminator };\n}'));
   let _constructorNameFallback = dart.const(new _foreign_helper.JS_CONST('function getTagFallback(o) {\n  var constructor = o.constructor;\n  if (typeof constructor == "function") {\n    var name = constructor.name;\n    // If the name is a non-empty string, we use that as the type name of this\n    // object.  There are various cases where that does not work, so we have to\n    // detect them and fall through to the toString() based implementation.\n\n    if (typeof name == "string" &&\n\n        // Sometimes the string is empty.  This test also catches minified\n        // shadow dom polyfil wrapper for Window on Firefox where the faked\n        // constructor name does not \'stick\'.  The shortest real DOM object\n        // names have three characters (e.g. URL, CSS).\n        name.length > 2 &&\n\n        // On Firefox we often get "Object" as the constructor name, even for\n        // more specialized DOM objects.\n        name !== "Object" &&\n\n        // This can happen in Opera.\n        name !== "Function.prototype") {\n      return name;\n    }\n  }\n  var s = Object.prototype.toString.call(o);\n  return s.substring(8, s.length - 1);\n}'));
   let _fallbackConstructorHooksTransformerGenerator = dart.const(new _foreign_helper.JS_CONST('function(getTagFallback) {\n  return function(hooks) {\n    // If we are not in a browser, assume we are in d8.\n    // TODO(sra): Recognize jsshell.\n    if (typeof navigator != "object") return hooks;\n\n    var ua = navigator.userAgent;\n    // TODO(antonm): remove a reference to DumpRenderTree.\n    if (ua.indexOf("DumpRenderTree") >= 0) return hooks;\n    if (ua.indexOf("Chrome") >= 0) {\n      // Confirm constructor name is usable for dispatch.\n      function confirm(p) {\n        return typeof window == "object" && window[p] && window[p].name == p;\n      }\n      if (confirm("Window") && confirm("HTMLElement")) return hooks;\n    }\n\n    hooks.getTag = getTagFallback;\n  };\n}'));
   let _ieHooksTransformer = dart.const(new _foreign_helper.JS_CONST('function(hooks) {\n  var userAgent = typeof navigator == "object" ? navigator.userAgent : "";\n  if (userAgent.indexOf("Trident/") == -1) return hooks;\n\n  var getTag = hooks.getTag;\n\n  var quickMap = {\n    "BeforeUnloadEvent": "Event",\n    "DataTransfer": "Clipboard",\n    "HTMLDDElement": "HTMLElement",\n    "HTMLDTElement": "HTMLElement",\n    "HTMLPhraseElement": "HTMLElement",\n    "Position": "Geoposition"\n  };\n\n  function getTagIE(o) {\n    var tag = getTag(o);\n    var newTag = quickMap[tag];\n    if (newTag) return newTag;\n    // Patches for types which report themselves as Objects.\n    if (tag == "Object") {\n      if (window.DataView && (o instanceof window.DataView)) return "DataView";\n    }\n    return tag;\n  }\n\n  function prototypeForTagIE(tag) {\n    var constructor = window[tag];\n    if (constructor == null) return null;\n    return constructor.prototype;\n  }\n\n  hooks.getTag = getTagIE;\n  hooks.prototypeForTag = prototypeForTagIE;\n}'));
   let _fixDocumentHooksTransformer = dart.const(new _foreign_helper.JS_CONST('function(hooks) {\n  var getTag = hooks.getTag;\n  var prototypeForTag = hooks.prototypeForTag;\n  function getTagFixed(o) {\n    var tag = getTag(o);\n    if (tag == "Document") {\n      // Some browsers and the polymer polyfill call both HTML and XML documents\n      // "Document", so we check for the xmlVersion property, which is the empty\n      // string on HTML documents. Since both dart:html classes Document and\n      // HtmlDocument share the same type, we must patch the instances and not\n      // the prototype.\n      if (!!o.xmlVersion) return "!Document";\n      return "!HTMLDocument";\n    }\n    return tag;\n  }\n\n  function prototypeForTagFixed(tag) {\n    if (tag == "Document") return null;  // Do not pre-patch Document.\n    return prototypeForTag(tag);\n  }\n\n  hooks.getTag = getTagFixed;\n  hooks.prototypeForTag = prototypeForTagFixed;\n}'));
   let _firefoxHooksTransformer = dart.const(new _foreign_helper.JS_CONST('function(hooks) {\n  var userAgent = typeof navigator == "object" ? navigator.userAgent : "";\n  if (userAgent.indexOf("Firefox") == -1) return hooks;\n\n  var getTag = hooks.getTag;\n\n  var quickMap = {\n    "BeforeUnloadEvent": "Event",\n    "DataTransfer": "Clipboard",\n    "GeoGeolocation": "Geolocation",\n    "Location": "!Location",               // Fixes issue 18151\n    "WorkerMessageEvent": "MessageEvent",\n    "XMLDocument": "!Document"};\n\n  function getTagFirefox(o) {\n    var tag = getTag(o);\n    return quickMap[tag] || tag;\n  }\n\n  hooks.getTag = getTagFirefox;\n}'));
   let _operaHooksTransformer = dart.const(new _foreign_helper.JS_CONST('function(hooks) { return hooks; }\n'));
   let _safariHooksTransformer = dart.const(new _foreign_helper.JS_CONST('function(hooks) { return hooks; }\n'));
   let _dartExperimentalFixupGetTagHooksTransformer = dart.const(new _foreign_helper.JS_CONST('function(hooks) {\n  if (typeof dartExperimentalFixupGetTag != "function") return hooks;\n  hooks.getTag = dartExperimentalFixupGetTag(hooks.getTag);\n}'));
   let _nativeRegExp = Symbol('_nativeRegExp');
   function regExpGetNative(regexp) {
     return regexp[_nativeRegExp];
   }
-  dart.fn(regExpGetNative, () => dart.functionType(dart.dynamic, [JSSyntaxRegExp]));
+  dart.fn(regExpGetNative, () => dart.functionType(core.Object, [JSSyntaxRegExp]));
   let _nativeGlobalVersion = Symbol('_nativeGlobalVersion');
   function regExpGetGlobalNative(regexp) {
     let nativeRegexp = regexp[_nativeGlobalVersion];
     nativeRegexp.lastIndex = 0;
     return nativeRegexp;
   }
-  dart.fn(regExpGetGlobalNative, () => dart.functionType(dart.dynamic, [JSSyntaxRegExp]));
+  dart.fn(regExpGetGlobalNative, () => dart.functionType(core.Object, [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]));
   let _nativeGlobalRegExp = Symbol('_nativeGlobalRegExp');
   let _nativeAnchoredRegExp = Symbol('_nativeAnchoredRegExp');
   let _isMultiLine = Symbol('_isMultiLine');
@@ skipping 109 matching lines @@
   dart.setSignature(JSSyntaxRegExp, {
     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: [dart.dynamic, [core.String, core.bool, core.bool, core.bool]]}),
+    statics: () => ({makeNative: [core.Object, [core.String, core.bool, core.bool, core.bool]]}),
     names: ['makeNative']
   });
   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 285 matching lines @@
       if (dart.dsend(index, '<', 0))
         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, dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic], [core.int]);
+  dart.fn(stringReplaceFirstUnchecked, core.Object, [core.Object, core.Object, core.Object], [core.int]);
   function stringJoinUnchecked(array, separator) {
     return array.join(separator);
   }
   dart.fn(stringJoinUnchecked);
   function createRuntimeType(name) {
     return new TypeImpl(name);
   }
   dart.fn(createRuntimeType, core.Type, [core.String]);
   let _typeName = Symbol('_typeName');
   let _unmangledName = Symbol('_unmangledName');
@@ skipping 19 matching lines @@
   class TypeVariable extends core.Object {
     TypeVariable(owner, name, bound) {
       this.owner = owner;
       this.name = name;
       this.bound = bound;
     }
   }
   function getMangledTypeName(type) {
     return type[_typeName];
   }
-  dart.fn(getMangledTypeName, dart.dynamic, [TypeImpl]);
+  dart.fn(getMangledTypeName, core.Object, [TypeImpl]);
   function setRuntimeTypeInfo(target, typeInfo) {
     dart.assert(dart.notNull(typeInfo == null) || dart.notNull(isJsArray(typeInfo)));
     if (target != null)
       target.$builtinTypeInfo = typeInfo;
     return target;
   }
-  dart.fn(setRuntimeTypeInfo, core.Object, [core.Object, dart.dynamic]);
+  dart.fn(setRuntimeTypeInfo, core.Object, [core.Object, core.Object]);
   function getRuntimeTypeInfo(target) {
     if (target == null)
       return null;
     return target.$builtinTypeInfo;
   }
-  dart.fn(getRuntimeTypeInfo, dart.dynamic, [core.Object]);
+  dart.fn(getRuntimeTypeInfo, core.Object, [core.Object]);
   function getRuntimeTypeArguments(target, substitutionName) {
     let substitution = getField(target, `${_foreign_helper.JS_OPERATOR_AS_PREFIX()}${substitutionName}`);
     return substitute(substitution, getRuntimeTypeInfo(target));
   }
   dart.fn(getRuntimeTypeArguments);
   function getRuntimeTypeArgument(target, substitutionName, index) {
     let arguments$ = getRuntimeTypeArguments(target, substitutionName);
     return arguments$ == null ? null : getIndex(arguments$, index);
   }
-  dart.fn(getRuntimeTypeArgument, dart.dynamic, [core.Object, core.String, core.int]);
+  dart.fn(getRuntimeTypeArgument, core.Object, [core.Object, core.String, core.int]);
   function getTypeArgumentByIndex(target, index) {
     let rti = getRuntimeTypeInfo(target);
     return rti == null ? null : getIndex(rti, index);
   }
-  dart.fn(getTypeArgumentByIndex, dart.dynamic, [core.Object, core.int]);
+  dart.fn(getTypeArgumentByIndex, core.Object, [core.Object, core.int]);
   function copyTypeArguments(source, target) {
     target.$builtinTypeInfo = source.$builtinTypeInfo;
   }
   dart.fn(copyTypeArguments, dart.void, [core.Object, core.Object]);
   function getClassName(object) {
     return _interceptors.getInterceptor(object).constructor.builtin$cls;
   }
-  dart.fn(getClassName, core.String, [dart.dynamic]);
+  dart.fn(getClassName, core.String, [core.Object]);
   function getRuntimeTypeAsString(runtimeType, opts) {
     let onTypeVariable = opts && 'onTypeVariable' in opts ? opts.onTypeVariable : null;
     dart.assert(isJsArray(runtimeType));
     let className = getConstructorName(getIndex(runtimeType, 0));
     return `${className}` + `${joinArguments(runtimeType, 1, {onTypeVariable: onTypeVariable})}`;
   }
-  dart.fn(getRuntimeTypeAsString, core.String, [dart.dynamic], {nTypeVariabl: dart.functionType(core.String, [core.int])});
+  dart.fn(getRuntimeTypeAsString, core.String, [core.Object], {nTypeVariabl: dart.functionType(core.String, [core.int])});
   function getConstructorName(type) {
     return type.builtin$cls;
   }
-  dart.fn(getConstructorName, core.String, [dart.dynamic]);
+  dart.fn(getConstructorName, core.String, [core.Object]);
   function runtimeTypeToString(type, opts) {
     let onTypeVariable = opts && 'onTypeVariable' in opts ? opts.onTypeVariable : null;
     if (type == null) {
       return 'dynamic';
     } else if (isJsArray(type)) {
       return getRuntimeTypeAsString(type, {onTypeVariable: onTypeVariable});
     } else if (isJsFunction(type)) {
       return getConstructorName(type);
     } else if (typeof type == 'number') {
       if (onTypeVariable == null) {
         return dart.toString(type);
       } else {
         return onTypeVariable(dart.as(type, core.int));
       }
     } else {
       return null;
     }
   }
-  dart.fn(runtimeTypeToString, core.String, [dart.dynamic], {nTypeVariabl: dart.functionType(core.String, [core.int])});
+  dart.fn(runtimeTypeToString, core.String, [core.Object], {nTypeVariabl: dart.functionType(core.String, [core.int])});
   function joinArguments(types, startIndex, opts) {
     let onTypeVariable = opts && 'onTypeVariable' in opts ? opts.onTypeVariable : null;
     if (types == null)
       return '';
     dart.assert(isJsArray(types));
     let firstArgument = true;
     let allDynamic = true;
     let buffer = new core.StringBuffer();
     for (let index = startIndex; dart.notNull(index) < dart.notNull(getLength(types)); index = dart.notNull(index) + 1) {
       if (firstArgument) {
         firstArgument = false;
       } else {
         buffer.write(', ');
       }
       let argument = getIndex(types, index);
       if (argument != null) {
         allDynamic = false;
       }
       buffer.write(runtimeTypeToString(argument, {onTypeVariable: onTypeVariable}));
     }
     return allDynamic ? '' : `<${buffer}>`;
   }
-  dart.fn(joinArguments, core.String, [dart.dynamic, core.int], {nTypeVariabl: dart.functionType(core.String, [core.int])});
+  dart.fn(joinArguments, core.String, [core.Object, core.int], {nTypeVariabl: dart.functionType(core.String, [core.int])});
   function getRuntimeTypeString(object) {
     let className = getClassName(object);
     if (object == null)
       return className;
     let typeInfo = object.$builtinTypeInfo;
     return `${className}${joinArguments(typeInfo, 0)}`;
   }
-  dart.fn(getRuntimeTypeString, core.String, [dart.dynamic]);
+  dart.fn(getRuntimeTypeString, core.String, [core.Object]);
   function getRuntimeType(object) {
     let type = getRuntimeTypeString(object);
     return new TypeImpl(type);
   }
-  dart.fn(getRuntimeType, core.Type, [dart.dynamic]);
+  dart.fn(getRuntimeType, core.Type, [core.Object]);
   function substitute(substitution, arguments$) {
     dart.assert(dart.notNull(substitution == null) || dart.notNull(isJsFunction(substitution)));
     dart.assert(dart.notNull(arguments$ == null) || dart.notNull(isJsArray(arguments$)));
     if (isJsFunction(substitution)) {
       substitution = invoke(substitution, arguments$);
       if (isJsArray(substitution)) {
         arguments$ = substitution;
       } else if (isJsFunction(substitution)) {
         arguments$ = invoke(substitution, arguments$);
       }
@@ skipping 33 matching lines @@
       throw new TypeErrorImplementation(object, typeName);
     }
     return object;
   }
   dart.fn(assertSubtype, core.Object, [core.Object, core.String, core.List, core.String]);
   function assertIsSubtype(subtype, supertype, message) {
     if (!dart.notNull(isSubtype(subtype, supertype))) {
       throwTypeError(message);
     }
   }
-  dart.fn(assertIsSubtype, dart.dynamic, [dart.dynamic, dart.dynamic, core.String]);
+  dart.fn(assertIsSubtype, core.Object, [core.Object, core.Object, core.String]);
   function throwTypeError(message) {
     throw new TypeErrorImplementation.fromMessage(dart.as(message, core.String));
   }
   dart.fn(throwTypeError);
   function checkArguments(substitution, arguments$, checks) {
     return areSubtypes(substitute(substitution, arguments$), checks);
   }
-  dart.fn(checkArguments, core.bool, [dart.dynamic, dart.dynamic, dart.dynamic]);
+  dart.fn(checkArguments, core.bool, [core.Object, core.Object, core.Object]);
   function areSubtypes(s, t) {
     if (dart.notNull(s == null) || dart.notNull(t == null))
       return true;
     dart.assert(isJsArray(s));
     dart.assert(isJsArray(t));
     dart.assert(getLength(s) == getLength(t));
     let len = getLength(s);
     for (let i = 0; dart.notNull(i) < dart.notNull(len); i = dart.notNull(i) + 1) {
       if (!dart.notNull(isSubtype(getIndex(s, i), getIndex(t, i)))) {
         return false;
       }
     }
     return true;
   }
-  dart.fn(areSubtypes, core.bool, [dart.dynamic, dart.dynamic]);
+  dart.fn(areSubtypes, core.bool, [core.Object, core.Object]);
   function computeSignature(signature, context, contextName) {
     let typeArguments = getRuntimeTypeArguments(context, contextName);
     return invokeOn(signature, context, typeArguments);
   }
   dart.fn(computeSignature);
   function isSupertypeOfNull(type) {
     return dart.notNull(type == null) || getConstructorName(type) == _foreign_helper.JS_OBJECT_CLASS_NAME() || getConstructorName(type) == _foreign_helper.JS_NULL_CLASS_NAME();
   }
-  dart.fn(isSupertypeOfNull, core.bool, [dart.dynamic]);
+  dart.fn(isSupertypeOfNull, core.bool, [core.Object]);
   function checkSubtypeOfRuntimeType(o, t) {
     if (o == null)
       return isSupertypeOfNull(t);
     if (t == null)
       return true;
     let rti = getRuntimeTypeInfo(o);
     o = _interceptors.getInterceptor(o);
     let type = o.constructor;
     if (rti != null) {
       rti = rti.slice();
       rti.splice(0, 0, type);
       type = rti;
     } else if (hasField(t, `${_foreign_helper.JS_FUNCTION_TYPE_TAG()}`)) {
       let signatureName = `${_foreign_helper.JS_OPERATOR_IS_PREFIX()}_${getField(t, _foreign_helper.JS_FUNCTION_TYPE_TAG())}`;
       if (hasField(o, signatureName))
         return true;
       let targetSignatureFunction = getField(o, `${_foreign_helper.JS_SIGNATURE_NAME()}`);
       if (targetSignatureFunction == null)
         return false;
       type = invokeOn(targetSignatureFunction, o, null);
       return isFunctionSubtype(type, t);
     }
     return isSubtype(type, t);
   }
-  dart.fn(checkSubtypeOfRuntimeType, core.bool, [dart.dynamic, dart.dynamic]);
+  dart.fn(checkSubtypeOfRuntimeType, core.bool, [core.Object, core.Object]);
   function subtypeOfRuntimeTypeCast(object, type) {
     if (dart.notNull(object != null) && !dart.notNull(checkSubtypeOfRuntimeType(object, type))) {
       let actualType = Primitives.objectTypeName(object);
       throw new CastErrorImplementation(actualType, runtimeTypeToString(type));
     }
     return object;
   }
-  dart.fn(subtypeOfRuntimeTypeCast, core.Object, [core.Object, dart.dynamic]);
+  dart.fn(subtypeOfRuntimeTypeCast, core.Object, [core.Object, core.Object]);
   function assertSubtypeOfRuntimeType(object, type) {
     if (dart.notNull(object != null) && !dart.notNull(checkSubtypeOfRuntimeType(object, type))) {
       throw new TypeErrorImplementation(object, runtimeTypeToString(type));
     }
     return object;
   }
-  dart.fn(assertSubtypeOfRuntimeType, core.Object, [core.Object, dart.dynamic]);
+  dart.fn(assertSubtypeOfRuntimeType, core.Object, [core.Object, core.Object]);
   function getArguments(type) {
     return isJsArray(type) ? type.slice(1) : null;
   }
   dart.fn(getArguments);
   function isSubtype(s, t) {
     if (isIdentical(s, t))
       return true;
     if (dart.notNull(s == null) || dart.notNull(t == null))
       return true;
     if (hasField(t, `${_foreign_helper.JS_FUNCTION_TYPE_TAG()}`)) {
@@ skipping 12 matching lines @@
       if (hasNoField(typeOfSPrototype, test))
         return false;
       let field = `${_foreign_helper.JS_OPERATOR_AS_PREFIX()}${runtimeTypeToString(typeOfT)}`;
       substitution = getField(typeOfSPrototype, field);
     }
     if (!dart.notNull(isJsArray(s)) && dart.notNull(substitution == null) || !dart.notNull(isJsArray(t))) {
       return true;
     }
     return checkArguments(substitution, getArguments(s), getArguments(t));
   }
-  dart.fn(isSubtype, core.bool, [dart.dynamic, dart.dynamic]);
+  dart.fn(isSubtype, core.bool, [core.Object, core.Object]);
   function isAssignable(s, t) {
     return dart.notNull(isSubtype(s, t)) || dart.notNull(isSubtype(t, s));
   }
-  dart.fn(isAssignable, core.bool, [dart.dynamic, dart.dynamic]);
+  dart.fn(isAssignable, core.bool, [core.Object, core.Object]);
   function areAssignable(s, t, allowShorter) {
     if (dart.notNull(t == null) && dart.notNull(s == null))
       return true;
     if (t == null)
       return allowShorter;
     if (s == null)
       return false;
     dart.assert(isJsArray(s));
     dart.assert(isJsArray(t));
     let sLength = getLength(s);
@@ skipping 26 matching lines @@
       if (!Object.hasOwnProperty.call(s, name)) {
         return false;
       }
       let tType = t[name];
       let sType = s[name];
       if (!dart.notNull(isAssignable(tType, sType)))
         return false;
     }
     return true;
   }
-  dart.fn(areAssignableMaps, core.bool, [dart.dynamic, dart.dynamic]);
+  dart.fn(areAssignableMaps, core.bool, [core.Object, core.Object]);
   function isFunctionSubtype(s, t) {
     dart.assert(hasField(t, `${_foreign_helper.JS_FUNCTION_TYPE_TAG()}`));
     if (hasNoField(s, `${_foreign_helper.JS_FUNCTION_TYPE_TAG()}`))
       return false;
     if (hasField(s, `${_foreign_helper.JS_FUNCTION_TYPE_VOID_RETURN_TAG()}`)) {
       if (dart.notNull(dart.as(hasNoField(t, `${_foreign_helper.JS_FUNCTION_TYPE_VOID_RETURN_TAG()}`), core.bool)) && dart.notNull(dart.as(hasField(t, `${_foreign_helper.JS_FUNCTION_TYPE_RETURN_TYPE_TAG()}`), core.bool))) {
         return false;
       }
     } else if (hasNoField(t, `${_foreign_helper.JS_FUNCTION_TYPE_VOID_RETURN_TAG()}`)) {
       let sReturnType = getField(s, `${_foreign_helper.JS_FUNCTION_TYPE_RETURN_TYPE_TAG()}`);
@@ skipping 39 matching lines @@
       for (; dart.notNull(tPos) < dart.notNull(tOptionalParametersLen); sPos = dart.notNull(sPos) + 1, tPos = dart.notNull(tPos) + 1) {
         if (!dart.notNull(isAssignable(getIndex(sOptionalParameterTypes, sPos), getIndex(tOptionalParameterTypes, tPos)))) {
           return false;
         }
       }
     }
     let sNamedParameters = getField(s, `${_foreign_helper.JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG()}`);
     let tNamedParameters = getField(t, `${_foreign_helper.JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG()}`);
     return areAssignableMaps(sNamedParameters, tNamedParameters);
   }
-  dart.fn(isFunctionSubtype, core.bool, [dart.dynamic, dart.dynamic]);
+  dart.fn(isFunctionSubtype, core.bool, [core.Object, core.Object]);
   function invoke(func, arguments$) {
     return invokeOn(func, null, arguments$);
   }
   dart.fn(invoke);
   function invokeOn(func, receiver, arguments$) {
     dart.assert(isJsFunction(func));
     dart.assert(dart.notNull(arguments$ == null) || dart.notNull(isJsArray(arguments$)));
     return func.apply(receiver, arguments$);
   }
-  dart.fn(invokeOn, core.Object, [dart.dynamic, dart.dynamic, dart.dynamic]);
+  dart.fn(invokeOn, core.Object, [core.Object, core.Object, core.Object]);
   function call(object, name) {
     return object[name]();
   }
-  dart.fn(call, dart.dynamic, [dart.dynamic, core.String]);
+  dart.fn(call, core.Object, [core.Object, core.String]);
   function getField(object, name) {
     return object[name];
   }
-  dart.fn(getField, dart.dynamic, [dart.dynamic, core.String]);
+  dart.fn(getField, core.Object, [core.Object, core.String]);
   function getIndex(array, index) {
     dart.assert(isJsArray(array));
     return array[index];
   }
-  dart.fn(getIndex, dart.dynamic, [dart.dynamic, core.int]);
+  dart.fn(getIndex, core.Object, [core.Object, core.int]);
   function getLength(array) {
     dart.assert(isJsArray(array));
     return array.length;
   }
-  dart.fn(getLength, core.int, [dart.dynamic]);
+  dart.fn(getLength, core.int, [core.Object]);
   function isJsArray(value) {
     return dart.is(value, _interceptors.JSArray);
   }
-  dart.fn(isJsArray, core.bool, [dart.dynamic]);
+  dart.fn(isJsArray, core.bool, [core.Object]);
   function hasField(object, name) {
     return name in object;
   }
   dart.fn(hasField);
   function hasNoField(object, name) {
     return dart.dsend(hasField(object, name), '!');
   }
   dart.fn(hasNoField);
   function isJsFunction(o) {
     return typeof o == "function";
   }
-  dart.fn(isJsFunction, core.bool, [dart.dynamic]);
+  dart.fn(isJsFunction, core.bool, [core.Object]);
   function isJsObject(o) {
     return typeof o == 'object';
   }
-  dart.fn(isJsObject, core.bool, [dart.dynamic]);
+  dart.fn(isJsObject, core.bool, [core.Object]);
   function isIdentical(s, t) {
     return s === t;
   }
-  dart.fn(isIdentical, core.bool, [dart.dynamic, dart.dynamic]);
+  dart.fn(isIdentical, core.bool, [core.Object, core.Object]);
   function isNotIdentical(s, t) {
     return s !== t;
   }
-  dart.fn(isNotIdentical, core.bool, [dart.dynamic, dart.dynamic]);
+  dart.fn(isNotIdentical, core.bool, [core.Object, core.Object]);
   function unmangleGlobalNameIfPreservedAnyways(str) {
     return str;
   }
   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() {
     }
   }
   let patch = dart.const(new _Patch());
   class InternalMap extends core.Object {}
   function requiresPreamble() {
   }
   dart.fn(requiresPreamble);
   function isJsIndexable(object, record) {
     if (record != null) {
       let result = _interceptors.dispatchRecordIndexability(record);
       if (result != null)
         return dart.as(result, core.bool);
     }
     return dart.is(object, exports.JavaScriptIndexingBehavior);
   }
-  dart.fn(isJsIndexable, core.bool, [dart.dynamic, dart.dynamic]);
+  dart.fn(isJsIndexable, core.bool, [core.Object, core.Object]);
   function S(value) {
     if (typeof value == 'string')
       return dart.as(value, core.String);
     if (dart.is(value, core.num)) {
       if (!dart.equals(value, 0)) {
         return "" + value;
       }
     } else if (dart.equals(true, value)) {
       return 'true';
     } else if (dart.equals(false, value)) {
       return 'false';
     } else if (value == null) {
       return 'null';
     }
     let res = dart.toString(value);
     if (!(typeof res == 'string'))
       throw new core.ArgumentError(value);
     return res;
   }
-  dart.fn(S, core.String, [dart.dynamic]);
+  dart.fn(S, core.String, [core.Object]);
   function createInvocationMirror(name, internalName, kind, arguments$, argumentNames) {
     return new JSInvocationMirror(name, dart.as(internalName, core.String), dart.as(kind, core.int), dart.as(arguments$, core.List), dart.as(argumentNames, core.List));
   }
-  dart.fn(createInvocationMirror, dart.dynamic, [core.String, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]);
+  dart.fn(createInvocationMirror, core.Object, [core.String, core.Object, core.Object, core.Object, core.Object]);
   function createUnmangledInvocationMirror(symbol, internalName, kind, arguments$, argumentNames) {
     return new JSInvocationMirror(symbol, dart.as(internalName, core.String), dart.as(kind, core.int), dart.as(arguments$, core.List), dart.as(argumentNames, core.List));
   }
-  dart.fn(createUnmangledInvocationMirror, dart.dynamic, [core.Symbol, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]);
+  dart.fn(createUnmangledInvocationMirror, core.Object, [core.Symbol, core.Object, core.Object, core.Object, core.Object]);
   function throwInvalidReflectionError(memberName) {
     throw new core.UnsupportedError(`Can't use '${memberName}' in reflection ` + "because it is not included in a @MirrorsUsed annotation.");
   }
   dart.fn(throwInvalidReflectionError, dart.void, [core.String]);
   function traceHelper(method) {
     if (!this.cache) {
       this.cache = Object.create(null);
     }
     if (!this.cache[method]) {
       console.log(method);
@@ skipping 56 matching lines @@
       }
       return dart.as(makeLiteralListConst(list), core.List);
     }
     get namedArguments() {
       if (this.isAccessor)
         return dart.map();
       let namedArgumentCount = this[_namedArgumentNames][core.$length];
       let namedArgumentsStartIndex = dart.notNull(this[_arguments][core.$length]) - dart.notNull(namedArgumentCount);
       if (namedArgumentCount == 0)
         return dart.map();
-      let map = new (core.Map$(core.Symbol, dart.dynamic))();
+      let map = new (core.Map$(core.Symbol, core.Object))();
       for (let i = 0; dart.notNull(i) < dart.notNull(namedArgumentCount); i = dart.notNull(i) + 1) {
         map.set(new _internal.Symbol.unvalidated(dart.as(this[_namedArgumentNames][core.$get](i), core.String)), this[_arguments][core.$get](dart.notNull(namedArgumentsStartIndex) + dart.notNull(i)));
       }
       return map;
     }
     [_getCachedInvocation](object) {
       let interceptor = _interceptors.getInterceptor(object);
       let receiver = object;
       let name = this[_internalName];
       let arguments$ = this[_arguments];
@@ skipping 41 matching lines @@
       } else {
         return dart.dsend(cached, 'invokeOn', victim, invocation[_arguments]);
       }
     }
     static getCachedInvocation(invocation, victim) {
       return invocation[_getCachedInvocation](victim);
     }
   }
   JSInvocationMirror[dart.implements] = () => [core.Invocation];
   dart.setSignature(JSInvocationMirror, {
-    methods: () => ({[_getCachedInvocation]: [dart.dynamic, [core.Object]]}),
+    methods: () => ({[_getCachedInvocation]: [core.Object, [core.Object]]}),
     statics: () => ({
-      invokeFromMirror: [dart.dynamic, [JSInvocationMirror, core.Object]],
-      getCachedInvocation: [dart.dynamic, [JSInvocationMirror, core.Object]]
+      invokeFromMirror: [core.Object, [JSInvocationMirror, core.Object]],
+      getCachedInvocation: [core.Object, [JSInvocationMirror, core.Object]]
     }),
     names: ['invokeFromMirror', 'getCachedInvocation']
   });
   JSInvocationMirror.METHOD = 0;
   JSInvocationMirror.GETTER = 1;
   JSInvocationMirror.SETTER = 2;
   class CachedInvocation extends core.Object {
     CachedInvocation(mangledName, jsFunction, isIntercepted, cachedInterceptor) {
       this.mangledName = mangledName;
       this.jsFunction = jsFunction;
@@ skipping 15 matching lines @@
         let _ = [victim];
         _[core.$addAll](arguments$);
         arguments$ = _;
         if (this.cachedInterceptor != null)
           receiver = this.cachedInterceptor;
       }
       return this.jsFunction.apply(receiver, arguments$);
     }
   }
   dart.setSignature(CachedInvocation, {
-    methods: () => ({invokeOn: [dart.dynamic, [core.Object, core.List]]})
+    methods: () => ({invokeOn: [core.Object, [core.Object, core.List]]})
   });
   class CachedCatchAllInvocation extends CachedInvocation {
     CachedCatchAllInvocation(name, jsFunction, isIntercepted, cachedInterceptor) {
       this.info = new ReflectionInfo(jsFunction);
       super.CachedInvocation(name, jsFunction, isIntercepted, cachedInterceptor);
     }
     get isGetterStub() {
       return false;
     }
     invokeOn(victim, arguments$) {
@@ skipping 40 matching lines @@
     }
     get isGetterStub() {
       return false;
     }
     invokeOn(victim, invocation) {
       let receiver = this.interceptor == null ? victim : this.interceptor;
       return dart.dsend(receiver, 'noSuchMethod', invocation);
     }
   }
   dart.setSignature(CachedNoSuchMethodInvocation, {
-    methods: () => ({invokeOn: [dart.dynamic, [core.Object, core.Invocation]]})
+    methods: () => ({invokeOn: [core.Object, [core.Object, core.Invocation]]})
   });
   class ReflectionInfo extends core.Object {
     internal(jsFunction, data, isAccessor, requiredParameterCount, optionalParameterCount, areOptionalParametersNamed, functionType) {
       this.jsFunction = jsFunction;
       this.data = data;
       this.isAccessor = isAccessor;
       this.requiredParameterCount = requiredParameterCount;
       this.optionalParameterCount = optionalParameterCount;
       this.areOptionalParametersNamed = areOptionalParametersNamed;
       this.functionType = functionType;
@@ skipping 65 matching lines @@
         (() => {
           let _ = positions.keys[core.$toList]();
           _[core.$sort]();
           return _;
         })()[core.$forEach](dart.fn((name => {
           this.cachedSortedIndices[core.$set]((() => {
             let x = index;
             index = dart.notNull(x) + 1;
             return x;
           })(), positions.get(name));
-        }).bind(this), dart.dynamic, [core.String]));
+        }).bind(this), core.Object, [core.String]));
       }
       return dart.as(this.cachedSortedIndices[core.$get](unsortedIndex), core.int);
     }
     computeFunctionRti(jsConstructor) {
       if (typeof this.functionType == "number") {
         return getMetadata(dart.as(this.functionType, core.int));
       } else if (typeof this.functionType == "function") {
         let fakeInstance = new jsConstructor();
         setRuntimeTypeInfo(fakeInstance, fakeInstance["<>"]);
         return this.functionType.apply({$receiver: fakeInstance});
       } else {
         throw new RuntimeError('Unexpected function type');
       }
     }
     get reflectionName() {
       return this.jsFunction.$reflectionName;
     }
   }
   dart.defineNamedConstructor(ReflectionInfo, 'internal');
   dart.setSignature(ReflectionInfo, {
     methods: () => ({
       parameterName: [core.String, [core.int]],
       parameterMetadataAnnotations: [core.List$(core.int), [core.int]],
       defaultValue: [core.int, [core.int]],
       defaultValueInOrder: [core.int, [core.int]],
       parameterNameInOrder: [core.String, [core.int]],
       sortedIndex: [core.int, [core.int]],
-      computeFunctionRti: [dart.dynamic, [dart.dynamic]]
+      computeFunctionRti: [core.Object, [core.Object]]
     })
   });
   ReflectionInfo.REQUIRED_PARAMETERS_INFO = 0;
   ReflectionInfo.OPTIONAL_PARAMETERS_INFO = 1;
   ReflectionInfo.FUNCTION_TYPE_INDEX = 2;
   ReflectionInfo.FIRST_DEFAULT_ARGUMENT = 3;
   function getMetadata(index) {
     let metadata = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.METADATA);
     return metadata[index];
   }
-  dart.fn(getMetadata, dart.dynamic, [core.int]);
+  dart.fn(getMetadata, core.Object, [core.int]);
   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;
@@ skipping 292 matching lines @@
         argumentCount = dart.notNull(argumentCount) + dart.notNull(positionalArguments[core.$length]);
         arguments$[core.$addAll](positionalArguments);
       }
       let names = '';
       if (dart.notNull(namedArguments != null) && !dart.notNull(namedArguments.isEmpty)) {
         namedArguments.forEach(dart.fn((name, argument) => {
           names = `${names}$${name}`;
           namedArgumentList[core.$add](name);
           arguments$[core.$add](argument);
           argumentCount = dart.notNull(argumentCount) + 1;
-        }, dart.dynamic, [core.String, dart.dynamic]));
+        }, core.Object, [core.String, core.Object]));
       }
       let selectorName = `${_foreign_helper.JS_GET_NAME("CALL_PREFIX")}$${argumentCount}${names}`;
       return dart.dsend(func, 'noSuchMethod', createUnmangledInvocationMirror(dart.const(new core.Symbol('call')), selectorName, JSInvocationMirror.METHOD, arguments$, namedArgumentList));
     }
     static applyFunction(func, positionalArguments, namedArguments) {
       return namedArguments == null ? Primitives.applyFunctionWithPositionalArguments(func, positionalArguments) : Primitives.applyFunctionWithNamedArguments(func, positionalArguments, namedArguments);
     }
     static applyFunctionWithPositionalArguments(func, positionalArguments) {
       let argumentCount = 0;
       let arguments$ = null;
@@ skipping 43 matching lines @@
         let defaultValue = getMetadata(value);
         defaultArguments.set(parameterName, defaultValue);
       }
       let bad = false;
       namedArguments.forEach(dart.fn((parameter, value) => {
         if (defaultArguments.containsKey(parameter)) {
           defaultArguments.set(parameter, value);
         } else {
           bad = true;
         }
-      }, dart.dynamic, [core.String, dart.dynamic]));
+      }, core.Object, [core.String, core.Object]));
       if (bad) {
         return Primitives.functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
       positionalArguments[core.$addAll](defaultArguments.values);
       return jsFunction.apply(func, positionalArguments);
     }
     static _mangledNameMatchesType(mangledName, type) {
       return mangledName == type[_typeName];
     }
     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, [dart.dynamic]],
-      _throwFormatException: [dart.dynamic, [core.String]],
+      objectHashCode: [core.int, [core.Object]],
+      _throwFormatException: [core.Object, [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])]],
       formatType: [core.String, [core.String, core.List]],
       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, [dart.dynamic]],
-      stringFromCharCodes: [core.String, [dart.dynamic]],
-      stringFromCharCode: [core.String, [dart.dynamic]],
+      stringFromCodePoints: [core.String, [core.Object]],
+      stringFromCharCodes: [core.String, [core.Object]],
+      stringFromCharCode: [core.String, [core.Object]],
       stringConcatUnchecked: [core.String, [core.String, core.String]],
       flattenString: [core.String, [core.String]],
-      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]],
-      functionNoSuchMethod: [dart.dynamic, [dart.dynamic, core.List, core.Map$(core.String, dart.dynamic)]],
-      applyFunction: [dart.dynamic, [core.Function, core.List, core.Map$(core.String, dart.dynamic)]],
-      applyFunctionWithPositionalArguments: [dart.dynamic, [core.Function, core.List]],
-      applyFunctionWithNamedArguments: [dart.dynamic, [core.Function, core.List, core.Map$(core.String, dart.dynamic)]],
-      _mangledNameMatchesType: [dart.dynamic, [core.String, TypeImpl]],
-      identicalImplementation: [core.bool, [dart.dynamic, dart.dynamic]],
+      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]],
+      functionNoSuchMethod: [core.Object, [core.Object, core.List, core.Map$(core.String, core.Object)]],
+      applyFunction: [core.Object, [core.Function, core.List, core.Map$(core.String, core.Object)]],
+      applyFunctionWithPositionalArguments: [core.Object, [core.Function, core.List]],
+      applyFunctionWithNamedArguments: [core.Object, [core.Function, core.List, core.Map$(core.String, core.Object)]],
+      _mangledNameMatchesType: [core.Object, [core.String, TypeImpl]],
+      identicalImplementation: [core.bool, [core.Object, core.Object]],
       extractStackTrace: [core.StackTrace, [core.Error]]
     }),
     names: ['initializeStatics', 'objectHashCode', '_throwFormatException', 'parseInt', 'parseDouble', 'formatType', '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', 'functionNoSuchMethod', 'applyFunction', 'applyFunctionWithPositionalArguments', 'applyFunctionWithNamedArguments', '_mangledNameMatchesType', 'identicalImplementation', 'extractStackTrace']
   });
   Primitives.mirrorFunctionCacheName = '$cachedFunction';
   Primitives.mirrorInvokeCacheName = '$cachedInvocation';
   Primitives.DOLLAR_CHAR_VALUE = 36;
   Primitives.timerFrequency = null;
   Primitives.timerTicks = null;
   dart.defineLazyProperties(Primitives, {
@@ skipping 21 matching lines @@
     }
     static fetch(cache, key) {
       return cache[key];
     }
     static update(cache, key, value) {
       cache[key] = value;
     }
   }
   dart.setSignature(JsCache, {
     statics: () => ({
-      allocate: [dart.dynamic, []],
-      fetch: [dart.dynamic, [dart.dynamic, core.String]],
-      update: [dart.void, [dart.dynamic, core.String, dart.dynamic]]
+      allocate: [core.Object, []],
+      fetch: [core.Object, [core.Object, core.String]],
+      update: [dart.void, [core.Object, core.String, core.Object]]
     }),
     names: ['allocate', 'fetch', 'update']
   });
   function iae(argument) {
     throw new core.ArgumentError(argument);
   }
   dart.fn(iae);
   function ioore(receiver, index) {
     if (receiver == null)
       dart.dload(receiver, 'length');
@@ skipping 205 matching lines @@
           (void 0).$method$;
         } catch (e) {
           return e.message;
         }
 
       };
       return func();
     }
   }
   dart.setSignature(TypeErrorDecoder, {
-    methods: () => ({matchTypeError: [dart.dynamic, [dart.dynamic]]}),
+    methods: () => ({matchTypeError: [core.Object, [core.Object]]}),
     statics: () => ({
-      buildJavaScriptObject: [dart.dynamic, []],
-      buildJavaScriptObjectWithNonClosure: [dart.dynamic, []],
-      extractPattern: [dart.dynamic, [core.String]],
-      provokeCallErrorOn: [core.String, [dart.dynamic]],
+      buildJavaScriptObject: [core.Object, []],
+      buildJavaScriptObjectWithNonClosure: [core.Object, []],
+      extractPattern: [core.Object, [core.String]],
+      provokeCallErrorOn: [core.String, [core.Object]],
       provokeCallErrorOnNull: [core.String, []],
       provokeCallErrorOnUndefined: [core.String, []],
-      provokePropertyErrorOn: [core.String, [dart.dynamic]],
+      provokePropertyErrorOn: [core.String, [core.Object]],
       provokePropertyErrorOnNull: [core.String, []],
       provokePropertyErrorOnUndefined: [core.String, []]
     }),
     names: ['buildJavaScriptObject', 'buildJavaScriptObjectWithNonClosure', 'extractPattern', 'provokeCallErrorOn', 'provokeCallErrorOnNull', 'provokeCallErrorOnUndefined', 'provokePropertyErrorOn', 'provokePropertyErrorOnNull', 'provokePropertyErrorOnUndefined']
   });
   dart.defineLazyProperties(TypeErrorDecoder, {
     get noSuchMethodPattern() {
       return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokeCallErrorOn(TypeErrorDecoder.buildJavaScriptObject())), TypeErrorDecoder);
     },
     get notClosurePattern() {
@@ skipping 135 matching lines @@
       if (typeof message == 'string' && dart.notNull(dart.equals(message, 'too much recursion'))) {
         return new core.StackOverflowError();
       }
     }
     return ex;
   }
   dart.fn(unwrapException);
   function getTraceFromException(exception) {
     return new _StackTrace(exception);
   }
-  dart.fn(getTraceFromException, core.StackTrace, [dart.dynamic]);
+  dart.fn(getTraceFromException, core.StackTrace, [core.Object]);
   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];
   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]);
+  dart.fn(objectHashCode, core.int, [core.Object]);
   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, dart.dynamic, [dart.dynamic, core.Map]);
+  dart.fn(fillLiteralMap, core.Object, [core.Object, core.Map]);
   function invokeClosure(closure, isolate, numberOfArguments, arg1, arg2, arg3, arg4) {
     if (numberOfArguments == 0) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, dart.fn(() => dart.dcall(closure)));
     } else if (numberOfArguments == 1) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, dart.fn(() => dart.dcall(closure, arg1)));
     } else if (numberOfArguments == 2) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, dart.fn(() => dart.dcall(closure, arg1, arg2)));
     } else if (numberOfArguments == 3) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, dart.fn(() => dart.dcall(closure, arg1, arg2, arg3)));
     } else if (numberOfArguments == 4) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, dart.fn(() => dart.dcall(closure, arg1, arg2, arg3, arg4)));
     } else {
       throw new core.Exception('Unsupported number of arguments for wrapped closure');
     }
   }
-  dart.fn(invokeClosure, dart.dynamic, [core.Function, dart.dynamic, core.int, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]);
+  dart.fn(invokeClosure, core.Object, [core.Function, core.Object, core.int, core.Object, core.Object, core.Object, core.Object]);
   function convertDartClosureToJS(closure, arity) {
     return closure;
   }
-  dart.fn(convertDartClosureToJS, dart.dynamic, [dart.dynamic, core.int]);
+  dart.fn(convertDartClosureToJS, core.Object, [core.Object, core.int]);
   class Closure extends core.Object {
     Closure() {
     }
     static fromTearOff(receiver, functions, reflectionInfo, isStatic, jsArguments, propertyName) {
       _foreign_helper.JS_EFFECT(dart.fn(() => {
         BoundClosure.receiverOf(dart.as(void 0, BoundClosure));
         BoundClosure.selfOf(dart.as(void 0, BoundClosure));
       }));
       let func = functions[0];
       let name = dart.as(func.$stubName, core.String);
@@ skipping 242 matching lines @@
         return x;
       })()}` + '}')();
     }
     toString() {
       return "Closure";
     }
   }
   Closure[dart.implements] = () => [core.Function];
   dart.setSignature(Closure, {
     statics: () => ({
-      fromTearOff: [dart.dynamic, [dart.dynamic, core.List, core.List, core.bool, dart.dynamic, core.String]],
-      cspForwardCall: [dart.dynamic, [core.int, core.bool, core.String, dart.dynamic]],
-      forwardCallTo: [dart.dynamic, [dart.dynamic, dart.dynamic, core.bool]],
-      cspForwardInterceptedCall: [dart.dynamic, [core.int, core.bool, core.String, dart.dynamic]],
-      forwardInterceptedCallTo: [dart.dynamic, [dart.dynamic, dart.dynamic]]
+      fromTearOff: [core.Object, [core.Object, core.List, core.List, core.bool, core.Object, core.String]],
+      cspForwardCall: [core.Object, [core.int, core.bool, core.String, core.Object]],
+      forwardCallTo: [core.Object, [core.Object, core.Object, core.bool]],
+      cspForwardInterceptedCall: [core.Object, [core.int, core.bool, core.String, core.Object]],
+      forwardInterceptedCallTo: [core.Object, [core.Object, core.Object]]
     }),
     names: ['fromTearOff', 'cspForwardCall', 'forwardCallTo', 'cspForwardInterceptedCall', 'forwardInterceptedCallTo']
   });
   Closure.FUNCTION_INDEX = 0;
   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;
@@ skipping 64 matching lines @@
       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, {
     statics: () => ({
-      selfOf: [dart.dynamic, [BoundClosure]],
-      targetOf: [dart.dynamic, [BoundClosure]],
-      receiverOf: [dart.dynamic, [BoundClosure]],
-      nameOf: [dart.dynamic, [BoundClosure]],
+      selfOf: [core.Object, [BoundClosure]],
+      targetOf: [core.Object, [BoundClosure]],
+      receiverOf: [core.Object, [BoundClosure]],
+      nameOf: [core.Object, [BoundClosure]],
       selfFieldName: [core.String, []],
       receiverFieldName: [core.String, []],
       computeFieldNamed: [core.String, [core.String]]
     }),
     names: ['selfOf', 'targetOf', 'receiverOf', 'nameOf', 'selfFieldName', 'receiverFieldName', 'computeFieldNamed']
   });
   BoundClosure.selfFieldNameCache = null;
   BoundClosure.receiverFieldNameCache = null;
   function jsHasOwnProperty(jsObject, property) {
     return jsObject.hasOwnProperty(property);
   }
-  dart.fn(jsHasOwnProperty, core.bool, [dart.dynamic, core.String]);
+  dart.fn(jsHasOwnProperty, core.bool, [core.Object, core.String]);
   function jsPropertyAccess(jsObject, property) {
     return jsObject[property];
   }
-  dart.fn(jsPropertyAccess, dart.dynamic, [dart.dynamic, core.String]);
+  dart.fn(jsPropertyAccess, core.Object, [core.Object, core.String]);
   function getFallThroughError() {
     return new FallThroughErrorImplementation();
   }
   dart.fn(getFallThroughError);
   class Creates extends core.Object {
     Creates(types) {
       this.types = types;
     }
   }
   class Returns extends core.Object {
@@ skipping 81 matching lines @@
   function intTypeCast(value) {
     if (typeof value == 'number' || dart.notNull(value == null))
       return value;
     throw new CastErrorImplementation(Primitives.objectTypeName(value), 'int');
   }
   dart.fn(intTypeCast);
   function propertyTypeError(value, property) {
     let name = dart.as(dart.dsend(property, 'substring', 3, dart.dload(property, 'length')), core.String);
     throw new TypeErrorImplementation(value, name);
   }
-  dart.fn(propertyTypeError, dart.void, [dart.dynamic, dart.dynamic]);
+  dart.fn(propertyTypeError, dart.void, [core.Object, core.Object]);
   function propertyTypeCastError(value, property) {
     let actualType = Primitives.objectTypeName(value);
     let expectedType = dart.as(dart.dsend(property, 'substring', 3, dart.dload(property, 'length')), core.String);
     throw new CastErrorImplementation(actualType, expectedType);
   }
-  dart.fn(propertyTypeCastError, dart.void, [dart.dynamic, dart.dynamic]);
+  dart.fn(propertyTypeCastError, dart.void, [core.Object, core.Object]);
   function propertyTypeCheck(value, property) {
     if (value == null)
       return value;
     if (!!value[property])
       return value;
     propertyTypeError(value, property);
   }
   dart.fn(propertyTypeCheck);
   function propertyTypeCast(value, property) {
     if (dart.notNull(value == null) || !!value[property])
@@ skipping 204 matching lines @@
     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();
   }
-  dart.fn(assertHelper, dart.void, [dart.dynamic]);
+  dart.fn(assertHelper, dart.void, [core.Object]);
   function throwNoSuchMethod(obj, name, arguments$, expectedArgumentNames) {
     let memberName = new _internal.Symbol.unvalidated(dart.as(name, core.String));
-    throw new core.NoSuchMethodError(obj, memberName, dart.as(arguments$, core.List), new (core.Map$(core.Symbol, dart.dynamic))(), dart.as(expectedArgumentNames, core.List));
+    throw new core.NoSuchMethodError(obj, memberName, dart.as(arguments$, core.List), new (core.Map$(core.Symbol, core.Object))(), dart.as(expectedArgumentNames, core.List));
   }
-  dart.fn(throwNoSuchMethod, dart.void, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]);
+  dart.fn(throwNoSuchMethod, dart.void, [core.Object, core.Object, core.Object, core.Object]);
   function throwCyclicInit(staticName) {
     throw new core.CyclicInitializationError(`Cyclic initialization for static ${staticName}`);
   }
   dart.fn(throwCyclicInit, dart.void, [core.String]);
   class RuntimeError extends core.Error {
     RuntimeError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
@@ skipping 150 matching lines @@
           needsComma = true;
         }
         result = dart.notNull(result) + '}';
       }
       result = dart.notNull(result) + `) -> ${this.returnType}`;
       return result;
     }
   }
   dart.setSignature(RuntimeFunctionType, {
     methods: () => ({
-      [_isTest]: [core.bool, [dart.dynamic]],
-      [_asCheck]: [dart.dynamic, [dart.dynamic]],
-      [_assertCheck]: [dart.dynamic, [dart.dynamic]],
-      [_check]: [dart.dynamic, [dart.dynamic, core.bool]],
-      [_extractFunctionTypeObjectFrom]: [dart.dynamic, [dart.dynamic]],
-      toRti: [dart.dynamic, []]
+      [_isTest]: [core.bool, [core.Object]],
+      [_asCheck]: [core.Object, [core.Object]],
+      [_assertCheck]: [core.Object, [core.Object]],
+      [_check]: [core.Object, [core.Object, core.bool]],
+      [_extractFunctionTypeObjectFrom]: [core.Object, [core.Object]],
+      toRti: [core.Object, []]
     }),
-    statics: () => ({listToRti: [dart.dynamic, [dart.dynamic]]}),
+    statics: () => ({listToRti: [core.Object, [core.Object]]}),
     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]);
+  dart.fn(buildFunctionType, RuntimeFunctionType, [core.Object, core.Object, core.Object]);
   function buildNamedFunctionType(returnType, parameterTypes, namedParameters) {
     return new RuntimeFunctionType(dart.as(returnType, RuntimeType), dart.as(parameterTypes, core.List$(RuntimeType)), null, namedParameters);
   }
-  dart.fn(buildNamedFunctionType, RuntimeFunctionType, [dart.dynamic, dart.dynamic, dart.dynamic]);
+  dart.fn(buildNamedFunctionType, RuntimeFunctionType, [core.Object, core.Object, core.Object]);
   function buildInterfaceType(rti, typeArguments) {
     let name = dart.as(rti.name, core.String);
     if (dart.notNull(typeArguments == null) || dart.notNull(dart.as(dart.dload(typeArguments, 'isEmpty'), core.bool))) {
       return new RuntimeTypePlain(name);
     }
     return new RuntimeTypeGeneric(name, dart.as(typeArguments, core.List$(RuntimeType)), null);
   }
-  dart.fn(buildInterfaceType, RuntimeType, [dart.dynamic, dart.dynamic]);
+  dart.fn(buildInterfaceType, RuntimeType, [core.Object, core.Object]);
   class DynamicRuntimeType extends RuntimeType {
     DynamicRuntimeType() {
       super.RuntimeType();
     }
     toString() {
       return 'dynamic';
     }
     toRti() {
       return null;
     }
   }
   dart.setSignature(DynamicRuntimeType, {
-    methods: () => ({toRti: [dart.dynamic, []]})
+    methods: () => ({toRti: [core.Object, []]})
   });
   function getDynamicRuntimeType() {
     return dart.const(new DynamicRuntimeType());
   }
   dart.fn(getDynamicRuntimeType, RuntimeType, []);
   class VoidRuntimeType extends RuntimeType {
     VoidRuntimeType() {
       super.RuntimeType();
     }
     toString() {
       return 'void';
     }
     toRti() {
       return dart.throw_('internal error');
     }
   }
   dart.setSignature(VoidRuntimeType, {
-    methods: () => ({toRti: [dart.dynamic, []]})
+    methods: () => ({toRti: [core.Object, []]})
   });
   function getVoidRuntimeType() {
     return dart.const(new VoidRuntimeType());
   }
   dart.fn(getVoidRuntimeType, RuntimeType, []);
   function functionTypeTestMetaHelper() {
     let dyn = x;
     let dyn2 = x;
     let fixedListOrNull = dart.as(x, core.List);
     let fixedListOrNull2 = dart.as(x, core.List);
@@ skipping 22 matching lines @@
       for (let i = 1; dart.notNull(i) < dart.notNull(list[core.$length]); i = dart.notNull(i) + 1) {
         arguments$[core.$add](convertRtiToRuntimeType(list[core.$get](i)));
       }
       return new RuntimeTypeGeneric(name, dart.as(arguments$, core.List$(RuntimeType)), rti);
     } else if ("func" in rti) {
       return new FunctionTypeInfoDecoderRing(rti).toRuntimeType();
     } else {
       throw new RuntimeError("Cannot convert " + `'${JSON.stringify(rti)}' to RuntimeType.`);
     }
   }
-  dart.fn(convertRtiToRuntimeType, RuntimeType, [dart.dynamic]);
+  dart.fn(convertRtiToRuntimeType, RuntimeType, [core.Object]);
   class RuntimeTypePlain extends RuntimeType {
     RuntimeTypePlain(name) {
       this.name = name;
       super.RuntimeType();
     }
     toRti() {
       let allClasses = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.ALL_CLASSES);
       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.dynamic, []]})
+    methods: () => ({toRti: [core.Object, []]})
   });
   class RuntimeTypeGeneric extends RuntimeType {
     RuntimeTypeGeneric(name, arguments$, rti) {
       this.name = name;
       this.arguments = arguments$;
       this.rti = rti;
       super.RuntimeType();
     }
     toRti() {
       if (this.rti != null)
         return this.rti;
       let allClasses = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.ALL_CLASSES);
       let result = [allClasses[this.name]];
       if (dart.dindex(result, 0) == null) {
         throw `no type for '${this.name}<...>'`;
       }
       for (let argument of this.arguments) {
         result.push(argument.toRti());
       }
       return this.rti = result;
     }
     toString() {
       return `${this.name}<${this.arguments[core.$join](", ")}>`;
     }
   }
   dart.setSignature(RuntimeTypeGeneric, {
-    methods: () => ({toRti: [dart.dynamic, []]})
+    methods: () => ({toRti: [core.Object, []]})
   });
   let _typeData = Symbol('_typeData');
   let _cachedToString = Symbol('_cachedToString');
   let _hasReturnType = Symbol('_hasReturnType');
   let _returnType = Symbol('_returnType');
   let _isVoid = Symbol('_isVoid');
   let _hasArguments = Symbol('_hasArguments');
   let _hasOptionalArguments = Symbol('_hasOptionalArguments');
   let _optionalArguments = Symbol('_optionalArguments');
   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: [RuntimeType, []],
-      [_convert]: [core.String, [dart.dynamic]]
+      [_convert]: [core.String, [core.Object]]
     })
   });
   class UnimplementedNoSuchMethodError extends core.Error {
     UnimplementedNoSuchMethodError(message) {
       this[_message] = message;
       super.Error();
     }
     toString() {
       return `Unsupported operation: ${this[_message]}`;
     }
@@ skipping 29 matching lines @@
   });
   let DeferredLoadCallback = dart.typedef('DeferredLoadCallback', () => dart.functionType(dart.void, []));
   exports.deferredLoadHook = null;
   function loadDeferredLibrary(loadId) {
     let urisMap = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.DEFERRED_LIBRARY_URIS);
     let uris = dart.as(urisMap[loadId], core.List$(core.String));
     let hashesMap = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.DEFERRED_LIBRARY_HASHES);
     let hashes = dart.as(hashesMap[loadId], core.List$(core.String));
     if (uris == null)
       return new (async.Future$(core.Null)).value(null);
-    let indices = new (core.List$(core.int)).generate(uris[core.$length], dart.fn(i => dart.as(i, core.int), core.int, [dart.dynamic]));
+    let indices = new (core.List$(core.int)).generate(uris[core.$length], dart.fn(i => dart.as(i, core.int), core.int, [core.Object]));
     let isHunkLoaded = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.IS_HUNK_LOADED);
     let isHunkInitialized = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.IS_HUNK_INITIALIZED);
     let indicesToLoad = indices[core.$where](dart.fn(i => !isHunkLoaded(hashes[core.$get](i)), core.bool, [core.int]))[core.$toList]();
     return dart.as(async.Future.wait(dart.as(indicesToLoad[core.$map](dart.fn(i => _loadHunk(uris[core.$get](i)), async.Future$(core.Null), [core.int])), core.Iterable$(async.Future))).then(dart.fn(_ => {
       let indicesToInitialize = indices[core.$where](dart.fn(i => !isHunkInitialized(hashes[core.$get](i)), core.bool, [core.int]))[core.$toList]();
       for (let i of indicesToInitialize) {
         let initializer = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.INITIALIZE_LOADED_HUNK);
         initializer(hashes[core.$get](i));
       }
       let updated = exports._loadedLibraries.add(loadId);
       if (dart.notNull(updated) && dart.notNull(exports.deferredLoadHook != null)) {
         exports.deferredLoadHook();
       }
     })), async.Future$(core.Null));
   }
   dart.fn(loadDeferredLibrary, async.Future$(core.Null), [core.String]);
   function _loadHunk(hunkName) {
     let future = exports._loadingLibraries.get(hunkName);
     if (future != null) {
-      return dart.as(future.then(dart.fn(_ => null, dart.bottom, [dart.dynamic])), async.Future$(core.Null));
+      return dart.as(future.then(dart.fn(_ => null, dart.bottom, [core.Object])), async.Future$(core.Null));
     }
     let uri = _isolate_helper.IsolateNatives.thisScript;
     let index = uri.lastIndexOf('/');
     uri = `${uri.substring(0, dart.notNull(index) + 1)}${hunkName}`;
     if (dart.notNull(Primitives.isJsshell) || dart.notNull(Primitives.isD8)) {
       return exports._loadingLibraries.set(hunkName, new (async.Future$(core.Null))(dart.fn(() => {
         try {
           new Function(`load("${uri}")`)();
         } catch (error) {
           let stackTrace = dart.stackTrace(error);
@@ skipping 304 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);