Use the command builtin rather than which.

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';
 
@@ skipping 663 matching lines @@
 
 /// Spawns and runs the process located at [executable], passing in [args].
 ///
 /// Returns a [Future] that will complete with the results of the process after
 /// it has ended.
 ///
 /// The spawned process will inherit its parent's environment variables. If
 /// [environment] is provided, that will be used to augment (not replace) the
 /// the inherited variables.
 Future<PubProcessResult> runProcess(String executable, List<String> args,
-    {workingDir, Map<String, String> environment}) {
-  return _descriptorPool.withResource(() {
-    return _doProcess(Process.run, executable, args, workingDir, environment)
-        .then((result) {
-      var pubResult = new PubProcessResult(
-          result.stdout, result.stderr, result.exitCode);
-      log.processResult(executable, pubResult);
-      return pubResult;
-    });
+    {workingDir, Map<String, String> environment, bool runInShell: false}) {
+  return _descriptorPool.withResource(() async {
+    var result = await _doProcess(Process.run, executable, args,
+        workingDir: workingDir,
+        environment: environment,
+        runInShell: runInShell);
+
+    var pubResult = new PubProcessResult(
+        result.stdout, result.stderr, result.exitCode);
+    log.processResult(executable, pubResult);
+    return pubResult;
   });
 }
 
 /// Spawns the process located at [executable], passing in [args].
 ///
 /// Returns a [Future] that will complete with the [Process] once it's been
 /// started.
 ///
 /// The spawned process will inherit its parent's environment variables. If
 /// [environment] is provided, that will be used to augment (not replace) the
 /// the inherited variables.
 Future<PubProcess> startProcess(String executable, List<String> args,
-    {workingDir, Map<String, String> environment}) {
-  return _descriptorPool.request().then((resource) {
-    return _doProcess(Process.start, executable, args, workingDir, environment)
-        .then((ioProcess) {
-      var process = new PubProcess(ioProcess);
-      process.exitCode.whenComplete(resource.release);
-      return process;
-    });
+    {workingDir, Map<String, String> environment, bool runInShell: false}) {
+  return _descriptorPool.request().then((resource) async {
+    var ioProcess = await _doProcess(Process.start, executable, args,
+        workingDir: workingDir,
+        environment: environment,
+        runInShell: runInShell);
+
+    var process = new PubProcess(ioProcess);
+    process.exitCode.whenComplete(resource.release);
+    return process;
   });
 }
 
 /// Like [runProcess], but synchronous.
 PubProcessResult runProcessSync(String executable, List<String> args,
-        {String workingDir, Map<String, String> environment}) {
+    {String workingDir, Map<String, String> environment,
+    bool runInShell: false}) {
   var result = _doProcess(
-      Process.runSync, executable, args, workingDir, environment);
+      Process.runSync, executable, args,
+      workingDir: workingDir,
+      environment: environment,
+      runInShell: runInShell);
   var pubResult = new PubProcessResult(
       result.stdout, result.stderr, result.exitCode);
   log.processResult(executable, pubResult);
   return pubResult;
 }
 
 /// A wrapper around [Process] that exposes `dart:async`-style APIs.
 class PubProcess {
   /// The underlying `dart:io` [Process].
   final Process _process;
@@ skipping 75 matching lines @@
   /// 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) {
+    {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]);
     executable = "cmd";
   }
 
   log.process(executable, args, workingDir == null ? '.' : workingDir);
 
   return fn(executable, args,
       workingDirectory: workingDir,
-      environment: environment);
+      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();
 }
@@ skipping 224 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;
 }