New analyzer snapshot.

pkg/analyzer/lib/src/generated/constant.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.constant;
 
 import 'java_core.dart';
 import 'java_engine.dart' show ObjectUtilities;
 import 'source.dart' show Source;
 import 'error.dart' show AnalysisError, ErrorCode, CompileTimeErrorCode;
 import 'scanner.dart' show Token, TokenType;
 import 'ast.dart';
 import 'element.dart';
 import 'resolver.dart' show TypeProvider;
 import 'engine.dart' show AnalysisEngine;
 import 'utilities_dart.dart' show ParameterKind;
+import 'utilities_collection.dart' show DirectedGraph;
 
 /**
  * Instances of the class `ConstantEvaluator` evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
  * * A literal number.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time constant that evaluates
  * to a numeric, string or boolean value or to <b>null</b>.
  * * A literal symbol.
@@ skipping 851 matching lines @@
   DartObjectImpl _valueOf(Expression expression) {
     EvaluationResultImpl expressionValue = expression.accept(this);
     if (expressionValue is ValidResult) {
       return expressionValue.value;
     }
     return null2;
   }
 }
 
 /**
- * Instances of the class `DirectedGraph` implement a directed graph in which the nodes are
- * arbitrary (client provided) objects and edges are represented implicitly. The graph will allow an
- * edge from any node to any other node, including itself, but will not represent multiple edges
- * 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>>();
-
-  /**
-   * 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.
-    //
-    Set<N> tails = _edges[tail];
-    if (tails == null) {
-      _edges[tail] = new Set<N>();
-    }
-    //
-    // Then create the edge.
-    //
-    tails = _edges[head];
-    if (tails == null) {
-      tails = new Set<N>();
-      _edges[head] = tails;
-    }
-    tails.add(tail);
-  }
-
-  /**
-   * Add the given node to the set of nodes in the graph.
-   *
-   * @param node the node to be added
-   */
-  void addNode(N node) {
-    Set<N> tails = _edges[node];
-    if (tails == null) {
-      _edges[node] = new Set<N>();
-    }
-  }
-
-  /**
-   * Return a list of nodes that form a cycle, or `null` if there are no cycles in this graph.
-   *
-   * @return a list of nodes that form a cycle
-   */
-  List<N> findCycle() => null;
-
-  /**
-   * Return the number of nodes in this graph.
-   *
-   * @return the number of nodes in this graph
-   */
-  int get nodeCount => _edges.length;
-
-  /**
-   * 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) {
-    Set<N> tails = _edges[head];
-    if (tails == null) {
-      return new Set<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);
-    }
-  }
-
-  /**
-   * Remove the edge from the given head node to the given tail node. If there was no such edge then
-   * the graph will be unmodified: the number of edges will be the same and the set of nodes will be
-   * the same (neither node will either be added or removed).
-   *
-   * @param head the node at the head of the edge
-   * @param tail the node at the tail of the edge
-   * @return `true` if the graph was modified as a result of this operation
-   */
-  void removeEdge(N head, N tail) {
-    Set<N> tails = _edges[head];
-    if (tails != null) {
-      tails.remove(tail);
-    }
-  }
-
-  /**
-   * Remove the given node from this graph. As a consequence, any edges for which that node was
-   * either a head or a tail will also be removed.
-   *
-   * @param node the node to be removed
-   */
-  void removeNode(N node) {
-    _edges.remove(node);
-    for (Set<N> tails in _edges.values) {
-      tails.remove(node);
-    }
-  }
-
-  /**
-   * Find one node (referred to as a sink node) that has no outgoing edges (that is, for which there
-   * are no edges that have that node as the head of the edge) and remove it from this graph. Return
-   * the node that was removed, or `null` if there are no such nodes either because the graph
-   * is empty or because every node in the graph has at least one outgoing edge. As a consequence of
-   * removing the node from the graph any edges for which that node was a tail will also be removed.
-   *
-   * @return the sink node that was removed
-   */
-  N removeSink() {
-    N sink = _findSink();
-    if (sink == null) {
-      return null;
-    }
-    removeNode(sink);
-    return sink;
-  }
-
-  /**
-   * Return one node that has no outgoing edges (that is, for which there are no edges that have
-   * that node as the head of the edge), or `null` if there are no such nodes.
-   *
-   * @return a sink node
-   */
-  N _findSink() {
-    for (N key in _edges.keys) {
-      if (_edges[key].isEmpty) return key;
-    }
-    return null;
-  }
-}
-
-/**
  * Instances of the class `ErrorResult` represent the result of evaluating an expression that
  * is not a valid compile time constant.
  */
 class ErrorResult extends EvaluationResultImpl {
   /**
    * The errors that prevent the expression from being a valid compile time constant.
    */
   List<ErrorResult_ErrorData> _errors = new List<ErrorResult_ErrorData>();
 
   /**
@@ skipping 3448 matching lines @@
 
   @override
   String get typeName => "Type";
 
   @override
   int get hashCode => _element == null ? 0 : _element.hashCode;
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }