Asset load failures in Barback should produce AssetNotFoundExceptions.

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 168 matching lines @@
     _clearInputSubscriptions();
     _state = _TransformNodeState.PROCESSING;
     primary.whenAvailable((_) {
       _state = _TransformNodeState.PROCESSING;
       return transformer.isPrimary(primary.asset);
     }).catchError((error, stackTrace) {
       // If the transform became dirty while processing, ignore any errors from
       // it.
       if (_state.needsIsPrimary || _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);
+      phase.cascade.reportError(_wrapException(error, stackTrace));
 
       return false;
     }).then((isPrimary) {
       if (_isRemoved) return;
       if (_state.needsIsPrimary) {
         _process();
       } else if (isPrimary) {
         _apply();
       } else {
         _clearOutputs();
@@ skipping 18 matching lines @@
       // 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 (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);
+      phase.cascade.reportError(_wrapException(error, stackTrace));
 
       _clearOutputs();
       _dontEmitPassThrough();
     }).then((_) {
       if (_isRemoved) return;
 
       if (_state.needsIsPrimary) {
         _process();
       } else if (_state.needsApply) {
         _apply();
       } else {
         assert(_state.isProcessing);
         _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].
+  /// If an input with [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);
+      if (node == null) throw new AssetNotFoundException(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)
@@ skipping 128 matching lines @@
     }
   }
 
   /// Stop emitting the pass-through asset if it's being emitted already.
   void _dontEmitPassThrough() {
     if (_passThroughController == null) return;
     _passThroughController.setRemoved();
     _passThroughController = null;
   }
 
+  BarbackException _wrapException(error, StackTrace stackTrace) {
+    if (error is! AssetNotFoundException) {
+      return new TransformerException(info, error, stackTrace);
+    } else {
+      return new MissingInputException(info, error.id);
+    }
+  }
+
   String toString() =>
     "transform node in $_location for $transformer on $primary";
 }
 
 /// The enum of states that [TransformNode] can be in.
 class _TransformNodeState {
   /// The transform node is running [Transformer.isPrimary] or
   /// [Transformer.apply] and doesn't need to re-run them.
   ///
   /// If there are no external changes by the time the processing finishes, this
@@ skipping 52 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;
 }