Removed fixed dependencies

packages/analyzer/lib/src/generated/utilities_collection.dart

 // Copyright (c) 2014, 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.
 
-library engine.utilities.collection;
+library analyzer.src.generated.utilities_collection;
 
+import 'dart:collection';
 import "dart:math" as math;
-import 'dart:collection';
 
-import 'java_core.dart';
-import 'scanner.dart' show Token;
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/src/generated/java_core.dart';
 
 /**
- * The class `BooleanArray` defines methods for operating on integers as if they were arrays
- * of booleans. These arrays can be indexed by either integers or by enumeration constants.
+ * Returns `true` if a and b contain equal elements in the same order.
+ */
+bool listsEqual(List a, List b) {
+  // TODO(rnystrom): package:collection also implements this, and analyzer
+  // already transitively depends on that package. Consider using it instead.
+  if (identical(a, b)) {
+    return true;
+  }
+
+  if (a.length != b.length) {
+    return false;
+  }
+
+  for (int i = 0; i < a.length; i++) {
+    if (a[i] != b[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Methods for operating on integers as if they were arrays of booleans. These
+ * arrays can be indexed by either integers or by enumeration constants.
  */
 class BooleanArray {
   /**
-   * Return the value of the element at the given index.
-   *
-   * @param array the array being accessed
-   * @param index the index of the element being accessed
-   * @return the value of the element at the given index
-   * @throws IndexOutOfBoundsException if the index is not between zero (0) and 31, inclusive
+   * Return the value of the element of the given [array] at the given [index].
    */
   static bool get(int array, int index) {
     _checkIndex(index);
     return (array & (1 << index)) > 0;
   }
 
   /**
    * Return the value of the element at the given index.
-   *
-   * @param array the array being accessed
-   * @param index the index of the element being accessed
-   * @return the value of the element at the given index
-   * @throws IndexOutOfBoundsException if the index is not between zero (0) and 31, inclusive
    */
+  @deprecated
   static bool getEnum(int array, Enum index) => get(array, index.ordinal);
 
   /**
-   * Set the value of the element at the given index to the given value.
-   *
-   * @param array the array being modified
-   * @param index the index of the element being set
-   * @param value the value to be assigned to the element
-   * @return the updated value of the array
-   * @throws IndexOutOfBoundsException if the index is not between zero (0) and 31, inclusive
+   * Set the value of the element of the given [array] at the given [index] to
+   * the given [value].
    */
   static int set(int array, int index, bool value) {
     _checkIndex(index);
     if (value) {
       return array | (1 << index);
     } else {
       return array & ~(1 << index);
     }
   }
 
   /**
    * Set the value of the element at the given index to the given value.
-   *
-   * @param array the array being modified
-   * @param index the index of the element being set
-   * @param value the value to be assigned to the element
-   * @return the updated value of the array
-   * @throws IndexOutOfBoundsException if the index is not between zero (0) and 31, inclusive
    */
+  @deprecated
   static int setEnum(int array, Enum index, bool value) =>
       set(array, index.ordinal, value);
 
   /**
-   * Throw an exception if the index is not within the bounds allowed for an integer-encoded array
-   * of boolean values.
-   *
-   * @throws IndexOutOfBoundsException if the index is not between zero (0) and 31, inclusive
+   * Throw an exception if the index is not within the bounds allowed for an
+   * integer-encoded array of boolean values.
    */
   static void _checkIndex(int index) {
     if (index < 0 || index > 30) {
       throw new RangeError("Index not between 0 and 30: $index");
     }
   }
 }
 
 /**
  * Instances of the class `DirectedGraph` implement a directed graph in which the nodes are
@@ skipping 87 matching lines @@
   }
 
   /**
    * Return a list of nodes that form a cycle containing the given node. If the node is not part of
    * this graph, then a list containing only the node itself will be returned.
    *
    * @return a list of nodes that form a cycle containing the given node
    */
   List<N> findCycleContaining(N node) {
     if (node == null) {
-      throw new IllegalArgumentException();
+      throw new ArgumentError();
     }
     DirectedGraph_SccFinder<N> finder = new DirectedGraph_SccFinder<N>(this);
     return finder.componentContaining(node);
   }
 
   /**
    * Return a set containing the tails of edges that have the given node as their head. The set will
    * be empty if there are no such edges or if the node is not part of the graph. Clients must not
    * modify the returned set.
    *
@@ skipping 265 matching lines @@
         component.add(w);
         _nodeMap[w].component = component;
       } while (!identical(w, v));
       _allComponents.add(component);
     }
     return vInfo;
   }
 }
 
 /**
- * The class `ListUtilities` defines utility methods useful for working with [List
- ].
- */
-class ListUtilities {
-  /**
-   * Add all of the elements in the given array to the given list.
-   *
-   * @param list the list to which the elements are to be added
-   * @param elements the elements to be added to the list
-   */
-  static void addAll(List list, List<Object> elements) {
-    int count = elements.length;
-    for (int i = 0; i < count; i++) {
-      list.add(elements[i]);
-    }
-  }
-}
-
-/**
  * The interface `MapIterator` defines the behavior of objects that iterate over the entries
  * in a map.
  *
  * This interface defines the concept of a current entry and provides methods to access the key and
  * value in the current entry. When an iterator is first created it will be positioned before the
  * first entry and there is no current entry until [moveNext] is invoked. When all of the
  * entries have been accessed there will also be no current entry.
  *
  * There is no guarantee made about the order in which the entries are accessible.
  */
@@ skipping 61 matching lines @@
     int count = maps.length;
     _iterators = new List<MapIterator<K, V>>(count);
     for (int i = 0; i < count; i++) {
       _iterators[i] = new SingleMapIterator<K, V>(maps[i]);
     }
   }
 
   @override
   K get key {
     if (_currentIterator == null) {
-      throw new NoSuchElementException();
+      throw new StateError('No element');
     }
     return _currentIterator.key;
   }
 
   @override
   V get value {
     if (_currentIterator == null) {
-      throw new NoSuchElementException();
+      throw new StateError('No element');
     }
     return _currentIterator.value;
   }
 
   @override
   void set value(V newValue) {
     if (_currentIterator == null) {
-      throw new NoSuchElementException();
+      throw new StateError('No element');
     }
     _currentIterator.value = newValue;
   }
 
   @override
   bool moveNext() {
     if (_iteratorIndex < 0) {
       if (_iterators.length == 0) {
         _currentIterator = null;
         return false;
@@ skipping 65 matching lines @@
    *
    * @param map the map containing the entries to be iterated over
    */
   SingleMapIterator(this._map) {
     this._keyIterator = _map.keys.iterator;
   }
 
   @override
   K get key {
     if (_currentKey == null) {
-      throw new NoSuchElementException();
+      throw new StateError('No element');
     }
     return _currentKey;
   }
 
   @override
   V get value {
     if (_currentKey == null) {
-      throw new NoSuchElementException();
+      throw new StateError('No element');
     }
     if (_currentValue == null) {
       _currentValue = _map[_currentKey];
     }
     return _currentValue;
   }
 
   @override
   void set value(V newValue) {
     if (_currentKey == null) {
-      throw new NoSuchElementException();
+      throw new StateError('No element');
     }
     _currentValue = newValue;
     _map[_currentKey] = newValue;
   }
 
   @override
   bool moveNext() {
     if (_keyIterator.moveNext()) {
       _currentKey = _keyIterator.current;
       _currentValue = null;
@@ skipping 33 matching lines @@
   /**
    * Map the key to the value.
    *
    * @param key the token being mapped to the value
    * @param value the token to which the key will be mapped
    */
   void put(Token key, Token value) {
     _map[key] = value;
   }
 }