Update dart:collection.

This doesn't include the copious changes in collection_patch.dart
because I believe (1) those are quite old and (2) are dart2js specific.

The changes here have basically no effect on DDC, but it at least gets
us a little better test coverage and reduces noise in the diffs.

[email protected]

Review URL: https://codereview.chromium.org/1977003002 .

Author: munificent

pkg/dev_compiler/lib/runtime/dart_sdk.js

@@ -21405,8 +21405,10 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       static from(elements) {
         let result = collection.HashSet$(E).new();
-        for (let e of elements)
-          result.add(dart.as(e, E));
+        for (let e of elements) {
+          let element = dart.as(e, E);
+          result.add(element);
+        }
         return result;
       }
       [Symbol.iterator]() {
@@ -21911,7 +21913,8 @@ dart_library.library('dart_sdk', null, /* Imports */[
       static from(elements) {
         let result = collection.LinkedHashSet$(E).new();
         for (let element of elements) {
-          result.add(dart.as(element, E));
+          let e = dart.as(element, E);
+          result.add(e);
         }
         return result;
       }
@@ -22808,7 +22811,8 @@ dart_library.library('dart_sdk', null, /* Imports */[
       static from(elements) {
         let list = new (collection.DoubleLinkedQueue$(E))();
         for (let e of elements) {
-          list.addLast(dart.as(e, E));
+          let element = dart.as(e, E);
+          list.addLast(element);
         }
         return dart.as(list, collection.DoubleLinkedQueue$(E));
       }
@@ -24015,7 +24019,8 @@ dart_library.library('dart_sdk', null, /* Imports */[
         if (isValidKey === void 0) isValidKey = null;
         let result = new (collection.SplayTreeSet$(E))(compare, isValidKey);
         for (let element of elements) {
-          result.add(dart.as(element, E));
+          let e = dart.as(element, E);
+          result.add(e);
         }
         return result;
       }

pkg/dev_compiler/test/codegen/corelib/set_test.dart

@@ -523,5 +523,5 @@ main() {
   testASetFrom((x) => new Set<A>.from(x));
   testASetFrom((x) => new HashSet<A>.from(x));
   testASetFrom((x) => new LinkedHashSet<A>.from(x));
-  testASetFrom((x) => new SplayTreeSet<A>.from(x));
+  testASetFrom((x) => new SplayTreeSet<A>.from(x, identityCompare));
 }

pkg/dev_compiler/test/codegen/lib/collection/hash_map_test.dart

@@ -0,0 +1,42 @@
+// Copyright (c) 2011, 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";
+import "package:expect/expect.dart";
+
+void main() {
+  // Test customized maps.
+  // Regression test for issue http://dartbug.com/18109
+
+  hash(s) => s.toLowerCase().hashCode;
+  equals(a, b) => a.toLowerCase() == b.toLowerCase();
+
+  for (var m in [
+    new HashMap<String,int>(equals: equals, hashCode: hash),
+    new LinkedHashMap<String,int>(equals: equals, hashCode: hash),
+  ]) {
+    m["Abel"] = 42;
+    for (var key in ["Abel", "abel", "ABEL", "Abel"]) {
+      Expect.isTrue(m.containsKey(key), "contains $key in ${m.runtimeType} $m");
+      Expect.equals(42, m[key], "get $key in ${m.runtimeType} $m");
+      Expect.equals(42, m.remove(key), "remove $key in ${m.runtimeType} $m");
+      m[key] = 42;
+    }
+  }
+
+  abshash(n) => n.abs();
+  abseq(a, b) => a.abs() == b.abs();
+  for (var m in [
+    new HashMap<int,int>(equals: abseq, hashCode: abshash),
+    new LinkedHashMap<int,int>(equals: abseq, hashCode: abshash),
+  ]) {
+    m[1] = 42;
+    for (var key in [1, -1, 1]) {
+      Expect.isTrue(m.containsKey(key), "contains $key in ${m.runtimeType} $m");
+      Expect.equals(42, m[key], "get $key in ${m.runtimeType} $m");
+      Expect.equals(42, m.remove(key), "remove $key in ${m.runtimeType} $m");
+      m[key] = 42;
+    }
+  }
+}

pkg/dev_compiler/test/codegen/lib/collection/hash_set_test.dart

@@ -0,0 +1,46 @@
+// Copyright (c) 2011, 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";
+import "package:expect/expect.dart";
+
+void main() {
+  // Test customized sets.
+  // Regression test for issue http://dartbug.com/18109
+
+  hash(s) => s.toLowerCase().hashCode;
+  equals(a, b) => a.toLowerCase() == b.toLowerCase();
+
+  for (var m in [
+    new HashSet<String>(equals: equals, hashCode: hash),
+    new LinkedHashSet<String>(equals: equals, hashCode: hash),
+  ]) {
+    m.add("Abel");
+    var prev = "Abel";
+    for (var key in ["Abel", "abel", "ABEL", "Abel"]) {
+      Expect.isTrue(m.contains(key), "contains $key in ${m.runtimeType} $m");
+      Expect.equals(prev, m.lookup(key), "lookup $key in ${m.runtimeType} $m");
+      Expect.isTrue(m.remove(key), "remove $key in ${m.runtimeType} $m");
+      m.add(key);
+      prev = key;
+    }
+  }
+
+  abshash(n) => n.abs();
+  abseq(a, b) => a.abs() == b.abs();
+  for (var m in [
+    new HashSet<int>(equals: abseq, hashCode: abshash),
+    new LinkedHashSet<int>(equals: abseq, hashCode: abshash),
+  ]) {
+    m.add(1);
+    var prev = 1;
+    for (var key in [1, -1, 1]) {
+      Expect.isTrue(m.contains(key), "contains $key in ${m.runtimeType} $m");
+      Expect.equals(prev, m.lookup(key), "lookup $key in ${m.runtimeType} $m");
+      Expect.isTrue(m.remove(key), "remove $key in ${m.runtimeType} $m");
+      m.add(key);
+      prev = key;
+    }
+  }
+}

pkg/dev_compiler/test/codegen/lib/collection/linked_list_test.dart

@@ -0,0 +1,175 @@
+// 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';
+import "package:expect/expect.dart";
+
+class MyEntry extends LinkedListEntry<MyEntry> {
+  final int value;
+
+  MyEntry(int this.value);
+
+  String toString() => value.toString();
+}
+
+
+testInsert() {
+  // Insert last.
+  var list = new LinkedList<MyEntry>();
+  for (int i = 0; i < 10; i++) {
+    list.add(new MyEntry(i));
+  }
+
+  Expect.equals(10, list.length);
+
+  int i = 0;
+  for (var entry in list) {
+    Expect.equals(i, entry.value);
+    i++;
+  }
+
+  Expect.equals(10, i);
+
+  list.clear();
+
+  // Insert first.
+  for (int i = 0; i < 10; i++) {
+    list.addFirst(new MyEntry(i));
+  }
+
+  Expect.equals(10, list.length);
+
+  i = 10;
+  for (var entry in list) {
+    Expect.equals(--i, entry.value);
+  }
+  Expect.equals(0, i);
+
+  list.clear();
+
+  // Insert after.
+  list.addFirst(new MyEntry(0));
+  for (int i = 1; i < 10; i++) {
+    list.last.insertAfter(new MyEntry(i));
+  }
+
+  Expect.equals(10, list.length);
+
+  i = 0;
+  for (var entry in list) {
+    Expect.equals(i, entry.value);
+    i++;
+  }
+
+  Expect.equals(10, i);
+
+  list.clear();
+
+  // Insert before.
+  list.addFirst(new MyEntry(0));
+  for (int i = 1; i < 10; i++) {
+    list.first.insertBefore(new MyEntry(i));
+  }
+
+  Expect.equals(10, list.length);
+
+  i = 10;
+  for (var entry in list) {
+    Expect.equals(--i, entry.value);
+  }
+  Expect.equals(0, i);
+
+  list.clear();
+}
+
+
+testRemove() {
+  var list = new LinkedList<MyEntry>();
+  for (int i = 0; i < 10; i++) {
+    list.add(new MyEntry(i));
+  }
+
+  Expect.equals(10, list.length);
+
+  list.remove(list.skip(5).first);
+
+  Expect.equals(9, list.length);
+
+  int i = 0;
+  for (var entry in list) {
+    if (i == 5) i++;
+    Expect.equals(i, entry.value);
+    i++;
+  }
+
+  Expect.listEquals([0, 1, 2, 3, 4, 6, 7, 8, 9],
+                    list.map((e) => e.value).toList());
+
+  for (int i = 0; i < 9; i++) {
+    list.first.unlink();
+  }
+
+  Expect.throws(() => list.first);
+
+  Expect.equals(0, list.length);
+}
+
+
+testBadAdd() {
+  var list1 = new LinkedList<MyEntry>();
+  list1.addFirst(new MyEntry(0));
+
+  var list2 = new LinkedList<MyEntry>();
+  Expect.throws(() => list2.addFirst(list1.first));
+
+  Expect.throws(() => new MyEntry(0).unlink());
+}
+
+testConcurrentModificationError() {
+
+  test(function(LinkedList ll)) {
+    var ll = new LinkedList<MyEntry>();
+    for (int i = 0; i < 10; i++) {
+      ll.add(new MyEntry(i));
+    }
+    Expect.throws(() => function(ll), (e) => e is ConcurrentModificationError);
+  }
+  test((ll) { for(var x in ll) { ll.remove(x); } });
+  test((ll) { ll.forEach((x) { ll.remove(x); }); });
+  test((ll) { ll.any((x) { ll.remove(x); return false; }); });
+  test((ll) { ll.every((x) { ll.remove(x); return true; }); });
+  test((ll) { ll.fold(0, (x, y) { ll.remove(y); return x; }); });
+  test((ll) { ll.reduce((x, y) { ll.remove(y); return x; }); });
+  test((ll) { ll.where((x) { ll.remove(x); return true; }).forEach((_) {}); });
+  test((ll) { ll.map((x) { ll.remove(x); return x; }).forEach((_) {}); });
+  test((ll) { ll.expand((x) { ll.remove(x); return[x];}).forEach((_) {}); });
+  test((ll) { ll.takeWhile((x) {
+      ll.remove(x); return true;}).forEach((_) {}); });
+  test((ll) { ll.skipWhile((x) {
+      ll.remove(x); return true;}).forEach((_) {}); });
+  test((ll) {
+    bool first = true;
+    ll.firstWhere((x) {
+      ll.remove(x);
+      if (!first) return true;
+      return first = false;
+    });
+  });
+  test((ll) { ll.lastWhere((x) { ll.remove(x); return true;}); });
+  test((ll) {
+    bool first = true;
+    ll.singleWhere((x) {
+      ll.remove(x);
+      if (!first) return false;
+      return !(first = false);
+    });
+  });
+}
+
+main() {
+  testInsert();
+  testRemove();
+  testBadAdd();
+  testConcurrentModificationError();
+}

pkg/dev_compiler/tool/input_sdk/lib/collection/hash_map.dart

@@ -102,7 +102,7 @@ abstract class HashMap<K, V> implements Map<K, V> {
    */
   factory HashMap.from(Map other) {
     HashMap<K, V> result = new HashMap<K, V>();
-    other.forEach((k, v) { result[k as K] = v as V; });
+    other.forEach((k, v) { result[k as Object/*=K*/] = v as Object/*=V*/; });
     return result;
   }
 

pkg/dev_compiler/tool/input_sdk/lib/collection/hash_set.dart

@@ -121,7 +121,10 @@ abstract class HashSet<E> implements Set<E> {
    */
   factory HashSet.from(Iterable elements) {
     HashSet<E> result = new HashSet<E>();
-    for (final e in elements) result.add(e as E);
+    for (final e in elements) {
+      E element = e as Object/*=E*/;
+      result.add(element);
+    }
     return result;
   }
 

pkg/dev_compiler/tool/input_sdk/lib/collection/linked_hash_map.dart

@@ -89,7 +89,7 @@ abstract class LinkedHashMap<K, V> implements HashMap<K, V> {
    */
   factory LinkedHashMap.from(Map other) {
     LinkedHashMap<K, V> result = new LinkedHashMap<K, V>();
-    other.forEach((k, v) { result[k as K] = v as V; });
+    other.forEach((k, v) { result[k as Object/*=K*/] = v as Object/*=V*/; });
     return result;
   }
 

pkg/dev_compiler/tool/input_sdk/lib/collection/linked_hash_set.dart

@@ -105,7 +105,8 @@ abstract class LinkedHashSet<E> implements HashSet<E> {
   factory LinkedHashSet.from(Iterable elements) {
     LinkedHashSet<E> result = new LinkedHashSet<E>();
     for (final element in elements) {
-      result.add(element as E);
+      E e = element as Object/*=E*/;
+      result.add(e);
     }
     return result;
   }

pkg/dev_compiler/tool/input_sdk/lib/collection/linked_list.dart

@@ -296,6 +296,6 @@ abstract class LinkedListEntry<E extends LinkedListEntry<E>> {
    * The [entry] must not be in a linked list.
    */
   void insertBefore(E entry) {
-    _list._insertBefore(this as E, entry, updateFirst: true);
+    _list._insertBefore(this as dynamic/*=E*/, entry, updateFirst: true);
   }
 }

pkg/dev_compiler/tool/input_sdk/lib/collection/queue.dart

@@ -293,7 +293,8 @@ class DoubleLinkedQueue<E> extends Iterable<E> implements Queue<E> {
   factory DoubleLinkedQueue.from(Iterable elements) {
     Queue<E> list = new DoubleLinkedQueue<E>();
     for (final e in elements) {
-      list.addLast(e as E);
+      E element = e as Object/*=E*/;
+      list.addLast(element);
     }
     return list;
   }
@@ -498,7 +499,7 @@ class ListQueue<E> extends Iterable<E> implements Queue<E> {
       ListQueue<E> queue = new ListQueue(length + 1);
       assert(queue._table.length > length);
       for (int i = 0; i < length; i++) {
-        queue._table[i] = elements[i] as E;
+        queue._table[i] = elements[i] as Object/*=E*/;
       }
       queue._tail = length;
       return queue;
@@ -509,7 +510,7 @@ class ListQueue<E> extends Iterable<E> implements Queue<E> {
       }
       ListQueue<E> result = new ListQueue<E>(capacity);
       for (final element in elements) {
-        result.addLast(element as E);
+        result.addLast(element as Object/*=E*/);
       }
       return result;
     }