Don't load barback for "pub run" unless necessary.

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.
 
 library pub.executable;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:barback/barback.dart';
@@ skipping 56 matching lines @@
           'dependency?');
     }
   }
 
   // Unless the user overrides the verbosity, we want to filter out the
   // normal pub output shown while loading the environment.
   if (log.verbosity == log.Verbosity.NORMAL) {
     log.verbosity = log.Verbosity.WARNING;
   }
 
-  // Ignore a trailing extension.
-  if (p.extension(executable) == ".dart") {
-    executable = p.withoutExtension(executable);
-  }
+  // Ensure that there's a trailing extension.
+  if (p.extension(executable) != ".dart") executable += ".dart";
 
   var localSnapshotPath = p.join(".pub", "bin", package,
-      "$executable.dart.snapshot");
+      "$executable.snapshot");
   if (!isGlobal && fileExists(localSnapshotPath) &&
       // Dependencies are only snapshotted in release mode, since that's the
       // default mode for them to run. We can't run them in a different mode
       // using the snapshot.
       mode == BarbackMode.RELEASE) {
     return _runCachedExecutable(entrypoint, localSnapshotPath, args);
   }
 
   // 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".
-  var rootDir = "bin";
-  var parts = p.split(executable);
-  if (parts.length > 1) {
-    assert(!isGlobal && package == entrypoint.root.name);
-    rootDir = parts.first;
-  } else {
-    executable = p.join("bin", executable);
+  if (p.split(executable).length == 1) executable = p.join("bin", executable);
+
+  var vmArgs = [];
+
+  // Run in checked mode.
+  // TODO(rnystrom): Make this configurable.
+  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 (package != entrypoint.root.name) {
+      message += " in package ${log.bold(package)}";
+    }
+    log.error("$message.");
+    return exit_codes.NO_INPUT;
   }
 
-  var assetPath = "${p.url.joinAll(p.split(executable))}.dart";
+  vmArgs.add(executableUrl.toString());
+  vmArgs.addAll(args);
+
+  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);
+  process.stdout.listen(stdout.add);
+  stdin.listen(process.stdin.add);
+
+  return process.exitCode;
+}
+
+/// Returns the URL the VM should use to load the executable at [path].
+///
+/// [path] must be relative to the root of [package]. If [path] doesn't exist,
+/// returns `null`.
+Future<Uri> _executableUrl(Entrypoint entrypoint, String package, String path,
+    {bool isGlobal: false, BarbackMode mode}) async {
+  assert(p.isRelative(path));
+
+  // If neither the executable nor any of its dependencies are transformed,
+  // there's no need to spin up a barback server. Just run the VM directly
+  // against the filesystem.
+  //
+  // TODO(nweiz): Once sdk#23369 is fixed, allow global executables to be run
+  // (and snapshotted) from the filesystem using package specs. A spec can by
+  // saved when activating the package.
+  var packageGraph = await entrypoint.loadPackageGraph();
+  if (!isGlobal && !packageGraph.isPackageTransformed(package)) {
+    var fullPath = packageGraph.packages[package].path(path);
+    if (!fileExists(fullPath)) return null;
+    return p.toUri(fullPath);
+  }
+
+  var assetPath = p.url.joinAll(p.split(path));
   var id = new AssetId(package, assetPath);
 
   // TODO(nweiz): Use [packages] to only load assets from packages that the
   // executable might load.
   var environment = await AssetEnvironment.create(entrypoint, mode,
       useDart2JS: false, entrypoints: [id]);
   environment.barback.errors.listen((error) {
     log.error(log.red("Build error:\n$error"));
   });
 
   var server;
   if (package == entrypoint.root.name) {
     // Serve the entire root-most directory containing the entrypoint. That
     // ensures that, for example, things like `import '../../utils.dart';`
     // will work from within some deeply nested script.
-    server = await environment.serveDirectory(rootDir);
+    server = await environment.serveDirectory(p.split(path).first);
   } else {
+    assert(p.split(path).first == "bin");
+
     // For other packages, always use the "bin" directory.
     server = await environment.servePackageBinDirectory(package);
   }
 
   try {
     await environment.barback.getAssetById(id);
-  } on AssetNotFoundException catch (error, stackTrace) {
-    var message = "Could not find ${log.bold(executable + ".dart")}";
-    if (package != entrypoint.root.name) {
-      message += " in package ${log.bold(server.package)}";
-    }
-
-    log.error("$message.");
-    log.fine(new Chain.forTrace(stackTrace));
-    return exit_codes.NO_INPUT;
+  } on AssetNotFoundException catch (_) {
+    return null;
   }
 
-  var vmArgs = [];
-
-  // Run in checked mode.
-  // TODO(rnystrom): Make this configurable.
-  vmArgs.add("--checked");
-
   // Get the URL of the executable, relative to the server's root directory.
   var relativePath = p.url.relative(assetPath,
       from: p.url.joinAll(p.split(server.rootDirectory)));
-  vmArgs.add(server.url.resolve(relativePath).toString());
-  vmArgs.addAll(args);
-
-  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);
-  process.stdout.listen(stdout.add);
-  stdin.listen(process.stdin.add);
-
-  return process.exitCode;
+  return server.url.resolve(relativePath);
 }
 
 /// Runs the snapshot at [path] with [args] and hooks its stdout, stderr, and
 /// sdtin to this process's.
 ///
 /// If [recompile] is passed, it's called if the snapshot is out-of-date. It's
 /// expected to regenerate a snapshot at [path], after which the snapshot will
 /// be re-run. It may return a Future.
 ///
 /// If [checked] is set, runs the snapshot in checked mode.
@@ skipping 59 matching lines @@
 }
 
 /// Runs the executable snapshot at [snapshotPath].
 Future<int> _runCachedExecutable(Entrypoint entrypoint, String snapshotPath,
     List<String> args) {
   return runSnapshot(snapshotPath, args, checked: true, recompile: () {
     log.fine("Precompiled executable is out of date.");
     return entrypoint.precompileExecutables();
   });
 }