Make pub strong-mode clean.

lib/src/io.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.
 
 /// Helper functionality to make working with IO easier.
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
 
+import 'package:async/async.dart';
 import 'package:path/path.dart' as path;
 import 'package:pool/pool.dart';
 import 'package:http/http.dart' show ByteStream;
 import 'package:http_multi_server/http_multi_server.dart';
 import 'package:stack_trace/stack_trace.dart';
 
 import 'exit_codes.dart' as exit_codes;
 import 'exceptions.dart';
 import 'error_group.dart';
 import 'log.dart' as log;
@@ skipping 166 matching lines @@
 }
 
 /// Writes [stream] to a new file at path [file].
 ///
 /// Replaces any file already at that path. Completes when the file is done
 /// being written.
 Future<String> createFileFromStream(Stream<List<int>> stream, String file) {
   // TODO(nweiz): remove extra logging when we figure out the windows bot issue.
   log.io("Creating $file from stream.");
 
-  return _descriptorPool.withResource(() {
-    return stream.pipe(new File(file).openWrite()).then((_) {
-      log.fine("Created $file from stream.");
-      return file;
-    });
+  return _descriptorPool.withResource/*<Future<String>>*/(() async {
+    await stream.pipe(new File(file).openWrite());
+    log.fine("Created $file from stream.");
+    return file;
   });
 }
 
 /// Copies all files in [files] to the directory [destination].
 ///
 /// Their locations in [destination] will be determined by their relative
 /// location to [baseDir]. Any existing files at those paths will be
 /// overwritten.
 void copyFiles(Iterable<String> files, String baseDir, String destination) {
   for (var file in files) {
@@ skipping 420 matching lines @@
 Future flushThenExit(int status) {
   return Future.wait([
     stdout.close(),
     stderr.close()
   ]).then((_) => exit(status));
 }
 
 /// Returns a [EventSink] that pipes all data to [consumer] and a [Future] that
 /// will succeed when [EventSink] is closed or fail with any errors that occur
 /// while writing.
-Pair<EventSink, Future> consumerToSink(StreamConsumer consumer) {
-  var controller = new StreamController(sync: true);
+Pair<EventSink/*<T>*/, Future> consumerToSink/*<T>*/(
+    StreamConsumer/*<T>*/ consumer) {
+  var controller = new StreamController/*<T>*/(sync: true);
   var done = controller.stream.pipe(consumer);
-  return new Pair<EventSink, Future>(controller.sink, done);
+  return new Pair(controller.sink, done);
 }
 
 // TODO(nweiz): remove this when issue 7786 is fixed.
 /// Pipes all data and errors from [stream] into [sink].
 ///
 /// When [stream] is done, the returned [Future] is completed and [sink] is
 /// closed if [closeSink] is true.
 ///
 /// When an error occurs on [stream], that error is passed to [sink]. If
 /// [cancelOnError] is true, [Future] will be completed successfully and no
@@ skipping 138 matching lines @@
 
   /// Creates a new [PubProcess] wrapping [process].
   PubProcess(Process process)
     : _process = process {
     var errorGroup = new ErrorGroup();
 
     var pair = consumerToSink(process.stdin);
     _stdin = pair.first;
     _stdinClosed = errorGroup.registerFuture(pair.last);
 
-    _stdout = new ByteStream(
-        errorGroup.registerStream(process.stdout));
-    _stderr = new ByteStream(
-        errorGroup.registerStream(process.stderr));
+    _stdout = new ByteStream(errorGroup.registerStream(process.stdout));
+    _stderr = new ByteStream(errorGroup.registerStream(process.stderr));
 
-    var exitCodeCompleter = new Completer();
+    var exitCodeCompleter = new Completer<int>();
     _exitCode = errorGroup.registerFuture(exitCodeCompleter.future);
     _process.exitCode.then((code) => exitCodeCompleter.complete(code));
   }
 
   /// Sends [signal] to the underlying process.
   bool kill([ProcessSignal signal = ProcessSignal.SIGTERM]) =>
     _process.kill(signal);
 }
 
 /// Calls [fn] with appropriately modified arguments.
 ///
 /// [fn] should have the same signature as [Process.start], except that the
 /// returned value may have any return type.
 _doProcess(Function fn, String executable, List<String> args,
     {String workingDir, Map<String, String> environment,
     bool runInShell: false}) {
   // TODO(rnystrom): Should dart:io just handle this?
   // Spawning a process on Windows will not look for the executable in the
   // system path. So, if executable looks like it needs that (i.e. it doesn't
   // have any path separators in it), then spawn it through a shell.
   if ((Platform.operatingSystem == "windows") &&
       (executable.indexOf('\\') == -1)) {
-    args = flatten(["/c", executable, args]);
+    args = ["/c", executable]..addAll(args);
     executable = "cmd";
   }
 
   log.process(executable, args, workingDir == null ? '.' : workingDir);
 
   return fn(executable, args,
       workingDirectory: workingDir,
       environment: environment,
       runInShell: runInShell);
 }
 
 /// Updates [path]'s modification time.
 void touch(String path) {
   var file = new File(path).openSync(mode: FileMode.APPEND);
   var originalLength = file.lengthSync();
   file.writeByteSync(0);
   file.truncateSync(originalLength);
   file.closeSync();
 }
 
 /// Creates a temporary directory and passes its path to [fn].
 ///
 /// Once the [Future] returned by [fn] completes, the temporary directory and
 /// all its contents are deleted. [fn] can also return `null`, in which case
 /// the temporary directory is deleted immediately afterwards.
 ///
 /// Returns a future that completes to the value that the future returned from
 /// [fn] completes to.
-Future withTempDir(Future fn(String path)) {
-  return new Future.sync(() {
-    var tempDir = createSystemTempDir();
-    return new Future.sync(() => fn(tempDir))
-        .whenComplete(() => deleteEntry(tempDir));
-  });
+Future/*<T>*/ withTempDir/*<T>*/(Future/*<T>*/ fn(String path)) async {
+  var tempDir = createSystemTempDir();
+  try {
+    return await fn(tempDir);
+  } finally {
+    deleteEntry(tempDir);
+  }
 }
 
 /// Binds an [HttpServer] to [host] and [port].
 ///
 /// If [host] is "localhost", this will automatically listen on both the IPv4
 /// and IPv6 loopback addresses.
 Future<HttpServer> bindServer(String host, int port) async {
   var server = host == 'localhost'
       ? await HttpMultiServer.loopback(port)
       : await HttpServer.bind(host, port);
@@ skipping 111 matching lines @@
   });
 }
 
 /// Create a .tar.gz archive from a list of entries.
 ///
 /// Each entry can be a [String], [Directory], or [File] object. The root of
 /// the archive is considered to be [baseDir], which defaults to the current
 /// working directory.
 ///
 /// Returns a [ByteStream] that emits the contents of the archive.
-ByteStream createTarGz(List contents, {baseDir}) {
-  return new ByteStream(futureStream(new Future.sync(() async {
+ByteStream createTarGz(List contents, {String baseDir}) {
+  return new ByteStream(StreamCompleter.fromFuture(new Future.sync(() async {
     var buffer = new StringBuffer();
     buffer.write('Creating .tag.gz stream containing:\n');
     contents.forEach((file) => buffer.write('$file\n'));
     log.fine(buffer.toString());
 
     if (baseDir == null) baseDir = path.current;
     baseDir = path.absolute(baseDir);
     contents = contents.map((entry) {
       entry = path.absolute(entry);
       if (!path.isWithin(baseDir, entry)) {
@@ skipping 66 matching lines @@
 
   // TODO(rnystrom): Remove this and change to returning one string.
   static List<String> _toLines(String output) {
     var lines = splitLines(output);
     if (!lines.isEmpty && lines.last == "") lines.removeLast();
     return lines;
   }
 
   bool get success => exitCode == exit_codes.SUCCESS;
 }