Add a bunch of toString methods to internal Barback classes.

pkg/barback/lib/src/phase_input.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_input;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'asset.dart';
 import 'asset_forwarder.dart';
 import 'asset_node.dart';
 import 'errors.dart';
 import 'log.dart';
 import 'phase.dart';
 import 'stream_pool.dart';
 import 'transform_node.dart';
 import 'transformer.dart';
 import 'utils.dart';
 
 /// A class for watching a single [AssetNode] and running any transforms that
 /// take that node as a primary input.
 class PhaseInput {
   /// The phase for which this is an input.
   final Phase _phase;
 
+  /// A string describing the location of [this] in the transformer graph.
+  final String _location;
+
   /// The transformers to (potentially) run against [input].
   final Set<Transformer> _transformers;
 
   /// The transforms currently applicable to [input].
   ///
   /// These are the transforms that have been "wired up": they represent a
   /// repeatable transformation of a single concrete set of inputs. "dart2js" is
   /// a transformer. "dart2js on web/main.dart" is a transform.
   final _transforms = new Set<TransformNode>();
 
@@ skipping 40 matching lines @@
 
   /// Whether this input is dirty and needs [process] to be called.
   bool get isDirty => _adjustTransformersFuture != null ||
       _newPassThrough || _transforms.any((transform) => transform.isDirty);
 
   /// A stream that emits an event whenever any transforms that use [input] as
   /// their primary input log an entry.
   Stream<LogEntry> get onLog => _onLogPool.stream;
   final _onLogPool = new StreamPool<LogEntry>.broadcast();
 
-  PhaseInput(this._phase, AssetNode input, Iterable<Transformer> transformers)
+  PhaseInput(this._phase, AssetNode input, Iterable<Transformer> transformers,
+        this._location)

[Bob Nystrom, 2014/02/05 20:51:14]

Only indent +4.

[nweiz, 2014/02/05 21:23:24]

Done.

       : _transformers = transformers.toSet(),
         _inputForwarder = new AssetForwarder(input) {
     _onDirtyPool.add(_onDirtyController.stream);
 
     input.onStateChange.listen((state) {
       if (state.isRemoved) {
         remove();
       } else if (_adjustTransformersFuture == null) {
         _adjustTransformers();
       }
@@ skipping 123 matching lines @@
       // run will be discarded, so we can just short-circuit.
       if (input.asset == null) return new Future.value();
 
       // We can safely access [input.asset] here even though it might have
       // changed since (as above) if it has, [_adjustTransformers] will just be
       // re-run.
       // TODO(rnystrom): Catch all errors from isPrimary() and redirect to
       // results.
       return transformer.isPrimary(input.asset).then((isPrimary) {
         if (!isPrimary) return;
-        var transform = new TransformNode(_phase, transformer, input);
+        var transform = new TransformNode(
+            _phase, transformer, input, _location);
         _transforms.add(transform);
         _onDirtyPool.add(transform.onDirty);
         _onLogPool.add(transform.onLog);
       });
     }));
   }
 
   /// Adjust whether [input] is passed through the phase unmodified, based on
   /// whether it's consumed by other transforms in this phase.
   ///
@@ skipping 63 matching lines @@
       _newPassThrough = false;
       return new Future.value(
           new Set<AssetNode>.from([_passThroughController.node]));
     }
 
     return Future.wait(_transforms.map((transform) {
       if (!transform.isDirty) return new Future.value(new Set());
       return transform.apply();
     })).then((outputs) => unionAll(outputs));
   }
+
+  String toString() => "phase input in $_location for $input";
 }