Finish @nex3's strong-mode fixes in package:collection and test it in Travis

lib/src/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.
 
 import "dart:collection";
 
 const int _HASH_MASK = 0x7fffffff;
 
 /// A generic equality relation on objects.
 abstract class Equality<E> {
-  const factory Equality() = DefaultEquality;
+  const factory Equality() = DefaultEquality<E>;
 
   /// Compare two elements for being equal.
   ///
   /// This should be a proper equality relation.
   bool equals(E e1, E e2);
 
   /// Get a hashcode of an element.
   ///
   /// The hashcode should be compatible with [equals], so that if
   /// `equals(a, b)` then `hash(a) == hash(b)`.
   int hash(E e);
 
   /// Test whether an object is a valid argument to [equals] and [hash].
   ///
   /// Some implementations may be restricted to only work on specific types
   /// of objects.
   bool isValidKey(Object o);
 }
 
 /// Equality of objects that compares only the natural equality of the objects.
 ///
 /// This equality uses the objects' own [Object.==] and [Object.hashCode] for
 /// the equality.
-class DefaultEquality implements Equality {
+class DefaultEquality<E> implements Equality<E> {
   const DefaultEquality();
-  bool equals(Object e1, Object e2) => e1 == e2;
-  int hash(Object e) => e.hashCode;
+  bool equals(E e1, E e2) => e1 == e2;

[Leaf, 2016/03/18 16:35:40]

I think these could safely be left as Object for backwards compatibility, if
desired.

[ochafik, 2016/03/19 01:38:33]

Any potential backwards-incompatibility would only affect strong-mode-clean
code, right? (which there isn't much of yet?)

I vote for a package version bump (to stay on safe side) and cleaner / more
generic-intensive code...

Natalie, WDYT?

[nweiz, 2016/03/21 20:09:18]

I'm not sure I see the backwards-incompatibility here. Won't code that doesn't
specify a type argument default to using DefaultEquality<Object> anyway?

I'd strongly like to avoid a major version bump for this package. It's very
widely used, and changing the major version will create a lot of painful ripples
through the ecosystem. I also don't think we need to worry about
backwards-incompatibilities that only affect strong mode, at least until a
package is officially strong-mode-clean.

+  int hash(E e) => e.hashCode;
   bool isValidKey(Object o) => true;
 }
 
 /// Equality of objects that compares only the identity of the objects.
-class IdentityEquality implements Equality {
+class IdentityEquality<E> implements Equality<E> {
   const IdentityEquality();
-  bool equals(Object e1, Object e2) => identical(e1, e2);
-  int hash(Object e) => identityHashCode(e);
+  bool equals(E e1, E e2) => identical(e1, e2);
+  int hash(E e) => identityHashCode(e);
   bool isValidKey(Object o) => true;
 }
 
 /// Equality on iterables.
 ///
 /// Two iterables are equal if they have the same elements in the same order.
 class IterableEquality<E> implements Equality<Iterable<E>> {
   final Equality<E> _elementEquality;
   const IterableEquality([Equality<E> elementEquality =
                               const DefaultEquality()])
       : _elementEquality = elementEquality;
 
   bool equals(Iterable<E> elements1, Iterable<E> elements2) {
     if (identical(elements1, elements2)) return true;
     if (elements1 == null || elements2 == null) return false;
-    Iterator it1 = elements1.iterator;
-    Iterator it2 = elements2.iterator;
+    var it1 = elements1.iterator;
+    var it2 = elements2.iterator;
     while (true) {
       bool hasNext = it1.moveNext();
       if (hasNext != it2.moveNext()) return false;
       if (!hasNext) return true;
       if (!_elementEquality.equals(it1.current, it2.current)) return false;
     }
   }
 
   int hash(Iterable<E> elements) {
     // Jenkins's one-at-a-time hash function.
@@ skipping 301 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);
 }