Avoid barback for precompilation if possible.

Previously we were always loading an AssetEnvironment when we
precompiled any executable. Now we only load that environment if some
package dependended on by some executable actually uses a transformer.
Otherwise, we precompile from disk. The new approach is substantially
faster and produces better error messages.

Closes #1473

Author: nex3

lib/src/barback/asset_environment.dart

@@ -10,8 +10,8 @@ import 'package:path/path.dart' as path;
 import 'package:watcher/watcher.dart';
 
 import '../cached_package.dart';
+import '../dart.dart' as dart;
 import '../entrypoint.dart';
-import '../exceptions.dart';
 import '../io.dart';
 import '../log.dart' as log;
 import '../package.dart';
@@ -272,18 +272,8 @@ class AssetEnvironment {
       await waitAndPrintErrors(executableIds.map((id) async {
         var basename = path.url.basename(id.path);
         var snapshotPath = path.join(directory, "$basename.snapshot");
-        var result = await runProcess(Platform.executable, [
-          '--snapshot=$snapshotPath',
-          server.url.resolve(basename).toString()
-        ]);
-        if (result.success) {
-          log.message("Precompiled ${_formatExecutable(id)}.");
-          precompiled[path.withoutExtension(basename)] = snapshotPath;
-        } else {
-          throw new ApplicationException(
-              log.yellow("Failed to precompile ${_formatExecutable(id)}:\n") +
-              result.stderr.join('\n'));
-        }
+        await dart.snapshot(server.url.resolve(basename), snapshotPath, id: id);
+        precompiled[path.withoutExtension(basename)] = snapshotPath;
       }));
 
       return precompiled;
@@ -294,13 +284,6 @@ class AssetEnvironment {
     }
   }
 
-  /// Returns the executable name for [id].
-  ///
-  /// [id] is assumed to be an executable in a bin directory. The return value
-  /// is intended for log output and may contain formatting.
-  String _formatExecutable(AssetId id) =>
-      log.bold("${id.package}:${path.basenameWithoutExtension(id.path)}");
-
   /// Stops the server bound to [rootDirectory].
   ///
   /// Also removes any source files within that directory from barback. Returns

lib/src/dart.dart

@@ -8,12 +8,14 @@ import 'dart:io';
 import 'dart:isolate';
 
 import 'package:analyzer/analyzer.dart';
+import 'package:barback/barback.dart';
 import 'package:compiler_unsupported/compiler.dart' as compiler;
 import 'package:compiler_unsupported/src/filenames.dart'
     show appendSlash;
 import 'package:path/path.dart' as p;
 
 import 'asset/dart/serialize.dart';
+import 'exceptions.dart';
 import 'io.dart';
 import 'log.dart' as log;
 
@@ -226,3 +228,34 @@ void _isolateBuffer(message) {
     });
   });
 }
+
+/// Snapshots the Dart executable at [executableUrl] to a snapshot at
+/// [snapshotPath].
+///
+/// If [packagesFile] is passed, it's used to resolve `package:` URIs in the
+/// executable. Otherwise, a `packages/` directory or a package spec is inferred
+/// from the executable's location.
+///
+/// If [id] is passed, it's used to describe the executable in logs and error
+/// messages.
+Future snapshot(Uri executableUrl, String snapshotPath, {Uri packagesFile,
+    AssetId id}) async {
+  var name = log.bold(id == null
+      ? executableUrl.toString()
+      : "${id.package}:${p.url.basenameWithoutExtension(id.path)}");
+
+  var args = [
+    '--snapshot=$snapshotPath',
+    executableUrl.toString()
+  ];
+  if (packagesFile != null) args.insert(0, "--packages=$packagesFile");
+  var result = await runProcess(Platform.executable, args);
+
+  if (result.success) {
+    log.message("Precompiled $name.");
+  } else {
+    throw new ApplicationException(
+        log.yellow("Failed to precompile $name:\n") +
+        result.stderr.join('\n'));
+  }
+}

lib/src/entrypoint.dart

@@ -11,6 +11,7 @@ import 'package:path/path.dart' as p;
 import 'package:pub_semver/pub_semver.dart';
 
 import 'barback/asset_environment.dart';
+import 'dart.dart' as dart;
 import 'exceptions.dart';
 import 'flutter.dart' as flutter;
 import 'io.dart';
@@ -214,6 +215,8 @@ class Entrypoint {
     _packageGraph = new PackageGraph.fromSolveResult(this, result);
     packageGraph.loadTransformerCache().clearIfOutdated(result.changedPackages);
 
+    writeTextFile(packagesFile, lockFile.packagesFile(cache, root.name));
+
     try {
       if (precompile) {
         await _precompileDependencies(changed: result.changedPackages);
@@ -230,8 +233,6 @@ class Entrypoint {
       // dependencies, it shouldn't fail unless that fails.
       log.exception(error, stackTrace);
     }
-
-    writeTextFile(packagesFile, lockFile.packagesFile(cache, root.name));
   }
 
   /// Precompile any transformed dependencies of the entrypoint.
@@ -335,7 +336,8 @@ class Entrypoint {
   Future precompileExecutables({Iterable<String> changed}) async {
     _deleteExecutableSnapshots(changed: changed);
 
-    var executables = new Map.fromIterable(root.immediateDependencies,
+    var executables = new Map<String, List<AssetId>>.fromIterable(
+        root.immediateDependencies,
         key: (dep) => dep.name,
         value: (dep) => _executablesForPackage(dep.name));
 
@@ -354,25 +356,55 @@ class Entrypoint {
 
       var packagesToLoad =
           unionAll(executables.keys.map(packageGraph.transitiveDependencies))
-          .map((package) => package.name).toSet();
-      var executableIds = unionAll(
-          executables.values.map((ids) => ids.toSet()));
-      var environment = await AssetEnvironment.create(this, BarbackMode.RELEASE,
-          packages: packagesToLoad,
-          entrypoints: executableIds,
-          useDart2JS: false);
-      environment.barback.errors.listen((error) {
-        log.error(log.red("Build error:\n$error"));
-      });
+              .toSet();
 
-      await waitAndPrintErrors(executables.keys.map((package) async {
-        var dir = p.join(_snapshotPath, package);
-        cleanDir(dir);
-        await environment.precompileExecutables(package, dir,
-            executableIds: executables[package]);
+      // Try to avoid starting up an asset server to precompile packages if
+      // possible. This is faster and produces better error messages.
+      if (packagesToLoad.every(
+          (package) => package.pubspec.transformers.isEmpty)) {
+        await _precompileExecutablesWithoutBarback(executables);
+      } else {
+        await _precompileExecutablesWithBarback(executables, packagesToLoad);
+      }
+    });
+  }
+
+  Future _precompileExecutablesWithoutBarback(
+      Map<String, List<AssetId>> executables) {
+    return waitAndPrintErrors(executables.keys.map((package) {
+      var dir = p.join(_snapshotPath, package);
+      cleanDir(dir);
+      return waitAndPrintErrors(executables[package].map((id) {
+        var url = p.toUri(packageGraph.packages[id.package].dir);
+        url = url.replace(path: p.url.join(url.path, id.path));
+        return dart.snapshot(
+            url, p.join(dir, p.url.basename(id.path) + '.snapshot'),
+            packagesFile: p.toUri(packagesFile),
+            id: id);
       }));
+    }));
+  }
+
+  Future _precompileExecutablesWithBarback(
+      Map<String, List<AssetId>> executables, Set<Package> packagesToLoad) async {
+    var executableIds = unionAll(
+        executables.values.map((ids) => ids.toSet()));
+    var environment = await AssetEnvironment.create(this, BarbackMode.RELEASE,
+        packages: packagesToLoad.map((package) => package.name),
+        entrypoints: executableIds,
+        useDart2JS: false);
+    environment.barback.errors.listen((error) {
+      log.error(log.red("Build error:\n$error"));
     });
+
+    await waitAndPrintErrors(executables.keys.map((package) async {
+      var dir = p.join(_snapshotPath, package);
+      cleanDir(dir);
+      await environment.precompileExecutables(package, dir,
+          executableIds: executables[package]);
+    }));
   }
+      
 
   /// Deletes outdated cached executable snapshots.
   ///