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

lib/src/package_graph.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.
 
 library pub.package_graph;
 
 import 'barback/transformer_cache.dart';
 import 'entrypoint.dart';
 import 'lock_file.dart';
 import 'package.dart';
@@ skipping 54 matching lines @@
     if (_transitiveDependencies == null) {
       var closure = transitiveClosure(mapMap(packages,
           value: (_, package) => package.dependencies.map((dep) => dep.name)));
       _transitiveDependencies = mapMap(closure,
           value: (_, names) => names.map((name) => packages[name]).toSet());
     }
 
     return _transitiveDependencies[package];
   }
 
+  /// Returns whether [package], or any of its transitive dependencies, have
+  /// transformers that run on any of their public assets.
+  ///
+  /// This is pessimistic; if any package can't be determined to be transformed,
+  /// this returns `true`.
+  bool isPackageTransformed(String packageName) {
+    if (_isIndividualPackageTransformed(packages[packageName])) return true;
+
+    return transitiveDependencies(packageName)
+        .any(_isIndividualPackageTransformed);
+  }
+
+  /// Returns whether [package] itself has transformers that run on any of its
+  /// public assets.
+  bool _isIndividualPackageTransformed(Package package) {
+    // If the caller passed in an unknown package name to isPackageTransformed,
+    // the package will be null.
+    if (package == null) return true;
+
+    if (package.name == entrypoint.root.name) {
+      return package.pubspec.transformers.isNotEmpty;
+    }
+
+    return package.pubspec.transformers.any((phase) {
+      return phase.any((config) => config.canTransformPublicFiles);
+    });
+  }
+
   /// Returns whether [package] is mutable.
   ///
   /// A package is considered to be mutable if it or any of its dependencies
   /// don't come from a cached source, since the user can change its contents
   /// without modifying the pub cache. Information generated from mutable
   /// packages is generally not safe to cache, since it may change frequently.
   bool isPackageMutable(String package) {
     var id = lockFile.packages[package];
     if (id == null) return true;
 
@@ skipping 22 matching lines @@
   bool isPackageStatic(String package) {
     var id = lockFile.packages[package];
     if (id == null) return false;
 
     var source = entrypoint.cache.sources[id.source];
     if (source is! CachedSource) return false;
 
     return packages[package].pubspec.transformers.isEmpty;
   }
 }