Don't implicitly run "pub get".

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';
+import 'solver/version_solver.dart';
 import 'source/cached.dart';
 import 'utils.dart';
 
 /// A holistic view of the entire transitive dependency graph for an entrypoint.
-///
-/// A package graph can be loaded using [Entrypoint.loadPackageGraph].
 class PackageGraph {
   /// The entrypoint.
   final Entrypoint entrypoint;
 
   /// The entrypoint's lockfile.
   ///
   /// This describes the sources and resolved descriptions of everything in
   /// [packages].
   final LockFile lockFile;
 
   /// The transitive dependencies of the entrypoint (including itself).
   ///
   /// This may not include all transitive dependencies of the entrypoint if the
   /// creator of the package graph knows only a subset of the packages are
   /// relevant in the current context.
   final Map<String, Package> packages;
 
   /// A map of transitive dependencies for each package.
   Map<String, Set<Package>> _transitiveDependencies;
 
   /// The transformer cache, if it's been loaded.
   TransformerCache _transformerCache;
 
   PackageGraph(this.entrypoint, this.lockFile, this.packages);
 
+  /// Creates a package graph using the data from [result].
+  ///
+  /// This is generally faster than loading a package graph from scratch, since
+  /// the packages' pubspecs are already fully-parsed.
+  factory PackageGraph.fromSolveResult(Entrypoint entrypoint,
+      SolveResult result) {
+    var packages = new Map.fromIterable(result.packages,
+        key: (id) => id.name,
+        value: (id) {
+      if (id.name == entrypoint.root.name) return entrypoint.root;
+
+      return new Package(result.pubspecs[id.name],
+          entrypoint.cache.sources[id.source].getDirectory(id));
+    });
+
+    return new PackageGraph(
+        entrypoint,
+        new LockFile(result.packages, entrypoint.cache.sources),
+        packages);
+  }
+
   /// Loads the transformer cache for this graph.
   ///
   /// This may only be called if [entrypoint] represents a physical package.
   /// This may modify the cache.
   TransformerCache loadTransformerCache() {
     if (_transformerCache == null) {
       if (entrypoint.root.dir == null) {
         throw new StateError("Can't load the transformer cache for virtual "
             "entrypoint ${entrypoint.root.name}.");
       }
@@ skipping 83 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;
   }
 }