Fix unordered equality to not trigger dart2js typing restriction.

pkg/collection_helpers/lib/equality.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Defines equality relations on collections.
  */
 library dart.collection_helper.equality;
 
 import "dart:collection";
@@ skipping 133 matching lines @@
     }
     hash = (hash + (hash << 3)) & _HASH_MASK;
     hash ^= (hash >> 11);
     hash = (hash + (hash << 15)) & _HASH_MASK;
     return hash;
   }
 
   bool isValidKey(Object o) => o is List<E>;
 }
 
-/**
- * Equality of the elements of two iterables without considering order.
- *
- * Two iterables are considered equal if they have the same number of elements,
- * and the elements of one set can be paired with the elements
- * of the other iterable, so that each pair are equal.
- */
-class UnorderedIterableEquality<E> implements Equality<Iterable<E>> {
+abstract class _UnorderedEquality<T> implements Equality<T> {
   final Equality<E> _elementEquality;
 
-  const UnorderedIterableEquality(
-      [Equality<E> elementEquality = const DefaultEquality()])
-      : _elementEquality = elementEquality;
+  const _UnorderedEquality(this._elementEquality);
 
-  bool equals(Iterable<E> e1, Iterable<E> e2) {
+  bool equals(T e1, T e2) {
     if (identical(e1, e2)) return true;
     if (e1 == null || e2 == null) return false;
     HashMap<E, int> counts = new HashMap(
         equals: _elementEquality.equals,
         hashCode: _elementEquality.hash,
         isValidKey: _elementEquality.isValidKey);
     int length = 0;
-    for (E e in e1) {
+    for (var e in e1) {
       int count = counts[e];
       if (count == null) count = 0;
       counts[e] = count + 1;
       length++;
     }
-    for (E e in e2) {
+    for (var e in e2) {
       int count = counts[e];
       if (count == null || count == 0) return false;
       counts[e] = count - 1;
       length--;
     }
     return length == 0;
   }
 
-  int hash(Iterable<E> e) {
+  int hash(T e) {
     int hash = 0;
-    for (E element in e) {
+    for (var element in e) {
       int c = _elementEquality.hash(element);
       hash = (hash + c) & _HASH_MASK;
     }
     hash = (hash + (hash << 3)) & _HASH_MASK;
     hash ^= (hash >> 11);
     hash = (hash + (hash << 15)) & _HASH_MASK;
     return hash;
   }
+}
+
+/**
+ * Equality of the elements of two iterables without considering order.
+ *
+ * Two iterables are considered equal if they have the same number of elements,
+ * and the elements of one set can be paired with the elements
+ * of the other iterable, so that each pair are equal.
+ */
+class UnorderedIterableEquality<E> extends _UnorderedEquality<Iterable<E>> {
+  const UnorderedIterableEquality(
+      [Equality<E> elementEquality = const DefaultEquality()])
+      : super(elementEquality);
 
   bool isValidKey(Object o) => o is Iterable<E>;
 }
 
 /**
  * Equality of sets.
  *
  * Two sets are considered equal if they have the same number of elements,
  * and the elements of one set can be paired with the elements
  * of the other set, so that each pair are equal.
  *
  * This equality behaves the same as [UnorderedIterableEquality] except that
  * it expects sets instead of iterables as arguments.
  */
-class SetEquality<E> extends UnorderedIterableEquality<E>
-                     implements Equality<Set<E>> {
+class SetEquality<E> extends _UnorderedEquality<Set<E>> {
   const SetEquality(
       [Equality<E> elementEquality = const DefaultEquality()])
       : super(elementEquality);
 
-  bool equals(Set<E> e1, Set<E> e2) => super.equals(e1, e2);
-
-  int hash(Set<E> e) => super.hash(e);
-
   bool isValidKey(Object o) => o is Set<E>;
 }
 
 /**
  *  Internal class used by [MapEquality].
  *
  *  The class represents a map entry as a single object,
  *  using a combined hashCode and equality of the key and value.
  */
 class _MapEntry {
@@ skipping 174 matching lines @@
       if (o is List) return new ListEquality(this).hash(o);
       if (o is Iterable) return new IterableEquality(this).hash(o);
     } else if (o is Iterable) {
       return new UnorderedIterableEquality(this).hash(o);
     }
     return _base.hash(o);
   }
 
   bool isValidKey(Object o) => o is Iterable || o is Map || _base.isValidKey(o);
 }