New analyzer snapshot.

pkg/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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.utilities.collection;
 
+import 'dart:collection';
 import 'java_core.dart';
 import 'scanner.dart' show Token;
 
 /**
  * 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.
  */
 class BooleanArray {
   /**
    * Return the value of the element at the given index.
@@ skipping 67 matching lines @@
  * between the same pair of nodes.
  *
  * @param N the type of the nodes in the graph
  */
 class DirectedGraph<N> {
   /**
    * The table encoding the edges in the graph. An edge is represented by an entry mapping the head
    * to a set of tails. Nodes that are not the head of any edge are represented by an entry mapping
    * the node to an empty set of tails.
    */
-  Map<N, Set<N>> _edges = new Map<N, Set<N>>();
+  HashMap<N, Set<N>> _edges = new HashMap<N, Set<N>>();
 
   /**
    * Add an edge from the given head node to the given tail node. Both nodes will be a part of the
    * graph after this method is invoked, whether or not they were before.
    *
    * @param head the node at the head of the edge
    * @param tail the node at the tail of the edge
    */
   void addEdge(N head, N tail) {
     //
@@ skipping 240 matching lines @@
   int _index = 0;
 
   /**
    * The stack of nodes that are being visited in order to identify components.
    */
   List<N> _stack = new List<N>();
 
   /**
    * A table mapping nodes to information about the nodes that is used by this algorithm.
    */
-  Map<N, DirectedGraph_NodeInfo<N>> _nodeMap = new Map<N, DirectedGraph_NodeInfo<N>>();
+  HashMap<N, DirectedGraph_NodeInfo<N>> _nodeMap = new HashMap<N, DirectedGraph_NodeInfo<N>>();
 
   /**
    * A list of all strongly connected components found, in topological sort order (each node in a
    * strongly connected component only has edges that point to nodes in the same component or
    * earlier components).
    */
   List<List<N>> _allComponents = new List<List<N>>();
 
   /**
    * Initialize a newly created finder.
@@ skipping 262 matching lines @@
 
 /**
  * Instances of the class `TokenMap` map one set of tokens to another set of tokens.
  */
 class TokenMap {
   /**
    * A table mapping tokens to tokens. This should be replaced by a more performant implementation.
    * One possibility is a pair of parallel arrays, with keys being sorted by their offset and a
    * cursor indicating where to start searching.
    */
-  Map<Token, Token> _map = new Map<Token, Token>();
+  HashMap<Token, Token> _map = new HashMap<Token, Token>();
 
   /**
    * Return the token that is mapped to the given token, or `null` if there is no token
    * corresponding to the given token.
    *
    * @param key the token being mapped to another token
    * @return the token that is mapped to the given token
    */
   Token get(Token key) => _map[key];
 
@@ skipping 77 matching lines @@
 
   @override
   void set value(V newValue) {
     if (_currentKey == null) {
       throw new NoSuchElementException();
     }
     _currentValue = newValue;
     _map[_currentKey] = newValue;
   }
 }