Add a bunch of toString methods to internal Barback classes.

pkg/barback/lib/src/phase.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 barback.phase;
 
 import 'dart:async';
 
 import 'asset_cascade.dart';
 import 'asset_id.dart';
@@ skipping 18 matching lines @@
 ///
 /// Building can be interrupted between phases. For example, a source is added
 /// which starts the background process. Sometime during, say, phase 2 (which
 /// is running asynchronously) that source is modified. When the process queue
 /// goes to advance to phase 3, it will see that modification and start the
 /// waterfall from the beginning again.
 class Phase {
   /// The cascade that owns this phase.
   final AssetCascade cascade;
 
+  /// A string describing the location of [this] in the transformer graph.
+  final String _location;
+
+  /// The index of [this] in its parent cascade or group.
+  final int _index;
+
   /// The transformers that can access [inputs].
   ///
   /// Their outputs will be available to the next phase.
   final Set<Transformer> _transformers;
 
   /// The groups for this phase.
   final _groups = new Map<TransformerGroup, GroupRunner>();
 
   /// The inputs for this phase.
   ///
@@ skipping 55 matching lines @@
   Set<AssetNode> get availableOutputs {
     return _outputs.values
         .map((output) => output.output)
         .where((node) => node.state.isAvailable)
         .toSet();
   }
 
   // TODO(nweiz): Rather than passing the cascade and the phase everywhere,
   // create an interface that just exposes [getInput]. Emit errors via
   // [AssetNode]s.
-  Phase(this.cascade, Iterable transformers)
+  Phase(AssetCascade cascade, Iterable transformers, String location)
+      : this._(cascade, transformers, location, 0);
+
+  Phase._(this.cascade, Iterable transformers, this._location, this._index)
       : _transformers = transformers.where((op) => op is Transformer).toSet() {
     _onDirtyPool.add(_onDirtyController.stream);
 
     for (var group in transformers.where((op) => op is TransformerGroup)) {
-      var runner = new GroupRunner(cascade, group);
+      var runner = new GroupRunner(cascade, group, "$_location.$_index");
       _groups[group] = runner;
       _onDirtyPool.add(runner.onDirty);
       _onLogPool.add(runner.onLog);
     }
   }
 
   /// Adds a new asset as an input for this phase.
   ///
   /// [node] doesn't have to be [AssetState.AVAILABLE]. Once it is, the phase
   /// will automatically begin determining which transforms can consume it as a
@@ skipping 11 matching lines @@
     var forwarder = new PhaseForwarder(_groups.length + 1);
     _forwarders[node.id] = forwarder;
     forwarder.onForwarding.listen((asset) {
       _addOutput(asset);
 
       var exception = _outputs[asset.id].collisionException;
       if (exception != null) cascade.reportError(exception);
     });
 
     _inputOrigins.add(node.origin);
-    var input = new PhaseInput(this, node, _transformers);
+    var input = new PhaseInput(this, node, _transformers, "$_location.$_index");
     _inputs[node.id] = input;
     input.input.whenRemoved(() {
       _inputOrigins.remove(node.origin);
       _inputs.remove(node.id);
       _forwarders.remove(node.id).remove();
     });
     _onDirtyPool.add(input.onDirty);
     _onDirtyController.add(null);
     _onLogPool.add(input.onLog);
 
@@ skipping 36 matching lines @@
     }
 
     var newGroups = transformers.where((op) => op is TransformerGroup)
         .toSet();
     var oldGroups = _groups.keys.toSet();
     for (var removed in oldGroups.difference(newGroups)) {
       _groups.remove(removed).remove();
     }
 
     for (var added in newGroups.difference(oldGroups)) {
-      var runner = new GroupRunner(cascade, added);
+      var runner = new GroupRunner(cascade, added, "$_location.$_index");
       _groups[added] = runner;
       _onDirtyPool.add(runner.onDirty);
       _onLogPool.add(runner.onLog);
       for (var input in _inputs.values) {
         runner.addInput(input.input);
       }
     }
 
     for (var forwarder in _forwarders.values) {
       forwarder.numChannels = _groups.length + 1;
     }
   }
 
   /// Add a new phase after this one with [transformers].
   ///
   /// This may only be called on a phase with no phase following it.
   Phase addPhase(Iterable transformers) {
     assert(_next == null);
-    _next = new Phase(cascade, transformers);
+    _next = new Phase._(cascade, transformers, _location, _index + 1);
     for (var output in _outputs.values.toList()) {
       // Remove [output]'s listeners because now they should get the asset from
       // [_next], rather than this phase. Any transforms consuming [output] will
       // be re-run and will consume the output from the new final phase.
       output.removeListeners();
     }
     return _next;
   }
 
   /// Mark this phase as removed.
@@ skipping 60 matching lines @@
         if (exception != null) cascade.reportError(exception);
       }
     });
   }
 
   /// Add [asset] as an output of this phase.
   void _addOutput(AssetNode asset) {
     if (_outputs.containsKey(asset.id)) {
       _outputs[asset.id].add(asset);
     } else {
-      _outputs[asset.id] = new PhaseOutput(this, asset);
+      _outputs[asset.id] = new PhaseOutput(this, asset, "$_location.$_index");
       _outputs[asset.id].onAsset.listen((output) {
         if (_next != null) _next.addInput(output);
       }, onDone: () => _outputs.remove(asset.id));
       if (_next != null) _next.addInput(_outputs[asset.id].output);
     }
   }
+
+  String toString() => "phase $_location.$_index";
 }