Make pub strong-mode clean.

lib/src/executable.dart

 // Copyright (c) 2014, 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.
 
 import 'dart:async';
 import 'dart:io';
 
+import 'package:async/async.dart';
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as p;
 
 import 'barback/asset_environment.dart';
 import 'entrypoint.dart';
 import 'exit_codes.dart' as exit_codes;
 import 'io.dart';
 import 'log.dart' as log;
 import 'utils.dart';
 
@@ skipping 68 matching lines @@
 
     return _runCachedExecutable(entrypoint, localSnapshotPath, args,
         checked: checked);
   }
 
   // If the command has a path separator, then it's a path relative to the
   // root of the package. Otherwise, it's implicitly understood to be in
   // "bin".
   if (p.split(executable).length == 1) executable = p.join("bin", executable);
 
-  var vmArgs = [];
+  var vmArgs = <String>[];
 
   // Run in checked mode.
   if (checked) vmArgs.add("--checked");
 
   var executableUrl = await _executableUrl(
       entrypoint, package, executable, isGlobal: isGlobal, mode: mode);
 
   if (executableUrl == null) {
     var message = "Could not find ${log.bold(executable)}";
     if (isGlobal || package != entrypoint.root.name) {
@@ skipping 104 matching lines @@
 ///
 /// If [checked] is set, runs the snapshot in checked mode.
 ///
 /// Returns the snapshot's exit code.
 ///
 /// This doesn't do any validation of the snapshot's SDK version.
 Future<int> runSnapshot(String path, Iterable<String> args, {recompile(),
     String packagesFile, bool checked: false}) async {
   // TODO(nweiz): pass a flag to silence the "Wrong full snapshot version"
   // message when issue 20784 is fixed.
-  var vmArgs = [];
+  var vmArgs = <String>[];
   if (checked) vmArgs.add("--checked");
 
   if (packagesFile != null) {
     // We use an absolute path here not because the VM insists but because it's
     // helpful for the subprocess to be able to spawn Dart with
     // Platform.executableArguments and have that work regardless of the working
     // directory.
     vmArgs.add("--packages=${p.toUri(p.absolute(packagesFile))}");
   }
 
   vmArgs.add(path);
   vmArgs.addAll(args);
 
   // We need to split stdin so that we can send the same input both to the
   // first and second process, if we start more than one.
   var stdin1;
   var stdin2;
   if (recompile == null) {
     stdin1 = stdin;
   } else {
-    var pair = tee(stdin);
-    stdin1 = pair.first;
-    stdin2 = pair.last;
+    var stdins = StreamSplitter.splitFrom(stdin);
+    stdin1 = stdins.first;
+    stdin2 = stdins.last;
   }
 
   runProcess(input) async {
     var process = await Process.start(Platform.executable, vmArgs);
 
     _forwardSignals(process);
 
     // Note: we're not using process.std___.pipe(std___) here because
     // that prevents pub from also writing to the output streams.
     process.stderr.listen(stderr.add);
@@ skipping 30 matching lines @@
 Future<int> _runCachedExecutable(Entrypoint entrypoint, String snapshotPath,
     List<String> args, {bool checked: false}) {
   return runSnapshot(snapshotPath, args,
       packagesFile: entrypoint.packagesFile,
       checked: checked,
       recompile: () {
     log.fine("Precompiled executable is out of date.");
     return entrypoint.precompileExecutables();
   });
 }