Fix all strong-mode warnings.

lib/src/graph/phase.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.phase;
 
 import 'dart:async';
 
+import 'package:collection/collection.dart';
+
 import '../asset/asset_id.dart';
 import '../asset/asset_node.dart';
 import '../asset/asset_node_set.dart';
 import '../errors.dart';
 import '../log.dart';
 import '../transformer/aggregate_transformer.dart';
 import '../transformer/transformer.dart';
 import '../transformer/transformer_group.dart';
-import '../utils.dart';
 import '../utils/multiset.dart';
 import 'asset_cascade.dart';
 import 'group_runner.dart';
 import 'node_status.dart';
 import 'node_streams.dart';
 import 'phase_forwarder.dart';
 import 'phase_output.dart';
 import 'transformer_classifier.dart';
 
 /// One phase in the ordered series of transformations in an [AssetCascade].
@@ skipping 170 matching lines @@
   // avoid this, we should have this and the methods it calls take explicit
   // callbacks, as in [AssetNode.whenAvailable].
   /// Gets the asset node for an output [id].
   ///
   /// If [id] is for a generated or transformed asset, this will wait until it
   /// has been created and return it. This means that the returned asset will
   /// always be [AssetState.AVAILABLE].
   /// 
   /// If the output cannot be found, returns null.
   Future<AssetNode> getOutput(AssetId id) {
-    return syncFuture(() {
+    return new Future.sync(() {
       if (id.package != cascade.package) return cascade.graph.getAssetNode(id);
       if (_outputs.containsKey(id)) {
         var output = _outputs[id].output;
         // If the requested output is available, we can just return it.
         if (output.state.isAvailable) return output;
 
         // If the requested output exists but isn't yet available, wait to see
         // if it becomes available. If it's removed before becoming available,
         // try again, since it could be generated again.
         output.force();
@@ skipping 32 matching lines @@
           this, transformer, "$_location.$_index");
       _classifiers[transformer] = classifier;
       classifier.onAsset.listen(_handleOutput);
       _streams.onLogPool.add(classifier.onLog);
       classifier.onStatusChange.listen((_) => _streams.changeStatus(status));
       for (var input in _inputs) {
         classifier.addInput(input);
       }
     }
 
-    var newGroups = transformers.where((op) => op is TransformerGroup)
-        .toSet();
+    var newGroups = DelegatingSet.typed/*<TransformerGroup>*/(
+        transformers.where((op) => op is TransformerGroup).toSet());
     var oldGroups = _groups.keys.toSet();
     for (var removed in oldGroups.difference(newGroups)) {
       _groups.remove(removed).remove();
     }
 
     for (var added in newGroups.difference(oldGroups)) {
       var runner = new GroupRunner(previous, added, "$_location.$_index");
       _groups[added] = runner;
       runner.onAsset.listen(_handleOutput);
       _streams.onLogPool.add(runner.onLog);
@@ skipping 109 matching lines @@
       return;
     }
 
     // A lazy asset may be emitted while still dirty. If so, we wait until it's
     // either available or removed before trying again to access it.
     assert(asset.state.isDirty);
     asset.force();
     asset.whenStateChanges().then((state) {
       if (state.isRemoved) return getOutput(asset.id);
       return asset;
-    }).then(request.complete).catchError(request.completeError);
+    })
+       .then((asset) => request.complete(asset))
+       .catchError(request.completeError);
   }
 
   String toString() => "phase $_location.$_index";
 }