Don't assume that a transform node is consistently deferred or not.

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 34 matching lines @@
   /// The subscription to [phase]'s [Phase.onAsset] stream.
   StreamSubscription<AssetNode> _phaseSubscription;
 
   /// How far along [this] is in processing its assets.
   NodeStatus get status {
     if (_state == _State.NOT_PRIMARY || _state == _State.APPLIED ||
         _state == _State.DECLARED) {
       return NodeStatus.IDLE;
     }
 
-    if (transformer is DeclaringTransformer && _state != _State.DECLARING) {
+    if (_declaring && _state != _State.DECLARING) {
       return NodeStatus.MATERIALIZING;
     } else {
       return NodeStatus.RUNNING;
     }
   }
 
-  /// Whether this transform is deferred.
+  /// Whether this is a declaring transform.
   ///
-  /// A transform is deferred if either its transformer is lazy or if its
-  /// transformer is declaring and its primary input comes from a deferred
-  /// transformer.
-  final bool deferred;
+  /// This is usually identical to `transformer is DeclaringTransformer`, but if
+  /// a declaring and non-lazy transformer emits an error during
+  /// `declareOutputs` it's treated as though it wasn't declaring.
+  bool get _declaring => transformer is DeclaringTransformer &&
+      (_state == _State.DECLARING || _declaredOutputs != null);
 
   /// Whether this transform has been forced since it last finished applying.
   ///
   /// A transform being forced means it should run until it generates outputs
-  /// and is no longer dirty. This is always true for non-[deferred]
+  /// and is no longer dirty. This is always true for non-declaring
   /// transformers, since they always need to eagerly generate outputs.
   bool _forced;
 
   /// The subscriptions to each input's [AssetNode.onStateChange] stream.
   final _inputSubscriptions = new Map<AssetId, StreamSubscription>();
 
   /// The controllers for the asset nodes emitted by this node.
   final _outputControllers = new Map<AssetId, AssetNodeController>();
 
   /// The ids of inputs the transformer tried and failed to read last time it
@@ skipping 14 matching lines @@
   Stream<NodeStatus> get onStatusChange => _streams.onStatusChange;
   Stream<AssetNode> get onAsset => _streams.onAsset;
   Stream<LogEntry> get onLog => _streams.onLog;
 
   /// The current state of [this].
   var _state = _State.DECLARING;
 
   /// Whether [this] has been marked as removed.
   bool get _isRemoved => _streams.onAssetController.isClosed;
 
+  // If [transformer] is declaring but not lazy and [primary] is available, we
+  // can run [apply] even if [force] hasn't been called, since [transformer]
+  // should run eagerly if possible.
+  bool get _canRunDeclaringEagerly =>
+      _declaring && transformer is! LazyTransformer &&
+      primary.state.isAvailable;
+
   /// Whether the most recent run of this transform has declared that it
   /// consumes the primary input.
   ///
   /// Defaults to `false`. This is not meaningful unless [_state] is
   /// [_State.APPLIED] or [_State.DECLARED].
   bool _consumePrimary = false;
 
   /// The set of output ids that [transformer] declared it would emit.
   ///
   /// This is only non-null if [transformer] is a [DeclaringTransformer] and its
   /// [declareOutputs] has been run successfully.
   Set<AssetId> _declaredOutputs;
 
   TransformNode(this.phase, Transformer transformer, AssetNode primary,
       this._location)
       : transformer = transformer,
-        primary = primary,
-        deferred = transformer is LazyTransformer ||
-            (transformer is DeclaringTransformer && primary.deferred) {
-    _forced = !deferred;
+        primary = primary {
+    _forced = transformer is! DeclaringTransformer;
 
     _primarySubscription = primary.onStateChange.listen((state) {
       if (state.isRemoved) {
         remove();
       } else {
-        if (state.isDirty && !deferred) primary.force();
-        // If this is deferred but applying, that means it must have been
-        // forced, so we should ensure its input remains forced as well.
-        if (deferred && _forced && _state == _State.APPLYING) primary.force();
+        if (_forced) primary.force();
         _dirty();
       }
     });
 
     _phaseSubscription = phase.previous.onAsset.listen((node) {
       if (!_missingInputs.contains(node.id)) return;
-      if (!deferred) node.force();
+      if (_forced) node.force();
       _dirty();
     });
 
     _isPrimary();
   }
 
   /// The [TransformInfo] describing this node.
   ///
   /// [TransformInfo] is the publicly-visible representation of a transform
   /// node.
@@ skipping 16 matching lines @@
       _passThroughController = null;
     }
   }
 
   /// If [this] is deferred, ensures that its concrete outputs will be
   /// generated.
   void force() {
     if (_forced || _state == _State.APPLIED) return;
     primary.force();
     _forced = true;
-    _dirty();
+    if (_state == _State.DECLARED) _dirty();
   }
 
   /// Marks this transform as dirty.
   ///
   /// This causes all of the transform's outputs to be marked as dirty as well.
   void _dirty() {
     if (_state == _State.NOT_PRIMARY) {
       _emitPassThrough();
       return;
     }
 
     // If we're in the process of running [isPrimary] or [declareOutputs], we
     // already know that [apply] needs to be run so there's nothing we need to
     // mark as dirty.
     if (_state == _State.DECLARING) return;
 
-    // If [transformer] is declaring but not lazy and [primary] is available, we
-    // do want to start running [apply] even if [force] hasn't been called,
-    // since [transformer] should run eagerly if possible.
-    var canRunDeclaringEagerly =
-        transformer is! LazyTransformer && primary.state.isAvailable;
-    if (!_forced && !canRunDeclaringEagerly) {
-      // [forced] should only ever be false for a deferred transform.
-      assert(deferred);
+    if (!_forced && !_canRunDeclaringEagerly) {
+      // [forced] should only ever be false for a declaring transformer.
+      assert(_declaring);
 
       // If we've finished applying, transition to MATERIALIZING, indicating
       // that we know what outputs [apply] will emit but we're waiting to emit
       // them concretely until [force] is called. If we're still applying, we'll
       // transition to MATERIALIZING once we finish.
       if (_state == _State.APPLIED) _state = _State.DECLARED;
       for (var controller in _outputControllers.values) {
         controller.setLazy(force);
       }
       _emitDeclaredOutputs();
@@ skipping 25 matching lines @@
       if (_isRemoved) return false;
 
       // 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(_wrapException(error, stackTrace));
 
       return false;
     }).then((isPrimary) {
       if (_isRemoved) return null;
       if (isPrimary) {
-        if (!deferred) primary.force();
+        if (_forced) primary.force();
         return _declareOutputs().then((_) {
           if (_isRemoved) return;
-          if (_forced) {
+          if (_forced || _canRunDeclaringEagerly) {
             _apply();
           } else {
             _state = _State.DECLARED;
             _streams.changeStatus(NodeStatus.IDLE);
           }
         });
       }
 
       _emitPassThrough();
       _state = _State.NOT_PRIMARY;
@@ skipping 21 matching lines @@
       for (var id in invalidIds) {
         _declaredOutputs.remove(id);
         // TODO(nweiz): report this as a warning rather than a failing error.
         phase.cascade.reportError(new InvalidOutputException(info, id));
       }
 
       if (!_declaredOutputs.contains(primary.id)) _emitPassThrough();
       _emitDeclaredOutputs();
     }).catchError((error, stackTrace) {
       if (_isRemoved) return;
+      if (transformer is! LazyTransformer) _forced = true;
       phase.cascade.reportError(_wrapException(error, stackTrace));
     });
   }
 
   /// Emits a dirty asset node for all outputs that were declared by the
   /// transformer.
   ///
   /// This won't emit any outputs for which there already exist output
   /// controllers. It should only be called for transforms that have declared
   /// their outputs.
@@ skipping 21 matching lines @@
     _runApply().then((hadError) {
       if (_isRemoved) return;
 
       if (_state == _State.DECLARED) return;
 
       if (_state == _State.NEEDS_APPLY) {
         _apply();
         return;
       }
 
-      if (deferred) _forced = false;
+      if (_declaring) _forced = false;
 
       assert(_state == _State.APPLYING);
       if (hadError) {
         _clearOutputs();
         // If the transformer threw an error, we don't want to emit the
         // pass-through asset in case it will be overwritten by the transformer.
         // However, if the transformer declared that it wouldn't overwrite or
         // consume the pass-through asset, we can safely emit it.
         if (_declaredOutputs != null && !_consumePrimary &&
             !_declaredOutputs.contains(primary.id)) {
@@ skipping 34 matching lines @@
   /// Returns whether or not an error occurred while running the transformer.
   Future<bool> _runApply() {
     var transformController = new TransformController(this);
     _streams.onLogPool.add(transformController.onLog);
 
     return primary.whenAvailable((_) {
       if (_isRemoved) return null;
       _state = _State.APPLYING;
       return syncFuture(() => transformer.apply(transformController.transform));
     }).then((_) {
-      if (deferred && !_forced && !primary.state.isAvailable) {
+      if (!_forced && !primary.state.isAvailable) {
         _state = _State.DECLARED;
         _streams.changeStatus(NodeStatus.IDLE);
         return false;
       }
 
       if (_isRemoved) return false;
       if (_state == _State.NEEDS_APPLY) return false;
       if (_state == _State.DECLARING) return false;
       if (transformController.loggedError) return true;
       _handleApplyResults(transformController);
@@ skipping 104 matching lines @@
     }
   }
 
   /// Emit a warning about the transformer on [id].
   void _warn(String message) {
     _streams.onLogController.add(
         new LogEntry(info, primary.id, LogLevel.WARNING, message, null));
   }
 
   String toString() =>
-    "transform node in $_location for $transformer on $primary";
+      "transform node in $_location for $transformer on $primary ($_state, "
+      "$status, ${_forced ? '' : 'un'}forced)";
 }
 
 /// The enum of states that [TransformNode] can be in.
 class _State {
   /// The transform is running [Transformer.isPrimary] followed by
   /// [DeclaringTransformer.declareOutputs] (for a [DeclaringTransformer]).
   ///
   /// This is the initial state of the transformer, and it will only occur once
   /// since [Transformer.isPrimary] and [DeclaringTransformer.declareOutputs]
   /// are independent of the contents of the primary input. Once the two methods
@@ skipping 39 matching lines @@
   ///
   /// This will never transition to another state.
   static final NOT_PRIMARY = const _State._("not primary");
 
   final String name;
 
   const _State._(this.name);
 
   String toString() => name;
 }