Consider errors logged by a transformer equivalent to thrown errors.

pkg/barback/lib/src/transform_node.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.transform_node;
 
 import 'dart:async';
 
 import 'asset.dart';
 import 'asset_id.dart';
@@ skipping 211 matching lines @@
       if (_state.needsIsPrimary) return null;
       _state = _TransformNodeState.PROCESSING;
       // TODO(nweiz): If [transformer] is a [DeclaringTransformer] but not a
       // [LazyTransformer], we can get some mileage out of doing a declarative
       // first so we know how to hook up the assets.
       if (_isLazy) return _declareLazy();
       return _applyImmediate();
     }).catchError((error, stackTrace) {
       // If the transform became dirty while processing, ignore any errors from
       // it.
-      if (!_state.isProcessing || _isRemoved) return;
+      if (!_state.isProcessing || _isRemoved) return false;
 
       if (error is! MissingInputException) {
         error = new TransformerException(info, error, stackTrace);
       }
 
       // Catch all transformer errors and pipe them to the results stream. This
       // is so a broken transformer doesn't take down the whole graph.
       phase.cascade.reportError(error);
-
-      _clearOutputs();
-      _dontEmitPassThrough();
-    }).then((_) {
+      return true;
+    }).then((hadError) {
       if (_isRemoved) return;
 
       if (_state.needsIsPrimary) {
         _process();
       } else if (_state.needsApply) {
         _apply();
       } else {
         assert(_state.isProcessing);
+        if (hadError) {
+          _clearOutputs();
+          _dontEmitPassThrough();
+        }
+
         _state = _TransformNodeState.APPLIED;
         _onDoneController.add(null);
       }
     });
   }
 
   /// Gets the asset for an input [id].
   ///
   /// If an input with that ID cannot be found, throws an
   /// [AssetNotFoundException].
   Future<Asset> getInput(AssetId id) {
     return phase.getInput(id).then((node) {
       // Throw if the input isn't found. This ensures the transformer's apply
       // is exited. We'll then catch this and report it through the proper
       // results stream.
       if (node == null) throw new MissingInputException(info, id);
 
       _inputSubscriptions.putIfAbsent(node.id, () {
         return node.onStateChange.listen((_) => _dirty(primaryChanged: false));
       });
 
       return node.asset;
     });
   }
 
   /// Applies the transform so that it produces concrete (as opposed to lazy)
   /// outputs.
-  Future _applyImmediate() {
+  ///
+  /// Returns whether or not the transformer logged an error.
+  Future<bool> _applyImmediate() {
     var transformController = new TransformController(this);
     _onLogPool.add(transformController.onLog);
 
     return syncFuture(() {
       return transformer.apply(transformController.transform);
     }).then((_) {
-      if (!_state.isProcessing || _onAssetController.isClosed) return;
+      if (!_state.isProcessing || _onAssetController.isClosed) return false;
+      if (transformController.loggedError) return true;
 
       _consumePrimary = transformController.consumePrimary;
 
       var newOutputs = transformController.outputs;
       // Any ids that are for a different package are invalid.
       var invalidIds = newOutputs
           .map((asset) => asset.id)
           .where((id) => id.package != phase.cascade.package)
           .toSet();
       for (var id in invalidIds) {
@@ skipping 20 matching lines @@
       for (var asset in newOutputs) {
         var controller = _outputControllers[asset.id];
         if (controller != null) {
           controller.setAvailable(asset);
         } else {
           var controller = new AssetNodeController.available(asset, this);
           _outputControllers[asset.id] = controller;
           _onAssetController.add(controller.node);
         }
       }
+
+      return false;
     });
   }
 
   /// Applies the transform in declarative mode so that it produces lazy
   /// outputs.
-  Future _declareLazy() {
+  ///
+  /// Returns whether or not the transformer logged an error.
+  Future<bool> _declareLazy() {
     var transformController = new DeclaringTransformController(this);
 
     return syncFuture(() {
       return (transformer as LazyTransformer)
           .declareOutputs(transformController.transform);
     }).then((_) {
-      if (!_state.isProcessing || _onAssetController.isClosed) return;
+      if (!_state.isProcessing || _onAssetController.isClosed) return false;
+      if (transformController.loggedError) return true;
 
       _consumePrimary = transformController.consumePrimary;
 
       var newIds = transformController.outputIds;
       var invalidIds =
           newIds.where((id) => id.package != phase.cascade.package).toSet();
       for (var id in invalidIds) {
         newIds.remove(id);
         // TODO(nweiz): report this as a warning rather than a failing error.
         phase.cascade.reportError(new InvalidOutputException(info, id));
@@ skipping 16 matching lines @@
       for (var id in newIds) {
         var controller = _outputControllers[id];
         if (controller != null) {
           controller.setLazy(force);
         } else {
           var controller = new AssetNodeController.lazy(id, force, this);
           _outputControllers[id] = controller;
           _onAssetController.add(controller.node);
         }
       }
+
+      return false;
     });
   }
 
   /// Cancels all subscriptions to secondary input nodes.
   void _clearInputSubscriptions() {
     for (var subscription in _inputSubscriptions.values) {
       subscription.cancel();
     }
     _inputSubscriptions.clear();
   }
@@ skipping 92 matching lines @@
   ///
   /// Specifically, whether [this] is [APPLIED] or [NOT_PRIMARY].
   bool get isDone => isApplied || isNotPrimary;
 
   final String name;
 
   const _TransformNodeState._(this.name);
 
   String toString() => name;
 }