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

lib/src/equality.dart

Index: lib/src/equality.dart
diff --git a/lib/src/equality.dart b/lib/src/equality.dart
index 5a0d074bd8d70b630187ecf76cd2ce13d705683e..09f10a644bdf2b8cc2e8f1da0b57f50d786a7004 100644
--- a/lib/src/equality.dart
+++ b/lib/src/equality.dart
@@ -8,7 +8,7 @@ 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.
   ///
@@ -32,18 +32,18 @@ abstract class Equality<E> {
 ///
 /// 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;
 }
 
@@ -59,8 +59,8 @@ class IterableEquality<E> implements Equality<Iterable<E>> {
   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;