Fix all strong-mode warnings.

lib/src/graph/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.graph.asset_cascade;
 
 import 'dart:async';
 
+import 'package:async/async.dart';
+
 import '../asset/asset.dart';
 import '../asset/asset_id.dart';
 import '../asset/asset_node.dart';
 import '../asset/asset_set.dart';
 import '../errors.dart';
 import '../log.dart';
 import '../transformer/transformer.dart';
-import '../utils.dart';
 import '../utils/cancelable_future.dart';
 import 'node_status.dart';
 import 'node_streams.dart';
 import 'package_graph.dart';
 import 'phase.dart';
 
 /// The asset cascade for an individual package.
 ///
 /// This keeps track of which [Transformer]s are applied to which assets, and
 /// re-runs those transformers when their dependencies change. The transformed
@@ skipping 79 matching lines @@
 
     var oldLastPhase = _phases.last;
     // 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 oldLastPhase.getOutput(id).then((node) {
+    return DelegatingFuture.typed(oldLastPhase.getOutput(id).then((node) {
       // The last phase may have changed if [updateSources] was called after
       // requesting the output. In that case, we want the output from the new
       // last phase.
       if (_phases.last == oldLastPhase) return node;
       return getAssetNode(id);
-    });
+    }));
   }
 
   /// Adds [sources] to the graph's known set of source assets.
   ///
   /// Begins applying any transforms that can consume any of the sources. If a
   /// given source is already known, it is considered modified and all
   /// transforms that use it will be re-applied.
   void updateSources(Iterable<AssetId> sources) {
     for (var id in sources) {
       var controller = _sourceControllerMap[id];
       if (controller != null) {
         controller.setDirty();
       } else {
         _sourceControllerMap[id] = new AssetNodeController(id);
         _phases.first.addInput(_sourceControllerMap[id].node);
       }
 
       // If this source was already loading, cancel the old load, since it may
       // return out-of-date contents for the asset.
       if (_loadingSources.containsKey(id)) _loadingSources[id].cancel();
 
       _loadingSources[id] = new CancelableFuture<Asset>(
-          syncFuture(() => graph.provider.getAsset(id)));
+          new Future.sync(() => graph.provider.getAsset(id)));
       _loadingSources[id].whenComplete(() {
         _loadingSources.remove(id);
       }).then((asset) {
-        var controller = _sourceControllerMap[id].setAvailable(asset);
+        _sourceControllerMap[id].setAvailable(asset);
       }).catchError((error, stack) {
         reportError(new AssetLoadException(id, error, stack));
 
         // TODO(nweiz): propagate error information through asset nodes.
         _sourceControllerMap.remove(id).setRemoved();
       });
     }
   }
 
   /// Removes [removed] from the graph's known set of source assets.
@@ skipping 59 matching lines @@
     _streams.onLogPool.add(phase.onLog);
     if (_phaseStatusSubscription != null) _phaseStatusSubscription.cancel();
     _phaseStatusSubscription =
         phase.onStatusChange.listen(_streams.changeStatus);
 
     _phases.add(phase);
   }
 
   String toString() => "cascade for $package";
 }