Remove the transformless phase from AssetCascade.

pkg/barback/lib/src/asset_cascade.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.asset_cascade;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'asset.dart';
@@ skipping 75 matching lines @@
   /// Creates a new [AssetCascade].
   ///
   /// It loads source assets within [package] using [provider] and then uses
   /// [transformerPhases] to generate output files from them.
   //TODO(rnystrom): Better way of specifying transformers and their ordering.
   AssetCascade(this.graph, this.package,
       Iterable<Iterable<Transformer>> transformerPhases) {
     // Flatten the phases to a list so we can traverse backwards to wire up
     // each phase to its next.
     var phases = transformerPhases.toList();
-
-    // Each phase writes its outputs as inputs to the next phase after it.
-    // Add a phase at the end for the final outputs of the last phase.
-    phases.add([]);
+    if (phases.isEmpty) phases = [[]];
 
     Phase nextPhase = null;
     for (var transformers in phases.reversed) {
-      nextPhase = new Phase(this, _phases.length, transformers.toList(),
-          nextPhase);
+      nextPhase = new Phase(this, transformers.toList(), nextPhase);
       nextPhase.onDirty.listen((_) {
         _newChanges = true;
         _waitForProcess();
       });
       _phases.insert(0, nextPhase);
     }
   }
 
   /// Gets the asset identified by [id].
   ///
   /// If [id] is for a generated or transformed asset, this will wait until it
   /// has been created and return it. This means that the returned asset will
   /// always be [AssetState.AVAILABLE].
   ///
   /// If the asset cannot be found, returns null.
   Future<AssetNode> getAssetNode(AssetId id) {
     assert(id.package == package);
 
     // TODO(rnystrom): Waiting for the entire build to complete is unnecessary
     // in some cases. Should optimize:
     // * [id] may be generated before the compilation is finished. We should
     //   be able to quickly check whether there are any more in-place
     //   transformations that can be run on it. If not, we can return it early.
     // * If [id] has never been generated and all active transformers provide
     //   metadata about the file names of assets it can emit, we can prove that
     //   none of them can emit [id] and fail early.
-    return _phases.last.getInput(id).then((node) {
+    return _phases.last.getOutput(id).then((node) {
       // If the requested asset is available, we can just return it.
       if (node != null && node.state.isAvailable) return node;
 
       // If there's a build running, that build might generate the asset, so we
       // wait for it to complete and then try again.
       if (_processDone != null) {
         return _processDone.then((_) => getAssetNode(id));
       }
 
       // If the asset hasn't been built and nothing is building now, the asset
@@ skipping 104 matching lines @@
 
         // Otherwise, everything is done.
         return;
       }
 
       // Process that phase and then loop onto the next.
       return future.then((_) => _process());
     });
   }
 }