Move pubspec caching into each source.

lib/src/solver/backtracking_solver.dart

 // Copyright (c) 2012, 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.
 
 /// A back-tracking depth-first solver.
 ///
 /// Attempts to find the best solution for a root package's transitive
 /// dependency graph, where a "solution" is a set of concrete package versions.
 /// A valid solution will select concrete versions for every package reached
 /// from the root package's dependency graph, and each of those packages will
@@ skipping 48 matching lines @@
 /// versions for speculative package selections. Backtracks and advances to the
 /// next potential solution in the case of a failure.
 class BacktrackingSolver {
   final SolveType type;
   final SourceRegistry sources;
   final Package root;
 
   /// The lockfile that was present before solving.
   final LockFile lockFile;
 
-  final PubspecCache cache;
+  /// A cache of data requested during solving.
+  final SolverCache cache;
 
   /// The set of packages that are being explicitly upgraded.
   ///
   /// The solver will only allow the very latest version for each of these
   /// packages.
   final _forceLatest = new Set<String>();
 
   /// The set of packages whose dependecy is being overridden by the root
   /// package, keyed by the name of the package.
   ///
@@ skipping 30 matching lines @@
   /// two differences. First, [_versions] doesn't have an entry for the root
   /// package, since it has only one valid version, but [_selection] does, since
   /// its dependencies are relevant. Second, when backtracking, [_versions]
   /// contains the version that's being backtracked, while [_selection] does
   /// not.
   VersionSelection _selection;
 
   /// The number of solutions the solver has tried so far.
   var _attemptedSolutions = 1;
 
+  /// A pubspec for pub's implicit dependencies on barback and related packages.
+  final Pubspec _implicitPubspec = (() {

[Bob Nystrom, 2015/11/19 23:43:55]

Nit, I don't think the parens around the entire fn are needed.

[nweiz, 2015/11/24 01:32:53]

Done.

+    var dependencies = [];
+    barback.pubConstraints.forEach((name, constraint) {
+      dependencies.add(new PackageDep(name, "hosted", constraint, name));
+    });
+
+    return new Pubspec("pub itself", dependencies: dependencies);
+  })();
+
   BacktrackingSolver(SolveType type, SourceRegistry sources, this.root,
           this.lockFile, List<String> useLatest)
       : type = type,
         sources = sources,
-        cache = new PubspecCache(type, sources) {
+        cache = new SolverCache(type, sources) {
     _selection = new VersionSelection(this);
 
     for (var package in useLatest) {
       _forceLatest.add(package);
     }
 
     for (var override in root.dependencyOverrides) {
       _overrides[override.name] = override;
     }
   }
 
   /// Run the solver.
   ///
   /// Completes with a list of specific package versions if successful or an
   /// error if it failed to find a solution.
   Future<SolveResult> solve() async {
     var stopwatch = new Stopwatch();
 
     _logParameters();
 
     // Sort the overrides by package name to make sure they're deterministic.
     var overrides = _overrides.values.toList();
     overrides.sort((a, b) => a.name.compareTo(b.name));
 
     try {
       stopwatch.start();
 
       // Pre-cache the root package's known pubspec.
       var rootID = new PackageId.root(root);
-      cache.cache(rootID, root.pubspec);
-      cache.cache(new PackageId.magic('pub itself'), _implicitPubspec());
       await _selection.select(rootID);
 
       _validateSdkConstraint(root.pubspec);
 
       logSolve();
       var packages = await _solve();
 
-      var pubspecs = new Map.fromIterable(packages,
-          key: (id) => id.name,
-          value: (id) => cache.getCachedPubspec(id));
+      var pubspecs = {};
+      for (var id in packages) {
+        pubspecs[id.name] = await _getPubspec(id);
+      }
 
       var resolved = await Future.wait(
           packages.map((id) => sources[id.source].resolveId(id)));
 
       return new SolveResult.success(sources, root, lockFile, resolved,
           overrides, pubspecs, _getAvailableVersions(resolved),
           _attemptedSolutions);
     } on SolveFailure catch (error) {
       // Wrap a failure in a result so we can attach some other data.
       return new SolveResult.failure(sources, root, lockFile, overrides,
           error, _attemptedSolutions);
     } finally {
       // Gather some solving metrics.
       var buffer = new StringBuffer();
       buffer.writeln('${runtimeType} took ${stopwatch.elapsed} seconds.');
       buffer.writeln(cache.describeResults());
       log.solver(buffer);
     }
   }
 
-  /// Creates a pubspec for pub's implicit dependencies on barback and related
-  /// packages.
-  Pubspec _implicitPubspec() {
-    var dependencies = [];
-    barback.pubConstraints.forEach((name, constraint) {
-      dependencies.add(new PackageDep(name, "hosted", constraint, name));
-    });
-
-    return new Pubspec("pub itself", dependencies: dependencies);
-  }
-
   /// Generates a map containing all of the known available versions for each
   /// package in [packages].
   ///
   /// The version list may not always be complete. If the package is the root
   /// root package, or if it's a package that we didn't unlock while solving
   /// because we weren't trying to upgrade it, we will just know the current
   /// version.
   Map<String, List<Version>> _getAvailableVersions(List<PackageId> packages) {
     var availableVersions = new Map<String, List<Version>>();
     for (var package in packages) {
@@ skipping 262 matching lines @@
 
       logSolve(
           "version ${id.version} of ${id.name} doesn't match $constraint:\n" +
               _selection.describeDependencies(id.name));
       throw new NoVersionException(
           id.name, id.version, constraint, deps.toList());
     }
 
     var pubspec;
     try {
-      pubspec = await cache.getPubspec(id);
+      pubspec = await _getPubspec(id);
     } on PackageNotFoundException {
       // We can only get here if the lockfile refers to a specific package
       // version that doesn't exist (probably because it was yanked).
       throw new NoVersionException(id.name, null, id.version, []);
     }
 
     _validateSdkConstraint(pubspec);
 
     for (var dep in await depsFor(id)) {
       if (dep.isMagic) continue;
@@ skipping 72 matching lines @@
     // Don't mark the root package as failing because it's not in [_versions]
     // and there's only one version of it anyway.
     if (name == root.name) return;
     _versions.firstWhere((queue) => queue.current.name == name).fail();
   }
 
   /// Returns the dependencies of the package identified by [id].
   ///
   /// This takes overrides and dev dependencies into account when neccessary.
   Future<Set<PackageDep>> depsFor(PackageId id) async {
-    var pubspec = await cache.getPubspec(id);
+    var pubspec = await _getPubspec(id);
     var deps = pubspec.dependencies.toSet();
     if (id.isRoot) {
       // Include dev dependencies of the root package.
       deps.addAll(pubspec.devDependencies);
 
       // Add all overrides. This ensures a dependency only present as an
       // override is still included.
       deps.addAll(_overrides.values);
 
       // Replace any overridden dependencies.
@@ skipping 16 matching lines @@
       }
 
       if (dep.name == 'barback') {
         deps.add(new PackageDep.magic('pub itself'));
       }
     }
 
     return deps;
   }
 
+  /// Loads and returns the pubspec for [id].
+  Future<Pubspec> _getPubspec(PackageId id) async {
+    if (id.isRoot) return root.pubspec;
+    if (id.isMagic && id.name == 'pub itself') return _implicitPubspec;
+
+    var source = sources[id.source];
+    return await source.describe(id);
+  }
+
   /// Logs the initial parameters to the solver.
   void _logParameters() {
     var buffer = new StringBuffer();
     buffer.writeln("Solving dependencies:");
     for (var package in root.dependencies) {
       buffer.write("- $package");
       var locked = getLocked(package.name);
       if (_forceLatest.contains(package.name)) {
         buffer.write(" (use latest)");
       } else if (locked != null) {
@@ skipping 31 matching lines @@
   void _validateSdkConstraint(Pubspec pubspec) {
     if (_overrides.containsKey(pubspec.name)) return;
     if (pubspec.environment.sdkVersion.allows(sdk.version)) return;
 
     throw new BadSdkVersionException(pubspec.name,
         'Package ${pubspec.name} requires SDK version '
         '${pubspec.environment.sdkVersion} but the current SDK is '
         '${sdk.version}.');
   }
 }