Format and sort analyzer and analysis_server packages.

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:math" as math;
 import 'dart:collection';
-import "dart:math" as math;
 
 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 {
   /**
@@ skipping 39 matching lines @@
 
   /**
    * 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
    */
-  static int setEnum(int array, Enum index, bool value) => set(array, index.ordinal, value);
+  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
    */
   static void _checkIndex(int index) {
     if (index < 0 || index > 30) {
       throw new RangeError("Index not between 0 and 30: $index");
@@ skipping 11 matching lines @@
  */
 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.
    */
   HashMap<N, HashSet<N>> _edges = new HashMap<N, HashSet<N>>();
 
   /**
+   * Return `true` if this graph is empty.
+   *
+   * @return `true` if this graph is empty
+   */
+  bool get isEmpty => _edges.isEmpty;
+
+  /**
+   * Return the number of nodes in this graph.
+   *
+   * @return the number of nodes in this graph
+   */
+  int get nodeCount => _edges.length;
+
+  /**
+   * Return a set of all nodes in the graph.
+   */
+  Set<N> get nodes => _edges.keys.toSet();
+
+  /**
    * 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) {
     //
     // First, ensure that the tail is a node known to the graph.
     //
@@ skipping 50 matching lines @@
    */
   List<N> findCycleContaining(N node) {
     if (node == null) {
       throw new IllegalArgumentException();
     }
     DirectedGraph_SccFinder<N> finder = new DirectedGraph_SccFinder<N>(this);
     return finder.componentContaining(node);
   }
 
   /**
-   * Return the number of nodes in this graph.
-   *
-   * @return the number of nodes in this graph
-   */
-  int get nodeCount => _edges.length;
-
-  /**
-   * Return a set of all nodes in the graph.
-   */
-  Set<N> get nodes => _edges.keys.toSet();
-
-  /**
    * 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.
    *
    * @param head the node at the head of all of the edges whose tails are to be returned
    * @return a set containing the tails of edges that have the given node as their head
    */
   Set<N> getTails(N head) {
     HashSet<N> tails = _edges[head];
     if (tails == null) {
       return new HashSet<N>();
     }
     return tails;
   }
 
   /**
-   * Return `true` if this graph is empty.
-   *
-   * @return `true` if this graph is empty
-   */
-  bool get isEmpty => _edges.isEmpty;
-
-  /**
    * Remove all of the given nodes from this graph. As a consequence, any edges for which those
    * nodes were either a head or a tail will also be removed.
    *
    * @param nodes the nodes to be removed
    */
   void removeAllNodes(List<N> nodes) {
     for (N node in nodes) {
       removeNode(node);
     }
   }
@@ skipping 133 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.
    */
-  HashMap<N, DirectedGraph_NodeInfo<N>> _nodeMap = new HashMap<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 135 matching lines @@
 
   /**
    * Return the value associated with the current element.
    *
    * @return the value associated with the current element
    * @throws NoSuchElementException if there is no current element
    */
   V get value;
 
   /**
+   * Set the value associated with the current element to the given value.
+   *
+   * @param newValue the new value to be associated with the current element
+   * @throws NoSuchElementException if there is no current element
+   */
+  void set value(V newValue);
+
+  /**
    * Advance to the next entry in the map. Return `true` if there is a current element that
    * can be accessed after this method returns. It is safe to invoke this method even if the
    * previous invocation returned `false`.
    *
    * @return `true` if there is a current element that can be accessed
    */
   bool moveNext();
-
-  /**
-   * Set the value associated with the current element to the given value.
-   *
-   * @param newValue the new value to be associated with the current element
-   * @throws NoSuchElementException if there is no current element
-   */
-  void set value(V newValue);
 }
 
 /**
  * Instances of the class `MultipleMapIterator` implement an iterator that can be used to
  * sequentially access the entries in multiple maps.
  */
 class MultipleMapIterator<K, V> implements MapIterator<K, V> {
   /**
    * The iterators used to access the entries.
    */
@@ skipping 32 matching lines @@
 
   @override
   V get value {
     if (_currentIterator == null) {
       throw new NoSuchElementException();
     }
     return _currentIterator.value;
   }
 
   @override
+  void set value(V newValue) {
+    if (_currentIterator == null) {
+      throw new NoSuchElementException();
+    }
+    _currentIterator.value = newValue;
+  }
+
+  @override
   bool moveNext() {
     if (_iteratorIndex < 0) {
       if (_iterators.length == 0) {
         _currentIterator = null;
         return false;
       }
       if (_advanceToNextIterator()) {
         return true;
       } else {
         _currentIterator = null;
         return false;
       }
     }
     if (_currentIterator.moveNext()) {
       return true;
     } else if (_advanceToNextIterator()) {
       return true;
     } else {
       _currentIterator = null;
       return false;
     }
   }
 
-  @override
-  void set value(V newValue) {
-    if (_currentIterator == null) {
-      throw new NoSuchElementException();
-    }
-    _currentIterator.value = newValue;
-  }
-
   /**
    * Under the assumption that there are no more entries that can be returned using the current
    * iterator, advance to the next iterator that has entries.
    *
    * @return `true` if there is a current iterator that has entries
    */
   bool _advanceToNextIterator() {
     _iteratorIndex++;
     while (_iteratorIndex < _iterators.length) {
       MapIterator<K, V> iterator = _iterators[_iteratorIndex];
       if (iterator.moveNext()) {
         _currentIterator = iterator;
         return true;
       }
       _iteratorIndex++;
     }
     return false;
   }
 }
 
 /**
- * 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.
-   */
-  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];
-
-  /**
-   * 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;
-  }
-}
-
-/**
  * Instances of the class `SingleMapIterator` implement an iterator that can be used to access
  * the entries in a single map.
  */
 class SingleMapIterator<K, V> implements MapIterator<K, V> {
   /**
-   * Returns a new [SingleMapIterator] instance for the given [Map].
-   */
-  static SingleMapIterator forMap(Map map) => new SingleMapIterator(map);
-
-  /**
    * The [Map] containing the entries to be iterated over.
    */
   final Map<K, V> _map;
 
   /**
    * The iterator used to access the entries.
    */
   Iterator<K> _keyIterator;
 
   /**
@@ skipping 25 matching lines @@
 
   @override
   V get value {
     if (_currentKey == null) {
       throw new NoSuchElementException();
     }
     return _currentValue;
   }
 
   @override
+  void set value(V newValue) {
+    if (_currentKey == null) {
+      throw new NoSuchElementException();
+    }
+    _currentValue = newValue;
+    _map[_currentKey] = newValue;
+  }
+
+  @override
   bool moveNext() {
     if (_keyIterator.moveNext()) {
       _currentKey = _keyIterator.current;
       _currentValue = _map[_currentKey];
       return true;
     } else {
       _currentKey = null;
       return false;
     }
   }
 
-  @override
-  void set value(V newValue) {
-    if (_currentKey == null) {
-      throw new NoSuchElementException();
-    }
-    _currentValue = newValue;
-    _map[_currentKey] = newValue;
+  /**
+   * Returns a new [SingleMapIterator] instance for the given [Map].
+   */
+  static SingleMapIterator forMap(Map map) => new SingleMapIterator(map);
+}
+
+/**
+ * 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.
+   */
+  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];
+
+  /**
+   * 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;
   }
 }