Handle dynamic as bottom inside of function type reps

lib/runtime/dart/_interceptors.js

 dart_library.library('dart/_interceptors', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core',
   'dart/_internal',
   'dart/collection',
   'dart/math'
 ], /* Lazy imports */[
   'dart/_js_helper'
 ], function(exports, dart, core, _internal, collection, math, _js_helper) {
   'use strict';
@@ skipping 156 matching lines @@
         dart.as(f, dart.functionType(dart.void, [E]));
         let length = this[dartx.length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           f(dart.as(this[i], E));
           if (length != this[dartx.length]) {
             throw new core.ConcurrentModificationError(this);
           }
         }
       }
       [dartx.map](f) {
-        dart.as(f, dart.functionType(core.Object, [E]));
+        dart.as(f, dart.functionType(dart.dynamic, [E]));
         return _internal.IterableMixinWorkaround.mapList(this, f);
       }
       [dartx.join](separator) {
         if (separator === void 0)
           separator = "";
         let list = core.List.new(this[dartx.length]);
         for (let i = 0; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
           list[dartx.set](i, `${this[dartx.get](i)}`);
         }
         return list.join(separator);
@@ skipping 10 matching lines @@
       }
       [dartx.skipWhile](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
         return new (_internal.IterableMixinWorkaround$(E))().skipWhile(this, test);
       }
       [dartx.reduce](combine) {
         dart.as(combine, dart.functionType(E, [E, E]));
         return dart.as(_internal.IterableMixinWorkaround.reduce(this, combine), E);
       }
       [dartx.fold](initialValue, combine) {
-        dart.as(combine, dart.functionType(core.Object, [dart.bottom, E]));
+        dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));

[vsm, 2015/06/17 22:43:13]

Is the "dynamic" first arg param Top or Bottom in this context?  Would we need a
dinvoke to call combine at this point?

[Leaf, 2015/06/17 22:53:07]

Dynamic here will be treated as bottom, since function types are by default
fuzzy.  It's only things created via definiteFunctionType which retain dynamic
on the arguments.  For correctness this would need to be called with a dinvoke
here.

         return _internal.IterableMixinWorkaround.fold(this, initialValue, combine);
       }
       [dartx.firstWhere](test, opts) {
         dart.as(test, dart.functionType(core.bool, [E]));
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
         dart.as(orElse, dart.functionType(E, []));
         return dart.as(_internal.IterableMixinWorkaround.firstWhere(this, test, orElse), E);
       }
       [dartx.lastWhere](test, opts) {
         dart.as(test, dart.functionType(core.bool, [E]));
@@ skipping 170 matching lines @@
       }
       [dartx.asMap]() {
         return new (_internal.IterableMixinWorkaround$(E))().asMapList(this);
       }
     }
     dart.setBaseClass(JSArray, dart.global.Array);
     JSArray[dart.implements] = () => [core.List$(E), JSIndexable];
     dart.setSignature(JSArray, {
       constructors: () => ({
         JSArray: [JSArray$(E), []],
-        typed: [JSArray$(E), [core.Object]],
-        markFixed: [JSArray$(E), [core.Object]],
-        markGrowable: [JSArray$(E), [core.Object]]
+        typed: [JSArray$(E), [dart.dynamic]],
+        markFixed: [JSArray$(E), [dart.dynamic]],
+        markGrowable: [JSArray$(E), [dart.dynamic]]
       }),
       methods: () => ({
-        [dartx.checkGrowable]: [core.Object, [core.Object]],
+        [dartx.checkGrowable]: [dart.dynamic, [dart.dynamic]],
         [dartx.add]: [dart.void, [E]],
         [dartx.removeAt]: [E, [core.int]],
         [dartx.insert]: [dart.void, [core.int, E]],
         [dartx.insertAll]: [dart.void, [core.int, core.Iterable$(E)]],
         [dartx.setAll]: [dart.void, [core.int, core.Iterable$(E)]],
         [dartx.removeLast]: [E, []],
         [dartx.remove]: [core.bool, [core.Object]],
         [dartx.removeWhere]: [dart.void, [dart.functionType(core.bool, [E])]],
         [dartx.retainWhere]: [dart.void, [dart.functionType(core.bool, [E])]],
         [dartx.where]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         [dartx.expand]: [core.Iterable, [dart.functionType(core.Iterable, [E])]],
         [dartx.addAll]: [dart.void, [core.Iterable$(E)]],
         [dartx.clear]: [dart.void, []],
         [dartx.forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
-        [dartx.map]: [core.Iterable, [dart.functionType(core.Object, [E])]],
+        [dartx.map]: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
         [dartx.join]: [core.String, [], [core.String]],
         [dartx.take]: [core.Iterable$(E), [core.int]],
         [dartx.takeWhile]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         [dartx.skip]: [core.Iterable$(E), [core.int]],
         [dartx.skipWhile]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         [dartx.reduce]: [E, [dart.functionType(E, [E, E])]],
-        [dartx.fold]: [core.Object, [core.Object, dart.functionType(core.Object, [dart.bottom, E])]],
+        [dartx.fold]: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]],
         [dartx.firstWhere]: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functionType(E, [])}],
         [dartx.lastWhere]: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functionType(E, [])}],
         [dartx.singleWhere]: [E, [dart.functionType(core.bool, [E])]],
         [dartx.elementAt]: [E, [core.int]],
         [dartx.sublist]: [core.List$(E), [core.int], [core.int]],
         [dartx.getRange]: [core.Iterable$(E), [core.int, core.int]],
         [dartx.removeRange]: [dart.void, [core.int, core.int]],
         [dartx.setRange]: [dart.void, [core.int, core.int, core.Iterable$(E)], [core.int]],
         [dartx.fillRange]: [dart.void, [core.int, core.int], [E]],
         [dartx.replaceRange]: [dart.void, [core.int, core.int, core.Iterable$(E)]],
@@ skipping 422 matching lines @@
       [dartx.toStringAsFixed]: [core.String, [core.int]],
       [dartx.toStringAsExponential]: [core.String, [], [core.int]],
       [dartx.toStringAsPrecision]: [core.String, [core.int]],
       [dartx.toRadixString]: [core.String, [core.int]],
       [dartx['unary-']]: [core.num, []],
       [dartx['+']]: [core.num, [core.num]],
       [dartx['-']]: [core.num, [core.num]],
       [dartx['/']]: [core.double, [core.num]],
       [dartx['*']]: [core.num, [core.num]],
       [dartx['%']]: [core.num, [core.num]],
-      [_isInt32]: [core.bool, [core.Object]],
+      [_isInt32]: [core.bool, [dart.dynamic]],
       [dartx['~/']]: [core.int, [core.num]],
       [_tdivFast]: [core.int, [core.num]],
       [_tdivSlow]: [core.int, [core.num]],
       [dartx['<<']]: [core.num, [core.num]],
       [_shlPositive]: [core.num, [core.num]],
       [dartx['>>']]: [core.num, [core.num]],
       [_shrOtherPositive]: [core.num, [core.num]],
       [_shrReceiverPositive]: [core.num, [core.num]],
       [_shrBothPositive]: [core.num, [core.num]],
       [dartx['&']]: [core.num, [core.num]],
@@ skipping 711 matching lines @@
   exports.JSString = JSString;
   exports.getInterceptor = getInterceptor;
   exports.JSBool = JSBool;
   exports.JSIndexable = JSIndexable;
   exports.JSMutableIndexable = JSMutableIndexable;
   exports.JSObject = JSObject;
   exports.JavaScriptObject = JavaScriptObject;
   exports.PlainJavaScriptObject = PlainJavaScriptObject;
   exports.UnknownJavaScriptObject = UnknownJavaScriptObject;
 });