Make pub strong-mode clean.

lib/src/utils.dart

 // Copyright (c) 2012, 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.
 
 /// Generic utility functions. Stuff that should possibly be in core.
 import 'dart:async';
 import "dart:convert";
 import 'dart:io';
 import 'dart:math' as math;
 
@@ skipping 37 matching lines @@
   String toString() => '($first, $last)';
 
   bool operator==(other) {
     if (other is! Pair) return false;
     return other.first == first && other.last == last;
   }
 
   int get hashCode => first.hashCode ^ last.hashCode;
 }
 
-/// A completer that waits until all added [Future]s complete.
-// TODO(rnystrom): Copied from web_components. Remove from here when it gets
-// added to dart:core. (See #6626.)
-class FutureGroup<T> {
-  int _pending = 0;
-  Completer<List<T>> _completer = new Completer<List<T>>();
-  final List<Future<T>> futures = <Future<T>>[];
-  bool completed = false;
-
-  final List<T> _values = <T>[];
-
-  /// Wait for [task] to complete.
-  Future<T> add(Future<T> task) {
-    if (completed) {
-      throw new StateError("The FutureGroup has already completed.");
-    }
-
-    _pending++;
-    futures.add(task.then((value) {
-      if (completed) return;
-
-      _pending--;
-      _values.add(value);
-
-      if (_pending <= 0) {
-        completed = true;
-        _completer.complete(_values);
-      }
-    }).catchError((e, stackTrace) {
-      if (completed) return;
-
-      completed = true;
-      _completer.completeError(e, stackTrace);
-    }));
-
-    return task;
-  }
-
-  Future<List> get future => _completer.future;
-}
-
 /// Like [new Future], but avoids around issue 11911 by using [new Future.value]
 /// under the covers.
 Future newFuture(callback()) => new Future.value().then((_) => callback());
 
 /// Runs [callback] in an error zone and pipes any unhandled error to the
 /// returned [Future].
 ///
 /// If the returned [Future] produces an error, its stack trace will always be a
 /// [Chain]. By default, this chain will contain only the local stack trace, but
 /// if [captureStackChains] is passed, it will contain the full stack chain for
@@ skipping 29 matching lines @@
     });
   }
 
   return completer.future;
 }
 
 /// Like [Future.wait], but prints all errors from the futures as they occur and
 /// only returns once all Futures have completed, successfully or not.
 ///
 /// This will wrap the first error thrown in a [SilentException] and rethrow it.
-Future waitAndPrintErrors(Iterable<Future> futures) {
+Future<List/*<T>*/> waitAndPrintErrors/*<T>*/(Iterable<Future/*<T>*/> futures) {
   return Future.wait(futures.map((future) {
     return future.catchError((error, stackTrace) {
       log.exception(error, stackTrace);
       throw error;
     });
   })).catchError((error, stackTrace) {
     throw new SilentException(error, stackTrace);
   });
 }
 
 /// Returns a [StreamTransformer] that will call [onDone] when the stream
 /// completes.
 ///
 /// The stream will be passed through unchanged.
-StreamTransformer onDoneTransformer(void onDone()) {
-  return new StreamTransformer.fromHandlers(handleDone: (sink) {
+StreamTransformer/*<T, T>*/ onDoneTransformer/*<T>*/(void onDone()) {
+  return new StreamTransformer/*<T, T>*/.fromHandlers(handleDone: (sink) {
     onDone();
     sink.close();
   });
 }
 
 // TODO(rnystrom): Move into String?
 /// Pads [source] to [length] by adding spaces at the end.
 String padRight(String source, int length) {
   final result = new StringBuffer();
   result.write(source);
@@ skipping 92 matching lines @@
 
   try {
     return new InternetAddress(host).isLoopback;
   } on ArgumentError catch (_) {
     // The host isn't an IP address and isn't "localhost', so it's almost
     // certainly not a loopback host.
     return false;
   }
 }
 
-/// Flattens nested lists inside an iterable into a single list containing only
-/// non-list elements.
-List flatten(Iterable nested) {
-  var result = [];
-  helper(list) {
-    for (var element in list) {
-      if (element is List) {
-        helper(element);
-      } else {
-        result.add(element);
-      }
-    }
-  }
-  helper(nested);
-  return result;
-}
-
 /// Randomly chooses a single element in [elements].
 /*=T*/ choose/*<T>*/(List/*<T>*/ elements) =>
     elements[random.nextInt(elements.length)];
 
 /// Returns a set containing all elements in [minuend] that are not in
 /// [subtrahend].
 Set setMinus(Iterable minuend, Iterable subtrahend) {
   var minuendSet = new Set.from(minuend);
   minuendSet.removeAll(subtrahend);
   return minuendSet;
 }
 
 /// Returns whether there's any overlap between [set1] and [set2].
 bool overlaps(Set set1, Set set2) {
   // Iterate through the smaller set.
   var smaller = set1.length > set2.length ? set1 : set2;
   var larger = smaller == set1 ? set2 : set1;
   return smaller.any(larger.contains);
 }
 
 /// Returns a list containing the sorted elements of [iter].
-List ordered(Iterable<Comparable> iter) {
+List/*<T>*/ ordered/*<T extends Comparable<T>>*/(Iterable/*<T>*/ iter) {
   var list = iter.toList();
   list.sort();
   return list;
 }
 
 /// Returns the element of [iter] for which [f] returns the minimum value.
 minBy(Iterable iter, Comparable f(element)) {
   var min = null;
   var minComparable = null;
   for (var element in iter) {
@@ skipping 13 matching lines @@
 /// (3, 4)]`.
 Iterable<Pair> pairs(Iterable iter) {
   var previous = iter.first;
   return iter.skip(1).map((element) {
     var oldPrevious = previous;
     previous = element;
     return new Pair(oldPrevious, element);
   });
 }
 
-/// Creates a new map from [map] with new keys and values.
-///
-/// The return values of [key] are used as the keys and the return values of
-/// [value] are used as the values for the new map.
-///
-/// [key] defaults to returning the original key and [value] defaults to
-/// returning the original value.
-Map mapMap(Map map, {key(key, value), value(key, value)}) {
-  if (key == null) key = (key, _) => key;
-  if (value == null) value = (_, value) => value;
-
-  var result = {};
-  map.forEach((mapKey, mapValue) {
-    result[key(mapKey, mapValue)] = value(mapKey, mapValue);
-  });
-  return result;
-}
-
-/// Like [Map.fromIterable], but [key] and [value] may return [Future]s.
-Future<Map> mapFromIterableAsync(Iterable iter, {key(element),
-    value(element)}) {
-  if (key == null) key = (element) => element;
-  if (value == null) value = (element) => element;
-
-  var map = new Map();
-  return Future.wait(iter.map((element) {
-    return Future.wait([
-      new Future.sync(() => key(element)),
-      new Future.sync(() => value(element))
-    ]).then((results) {
-      map[results[0]] = results[1];
-    });
-  })).then((_) => map);
-}
-
-/// Returns a new map with all entries in both [map1] and [map2].
-///
-/// If there are overlapping keys, [map2]'s value wins.
-Map mergeMaps(Map map1, Map map2) {
-  var result = {};
-  result.addAll(map1);
-  result.addAll(map2);
-  return result;
-}
-
-/// Returns the transitive closure of [graph].
-///
-/// This assumes [graph] represents a graph with a vertex for each key and an
-/// edge betweek each key and the values for that key.
-Map<dynamic, Set> transitiveClosure(Map<dynamic, Iterable> graph) {
-  // This uses the Floyd-Warshall algorithm
-  // (https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm).
-  var result = {};
-  graph.forEach((vertex, edges) {
-    result[vertex] = new Set.from(edges)..add(vertex);
-  });
-
-  for (var vertex1 in graph.keys) {
-    for (var vertex2 in graph.keys) {
-      for (var vertex3 in graph.keys) {
-        if (result[vertex2].contains(vertex1) &&
-            result[vertex1].contains(vertex3)) {
-          result[vertex2].add(vertex3);
-        }
-      }
-    }
-  }
-
-  return result;
-}
-
 /// Given a list of filenames, returns a set of patterns that can be used to
 /// filter for those filenames.
 ///
 /// For a given path, that path ends with some string in the returned set if
 /// and only if that path's basename is in [files].
 Set<String> createFileFilter(Iterable<String> files) {
-  return files.expand((file) {
+  return files.expand/*<String>*/((file) {
     var result = ["/$file"];
     if (Platform.operatingSystem == 'windows') result.add("\\$file");
     return result;
   }).toSet();
 }
 
 /// Given a blacklist of directory names, returns a set of patterns that can
 /// be used to filter for those directory names.
 ///
 /// For a given path, that path contains some string in the returned set if
 /// and only if one of that path's components is in [dirs].
 Set<String> createDirectoryFilter(Iterable<String> dirs) {
-  return dirs.expand((dir) {
+  return dirs.expand/*<String>*/((dir) {
     var result = ["/$dir/"];
     if (Platform.operatingSystem == 'windows') {
       result..add("/$dir\\")..add("\\$dir/")..add("\\$dir\\");
     }
     return result;
   }).toSet();
 }
 
 /// Returns the maximum value in [iter] by [compare].
 ///
@@ skipping 76 matching lines @@
 ///
 /// For example, reading asynchronously from a non-existent file will return a
 /// stream that fails on the first chunk. In order to handle that more
 /// gracefully, you may want to check that the stream looks like it's working
 /// before you pipe the stream to something else.
 ///
 /// This lets you do that. It returns a [Future] that completes to a [Stream]
 /// emitting the same values and errors as [stream], but only if at least one
 /// value can be read successfully. If an error occurs before any values are
 /// emitted, the returned Future completes to that error.
-Future<Stream> validateStream(Stream stream) {
+Future<Stream/*<T>*/> validateStream/*<T>*/(Stream/*<T>*/ stream) {
   var completer = new Completer<Stream>();
   var controller = new StreamController(sync: true);
 
   StreamSubscription subscription;
   subscription = stream.listen((value) {
     // We got a value, so the stream is valid.
     if (!completer.isCompleted) completer.complete(controller.stream);
     controller.add(value);
   }, onError: (error, [stackTrace]) {
     // If the error came after values, it's OK.
@@ skipping 40 matching lines @@
 Pair<Stream, StreamSubscription> streamWithSubscription(Stream stream) {
   var controller =
       stream.isBroadcast ? new StreamController.broadcast(sync: true)
                          : new StreamController(sync: true);
   var subscription = stream.listen(controller.add,
       onError: controller.addError,
       onDone: controller.close);
   return new Pair<Stream, StreamSubscription>(controller.stream, subscription);
 }
 
-// TODO(nweiz): remove this when issue 7787 is fixed.
-/// Creates two single-subscription [Stream]s that each emit all values and
-/// errors from [stream].
-///
-/// This is useful if [stream] is single-subscription but multiple subscribers
-/// are necessary.
-Pair<Stream, Stream> tee(Stream stream) {
-  var controller1 = new StreamController(sync: true);
-  var controller2 = new StreamController(sync: true);
-  stream.listen((value) {
-    controller1.add(value);
-    controller2.add(value);
-  }, onError: (error, [stackTrace]) {
-    controller1.addError(error, stackTrace);
-    controller2.addError(error, stackTrace);
-  }, onDone: () {
-    controller1.close();
-    controller2.close();
-  });
-  return new Pair<Stream, Stream>(controller1.stream, controller2.stream);
-}
-
-/// Merges [stream1] and [stream2] into a single stream that emits events from
-/// both sources.
-Stream mergeStreams(Stream stream1, Stream stream2) {
-  var doneCount = 0;
-  var controller = new StreamController(sync: true);
-
-  for (var stream in [stream1, stream2]) {
-    stream.listen(
-        controller.add,
-        onError: controller.addError,
-        onDone: () {
-      doneCount++;
-      if (doneCount == 2) controller.close();
-    });
-  }
-
-  return controller.stream;
-}
-
-/// Returns a [Stream] that will emit the same values as the stream returned by
-/// [callback].
-///
-/// [callback] will only be called when the returned [Stream] gets a subscriber.
-Stream callbackStream(Stream callback()) {
-  var subscription;
-  var controller;
-  controller = new StreamController(onListen: () {
-    subscription = callback().listen(controller.add,
-        onError: controller.addError,
-        onDone: controller.close);
-  },
-      onCancel: () => subscription.cancel(),
-      onPause: () => subscription.pause(),
-      onResume: () => subscription.resume(),
-      sync: true);
-  return controller.stream;
-}
-
 /// A regular expression matching a trailing CR character.
 final _trailingCR = new RegExp(r"\r$");
 
 // TODO(nweiz): Use `text.split(new RegExp("\r\n?|\n\r?"))` when issue 9360 is
 // fixed.
 /// Splits [text] on its line breaks in a Windows-line-break-friendly way.
 List<String> splitLines(String text) =>
   text.split("\n").map((line) => line.replaceFirst(_trailingCR, "")).toList();
 
 /// Converts a stream of arbitrarily chunked strings into a line-by-line stream.
@@ skipping 54 matching lines @@
 /// parameters if a name conflict occurs.
 Uri addQueryParameters(Uri url, Map<String, String> parameters) {
   var queryMap = queryToMap(url.query);
   queryMap.addAll(parameters);
   return url.resolve("?${mapToQuery(queryMap)}");
 }
 
 /// Convert a URL query string (or `application/x-www-form-urlencoded` body)
 /// into a [Map] from parameter names to values.
 Map<String, String> queryToMap(String queryList) {
-  var map = {};
+  var map = <String, String>{};
   for (var pair in queryList.split("&")) {
     var split = split1(pair, "=");
     if (split.isEmpty) continue;
     var key = urlDecode(split[0]);
     var value = split.length > 1 ? urlDecode(split[1]) : "";
     map[key] = value;
   }
   return map;
 }
 
 /// Convert a [Map] from parameter names to values to a URL query string.
 String mapToQuery(Map<String, String> map) {
   var pairs = <List<String>>[];
   map.forEach((key, value) {
     key = Uri.encodeQueryComponent(key);
     value = (value == null || value.isEmpty)
        ? null : Uri.encodeQueryComponent(value);
     pairs.add([key, value]);
   });
   return pairs.map((pair) {
     if (pair[1] == null) return pair[0];
     return "${pair[0]}=${pair[1]}";
   }).join("&");
 }
 
 /// Returns the union of all elements in each set in [sets].
-Set unionAll(Iterable<Set> sets) =>
+Set/*<T>*/ unionAll/*<T>*/(Iterable<Set/*<T>*/> sets) =>
   sets.fold(new Set(), (union, set) => union.union(set));
 
 // TODO(nweiz): remove this when issue 9068 has been fixed.
 /// Whether [uri1] and [uri2] are equal.
 ///
 /// This consider HTTP URIs to default to port 80, and HTTPs URIs to default to
 /// port 443.
 bool urisEqual(Uri uri1, Uri uri2) =>
   canonicalizeUri(uri1) == canonicalizeUri(uri2);
 
@@ skipping 19 matching lines @@
 /// Returns a human-friendly representation of [duration].
 String niceDuration(Duration duration) {
   var hasMinutes = duration.inMinutes > 0;
   var result = hasMinutes ? "${duration.inMinutes}:" : "";
 
   var s = duration.inSeconds % 60;
   var ms = duration.inMilliseconds % 1000;
 
   // If we're using verbose logging, be more verbose but more accurate when
   // reporting timing information.
-  if (log.verbosity.isLevelVisible(log.Level.FINE)) {
-    ms = padLeft(ms.toString(), 3, '0');
-  } else {
-    ms ~/= 100;
-  }
+  var msString = log.verbosity.isLevelVisible(log.Level.FINE)
+      ? padLeft(ms.toString(), 3, '0')
+      : (ms ~/ 100).toString();
 
-  return "$result${hasMinutes ? padLeft(s.toString(), 2, '0') : s}.${ms}s";
+  return "$result${hasMinutes ? padLeft(s.toString(), 2, '0') : s}"
+      ".${msString}s";
 }
 
 /// Decodes a URL-encoded string.
 ///
 /// Unlike [Uri.decodeComponent], this includes replacing `+` with ` `.
 String urlDecode(String encoded) =>
   Uri.decodeComponent(encoded.replaceAll("+", " "));
 
 /// Takes a simple data structure (composed of [Map]s, [Iterable]s, scalar
 /// objects, and [Future]s) and recursively resolves all the [Future]s contained
 /// within.
 ///
 /// Completes with the fully resolved structure.
-Future awaitObject(object) {
+Future/*<T>*/ awaitObject/*<T>*/(/*=T*/ object) async {
   // Unroll nested futures.
-  if (object is Future) return object.then(awaitObject);
+  if (object is Future) return await awaitObject(await object);
+
   if (object is Iterable) {
-    return Future.wait(object.map(awaitObject).toList());
+    // TODO(nweiz): Remove the unnecessary as check when sdk#26965 is fixed.
+    return await Future.wait((object as Iterable).map(awaitObject))
+        as List/*=T*/;
   }
-  if (object is! Map) return new Future.value(object);
 
-  var pairs = <Future<Pair>>[];
-  object.forEach((key, value) {
-    pairs.add(awaitObject(value)
-        .then((resolved) => new Pair(key, resolved)));
-  });
-  return Future.wait(pairs).then((resolvedPairs) {
-    var map = {};
-    for (var pair in resolvedPairs) {
-      map[pair.first] = pair.last;
-    }
-    return map;
-  });
+  if (object is Map) {
+    // TODO(nweiz): Remove the unnecessary as check when sdk#26965 is fixed.
+    var oldMap = object as Map;
+    var newMap = {};
+    await Future.wait(oldMap.keys.map((key) async {
+      newMap[key] = await awaitObject(await oldMap[key]);
+    }));
+    return newMap as Map/*=T*/;
+  }
+
+  return object;
 }
 
 /// Whether "special" strings such as Unicode characters or color escapes are
 /// safe to use.
 ///
 /// On Windows or when not printing to a terminal, only printable ASCII
 /// characters should be used.
 bool get canUseSpecialChars => !runningFromTest && !runningAsTest &&
     Platform.operatingSystem != 'windows' &&
     stdioType(stdout) == StdioType.TERMINAL;
@@ skipping 124 matching lines @@
   } else {
     throw new ApplicationException(message);
   }
 }
 
 /// Throw a [DataException] with [message] to indicate that the command has
 /// failed because of invalid input data.
 ///
 /// This will report the error and cause pub to exit with [exit_codes.DATA].
 void dataError(String message) => throw new DataException(message);