Fix all strong-mode warnings.

lib/src/graph/package_graph.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.package_graph;
 
 import 'dart:async';
 import 'dart:collection';
 
 import '../asset/asset_id.dart';
@@ skipping 109 matching lines @@
   }
 
   /// Gets the asset node identified by [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 asset cannot be found, returns null.
   Future<AssetNode> getAssetNode(AssetId id) {
-    return _inErrorZone(() {
+    return _inErrorZone/*<Future<AssetNode>>*/(() {
       var cascade = _cascades[id.package];
       if (cascade != null) return cascade.getAssetNode(id);
       return new Future.value(null);
     });
   }
 
   /// Returns the stream of newly-emitted assets for the given package's
   /// cascade.
   ///
   /// If there's no cascade for [package], returns `null`.
@@ skipping 10 matching lines @@
   ///
   /// Any transforms using [LazyTransformer]s will be forced to generate
   /// concrete outputs, and those outputs will be returned.
   Future<AssetSet> getAllAssets() {
     for (var cascade in _cascades.values) {
       _inErrorZone(() => cascade.forceAllTransforms());
     }
 
     if (_status != NodeStatus.IDLE) {
       // A build is still ongoing, so wait for it to complete and try again.
-      return results.first.then((_) => getAllAssets());
+      return results.first.then/*<Future<AssetSet>>*/((_) => getAllAssets());
     }
 
     // If an unexpected error occurred, complete with that.
     if (_lastUnexpectedError != null) {
       var error = _lastUnexpectedError;
       _lastUnexpectedError = null;
       return new Future.error(error, _lastUnexpectedErrorTrace);
     }
 
     // If the last build completed with an error, complete the future with it.
     if (!_lastResult.succeeded) {
       return new Future.error(BarbackException.aggregate(_lastResult.errors));
     }
 
     // Otherwise, return all of the final output assets.
     return Future.wait(_cascades.values.map(
             (cascade) => cascade.availableOutputs))
           .then((assetSets) {
       var assets = unionAll(assetSets.map((assetSet) => assetSet.toSet()));
-      return new Future.value(new AssetSet.from(assets));
+      return new AssetSet.from(assets);
     });
   }
 
   /// 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) {
     groupBy(sources, (id) => id.package).forEach((package, ids) {
@@ skipping 75 matching lines @@
     });
   }
 
   /// Run [body] in an error-handling [Zone] and pipe any unexpected errors to
   /// the error channel of [results].
   ///
   /// [body] can return a value or a [Future] that will be piped to the returned
   /// [Future]. If it throws a [BarbackException], that exception will be piped
   /// to the returned [Future] as well. Any other exceptions will be piped to
   /// [results].
-  Future _inErrorZone(body()) {
-    var completer = new Completer.sync();
+  Future/*<T>*/ _inErrorZone/*<T>*/(/*=T*/ body()) {
+    var completer = new Completer/*<T>*/.sync();
     runZoned(() {
-      syncFuture(body).then(completer.complete).catchError((error, stackTrace) {
+      new Future.sync(body).then(completer.complete)
+          .catchError((error, stackTrace) {
         if (error is! BarbackException) throw error;
         completer.completeError(error, stackTrace);
       });
     }, onError: (error, stackTrace) {
       _lastUnexpectedError = error;
       _lastUnexpectedErrorTrace = stackTrace;
       _resultsController.addError(error, stackTrace);
     });
     return completer.future;
   }
 }