Tighten up a bunch of types in test.dart.

tools/testing/dart/dependency_graph.dart

 // 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.
 
 library dependency_graph;
 
 import 'dart:async';
 import 'utils.dart';
 
 /*
@@ skipping 10 matching lines @@
  *   - stateCount: Counts the number of nodes who are in a given [NodeState].
  *
  * Users of a [Graph] can listen for events by subscribing to the [events]
  * stream. Three types of events will be fired (after the graph was modified):
  *   - NodeAddedEvent: Fired after a node was added ot the graph.
  *   - StateChangedEvent: Fired after the state of a node changed.
  *   - GraphSealedEvent: Fired after the graph was marked as immutable/sealed.
  */
 class Graph {
   final _nodes = new Set<Node>();
-  final _eventController = new StreamController<GraphEvent>();
-  final _stateCounts = new Map<NodeState, int>();
-  var _eventStream;
+  final StreamController<GraphEvent> _eventController;
+  final _stateCounts = <NodeState, int>{};
+  final Stream<GraphEvent> _eventStream;
   bool _isSealed = false;
 
-  Graph() {
-    _eventStream = _eventController.stream.asBroadcastStream();
+  factory Graph() {
+    var controller = new StreamController<GraphEvent>();
+    return new Graph._(controller, controller.stream.asBroadcastStream());
   }
 
+  Graph._(this._eventController, this._eventStream);
+
   Iterable<Node> get nodes => _nodes;
   Stream<GraphEvent> get events => _eventStream;
   bool get isSealed => _isSealed;
 
   int stateCount(NodeState state) {
     int count = _stateCounts[state];
     return count == null ? 0 : count;
   }
 
   void DumpCounts() {
@@ skipping 31 matching lines @@
     var fromState = node.state;
     node._state = newState;
 
     _stateCounts[fromState] -= 1;
     _stateCounts.putIfAbsent(newState, () => 0);
     _stateCounts[newState] += 1;
 
     _emitEvent(new StateChangedEvent(node, fromState, newState));
   }
 
-  _emitEvent(GraphEvent event) {
+  void _emitEvent(GraphEvent event) {
     // We emit events asynchronously so the graph can be build up in small
     // batches and the events are delivered in small batches.
     Timer.run(() {
       _eventController.add(event);
     });
   }
 }
 
 class Node extends UniqueObject {
   final Object _userData;
@@ skipping 35 matching lines @@
   NodeAddedEvent(this.node);
 }
 
 class StateChangedEvent extends GraphEvent {
   final Node node;
   final NodeState from;
   final NodeState to;
 
   StateChangedEvent(this.node, this.from, this.to);
 }