Preserve laziness in declaring transformers.

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 29 matching lines @@
 
   /// The subscription to [primary]'s [AssetNode.onStateChange] stream.
   StreamSubscription _primarySubscription;
 
   /// The subscription to [phase]'s [Phase.onAsset] stream.
   StreamSubscription<AssetNode> _phaseSubscription;
 
   /// Whether [this] is dirty and still has more processing to do.
   bool get isDirty => _state != _State.NOT_PRIMARY && _state != _State.APPLIED;
 
-  /// Whether [transformer] is lazy and this transform has yet to be forced.
+  /// Whether this transform is lazy and this transform has yet to be forced.
+  ///
+  /// A transform being lazy is distinct from a transformer being lazy. A
+  /// transformer that's declaring but not lazy will have lazy transforms for
+  /// primary inputs that are themselves lazy.
   bool _isLazy;
 
   /// 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
   /// ran.
@@ skipping 46 matching lines @@
   /// Defaults to `false`. This is not meaningful unless [_state] is
   /// [_State.APPLIED].
   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, this.primary,
+  TransformNode(this.phase, Transformer transformer, AssetNode primary,
       this._location)
       : transformer = transformer,
-        _isLazy = transformer is LazyTransformer {
+        primary = primary,
+        _isLazy = transformer is LazyTransformer ||
+            (transformer is DeclaringTransformer && primary.isLazy) {
     _onLogPool.add(_onLogController.stream);
 
+    if (!_isLazy) primary.force();
+
     _primarySubscription = primary.onStateChange.listen((state) {
       if (state.isRemoved) {
         remove();
       } else {
         _dirty();
       }
     });
 
     _phaseSubscription = phase.previous.onAsset.listen((node) {
       if (_missingInputs.contains(node.id)) _dirty();
@@ skipping 27 matching lines @@
       _passThroughController = null;
     }
   }
 
   /// If [transformer] is lazy, ensures that its concrete outputs will be
   /// generated.
   void force() {
     // TODO(nweiz): we might want to have a timeout after which, if the
     // transform's outputs have gone unused, we switch it back to lazy mode.
     if (!_isLazy) return;
+    primary.force();
     _isLazy = false;
     _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();
@@ skipping 66 matching lines @@
           .where((id) => id.package != phase.cascade.package).toSet();
       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();
 
       for (var id in _declaredOutputs) {
-        var controller = transformer is LazyTransformer
+        var controller = _isLazy
             ? new AssetNodeController.lazy(id, force, this)
             : new AssetNodeController(id, this);
         _outputControllers[id] = controller;
         _onAssetController.add(controller.node);
       }
     }).catchError((error, stackTrace) {
       if (_isRemoved) return;
       phase.cascade.reportError(_wrapException(error, stackTrace));
     });
   }
@@ skipping 235 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;
 }