Allow S->T <: dynamic->T

test/codegen/expect/dart/collection.js

 var collection;
 (function(exports) {
   'use strict';
   let _source = Symbol('_source');
   let UnmodifiableListView$ = dart.generic(function(E) {
     class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
       UnmodifiableListView(source) {
         this[_source] = source;
         super.UnmodifiableListBase();
       }
@@ skipping 19 matching lines @@
     class HashMap extends core.Object {
       HashMap(opt$) {
         let equals = opt$.equals === void 0 ? null : opt$.equals;
         let hashCode = opt$.hashCode === void 0 ? null : opt$.hashCode;
         let isValidKey = opt$.isValidKey === void 0 ? null : opt$.isValidKey;
         if (isValidKey === null) {
           if (hashCode === null) {
             if (equals === null) {
               return new _HashMap();
             }
-            hashCode = _defaultHashCode;
+            hashCode = dart.closureWrap(_defaultHashCode, "(K) → int");

[Leaf, 2015/03/18 22:57:26]

In this case, I believe that a cast will succeed, since _defaultHashCode will
get reified as Object -> int.  I wonder if this generalizes with this change...
that more of the ClosureWraps could usefully be made into casts?  On further
thought though - really this is another case where we should be generalizing
your "isDynamicCall" optimization further.  This shouldn't even be a cast - we
should treat _defaultHashCode as having type "Object -> int" not "dynamic ->
int", and so this subtyping should succeed.

[vsm, 2015/03/18 23:40:33]

Agreed.  I'll start taking a look at closure wrapping.

           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
               return new _IdentityHashMap();
             }
             if (equals === null) {
-              equals = _defaultEquals;
+              equals = dart.closureWrap(_defaultEquals, "(K, K) → bool");
             }
           }
         } else {
           if (hashCode === null) {
-            hashCode = _defaultHashCode;
+            hashCode = dart.closureWrap(_defaultHashCode, "(K) → int");
           }
           if (equals === null) {
-            equals = _defaultEquals;
+            equals = dart.closureWrap(_defaultEquals, "(K, K) → bool");
           }
         }
         return new _CustomHashMap(equals, hashCode, isValidKey);
       }
       HashMap$identity() {
         return new _IdentityHashMap();
       }
       HashMap$from(other) {
         let result = new HashMap();
         other.forEach((k, v) => {
@@ skipping 54 matching lines @@
     class HashSet extends core.Object {
       HashSet(opt$) {
         let equals = opt$.equals === void 0 ? null : opt$.equals;
         let hashCode = opt$.hashCode === void 0 ? null : opt$.hashCode;
         let isValidKey = opt$.isValidKey === void 0 ? null : opt$.isValidKey;
         if (isValidKey === null) {
           if (hashCode === null) {
             if (equals === null) {
               return new _HashSet();
             }
-            hashCode = _defaultHashCode;
+            hashCode = dart.closureWrap(_defaultHashCode, "(E) → int");
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
               return new _IdentityHashSet();
             }
             if (equals === null) {
-              equals = _defaultEquals;
+              equals = dart.closureWrap(_defaultEquals, "(E, E) → bool");
             }
           }
         } else {
           if (hashCode === null) {
-            hashCode = _defaultHashCode;
+            hashCode = dart.closureWrap(_defaultHashCode, "(E) → int");
           }
           if (equals === null) {
-            equals = _defaultEquals;
+            equals = dart.closureWrap(_defaultEquals, "(E, E) → bool");
           }
         }
         return new _CustomHashSet(equals, hashCode, isValidKey);
       }
       HashSet$identity() {
         return new _IdentityHashSet();
       }
       HashSet$from(elements) {
         let result = new HashSet();
         for (let e of elements)
@@ skipping 35 matching lines @@
         }
         let value = iterator.current;
         while (iterator.moveNext()) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       fold(initialValue, combine) {
         let value = initialValue;
         for (let element of this)
-          value = combine(value, element);
+          value = dart.dinvokef(combine, value, element);
         return value;
       }
       every(f) {
         for (let element of this) {
           if (!dart.notNull(f(element)))
             return false;
         }
         return true;
       }
       join(separator) {
@@ skipping 178 matching lines @@
         }
         let value = iterator.current;
         while (iterator.moveNext()) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       fold(initialValue, combine) {
         let value = initialValue;
         for (let element of this)
-          value = combine(value, element);
+          value = dart.dinvokef(combine, value, element);
         return value;
       }
       every(f) {
         for (let element of this) {
           if (!dart.notNull(f(element)))
             return false;
         }
         return true;
       }
       join(separator) {
@@ skipping 319 matching lines @@
     class LinkedHashMap extends core.Object {
       LinkedHashMap(opt$) {
         let equals = opt$.equals === void 0 ? null : opt$.equals;
         let hashCode = opt$.hashCode === void 0 ? null : opt$.hashCode;
         let isValidKey = opt$.isValidKey === void 0 ? null : opt$.isValidKey;
         if (isValidKey === null) {
           if (hashCode === null) {
             if (equals === null) {
               return new _LinkedHashMap();
             }
-            hashCode = _defaultHashCode;
+            hashCode = dart.closureWrap(_defaultHashCode, "(K) → int");
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
               return new _LinkedIdentityHashMap();
             }
             if (equals === null) {
-              equals = _defaultEquals;
+              equals = dart.closureWrap(_defaultEquals, "(K, K) → bool");
             }
           }
         } else {
           if (hashCode === null) {
-            hashCode = _defaultHashCode;
+            hashCode = dart.closureWrap(_defaultHashCode, "(K) → int");
           }
           if (equals === null) {
-            equals = _defaultEquals;
+            equals = dart.closureWrap(_defaultEquals, "(K, K) → bool");
           }
         }
         return new _LinkedCustomHashMap(equals, hashCode, isValidKey);
       }
       LinkedHashMap$identity() {
         return new _LinkedIdentityHashMap();
       }
       LinkedHashMap$from(other) {
         let result = new LinkedHashMap();
         other.forEach((k, v) => {
@@ skipping 33 matching lines @@
     class LinkedHashSet extends core.Object {
       LinkedHashSet(opt$) {
         let equals = opt$.equals === void 0 ? null : opt$.equals;
         let hashCode = opt$.hashCode === void 0 ? null : opt$.hashCode;
         let isValidKey = opt$.isValidKey === void 0 ? null : opt$.isValidKey;
         if (isValidKey === null) {
           if (hashCode === null) {
             if (equals === null) {
               return new _LinkedHashSet();
             }
-            hashCode = _defaultHashCode;
+            hashCode = dart.closureWrap(_defaultHashCode, "(E) → int");
           } else {
             if (dart.notNull(core.identical(core.identityHashCode, hashCode)) && dart.notNull(core.identical(core.identical, equals))) {
               return new _LinkedIdentityHashSet();
             }
             if (equals === null) {
-              equals = _defaultEquals;
+              equals = dart.closureWrap(_defaultEquals, "(E, E) → bool");
             }
           }
         } else {
           if (hashCode === null) {
-            hashCode = _defaultHashCode;
+            hashCode = dart.closureWrap(_defaultHashCode, "(E) → int");
           }
           if (equals === null) {
-            equals = _defaultEquals;
+            equals = dart.closureWrap(_defaultEquals, "(E, E) → bool");
           }
         }
         return new _LinkedCustomHashSet(equals, hashCode, isValidKey);
       }
       LinkedHashSet$identity() {
         return new _LinkedIdentityHashSet();
       }
       LinkedHashSet$from(elements) {
         let result = new LinkedHashSet();
         for (let element of elements) {
@@ skipping 24 matching lines @@
         super.IterableBase();
         this[_next] = this[_previous] = this;
       }
       addFirst(entry) {
         this[_insertAfter](this, entry);
       }
       add(entry) {
         this[_insertAfter](this[_previous], entry);
       }
       addAll(entries) {
-        entries.forEach(((entry) => this[_insertAfter](this[_previous], dart.as(entry, E))).bind(this));
+        entries.forEach(dart.closureWrap(((entry) => this[_insertAfter](this[_previous], dart.as(entry, E))).bind(this), "(E) → void"));
       }
       remove(entry) {
         if (!dart.equals(entry[_list], this))
           return false;
         this[_unlink](entry);
         return true;
       }
       get iterator() {
         return new _LinkedListIterator(this);
       }
@@ skipping 279 matching lines @@
         if (this.length === 0)
           return "";
         let buffer = new core.StringBuffer();
         buffer.writeAll(this, separator);
         return buffer.toString();
       }
       where(test) {
         return new _internal.WhereIterable(this, test);
       }
       map(f) {
-        return new _internal.MappedListIterable(this, dart.as(f, dart.throw_("Unimplemented type (dynamic) → dynamic")));
+        return new _internal.MappedListIterable(this, f);
       }
       expand(f) {
         return new _internal.ExpandIterable(this, f);
       }
       reduce(combine) {
         let length = this.length;
         if (length === 0)
           throw _internal.IterableElementError.noElement();
         let value = this.get(0);
         for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           value = combine(value, this.get(i));
           if (length !== this.length) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       fold(initialValue, combine) {
         let value = initialValue;
         let length = this.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          value = combine(value, this.get(i));
+          value = dart.dinvokef(combine, value, this.get(i));
           if (length !== this.length) {
             throw new core.ConcurrentModificationError(this);
           }
         }
         return value;
       }
       skip(count) {
         return new _internal.SubListIterable(this, count, null);
       }
       skipWhile(test) {
@@ skipping 40 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
           if (dart.equals(this.get(i), element)) {
             this.setRange(i, dart.notNull(this.length) - 1, this, dart.notNull(i) + 1);
             this.length = 1;
             return true;
           }
         }
         return false;
       }
       removeWhere(test) {
-        _filter(this, dart.as(test, dart.throw_("Unimplemented type (dynamic) → bool")), false);
+        _filter(this, test, false);
       }
       retainWhere(test) {
-        _filter(this, dart.as(test, dart.throw_("Unimplemented type (dynamic) → bool")), true);
+        _filter(this, test, true);
       }
       static [_filter](source, test, retainMatching) {
         let retained = new List.from([]);
         let length = source.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = source.get(i);
-          if (test(element) === retainMatching) {
+          if (dart.dinvokef(test, element) === retainMatching) {
             retained.add(element);
           }
           if (length !== source.length) {
             throw new core.ConcurrentModificationError(source);
           }
         }
         if (retained.length !== source.length) {
           source.setRange(0, retained.length, retained);
           source.length = retained.length;
         }
       }
       clear() {
         this.length = 0;
       }
       removeLast() {
         if (this.length === 0) {
           throw _internal.IterableElementError.noElement();
         }
         let result = this.get(dart.notNull(this.length) - 1);
         this.length = dart.notNull(this.length) - 1;
         return result;
       }
       sort(compare) {
         if (compare === void 0)
           compare = null;
         if (compare === null) {
           let defaultCompare = core.Comparable.compare;
           compare = defaultCompare;
         }
-        _internal.Sort.sort(this, dart.as(compare, dart.throw_("Unimplemented type (dynamic, dynamic) → int")));
+        _internal.Sort.sort(this, compare);
       }
       shuffle(random) {
         if (random === void 0)
           random = null;
         if (random === null)
           random = new math.Random();
         let length = this.length;
         while (dart.notNull(length) > 1) {
           let pos = random.nextInt(length);
           length = 1;
@@ skipping 400 matching lines @@
       map.set(key, v);
       return v;
     }
     static clear(map) {
       for (let k of map.keys.toList()) {
         map.remove(k);
       }
     }
     static forEach(map, f) {
       for (let k of map.keys) {
-        f(k, map.get(k));
+        dart.dinvokef(f, k, map.get(k));
       }
     }
     static getValues(map) {
       return map.keys.map((key) => map.get(key));
     }
     static length(map) {
       return map.keys.length;
     }
     static isEmpty(map) {
       return map.keys.isEmpty;
@@ skipping 28 matching lines @@
     }
     static [_id](x) {
       return x;
     }
     static [_fillMapWithMappedIterable](map, iterable, key, value) {
       if (key === null)
         key = _id;
       if (value === null)
         value = _id;
       for (let element of iterable) {
-        map.set(key(element), value(element));
+        map.set(dart.dinvokef(key, element), dart.dinvokef(value, element));
       }
     }
     static [_fillMapWithIterables](map, keys, values) {
       let keyIterator = keys.iterator;
       let valueIterator = values.iterator;
       let hasNextKey = keyIterator.moveNext();
       let hasNextValue = valueIterator.moveNext();
       while (dart.notNull(hasNextKey) && dart.notNull(hasNextValue)) {
         map.set(keyIterator.current, valueIterator.current);
         hasNextKey = keyIterator.moveNext();
@@ skipping 670 matching lines @@
         }
         let value = iterator.current;
         while (iterator.moveNext()) {
           value = combine(value, iterator.current);
         }
         return value;
       }
       fold(initialValue, combine) {
         let value = initialValue;
         for (let element of this)
-          value = combine(value, element);
+          value = dart.dinvokef(combine, value, element);
         return value;
       }
       every(f) {
         for (let element of this) {
           if (!dart.notNull(f(element)))
             return false;
         }
         return true;
       }
       join(separator) {
@@ skipping 347 matching lines @@
         return this[_comparator](key1, key2);
       }
       SplayTreeMap$_internal() {
         this[_comparator] = null;
         this[_validKey] = null;
         super._SplayTree();
       }
       get(key) {
         if (key === null)
           throw new core.ArgumentError(key);
-        if (!dart.notNull(this[_validKey](key)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], key)))
           return null;
         if (this[_root] !== null) {
           let comp = this[_splay](dart.as(key, K));
           if (comp === 0) {
             let mapRoot = dart.as(this[_root], _SplayTreeMapNode);
             return dart.as(mapRoot.value, V);
           }
         }
         return null;
       }
       remove(key) {
-        if (!dart.notNull(this[_validKey](key)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], key)))
           return null;
         let mapRoot = dart.as(this[_remove](dart.as(key, K)), _SplayTreeMapNode);
         if (mapRoot !== null)
           return dart.as(mapRoot.value, V);
         return null;
       }
       set(key, value) {
         if (key === null)
           throw new core.ArgumentError(key);
         let comp = this[_splay](key);
@@ skipping 43 matching lines @@
           f(node.key, node.value);
         }
       }
       get length() {
         return this[_count];
       }
       clear() {
         this[_clear]();
       }
       containsKey(key) {
-        return dart.notNull(this[_validKey](key)) && this[_splay](dart.as(key, K)) === 0;
+        return dart.notNull(dart.dinvokef(this[_validKey], key)) && this[_splay](dart.as(key, K)) === 0;
       }
       containsValue(value) {
         let found = false;
         let initialSplayCount = this[_splayCount];
         // Function visit: (_SplayTreeMapNode<dynamic, dynamic>) → bool
         function visit(node) {
           while (node !== null) {
             if (dart.equals(node.value, value))
               return true;
             if (initialSplayCount !== this[_splayCount]) {
@@ skipping 243 matching lines @@
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         let result = new SplayTreeSet(compare, isValidKey);
         for (let element of elements) {
           result.add(element);
         }
         return result;
       }
       [_compare](e1, e2) {
-        return this[_comparator](e1, e2);
+        return dart.dinvokef(this[_comparator], e1, e2);
       }
       get iterator() {
         return new _SplayTreeKeyIterator(this);
       }
       get length() {
         return this[_count];
       }
       get isEmpty() {
         return this[_root] === null;
       }
@@ skipping 11 matching lines @@
         return dart.as(this[_last].key, E);
       }
       get single() {
         if (this[_count] === 0)
           throw _internal.IterableElementError.noElement();
         if (dart.notNull(this[_count]) > 1)
           throw _internal.IterableElementError.tooMany();
         return this[_root].key;
       }
       contains(object) {
-        return dart.notNull(this[_validKey](object)) && this[_splay](dart.as(object, E)) === 0;
+        return dart.notNull(dart.dinvokef(this[_validKey], object)) && this[_splay](dart.as(object, E)) === 0;
       }
       add(element) {
         let compare = this[_splay](element);
         if (compare === 0)
           return false;
         this[_addNewRoot](dart.as(new _SplayTreeNode(element), _SplayTreeNode$(E)), compare);
         return true;
       }
       remove(object) {
-        if (!dart.notNull(this[_validKey](object)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], object)))
           return false;
         return this[_remove](dart.as(object, E)) !== null;
       }
       addAll(elements) {
         for (let element of elements) {
           let compare = this[_splay](element);
           if (compare !== 0) {
             this[_addNewRoot](dart.as(new _SplayTreeNode(element), _SplayTreeNode$(E)), compare);
           }
         }
       }
       removeAll(elements) {
         for (let element of elements) {
-          if (this[_validKey](element))
+          if (dart.dinvokef(this[_validKey], element))
             this[_remove](dart.as(element, E));
         }
       }
       retainAll(elements) {
-        let retainSet = new SplayTreeSet(this[_comparator], this[_validKey]);
+        let retainSet = new SplayTreeSet(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
         let modificationCount = this[_modificationCount];
         for (let object of elements) {
           if (modificationCount !== this[_modificationCount]) {
             throw new core.ConcurrentModificationError(this);
           }
-          if (dart.notNull(this[_validKey](object)) && this[_splay](dart.as(object, E)) === 0)
+          if (dart.notNull(dart.dinvokef(this[_validKey], object)) && this[_splay](dart.as(object, E)) === 0)
             retainSet.add(this[_root].key);
         }
         if (retainSet[_count] !== this[_count]) {
           this[_root] = retainSet[_root];
           this[_count] = retainSet[_count];
           this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         }
       }
       lookup(object) {
-        if (!dart.notNull(this[_validKey](object)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], object)))
           return null;
         let comp = this[_splay](dart.as(object, E));
         if (comp !== 0)
           return null;
         return this[_root].key;
       }
       intersection(other) {
-        let result = new SplayTreeSet(this[_comparator], this[_validKey]);
+        let result = new SplayTreeSet(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
         for (let element of this) {
           if (other.contains(element))
             result.add(element);
         }
         return result;
       }
       difference(other) {
-        let result = new SplayTreeSet(this[_comparator], this[_validKey]);
+        let result = new SplayTreeSet(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
         for (let element of this) {
           if (!dart.notNull(other.contains(element)))
             result.add(element);
         }
         return result;
       }
       union(other) {
         return ((_) => {
           _.addAll(other);
           return _;
         }).bind(this)(this[_clone]());
       }
       [_clone]() {
-        let set = new SplayTreeSet(this[_comparator], this[_validKey]);
+        let set = new SplayTreeSet(dart.closureWrap(this[_comparator], "(E, E) → int"), this[_validKey]);
         set[_count] = this[_count];
         set[_root] = this[_copyNode](this[_root]);
         return set;
       }
       [_copyNode](node) {
         if (node === null)
           return null;
         return ((_) => {
           _.left = this[_copyNode](node.left);
           _.right = this[_copyNode](node.right);
@@ skipping 48 matching lines @@
       get isEmpty() {
         return this[_length] === 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new HashMapKeyIterable(this);
       }
       get values() {
-        return new _internal.MappedIterable(this.keys, ((each) => this.get(each)).bind(this));
+        return new _internal.MappedIterable(this.keys, dart.closureWrap(((each) => this.get(each)).bind(this), "(K) → V"));
       }
       containsKey(key) {
         if (_isStringKey(key)) {
           let strings = this[_strings];
           return strings === null ? false : _hasTableEntry(strings, key);
         } else if (_isNumericKey(key)) {
           let nums = this[_nums];
           return nums === null ? false : _hasTableEntry(nums, key);
         } else {
           return this[_containsKey](key);
@@ skipping 249 matching lines @@
   let _hashCode = Symbol('_hashCode');
   let _CustomHashMap$ = dart.generic(function(K, V) {
     class _CustomHashMap extends _HashMap$(K, V) {
       _CustomHashMap($_equals, $_hashCode, validKey) {
         this[_equals] = $_equals;
         this[_hashCode] = $_hashCode;
         this[_validKey] = dart.as(validKey !== null ? validKey : (v) => dart.is(v, K), _Predicate);
         super._HashMap();
       }
       get(key) {
-        if (!dart.notNull(this[_validKey](key)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], key)))
           return null;
         return super._get(key);
       }
       set(key, value) {
         super._set(key, value);
       }
       containsKey(key) {
-        if (!dart.notNull(this[_validKey](key)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], key)))
           return false;
         return super._containsKey(key);
       }
       remove(key) {
-        if (!dart.notNull(this[_validKey](key)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], key)))
           return null;
         return super._remove(key);
       }
       [_computeHashCode](key) {
         return this[_hashCode](dart.as(key, K)) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket === null)
           return -1;
         let length = bucket.length;
@@ skipping 94 matching lines @@
       get isEmpty() {
         return this[_length] === 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new LinkedHashMapKeyIterable(this);
       }
       get values() {
-        return new _internal.MappedIterable(this.keys, ((each) => this.get(each)).bind(this));
+        return new _internal.MappedIterable(this.keys, dart.closureWrap(((each) => this.get(each)).bind(this), "(K) → V"));
       }
       containsKey(key) {
         if (_isStringKey(key)) {
           let strings = this[_strings];
           if (strings === null)
             return false;
           let cell = dart.as(_getTableEntry(strings, key), LinkedHashMapCell);
           return cell !== null;
         } else if (_isNumericKey(key)) {
           let nums = this[_nums];
           if (nums === null)
             return false;
           let cell = dart.as(_getTableEntry(nums, key), LinkedHashMapCell);
           return cell !== null;
         } else {
           return this[_containsKey](key);
         }
       }
       [_containsKey](key) {
         let rest = this[_rest];
         if (rest === null)
           return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
-        return this.keys.any(((each) => dart.equals(this.get(each), value)).bind(this));
+        return this.keys.any(dart.closureWrap(((each) => dart.equals(this.get(each), value)).bind(this), "(K) → bool"));
       }
       addAll(other) {
         other.forEach(((key, value) => {
           this.set(key, value);
         }).bind(this));
       }
       get(key) {
         if (_isStringKey(key)) {
           let strings = this[_strings];
           if (strings === null)
@@ skipping 224 matching lines @@
   let _LinkedIdentityHashMap = _LinkedIdentityHashMap$(dart.dynamic, dart.dynamic);
   let _LinkedCustomHashMap$ = dart.generic(function(K, V) {
     class _LinkedCustomHashMap extends _LinkedHashMap$(K, V) {
       _LinkedCustomHashMap($_equals, $_hashCode, validKey) {
         this[_equals] = $_equals;
         this[_hashCode] = $_hashCode;
         this[_validKey] = dart.as(validKey !== null ? validKey : (v) => dart.is(v, K), _Predicate);
         super._LinkedHashMap();
       }
       get(key) {
-        if (!dart.notNull(this[_validKey](key)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], key)))
           return null;
         return super._get(key);
       }
       set(key, value) {
         super._set(key, value);
       }
       containsKey(key) {
-        if (!dart.notNull(this[_validKey](key)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], key)))
           return false;
         return super._containsKey(key);
       }
       remove(key) {
-        if (!dart.notNull(this[_validKey](key)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], key)))
           return null;
         return super._remove(key);
       }
       [_computeHashCode](key) {
         return this[_hashCode](dart.as(key, K)) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket === null)
           return -1;
         let length = bucket.length;
@@ skipping 359 matching lines @@
         }
         return -1;
       }
       [_computeHashCode](element) {
         return this[_hasher](dart.as(element, E)) & 0x3ffffff;
       }
       add(object) {
         return super._add(object);
       }
       contains(object) {
-        if (!dart.notNull(this[_validKey](object)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], object)))
           return false;
         return super._contains(object);
       }
       lookup(object) {
-        if (!dart.notNull(this[_validKey](object)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], object)))
           return null;
         return super._lookup(object);
       }
       remove(object) {
-        if (!dart.notNull(this[_validKey](object)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], object)))
           return false;
         return super._remove(object);
       }
     }
     return _CustomHashSet;
   });
   let _CustomHashSet = _CustomHashSet$(dart.dynamic);
   let HashSetIterator$ = dart.generic(function(E) {
     class HashSetIterator extends core.Object {
       HashSetIterator($_set, $_elements) {
@@ skipping 339 matching lines @@
         }
         return -1;
       }
       [_computeHashCode](element) {
         return this[_hasher](dart.as(element, E)) & 0x3ffffff;
       }
       add(element) {
         return super._add(element);
       }
       contains(object) {
-        if (!dart.notNull(this[_validKey](object)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], object)))
           return false;
         return super._contains(object);
       }
       lookup(object) {
-        if (!dart.notNull(this[_validKey](object)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], object)))
           return null;
         return super._lookup(object);
       }
       remove(object) {
-        if (!dart.notNull(this[_validKey](object)))
+        if (!dart.notNull(dart.dinvokef(this[_validKey], object)))
           return false;
         return super._remove(object);
       }
       containsAll(elements) {
         for (let element of elements) {
-          if (!dart.notNull(this[_validKey](element)) || !dart.notNull(this.contains(element)))
+          if (!dart.notNull(dart.dinvokef(this[_validKey], element)) || !dart.notNull(this.contains(element)))
             return false;
         }
         return true;
       }
       removeAll(elements) {
         for (let element of elements) {
-          if (this[_validKey](element)) {
+          if (dart.dinvokef(this[_validKey], element)) {
             super._remove(element);
           }
         }
       }
     }
     return _LinkedCustomHashSet;
   });
   let _LinkedCustomHashSet = _LinkedCustomHashSet$(dart.dynamic);
   class LinkedHashSetCell extends core.Object {
     LinkedHashSetCell($_element) {
@@ skipping 90 matching lines @@
   exports.LinkedHashMapKeyIterable = LinkedHashMapKeyIterable;
   exports.LinkedHashMapKeyIterable$ = LinkedHashMapKeyIterable$;
   exports.LinkedHashMapKeyIterator = LinkedHashMapKeyIterator;
   exports.LinkedHashMapKeyIterator$ = LinkedHashMapKeyIterator$;
   exports.HashSetIterator = HashSetIterator;
   exports.HashSetIterator$ = HashSetIterator$;
   exports.LinkedHashSetCell = LinkedHashSetCell;
   exports.LinkedHashSetIterator = LinkedHashSetIterator;
   exports.LinkedHashSetIterator$ = LinkedHashSetIterator$;
 })(collection || (collection = {}));