Roll to pickup pool changes

packages/barback/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 39 matching lines @@
   /// This will not emit programming errors from barback itself. Those will be
   /// emitted through the [results] stream's error channel.
   Stream<BarbackException> get errors => _errors;
   Stream<BarbackException> _errors;
 
   /// The stream of [LogEntry] objects used to report transformer log entries.
   Stream<LogEntry> get log => _logController.stream;
   final _logController = new StreamController<LogEntry>.broadcast(sync: true);
 
   /// How far along [this] is in processing its assets.
-  NodeStatus get _status => NodeStatus.dirtiest(
-      _cascades.values.map((cascade) => cascade.status));
+  NodeStatus get _status =>
+      NodeStatus.dirtiest(_cascades.values.map((cascade) => cascade.status));
 
   /// Whether a [BuildResult] is scheduled to be emitted on [results] (see
   /// [_tryScheduleResult]).
   bool _resultScheduled = false;
 
   /// The most recent [BuildResult] emitted on [results].
   BuildResult _lastResult;
 
   // TODO(nweiz): This can have bogus errors if an error is created and resolved
   // in the space of one build.
@@ skipping 48 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/*<Future<AssetNode>>*/(() {
+    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/*<Future<AssetSet>>*/((_) => 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) {
+    return Future
+        .wait(_cascades.values.map((cascade) => cascade.availableOutputs))
+        .then((assetSets) {
       var assets = unionAll(assetSets.map((assetSet) => assetSet.toSet()));
       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.
@@ skipping 28 matching lines @@
     // It's possible for updating transformers not to cause any processing. The
     // user still expects there to be a build, though, so we emit one
     // immediately.
     _tryScheduleResult();
   }
 
   /// A handler for a log entry from an [AssetCascade].
   void _onLog(LogEntry entry) {
     if (entry.level == LogLevel.ERROR) {
       // TODO(nweiz): keep track of stack chain.
-      _accumulatedErrors.add(
-          new TransformerException(entry.transform, entry.message, null));
+      _accumulatedErrors
+          .add(new TransformerException(entry.transform, entry.message, null));
     }
 
     if (_logController.hasListener) {
       _logController.add(entry);
     } else if (entry.level != LogLevel.FINE) {
       // No listeners, so just print entry.
       var buffer = new StringBuffer();
       buffer.write("[${entry.level} ${entry.transform}] ");
 
       if (entry.span != null) {
@@ skipping 27 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/*<T>*/ _inErrorZone/*<T>*/(/*=T*/ body()) {
-    var completer = new Completer/*<T>*/.sync();
+  Future<T> _inErrorZone<T>(T body()) {
+    var completer = new Completer<T>.sync();
     runZoned(() {
-      new Future.sync(body).then(completer.complete)
+      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;
   }
 }