Fix type variables for pkg/collection_helpers unordered equality.

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>;
 }
 
-abstract class _UnorderedEquality<T> implements Equality<T> {
+abstract class _UnorderedEquality<E, T extends Iterable<E>>
+    implements Equality<T> {
   final Equality<E> _elementEquality;
 
   const _UnorderedEquality(this._elementEquality);
 
   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 (var e in e1) {
       int count = counts[e];
       if (count == null) count = 0;
       counts[e] = count + 1;
       length++;
     }
     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(T e) {
     int hash = 0;
-    for (var element in e) {
+    for (E 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>> {
+class UnorderedIterableEquality<E> extends _UnorderedEquality<E, 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 _UnorderedEquality<Set<E>> {
+class SetEquality<E> extends _UnorderedEquality<E, Set<E>> {
   const SetEquality(
       [Equality<E> elementEquality = const DefaultEquality()])
       : super(elementEquality);
 
   bool isValidKey(Object o) => o is Set<E>;
 }
 
 /**
  *  Internal class used by [MapEquality].
  *
@@ skipping 178 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);
 }